text: /*!
   * 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);
  