/**
   * @license Map plugin v0.1 for Highcharts
   *
   * (c) 2011-2013 Torstein Hønsi
   *
   * License: www.highcharts.com/license
   */
  
  /* 
   * See www.highcharts.com/studies/world-map.htm for use case.
   *
   * To do:
   * - Optimize long variable names and alias adapter methods and Highcharts namespace variables
   * - Zoom and pan GUI
   */
  (function (Highcharts) {
  	var UNDEFINED,
  		Axis = Highcharts.Axis,
  		Chart = Highcharts.Chart,
  		Point = Highcharts.Point,
  		Pointer = Highcharts.Pointer,
  		each = Highcharts.each,
  		extend = Highcharts.extend,
  		merge = Highcharts.merge,
  		pick = Highcharts.pick,
  		numberFormat = Highcharts.numberFormat,
  		defaultOptions = Highcharts.getOptions(),
  		seriesTypes = Highcharts.seriesTypes,
  		plotOptions = defaultOptions.plotOptions,
  		wrap = Highcharts.wrap,
  		Color = Highcharts.Color,
  		noop = function () {};
  
  	
  
  	/*
  	 * Return an intermediate color between two colors, according to pos where 0
  	 * is the from color and 1 is the to color
  	 */
  	function tweenColors(from, to, pos) {
  		var i = 4,
  			rgba = [];
  
  		while (i--) {
  			rgba[i] = Math.round(
  				to.rgba[i] + (from.rgba[i] - to.rgba[i]) * (1 - pos)
  			);
  		}
  		return 'rgba(' + rgba.join(',') + ')';
  	}
  
  	// Set the default map navigation options
  	defaultOptions.mapNavigation = {
  		buttonOptions: {
  			align: 'right',
  			verticalAlign: 'bottom',
  			x: 0,
  			width: 18,
  			height: 18,
  			style: {
  				fontSize: '15px',
  				fontWeight: 'bold',
  				textAlign: 'center'
  			}
  		},
  		buttons: {
  			zoomIn: {
  				onclick: function () {
  					this.mapZoom(0.5);
  				},
  				text: '+',
  				y: -32
  			},
  			zoomOut: {
  				onclick: function () {
  					this.mapZoom(2);
  				},
  				text: '-',
  				y: 0
  			}
  		}
  		// enableButtons: false,
  		// enableTouchZoom: false,
  		// zoomOnDoubleClick: false,
  		// zoomOnMouseWheel: false
  
  	};
  	
  	/**
  	 * Utility for reading SVG paths directly.
  	 */
  	Highcharts.splitPath = function (path) {
  		var i;
  
  		// Move letters apart
  		path = path.replace(/([A-Za-z])/g, ' $1 ');
  		// Trim
  		path = path.replace(/^\s*/, "").replace(/\s*$/, "");
  		
  		// Split on spaces and commas
  		path = path.split(/[ ,]+/);
  		
  		// Parse numbers
  		for (i = 0; i < path.length; i++) {
  			if (!/[a-zA-Z]/.test(path[i])) {
  				path[i] = parseFloat(path[i]);
  			}
  		}
  		return path;
  	};
  
  	// A placeholder for map definitions
  	Highcharts.maps = {};
  	
  	/**
  	 * Override to use the extreme coordinates from the SVG shape, not the
  	 * data values
  	 */
  	wrap(Axis.prototype, 'getSeriesExtremes', function (proceed) {
  		var isXAxis = this.isXAxis,
  			dataMin,
  			dataMax,
  			xData = [];
  
  		// Remove the xData array and cache it locally so that the proceed method doesn't use it
  		each(this.series, function (series, i) {
  			if (series.useMapGeometry) {
  				xData[i] = series.xData;
  				series.xData = [];
  			}
  		});
  
  		// Call base to reach normal cartesian series (like mappoint)
  		proceed.call(this);
  
  		// Run extremes logic for map and mapline
  		dataMin = pick(this.dataMin, Number.MAX_VALUE);
  		dataMax = pick(this.dataMax, Number.MIN_VALUE);
  		each(this.series, function (series, i) {
  			if (series.useMapGeometry) {
  				dataMin = Math.min(dataMin, series[isXAxis ? 'minX' : 'minY']);
  				dataMax = Math.max(dataMax, series[isXAxis ? 'maxX' : 'maxY']);
  				series.xData = xData[i]; // Reset xData array
  			}
  		});
  		
  		this.dataMin = dataMin;
  		this.dataMax = dataMax;
  	});
  	
  	/**
  	 * Override axis translation to make sure the aspect ratio is always kept
  	 */
  	wrap(Axis.prototype, 'setAxisTranslation', function (proceed) {
  		var chart = this.chart,
  			mapRatio,
  			plotRatio = chart.plotWidth / chart.plotHeight,
  			isXAxis = this.isXAxis,
  			adjustedAxisLength,
  			xAxis = chart.xAxis[0],
  			padAxis;
  		
  		// Run the parent method
  		proceed.call(this);
  		
  		// On Y axis, handle both
  		if (chart.options.chart.type === 'map' && !isXAxis && xAxis.transA !== UNDEFINED) {
  			
  			// Use the same translation for both axes
  			this.transA = xAxis.transA = Math.min(this.transA, xAxis.transA);
  			
  			mapRatio = (xAxis.max - xAxis.min) / (this.max - this.min);
  			
  			// What axis to pad to put the map in the middle
  			padAxis = mapRatio > plotRatio ? this : xAxis;
  			
  			// Pad it
  			adjustedAxisLength = (padAxis.max - padAxis.min) * padAxis.transA;
  			padAxis.minPixelPadding = (padAxis.len - adjustedAxisLength) / 2;
  		}
  	});
  
  
  	//--- Start zooming and panning features
  
  	wrap(Chart.prototype, 'render', function (proceed) {
  		var chart = this,
  			mapNavigation = chart.options.mapNavigation;
  
  		proceed.call(chart);
  
  		// Render the plus and minus buttons
  		chart.renderMapNavigation();
  
  		// Add the double click event
  		if (mapNavigation.zoomOnDoubleClick) {
  			Highcharts.addEvent(chart.container, 'dblclick', function (e) {
  				chart.pointer.onContainerDblClick(e);
  			});
  		}
  
  		// Add the mousewheel event
  		if (mapNavigation.zoomOnMouseWheel) {
  			Highcharts.addEvent(chart.container, document.onmousewheel === undefined ? 'DOMMouseScroll' : 'mousewheel', function (e) {
  				chart.pointer.onContainerMouseWheel(e);
  			});
  		}
  	});
  
  	// Extend the Pointer
  	extend(Pointer.prototype, {
  
  		/**
  		 * The event handler for the doubleclick event
  		 */
  		onContainerDblClick: function (e) {
  			var chart = this.chart;
  
  			e = this.normalize(e);
  
  			if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
  				chart.mapZoom(
  					0.5,
  					chart.xAxis[0].toValue(e.chartX),
  					chart.yAxis[0].toValue(e.chartY)
  				);
  			}
  		},
  
  		/**
  		 * The event handler for the mouse scroll event
  		 */
  		onContainerMouseWheel: function (e) {
  			var chart = this.chart,
  				delta;
  
  			e = this.normalize(e);
  
  			// Firefox uses e.detail, WebKit and IE uses wheelDelta
  			delta = e.detail || -(e.wheelDelta / 120);
  			if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
  				chart.mapZoom(
  					delta > 0 ? 2 : 0.5,
  					chart.xAxis[0].toValue(e.chartX),
  					chart.yAxis[0].toValue(e.chartY)
  				);
  			}
  		}
  	});
  	// Implement the pinchType option
  	wrap(Pointer.prototype, 'init', function (proceed, chart, options) {
  
  		proceed.call(this, chart, options);
  
  		// Pinch status
  		if (options.mapNavigation.enableTouchZoom) {
  			this.pinchX = this.pinchHor = 
  				this.pinchY = this.pinchVert = true;
  		}
  	});
  
  	// Add events to the Chart object itself
  	extend(Chart.prototype, {
  		renderMapNavigation: function () {
  			var chart = this,
  				options = this.options.mapNavigation,
  				buttons = options.buttons,
  				n,
  				button,
  				buttonOptions,
  				outerHandler = function () { 
  					this.handler.call(chart); 
  				};
  
  			if (options.enableButtons) {
  				for (n in buttons) {
  					if (buttons.hasOwnProperty(n)) {
  						buttonOptions = merge(options.buttonOptions, buttons[n]);
  
  						button = chart.renderer.button(buttonOptions.text, 0, 0, outerHandler)
  							.attr({
  								width: buttonOptions.width,
  								height: buttonOptions.height
  							})
  							.css(buttonOptions.style)
  							.add();
  						button.handler = buttonOptions.onclick;
  						button.align(extend(buttonOptions, { width: button.width, height: button.height }), null, 'spacingBox');
  					}
  				}
  			}
  		},
  
  		/**
  		 * Fit an inner box to an outer. If the inner box overflows left or right, align it to the sides of the
  		 * outer. If it overflows both sides, fit it within the outer. This is a pattern that occurs more places
  		 * in Highcharts, perhaps it should be elevated to a common utility function.
  		 */
  		fitToBox: function (inner, outer) {
  			each([['x', 'width'], ['y', 'height']], function (dim) {
  				var pos = dim[0],
  					size = dim[1];
  				if (inner[pos] + inner[size] > outer[pos] + outer[size]) { // right overflow
  					if (inner[size] > outer[size]) { // the general size is greater, fit fully to outer
  						inner[size] = outer[size];
  						inner[pos] = outer[pos];
  					} else { // align right
  						inner[pos] = outer[pos] + outer[size] - inner[size];
  					}
  				}
  				if (inner[size] > outer[size]) {
  					inner[size] = outer[size];
  				}
  				if (inner[pos] < outer[pos]) {
  					inner[pos] = outer[pos];
  				}
  				
  			});
  
  			return inner;
  		},
  
  		/**
  		 * Zoom the map in or out by a certain amount. Less than 1 zooms in, greater than 1 zooms out.
  		 */
  		mapZoom: function (howMuch, centerXArg, centerYArg) {
  
  			if (this.isMapZooming) {
  				return;
  			}
  
  			var chart = this,
  				xAxis = chart.xAxis[0],
  				xRange = xAxis.max - xAxis.min,
  				centerX = pick(centerXArg, xAxis.min + xRange / 2),
  				newXRange = xRange * howMuch,
  				yAxis = chart.yAxis[0],
  				yRange = yAxis.max - yAxis.min,
  				centerY = pick(centerYArg, yAxis.min + yRange / 2),
  				newYRange = yRange * howMuch,
  				newXMin = centerX - newXRange / 2,
  				newYMin = centerY - newYRange / 2,
  				animation = pick(chart.options.chart.animation, true),
  				delay,
  				newExt = chart.fitToBox({
  					x: newXMin,
  					y: newYMin,
  					width: newXRange,
  					height: newYRange
  				}, {
  					x: xAxis.dataMin,
  					y: yAxis.dataMin,
  					width: xAxis.dataMax - xAxis.dataMin,
  					height: yAxis.dataMax - yAxis.dataMin
  				});
  
  			xAxis.setExtremes(newExt.x, newExt.x + newExt.width, false);
  			yAxis.setExtremes(newExt.y, newExt.y + newExt.height, false);
  
  			// Prevent zooming until this one is finished animating
  			delay = animation ? animation.duration || 500 : 0;
  			if (delay) {
  				chart.isMapZooming = true;
  				setTimeout(function () {
  					chart.isMapZooming = false;
  				}, delay);
  			}
  
  			chart.redraw();
  		}
  	});
  	
  	/**
  	 * Extend the default options with map options
  	 */
  	plotOptions.map = merge(plotOptions.scatter, {
  		animation: false, // makes the complex shapes slow
  		nullColor: '#F8F8F8',
  		borderColor: 'silver',
  		borderWidth: 1,
  		marker: null,
  		stickyTracking: false,
  		dataLabels: {
  			verticalAlign: 'middle'
  		},
  		turboThreshold: 0,
  		tooltip: {
  			followPointer: true,
  			pointFormat: '{point.name}: {point.y}<br/>'
  		},
  		states: {
  			normal: {
  				animation: true
  			}
  		}
  	});
  
  	var MapAreaPoint = Highcharts.extendClass(Point, {
  		/**
  		 * Extend the Point object to split paths
  		 */
  		applyOptions: function (options, x) {
  
  			var point = Point.prototype.applyOptions.call(this, options, x);
  
  			if (point.path && typeof point.path === 'string') {
  				point.path = point.options.path = Highcharts.splitPath(point.path);
  			}
  
  			return point;
  		},
  		/**
  		 * Stop the fade-out 
  		 */
  		onMouseOver: function () {
  			clearTimeout(this.colorInterval);
  			Point.prototype.onMouseOver.call(this);
  		},
  		/**
  		 * Custom animation for tweening out the colors. Animation reduces blinking when hovering
  		 * over islands and coast lines. We run a custom implementation of animation becuase we
  		 * need to be able to run this independently from other animations like zoom redraw. Also,
  		 * adding color animation to the adapters would introduce almost the same amount of code.
  		 */
  		onMouseOut: function () {
  			var point = this,
  				start = +new Date(),
  				normalColor = Color(point.options.color),
  				hoverColor = Color(point.pointAttr.hover.fill),
  				animation = point.series.options.states.normal.animation,
  				duration = animation && (animation.duration || 500);
  
  			if (duration && normalColor.rgba.length === 4 && hoverColor.rgba.length === 4) {
  				delete point.pointAttr[''].fill; // avoid resetting it in Point.setState
  
  				clearTimeout(point.colorInterval);
  				point.colorInterval = setInterval(function () {
  					var pos = (new Date() - start) / duration,
  						graphic = point.graphic;
  					if (pos > 1) {
  						pos = 1;
  					}
  					if (graphic) {
  						graphic.attr('fill', tweenColors(hoverColor, normalColor, pos));
  					}
  					if (pos >= 1) {
  						clearTimeout(point.colorInterval);
  					}
  				}, 13);
  			}
  			Point.prototype.onMouseOut.call(point);
  		}
  	});
  
  	/**
  	 * Add the series type
  	 */
  	seriesTypes.map = Highcharts.extendClass(seriesTypes.scatter, {
  		type: 'map',
  		pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
  			stroke: 'borderColor',
  			'stroke-width': 'borderWidth',
  			fill: 'color'
  		},
  		colorKey: 'y',
  		pointClass: MapAreaPoint,
  		trackerGroups: ['group', 'markerGroup', 'dataLabelsGroup'],
  		getSymbol: noop,
  		supportsDrilldown: true,
  		getExtremesFromAll: true,
  		useMapGeometry: true, // get axis extremes from paths, not values
  		init: function (chart) {
  			var series = this,
  				valueDecimals = chart.options.legend.valueDecimals,
  				legendItems = [],
  				name,
  				from,
  				to,
  				fromLabel,
  				toLabel,
  				colorRange,
  				valueRanges,
  				gradientColor,
  				grad,
  				tmpLabel,
  				horizontal = chart.options.legend.layout === 'horizontal';
  
  			
  			Highcharts.Series.prototype.init.apply(this, arguments);
  			colorRange = series.options.colorRange;
  			valueRanges = series.options.valueRanges;
  
  			if (valueRanges) {
  				each(valueRanges, function (range) {
  					from = range.from;
  					to = range.to;
  					
  					// Assemble the default name. This can be overridden by legend.options.labelFormatter
  					name = '';
  					if (from === UNDEFINED) {
  						name = '< ';
  					} else if (to === UNDEFINED) {
  						name = '> ';
  					}
  					if (from !== UNDEFINED) {
  						name += numberFormat(from, valueDecimals);
  					}
  					if (from !== UNDEFINED && to !== UNDEFINED) {
  						name += ' - ';
  					}
  					if (to !== UNDEFINED) {
  						name += numberFormat(to, valueDecimals);
  					}
  					
  					// Add a mock object to the legend items
  					legendItems.push(Highcharts.extend({
  						chart: series.chart,
  						name: name,
  						options: {},
  						drawLegendSymbol: seriesTypes.area.prototype.drawLegendSymbol,
  						visible: true,
  						setState: function () {},
  						setVisible: function () {}
  					}, range));
  				});
  				series.legendItems = legendItems;
  
  			} else if (colorRange) {
  
  				from = colorRange.from;
  				to = colorRange.to;
  				fromLabel = colorRange.fromLabel;
  				toLabel = colorRange.toLabel;
  
  				// Flips linearGradient variables and label text.
  				grad = horizontal ? [0, 0, 1, 0] : [0, 1, 0, 0]; 
  				if (!horizontal) {
  					tmpLabel = fromLabel;
  					fromLabel = toLabel;
  					toLabel = tmpLabel;
  				} 
  
  				// Creates color gradient.
  				gradientColor = {
  					linearGradient: { x1: grad[0], y1: grad[1], x2: grad[2], y2: grad[3] },
  					stops: 
  					[
  						[0, from],
  						[1, to]
  					]
  				};
  
  				// Add a mock object to the legend items.
  				legendItems = [{
  					chart: series.chart,
  					options: {},
  					fromLabel: fromLabel,
  					toLabel: toLabel,
  					color: gradientColor,
  					drawLegendSymbol: this.drawLegendSymbolGradient,
  					visible: true,
  					setState: function () {},
  					setVisible: function () {}
  				}];
  
  				series.legendItems = legendItems;
  			}
  		},
  
  		/**
  		 * If neither valueRanges nor colorRanges are defined, use basic area symbol.
  		 */
  		drawLegendSymbol: seriesTypes.area.prototype.drawLegendSymbol,
  
  		/**
  		 * Gets the series' symbol in the legend and extended legend with more information.
  		 * 
  		 * @param {Object} legend The legend object
  		 * @param {Object} item The series (this) or point
  		 */
  		drawLegendSymbolGradient: function (legend, item) {
  			var spacing = legend.options.symbolPadding,
  				padding = pick(legend.options.padding, 8),
  				positionY,
  				positionX,
  				gradientSize = this.chart.renderer.fontMetrics(legend.options.itemStyle.fontSize).h,
  				horizontal = legend.options.layout === 'horizontal',
  				box1,
  				box2,
  				box3,
  				rectangleLength = pick(legend.options.rectangleLength, 200);
  
  			// Set local variables based on option.
  			if (horizontal) {
  				positionY = -(spacing / 2);
  				positionX = 0;
  			} else {
  				positionY = -rectangleLength + legend.baseline - (spacing / 2);
  				positionX = padding + gradientSize;
  			}
  
  			// Creates the from text.
  			item.fromText = this.chart.renderer.text(
  					item.fromLabel,	// Text.
  					positionX,		// Lower left x.
  					positionY		// Lower left y.
  				).attr({
  					zIndex: 2
  				}).add(item.legendGroup);
  			box1 = item.fromText.getBBox();
  
  			// Creates legend symbol.
  			// Ternary changes variables based on option.
  			item.legendSymbol = this.chart.renderer.rect(
  				horizontal ? box1.x + box1.width + spacing : box1.x - gradientSize - spacing,		// Upper left x.
  				box1.y,																				// Upper left y.
  				horizontal ? rectangleLength : gradientSize,											// Width.
  				horizontal ? gradientSize : rectangleLength,										// Height.
  				2																					// Corner radius.
  			).attr({
  				zIndex: 1
  			}).add(item.legendGroup);
  			box2 = item.legendSymbol.getBBox();
  
  			// Creates the to text.
  			// Vertical coordinate changed based on option.
  			item.toText = this.chart.renderer.text(
  					item.toLabel,
  					box2.x + box2.width + spacing,
  					horizontal ? positionY : box2.y + box2.height - spacing
  				).attr({
  					zIndex: 2
  				}).add(item.legendGroup);
  			box3 = item.toText.getBBox();
  
  			// Changes legend box settings based on option.
  			if (horizontal) {
  				legend.offsetWidth = box1.width + box2.width + box3.width + (spacing * 2) + padding;
  				legend.itemY = gradientSize + padding;
  			} else {
  				legend.offsetWidth = Math.max(box1.width, box3.width) + (spacing) + box2.width + padding;
  				legend.itemY = box2.height + padding;
  				legend.itemX = spacing;
  			}
  		},
  
  		/**
  		 * Get the bounding box of all paths in the map combined.
  		 */
  		getBox: function (paths) {
  			var maxX = Number.MIN_VALUE, 
  				minX =  Number.MAX_VALUE, 
  				maxY = Number.MIN_VALUE, 
  				minY =  Number.MAX_VALUE;
  			
  			
  			// Find the bounding box
  			each(paths || this.options.data, function (point) {
  				var path = point.path,
  					i = path.length,
  					even = false, // while loop reads from the end
  					pointMaxX = Number.MIN_VALUE, 
  					pointMinX =  Number.MAX_VALUE, 
  					pointMaxY = Number.MIN_VALUE, 
  					pointMinY =  Number.MAX_VALUE;
  					
  				while (i--) {
  					if (typeof path[i] === 'number' && !isNaN(path[i])) {
  						if (even) { // even = x
  							pointMaxX = Math.max(pointMaxX, path[i]);
  							pointMinX = Math.min(pointMinX, path[i]);
  						} else { // odd = Y
  							pointMaxY = Math.max(pointMaxY, path[i]);
  							pointMinY = Math.min(pointMinY, path[i]);
  						}
  						even = !even;
  					}
  				}
  				// Cache point bounding box for use to position data labels
  				point._maxX = pointMaxX;
  				point._minX = pointMinX;
  				point._maxY = pointMaxY;
  				point._minY = pointMinY;
  
  				maxX = Math.max(maxX, pointMaxX);
  				minX = Math.min(minX, pointMinX);
  				maxY = Math.max(maxY, pointMaxY);
  				minY = Math.min(minY, pointMinY);
  			});
  			this.minY = minY;
  			this.maxY = maxY;
  			this.minX = minX;
  			this.maxX = maxX;
  			
  		},
  		
  		
  		
  		/**
  		 * Translate the path so that it automatically fits into the plot area box
  		 * @param {Object} path
  		 */
  		translatePath: function (path) {
  			
  			var series = this,
  				even = false, // while loop reads from the end
  				xAxis = series.xAxis,
  				yAxis = series.yAxis,
  				i;
  				
  			// Preserve the original
  			path = [].concat(path);
  				
  			// Do the translation
  			i = path.length;
  			while (i--) {
  				if (typeof path[i] === 'number') {
  					if (even) { // even = x
  						path[i] = Math.round(xAxis.translate(path[i]));
  					} else { // odd = Y
  						path[i] = Math.round(yAxis.len - yAxis.translate(path[i]));
  					}
  					even = !even;
  				}
  			}
  			return path;
  		},
  		
  		setData: function () {
  			Highcharts.Series.prototype.setData.apply(this, arguments);
  			this.getBox();
  		},
  		
  		/**
  		 * Add the path option for data points. Find the max value for color calculation.
  		 */
  		translate: function () {
  			var series = this,
  				dataMin = Number.MAX_VALUE,
  				dataMax = Number.MIN_VALUE;
  	
  			series.generatePoints();
  	
  			each(series.data, function (point) {
  				
  				point.shapeType = 'path';
  				point.shapeArgs = {
  					d: series.translatePath(point.path)
  				};
  				
  				// TODO: do point colors in drawPoints instead of point.init
  				if (typeof point.y === 'number') {
  					if (point.y > dataMax) {
  						dataMax = point.y;
  					} else if (point.y < dataMin) {
  						dataMin = point.y;
  					}
  				}
  			});
  			
  			series.translateColors(dataMin, dataMax);
  		},
  		
  		/**
  		 * In choropleth maps, the color is a result of the value, so this needs translation too
  		 */
  		translateColors: function (dataMin, dataMax) {
  			
  			var seriesOptions = this.options,
  				valueRanges = seriesOptions.valueRanges,
  				colorRange = seriesOptions.colorRange,
  				colorKey = this.colorKey,
  				from,
  				to;
  
  			if (colorRange) {
  				from = Color(colorRange.from);
  				to = Color(colorRange.to);
  			}
  			
  			each(this.data, function (point) {
  				var value = point[colorKey],
  					range,
  					color,
  					i,
  					pos;
  
  				if (valueRanges) {
  					i = valueRanges.length;
  					while (i--) {
  						range = valueRanges[i];
  						from = range.from;
  						to = range.to;
  						if ((from === UNDEFINED || value >= from) && (to === UNDEFINED || value <= to)) {
  							color = range.color;
  							break;
  						}
  							
  					}
  				} else if (colorRange && value !== undefined) {
  
  					pos = 1 - ((dataMax - value) / (dataMax - dataMin));
  					color = value === null ? seriesOptions.nullColor : tweenColors(from, to, pos);
  				}
  
  				if (color) {
  					point.color = null; // reset from previous drilldowns, use of the same data options
  					point.options.color = color;
  				}
  			});
  		},
  		
  		drawGraph: noop,
  		
  		/**
  		 * We need the points' bounding boxes in order to draw the data labels, so 
  		 * we skip it now and call if from drawPoints instead.
  		 */
  		drawDataLabels: noop,
  		
  		/** 
  		 * Use the drawPoints method of column, that is able to handle simple shapeArgs.
  		 * Extend it by assigning the tooltip position.
  		 */
  		drawPoints: function () {
  			var series = this,
  				xAxis = series.xAxis,
  				yAxis = series.yAxis,
  				colorKey = series.colorKey;
  			
  			// Make points pass test in drawing
  			each(series.data, function (point) {
  				point.plotY = 1; // pass null test in column.drawPoints
  				if (point[colorKey] === null) {
  					point[colorKey] = 0;
  					point.isNull = true;
  				}
  			});
  			
  			// Draw them
  			seriesTypes.column.prototype.drawPoints.apply(series);
  			
  			each(series.data, function (point) {
  
  				var dataLabels = point.dataLabels,
  					minX = xAxis.toPixels(point._minX, true),
  					maxX = xAxis.toPixels(point._maxX, true),
  					minY = yAxis.toPixels(point._minY, true),
  					maxY = yAxis.toPixels(point._maxY, true);
  
  				point.plotX = Math.round(minX + (maxX - minX) * pick(dataLabels && dataLabels.anchorX, 0.5));
  				point.plotY = Math.round(minY + (maxY - minY) * pick(dataLabels && dataLabels.anchorY, 0.5)); 
  				
  				
  				// Reset escaped null points
  				if (point.isNull) {
  					point[colorKey] = null;
  				}
  			});
  
  			// Now draw the data labels
  			Highcharts.Series.prototype.drawDataLabels.call(series);
  			
  		},
  
  		/**
  		 * Animate in the new series from the clicked point in the old series.
  		 * Depends on the drilldown.js module
  		 */
  		animateDrilldown: function (init) {
  			var toBox = this.chart.plotBox,
  				level = this.chart.drilldownLevels[this.chart.drilldownLevels.length - 1],
  				fromBox = level.bBox,
  				animationOptions = this.chart.options.drilldown.animation,
  				scale;
  				
  			if (!init) {
  
  				scale = Math.min(fromBox.width / toBox.width, fromBox.height / toBox.height);
  				level.shapeArgs = {
  					scaleX: scale,
  					scaleY: scale,
  					translateX: fromBox.x,
  					translateY: fromBox.y
  				};
  				
  				// TODO: Animate this.group instead
  				each(this.points, function (point) {
  
  					point.graphic
  						.attr(level.shapeArgs)
  						.animate({
  							scaleX: 1,
  							scaleY: 1,
  							translateX: 0,
  							translateY: 0
  						}, animationOptions);
  
  				});
  
  				delete this.animate;
  			}
  			
  		},
  
  		/**
  		 * When drilling up, pull out the individual point graphics from the lower series
  		 * and animate them into the origin point in the upper series.
  		 */
  		animateDrillupFrom: function (level) {
  			seriesTypes.column.prototype.animateDrillupFrom.call(this, level);
  		},
  
  
  		/**
  		 * When drilling up, keep the upper series invisible until the lower series has
  		 * moved into place
  		 */
  		animateDrillupTo: function (init) {
  			seriesTypes.column.prototype.animateDrillupTo.call(this, init);
  		}
  	});
  
  
  	// The mapline series type
  	plotOptions.mapline = merge(plotOptions.map, {
  		lineWidth: 1,
  		backgroundColor: 'none'
  	});
  	seriesTypes.mapline = Highcharts.extendClass(seriesTypes.map, {
  		type: 'mapline',
  		pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
  			stroke: 'color',
  			'stroke-width': 'lineWidth',
  			fill: 'backgroundColor'
  		},
  		drawLegendSymbol: seriesTypes.line.prototype.drawLegendSymbol
  	});
  
  	// The mappoint series type
  	plotOptions.mappoint = merge(plotOptions.scatter, {
  		dataLabels: {
  			enabled: true,
  			format: '{point.name}',
  			color: 'black',
  			style: {
  				textShadow: '0 0 5px white'
  			}
  		}
  	});
  	seriesTypes.mappoint = Highcharts.extendClass(seriesTypes.scatter, {
  		type: 'mappoint'
  	});
  	
  
  	
  	/**
  	 * A wrapper for Chart with all the default values for a Map
  	 */
  	Highcharts.Map = function (options, callback) {
  		
  		var hiddenAxis = {
  				endOnTick: false,
  				gridLineWidth: 0,
  				labels: {
  					enabled: false
  				},
  				lineWidth: 0,
  				minPadding: 0,
  				maxPadding: 0,
  				startOnTick: false,
  				tickWidth: 0,
  				title: null
  			},
  			seriesOptions;
  		
  		// Don't merge the data
  		seriesOptions = options.series;
  		options.series = null;
  		
  		options = merge({
  			chart: {
  				type: 'map',
  				panning: 'xy'
  			},
  			xAxis: hiddenAxis,
  			yAxis: merge(hiddenAxis, { reversed: true })	
  		},
  		options, // user's options
  	
  		{ // forced options
  			chart: {
  				inverted: false
  			}
  		});
  	
  		options.series = seriesOptions;
  	
  	
  		return new Highcharts.Chart(options, callback);
  	};
  }(Highcharts));