Subversion-Projekte lars-tiefland.webanos.zeldi.de

/*!

 * JQVMap: jQuery Vector Map Library

 * @author JQVMap <me@peterschmalfeldt.com>

 * @version 1.5.1

 * @link http://jqvmap.com

 * @license https://github.com/manifestinteractive/jqvmap/blob/master/LICENSE

 * @builddate 2016/06/02

 */

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

};

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: []

};

var JQVMap = function (params) {

  params = params || {};

  var map = this;

  var mapData = JQVMap.maps[params.map];

  var mapPins;

  if( !mapData){

    throw new Error('Invalid "' + params.map + '" map parameter. Please make sure you have loaded this map file in your HTML.');

  }

  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.hoverColors = params.hoverColors;

  this.hoverOpacity = params.hoverOpacity;

  this.setBackgroundColor(params.backgroundColor);

  this.width = params.container.width();

  this.height = params.container.height();

  this.resize();

  jQuery(window).resize(function () {

    var newWidth = params.container.width();

    var newHeight = params.container.height();

    if(newWidth && newHeight){

      map.width = newWidth;

      map.height = newHeight;

      map.resize();

      map.canvas.setSize(map.width, map.height);

      map.applyTransform();

      var resizeEvent = jQuery.Event('resize.jqvmap');

      jQuery(params.container).trigger(resizeEvent, [newWidth, newHeight]);

      if(mapPins){

        jQuery('.jqvmap-pin').remove();

        map.pinHandlers = false;

        map.placePins(mapPins.pins, mapPins.mode);

      }

    }

  });

  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 = JQVMap.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.paths) {

    var path = this.canvas.createPath({

      path: mapData.paths[key].path

    });

    path.setFill(this.color);

    path.id = map.getCountryId(key);

    map.countries[key] = path;

    if (this.canvas.mode === 'svg') {

      path.setAttribute('class', 'jqvmap-region');

    } else {

      jQuery(path).addClass('jqvmap-region');

    }

    jQuery(this.rootGroup).append(path);

  }

  jQuery(params.container).delegate(this.canvas.mode === 'svg' ? 'path' : 'shape', 'mouseover mouseout', function (e) {

    var containerPath = e.target,

      code = e.target.id.split('_').pop(),

      labelShowEvent = jQuery.Event('labelShow.jqvmap'),

      regionMouseOverEvent = jQuery.Event('regionMouseOver.jqvmap');

    code = code.toLowerCase();

    if (e.type === 'mouseover') {

      jQuery(params.container).trigger(regionMouseOverEvent, [code, mapData.paths[code].name]);

      if (!regionMouseOverEvent.isDefaultPrevented()) {

        map.highlight(code, containerPath);

      }

      if (params.showTooltip) {

        map.label.text(mapData.paths[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, containerPath);

      map.label.hide();

      jQuery(params.container).trigger('regionMouseOut.jqvmap', [code, mapData.paths[code].name]);

    }

  });

  jQuery(params.container).delegate(this.canvas.mode === 'svg' ? 'path' : 'shape', 'click', function (regionClickEvent) {

    var targetPath = regionClickEvent.target;

    var code = regionClickEvent.target.id.split('_').pop();

    var mapClickEvent = jQuery.Event('regionClick.jqvmap');

    code = code.toLowerCase();

    jQuery(params.container).trigger(mapClickEvent, [code, mapData.paths[code].name]);

    if ( !params.multiSelectRegion && !mapClickEvent.isDefaultPrevented()) {

      for (var keyPath in mapData.paths) {

        map.countries[keyPath].currentFillColor = map.countries[keyPath].getOriginalFill();

        map.countries[keyPath].setFill(map.countries[keyPath].getOriginalFill());

      }

    }

    if ( !mapClickEvent.isDefaultPrevented()) {

      if (map.isSelected(code)) {

        map.deselect(code, targetPath);

      } else {

        map.select(code, targetPath);

      }

    }

  });

  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) {

    mapPins = {

      pins: params.pins,

      mode: params.pinMode

    };

    this.pinHandlers = false;

    this.placePins(params.pins, params.pinMode);

  }

  if(params.showLabels){

    this.pinHandlers = false;

    var pins = {};

    for (key in map.countries){

      if (typeof map.countries[key] !== 'function') {

        if( !params.pins || !params.pins[key] ){

          pins[key] = key.toUpperCase();

        }

      }

    }

    mapPins = {

      pins: pins,

      mode: 'content'

    };

    this.placePins(pins, 'content');

  }

  JQVMap.mapIndex++;

};

JQVMap.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

};

JQVMap.xlink = 'http://www.w3.org/1999/xlink';

JQVMap.mapIndex = 1;

JQVMap.maps = {};

(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',

    onLoad: 'load',

    onRegionOver: 'regionMouseOver',

    onRegionOut: 'regionMouseOut',

    onRegionClick: 'regionClick',

    onRegionSelect: 'regionSelect',

    onRegionDeselect: 'regionDeselect',

    onResize: 'resize'

  };

  jQuery.fn.vectorMap = function (options) {

    var defaultParams = {

      map: 'world_en',

      backgroundColor: '#a5bfdd',

      color: '#f4f3f0',

      hoverColor: '#c9dfaf',

      hoverColors: {},

      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') {

      JQVMap.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 {

      jQuery.extend(defaultParams, options);

      defaultParams.container = this;

      this.css({ position: 'relative', overflow: 'hidden' });

      map = new JQVMap(defaultParams);

      this.data('mapObject', map);

      this.unbind('.jqvmap');

      for (var e in apiEvents) {

        if (defaultParams[e]) {

          this.bind(apiEvents[e] + '.jqvmap', defaultParams[e]);

        }

      }

      var loadEvent = jQuery.Event('load.jqvmap');

      jQuery(defaultParams.container).trigger(loadEvent, map);

      return map;

    }

  };

})(jQuery);

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.prototype.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;

};

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)];

};

ColorScale.prototype.setColors = function (colors) {

  for (var i = 0; i < colors.length; i++) {

    colors[i] = ColorScale.rgbToArray(colors[i]);

  }

  this.colors = colors;

};

ColorScale.prototype.setMax = function (max) {

  this.clearMaxValue = max;

  if (typeof this.normalize === 'function') {

    this.maxValue = this.normalize(max);

  } else {

    this.maxValue = max;

  }

};

ColorScale.prototype.setMin = function (min) {

  this.clearMinValue = min;

  if (typeof this.normalize === 'function') {

    this.minValue = this.normalize(min);

  } else {

    this.minValue = min;

  }

};

ColorScale.prototype.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);

};

ColorScale.prototype.vectorAdd = function (vector1, vector2) {

  var vector = [];

  for (var i = 0; i < vector1.length; i++) {

    vector[i] = vector1[i] + vector2[i];

  }

  return vector;

};

ColorScale.prototype.vectorLength = function (vector) {

  var result = 0;

  for (var i = 0; i < vector.length; i++) {

    result += vector[i] * vector[i];

  }

  return Math.sqrt(result);

};

ColorScale.prototype.vectorMult = function (vector, num) {

  var result = [];

  for (var i = 0; i < vector.length; i++) {

    result[i] = vector[i] * num;

  }

  return result;

};

ColorScale.prototype.vectorSubtract = function (vector1, vector2) {

  var vector = [];

  for (var i = 0; i < vector1.length; i++) {

    vector[i] = vector1[i] - vector2[i];

  }

  return vector;

};

ColorScale.prototype.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;

};

JQVMap.prototype.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);

};

JQVMap.prototype.bindZoomButtons = function () {

  var map = this;

  this.container.find('.jqvmap-zoomin').click(function(){

    map.zoomIn();

  });

  this.container.find('.jqvmap-zoomout').click(function(){

    map.zoomOut();

  });

};

JQVMap.prototype.deselect = function (cc, path) {

  cc = cc.toLowerCase();

  path = path || jQuery('#' + this.getCountryId(cc))[0];

  if (this.isSelected(cc)) {

    this.selectedRegions.splice(this.selectIndex(cc), 1);

    jQuery(this.container).trigger('regionDeselect.jqvmap', [cc]);

    path.currentFillColor = path.getOriginalFill();

    path.setFill(path.getOriginalFill());

  } else {

    for (var key in this.countries) {

      this.selectedRegions.splice(this.selectedRegions.indexOf(key), 1);

      this.countries[key].currentFillColor = this.color;

      this.countries[key].setFill(this.color);

    }

  }

};

JQVMap.prototype.getCountryId = function (cc) {

  return 'jqvmap' + this.index + '_' + cc;

};

JQVMap.prototype.getPin = function(cc){

  var pinObj = jQuery('#' + this.getPinId(cc));

  return pinObj.html();

};

JQVMap.prototype.getPinId = function (cc) {

  return this.getCountryId(cc) + '_pin';

};

JQVMap.prototype.getPins = function(){

  var pins = this.container.find('.jqvmap-pin');

  var ret = {};

  jQuery.each(pins, function(index, pinObj){

    pinObj = jQuery(pinObj);

    var cc = pinObj.attr('for').toLowerCase();

    var pinContent = pinObj.html();

    ret[cc] = pinContent;

  });

  return JSON.stringify(ret);

};

JQVMap.prototype.highlight = function (cc, path) {

  path = path || jQuery('#' + this.getCountryId(cc))[0];

  if (this.hoverOpacity) {

    path.setOpacity(this.hoverOpacity);

  } else if (this.hoverColors && (cc in this.hoverColors)) {

    path.currentFillColor = path.getFill() + '';

    path.setFill(this.hoverColors[cc]);

  } else if (this.hoverColor) {

    path.currentFillColor = path.getFill() + '';

    path.setFill(this.hoverColor);

  }

};

JQVMap.prototype.isSelected = function(cc) {

  return this.selectIndex(cc) >= 0;

};

JQVMap.prototype.makeDraggable = function () {

  var mouseDown = false;

  var oldPageX, oldPageY;

  var self = this;

  self.isMoving = false;

  self.isMovingTimeout = false;

  var lastTouchCount;

  var touchCenterX;

  var touchCenterY;

  var touchStartDistance;

  var touchStartScale;

  var touchX;

  var touchY;

  this.container.mousemove(function (e) {

    if (mouseDown) {

      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;

    clearTimeout(self.isMovingTimeout);

    self.isMovingTimeout = setTimeout(function () {

      self.isMoving = false;

    }, 100);

    return false;

  }).mouseout(function () {

    if(mouseDown && self.isMoving){

      clearTimeout(self.isMovingTimeout);

      self.isMovingTimeout = setTimeout(function () {

        mouseDown = false;

        self.isMoving = false;

      }, 100);

      return false;

    }

  });

  jQuery(this.container).bind('touchmove', function (e) {

    var offset;

    var scale;

    var touches = e.originalEvent.touches;

    var transformXOld;

    var transformYOld;

    if (touches.length === 1) {

      if (lastTouchCount === 1) {

        if(touchX === touches[0].pageX && touchY === touches[0].pageY){

          return;

        }

        transformXOld = self.transX;

        transformYOld = self.transY;

        self.transX -= (touchX - touches[0].pageX) / self.scale;

        self.transY -= (touchY - touches[0].pageY) / self.scale;

        self.applyTransform();

        if (transformXOld !== self.transX || transformYOld !== self.transY) {

          e.preventDefault();

        }

        self.isMoving = true;

        if (self.isMovingTimeout) {

          clearTimeout(self.isMovingTimeout);

        }

      }

      touchX = touches[0].pageX;

      touchY = touches[0].pageY;

    } else if (touches.length === 2) {

      if (lastTouchCount === 2) {

        scale = Math.sqrt(

            Math.pow(touches[0].pageX - touches[1].pageX, 2) +

            Math.pow(touches[0].pageY - touches[1].pageY, 2)

          ) / touchStartDistance;

        self.setScale(

          touchStartScale * scale,

          touchCenterX,

          touchCenterY

        );

        e.preventDefault();

      } else {

        offset = jQuery(self.container).offset();

        if (touches[0].pageX > touches[1].pageX) {

          touchCenterX = touches[1].pageX + (touches[0].pageX - touches[1].pageX) / 2;

        } else {

          touchCenterX = touches[0].pageX + (touches[1].pageX - touches[0].pageX) / 2;

        }

        if (touches[0].pageY > touches[1].pageY) {

          touchCenterY = touches[1].pageY + (touches[0].pageY - touches[1].pageY) / 2;

        } else {

          touchCenterY = touches[0].pageY + (touches[1].pageY - touches[0].pageY) / 2;

        }

        touchCenterX -= offset.left;

        touchCenterY -= offset.top;

        touchStartScale = self.scale;

        touchStartDistance = Math.sqrt(

          Math.pow(touches[0].pageX - touches[1].pageX, 2) +

          Math.pow(touches[0].pageY - touches[1].pageY, 2)

        );

      }

    }

    lastTouchCount = touches.length;

  });

  jQuery(this.container).bind('touchstart', function () {

    lastTouchCount = 0;

  });

  jQuery(this.container).bind('touchend', function () {

    lastTouchCount = 0;

  });

};

JQVMap.prototype.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;

      }

      var pinIndex = map.getPinId(index);

      var $pin = jQuery('#' + pinIndex);

      if($pin.length > 0){

        $pin.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);

      var $pin = jQuery('#' + pinIndex);

      if($pin.length > 0){

        $pin.remove();

      }

      map.container.append('<div id="' + pinIndex + '" for="' + index + '" class="jqvmap-pin" style="position:absolute"></div>');

      $pin.append(jQuery('#' + pin));

    });

  }

  this.positionPins();

  if(!this.pinHandlers){

    this.pinHandlers = true;

    var positionFix = function(){

      map.positionPins();

    };

    this.container.bind('zoomIn', positionFix)

      .bind('zoomOut', positionFix)

      .bind('drag', positionFix);

  }

};

JQVMap.prototype.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').toLowerCase());

    var countryObj = jQuery('#' + countryId);

    var bbox = countryObj[0].getBBox();

    var scale = map.scale;

    var rootCoords = map.canvas.rootGroup.getBoundingClientRect();

    var mapCoords = map.container[0].getBoundingClientRect();

    var coords = {

      left: rootCoords.left - mapCoords.left,

      top: rootCoords.top - mapCoords.top

    };

    var middleX = (bbox.x * scale) + ((bbox.width * scale) / 2);

    var middleY = (bbox.y * scale) + ((bbox.height * scale) / 2);

    pinObj.css({

      left: coords.left + middleX - (pinObj.width() / 2),

      top: coords.top + middleY - (pinObj.height() / 2)

    });

  });

};

JQVMap.prototype.removePin = function(cc) {

  cc = cc.toLowerCase();

  jQuery('#' + this.getPinId(cc)).remove();

};

JQVMap.prototype.removePins = function(){

  this.container.find('.jqvmap-pin').remove();

};

JQVMap.prototype.reset = function () {

  for (var key in this.countries) {

    this.countries[key].setFill(this.color);

  }

  this.scale = this.baseScale;

  this.transX = this.baseTransX;

  this.transY = this.baseTransY;

  this.applyTransform();

};

JQVMap.prototype.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;

};

JQVMap.prototype.select = function (cc, path) {

  cc = cc.toLowerCase();

  path = path || jQuery('#' + this.getCountryId(cc))[0];

  if (!this.isSelected(cc)) {

    if (this.multiSelectRegion) {

      this.selectedRegions.push(cc);

    } else {

      this.selectedRegions = [cc];

    }

    jQuery(this.container).trigger('regionSelect.jqvmap', [cc]);

    if (this.selectedColor && path) {

      path.currentFillColor = this.selectedColor;

      path.setFill(this.selectedColor);

    }

  }

};

JQVMap.prototype.selectIndex = function (cc) {

  cc = cc.toLowerCase();

  for (var i = 0; i < this.selectedRegions.length; i++) {

    if (cc === this.selectedRegions[i]) {

      return i;

    }

  }

  return -1;

};

JQVMap.prototype.setBackgroundColor = function (backgroundColor) {

  this.container.css('background-color', backgroundColor);

};

JQVMap.prototype.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]);

      }

    }

  }

};

JQVMap.prototype.setNormalizeFunction = function (f) {

  this.colorScale.setNormalizeFunction(f);

  if (this.values) {

    this.setValues(this.values);

  }

};

JQVMap.prototype.setScale = function (scale) {

  this.scale = scale;

  this.applyTransform();

};

JQVMap.prototype.setScaleColors = function (colors) {

  this.colorScale.setColors(colors);

  if (this.values) {

    this.setValues(this.values);

  }

};

JQVMap.prototype.setValues = function (values) {

  var max = 0,

    min = Number.MAX_VALUE,

    val;

  for (var cc in values) {

    cc = cc.toLowerCase();

    val = parseFloat(values[cc]);

    if (isNaN(val)) {

      continue;

    }

    if (val > max) {

      max = values[cc];

    }

    if (val < min) {

      min = val;

    }

  }

  if (min === max) {

    max++;

  }

  this.colorScale.setMin(min);

  this.colorScale.setMax(max);

  var colors = {};

  for (cc in values) {

    cc = cc.toLowerCase();

    val = parseFloat(values[cc]);

    colors[cc] = isNaN(val) ? this.color : this.colorScale.getColor(val);

  }

  this.setColors(colors);

  this.values = values;