jvectormap-rails 1.0.1 → 2.0.0

data/vendor/assets/javascripts/jvectormap/src/marker.js

@@ -0,0 +1,76 @@
+jvm.Marker = function(config){
+  var text,
+      offsets;
+
+  this.config = config;
+  this.map = this.config.map;
+
+  this.isImage = !!this.config.style.initial.image;
+  this.createShape();
+
+  text = this.getLabelText(config.index);
+  if (this.config.label && text) {
+    this.offsets = this.getLabelOffsets(config.index);
+    this.labelX = config.cx / this.map.scale - this.map.transX;
+    this.labelY = config.cy / this.map.scale - this.map.transY;
+    this.label = config.canvas.addText({
+      text: text,
+      'data-index': config.index,
+      dy: "0.6ex",
+      x: this.labelX,
+      y: this.labelY
+    }, config.labelStyle, config.labelsGroup);
+
+    this.label.addClass('jvectormap-marker jvectormap-element');
+  }
+};
+
+jvm.inherits(jvm.Marker, jvm.MapObject);
+
+jvm.Marker.prototype.createShape = function(){
+  var that = this;
+
+  if (this.shape) {
+    this.shape.remove();
+  }
+  this.shape = this.config.canvas[this.isImage ? 'addImage' : 'addCircle']({
+    "data-index": this.config.index,
+    cx: this.config.cx,
+    cy: this.config.cy
+  }, this.config.style, this.config.group);
+
+  this.shape.addClass('jvectormap-marker jvectormap-element');
+
+  if (this.isImage) {
+    jvm.$(this.shape.node).on('imageloaded', function(){
+      that.updateLabelPosition();
+    });
+  }
+};
+
+jvm.Marker.prototype.updateLabelPosition = function(){
+  if (this.label) {
+    this.label.set({
+      x: this.labelX * this.map.scale + this.offsets[0] +
+         this.map.transX * this.map.scale + 5 + (this.isImage ? (this.shape.width || 0) / 2 : this.shape.properties.r),
+      y: this.labelY * this.map.scale + this.map.transY * this.map.scale + this.offsets[1]
+    });
+  }
+};
+
+jvm.Marker.prototype.setStyle = function(property, value){
+  var isImage;
+
+  jvm.Marker.parentClass.prototype.setStyle.apply(this, arguments);
+
+  if (property === 'r') {
+    this.updateLabelPosition();
+  }
+
+  isImage = !!this.shape.get('image');
+  if (isImage != this.isImage) {
+    this.isImage = isImage;
+    this.config.style = jvm.$.extend(true, {}, this.shape.style);
+    this.createShape();
+  }
+};

data/vendor/assets/javascripts/jvectormap/src/multimap.js

@@ -0,0 +1,139 @@
+/**
+ * Creates map with drill-down functionality.
+ * @constructor
+ * @param {Object} params Parameters to initialize map with.
+ * @param {Number} params.maxLevel Maximum number of levels user can go through
+ * @param {Object} params.main Config of the main map. See <a href="./jvm-map/">jvm.Map</a> for more information.
+ * @param {Function} params.mapNameByCode Function go generate map name by region code. Default value is:
+<pre>
+function(code, multiMap) {
+  return code.toLowerCase()+'_'+
+         multiMap.defaultProjection+'_en';
+}
+</pre>
+ * @param {Function} params.mapUrlByCode Function to generate map url by region code. Default value is:
+<pre>
+function(code, multiMap){
+  return 'jquery-jvectormap-data-'+
+         code.toLowerCase()+'-'+
+         multiMap.defaultProjection+'-en.js';
+}
+</pre>
+ */
+jvm.MultiMap = function(params) {
+  var that = this;
+
+  this.maps = {};
+  this.params = jvm.$.extend(true, {}, jvm.MultiMap.defaultParams, params);
+  this.params.maxLevel = this.params.maxLevel || Number.MAX_VALUE;
+  this.params.main = this.params.main || {};
+  this.params.main.multiMapLevel = 0;
+  this.history = [ this.addMap(this.params.main.map, this.params.main) ];
+  this.defaultProjection = this.history[0].mapData.projection.type;
+  this.mapsLoaded = {};
+
+  this.params.container.css({position: 'relative'});
+  this.backButton = jvm.$('<div/>').addClass('jvectormap-goback').text('Back').appendTo(this.params.container);
+  this.backButton.hide();
+  this.backButton.click(function(){
+    that.goBack();
+  });
+
+  this.spinner = jvm.$('<div/>').addClass('jvectormap-spinner').appendTo(this.params.container);
+  this.spinner.hide();
+};
+
+jvm.MultiMap.prototype = {
+  addMap: function(name, config){
+    var cnt = jvm.$('<div/>').css({
+      width: '100%',
+      height: '100%'
+    });
+
+    this.params.container.append(cnt);
+
+    this.maps[name] = new jvm.Map(jvm.$.extend(config, {container: cnt}));
+    if (this.params.maxLevel > config.multiMapLevel) {
+      this.maps[name].container.on('regionClick.jvectormap', {scope: this}, function(e, code){
+        var multimap = e.data.scope,
+            mapName = multimap.params.mapNameByCode(code, multimap);
+
+        if (!multimap.drillDownPromise || multimap.drillDownPromise.state() !== 'pending') {
+          multimap.drillDown(mapName, code);
+        }
+      });
+    }
+
+
+    return this.maps[name];
+  },
+
+  downloadMap: function(code){
+    var that = this,
+        deferred = jvm.$.Deferred();
+
+    if (!this.mapsLoaded[code]) {
+      jvm.$.get(this.params.mapUrlByCode(code, this)).then(function(){
+        that.mapsLoaded[code] = true;
+        deferred.resolve();
+      }, function(){
+        deferred.reject();
+      });
+    } else {
+      deferred.resolve();
+    }
+    return deferred;
+  },
+
+  drillDown: function(name, code){
+    var currentMap = this.history[this.history.length - 1],
+        that = this,
+        focusPromise = currentMap.setFocus({region: code, animate: true}),
+        downloadPromise = this.downloadMap(code);
+
+    focusPromise.then(function(){
+      if (downloadPromise.state() === 'pending') {
+        that.spinner.show();
+      }
+    });
+    downloadPromise.always(function(){
+      that.spinner.hide();
+    });
+    this.drillDownPromise = jvm.$.when(downloadPromise, focusPromise);
+    this.drillDownPromise.then(function(){
+      currentMap.params.container.hide();
+      if (!that.maps[name]) {
+        that.addMap(name, {map: name, multiMapLevel: currentMap.params.multiMapLevel + 1});
+      } else {
+        that.maps[name].params.container.show();
+      }
+      that.history.push( that.maps[name] );
+      that.backButton.show();
+    });
+  },
+
+  goBack: function(){
+    var currentMap = this.history.pop(),
+        prevMap = this.history[this.history.length - 1],
+        that = this;
+
+    currentMap.setFocus({scale: 1, x: 0.5, y: 0.5, animate: true}).then(function(){
+      currentMap.params.container.hide();
+      prevMap.params.container.show();
+      prevMap.updateSize();
+      if (that.history.length === 1) {
+        that.backButton.hide();
+      }
+      prevMap.setFocus({scale: 1, x: 0.5, y: 0.5, animate: true});
+    });
+  }
+};
+
+jvm.MultiMap.defaultParams = {
+  mapNameByCode: function(code, multiMap){
+    return code.toLowerCase()+'_'+multiMap.defaultProjection+'_en';
+  },
+  mapUrlByCode: function(code, multiMap){
+    return 'jquery-jvectormap-data-'+code.toLowerCase()+'-'+multiMap.defaultProjection+'-en.js';
+  }
+}

data/vendor/assets/javascripts/jvectormap/{lib → src}/numeric-scale.js

@@ -5,8 +5,8 @@ jvm.NumericScale = function(scale, normalizeFunction, minValue, maxValue) {
 
   if (scale) this.setScale(scale);
   if (normalizeFunction) this.setNormalizeFunction(normalizeFunction);
-  if (minValue) this.setMin(minValue);
-  if (maxValue) this.setMax(maxValue);
+  if (typeof minValue !== 'undefined' ) this.setMin(minValue);
+  if (typeof maxValue !== 'undefined' ) this.setMax(maxValue);
 };
 
 jvm.NumericScale.prototype = {
@@ -31,6 +31,7 @@ jvm.NumericScale.prototype = {
   setScale: function(scale) {
     var i;
 
+    this.scale = [];
     for (i = 0; i < scale.length; i++) {
       this.scale[i] = [scale[i]];
     }
@@ -143,5 +144,42 @@ jvm.NumericScale.prototype = {
       result += vector[i] * vector[i];
     }
     return Math.sqrt(result);
+  },
+
+  /* Derived from d3 implementation https://github.com/mbostock/d3/blob/master/src/scale/linear.js#L94 */
+  getTicks: function(){
+    var m = 5,
+        extent = [this.clearMinValue, this.clearMaxValue],
+        span = extent[1] - extent[0],
+        step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)),
+        err = m / span * step,
+        ticks = [],
+        tick,
+        v;
+
+    if (err <= .15) step *= 10;
+    else if (err <= .35) step *= 5;
+    else if (err <= .75) step *= 2;
+
+    extent[0] = Math.floor(extent[0] / step) * step;
+    extent[1] = Math.ceil(extent[1] / step) * step;
+
+    tick = extent[0];
+    while (tick <= extent[1]) {
+      if (tick == extent[0]) {
+        v = this.clearMinValue;
+      } else if (tick == extent[1]) {
+        v = this.clearMaxValue;
+      } else {
+        v = tick;
+      }
+      ticks.push({
+        label: tick,
+        value: this.getValue(v)
+      });
+      tick += step;
+    }
+
+    return ticks;
   }
-};
+};

data/vendor/assets/javascripts/jvectormap/src/ordinal-scale.js

@@ -0,0 +1,21 @@
+jvm.OrdinalScale = function(scale){
+  this.scale = scale;
+};
+
+jvm.OrdinalScale.prototype.getValue = function(value){
+  return this.scale[value];
+};
+
+jvm.OrdinalScale.prototype.getTicks = function(){
+  var ticks = [],
+      key;
+
+  for (key in this.scale) {
+    ticks.push({
+      label: key,
+      value: this.scale[key]
+    });
+  }
+
+  return ticks;
+};

data/vendor/assets/javascripts/jvectormap/src/region.js

@@ -0,0 +1,45 @@
+jvm.Region = function(config){
+  var bbox,
+      text,
+      offsets,
+      labelDx,
+      labelDy;
+
+  this.config = config;
+  this.map = this.config.map;
+
+  this.shape = config.canvas.addPath({
+    d: config.path,
+    'data-code': config.code
+  }, config.style, config.canvas.rootElement);
+  this.shape.addClass('jvectormap-region jvectormap-element');
+
+  bbox = this.shape.getBBox();
+
+  text = this.getLabelText(config.code);
+  if (this.config.label && text) {
+    offsets = this.getLabelOffsets(config.code);
+    this.labelX = bbox.x + bbox.width / 2 + offsets[0];
+    this.labelY = bbox.y + bbox.height / 2 + offsets[1];
+    this.label = config.canvas.addText({
+      text: text,
+      'text-anchor': 'middle',
+      'alignment-baseline': 'central',
+      x: this.labelX,
+      y: this.labelY,
+      'data-code': config.code
+    }, config.labelStyle, config.labelsGroup);
+    this.label.addClass('jvectormap-region jvectormap-element');
+  }
+};
+
+jvm.inherits(jvm.Region, jvm.MapObject);
+
+jvm.Region.prototype.updateLabelPosition = function(){
+  if (this.label) {
+    this.label.set({
+      x: this.labelX * this.map.scale + this.map.transX * this.map.scale,
+      y: this.labelY * this.map.scale + this.map.transY * this.map.scale
+    });
+  }
+};

data/vendor/assets/javascripts/jvectormap/{lib → src}/svg-canvas-element.js

@@ -1,6 +1,10 @@
 jvm.SVGCanvasElement = function(container, width, height){
   this.classPrefix = 'SVG';
   jvm.SVGCanvasElement.parentClass.call(this, 'svg');
+
+  this.defsElement = new jvm.SVGElement('defs');
+  this.node.appendChild( this.defsElement.node );
+
   jvm.AbstractCanvasElement.apply(this, arguments);
 }
 

data/vendor/assets/javascripts/jvectormap/src/svg-image-element.js

@@ -0,0 +1,36 @@
+jvm.SVGImageElement = function(config, style){
+  jvm.SVGImageElement.parentClass.call(this, 'image', config, style);
+};
+
+jvm.inherits(jvm.SVGImageElement, jvm.SVGShapeElement);
+
+jvm.SVGImageElement.prototype.applyAttr = function(attr, value){
+  var that = this;
+
+  if (attr == 'image') {
+    jvm.whenImageLoaded(value).then(function(img){
+      that.node.setAttributeNS('http://www.w3.org/1999/xlink', 'href', value);
+      that.width = img[0].width;
+      that.height = img[0].height;
+      that.applyAttr('width', that.width);
+      that.applyAttr('height', that.height);
+
+      that.applyAttr('x', that.cx - that.width / 2);
+      that.applyAttr('y', that.cy - that.height / 2);
+
+      jvm.$(that.node).trigger('imageloaded', [img]);
+    });
+  } else if(attr == 'cx') {
+    this.cx = value;
+    if (this.width) {
+      this.applyAttr('x', value - this.width / 2);
+    }
+  } else if(attr == 'cy') {
+    this.cy = value;
+    if (this.height) {
+      this.applyAttr('y', value - this.height / 2);
+    }
+  } else {
+    jvm.SVGImageElement.parentClass.prototype.applyAttr.apply(this, arguments);
+  }
+};

data/vendor/assets/javascripts/jvectormap/src/svg-shape-element.js

@@ -0,0 +1,49 @@
+jvm.SVGShapeElement = function(name, config, style){
+  jvm.SVGShapeElement.parentClass.call(this, name, config);
+  jvm.AbstractShapeElement.apply(this, arguments);
+};
+
+jvm.inherits(jvm.SVGShapeElement, jvm.SVGElement);
+jvm.mixin(jvm.SVGShapeElement, jvm.AbstractShapeElement);
+
+jvm.SVGShapeElement.prototype.applyAttr = function(attr, value){
+  var patternEl,
+      imageEl,
+      that = this;
+
+  if (attr === 'fill' && jvm.isImageUrl(value)) {
+    if (!jvm.SVGShapeElement.images[value]) {
+      jvm.whenImageLoaded(value).then(function(img){
+        imageEl = new jvm.SVGElement('image');
+        imageEl.node.setAttributeNS('http://www.w3.org/1999/xlink', 'href', value);
+        imageEl.applyAttr('x', '0');
+        imageEl.applyAttr('y', '0');
+        imageEl.applyAttr('width', img[0].width);
+        imageEl.applyAttr('height', img[0].height);
+
+        patternEl = new jvm.SVGElement('pattern');
+        patternEl.applyAttr('id', 'image'+jvm.SVGShapeElement.imageCounter);
+        patternEl.applyAttr('x', 0);
+        patternEl.applyAttr('y', 0);
+        patternEl.applyAttr('width', img[0].width / 2);
+        patternEl.applyAttr('height', img[0].height / 2);
+        patternEl.applyAttr('viewBox', '0 0 '+img[0].width+' '+img[0].height);
+        patternEl.applyAttr('patternUnits', 'userSpaceOnUse');
+        patternEl.node.appendChild( imageEl.node );
+
+        that.canvas.defsElement.node.appendChild( patternEl.node );
+
+        jvm.SVGShapeElement.images[value] = jvm.SVGShapeElement.imageCounter++;
+
+        that.applyAttr('fill', 'url(#image'+jvm.SVGShapeElement.images[value]+')');
+      });
+    } else {
+      this.applyAttr('fill', 'url(#image'+jvm.SVGShapeElement.images[value]+')');
+    }
+  } else {
+    jvm.SVGShapeElement.parentClass.prototype.applyAttr.apply(this, arguments);
+  }
+};
+
+jvm.SVGShapeElement.imageCounter = 1;
+jvm.SVGShapeElement.images = {};