jvectormap-rails 1.0.1 → 2.0.0

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

@@ -0,0 +1,83 @@
+/**
+ * Represents map legend.
+ * @constructor
+ * @param {Object} params Configuration parameters.
+ * @param {String} params.cssClass Additional CSS class to apply to legend element.
+ * @param {Boolean} params.vertical If <code>true</code> legend will be rendered as vertical.
+ * @param {String} params.title Legend title.
+ * @param {Function} params.labelRender Method to convert series values to legend labels.
+ */
+jvm.Legend = function(params) {
+  this.params = params || {};
+  this.map = this.params.map;
+  this.series = this.params.series;
+  this.body = jvm.$('<div/>');
+  this.body.addClass('jvectormap-legend');
+  if (this.params.cssClass) {
+    this.body.addClass(this.params.cssClass);
+  }
+
+  if (params.vertical) {
+    this.map.legendCntVertical.append( this.body );
+  } else {
+    this.map.legendCntHorizontal.append( this.body );
+  }
+
+  this.render();
+}
+
+jvm.Legend.prototype.render = function(){
+  var ticks = this.series.scale.getTicks(),
+      i,
+      inner = jvm.$('<div/>').addClass('jvectormap-legend-inner'),
+      tick,
+      sample,
+      label;
+
+  this.body.html('');
+  if (this.params.title) {
+    this.body.append(
+      jvm.$('<div/>').addClass('jvectormap-legend-title').html(this.params.title)
+    );
+  }
+  this.body.append(inner);
+
+  for (i = 0; i < ticks.length; i++) {
+    tick = jvm.$('<div/>').addClass('jvectormap-legend-tick');
+    sample = jvm.$('<div/>').addClass('jvectormap-legend-tick-sample');
+
+    switch (this.series.params.attribute) {
+      case 'fill':
+        if (jvm.isImageUrl(ticks[i].value)) {
+          sample.css('background', 'url('+ticks[i].value+')');
+        } else {
+          sample.css('background', ticks[i].value);
+        }
+        break;
+      case 'stroke':
+        sample.css('background', ticks[i].value);
+        break;
+      case 'image':
+        sample.css('background', 'url('+ticks[i].value+') no-repeat center center');
+        break;
+      case 'r':
+        jvm.$('<div/>').css({
+          'border-radius': ticks[i].value,
+          border: this.map.params.markerStyle.initial['stroke-width']+'px '+
+                  this.map.params.markerStyle.initial['stroke']+' solid',
+          width: ticks[i].value * 2 + 'px',
+          height: ticks[i].value * 2 + 'px',
+          background: this.map.params.markerStyle.initial['fill']
+        }).appendTo(sample);
+        break;
+    }
+    tick.append( sample );
+    label = ticks[i].label;
+    if (this.params.labelRender) {
+      label = this.params.labelRender(label);
+    }
+    tick.append( jvm.$('<div>'+label+' </div>').addClass('jvectormap-legend-tick-text') );
+    inner.append(tick);
+  }
+  inner.append( jvm.$('<div/>').css('clear', 'both') );
+}

data/vendor/assets/javascripts/jvectormap/src/map-object.js

@@ -0,0 +1,73 @@
+jvm.MapObject = function(config){};
+
+jvm.MapObject.prototype.getLabelText = function(key){
+  var text;
+
+  if (this.config.label) {
+    if (typeof this.config.label.render === 'function') {
+      text = this.config.label.render(key);
+    } else {
+      text = key;
+    }
+  } else {
+    text = null;
+  }
+  return text;
+}
+
+jvm.MapObject.prototype.getLabelOffsets = function(key){
+  var offsets;
+
+  if (this.config.label) {
+    if (typeof this.config.label.offsets === 'function') {
+      offsets = this.config.label.offsets(key);
+    } else if (typeof this.config.label.offsets === 'object') {
+      offsets = this.config.label.offsets[key];
+    }
+  }
+  return offsets || [0, 0];
+}
+
+/**
+ * Set hovered state to the element. Hovered state means mouse cursor is over element. Styles will be updates respectively.
+ * @param {Boolean} isHovered <code>true</code> to make element hovered, <code>false</code> otherwise.
+ */
+jvm.MapObject.prototype.setHovered = function(isHovered){
+  if (this.isHovered !== isHovered) {
+    this.isHovered = isHovered;
+    this.shape.isHovered = isHovered;
+    this.shape.updateStyle();
+    if (this.label) {
+      this.label.isHovered = isHovered;
+      this.label.updateStyle();
+    }
+  }
+};
+
+/**
+ * Set selected state to the element. Styles will be updates respectively.
+ * @param {Boolean} isSelected <code>true</code> to make element selected, <code>false</code> otherwise.
+ */
+jvm.MapObject.prototype.setSelected = function(isSelected){
+  if (this.isSelected !== isSelected) {
+    this.isSelected = isSelected;
+    this.shape.isSelected = isSelected;
+    this.shape.updateStyle();
+    if (this.label) {
+      this.label.isSelected = isSelected;
+      this.label.updateStyle();
+    }
+    jvm.$(this.shape).trigger('selected', [isSelected]);
+  }
+};
+
+jvm.MapObject.prototype.setStyle = function(){
+	this.shape.setStyle.apply(this.shape, arguments);
+};
+
+jvm.MapObject.prototype.remove = function(){
+  this.shape.remove();
+  if (this.label) {
+    this.label.remove();
+  }
+};

data/vendor/assets/javascripts/jvectormap/{lib/world-map.js → src/map.js}

@@ -2,12 +2,15 @@
  * Creates map, draws paths, binds events.
  * @constructor
  * @param {Object} params Parameters to initialize map with.
- * @param {String} params.map Name of the map in the format <code>territory_proj_lang</code> where <code>territory</code> is a unique code or name of the territory which the map represents (ISO 3166 alpha 2 standard is used where possible), <code>proj</code> is a name of projection used to generate representation of the map on the plane (projections are named according to the conventions of proj4 utility) and <code>lang</code> is a code of the language, used for the names of regions.
+ * @param {String} params.map Name of the map in the format <code>territory_proj_lang</code> where <code>territory</code> is a unique code or name of the territory which the map represents (ISO 3166 standard is used where possible), <code>proj</code> is a name of projection used to generate representation of the map on the plane (projections are named according to the conventions of proj4 utility) and <code>lang</code> is a code of the language, used for the names of regions.
  * @param {String} params.backgroundColor Background color of the map in CSS format.
  * @param {Boolean} params.zoomOnScroll When set to true map could be zoomed using mouse scroll. Default value is <code>true</code>.
+ * @param {Boolean} params.zoomOnScrollSpeed Mouse scroll speed. Number from 1 to 10. Default value is <code>3</code>.
+ * @param {Boolean} params.panOnDrag When set to true, the map pans when being dragged. Default value is <code>true</code>.
  * @param {Number} params.zoomMax Indicates the maximum zoom ratio which could be reached zooming the map. Default value is <code>8</code>.
  * @param {Number} params.zoomMin Indicates the minimum zoom ratio which could be reached zooming the map. Default value is <code>1</code>.
  * @param {Number} params.zoomStep Indicates the multiplier used to zoom map with +/- buttons. Default value is <code>1.6</code>.
+ * @param {Boolean} params.zoomAnimate Indicates whether or not to animate changing of map zoom with zoom buttons.
  * @param {Boolean} params.regionsSelectable When set to true regions of the map could be selected. Default value is <code>false</code>.
  * @param {Boolean} params.regionsSelectableOne Allow only one region to be selected at the moment. Default value is <code>false</code>.
  * @param {Boolean} params.markersSelectable When set to true markers on the map could be selected. Default value is <code>false</code>.
@@ -22,13 +25,27 @@
     "stroke-opacity": 1
   },
   hover: {
-    "fill-opacity": 0.8
+    "fill-opacity": 0.8,
+    cursor: 'pointer'
   },
   selected: {
     fill: 'yellow'
   },
   selectedHover: {
   }
+}</pre>
+* @param {Object} params.regionLabelStyle Set the styles for the regions' labels. Each region or marker has four states: <code>initial</code> (default state), <code>hover</code> (when the mouse cursor is over the region or marker), <code>selected</code> (when region or marker is selected), <code>selectedHover</code> (when the mouse cursor is over the region or marker and it's selected simultaneously). Styles could be set for each of this states. Default value for that parameter is:
+<pre>{
+  initial: {
+    'font-family': 'Verdana',
+    'font-size': '12',
+    'font-weight': 'bold',
+    cursor: 'default',
+    fill: 'black'
+  },
+  hover: {
+    cursor: 'pointer'
+  }
 }</pre>
  * @param {Object} params.markerStyle Set the styles for the map's markers. Any parameter suitable for <code>regionStyle</code> could be used as well as numeric parameter <code>r</code> to set the marker's radius. Default value for that parameter is:
 <pre>{
@@ -42,7 +59,8 @@
   },
   hover: {
     stroke: 'black',
-    "stroke-width": 2
+    "stroke-width": 2,
+    cursor: 'pointer'
   },
   selected: {
     fill: 'blue'
@@ -50,51 +68,63 @@
   selectedHover: {
   }
 }</pre>
- * @param {Object|Array} params.markers Set of markers to add to the map during initialization. In case of array is provided, codes of markers will be set as string representations of array indexes. Each marker is represented by <code>latLng</code> (array of two numeric values), <code>name</code> (string which will be show on marker's label) and any marker styles.
- * @param {Object} params.series Object with two keys: <code>markers</code> and <code>regions</code>. Each of which is an array of series configs to be applied to the respective map elements. See <a href="jvm.DataSeries.html">DataSeries</a> description for a list of parameters available.
- * @param {Object|String} params.focusOn This parameter sets the initial position and scale of the map viewport. It could be expressed as a string representing region which should be in focus or an object representing coordinates and scale to set. For example to focus on the center of the map at the double scale you can provide the following value:
+ * @param {Object} params.markerLabelStyle Set the styles for the markers' labels. Default value for that parameter is:
 <pre>{
-  x: 0.5,
-  y: 0.5,
-  scale: 2
+  initial: {
+    'font-family': 'Verdana',
+    'font-size': '12',
+    'font-weight': 'bold',
+    cursor: 'default',
+    fill: 'black'
+  },
+  hover: {
+    cursor: 'pointer'
+  }
 }</pre>
+ * @param {Object|Array} params.markers Set of markers to add to the map during initialization. In case of array is provided, codes of markers will be set as string representations of array indexes. Each marker is represented by <code>latLng</code> (array of two numeric values), <code>name</code> (string which will be show on marker's tip) and any marker styles.
+ * @param {Object} params.series Object with two keys: <code>markers</code> and <code>regions</code>. Each of which is an array of series configs to be applied to the respective map elements. See <a href="jvm.DataSeries.html">DataSeries</a> description for a list of parameters available.
+ * @param {Object|String} params.focusOn This parameter sets the initial position and scale of the map viewport. See <code>setFocus</code> docuemntation for possible parameters.
+ * @param {Object} params.labels Defines parameters for rendering static labels. Object could contain two keys: <code>regions</code> and <code>markers</code>. Each key value defines configuration object with the following possible options:
+<ul>
+  <li><code>render {Function}</code> - defines method for converting region code or marker index to actual label value.</li>
+  <li><code>offsets {Object|Function}</code> - provides method or object which could be used to define label offset by region code or marker index.</li>
+</ul>
+<b>Plase note: static labels feature is not supported in Internet Explorer 8 and below.</b>
  * @param {Array|Object|String} params.selectedRegions Set initially selected regions.
  * @param {Array|Object|String} params.selectedMarkers Set initially selected markers.
- * @param {Function} params.onRegionLabelShow <code>(Event e, Object label, String code)</code> Will be called right before the region label is going to be shown.
+ * @param {Function} params.onRegionTipShow <code>(Event e, Object tip, String code)</code> Will be called right before the region tip is going to be shown.
  * @param {Function} params.onRegionOver <code>(Event e, String code)</code> Will be called on region mouse over event.
  * @param {Function} params.onRegionOut <code>(Event e, String code)</code> Will be called on region mouse out event.
  * @param {Function} params.onRegionClick <code>(Event e, String code)</code> Will be called on region click event.
  * @param {Function} params.onRegionSelected <code>(Event e, String code, Boolean isSelected, Array selectedRegions)</code> Will be called when region is (de)selected. <code>isSelected</code> parameter of the callback indicates whether region is selected or not. <code>selectedRegions</code> contains codes of all currently selected regions.
- * @param {Function} params.onMarkerLabelShow <code>(Event e, Object label, String code)</code> Will be called right before the marker label is going to be shown.
+ * @param {Function} params.onMarkerTipShow <code>(Event e, Object tip, String code)</code> Will be called right before the marker tip is going to be shown.
  * @param {Function} params.onMarkerOver <code>(Event e, String code)</code> Will be called on marker mouse over event.
  * @param {Function} params.onMarkerOut <code>(Event e, String code)</code> Will be called on marker mouse out event.
  * @param {Function} params.onMarkerClick <code>(Event e, String code)</code> Will be called on marker click event.
  * @param {Function} params.onMarkerSelected <code>(Event e, String code, Boolean isSelected, Array selectedMarkers)</code> Will be called when marker is (de)selected. <code>isSelected</code> parameter of the callback indicates whether marker is selected or not. <code>selectedMarkers</code> contains codes of all currently selected markers.
  * @param {Function} params.onViewportChange <code>(Event e, Number scale)</code> Triggered when the map's viewport is changed (map was panned or zoomed).
  */
-jvm.WorldMap = function(params) {
+jvm.Map = function(params) {
   var map = this,
       e;
 
-  this.params = jvm.$.extend(true, {}, jvm.WorldMap.defaultParams, params);
+  this.params = jvm.$.extend(true, {}, jvm.Map.defaultParams, params);
 
-  if (!jvm.WorldMap.maps[this.params.map]) {
+  if (!jvm.Map.maps[this.params.map]) {
     throw new Error('Attempt to use map which was not loaded: '+this.params.map);
   }
 
-  this.mapData = jvm.WorldMap.maps[this.params.map];
+  this.mapData = jvm.Map.maps[this.params.map];
   this.markers = {};
   this.regions = {};
   this.regionsColors = {};
   this.regionsData = {};
 
-  this.container = jvm.$('<div>').css({width: '100%', height: '100%'}).addClass('jvectormap-container');
-  this.params.container.append( this.container );
+  this.container = jvm.$('<div>').addClass('jvectormap-container');
+  if (this.params.container) {
+    this.params.container.append( this.container );
+  }
   this.container.data('mapObject', this);
-  this.container.css({
-    position: 'relative',
-    overflow: 'hidden'
-  });
 
   this.defaultWidth = this.mapData.width;
   this.defaultHeight = this.mapData.height;
@@ -102,41 +132,44 @@ jvm.WorldMap = function(params) {
   this.setBackgroundColor(this.params.backgroundColor);
 
   this.onResize = function(){
-    map.setSize();
+    map.updateSize();
   }
   jvm.$(window).resize(this.onResize);
 
-  for (e in jvm.WorldMap.apiEvents) {
+  for (e in jvm.Map.apiEvents) {
     if (this.params[e]) {
-      this.container.bind(jvm.WorldMap.apiEvents[e]+'.jvectormap', this.params[e]);
+      this.container.bind(jvm.Map.apiEvents[e]+'.jvectormap', this.params[e]);
     }
   }
 
   this.canvas = new jvm.VectorCanvas(this.container[0], this.width, this.height);
 
-  if ( ('ontouchstart' in window) || (window.DocumentTouch && document instanceof DocumentTouch) ) {
-    if (this.params.bindTouchEvents) {
+  if (this.params.bindTouchEvents) {
+    if (('ontouchstart' in window) || (window.DocumentTouch && document instanceof DocumentTouch)) {
       this.bindContainerTouchEvents();
+    } else if (window.MSGesture) {
+      this.bindContainerPointerEvents();
     }
-  } else {
-    this.bindContainerEvents();
   }
+  this.bindContainerEvents();
   this.bindElementEvents();
-  this.createLabel();
+  this.createTip();
   if (this.params.zoomButtons) {
     this.bindZoomButtons();
   }
+
   this.createRegions();
   this.createMarkers(this.params.markers || {});
 
-  this.setSize();
+  this.updateSize();
 
   if (this.params.focusOn) {
-    if (typeof this.params.focusOn === 'object') {
-      this.setFocus.call(this, this.params.focusOn.scale, this.params.focusOn.x, this.params.focusOn.y);
-    } else {
-      this.setFocus.call(this, this.params.focusOn);
+    if (typeof this.params.focusOn === 'string') {
+      this.params.focusOn = {region: this.params.focusOn};
+    } else if (jvm.$.isArray(this.params.focusOn)) {
+      this.params.focusOn = {regions: this.params.focusOn};
     }
+    this.setFocus(this.params.focusOn);
   }
 
   if (this.params.selectedRegions) {
@@ -146,12 +179,17 @@ jvm.WorldMap = function(params) {
     this.setSelectedMarkers(this.params.selectedMarkers);
   }
 
+  this.legendCntHorizontal = jvm.$('<div/>').addClass('jvectormap-legend-cnt jvectormap-legend-cnt-h');
+  this.legendCntVertical = jvm.$('<div/>').addClass('jvectormap-legend-cnt jvectormap-legend-cnt-v');
+  this.container.append(this.legendCntHorizontal);
+  this.container.append(this.legendCntVertical);
+
   if (this.params.series) {
     this.createSeries();
   }
 };
 
-jvm.WorldMap.prototype = {
+jvm.Map.prototype = {
   transX: 0,
   transY: 0,
   scale: 1,
@@ -187,7 +225,7 @@ jvm.WorldMap.prototype = {
   /**
    * Synchronize the size of the map with the size of the container. Suitable in situations where the size of the container is changed programmatically or container is shown after it became visible.
    */
-  setSize: function(){
+  updateSize: function(){
     this.width = this.container.width();
     this.height = this.container.height();
     this.resize();
@@ -252,6 +290,8 @@ jvm.WorldMap.prototype = {
       this.repositionMarkers();
     }
 
+    this.repositionLabels();
+
     this.container.trigger('viewportChange', [this.scale/this.baseScale, this.transX, this.transY]);
   },
 
@@ -261,36 +301,39 @@ jvm.WorldMap.prototype = {
         oldPageY,
         map = this;
 
-    this.container.mousemove(function(e){
-      if (mouseDown) {
-        map.transX -= (oldPageX - e.pageX) / map.scale;
-        map.transY -= (oldPageY - e.pageY) / map.scale;
+    if (this.params.panOnDrag) {
+      this.container.mousemove(function(e){
+        if (mouseDown) {
+          map.transX -= (oldPageX - e.pageX) / map.scale;
+          map.transY -= (oldPageY - e.pageY) / map.scale;
 
-        map.applyTransform();
+          map.applyTransform();
 
+          oldPageX = e.pageX;
+          oldPageY = e.pageY;
+        }
+        return false;
+      }).mousedown(function(e){
+        mouseDown = true;
         oldPageX = e.pageX;
         oldPageY = e.pageY;
-      }
-      return false;
-    }).mousedown(function(e){
-      mouseDown = true;
-      oldPageX = e.pageX;
-      oldPageY = e.pageY;
-      return false;
-    });
+        return false;
+      });
 
-    jvm.$('body').mouseup(function(){
-      mouseDown = false;
-    });
+      this.onContainerMouseUp = function(){
+        mouseDown = false;
+      };
+      jvm.$('body').mouseup(this.onContainerMouseUp);
+    }
 
     if (this.params.zoomOnScroll) {
       this.container.mousewheel(function(event, delta, deltaX, deltaY) {
         var offset = jvm.$(map.container).offset(),
             centerX = event.pageX - offset.left,
             centerY = event.pageY - offset.top,
-            zoomStep = Math.pow(1.3, deltaY);
+            zoomStep = Math.pow(1 + map.params.zoomOnScrollSpeed / 1000, event.deltaFactor * event.deltaY);
 
-        map.label.hide();
+        map.tip.hide();
 
         map.setScale(map.scale * zoomStep, centerX, centerY);
         event.preventDefault();
@@ -309,7 +352,10 @@ jvm.WorldMap.prototype = {
         lastTouchesLength,
         handleTouchEvent = function(e){
           var touches = e.originalEvent.touches,
-              scale;
+              offset,
+              scale,
+              transXOld,
+              transYOld;
 
           if (e.type == 'touchstart') {
             lastTouchesLength = 0;
@@ -317,11 +363,15 @@ jvm.WorldMap.prototype = {
 
           if (touches.length == 1) {
             if (lastTouchesLength == 1) {
+              transXOld = map.transX;
+              transYOld = map.transY;
               map.transX -= (touchX - touches[0].pageX) / map.scale;
               map.transY -= (touchY - touches[0].pageY) / map.scale;
               map.applyTransform();
-              map.label.hide();
-              e.preventDefault();
+              map.tip.hide();
+              if (transXOld != map.transX || transYOld != map.transY) {
+                e.preventDefault();
+              }
             }
             touchX = touches[0].pageX;
             touchY = touches[0].pageY;
@@ -336,9 +386,10 @@ jvm.WorldMap.prototype = {
                 centerTouchX,
                 centerTouchY
               )
-              map.label.hide();
+              map.tip.hide();
               e.preventDefault();
             } else {
+              offset = jvm.$(map.container).offset();
               if (touches[0].pageX > touches[1].pageX) {
                 centerTouchX = touches[1].pageX + (touches[0].pageX - touches[1].pageX) / 2;
               } else {
@@ -349,6 +400,8 @@ jvm.WorldMap.prototype = {
               } else {
                 centerTouchY = touches[0].pageY + (touches[1].pageY - touches[0].pageY) / 2;
               }
+              centerTouchX -= offset.left;
+              centerTouchY -= offset.top;
               touchStartScale = map.scale;
               touchStartDistance = Math.sqrt(
                 Math.pow(touches[0].pageX - touches[1].pageX, 2) +
@@ -364,24 +417,67 @@ jvm.WorldMap.prototype = {
     jvm.$(this.container).bind('touchmove', handleTouchEvent);
   },
 
+  bindContainerPointerEvents: function(){
+    var map = this,
+        gesture = new MSGesture(),
+        element = this.container[0],
+        handlePointerDownEvent = function(e){
+          gesture.addPointer(e.pointerId);
+        },
+        handleGestureEvent = function(e){
+          var offset,
+              scale,
+              transXOld,
+              transYOld;
+
+          if (e.translationX != 0 || e.translationY != 0) {
+            transXOld = map.transX;
+            transYOld = map.transY;
+            map.transX += e.translationX / map.scale;
+            map.transY += e.translationY / map.scale;
+            map.applyTransform();
+            map.tip.hide();
+            if (transXOld != map.transX || transYOld != map.transY) {
+              e.preventDefault();
+            }
+          }
+          if (e.scale != 1) {
+            map.setScale(
+              map.scale * e.scale,
+              e.offsetX,
+              e.offsetY
+            )
+            map.tip.hide();
+            e.preventDefault();
+          }
+        };
+
+    gesture.target = element;
+    element.addEventListener("MSGestureChange", handleGestureEvent, false);
+    element.addEventListener("pointerdown", handlePointerDownEvent, false);
+  },
+
   bindElementEvents: function(){
     var map = this,
+        pageX,
+        pageY,
         mouseMoved;
 
-    this.container.mousemove(function(){
-      mouseMoved = true;
+    this.container.mousemove(function(e){
+      if (Math.abs(pageX - e.pageX) + Math.abs(pageY - e.pageY) > 2) {
+        mouseMoved = true;
+      }
     });
 
     /* Can not use common class selectors here because of the bug in jQuery
        SVG handling, use with caution. */
     this.container.delegate("[class~='jvectormap-element']", 'mouseover mouseout', function(e){
-      var path = this,
-          baseVal = jvm.$(this).attr('class').baseVal ? jvm.$(this).attr('class').baseVal : jvm.$(this).attr('class'),
+      var baseVal = jvm.$(this).attr('class').baseVal || jvm.$(this).attr('class'),
           type = baseVal.indexOf('jvectormap-region') === -1 ? 'marker' : 'region',
           code = type == 'region' ? jvm.$(this).attr('data-code') : jvm.$(this).attr('data-index'),
           element = type == 'region' ? map.regions[code].element : map.markers[code].element,
-          labelText = type == 'region' ? map.mapData.paths[code].name : (map.markers[code].config.name || ''),
-          labelShowEvent = jvm.$.Event(type+'LabelShow.jvectormap'),
+          tipText = type == 'region' ? map.mapData.paths[code].name : (map.markers[code].config.name || ''),
+          tipShowEvent = jvm.$.Event(type+'TipShow.jvectormap'),
           overEvent = jvm.$.Event(type+'Over.jvectormap');
 
       if (e.type == 'mouseover') {
@@ -390,16 +486,16 @@ jvm.WorldMap.prototype = {
           element.setHovered(true);
         }
 
-        map.label.text(labelText);
-        map.container.trigger(labelShowEvent, [map.label, code]);
-        if (!labelShowEvent.isDefaultPrevented()) {
-          map.label.show();
-          map.labelWidth = map.label.width();
-          map.labelHeight = map.label.height();
+        map.tip.text(tipText);
+        map.container.trigger(tipShowEvent, [map.tip, code]);
+        if (!tipShowEvent.isDefaultPrevented()) {
+          map.tip.show();
+          map.tipWidth = map.tip.width();
+          map.tipHeight = map.tip.height();
         }
       } else {
         element.setHovered(false);
-        map.label.hide();
+        map.tip.hide();
         map.container.trigger(type+'Out.jvectormap', [code]);
       }
     });
@@ -407,14 +503,15 @@ jvm.WorldMap.prototype = {
     /* Can not use common class selectors here because of the bug in jQuery
        SVG handling, use with caution. */
     this.container.delegate("[class~='jvectormap-element']", 'mousedown', function(e){
+      pageX = e.pageX;
+      pageY = e.pageY;
       mouseMoved = false;
     });
 
     /* Can not use common class selectors here because of the bug in jQuery
        SVG handling, use with caution. */
-    this.container.delegate("[class~='jvectormap-element']", 'mouseup', function(e){
-      var path = this,
-          baseVal = jvm.$(this).attr('class').baseVal ? jvm.$(this).attr('class').baseVal : jvm.$(this).attr('class'),
+    this.container.delegate("[class~='jvectormap-element']", 'mouseup', function(){
+      var baseVal = jvm.$(this).attr('class').baseVal ? jvm.$(this).attr('class').baseVal : jvm.$(this).attr('class'),
           type = baseVal.indexOf('jvectormap-region') === -1 ? 'marker' : 'region',
           code = type == 'region' ? jvm.$(this).attr('data-code') : jvm.$(this).attr('data-index'),
           clickEvent = jvm.$.Event(type+'Click.jvectormap'),
@@ -441,21 +538,21 @@ jvm.WorldMap.prototype = {
     jvm.$('<div/>').addClass('jvectormap-zoomout').html('&#x2212;').appendTo(this.container);
 
     this.container.find('.jvectormap-zoomin').click(function(){
-      map.setScale(map.scale * map.params.zoomStep, map.width / 2, map.height / 2);
+      map.setScale(map.scale * map.params.zoomStep, map.width / 2, map.height / 2, false, map.params.zoomAnimate);
     });
     this.container.find('.jvectormap-zoomout').click(function(){
-      map.setScale(map.scale / map.params.zoomStep, map.width / 2, map.height / 2);
+      map.setScale(map.scale / map.params.zoomStep, map.width / 2, map.height / 2, false, map.params.zoomAnimate);
     });
   },
 
-  createLabel: function(){
+  createTip: function(){
     var map = this;
 
-    this.label = jvm.$('<div/>').addClass('jvectormap-label').appendTo(jvm.$('body'));
+    this.tip = jvm.$('<div/>').addClass('jvectormap-tip').appendTo(jvm.$('body'));
 
     this.container.mousemove(function(e){
-      var left = e.pageX-15-map.labelWidth,
-          top = e.pageY-15-map.labelHeight;
+      var left = e.pageX-15-map.tipWidth,
+          top = e.pageY-15-map.tipHeight;
 
       if (left < 5) {
         left = e.pageX + 15;
@@ -464,18 +561,28 @@ jvm.WorldMap.prototype = {
         top = e.pageY + 15;
       }
 
-      if (map.label.is(':visible')) {
-        map.label.css({
-          left: left,
-          top: top
-        })
-      }
+      map.tip.css({
+        left: left,
+        top: top
+      });
     });
   },
 
-  setScale: function(scale, anchorX, anchorY, isCentered) {
-    var zoomStep,
-        viewportChangeEvent = jvm.$.Event('zoom.jvectormap');
+  setScale: function(scale, anchorX, anchorY, isCentered, animate) {
+    var viewportChangeEvent = jvm.$.Event('zoom.jvectormap'),
+        interval,
+        that = this,
+        i = 0,
+        count = Math.abs(Math.round((scale - this.scale) * 60 / Math.max(scale, this.scale))),
+        scaleStart,
+        scaleDiff,
+        transXStart,
+        transXDiff,
+        transYStart,
+        transYDiff,
+        transX,
+        transY,
+        deferred = new jvm.$.Deferred();
 
     if (scale > this.params.zoomMax * this.baseScale) {
       scale = this.params.zoomMax * this.baseScale;
@@ -486,41 +593,77 @@ jvm.WorldMap.prototype = {
     if (typeof anchorX != 'undefined' && typeof anchorY != 'undefined') {
       zoomStep = scale / this.scale;
       if (isCentered) {
-        this.transX = anchorX + this.defaultWidth * (this.width / (this.defaultWidth * scale)) / 2;
-        this.transY = anchorY + this.defaultHeight * (this.height / (this.defaultHeight * scale)) / 2;
+        transX = anchorX + this.defaultWidth * (this.width / (this.defaultWidth * scale)) / 2;
+        transY = anchorY + this.defaultHeight * (this.height / (this.defaultHeight * scale)) / 2;
       } else {
-        this.transX -= (zoomStep - 1) / scale * anchorX;
-        this.transY -= (zoomStep - 1) / scale * anchorY;
+        transX = this.transX - (zoomStep - 1) / scale * anchorX;
+        transY = this.transY - (zoomStep - 1) / scale * anchorY;
       }
     }
 
-    this.scale = scale;
-    this.applyTransform();
-    this.container.trigger(viewportChangeEvent, [scale/this.baseScale]);
+    if (animate && count > 0)  {
+      scaleStart = this.scale;
+      scaleDiff = (scale - scaleStart) / count;
+      transXStart = this.transX * this.scale;
+      transYStart = this.transY * this.scale;
+      transXDiff = (transX * scale - transXStart) / count;
+      transYDiff = (transY * scale - transYStart) / count;
+      interval = setInterval(function(){
+        i += 1;
+        that.scale = scaleStart + scaleDiff * i;
+        that.transX = (transXStart + transXDiff * i) / that.scale;
+        that.transY = (transYStart + transYDiff * i) / that.scale;
+        that.applyTransform();
+        if (i == count) {
+          clearInterval(interval);
+          that.container.trigger(viewportChangeEvent, [scale/that.baseScale]);
+          deferred.resolve();
+        }
+      }, 10);
+    } else {
+      this.transX = transX;
+      this.transY = transY;
+      this.scale = scale;
+      this.applyTransform();
+      this.container.trigger(viewportChangeEvent, [scale/this.baseScale]);
+      deferred.resolve();
+    }
+
+    return deferred;
   },
 
   /**
    * Set the map's viewport to the specific point and set zoom of the map to the specific level. Point and zoom level could be defined in two ways: using the code of some region to focus on or a central point and zoom level as numbers.
-   * @param {Number|String|Array} scale|regionCode|regionCodes If the first parameter of this method is a string or array of strings and there are regions with the these codes, the viewport will be set to show all these regions. Otherwise if the first parameter is a number, the viewport will be set to show the map with provided scale.
-   * @param {Number} centerX Number from 0 to 1 specifying the horizontal coordinate of the central point of the viewport.
-   * @param {Number} centerY Number from 0 to 1 specifying the vertical coordinate of the central point of the viewport.
+   * @param This method takes a configuration object as the single argument. The options passed to it are the following:
+   * @param {Array} params.regions Array of region codes to zoom to.
+   * @param {String} params.region Region code to zoom to.
+   * @param {Number} params.scale Map scale to set.
+   * @param {Number} params.lat Latitude to set viewport to.
+   * @param {Number} params.lng Longitude to set viewport to.
+   * @param {Number} params.x Number from 0 to 1 specifying the horizontal coordinate of the central point of the viewport.
+   * @param {Number} params.y Number from 0 to 1 specifying the vertical coordinate of the central point of the viewport.
+   * @param {Boolean} params.animate Indicates whether or not to animate the scale change and transition.
    */
-  setFocus: function(scale, centerX, centerY){
+  setFocus: function(config){
     var bbox,
         itemBbox,
         newBbox,
         codes,
-        i;
+        i,
+        point;
 
-    if (jvm.$.isArray(scale) || this.regions[scale]) {
-      if (jvm.$.isArray(scale)) {
-        codes = scale;
-      } else {
-        codes = [scale]
-      }
+    config = config || {};
+
+    if (config.region) {
+      codes = [config.region];
+    } else if (config.regions) {
+      codes = config.regions;
+    }
+
+    if (codes) {
       for (i = 0; i < codes.length; i++) {
         if (this.regions[codes[i]]) {
-          itemBbox = this.regions[codes[i]].element.getBBox();
+          itemBbox = this.regions[codes[i]].element.shape.getBBox();
           if (itemBbox) {
             if (typeof bbox == 'undefined') {
               bbox = itemBbox;
@@ -536,15 +679,23 @@ jvm.WorldMap.prototype = {
           }
         }
       }
-      this.setScale(
+      return this.setScale(
         Math.min(this.width / bbox.width, this.height / bbox.height),
         - (bbox.x + bbox.width / 2),
         - (bbox.y + bbox.height / 2),
-        true
+        true,
+        config.animate
       );
     } else {
-      scale = scale * this.baseScale;
-      this.setScale(scale, - centerX * this.defaultWidth, - centerY * this.defaultHeight, true);
+      if (config.lat && config.lng) {
+        point = this.latLngToPoint(config.lat, config.lng);
+        config.x = this.transX - point.x / this.scale;
+        config.y = this.transY - point.y / this.scale;
+      } else if (config.x && config.y) {
+        config.x *= -this.defaultWidth;
+        config.y *= -this.defaultHeight;
+      }
+      return this.setScale(config.scale * this.baseScale, config.x, config.y, true, config.animate);
     }
   },
 
@@ -637,8 +788,8 @@ jvm.WorldMap.prototype = {
   },
 
   /**
-   * Return the instance of WorldMap. Useful when instantiated as a jQuery plug-in.
-   * @returns {WorldMap}
+   * Return the instance of Map. Useful when instantiated as a jQuery plug-in.
+   * @returns {Map}
    */
   getMapObject: function(){
     return this;
@@ -657,15 +808,23 @@ jvm.WorldMap.prototype = {
         region,
         map = this;
 
+    this.regionLabelsGroup = this.regionLabelsGroup || this.canvas.addGroup();
+
     for (key in this.mapData.paths) {
-      region = this.canvas.addPath({
-        d: this.mapData.paths[key].path,
-        "data-code": key
-      }, jvm.$.extend(true, {}, this.params.regionStyle));
-      jvm.$(region.node).bind('selected', function(e, isSelected){
-        map.container.trigger('regionSelected.jvectormap', [jvm.$(this).attr('data-code'), isSelected, map.getSelectedRegions()]);
+      region = new jvm.Region({
+        map: this,
+        path: this.mapData.paths[key].path,
+        code: key,
+        style: jvm.$.extend(true, {}, this.params.regionStyle),
+        labelStyle: jvm.$.extend(true, {}, this.params.regionLabelStyle),
+        canvas: this.canvas,
+        labelsGroup: this.regionLabelsGroup,
+        label: this.canvas.mode != 'vml' ? (this.params.labels && this.params.labels.regions) : null
+      });
+
+      jvm.$(region.shape).bind('selected', function(e, isSelected){
+        map.container.trigger('regionSelected.jvectormap', [jvm.$(this.node).attr('data-code'), isSelected, map.getSelectedRegions()]);
       });
-      region.addClass('jvectormap-region jvectormap-element');
       this.regions[key] = {
         element: region,
         config: this.mapData.paths[key]
@@ -682,6 +841,7 @@ jvm.WorldMap.prototype = {
         map = this;
 
     this.markersGroup = this.markersGroup || this.canvas.addGroup();
+    this.markerLabelsGroup = this.markerLabelsGroup || this.canvas.addGroup();
 
     if (jvm.$.isArray(markers)) {
       markersArray = markers.slice();
@@ -696,14 +856,21 @@ jvm.WorldMap.prototype = {
       point = this.getMarkerPosition( markerConfig );
 
       if (point !== false) {
-        marker = this.canvas.addCircle({
-          "data-index": i,
+        marker = new jvm.Marker({
+          map: this,
+          style: jvm.$.extend(true, {}, this.params.markerStyle, {initial: markerConfig.style || {}}),
+          labelStyle: jvm.$.extend(true, {}, this.params.markerLabelStyle),
+          index: i,
           cx: point.x,
-          cy: point.y
-        }, jvm.$.extend(true, {}, this.params.markerStyle, {initial: markerConfig.style || {}}), this.markersGroup);
-        marker.addClass('jvectormap-marker jvectormap-element');
-        jvm.$(marker.node).bind('selected', function(e, isSelected){
-          map.container.trigger('markerSelected.jvectormap', [jvm.$(this).attr('data-index'), isSelected, map.getSelectedMarkers()]);
+          cy: point.y,
+          group: this.markersGroup,
+          canvas: this.canvas,
+          labelsGroup: this.markerLabelsGroup,
+          label: this.canvas.mode != 'vml' ? (this.params.labels && this.params.labels.markers) : null
+        });
+
+        jvm.$(marker.shape).bind('selected', function(e, isSelected){
+          map.container.trigger('markerSelected.jvectormap', [jvm.$(this.node).attr('data-index'), isSelected, map.getSelectedMarkers()]);
         });
         if (this.markers[i]) {
           this.removeMarkers([i]);
@@ -725,8 +892,20 @@ jvm.WorldMap.prototype = {
     }
   },
 
+  repositionLabels: function() {
+    var key;
+
+    for (key in this.regions) {
+      this.regions[key].element.updateLabelPosition();
+    }
+
+    for (key in this.markers) {
+      this.markers[key].element.updateLabelPosition();
+    }
+  },
+
   getMarkerPosition: function(markerConfig) {
-    if (jvm.WorldMap.maps[this.params.map].projection) {
+    if (jvm.Map.maps[this.params.map].projection) {
       return this.latLngToPoint.apply(this, markerConfig.latLng || [0, 0]);
     } else {
       return {
@@ -753,7 +932,9 @@ jvm.WorldMap.prototype = {
 
     for (i = 0; i < seriesData.length; i++) {
       values = {};
-      values[key] = seriesData[i];
+      if (typeof seriesData[i] !== 'undefined') {
+        values[key] = seriesData[i];
+      }
       data.push(values);
     }
     this.addMarkers(markers, data);
@@ -808,13 +989,10 @@ jvm.WorldMap.prototype = {
    */
   latLngToPoint: function(lat, lng) {
     var point,
-        proj = jvm.WorldMap.maps[this.params.map].projection,
+        proj = jvm.Map.maps[this.params.map].projection,
         centralMeridian = proj.centralMeridian,
-        width = this.width - this.baseTransX * 2 * this.baseScale,
-        height = this.height - this.baseTransY * 2 * this.baseScale,
         inset,
-        bbox,
-        scaleFactor = this.scale / this.baseScale;
+        bbox;
 
     if (lng < (-180 + centralMeridian)) {
       lng += 360;
@@ -844,9 +1022,9 @@ jvm.WorldMap.prototype = {
    * @param {Number} y Y-axis of point on map in pixels.
    */
   pointToLatLng: function(x, y) {
-    var proj = jvm.WorldMap.maps[this.params.map].projection,
+    var proj = jvm.Map.maps[this.params.map].projection,
         centralMeridian = proj.centralMeridian,
-        insets = jvm.WorldMap.maps[this.params.map].insets,
+        insets = jvm.Map.maps[this.params.map].insets,
         i,
         inset,
         bbox,
@@ -872,7 +1050,7 @@ jvm.WorldMap.prototype = {
   },
 
   getInsetForPoint: function(x, y){
-    var insets = jvm.WorldMap.maps[this.params.map].insets,
+    var insets = jvm.Map.maps[this.params.map].insets,
         i,
         bbox;
 
@@ -897,7 +1075,8 @@ jvm.WorldMap.prototype = {
       for (i = 0; i < this.params.series[key].length; i++) {
         this.series[key][i] = new jvm.DataSeries(
           this.params.series[key][i],
-          this[key]
+          this[key],
+          this
         );
       }
     }
@@ -907,21 +1086,25 @@ jvm.WorldMap.prototype = {
    * Gracefully remove the map and and all its accessories, unbind event handlers.
    */
   remove: function(){
-    this.label.remove();
+    this.tip.remove();
     this.container.remove();
     jvm.$(window).unbind('resize', this.onResize);
+    jvm.$('body').unbind('mouseup', this.onContainerMouseUp);
   }
 };
 
-jvm.WorldMap.maps = {};
-jvm.WorldMap.defaultParams = {
+jvm.Map.maps = {};
+jvm.Map.defaultParams = {
   map: 'world_mill_en',
   backgroundColor: '#505050',
   zoomButtons: true,
   zoomOnScroll: true,
+  zoomOnScrollSpeed: 3,
+  panOnDrag: true,
   zoomMax: 8,
   zoomMin: 1,
   zoomStep: 1.6,
+  zoomAnimate: true,
   regionsSelectable: false,
   markersSelectable: false,
   bindTouchEvents: true,
@@ -934,7 +1117,8 @@ jvm.WorldMap.defaultParams = {
       "stroke-opacity": 1
     },
     hover: {
-      "fill-opacity": 0.8
+      "fill-opacity": 0.8,
+      cursor: 'pointer'
     },
     selected: {
       fill: 'yellow'
@@ -942,6 +1126,18 @@ jvm.WorldMap.defaultParams = {
     selectedHover: {
     }
   },
+  regionLabelStyle: {
+    initial: {
+      'font-family': 'Verdana',
+      'font-size': '12',
+      'font-weight': 'bold',
+      cursor: 'default',
+      fill: 'black'
+    },
+    hover: {
+      cursor: 'pointer'
+    }
+  },
   markerStyle: {
     initial: {
       fill: 'grey',
@@ -953,25 +1149,38 @@ jvm.WorldMap.defaultParams = {
     },
     hover: {
       stroke: 'black',
-      "stroke-width": 2
+      "stroke-width": 2,
+      cursor: 'pointer'
     },
     selected: {
       fill: 'blue'
     },
     selectedHover: {
     }
+  },
+  markerLabelStyle: {
+    initial: {
+      'font-family': 'Verdana',
+      'font-size': '12',
+      'font-weight': 'bold',
+      cursor: 'default',
+      fill: 'black'
+    },
+    hover: {
+      cursor: 'pointer'
+    }
   }
 };
-jvm.WorldMap.apiEvents = {
-  onRegionLabelShow: 'regionLabelShow',
+jvm.Map.apiEvents = {
+  onRegionTipShow: 'regionTipShow',
   onRegionOver: 'regionOver',
   onRegionOut: 'regionOut',
   onRegionClick: 'regionClick',
   onRegionSelected: 'regionSelected',
-  onMarkerLabelShow: 'markerLabelShow',
+  onMarkerTipShow: 'markerTipShow',
   onMarkerOver: 'markerOver',
   onMarkerOut: 'markerOut',
   onMarkerClick: 'markerClick',
   onMarkerSelected: 'markerSelected',
   onViewportChange: 'viewportChange'
-};
+};