jvectormap-rails 1.0.0

data/vendor/assets/javascripts/jvectormap/lib/abstract-shape-element.js

@@ -0,0 +1,85 @@
+/**
+ * Abstract shape element. Shape element represents some visual vector or raster object.
+ * @constructor
+ * @param {String} name Tag name of the element.
+ * @param {Object} config Set of parameters to initialize element with.
+ * @param {Object} style Object with styles to set on element initialization.
+ */
+jvm.AbstractShapeElement = function(name, config, style){
+  this.style = style || {};
+  this.style.current = {};
+  this.isHovered = false;
+  this.isSelected = false;
+  this.updateStyle();
+};
+
+/**
+ * Set hovered state to the element. Hovered state means mouse cursor is over element. Styles will be updates respectively.
+ * @param {Boolean} isHovered <code>true</code> to make element hovered, <code>false</code> otherwise.
+ */
+jvm.AbstractShapeElement.prototype.setHovered = function(isHovered){
+  if (this.isHovered !== isHovered) {
+    this.isHovered = isHovered;
+    this.updateStyle();
+  }
+};
+
+/**
+ * Set selected state to the element. Styles will be updates respectively.
+ * @param {Boolean} isSelected <code>true</code> to make element selected, <code>false</code> otherwise.
+ */
+jvm.AbstractShapeElement.prototype.setSelected = function(isSelected){
+  if (this.isSelected !== isSelected) {
+    this.isSelected = isSelected;
+    this.updateStyle();
+    jvm.$(this.node).trigger('selected', [isSelected]);
+  }
+};
+
+/**
+ * Set element's style.
+ * @param {Object|String} property Could be string to set only one property or object to set several style properties at once.
+ * @param {String} value Value to set in case only one property should be set.
+ */
+jvm.AbstractShapeElement.prototype.setStyle = function(property, value){
+  var styles = {};
+
+  if (typeof property === 'object') {
+    styles = property;
+  } else {
+    styles[property] = value;
+  }
+  jvm.$.extend(this.style.current, styles);
+  this.updateStyle();
+};
+
+
+jvm.AbstractShapeElement.prototype.updateStyle = function(){
+  var attrs = {};
+
+  jvm.AbstractShapeElement.mergeStyles(attrs, this.style.initial);
+  jvm.AbstractShapeElement.mergeStyles(attrs, this.style.current);
+  if (this.isHovered) {
+    jvm.AbstractShapeElement.mergeStyles(attrs, this.style.hover);
+  }
+  if (this.isSelected) {
+    jvm.AbstractShapeElement.mergeStyles(attrs, this.style.selected);
+    if (this.isHovered) {
+      jvm.AbstractShapeElement.mergeStyles(attrs, this.style.selectedHover);
+    }
+  }
+  this.set(attrs);
+};
+
+jvm.AbstractShapeElement.mergeStyles = function(styles, newStyles){
+  var key;
+
+  newStyles = newStyles || {};
+  for (key in newStyles) {
+    if (newStyles[key] === null) {
+      delete styles[key];
+    } else {
+      styles[key] = newStyles[key];
+    }
+  }
+}

data/vendor/assets/javascripts/jvectormap/lib/color-scale.js

@@ -0,0 +1,44 @@
+jvm.ColorScale = function(colors, normalizeFunction, minValue, maxValue) {
+  jvm.ColorScale.parentClass.apply(this, arguments);
+}
+
+jvm.inherits(jvm.ColorScale, jvm.NumericScale);
+
+jvm.ColorScale.prototype.setScale = function(scale) {
+  var i;
+
+  for (i = 0; i < scale.length; i++) {
+    this.scale[i] = jvm.ColorScale.rgbToArray(scale[i]);
+  }
+};
+
+jvm.ColorScale.prototype.getValue = function(value) {
+  return jvm.ColorScale.numToRgb(jvm.ColorScale.parentClass.prototype.getValue.call(this, value));
+};
+
+jvm.ColorScale.arrayToRgb = function(ar) {
+  var rgb = '#',
+      d,
+      i;
+
+  for (i = 0; i < ar.length; i++) {
+    d = ar[i].toString(16);
+    rgb += d.length == 1 ? '0'+d : d;
+  }
+  return rgb;
+};
+
+jvm.ColorScale.numToRgb = function(num) {
+  num = num.toString(16);
+
+  while (num.length < 6) {
+    num = '0' + num;
+  }
+
+  return '#'+num;
+};
+
+jvm.ColorScale.rgbToArray = function(rgb) {
+  rgb = rgb.substr(1);
+  return [parseInt(rgb.substr(0, 2), 16), parseInt(rgb.substr(2, 2), 16), parseInt(rgb.substr(4, 2), 16)];
+};

data/vendor/assets/javascripts/jvectormap/lib/data-series.js

@@ -0,0 +1,139 @@
+/**
+ * Creates data series.
+ * @constructor
+ * @param {Object} params Parameters to initialize series with.
+ * @param {Array} params.values The data set to visualize.
+ * @param {String} params.attribute Numberic or color attribute to use for data visualization. This could be: <code>fill</code>, <code>stroke</code>, <code>fill-opacity</code>, <code>stroke-opacity</code> for markers and regions and <code>r</code> (radius) for markers only.
+ * @param {Array} params.scale Values used to map a dimension of data to a visual representation. The first value sets visualization for minimum value from the data set and the last value sets visualization for the maximum value. There also could be intermidiate values. Default value is <code>['#C8EEFF', '#0071A4']</code>
+ * @param {Function|String} params.normalizeFunction The function used to map input values to the provided scale. This parameter could be provided as function or one of the strings: <code>'linear'</code> or <code>'polynomial'</code>, while <code>'linear'</code> is used by default. The function provided takes value from the data set as an input and returns corresponding value from the scale.
+ * @param {Number} params.min Minimum value of the data set. Could be calculated automatically if not provided.
+ * @param {Number} params.min Maximum value of the data set. Could be calculated automatically if not provided.
+ */
+jvm.DataSeries = function(params, elements) {
+  var scaleConstructor;
+
+  params = params || {};
+  params.attribute = params.attribute || 'fill';
+
+  this.elements = elements;
+  this.params = params;
+
+  if (params.attributes) {
+    this.setAttributes(params.attributes);
+  }
+
+  if (jvm.$.isArray(params.scale)) {
+    scaleConstructor = (params.attribute === 'fill' || params.attribute === 'stroke') ? jvm.ColorScale : jvm.NumericScale;
+    this.scale = new scaleConstructor(params.scale, params.normalizeFunction, params.min, params.max);
+  } else if (params.scale) {
+    this.scale = new jvm.OrdinalScale(params.scale);
+  } else {
+    this.scale = new jvm.SimpleScale(params.scale);
+  }
+
+  this.values = params.values || {};
+  this.setValues(this.values);
+};
+
+jvm.DataSeries.prototype = {
+  setAttributes: function(key, attr){
+    var attrs = key,
+        code;
+
+    if (typeof key == 'string') {
+      if (this.elements[key]) {
+        this.elements[key].setStyle(this.params.attribute, attr);
+      }
+    } else {
+      for (code in attrs) {
+        if (this.elements[code]) {
+          this.elements[code].element.setStyle(this.params.attribute, attrs[code]);
+        }
+      }
+    }
+  },
+
+  /**
+   * Set values for the data set.
+   * @param {Object} values Object which maps codes of regions or markers to values.
+   */
+  setValues: function(values) {
+    var max = Number.MIN_VALUE,
+        min = Number.MAX_VALUE,
+        val,
+        cc,
+        attrs = {};
+
+    if (!(this.scale instanceof jvm.OrdinalScale) && !(this.scale instanceof jvm.SimpleScale)) {
+      if (!this.params.min || !this.params.max) {
+        for (cc in values) {
+          val = parseFloat(values[cc]);
+          if (val > max) max = values[cc];
+          if (val < min) min = val;
+        }
+        if (!this.params.min) {
+          this.scale.setMin(min);
+        }
+        if (!this.params.max) {
+          this.scale.setMax(max);
+        }
+        this.params.min = min;
+        this.params.max = max;
+      }
+      for (cc in values) {
+        val = parseFloat(values[cc]);
+        if (!isNaN(val)) {
+          attrs[cc] = this.scale.getValue(val);
+        } else {
+          attrs[cc] = this.elements[cc].element.style.initial[this.params.attribute];
+        }
+      }
+    } else {
+      for (cc in values) {
+        if (values[cc]) {
+          attrs[cc] = this.scale.getValue(values[cc]);
+        } else {
+          attrs[cc] = this.elements[cc].element.style.initial[this.params.attribute];
+        }
+      }
+    }
+
+    this.setAttributes(attrs);
+    jvm.$.extend(this.values, values);
+  },
+
+  clear: function(){
+    var key,
+        attrs = {};
+
+    for (key in this.values) {
+      if (this.elements[key]) {
+        attrs[key] = this.elements[key].element.style.initial[this.params.attribute];
+      }
+    }
+    this.setAttributes(attrs);
+    this.values = {};
+  },
+
+  /**
+   * Set scale of the data series.
+   * @param {Array} scale Values representing scale.
+   */
+  setScale: function(scale) {
+    this.scale.setScale(scale);
+    if (this.values) {
+      this.setValues(this.values);
+    }
+  },
+
+  /**
+   * Set normalize function of the data series.
+   * @param {Function|String} normilizeFunction.
+   */
+  setNormalizeFunction: function(f) {
+    this.scale.setNormalizeFunction(f);
+    if (this.values) {
+      this.setValues(this.values);
+    }
+  }
+};

data/vendor/assets/javascripts/jvectormap/lib/jvectormap.js

@@ -0,0 +1,99 @@
+/**
+ * @namespace jvm Holds core methods and classes used by jVectorMap.
+ */
+var jvm = {
+
+  /**
+   * Inherits child's prototype from the parent's one.
+   * @param {Function} child
+   * @param {Function} parent
+   */
+  inherits: function(child, parent) {
+    function temp() {}
+    temp.prototype = parent.prototype;
+    child.prototype = new temp();
+    child.prototype.constructor = child;
+    child.parentClass = parent;
+  },
+
+  /**
+   * Mixes in methods from the source constructor to the target one.
+   * @param {Function} target
+   * @param {Function} source
+   */
+  mixin: function(target, source){
+    var prop;
+
+    for (prop in source.prototype) {
+      if (source.prototype.hasOwnProperty(prop)) {
+        target.prototype[prop] = source.prototype[prop];
+      }
+    }
+  },
+
+  min: function(values){
+    var min = Number.MAX_VALUE,
+        i;
+
+    if (values instanceof Array) {
+      for (i = 0; i < values.length; i++) {
+        if (values[i] < min) {
+          min = values[i];
+        }
+      }
+    } else {
+      for (i in values) {
+        if (values[i] < min) {
+          min = values[i];
+        }
+      }
+    }
+    return min;
+  },
+
+  max: function(values){
+    var max = Number.MIN_VALUE,
+        i;
+
+    if (values instanceof Array) {
+      for (i = 0; i < values.length; i++) {
+        if (values[i] > max) {
+          max = values[i];
+        }
+      }
+    } else {
+      for (i in values) {
+        if (values[i] > max) {
+          max = values[i];
+        }
+      }
+    }
+    return max;
+  },
+
+  keys: function(object){
+    var keys = [],
+        key;
+
+    for (key in object) {
+      keys.push(key);
+    }
+    return keys;
+  },
+
+  values: function(object){
+    var values = [],
+        key,
+        i;
+
+    for (i = 0; i < arguments.length; i++) {
+      object = arguments[i];
+      for (key in object) {
+        values.push(object[key]);
+      }
+    }
+    return values;
+  }
+};
+
+jvm.$ = jQuery;

data/vendor/assets/javascripts/jvectormap/lib/numeric-scale.js

@@ -0,0 +1,147 @@
+jvm.NumericScale = function(scale, normalizeFunction, minValue, maxValue) {
+  this.scale = [];
+
+  normalizeFunction = normalizeFunction || 'linear';
+
+  if (scale) this.setScale(scale);
+  if (normalizeFunction) this.setNormalizeFunction(normalizeFunction);
+  if (minValue) this.setMin(minValue);
+  if (maxValue) this.setMax(maxValue);
+};
+
+jvm.NumericScale.prototype = {
+  setMin: function(min) {
+    this.clearMinValue = min;
+    if (typeof this.normalize === 'function') {
+      this.minValue = this.normalize(min);
+    } else {
+      this.minValue = min;
+    }
+  },
+
+  setMax: function(max) {
+    this.clearMaxValue = max;
+    if (typeof this.normalize === 'function') {
+      this.maxValue = this.normalize(max);
+    } else {
+      this.maxValue = max;
+    }
+  },
+
+  setScale: function(scale) {
+    var i;
+
+    for (i = 0; i < scale.length; i++) {
+      this.scale[i] = [scale[i]];
+    }
+  },
+
+  setNormalizeFunction: function(f) {
+    if (f === 'polynomial') {
+      this.normalize = function(value) {
+        return Math.pow(value, 0.2);
+      }
+    } else if (f === 'linear') {
+      delete this.normalize;
+    } else {
+      this.normalize = f;
+    }
+    this.setMin(this.clearMinValue);
+    this.setMax(this.clearMaxValue);
+  },
+
+  getValue: function(value) {
+    var lengthes = [],
+        fullLength = 0,
+        l,
+        i = 0,
+        c;
+
+    if (typeof this.normalize === 'function') {
+      value = this.normalize(value);
+    }
+    for (i = 0; i < this.scale.length-1; i++) {
+      l = this.vectorLength(this.vectorSubtract(this.scale[i+1], this.scale[i]));
+      lengthes.push(l);
+      fullLength += l;
+    }
+
+    c = (this.maxValue - this.minValue) / fullLength;
+    for (i=0; i<lengthes.length; i++) {
+      lengthes[i] *= c;
+    }
+
+    i = 0;
+    value -= this.minValue;
+    while (value - lengthes[i] >= 0) {
+      value -= lengthes[i];
+      i++;
+    }
+
+    if (i == this.scale.length - 1) {
+      value = this.vectorToNum(this.scale[i])
+    } else {
+      value = (
+        this.vectorToNum(
+          this.vectorAdd(this.scale[i],
+            this.vectorMult(
+              this.vectorSubtract(this.scale[i+1], this.scale[i]),
+              (value) / (lengthes[i])
+            )
+          )
+        )
+      );
+    }
+
+    return value;
+  },
+
+  vectorToNum: function(vector) {
+    var num = 0,
+        i;
+
+    for (i = 0; i < vector.length; i++) {
+      num += Math.round(vector[i])*Math.pow(256, vector.length-i-1);
+    }
+    return num;
+  },
+
+  vectorSubtract: function(vector1, vector2) {
+    var vector = [],
+        i;
+
+    for (i = 0; i < vector1.length; i++) {
+      vector[i] = vector1[i] - vector2[i];
+    }
+    return vector;
+  },
+
+  vectorAdd: function(vector1, vector2) {
+    var vector = [],
+        i;
+
+    for (i = 0; i < vector1.length; i++) {
+      vector[i] = vector1[i] + vector2[i];
+    }
+    return vector;
+  },
+
+  vectorMult: function(vector, num) {
+    var result = [],
+        i;
+
+    for (i = 0; i < vector.length; i++) {
+      result[i] = vector[i] * num;
+    }
+    return result;
+  },
+
+  vectorLength: function(vector) {
+    var result = 0,
+        i;
+    for (i = 0; i < vector.length; i++) {
+      result += vector[i] * vector[i];
+    }
+    return Math.sqrt(result);
+  }
+};