first commit

1 files changed, 1100 insertions, 0 deletions

diff --git a/public/admin/view/javascript/jquery/jqvmap/jquery.vmap.js b/public/admin/view/javascript/jquery/jqvmap/jquery.vmap.js
new file mode 100644
index 0000000..db70d85
--- /dev/null
+++ b/public/admin/view/javascript/jquery/jqvmap/jquery.vmap.js
@@ -0,0 +1,1100 @@
+/*!
+ * jQVMap Version 1.0
+ *
+ * http://jqvmap.com
+ *
+ * Copyright 2012, Peter Schmalfeldt <manifestinteractive@gmail.com>
+ * Copyright 2011-2012, Kirill Lebedev
+ * Licensed under the MIT license.
+ *
+ * Fork Me @ https://github.com/manifestinteractive/jqvmap
+ */
+(function ($) {
+
+  var apiParams = {
+    colors: 1,
+    values: 1,
+    backgroundColor: 1,
+    scaleColors: 1,
+    normalizeFunction: 1,
+    enableZoom: 1,
+    showTooltip: 1,
+    borderColor: 1,
+    borderWidth: 1,
+    borderOpacity: 1,
+    selectedRegions: 1,
+    multiSelectRegion: 1
+  };
+
+  var apiEvents = {
+    onLabelShow: 'labelShow',
+    onRegionOver: 'regionMouseOver',
+    onRegionOut: 'regionMouseOut',
+    onRegionClick: 'regionClick',
+    onRegionSelect: 'regionSelect',
+    onRegionDeselect: 'regionDeselect'
+  };
+
+  $.fn.vectorMap = function (options) {
+
+    var defaultParams = {
+      map: 'world_en',
+      backgroundColor: '#a5bfdd',
+      color: '#f4f3f0',
+      hoverColor: '#c9dfaf',
+      selectedColor: '#c9dfaf',
+      scaleColors: ['#b6d6ff', '#005ace'],
+      normalizeFunction: 'linear',
+      enableZoom: true,
+      showTooltip: true,
+      borderColor: '#818181',
+      borderWidth: 1,
+      borderOpacity: 0.25,
+      selectedRegions: null,
+      multiSelectRegion: false
+    }, map = this.data('mapObject');
+
+    if (options === 'addMap') {
+      WorldMap.maps[arguments[1]] = arguments[2];
+    } else if (options === 'set' && apiParams[arguments[1]]) {
+      map['set' + arguments[1].charAt(0).toUpperCase() + arguments[1].substr(1)].apply(map, Array.prototype.slice.call(arguments, 2));
+    } else if (typeof options === 'string' &&
+               typeof map[options] === 'function') {
+      return map[options].apply(map, Array.prototype.slice.call(arguments, 1));
+    } else {
+      $.extend(defaultParams, options);
+      defaultParams.container = this;
+      this.css({ position: 'relative', overflow: 'hidden' });
+
+      map = new WorldMap(defaultParams);
+
+      this.data('mapObject', map);
+
+      for (var e in apiEvents) {
+        if (defaultParams[e]) {
+          this.bind(apiEvents[e] + '.jqvmap', defaultParams[e]);
+        }
+      }
+    }
+  };
+
+  var VectorCanvas = function (width, height, params) {
+    this.mode = window.SVGAngle ? 'svg' : 'vml';
+    this.params = params;
+
+    if (this.mode == 'svg') {
+      this.createSvgNode = function (nodeName) {
+        return document.createElementNS(this.svgns, nodeName);
+      };
+    } else {
+      try {
+        if (!document.namespaces.rvml) {
+          document.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
+        }
+        this.createVmlNode = function (tagName) {
+          return document.createElement('<rvml:' + tagName + ' class="rvml">');
+        };
+      } catch (e) {
+        this.createVmlNode = function (tagName) {
+          return document.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
+        };
+      }
+
+      document.createStyleSheet().addRule(".rvml", "behavior:url(#default#VML)");
+    }
+
+    if (this.mode == 'svg') {
+      this.canvas = this.createSvgNode('svg');
+    } else {
+      this.canvas = this.createVmlNode('group');
+      this.canvas.style.position = 'absolute';
+    }
+
+    this.setSize(width, height);
+  };
+
+  VectorCanvas.prototype = {
+    svgns: "http://www.w3.org/2000/svg",
+    mode: 'svg',
+    width: 0,
+    height: 0,
+    canvas: null,
+
+    setSize: function (width, height) {
+      if (this.mode == 'svg') {
+        this.canvas.setAttribute('width', width);
+        this.canvas.setAttribute('height', height);
+      } else {
+        this.canvas.style.width = width + "px";
+        this.canvas.style.height = height + "px";
+        this.canvas.coordsize = width + ' ' + height;
+        this.canvas.coordorigin = "0 0";
+        if (this.rootGroup) {
+          var pathes = this.rootGroup.getElementsByTagName('shape');
+          for (var i = 0, l = pathes.length; i < l; i++) {
+            pathes[i].coordsize = width + ' ' + height;
+            pathes[i].style.width = width + 'px';
+            pathes[i].style.height = height + 'px';
+          }
+          this.rootGroup.coordsize = width + ' ' + height;
+          this.rootGroup.style.width = width + 'px';
+          this.rootGroup.style.height = height + 'px';
+        }
+      }
+      this.width = width;
+      this.height = height;
+    },
+
+    createPath: function (config) {
+      var node;
+      if (this.mode == 'svg') {
+        node = this.createSvgNode('path');
+        node.setAttribute('d', config.path);
+
+        if (this.params.borderColor !== null) {
+          node.setAttribute('stroke', this.params.borderColor);
+        }
+        if (this.params.borderWidth > 0) {
+          node.setAttribute('stroke-width', this.params.borderWidth);
+          node.setAttribute('stroke-linecap', 'round');
+          node.setAttribute('stroke-linejoin', 'round');
+        }
+        if (this.params.borderOpacity > 0) {
+          node.setAttribute('stroke-opacity', this.params.borderOpacity);
+        }
+
+        node.setFill = function (color) {
+          this.setAttribute("fill", color);
+          if (this.getAttribute("original") === null) {
+            this.setAttribute("original", color);
+          }
+        };
+
+        node.getFill = function (color) {
+          return this.getAttribute("fill");
+        };
+
+        node.getOriginalFill = function () {
+          return this.getAttribute("original");
+        };
+
+        node.setOpacity = function (opacity) {
+          this.setAttribute('fill-opacity', opacity);
+        };
+      } else {
+        node = this.createVmlNode('shape');
+        node.coordorigin = "0 0";
+        node.coordsize = this.width + ' ' + this.height;
+        node.style.width = this.width + 'px';
+        node.style.height = this.height + 'px';
+        node.fillcolor = WorldMap.defaultFillColor;
+        node.stroked = false;
+        node.path = VectorCanvas.pathSvgToVml(config.path);
+
+        var scale = this.createVmlNode('skew');
+        scale.on = true;
+        scale.matrix = '0.01,0,0,0.01,0,0';
+        scale.offset = '0,0';
+
+        node.appendChild(scale);
+
+        var fill = this.createVmlNode('fill');
+        node.appendChild(fill);
+
+        node.setFill = function (color) {
+          this.getElementsByTagName('fill')[0].color = color;
+          if (this.getAttribute("original") === null) {
+            this.setAttribute("original", color);
+          }
+        };
+
+        node.getFill = function (color) {
+          return this.getElementsByTagName('fill')[0].color;
+        };
+        node.getOriginalFill = function () {
+          return this.getAttribute("original");
+        };
+        node.setOpacity = function (opacity) {
+          this.getElementsByTagName('fill')[0].opacity = parseInt(opacity * 100, 10) + '%';
+        };
+      }
+      return node;
+    },
+
+    createGroup: function (isRoot) {
+      var node;
+      if (this.mode == 'svg') {
+        node = this.createSvgNode('g');
+      } else {
+        node = this.createVmlNode('group');
+        node.style.width = this.width + 'px';
+        node.style.height = this.height + 'px';
+        node.style.left = '0px';
+        node.style.top = '0px';
+        node.coordorigin = "0 0";
+        node.coordsize = this.width + ' ' + this.height;
+      }
+
+      if (isRoot) {
+        this.rootGroup = node;
+      }
+      return node;
+    },
+
+    applyTransformParams: function (scale, transX, transY) {
+      if (this.mode == 'svg') {
+        this.rootGroup.setAttribute('transform', 'scale(' + scale + ') translate(' + transX + ', ' + transY + ')');
+      } else {
+        this.rootGroup.coordorigin = (this.width - transX) + ',' + (this.height - transY);
+        this.rootGroup.coordsize = this.width / scale + ',' + this.height / scale;
+      }
+    }
+  };
+
+  VectorCanvas.pathSvgToVml = function (path) {
+    var result = '';
+    var cx = 0, cy = 0, ctrlx, ctrly;
+
+    return path.replace(/([MmLlHhVvCcSs])((?:-?(?:\d+)?(?:\.\d+)?,?\s?)+)/g, function (segment, letter, coords, index) {
+      coords = coords.replace(/(\d)-/g, '$1,-').replace(/\s+/g, ',').split(',');
+      if (!coords[0]) {
+        coords.shift();
+      }
+
+      for (var i = 0, l = coords.length; i < l; i++) {
+        coords[i] = Math.round(100 * coords[i]);
+      }
+
+      switch (letter) {
+      case 'm':
+        cx += coords[0];
+        cy += coords[1];
+        return 't' + coords.join(',');
+        break;
+
+      case 'M':
+        cx = coords[0];
+        cy = coords[1];
+        return 'm' + coords.join(',');
+        break;
+
+      case 'l':
+        cx += coords[0];
+        cy += coords[1];
+        return 'r' + coords.join(',');
+        break;
+
+      case 'L':
+        cx = coords[0];
+        cy = coords[1];
+        return 'l' + coords.join(',');
+        break;
+
+      case 'h':
+        cx += coords[0];
+        return 'r' + coords[0] + ',0';
+        break;
+
+      case 'H':
+        cx = coords[0];
+        return 'l' + cx + ',' + cy;
+        break;
+
+      case 'v':
+        cy += coords[0];
+        return 'r0,' + coords[0];
+        break;
+
+      case 'V':
+        cy = coords[0];
+        return 'l' + cx + ',' + cy;
+        break;
+
+      case 'c':
+        ctrlx = cx + coords[coords.length - 4];
+        ctrly = cy + coords[coords.length - 3];
+        cx += coords[coords.length - 2];
+        cy += coords[coords.length - 1];
+        return 'v' + coords.join(',');
+        break;
+
+      case 'C':
+        ctrlx = coords[coords.length - 4];
+        ctrly = coords[coords.length - 3];
+        cx = coords[coords.length - 2];
+        cy = coords[coords.length - 1];
+        return 'c' + coords.join(',');
+        break;
+
+      case 's':
+        coords.unshift(cy - ctrly);
+        coords.unshift(cx - ctrlx);
+        ctrlx = cx + coords[coords.length - 4];
+        ctrly = cy + coords[coords.length - 3];
+        cx += coords[coords.length - 2];
+        cy += coords[coords.length - 1];
+        return 'v' + coords.join(',');
+        break;
+
+      case 'S':
+        coords.unshift(cy + cy - ctrly);
+        coords.unshift(cx + cx - ctrlx);
+        ctrlx = coords[coords.length - 4];
+        ctrly = coords[coords.length - 3];
+        cx = coords[coords.length - 2];
+        cy = coords[coords.length - 1];
+        return 'c' + coords.join(',');
+        break;
+
+      default:
+        return false;
+        break;
+      }
+
+      return '';
+
+    }).replace(/z/g, '');
+  };
+
+  var WorldMap = function (params) {
+    params = params || {};
+    var map = this;
+    var mapData = WorldMap.maps[params.map];
+
+    this.selectedRegions = [];
+    this.multiSelectRegion = params.multiSelectRegion;
+
+    this.container = params.container;
+
+    this.defaultWidth = mapData.width;
+    this.defaultHeight = mapData.height;
+
+    this.color = params.color;
+    this.selectedColor = params.selectedColor;
+    this.hoverColor = params.hoverColor;
+    this.hoverOpacity = params.hoverOpacity;
+    this.setBackgroundColor(params.backgroundColor);
+
+    this.width = params.container.width();
+    this.height = params.container.height();
+
+    this.resize();
+
+    jQuery(window).resize(function () {
+      map.width = params.container.width();
+      map.height = params.container.height();
+      map.resize();
+      map.canvas.setSize(map.width, map.height);
+      map.applyTransform();
+    });
+
+    this.canvas = new VectorCanvas(this.width, this.height, params);
+    params.container.append(this.canvas.canvas);
+
+    this.makeDraggable();
+
+    this.rootGroup = this.canvas.createGroup(true);
+
+    this.index = WorldMap.mapIndex;
+    this.label = jQuery('<div/>').addClass('jqvmap-label').appendTo(jQuery('body')).hide();
+
+    if (params.enableZoom) {
+      jQuery('<div/>').addClass('jqvmap-zoomin').text('+').appendTo(params.container);
+      jQuery('<div/>').addClass('jqvmap-zoomout').html('&#x2212;').appendTo(params.container);
+    }
+
+    map.countries = [];
+
+    for (var key in mapData.pathes) {
+      var path = this.canvas.createPath({
+        path: mapData.pathes[key].path
+      });
+
+      path.setFill(this.color);
+      path.id = map.getCountryId(key);
+      map.countries[key] = path;
+
+      if (this.canvas.mode == 'svg') {
+        path.setAttribute('class', 'jvectormap-region');
+      } else {
+        jQuery(path).addClass('jvectormap-region');
+      }
+
+      jQuery(this.rootGroup).append(path);
+    }
+
+    jQuery(params.container).delegate(this.canvas.mode == 'svg' ? 'path' : 'shape', 'mouseover mouseout', function (e) {
+      var path = e.target,
+      code = e.target.id.split('_').pop(),
+      labelShowEvent = $.Event('labelShow.jqvmap'),
+      regionMouseOverEvent = $.Event('regionMouseOver.jqvmap');
+
+      if (e.type == 'mouseover') {
+        jQuery(params.container).trigger(regionMouseOverEvent, [code, mapData.pathes[code].name]);
+        if (!regionMouseOverEvent.isDefaultPrevented()) {
+          map.highlight(code, path);
+        }
+        if (params.showTooltip) {
+          map.label.text(mapData.pathes[code].name);
+          jQuery(params.container).trigger(labelShowEvent, [map.label, code]);
+
+          if (!labelShowEvent.isDefaultPrevented()) {
+            map.label.show();
+            map.labelWidth = map.label.width();
+            map.labelHeight = map.label.height();
+          }
+        }
+      } else {
+        map.unhighlight(code, path);
+
+        map.label.hide();
+        jQuery(params.container).trigger('regionMouseOut.jqvmap', [code, mapData.pathes[code].name]);
+      }
+    });
+
+    jQuery(params.container).delegate(this.canvas.mode == 'svg' ? 'path' : 'shape', 'click', function (e) {
+      if (!params.multiSelectRegion) {
+        for (var key in mapData.pathes) {
+          map.countries[key].currentFillColor = map.countries[key].getOriginalFill();
+          map.countries[key].setFill(map.countries[key].getOriginalFill());
+        }
+      }
+
+      var path = e.target;
+      var code = e.target.id.split('_').pop();
+
+      jQuery(params.container).trigger('regionClick.jqvmap', [code, mapData.pathes[code].name]);
+      if (!regionClickEvent.isDefaultPrevented()) {
+        if (map.selectedRegions.indexOf(code) !== -1) {
+          map.deselect(code, path);
+        } else {
+          map.select(code, path);
+        }
+      }
+
+      //console.log(selectedRegions);
+
+    });
+
+    if (params.showTooltip) {
+      params.container.mousemove(function (e) {
+        if (map.label.is(':visible')) {
+            var left = e.pageX - 15 - map.labelWidth;
+            var top = e.pageY - 15 - map.labelHeight;
+            
+            if(left < 0)
+               left = e.pageX + 15;
+            if(top < 0)
+                top = e.pageY + 15;
+            
+            map.label.css({
+                left: left,
+                top: top
+          });
+        }
+      });
+    }
+
+    this.setColors(params.colors);
+
+    this.canvas.canvas.appendChild(this.rootGroup);
+
+    this.applyTransform();
+
+    this.colorScale = new ColorScale(params.scaleColors, params.normalizeFunction, params.valueMin, params.valueMax);
+
+    if (params.values) {
+      this.values = params.values;
+      this.setValues(params.values);
+    }
+
+    if (params.selectedRegions) {
+      if (params.selectedRegions instanceof Array) {
+        for(var k in params.selectedRegions) {
+          this.select(params.selectedRegions[k].toLowerCase());
+        }
+      } else {
+        this.select(params.selectedRegions.toLowerCase());
+      }
+    }
+
+    this.bindZoomButtons();
+    
+    if(params.pins) {
+      /*if(params.pinMode) {
+          if(params.pinMode != "id" && params.pinMode != "content") {
+              params.pinMode = "content";
+          }
+      } else {
+          params.pinMode = "content";
+      }*/
+      this.pinHandlers = false;
+      this.placePins(params.pins, params.pinMode);
+    }
+
+    WorldMap.mapIndex++;
+  };
+
+  WorldMap.prototype = {
+    transX: 0,
+    transY: 0,
+    scale: 1,
+    baseTransX: 0,
+    baseTransY: 0,
+    baseScale: 1,
+    width: 0,
+    height: 0,
+    countries: {},
+    countriesColors: {},
+    countriesData: {},
+    zoomStep: 1.4,
+    zoomMaxStep: 4,
+    zoomCurStep: 1,
+
+    setColors: function (key, color) {
+      if (typeof key == 'string') {
+        this.countries[key].setFill(color);
+        this.countries[key].setAttribute("original", color);
+      } else {
+        var colors = key;
+
+        for (var code in colors) {
+          if (this.countries[code]) {
+            this.countries[code].setFill(colors[code]);
+            this.countries[code].setAttribute("original", colors[code]);
+          }
+        }
+      }
+    },
+
+    setValues: function (values) {
+      var max = 0,
+      min = Number.MAX_VALUE,
+      val;
+
+      for (var cc in values) {
+        val = parseFloat(values[cc]);
+        if (val > max) {
+          max = values[cc];
+        }
+        if (val && val < min) {
+          min = val;
+        }
+      }
+
+      this.colorScale.setMin(min);
+      this.colorScale.setMax(max);
+
+      var colors = {};
+      for (cc in values) {
+        val = parseFloat(values[cc]);
+        if (val) {
+          colors[cc] = this.colorScale.getColor(val);
+        } else {
+          colors[cc] = this.color;
+        }
+      }
+      this.setColors(colors);
+      this.values = values;
+    },
+
+    setBackgroundColor: function (backgroundColor) {
+      this.container.css('background-color', backgroundColor);
+    },
+
+    setScaleColors: function (colors) {
+      this.colorScale.setColors(colors);
+
+      if (this.values) {
+        this.setValues(this.values);
+      }
+    },
+
+    setNormalizeFunction: function (f) {
+      this.colorScale.setNormalizeFunction(f);
+
+      if (this.values) {
+        this.setValues(this.values);
+      }
+    },
+
+    highlight: function (cc, path) {
+      path = path || $('#' + this.getCountryId(cc))[0];
+      if (this.hoverOpacity) {
+        path.setOpacity(this.hoverOpacity);
+      } else if (this.hoverColor) {
+        path.currentFillColor = path.getFill() + '';
+        path.setFill(this.hoverColor);
+      }
+    },
+
+    unhighlight: function (cc, path) {
+      path = path || $('#' + this.getCountryId(cc))[0];
+      path.setOpacity(1);
+      if (path.currentFillColor) {
+        path.setFill(path.currentFillColor);
+      }
+    },
+
+    select: function (cc, path) {
+      path = path || $('#' + this.getCountryId(cc))[0];
+      if(this.selectedRegions.indexOf(cc) < 0) {
+        if (this.multiSelectRegion) {
+          this.selectedRegions.push(cc);
+        } else {
+          this.selectedRegions = [cc];
+        }
+        // MUST BE after the change of selectedRegions
+        // Otherwise, we might loop
+        $(this.container).trigger('regionSelect.jqvmap', [cc]);
+        if (this.selectedColor) {
+          path.currentFillColor = this.selectedColor;
+          path.setFill(this.selectedColor);
+        }
+      }
+    },
+
+    deselect: function (cc, path) {
+      path = path || $('#' + this.getCountryId(cc))[0];
+      if(this.selectedRegions.indexOf(cc) >= 0) {
+        this.selectedRegions.splice(this.selectedRegions.indexOf(cc), 1);
+        // MUST BE after the change of selectedRegions
+        // Otherwise, we might loop
+        $(this.container).trigger('regionDeselect.jqvmap', [cc]);
+        path.currentFillColor = path.getOriginalFill();
+        path.setFill(path.getOriginalFill());
+      }
+    },
+
+    isSelected: function(cc) {
+      return this.selectedRegions.indexOf(cc) >= 0;
+    },
+
+    resize: function () {
+      var curBaseScale = this.baseScale;
+      if (this.width / this.height > this.defaultWidth / this.defaultHeight) {
+        this.baseScale = this.height / this.defaultHeight;
+        this.baseTransX = Math.abs(this.width - this.defaultWidth * this.baseScale) / (2 * this.baseScale);
+      } else {
+        this.baseScale = this.width / this.defaultWidth;
+        this.baseTransY = Math.abs(this.height - this.defaultHeight * this.baseScale) / (2 * this.baseScale);
+      }
+      this.scale *= this.baseScale / curBaseScale;
+      this.transX *= this.baseScale / curBaseScale;
+      this.transY *= this.baseScale / curBaseScale;
+    },
+
+    reset: function () {
+      this.countryTitle.reset();
+      for (var key in this.countries) {
+        this.countries[key].setFill(WorldMap.defaultColor);
+      }
+      this.scale = this.baseScale;
+      this.transX = this.baseTransX;
+      this.transY = this.baseTransY;
+      this.applyTransform();
+    },
+
+    applyTransform: function () {
+      var maxTransX, maxTransY, minTransX, minTransY;
+      if (this.defaultWidth * this.scale <= this.width) {
+        maxTransX = (this.width - this.defaultWidth * this.scale) / (2 * this.scale);
+        minTransX = (this.width - this.defaultWidth * this.scale) / (2 * this.scale);
+      } else {
+        maxTransX = 0;
+        minTransX = (this.width - this.defaultWidth * this.scale) / this.scale;
+      }
+
+      if (this.defaultHeight * this.scale <= this.height) {
+        maxTransY = (this.height - this.defaultHeight * this.scale) / (2 * this.scale);
+        minTransY = (this.height - this.defaultHeight * this.scale) / (2 * this.scale);
+      } else {
+        maxTransY = 0;
+        minTransY = (this.height - this.defaultHeight * this.scale) / this.scale;
+      }
+
+      if (this.transY > maxTransY) {
+        this.transY = maxTransY;
+      }
+      else if (this.transY < minTransY) {
+        this.transY = minTransY;
+      }
+      if (this.transX > maxTransX) {
+        this.transX = maxTransX;
+      }
+      else if (this.transX < minTransX) {
+        this.transX = minTransX;
+      }
+
+      this.canvas.applyTransformParams(this.scale, this.transX, this.transY);
+    },
+
+    makeDraggable: function () {
+      var mouseDown = false;
+      var oldPageX, oldPageY;
+      var self = this;
+
+      self.isMoving = false;
+      self.isMovingTimeout = false;
+
+      this.container.mousemove(function (e) {
+
+        if (mouseDown) {
+          var curTransX = self.transX;
+          var curTransY = self.transY;
+
+          self.transX -= (oldPageX - e.pageX) / self.scale;
+          self.transY -= (oldPageY - e.pageY) / self.scale;
+
+          self.applyTransform();
+
+          oldPageX = e.pageX;
+          oldPageY = e.pageY;
+
+          self.isMoving = true;
+          if (self.isMovingTimeout) {
+            clearTimeout(self.isMovingTimeout);
+          }
+
+          self.container.trigger('drag');
+        }
+
+        return false;
+
+      }).mousedown(function (e) {
+
+        mouseDown = true;
+        oldPageX = e.pageX;
+        oldPageY = e.pageY;
+
+        return false;
+
+      }).mouseup(function () {
+
+        mouseDown = false;
+
+        self.isMovingTimeout = setTimeout(function () {
+          self.isMoving = false;
+        }, 100);
+
+        return false;
+
+      });
+    },
+
+    bindZoomButtons: function () {
+      var map = this;
+      this.container.find('.jqvmap-zoomin').click(function(){
+        map.zoomIn();
+      });
+      this.container.find('.jqvmap-zoomout').click(function(){
+        map.zoomOut();
+      });
+    },
+    
+    zoomIn: function () {
+      var map = this;
+      var sliderDelta = (jQuery('#zoom').innerHeight() - 6 * 2 - 15 * 2 - 3 * 2 - 7 - 6) / (this.zoomMaxStep - this.zoomCurStep);
+
+      if (map.zoomCurStep < map.zoomMaxStep) {
+        var curTransX = map.transX;
+        var curTransY = map.transY;
+        var curScale = map.scale;
+
+        map.transX -= (map.width / map.scale - map.width / (map.scale * map.zoomStep)) / 2;
+        map.transY -= (map.height / map.scale - map.height / (map.scale * map.zoomStep)) / 2;
+        map.setScale(map.scale * map.zoomStep);
+        map.zoomCurStep++;
+
+        jQuery('#zoomSlider').css('top', parseInt(jQuery('#zoomSlider').css('top'), 10) - sliderDelta);
+        
+        map.container.trigger("zoomIn");
+      }
+    },
+    
+    zoomOut: function () {
+      var map = this;
+      var sliderDelta = (jQuery('#zoom').innerHeight() - 6 * 2 - 15 * 2 - 3 * 2 - 7 - 6) / (this.zoomMaxStep - this.zoomCurStep);
+
+      if (map.zoomCurStep > 1) {
+        var curTransX = map.transX;
+        var curTransY = map.transY;
+        var curScale = map.scale;
+
+        map.transX += (map.width / (map.scale / map.zoomStep) - map.width / map.scale) / 2;
+        map.transY += (map.height / (map.scale / map.zoomStep) - map.height / map.scale) / 2;
+        map.setScale(map.scale / map.zoomStep);
+        map.zoomCurStep--;
+
+        jQuery('#zoomSlider').css('top', parseInt(jQuery('#zoomSlider').css('top'), 10) + sliderDelta);
+        
+        map.container.trigger("zoomOut");
+      }
+    },
+
+    setScale: function (scale) {
+      this.scale = scale;
+      this.applyTransform();
+    },
+
+    getCountryId: function (cc) {
+      return 'jqvmap' + this.index + '_' + cc;
+    },
+
+    getPinId: function (cc) {
+      return this.getCountryId(cc)+'_pin';
+    },
+    
+    placePins: function(pins, pinMode){
+      var map = this;
+
+      if(!pinMode || (pinMode != "content" && pinMode != "id")) {
+        pinMode = "content";
+      }
+
+      if(pinMode == "content") {//treat pin as content
+        jQuery.each(pins, function(index, pin){
+          if(jQuery('#'+map.getCountryId(index)).length == 0){
+              return;
+          }
+          //mapData.pathes[code].name
+          var pinIndex = map.getPinId(index);
+          if(jQuery('#'+pinIndex).length > 0){
+            jQuery('#'+pinIndex).remove();
+          }
+          map.container.append('<div id="' + pinIndex + '" for="'+index+'" class="jqvmap_pin" style="position:absolute">' + pin + '</div>');
+        });
+      } else { //treat pin as id of an html content
+        jQuery.each(pins, function(index, pin){
+          if(jQuery('#'+map.getCountryId(index)).length == 0){
+              return;
+          }
+          var pinIndex = map.getPinId(index);
+          if(jQuery('#'+pinIndex).length > 0){
+            jQuery('#'+pinIndex).remove();
+          }
+          map.container.append('<div id="' + pinIndex + '" for="'+index+'" class="jqvmap_pin" style="position:absolute"></div>');
+          jQuery('#'+pinIndex).append(jQuery('#'+pin));
+        });
+      }
+
+      this.positionPins();
+      if(!this.pinHandlers){
+        this.pinHandlers = true;//do only once
+        var positionFix = function(){
+          map.positionPins();
+        };
+        this.container.bind('zoomIn', positionFix)
+        .bind('zoomOut', positionFix)
+        .bind('drag', positionFix);
+      }
+    },
+
+    positionPins: function(){
+      var map = this;
+      var pins = this.container.find('.jqvmap_pin');
+      jQuery.each(pins, function(index, pinObj){
+        pinObj = jQuery(pinObj);
+        var countryId = map.getCountryId(pinObj.attr('for'));
+        var countryObj = jQuery('#' + countryId);
+
+        var bbox = document.getElementById(countryId).getBBox();
+        var position = countryObj.position();
+
+        var scale = map.scale;
+
+        var left = position.left + (bbox.width / 2) * scale - pinObj.width() / 2,
+        top = position.top + (bbox.height / 2) * scale - pinObj.height() / 2;
+
+        pinObj.css('left',left).css('top',top);
+      });
+     },
+
+     getPin: function(cc){
+       var pinObj = jQuery('#'+this.getPinId(cc));
+       return pinObj.html();
+     },
+
+     getPins: function(){
+       var pins = this.container.find('.jqvmap_pin');
+       var ret = new Object();
+       jQuery.each(pins, function(index, pinObj){
+         pinObj = jQuery(pinObj);
+         var cc = pinObj.attr('for');
+         var pinContent = pinObj.html();
+         eval("ret." + cc + "=pinContent");
+       });
+       return JSON.stringify(ret);
+     },
+
+     removePin: function(cc) {
+       jQuery('#'+this.getPinId(cc)).remove();
+     },
+
+     removePins: function(){
+       this.container.find('.jqvmap_pin').remove();
+     }
+  };
+
+  WorldMap.xlink = "http://www.w3.org/1999/xlink";
+  WorldMap.mapIndex = 1;
+  WorldMap.maps = {};
+
+  var ColorScale = function (colors, normalizeFunction, minValue, maxValue) {
+    if (colors) {
+      this.setColors(colors);
+    }
+    if (normalizeFunction) {
+      this.setNormalizeFunction(normalizeFunction);
+    }
+    if (minValue) {
+      this.setMin(minValue);
+    }
+    if (minValue) {
+      this.setMax(maxValue);
+    }
+  };
+
+  ColorScale.prototype = {
+    colors: [],
+
+    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;
+      }
+    },
+
+    setColors: function (colors) {
+      for (var i = 0; i < colors.length; i++) {
+        colors[i] = ColorScale.rgbToArray(colors[i]);
+      }
+      this.colors = colors;
+    },
+
+    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);
+    },
+
+    getColor: function (value) {
+      if (typeof this.normalize === 'function') {
+        value = this.normalize(value);
+      }
+
+      var lengthes = [];
+      var fullLength = 0;
+      var l;
+
+      for (var i = 0; i < this.colors.length - 1; i++) {
+        l = this.vectorLength(this.vectorSubtract(this.colors[i + 1], this.colors[i]));
+        lengthes.push(l);
+        fullLength += l;
+      }
+
+      var 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++;
+      }
+
+      var color;
+      if (i == this.colors.length - 1) {
+        color = this.vectorToNum(this.colors[i]).toString(16);
+      } else {
+        color = (this.vectorToNum(this.vectorAdd(this.colors[i], this.vectorMult(this.vectorSubtract(this.colors[i + 1], this.colors[i]), (value) / (lengthes[i]))))).toString(16);
+      }
+
+      while (color.length < 6) {
+        color = '0' + color;
+      }
+      return '#' + color;
+    },
+
+    vectorToNum: function (vector) {
+      var num = 0;
+      for (var 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 = [];
+      for (var i = 0; i < vector1.length; i++) {
+        vector[i] = vector1[i] - vector2[i];
+      }
+      return vector;
+    },
+
+    vectorAdd: function (vector1, vector2) {
+      var vector = [];
+      for (var i = 0; i < vector1.length; i++) {
+        vector[i] = vector1[i] + vector2[i];
+      }
+      return vector;
+    },
+
+    vectorMult: function (vector, num) {
+      var result = [];
+      for (var i = 0; i < vector.length; i++) {
+        result[i] = vector[i] * num;
+      }
+      return result;
+    },
+
+    vectorLength: function (vector) {
+      var result = 0;
+      for (var i = 0; i < vector.length; i++) {
+        result += vector[i] * vector[i];
+      }
+      return Math.sqrt(result);
+    }
+  };
+
+  ColorScale.arrayToRgb = function (ar) {
+    var rgb = '#';
+    var d;
+    for (var i = 0; i < ar.length; i++) {
+      d = ar[i].toString(16);
+      rgb += d.length == 1 ? '0' + d : d;
+    }
+    return rgb;
+  };
+
+  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)];
+  };
+
+})(jQuery);