highcharts-rails 3.0.7 → 3.0.8

data/app/assets/javascripts/highcharts/adapters/mootools-adapter.js

@@ -1,8 +1,8 @@
 /**
- * @license Highcharts JS v3.0.7 (2013-10-24)
+ * @license Highcharts JS v3.0.8 (2014-01-09)
  * MooTools adapter
  *
- * (c) 2010-2013 Torstein Hønsi
+ * (c) 2010-2014 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */

data/app/assets/javascripts/highcharts/adapters/prototype-adapter.js

@@ -1,8 +1,8 @@
 /**
- * @license Highcharts JS v3.0.7 (2013-10-24)
+ * @license Highcharts JS v3.0.8 (2014-01-09)
  * Prototype adapter
  *
- * @author Michael Nelson, Torstein Hønsi.
+ * @author Michael Nelson, Torstein Honsi.
  *
  * Feel free to use and modify this script.
  * Highcharts license: www.highcharts.com/license.

data/app/assets/javascripts/highcharts/adapters/standalone-framework.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v3.0.7 (2013-10-24)
+ * @license Highcharts JS v3.0.8 (2014-01-09)
  *
  * Standalone Highcharts Framework
  *
@@ -159,7 +159,15 @@ function augment(obj) {
 
 					args.preventDefault = preventDefault;
 					args.target = target;
-					args.type = name; // #2297	
+
+					// If the type is not set, we're running a custom event (#2297). If it is set,
+					// we're running a browser event, and setting it will cause en error in
+					// IE8 (#2465).
+					if (!args.type) {
+						args.type = name;
+					}
+					
+
 					
 					// If the event handler return false, prevent the default handler from executing
 					if (fn.call(this, args) === false) {

data/app/assets/javascripts/highcharts/highcharts-more.js

@@ -2,9 +2,9 @@
 // @compilation_level SIMPLE_OPTIMIZATIONS
 
 /**
- * @license Highcharts JS v3.0.7 (2013-10-24)
+ * @license Highcharts JS v3.0.8 (2014-01-09)
  *
- * (c) 2009-2013 Torstein Hønsi
+ * (c) 2009-2014 Torstein Honsi
  *
  * License: www.highcharts.com/license
  */
@@ -28,12 +28,16 @@ var arrayMin = Highcharts.arrayMin,
 	wrap = Highcharts.wrap,
 	Axis = Highcharts.Axis,
 	Tick = Highcharts.Tick,
+	Point = Highcharts.Point,
+	Pointer = Highcharts.Pointer,
+	TrackerMixin = Highcharts.TrackerMixin,
+	CenteredSeriesMixin = Highcharts.CenteredSeriesMixin,
 	Series = Highcharts.Series,
-	colProto = seriesTypes.column.prototype,
 	math = Math,
 	mathRound = math.round,
 	mathFloor = math.floor,
 	mathMax = math.max,
+	Color = Highcharts.Color,
 	noop = function () {};/**
  * The Pane object allows options that are common to a set of X and Y axes.
  * 
@@ -217,6 +221,9 @@ var radialAxisMixin = {
 		
 		// Title or label offsets are not counted
 		this.chart.axisOffset[this.side] = 0;
+		
+		// Set the center array
+		this.center = this.pane.center = CenteredSeriesMixin.getCenter.call(this.pane);
 	},
 
 
@@ -292,7 +299,7 @@ var radialAxisMixin = {
 		if (this.isRadial) {
 
 			// Set the center array
-			this.center = this.pane.center = seriesTypes.pie.prototype.getCenter.call(this.pane);
+			this.center = this.pane.center = Highcharts.CenteredSeriesMixin.getCenter.call(this.pane);
 			
 			this.len = this.width = this.height = this.isCircular ?
 				this.center[2] * (this.endAngleRad - this.startAngleRad) / 2 :
@@ -652,7 +659,7 @@ defaultPlotOptions.arearange = merge(defaultPlotOptions.area, {
 /**
  * Add the series type
  */
-seriesTypes.arearange = Highcharts.extendClass(seriesTypes.area, {
+seriesTypes.arearange = extendClass(seriesTypes.area, {
 	type: 'arearange',
 	pointArrayMap: ['low', 'high'],
 	toYData: function (point) {
@@ -801,7 +808,10 @@ seriesTypes.arearange = Highcharts.extendClass(seriesTypes.area, {
 					dataLabelOptions.y = dataLabelOptions.yHigh;
 				}
 			}
-			seriesProto.drawDataLabels.apply(this, arguments); // #1209
+			
+			if (seriesProto.drawDataLabels) {
+				seriesProto.drawDataLabels.apply(this, arguments); // #1209
+			}
 			
 			// Step 2: reorganize and handle data labels for the lower values
 			i = length;
@@ -825,12 +835,16 @@ seriesTypes.arearange = Highcharts.extendClass(seriesTypes.area, {
 					dataLabelOptions.y = dataLabelOptions.yLow;
 				}
 			}
-			seriesProto.drawDataLabels.apply(this, arguments);
+			if (seriesProto.drawDataLabels) {
+				seriesProto.drawDataLabels.apply(this, arguments);
+			}
 		}
 	
 	},
 	
-	alignDataLabel: seriesTypes.column.prototype.alignDataLabel,
+	alignDataLabel: function () {
+		seriesTypes.column.prototype.alignDataLabel.apply(this, arguments);
+	},
 	
 	getSymbol: seriesTypes.column.prototype.getSymbol,
 	
@@ -847,61 +861,69 @@ defaultPlotOptions.areasplinerange = merge(defaultPlotOptions.arearange);
 seriesTypes.areasplinerange = extendClass(seriesTypes.arearange, {
 	type: 'areasplinerange',
 	getPointSpline: seriesTypes.spline.prototype.getPointSpline
-});/**
- * The ColumnRangeSeries class
- */
-defaultPlotOptions.columnrange = merge(defaultPlotOptions.column, defaultPlotOptions.arearange, {
-	lineWidth: 1,
-	pointRange: null
 });
 
-/**
- * ColumnRangeSeries object
- */
-seriesTypes.columnrange = extendClass(seriesTypes.arearange, {
-	type: 'columnrange',
+(function () {
+	
+	var colProto = seriesTypes.column.prototype;
+
 	/**
-	 * Translate data points from raw values x and y to plotX and plotY
+	 * The ColumnRangeSeries class
 	 */
-	translate: function () {
-		var series = this,
-			yAxis = series.yAxis,
-			plotHigh;
+	defaultPlotOptions.columnrange = merge(defaultPlotOptions.column, defaultPlotOptions.arearange, {
+		lineWidth: 1,
+		pointRange: null
+	});
 
-		colProto.translate.apply(series);
+	/**
+	 * ColumnRangeSeries object
+	 */
+	seriesTypes.columnrange = extendClass(seriesTypes.arearange, {
+		type: 'columnrange',
+		/**
+		 * Translate data points from raw values x and y to plotX and plotY
+		 */
+		translate: function () {
+			var series = this,
+				yAxis = series.yAxis,
+				plotHigh;
+
+			colProto.translate.apply(series);
+
+			// Set plotLow and plotHigh
+			each(series.points, function (point) {
+				var shapeArgs = point.shapeArgs,
+					minPointLength = series.options.minPointLength,
+					heightDifference,
+					height,
+					y;
+
+				point.plotHigh = plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
+				point.plotLow = point.plotY;
+
+				// adjust shape
+				y = plotHigh;
+				height = point.plotY - plotHigh;
+
+				if (height < minPointLength) {
+					heightDifference = (minPointLength - height);
+					height += heightDifference;
+					y -= heightDifference / 2;
+				}
+				shapeArgs.height = height;
+				shapeArgs.y = y;
+			});
+		},
+		trackerGroups: ['group', 'dataLabels'],
+		drawGraph: noop,
+		pointAttrToOptions: colProto.pointAttrToOptions,
+		drawPoints: colProto.drawPoints,
+		drawTracker: colProto.drawTracker,
+		animate: colProto.animate,
+		getColumnMetrics: colProto.getColumnMetrics
+	});
+}());
 
-		// Set plotLow and plotHigh
-		each(series.points, function (point) {
-			var shapeArgs = point.shapeArgs,
-				minPointLength = series.options.minPointLength,
-				heightDifference,
-				height,
-				y;
-
-			point.plotHigh = plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
-			point.plotLow = point.plotY;
-
-			// adjust shape
-			y = plotHigh;
-			height = point.plotY - plotHigh;
-
-			if (height < minPointLength) {
-				heightDifference = (minPointLength - height);
-				height += heightDifference;
-				y -= heightDifference / 2;
-			}
-			shapeArgs.height = height;
-			shapeArgs.y = y;
-		});
-	},
-	trackerGroups: ['group', 'dataLabels'],
-	drawGraph: noop,
-	pointAttrToOptions: colProto.pointAttrToOptions,
-	drawPoints: colProto.drawPoints,
-	drawTracker: colProto.drawTracker,
-	animate: colProto.animate,
-	getColumnMetrics: colProto.getColumnMetrics
-});
 /* 
  * The GaugeSeries class
  */
@@ -918,6 +940,7 @@ defaultPlotOptions.gauge = merge(defaultPlotOptions.line, {
 		borderWidth: 1,
 		borderColor: 'silver',
 		borderRadius: 3,
+		crop: false,
 		style: {
 			fontWeight: 'bold'
 		},
@@ -949,7 +972,7 @@ defaultPlotOptions.gauge = merge(defaultPlotOptions.line, {
 /**
  * Extend the point object
  */
-var GaugePoint = Highcharts.extendClass(Highcharts.Point, {
+var GaugePoint = extendClass(Point, {
 	/**
 	 * Don't do any hover colors or anything
 	 */
@@ -971,6 +994,7 @@ var GaugeSeries = {
 	angular: true, 
 	drawGraph: noop,
 	fixedBox: true,
+	forceDL: true,
 	trackerGroups: ['group', 'dataLabels'],
 	
 	/**
@@ -1113,14 +1137,27 @@ var GaugeSeries = {
 			this.options.zIndex, 
 			this.chart.seriesGroup
 		);
-		seriesTypes.pie.prototype.render.call(this);
+		Series.prototype.render.call(this);
 		this.group.clip(this.chart.clipRect);
 	},
 	
-	setData: seriesTypes.pie.prototype.setData,
-	drawTracker: seriesTypes.column.prototype.drawTracker
+	/**
+	 * Extend the basic setData method by running processData and generatePoints immediately,
+	 * in order to access the points from the legend.
+	 */
+	setData: function (data, redraw) {
+		Series.prototype.setData.call(this, data, false);
+		this.processData();
+		this.generatePoints();
+		if (pick(redraw, true)) {
+			this.chart.redraw();
+		}
+	},
+	drawTracker: TrackerMixin.drawTrackerPoint
 };
-seriesTypes.gauge = Highcharts.extendClass(seriesTypes.line, GaugeSeries);/* ****************************************************************************
+seriesTypes.gauge = extendClass(seriesTypes.line, GaugeSeries);
+
+/* ****************************************************************************
  * Start Box plot series code											      *
  *****************************************************************************/
 
@@ -1403,7 +1440,7 @@ defaultPlotOptions.errorbar = merge(defaultPlotOptions.boxplot, {
 	grouping: false,
 	linkedTo: ':previous',
 	tooltip: {
-		pointFormat: defaultPlotOptions.arearange.tooltip.pointFormat
+		pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.low}</b> - <b>{point.high}</b><br/>' 
 	},
 	whiskerWidth: null
 });
@@ -1714,6 +1751,7 @@ defaultPlotOptions.bubble = merge(defaultPlotOptions.scatter, {
 seriesTypes.bubble = extendClass(seriesTypes.scatter, {
 	type: 'bubble',
 	pointArrayMap: ['y', 'z'],
+	parallelArrays: ['x', 'y', 'z'],
 	trackerGroups: ['group', 'dataLabelsGroup'],
 	bubblePadding: true,
 	
@@ -1737,7 +1775,7 @@ seriesTypes.bubble = extendClass(seriesTypes.scatter, {
 		fill = fill || markerOptions.fillColor || this.color; 
 		
 		if (fillOpacity !== 1) {
-			fill = Highcharts.Color(fill).setOpacity(fillOpacity).get('rgba');
+			fill = Color(fill).setOpacity(fillOpacity).get('rgba');
 		}
 		return fill;
 	},
@@ -1773,7 +1811,7 @@ seriesTypes.bubble = extendClass(seriesTypes.scatter, {
 			pos = zRange > 0 ? // relative size, a number between 0 and 1
 				(zData[i] - zMin) / (zMax - zMin) : 
 				0.5;
-			if (sizeByArea) {
+			if (sizeByArea && pos >= 0) {
 				pos = Math.sqrt(pos);
 			}
 			radii.push(math.ceil(minSize + pos * (maxSize - minSize)) / 2);
@@ -1957,7 +1995,7 @@ Axis.prototype.beforePadding = function () {
 			
 			if (range > 0) {
 				while (i--) {
-					if (data[i] !== null) {
+					if (typeof data[i] === 'number') {
 						radius = series.radii[i];
 						pxMin = Math.min(((data[i] - min) * transA) - radius, pxMin);
 						pxMax = Math.max(((data[i] - min) * transA) + radius, pxMax);
@@ -1978,462 +2016,482 @@ Axis.prototype.beforePadding = function () {
 /* ****************************************************************************
  * End Bubble series code                                                     *
  *****************************************************************************/
-/**
- * Extensions for polar charts. Additionally, much of the geometry required for polar charts is
- * gathered in RadialAxes.js.
- * 
- */
 
-var seriesProto = Series.prototype,
-	pointerProto = Highcharts.Pointer.prototype;
+(function () {
 
+	/**
+	 * Extensions for polar charts. Additionally, much of the geometry required for polar charts is
+	 * gathered in RadialAxes.js.
+	 * 
+	 */
 
+	var seriesProto = Series.prototype,
+		pointerProto = Pointer.prototype,
+		colProto;
 
-/**
- * Translate a point's plotX and plotY from the internal angle and radius measures to 
- * true plotX, plotY coordinates
- */
-seriesProto.toXY = function (point) {
-	var xy,
-		chart = this.chart,
-		plotX = point.plotX,
-		plotY = point.plotY;
+	/**
+	 * Translate a point's plotX and plotY from the internal angle and radius measures to 
+	 * true plotX, plotY coordinates
+	 */
+	seriesProto.toXY = function (point) {
+		var xy,
+			chart = this.chart,
+			plotX = point.plotX,
+			plotY = point.plotY;
 	
-	// Save rectangular plotX, plotY for later computation
-	point.rectPlotX = plotX;
-	point.rectPlotY = plotY;
+		// Save rectangular plotX, plotY for later computation
+		point.rectPlotX = plotX;
+		point.rectPlotY = plotY;
 	
-	// Record the angle in degrees for use in tooltip
-	point.clientX = ((plotX / Math.PI * 180) + this.xAxis.pane.options.startAngle) % 360;
+		// Record the angle in degrees for use in tooltip
+		point.clientX = ((plotX / Math.PI * 180) + this.xAxis.pane.options.startAngle) % 360;
 	
-	// Find the polar plotX and plotY
-	xy = this.xAxis.postTranslate(point.plotX, this.yAxis.len - plotY);
-	point.plotX = point.polarPlotX = xy.x - chart.plotLeft;
-	point.plotY = point.polarPlotY = xy.y - chart.plotTop;
-};
+		// Find the polar plotX and plotY
+		xy = this.xAxis.postTranslate(point.plotX, this.yAxis.len - plotY);
+		point.plotX = point.polarPlotX = xy.x - chart.plotLeft;
+		point.plotY = point.polarPlotY = xy.y - chart.plotTop;
+	};
 
-/** 
- * Order the tooltip points to get the mouse capture ranges correct. #1915. 
- */
-seriesProto.orderTooltipPoints = function (points) {
-	if (this.chart.polar) {
-		points.sort(function (a, b) {
-			return a.clientX - b.clientX;
-		});
+	/** 
+	 * Order the tooltip points to get the mouse capture ranges correct. #1915. 
+	 */
+	seriesProto.orderTooltipPoints = function (points) {
+		if (this.chart.polar) {
+			points.sort(function (a, b) {
+				return a.clientX - b.clientX;
+			});
 
-		// Wrap mouse tracking around to capture movement on the segment to the left
-		// of the north point (#1469, #2093).
-		if (points[0]) {
-			points[0].wrappedClientX = points[0].clientX + 360;
-			points.push(points[0]);
+			// Wrap mouse tracking around to capture movement on the segment to the left
+			// of the north point (#1469, #2093).
+			if (points[0]) {
+				points[0].wrappedClientX = points[0].clientX + 360;
+				points.push(points[0]);
+			}
 		}
-	}
-};
+	};
 
 
-/**
- * Add some special init logic to areas and areasplines
- */
-function initArea(proceed, chart, options) {
-	proceed.call(this, chart, options);
-	if (this.chart.polar) {
-		
-		/**
-		 * Overridden method to close a segment path. While in a cartesian plane the area 
-		 * goes down to the threshold, in the polar chart it goes to the center.
-		 */
-		this.closeSegment = function (path) {
-			var center = this.xAxis.center;
-			path.push(
-				'L',
-				center[0],
-				center[1]
-			);			
-		};
+	/**
+	 * Add some special init logic to areas and areasplines
+	 */
+	function initArea(proceed, chart, options) {
+		proceed.call(this, chart, options);
+		if (this.chart.polar) {
+		
+			/**
+			 * Overridden method to close a segment path. While in a cartesian plane the area 
+			 * goes down to the threshold, in the polar chart it goes to the center.
+			 */
+			this.closeSegment = function (path) {
+				var center = this.xAxis.center;
+				path.push(
+					'L',
+					center[0],
+					center[1]
+				);			
+			};
 		
-		// Instead of complicated logic to draw an area around the inner area in a stack,
-		// just draw it behind
-		this.closedStacks = true;
+			// Instead of complicated logic to draw an area around the inner area in a stack,
+			// just draw it behind
+			this.closedStacks = true;
+		}
 	}
-}
-wrap(seriesTypes.area.prototype, 'init', initArea);
-wrap(seriesTypes.areaspline.prototype, 'init', initArea);
-		
 
-/**
- * Overridden method for calculating a spline from one point to the next
- */
-wrap(seriesTypes.spline.prototype, 'getPointSpline', function (proceed, segment, point, i) {
-	
-	var ret,
-		smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
-		denom = smoothing + 1,
-		plotX, 
-		plotY,
-		lastPoint,
-		nextPoint,
-		lastX,
-		lastY,
-		nextX,
-		nextY,
-		leftContX,
-		leftContY,
-		rightContX,
-		rightContY,
-		distanceLeftControlPoint,
-		distanceRightControlPoint,
-		leftContAngle,
-		rightContAngle,
-		jointAngle;
-		
-		
-	if (this.chart.polar) {
-		
-		plotX = point.plotX;
-		plotY = point.plotY;
-		lastPoint = segment[i - 1];
-		nextPoint = segment[i + 1];
+	if (seriesTypes.area) {		
+		wrap(seriesTypes.area.prototype, 'init', initArea);	
+	}
+	if (seriesTypes.areaspline) {		
+		wrap(seriesTypes.areaspline.prototype, 'init', initArea);			
+	}	
+
+	if (seriesTypes.spline) {
+		/**
+		 * Overridden method for calculating a spline from one point to the next
+		 */
+		wrap(seriesTypes.spline.prototype, 'getPointSpline', function (proceed, segment, point, i) {
+	
+			var ret,
+				smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
+				denom = smoothing + 1,
+				plotX, 
+				plotY,
+				lastPoint,
+				nextPoint,
+				lastX,
+				lastY,
+				nextX,
+				nextY,
+				leftContX,
+				leftContY,
+				rightContX,
+				rightContY,
+				distanceLeftControlPoint,
+				distanceRightControlPoint,
+				leftContAngle,
+				rightContAngle,
+				jointAngle;
+		
+		
+			if (this.chart.polar) {
+		
+				plotX = point.plotX;
+				plotY = point.plotY;
+				lastPoint = segment[i - 1];
+				nextPoint = segment[i + 1];
 			
-		// Connect ends
-		if (this.connectEnds) {
-			if (!lastPoint) {
-				lastPoint = segment[segment.length - 2]; // not the last but the second last, because the segment is already connected
-			}
-			if (!nextPoint) {
-				nextPoint = segment[1];
-			}	
-		}
+				// Connect ends
+				if (this.connectEnds) {
+					if (!lastPoint) {
+						lastPoint = segment[segment.length - 2]; // not the last but the second last, because the segment is already connected
+					}
+					if (!nextPoint) {
+						nextPoint = segment[1];
+					}	
+				}
 
-		// find control points
-		if (lastPoint && nextPoint) {
-		
-			lastX = lastPoint.plotX;
-			lastY = lastPoint.plotY;
-			nextX = nextPoint.plotX;
-			nextY = nextPoint.plotY;
-			leftContX = (smoothing * plotX + lastX) / denom;
-			leftContY = (smoothing * plotY + lastY) / denom;
-			rightContX = (smoothing * plotX + nextX) / denom;
-			rightContY = (smoothing * plotY + nextY) / denom;
-			distanceLeftControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
-			distanceRightControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
-			leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
-			rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
-			jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
+				// find control points
+				if (lastPoint && nextPoint) {
+		
+					lastX = lastPoint.plotX;
+					lastY = lastPoint.plotY;
+					nextX = nextPoint.plotX;
+					nextY = nextPoint.plotY;
+					leftContX = (smoothing * plotX + lastX) / denom;
+					leftContY = (smoothing * plotY + lastY) / denom;
+					rightContX = (smoothing * plotX + nextX) / denom;
+					rightContY = (smoothing * plotY + nextY) / denom;
+					distanceLeftControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
+					distanceRightControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
+					leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
+					rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
+					jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
 				
 				
-			// Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
-			if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
-				jointAngle -= Math.PI;
-			}
+					// Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
+					if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
+						jointAngle -= Math.PI;
+					}
 			
-			// Find the corrected control points for a spline straight through the point
-			leftContX = plotX + Math.cos(jointAngle) * distanceLeftControlPoint;
-			leftContY = plotY + Math.sin(jointAngle) * distanceLeftControlPoint;
-			rightContX = plotX + Math.cos(Math.PI + jointAngle) * distanceRightControlPoint;
-			rightContY = plotY + Math.sin(Math.PI + jointAngle) * distanceRightControlPoint;
+					// Find the corrected control points for a spline straight through the point
+					leftContX = plotX + Math.cos(jointAngle) * distanceLeftControlPoint;
+					leftContY = plotY + Math.sin(jointAngle) * distanceLeftControlPoint;
+					rightContX = plotX + Math.cos(Math.PI + jointAngle) * distanceRightControlPoint;
+					rightContY = plotY + Math.sin(Math.PI + jointAngle) * distanceRightControlPoint;
 			
-			// Record for drawing in next point
-			point.rightContX = rightContX;
-			point.rightContY = rightContY;
+					// Record for drawing in next point
+					point.rightContX = rightContX;
+					point.rightContY = rightContY;
 
-		}
+				}
 		
 		
-		// moveTo or lineTo
-		if (!i) {
-			ret = ['M', plotX, plotY];
-		} else { // curve from last point to this
-			ret = [
-				'C',
-				lastPoint.rightContX || lastPoint.plotX,
-				lastPoint.rightContY || lastPoint.plotY,
-				leftContX || plotX,
-				leftContY || plotY,
-				plotX,
-				plotY
-			];
-			lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
-		}
+				// moveTo or lineTo
+				if (!i) {
+					ret = ['M', plotX, plotY];
+				} else { // curve from last point to this
+					ret = [
+						'C',
+						lastPoint.rightContX || lastPoint.plotX,
+						lastPoint.rightContY || lastPoint.plotY,
+						leftContX || plotX,
+						leftContY || plotY,
+						plotX,
+						plotY
+					];
+					lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
+				}
 		
 		
-	} else {
-		ret = proceed.call(this, segment, point, i);
+			} else {
+				ret = proceed.call(this, segment, point, i);
+			}
+			return ret;
+		});
 	}
-	return ret;
-});
 
-/**
- * Extend translate. The plotX and plotY values are computed as if the polar chart were a
- * cartesian plane, where plotX denotes the angle in radians and (yAxis.len - plotY) is the pixel distance from
- * center. 
- */
-wrap(seriesProto, 'translate', function (proceed) {
+	/**
+	 * Extend translate. The plotX and plotY values are computed as if the polar chart were a
+	 * cartesian plane, where plotX denotes the angle in radians and (yAxis.len - plotY) is the pixel distance from
+	 * center. 
+	 */
+	wrap(seriesProto, 'translate', function (proceed) {
 		
-	// Run uber method
-	proceed.call(this);
+		// Run uber method
+		proceed.call(this);
 	
-	// Postprocess plot coordinates
-	if (this.chart.polar && !this.preventPostTranslate) {
-		var points = this.points,
-			i = points.length;
-		while (i--) {
-			// Translate plotX, plotY from angle and radius to true plot coordinates
-			this.toXY(points[i]);
+		// Postprocess plot coordinates
+		if (this.chart.polar && !this.preventPostTranslate) {
+			var points = this.points,
+				i = points.length;
+			while (i--) {
+				// Translate plotX, plotY from angle and radius to true plot coordinates
+				this.toXY(points[i]);
+			}
 		}
-	}
-});
+	});
 
-/** 
- * Extend getSegmentPath to allow connecting ends across 0 to provide a closed circle in 
- * line-like series.
- */
-wrap(seriesProto, 'getSegmentPath', function (proceed, segment) {
+	/** 
+	 * Extend getSegmentPath to allow connecting ends across 0 to provide a closed circle in 
+	 * line-like series.
+	 */
+	wrap(seriesProto, 'getSegmentPath', function (proceed, segment) {
 		
-	var points = this.points;
+		var points = this.points;
 	
-	// Connect the path
-	if (this.chart.polar && this.options.connectEnds !== false && 
-			segment[segment.length - 1] === points[points.length - 1] && points[0].y !== null) {
-		this.connectEnds = true; // re-used in splines
-		segment = [].concat(segment, [points[0]]);
-	}
+		// Connect the path
+		if (this.chart.polar && this.options.connectEnds !== false && 
+				segment[segment.length - 1] === points[points.length - 1] && points[0].y !== null) {
+			this.connectEnds = true; // re-used in splines
+			segment = [].concat(segment, [points[0]]);
+		}
 	
-	// Run uber method
-	return proceed.call(this, segment);
+		// Run uber method
+		return proceed.call(this, segment);
 	
-});
-
+	});
 
-function polarAnimate(proceed, init) {
-	var chart = this.chart,
-		animation = this.options.animation,
-		group = this.group,
-		markerGroup = this.markerGroup,
-		center = this.xAxis.center,
-		plotLeft = chart.plotLeft,
-		plotTop = chart.plotTop,
-		attribs;
-
-	// Specific animation for polar charts
-	if (chart.polar) {
-		
-		// Enable animation on polar charts only in SVG. In VML, the scaling is different, plus animation
-		// would be so slow it would't matter.
-		if (chart.renderer.isSVG) {
 
-			if (animation === true) {
-				animation = {};
-			}
+	function polarAnimate(proceed, init) {
+		var chart = this.chart,
+			animation = this.options.animation,
+			group = this.group,
+			markerGroup = this.markerGroup,
+			center = this.xAxis.center,
+			plotLeft = chart.plotLeft,
+			plotTop = chart.plotTop,
+			attribs;
+
+		// Specific animation for polar charts
+		if (chart.polar) {
+		
+			// Enable animation on polar charts only in SVG. In VML, the scaling is different, plus animation
+			// would be so slow it would't matter.
+			if (chart.renderer.isSVG) {
+
+				if (animation === true) {
+					animation = {};
+				}
 	
-			// Initialize the animation
-			if (init) {
+				// Initialize the animation
+				if (init) {
 				
-				// Scale down the group and place it in the center
-				attribs = {
-					translateX: center[0] + plotLeft,
-					translateY: center[1] + plotTop,
-					scaleX: 0.001, // #1499
-					scaleY: 0.001
-				};
+					// Scale down the group and place it in the center
+					attribs = {
+						translateX: center[0] + plotLeft,
+						translateY: center[1] + plotTop,
+						scaleX: 0.001, // #1499
+						scaleY: 0.001
+					};
 					
-				group.attr(attribs);
-				if (markerGroup) {
-					markerGroup.attrSetters = group.attrSetters;
-					markerGroup.attr(attribs);
-				}
+					group.attr(attribs);
+					if (markerGroup) {
+						markerGroup.attrSetters = group.attrSetters;
+						markerGroup.attr(attribs);
+					}
 				
-			// Run the animation
-			} else {
-				attribs = {
-					translateX: plotLeft,
-					translateY: plotTop,
-					scaleX: 1,
-					scaleY: 1
-				};
-				group.animate(attribs, animation);
-				if (markerGroup) {
-					markerGroup.animate(attribs, animation);
-				}
+				// Run the animation
+				} else {
+					attribs = {
+						translateX: plotLeft,
+						translateY: plotTop,
+						scaleX: 1,
+						scaleY: 1
+					};
+					group.animate(attribs, animation);
+					if (markerGroup) {
+						markerGroup.animate(attribs, animation);
+					}
 				
-				// Delete this function to allow it only once
-				this.animate = null;
+					// Delete this function to allow it only once
+					this.animate = null;
+				}
 			}
-		}
 	
-	// For non-polar charts, revert to the basic animation
-	} else {
-		proceed.call(this, init);
-	} 
-}
-
-// Define the animate method for both regular series and column series and their derivatives
-wrap(seriesProto, 'animate', polarAnimate);
-wrap(colProto, 'animate', polarAnimate);
+		// For non-polar charts, revert to the basic animation
+		} else {
+			proceed.call(this, init);
+		} 
+	}
 
+	// Define the animate method for regular series
+	wrap(seriesProto, 'animate', polarAnimate);
 
-/**
- * Throw in a couple of properties to let setTooltipPoints know we're indexing the points
- * in degrees (0-360), not plot pixel width.
- */
-wrap(seriesProto, 'setTooltipPoints', function (proceed, renew) {
+	/**
+	 * Throw in a couple of properties to let setTooltipPoints know we're indexing the points
+	 * in degrees (0-360), not plot pixel width.
+	 */
+	wrap(seriesProto, 'setTooltipPoints', function (proceed, renew) {
 		
-	if (this.chart.polar) {
-		extend(this.xAxis, {
-			tooltipLen: 360 // degrees are the resolution unit of the tooltipPoints array
-		});	
-	}
+		if (this.chart.polar) {
+			extend(this.xAxis, {
+				tooltipLen: 360 // degrees are the resolution unit of the tooltipPoints array
+			});	
+		}
 	
-	// Run uber method
-	return proceed.call(this, renew);
-});
+		// Run uber method
+		return proceed.call(this, renew);
+	});
 
 
-/**
- * Extend the column prototype's translate method
- */
-wrap(colProto, 'translate', function (proceed) {
-		
-	var xAxis = this.xAxis,
-		len = this.yAxis.len,
-		center = xAxis.center,
-		startAngleRad = xAxis.startAngleRad,
-		renderer = this.chart.renderer,
-		start,
-		points,
-		point,
-		i;
-	
-	this.preventPostTranslate = true;
-	
-	// Run uber method
-	proceed.call(this);
-	
-	// Postprocess plot coordinates
-	if (xAxis.isRadial) {
-		points = this.points;
-		i = points.length;
-		while (i--) {
-			point = points[i];
-			start = point.barX + startAngleRad;
-			point.shapeType = 'path';
-			point.shapeArgs = {
-				d: renderer.symbols.arc(
-					center[0],
-					center[1],
-					len - point.plotY,
-					null, 
-					{
-						start: start,
-						end: start + point.pointWidth,
-						innerR: len - pick(point.yBottom, len)
-					}
-				)
-			};
-			this.toXY(point); // provide correct plotX, plotY for tooltip
-		}
-	}
-});
+	if (seriesTypes.column) {
 
+		colProto = seriesTypes.column.prototype;
+		/**
+		* Define the animate method for columnseries
+		*/
+		wrap(colProto, 'animate', polarAnimate);
 
-/**
- * Align column data labels outside the columns. #1199.
- */
-wrap(colProto, 'alignDataLabel', function (proceed, point, dataLabel, options, alignTo, isNew) {
-	
-	if (this.chart.polar) {
-		var angle = point.rectPlotX / Math.PI * 180,
-			align,
-			verticalAlign;
-		
-		// Align nicely outside the perimeter of the columns
-		if (options.align === null) {
-			if (angle > 20 && angle < 160) {
-				align = 'left'; // right hemisphere
-			} else if (angle > 200 && angle < 340) {
-				align = 'right'; // left hemisphere
-			} else {
-				align = 'center'; // top or bottom
+
+		/**
+		 * Extend the column prototype's translate method
+		 */
+		wrap(colProto, 'translate', function (proceed) {
+		
+			var xAxis = this.xAxis,
+				len = this.yAxis.len,
+				center = xAxis.center,
+				startAngleRad = xAxis.startAngleRad,
+				renderer = this.chart.renderer,
+				start,
+				points,
+				point,
+				i;
+	
+			this.preventPostTranslate = true;
+	
+			// Run uber method
+			proceed.call(this);
+	
+			// Postprocess plot coordinates
+			if (xAxis.isRadial) {
+				points = this.points;
+				i = points.length;
+				while (i--) {
+					point = points[i];
+					start = point.barX + startAngleRad;
+					point.shapeType = 'path';
+					point.shapeArgs = {
+						d: renderer.symbols.arc(
+							center[0],
+							center[1],
+							len - point.plotY,
+							null, 
+							{
+								start: start,
+								end: start + point.pointWidth,
+								innerR: len - pick(point.yBottom, len)
+							}
+						)
+					};
+					this.toXY(point); // provide correct plotX, plotY for tooltip
+				}
 			}
-			options.align = align;
-		}
-		if (options.verticalAlign === null) {
-			if (angle < 45 || angle > 315) {
-				verticalAlign = 'bottom'; // top part
-			} else if (angle > 135 && angle < 225) {
-				verticalAlign = 'top'; // bottom part
+		});
+
+
+		/**
+		 * Align column data labels outside the columns. #1199.
+		 */
+		wrap(colProto, 'alignDataLabel', function (proceed, point, dataLabel, options, alignTo, isNew) {
+	
+			if (this.chart.polar) {
+				var angle = point.rectPlotX / Math.PI * 180,
+					align,
+					verticalAlign;
+		
+				// Align nicely outside the perimeter of the columns
+				if (options.align === null) {
+					if (angle > 20 && angle < 160) {
+						align = 'left'; // right hemisphere
+					} else if (angle > 200 && angle < 340) {
+						align = 'right'; // left hemisphere
+					} else {
+						align = 'center'; // top or bottom
+					}
+					options.align = align;
+				}
+				if (options.verticalAlign === null) {
+					if (angle < 45 || angle > 315) {
+						verticalAlign = 'bottom'; // top part
+					} else if (angle > 135 && angle < 225) {
+						verticalAlign = 'top'; // bottom part
+					} else {
+						verticalAlign = 'middle'; // left or right
+					}
+					options.verticalAlign = verticalAlign;
+				}
+		
+				seriesProto.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
 			} else {
-				verticalAlign = 'middle'; // left or right
+				proceed.call(this, point, dataLabel, options, alignTo, isNew);
 			}
-			options.verticalAlign = verticalAlign;
-		}
-		
-		seriesProto.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
-	} else {
-		proceed.call(this, point, dataLabel, options, alignTo, isNew);
-	}
 	
-});
+		});		
+	}
 
-/**
- * Extend the mouse tracker to return the tooltip position index in terms of
- * degrees rather than pixels
- */
-wrap(pointerProto, 'getIndex', function (proceed, e) {
-	var ret,
-		chart = this.chart,
-		center,
-		x,
-		y;
+
+	/**
+	 * Extend the mouse tracker to return the tooltip position index in terms of
+	 * degrees rather than pixels
+	 */
+	wrap(pointerProto, 'getIndex', function (proceed, e) {
+		var ret,
+			chart = this.chart,
+			center,
+			x,
+			y;
 	
-	if (chart.polar) {
-		center = chart.xAxis[0].center;
-		x = e.chartX - center[0] - chart.plotLeft;
-		y = e.chartY - center[1] - chart.plotTop;
+		if (chart.polar) {
+			center = chart.xAxis[0].center;
+			x = e.chartX - center[0] - chart.plotLeft;
+			y = e.chartY - center[1] - chart.plotTop;
 		
-		ret = 180 - Math.round(Math.atan2(x, y) / Math.PI * 180);
+			ret = 180 - Math.round(Math.atan2(x, y) / Math.PI * 180);
 	
-	} else {
+		} else {
 	
-		// Run uber method
-		ret = proceed.call(this, e);
-	}
-	return ret;
-});
+			// Run uber method
+			ret = proceed.call(this, e);
+		}
+		return ret;
+	});
 
-/**
- * Extend getCoordinates to prepare for polar axis values
- */
-wrap(pointerProto, 'getCoordinates', function (proceed, e) {
-	var chart = this.chart,
-		ret = {
-			xAxis: [],
-			yAxis: []
-		};
+	/**
+	 * Extend getCoordinates to prepare for polar axis values
+	 */
+	wrap(pointerProto, 'getCoordinates', function (proceed, e) {
+		var chart = this.chart,
+			ret = {
+				xAxis: [],
+				yAxis: []
+			};
 	
-	if (chart.polar) {	
+		if (chart.polar) {	
 
-		each(chart.axes, function (axis) {
-			var isXAxis = axis.isXAxis,
-				center = axis.center,
-				x = e.chartX - center[0] - chart.plotLeft,
-				y = e.chartY - center[1] - chart.plotTop;
+			each(chart.axes, function (axis) {
+				var isXAxis = axis.isXAxis,
+					center = axis.center,
+					x = e.chartX - center[0] - chart.plotLeft,
+					y = e.chartY - center[1] - chart.plotTop;
 			
-			ret[isXAxis ? 'xAxis' : 'yAxis'].push({
-				axis: axis,
-				value: axis.translate(
-					isXAxis ?
-						Math.PI - Math.atan2(x, y) : // angle 
-						Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)), // distance from center
-					true
-				)
+				ret[isXAxis ? 'xAxis' : 'yAxis'].push({
+					axis: axis,
+					value: axis.translate(
+						isXAxis ?
+							Math.PI - Math.atan2(x, y) : // angle 
+							Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)), // distance from center
+						true
+					)
+				});
 			});
-		});
 		
-	} else {
-		ret = proceed.call(this, e);
-	}
+		} else {
+			ret = proceed.call(this, e);
+		}
 	
-	return ret;
-});
+		return ret;
+	});
+
+}());
+
 }(Highcharts));