highstock-rails 1.3.10 → 2.1.10

data/app/assets/javascripts/highstock/modules/funnel.js

@@ -6,8 +6,8 @@
 
  License: www.highcharts.com/license
 */
-(function(b){var d=b.getOptions(),v=d.plotOptions,q=b.seriesTypes,E=b.merge,D=function(){},A=b.each;v.funnel=E(v.pie,{center:["50%","50%"],width:"90%",neckWidth:"30%",height:"100%",neckHeight:"25%",reversed:!1,dataLabels:{connectorWidth:1,connectorColor:"#606060"},size:!0,states:{select:{color:"#C0C0C0",borderColor:"#000000",shadow:!1}}});q.funnel=b.extendClass(q.pie,{type:"funnel",animate:D,singularTooltips:!0,translate:function(){var a=function(j,a){return/%$/.test(j)?a*parseInt(j,10)/100:parseInt(j,
-10)},B=0,f=this.chart,c=this.options,g=c.reversed,b=f.plotWidth,n=f.plotHeight,o=0,f=c.center,h=a(f[0],b),d=a(f[0],n),q=a(c.width,b),k,r,e=a(c.height,n),s=a(c.neckWidth,b),t=a(c.neckHeight,n),w=e-t,a=this.data,x,y,v=c.dataLabels.position==="left"?1:0,z,l,C,p,i,u,m;this.getWidthAt=r=function(j){return j>e-t||e===t?s:s+(q-s)*((e-t-j)/(e-t))};this.getX=function(j,a){return h+(a?-1:1)*(r(g?n-j:j)/2+c.dataLabels.distance)};this.center=[h,d,e];this.centerX=h;A(a,function(a){B+=a.y});A(a,function(a){m=null;
-y=B?a.y/B:0;l=d-e/2+o*e;i=l+y*e;k=r(l);z=h-k/2;C=z+k;k=r(i);p=h-k/2;u=p+k;l>w?(z=p=h-s/2,C=u=h+s/2):i>w&&(m=i,k=r(w),p=h-k/2,u=p+k,i=w);g&&(l=e-l,i=e-i,m=m?e-m:null);x=["M",z,l,"L",C,l,u,i];m&&x.push(u,m,p,m);x.push(p,i,"Z");a.shapeType="path";a.shapeArgs={d:x};a.percentage=y*100;a.plotX=h;a.plotY=(l+(m||i))/2;a.tooltipPos=[h,a.plotY];a.slice=D;a.half=v;o+=y})},drawPoints:function(){var a=this,b=a.options,f=a.chart.renderer;A(a.data,function(c){var g=c.graphic,d=c.shapeArgs;g?g.animate(d):c.graphic=
-f.path(d).attr({fill:c.color,stroke:b.borderColor,"stroke-width":b.borderWidth}).add(a.group)})},sortByAngle:function(a){a.sort(function(a,b){return a.plotY-b.plotY})},drawDataLabels:function(){var a=this.data,b=this.options.dataLabels.distance,f,c,g,d=a.length,n,o;for(this.center[2]-=2*b;d--;)g=a[d],c=(f=g.half)?1:-1,o=g.plotY,n=this.getX(o,f),g.labelPos=[0,o,n+(b-5)*c,o,n+b*c,o,f?"right":"left",0];q.pie.prototype.drawDataLabels.call(this)}});d.plotOptions.pyramid=b.merge(d.plotOptions.funnel,{neckWidth:"0%",
-neckHeight:"0%",reversed:!0});b.seriesTypes.pyramid=b.extendClass(b.seriesTypes.funnel,{type:"pyramid"})})(Highcharts);
+(function(b){typeof module==="object"&&module.exports?module.exports=b:b(Highcharts)})(function(b){var q=b.getOptions(),w=q.plotOptions,r=b.seriesTypes,G=b.merge,E=function(){},B=b.each,F=b.pick;w.funnel=G(w.pie,{animation:!1,center:["50%","50%"],width:"90%",neckWidth:"30%",height:"100%",neckHeight:"25%",reversed:!1,dataLabels:{connectorWidth:1,connectorColor:"#606060"},size:!0,states:{select:{color:"#C0C0C0",borderColor:"#000000",shadow:!1}}});r.funnel=b.extendClass(r.pie,{type:"funnel",animate:E,
+translate:function(){var a=function(k,a){return/%$/.test(k)?a*parseInt(k,10)/100:parseInt(k,10)},b=0,e=this.chart,c=this.options,f=c.reversed,o=c.ignoreHiddenPoint,g=e.plotWidth,h=e.plotHeight,q=0,e=c.center,i=a(e[0],g),x=a(e[1],h),r=a(c.width,g),l,s,d=a(c.height,h),t=a(c.neckWidth,g),C=a(c.neckHeight,h),u=x-d/2+d-C,a=this.data,y,z,w=c.dataLabels.position==="left"?1:0,A,m,D,p,j,v,n;this.getWidthAt=s=function(k){var a=x-d/2;return k>u||d===C?t:t+(r-t)*(1-(k-a)/(d-C))};this.getX=function(k,a){return i+
+(a?-1:1)*(s(f?h-k:k)/2+c.dataLabels.distance)};this.center=[i,x,d];this.centerX=i;B(a,function(a){if(!o||a.visible!==!1)b+=a.y});B(a,function(a){n=null;z=b?a.y/b:0;m=x-d/2+q*d;j=m+z*d;l=s(m);A=i-l/2;D=A+l;l=s(j);p=i-l/2;v=p+l;m>u?(A=p=i-t/2,D=v=i+t/2):j>u&&(n=j,l=s(u),p=i-l/2,v=p+l,j=u);f&&(m=d-m,j=d-j,n=n?d-n:null);y=["M",A,m,"L",D,m,v,j];n&&y.push(v,n,p,n);y.push(p,j,"Z");a.shapeType="path";a.shapeArgs={d:y};a.percentage=z*100;a.plotX=i;a.plotY=(m+(n||j))/2;a.tooltipPos=[i,a.plotY];a.slice=E;a.half=
+w;if(!o||a.visible!==!1)q+=z})},drawPoints:function(){var a=this,b=a.options,e=a.chart.renderer;B(a.data,function(c){var f=c.options,o=c.graphic,g=c.shapeArgs;o?o.animate(g):c.graphic=e.path(g).attr({fill:c.color,stroke:F(f.borderColor,b.borderColor),"stroke-width":F(f.borderWidth,b.borderWidth)}).add(a.group)})},sortByAngle:function(a){a.sort(function(a,b){return a.plotY-b.plotY})},drawDataLabels:function(){var a=this.data,b=this.options.dataLabels.distance,e,c,f,o=a.length,g,h;for(this.center[2]-=
+2*b;o--;)f=a[o],c=(e=f.half)?1:-1,h=f.plotY,g=this.getX(h,e),f.labelPos=[0,h,g+(b-5)*c,h,g+b*c,h,e?"right":"left",0];r.pie.prototype.drawDataLabels.call(this)}});q.plotOptions.pyramid=b.merge(q.plotOptions.funnel,{neckWidth:"0%",neckHeight:"0%",reversed:!0});b.seriesTypes.pyramid=b.extendClass(b.seriesTypes.funnel,{type:"pyramid"})});

data/app/assets/javascripts/highstock/modules/funnel.src.js

@@ -0,0 +1,322 @@
+/**
+ * @license 
+ * Highcharts funnel module
+ *
+ * (c) 2010-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+/* eslint indent:0 */
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function (Highcharts) {
+	
+'use strict';
+
+// create shortcuts
+var defaultOptions = Highcharts.getOptions(),
+	defaultPlotOptions = defaultOptions.plotOptions,
+	seriesTypes = Highcharts.seriesTypes,
+	merge = Highcharts.merge,
+	noop = function () {},
+	each = Highcharts.each,
+	pick = Highcharts.pick;
+
+// set default options
+defaultPlotOptions.funnel = merge(defaultPlotOptions.pie, {
+	animation: false,
+	center: ['50%', '50%'],
+	width: '90%',
+	neckWidth: '30%',
+	height: '100%',
+	neckHeight: '25%',
+	reversed: false,
+	dataLabels: {
+		//position: 'right',
+		connectorWidth: 1,
+		connectorColor: '#606060'
+	},
+	size: true, // to avoid adapting to data label size in Pie.drawDataLabels
+	states: {
+		select: {
+			color: '#C0C0C0',
+			borderColor: '#000000',
+			shadow: false
+		}
+	}	
+});
+
+
+seriesTypes.funnel = Highcharts.extendClass(seriesTypes.pie, {
+	
+	type: 'funnel',
+	animate: noop,
+
+	/**
+	 * Overrides the pie translate method
+	 */
+	translate: function () {
+		
+		var 
+			// Get positions - either an integer or a percentage string must be given
+			getLength = function (length, relativeTo) {
+				return (/%$/).test(length) ?
+					relativeTo * parseInt(length, 10) / 100 :
+					parseInt(length, 10);
+			},
+			
+			sum = 0,
+			series = this,
+			chart = series.chart,
+			options = series.options,
+			reversed = options.reversed,
+			ignoreHiddenPoint = options.ignoreHiddenPoint,
+			plotWidth = chart.plotWidth,
+			plotHeight = chart.plotHeight,
+			cumulative = 0, // start at top
+			center = options.center,
+			centerX = getLength(center[0], plotWidth),
+			centerY = getLength(center[1], plotHeight),
+			width = getLength(options.width, plotWidth),
+			tempWidth,
+			getWidthAt,
+			height = getLength(options.height, plotHeight),
+			neckWidth = getLength(options.neckWidth, plotWidth),
+			neckHeight = getLength(options.neckHeight, plotHeight),
+			neckY = (centerY - height / 2) + height - neckHeight,
+			data = series.data,
+			path,
+			fraction,
+			half = options.dataLabels.position === 'left' ? 1 : 0,
+
+			x1, 
+			y1, 
+			x2, 
+			x3, 
+			y3, 
+			x4, 
+			y5;
+
+		// Return the width at a specific y coordinate
+		series.getWidthAt = getWidthAt = function (y) {
+			var top = (centerY - height / 2);
+			
+			return y > neckY || height === neckHeight ?
+				neckWidth :
+				neckWidth + (width - neckWidth) * (1 - (y - top) / (height - neckHeight));
+		};
+		series.getX = function (y, half) {
+			return centerX + (half ? -1 : 1) * ((getWidthAt(reversed ? plotHeight - y : y) / 2) + options.dataLabels.distance);
+		};
+
+		// Expose
+		series.center = [centerX, centerY, height];
+		series.centerX = centerX;
+
+		/*
+		 * Individual point coordinate naming:
+		 *
+		 * x1,y1 _________________ x2,y1
+		 *  \                         /
+		 *   \                       /
+		 *    \                     /
+		 *     \                   /
+		 *      \                 /
+		 *     x3,y3 _________ x4,y3
+		 *
+		 * Additional for the base of the neck:
+		 *
+		 *       |               |
+		 *       |               |
+		 *       |               |
+		 *     x3,y5 _________ x4,y5
+		 */
+
+
+
+
+		// get the total sum
+		each(data, function (point) {
+			if (!ignoreHiddenPoint || point.visible !== false) {
+				sum += point.y;
+			}
+		});
+
+		each(data, function (point) {
+			// set start and end positions
+			y5 = null;
+			fraction = sum ? point.y / sum : 0;
+			y1 = centerY - height / 2 + cumulative * height;
+			y3 = y1 + fraction * height;
+			//tempWidth = neckWidth + (width - neckWidth) * ((height - neckHeight - y1) / (height - neckHeight));
+			tempWidth = getWidthAt(y1);
+			x1 = centerX - tempWidth / 2;
+			x2 = x1 + tempWidth;
+			tempWidth = getWidthAt(y3);
+			x3 = centerX - tempWidth / 2;
+			x4 = x3 + tempWidth;
+
+			// the entire point is within the neck
+			if (y1 > neckY) {
+				x1 = x3 = centerX - neckWidth / 2;
+				x2 = x4 = centerX + neckWidth / 2;
+			
+			// the base of the neck
+			} else if (y3 > neckY) {
+				y5 = y3;
+
+				tempWidth = getWidthAt(neckY);
+				x3 = centerX - tempWidth / 2;
+				x4 = x3 + tempWidth;
+
+				y3 = neckY;
+			}
+
+			if (reversed) {
+				y1 = height - y1;
+				y3 = height - y3;
+				y5 = (y5 ? height - y5 : null);
+			}
+			// save the path
+			path = [
+				'M',
+				x1, y1,
+				'L',
+				x2, y1,
+				x4, y3
+			];
+			if (y5) {
+				path.push(x4, y5, x3, y5);
+			}
+			path.push(x3, y3, 'Z');
+
+			// prepare for using shared dr
+			point.shapeType = 'path';
+			point.shapeArgs = { d: path };
+
+
+			// for tooltips and data labels
+			point.percentage = fraction * 100;
+			point.plotX = centerX;
+			point.plotY = (y1 + (y5 || y3)) / 2;
+
+			// Placement of tooltips and data labels
+			point.tooltipPos = [
+				centerX,
+				point.plotY
+			];
+
+			// Slice is a noop on funnel points
+			point.slice = noop;
+			
+			// Mimicking pie data label placement logic
+			point.half = half;
+
+			if (!ignoreHiddenPoint || point.visible !== false) {
+				cumulative += fraction;
+			}
+		});		
+	},
+	/**
+	 * Draw a single point (wedge)
+	 * @param {Object} point The point object
+	 * @param {Object} color The color of the point
+	 * @param {Number} brightness The brightness relative to the color
+	 */
+	drawPoints: function () {
+		var series = this,
+			options = series.options,
+			chart = series.chart,
+			renderer = chart.renderer;
+
+		each(series.data, function (point) {
+			var pointOptions = point.options,
+				graphic = point.graphic,
+				shapeArgs = point.shapeArgs;
+
+			if (!graphic) { // Create the shapes				
+				point.graphic = renderer.path(shapeArgs)
+					.attr({
+						fill: point.color,
+						stroke: pick(pointOptions.borderColor, options.borderColor),
+						'stroke-width': pick(pointOptions.borderWidth, options.borderWidth)
+					})
+					.add(series.group);
+					
+			} else { // Update the shapes
+				graphic.animate(shapeArgs);
+			}
+		});
+	},
+
+	/**
+	 * Funnel items don't have angles (#2289)
+	 */
+	sortByAngle: function (points) {
+		points.sort(function (a, b) {
+			return a.plotY - b.plotY;
+		});
+	},
+	
+	/**
+	 * Extend the pie data label method
+	 */
+	drawDataLabels: function () {
+		var data = this.data,
+			labelDistance = this.options.dataLabels.distance,
+			leftSide,
+			sign,
+			point,
+			i = data.length,
+			x,
+			y;
+		
+		// In the original pie label anticollision logic, the slots are distributed
+		// from one labelDistance above to one labelDistance below the pie. In funnels
+		// we don't want this.
+		this.center[2] -= 2 * labelDistance;
+		
+		// Set the label position array for each point.
+		while (i--) {
+			point = data[i];
+			leftSide = point.half;
+			sign = leftSide ? 1 : -1;
+			y = point.plotY;
+			x = this.getX(y, leftSide);
+				
+			// set the anchor point for data labels
+			point.labelPos = [
+				0, // first break of connector
+				y, // a/a
+				x + (labelDistance - 5) * sign, // second break, right outside point shape
+				y, // a/a
+				x + labelDistance * sign, // landing point for connector
+				y, // a/a
+				leftSide ? 'right' : 'left', // alignment
+				0 // center angle
+			];
+		}
+		
+		seriesTypes.pie.prototype.drawDataLabels.call(this);
+	}
+
+});
+
+/** 
+ * Pyramid series type.
+ * A pyramid series is a special type of funnel, without neck and reversed by default.
+ */
+defaultOptions.plotOptions.pyramid = Highcharts.merge(defaultOptions.plotOptions.funnel, {        
+	neckWidth: '0%',
+	neckHeight: '0%',
+	reversed: true
+});
+Highcharts.seriesTypes.pyramid = Highcharts.extendClass(Highcharts.seriesTypes.funnel, {
+	type: 'pyramid'
+});
+
+}));

data/app/assets/javascripts/highstock/modules/heatmap.js

@@ -1,2 +1,23 @@
-(function(a){var c=a.seriesTypes,i=a.each;c.heatmap=a.extendClass(c.map,{useMapGeometry:!1,pointArrayMap:["y","value"],init:function(){c.map.prototype.init.apply(this,arguments);this.pointRange=this.options.colsize||1},translate:function(){var a=this.options,f=this.xAxis,c=this.yAxis;this.generatePoints();i(this.points,function(b){var d=(a.colsize||1)/2,e=(a.rowsize||1)/2,g=Math.round(f.len-f.translate(b.x-d,0,1,0,1)),d=Math.round(f.len-f.translate(b.x+d,0,1,0,1)),h=Math.round(c.translate(b.y-e,0,
-1,0,1)),e=Math.round(c.translate(b.y+e,0,1,0,1));b.plotY=1;b.shapeType="rect";b.shapeArgs={x:Math.min(g,d),y:Math.min(h,e),width:Math.abs(d-g),height:Math.abs(e-h)}});this.pointRange=a.colsize||1;this.translateColors()},animate:function(){},getBox:function(){},getExtremes:function(){a.Series.prototype.getExtremes.call(this,this.valueData);this.valueMin=this.dataMin;this.valueMax=this.dataMax;a.Series.prototype.getExtremes.call(this)}})})(Highcharts);
+/*
+ Highcharts JS v4.1.10 (2015-12-07)
+
+ (c) 2011-2014 Torstein Honsi
+
+ License: www.highcharts.com/license
+*/
+(function(d){typeof module==="object"&&module.exports?module.exports=d:d(Highcharts)})(function(d){var m=d.Axis,q=d.Chart,i=d.Color,x=d.Legend,s=d.LegendSymbolMixin,t=d.Series,y=d.Point,u=d.getOptions(),h=d.each,r=d.extend,v=d.extendClass,j=d.merge,k=d.pick,o=d.seriesTypes,w=d.wrap,n=function(){},p=d.ColorAxis=function(){this.isColorAxis=!0;this.init.apply(this,arguments)};r(p.prototype,m.prototype);r(p.prototype,{defaultColorAxisOptions:{lineWidth:0,minPadding:0,maxPadding:0,gridLineWidth:1,tickPixelInterval:72,
+startOnTick:!0,endOnTick:!0,offset:0,marker:{animation:{duration:50},color:"gray",width:0.01},labels:{overflow:"justify"},minColor:"#EFEFFF",maxColor:"#003875",tickLength:5},init:function(a,b){var c=a.options.legend.layout!=="vertical",f;f=j(this.defaultColorAxisOptions,{side:c?2:1,reversed:!c},b,{opposite:!c,showEmpty:!1,title:null,isColor:!0});m.prototype.init.call(this,a,f);b.dataClasses&&this.initDataClasses(b);this.initStops(b);this.horiz=c;this.zoomEnabled=!1},tweenColors:function(a,b,c){var f;
+!b.rgba.length||!a.rgba.length?a=b.input||"none":(a=a.rgba,b=b.rgba,f=b[3]!==1||a[3]!==1,a=(f?"rgba(":"rgb(")+Math.round(b[0]+(a[0]-b[0])*(1-c))+","+Math.round(b[1]+(a[1]-b[1])*(1-c))+","+Math.round(b[2]+(a[2]-b[2])*(1-c))+(f?","+(b[3]+(a[3]-b[3])*(1-c)):"")+")");return a},initDataClasses:function(a){var b=this,c=this.chart,f,e=0,l=this.options,g=a.dataClasses.length;this.dataClasses=f=[];this.legendItems=[];h(a.dataClasses,function(a,d){var h,a=j(a);f.push(a);if(!a.color)l.dataClassColor==="category"?
+(h=c.options.colors,a.color=h[e++],e===h.length&&(e=0)):a.color=b.tweenColors(i(l.minColor),i(l.maxColor),g<2?0.5:d/(g-1))})},initStops:function(a){this.stops=a.stops||[[0,this.options.minColor],[1,this.options.maxColor]];h(this.stops,function(a){a.color=i(a[1])})},setOptions:function(a){m.prototype.setOptions.call(this,a);this.options.crosshair=this.options.marker;this.coll="colorAxis"},setAxisSize:function(){var a=this.legendSymbol,b=this.chart,c,f,e;if(a)this.left=c=a.attr("x"),this.top=f=a.attr("y"),
+this.width=e=a.attr("width"),this.height=a=a.attr("height"),this.right=b.chartWidth-c-e,this.bottom=b.chartHeight-f-a,this.len=this.horiz?e:a,this.pos=this.horiz?c:f},toColor:function(a,b){var c,f=this.stops,e,l=this.dataClasses,g,d;if(l)for(d=l.length;d--;){if(g=l[d],e=g.from,f=g.to,(e===void 0||a>=e)&&(f===void 0||a<=f)){c=g.color;if(b)b.dataClass=d;break}}else{this.isLog&&(a=this.val2lin(a));c=1-(this.max-a)/(this.max-this.min||1);for(d=f.length;d--;)if(c>f[d][0])break;e=f[d]||f[d+1];f=f[d+1]||
+e;c=1-(f[0]-c)/(f[0]-e[0]||1);c=this.tweenColors(e.color,f.color,c)}return c},getOffset:function(){var a=this.legendGroup,b=this.chart.axisOffset[this.side];if(a){this.axisParent=a;m.prototype.getOffset.call(this);if(!this.added)this.added=!0,this.labelLeft=0,this.labelRight=this.width;this.chart.axisOffset[this.side]=b}},setLegendColor:function(){var a,b=this.options,c=this.reversed;a=c?1:0;c=c?0:1;a=this.horiz?[a,0,c,0]:[0,c,0,a];this.legendColor={linearGradient:{x1:a[0],y1:a[1],x2:a[2],y2:a[3]},
+stops:b.stops||[[0,b.minColor],[1,b.maxColor]]}},drawLegendSymbol:function(a,b){var c=a.padding,f=a.options,e=this.horiz,d=k(f.symbolWidth,e?200:12),g=k(f.symbolHeight,e?12:200),h=k(f.labelPadding,e?16:30),f=k(f.itemDistance,10);this.setLegendColor();b.legendSymbol=this.chart.renderer.rect(0,a.baseline-11,d,g).attr({zIndex:1}).add(b.legendGroup);this.legendItemWidth=d+c+(e?f:h);this.legendItemHeight=g+c+(e?h:0)},setState:n,visible:!0,setVisible:n,getSeriesExtremes:function(){var a;if(this.series.length)a=
+this.series[0],this.dataMin=a.valueMin,this.dataMax=a.valueMax},drawCrosshair:function(a,b){var c=b&&b.plotX,f=b&&b.plotY,e,d=this.pos,g=this.len;if(b)e=this.toPixels(b[b.series.colorKey]),e<d?e=d-2:e>d+g&&(e=d+g+2),b.plotX=e,b.plotY=this.len-e,m.prototype.drawCrosshair.call(this,a,b),b.plotX=c,b.plotY=f,this.cross&&this.cross.attr({fill:this.crosshair.color}).add(this.legendGroup)},getPlotLinePath:function(a,b,c,f,e){return typeof e==="number"?this.horiz?["M",e-4,this.top-6,"L",e+4,this.top-6,e,
+this.top,"Z"]:["M",this.left,e,"L",this.left-6,e+6,this.left-6,e-6,"Z"]:m.prototype.getPlotLinePath.call(this,a,b,c,f)},update:function(a,b){var c=this.chart,f=c.legend;h(this.series,function(a){a.isDirtyData=!0});if(a.dataClasses&&f.allItems)h(f.allItems,function(a){a.isDataClass&&a.legendGroup.destroy()}),c.isDirtyLegend=!0;c.options[this.coll]=j(this.userOptions,a);m.prototype.update.call(this,a,b);this.legendItem&&(this.setLegendColor(),f.colorizeItem(this,!0))},getDataClassLegendSymbols:function(){var a=
+this,b=this.chart,c=this.legendItems,f=b.options.legend,e=f.valueDecimals,l=f.valueSuffix||"",g;c.length||h(this.dataClasses,function(f,m){var i=!0,j=f.from,k=f.to;g="";j===void 0?g="< ":k===void 0&&(g="> ");j!==void 0&&(g+=d.numberFormat(j,e)+l);j!==void 0&&k!==void 0&&(g+=" - ");k!==void 0&&(g+=d.numberFormat(k,e)+l);c.push(r({chart:b,name:g,options:{},drawLegendSymbol:s.drawRectangle,visible:!0,setState:n,isDataClass:!0,setVisible:function(){i=this.visible=!i;h(a.series,function(a){h(a.points,
+function(a){a.dataClass===m&&a.setVisible(i)})});b.legend.colorizeItem(this,i)}},f))});return c},name:""});h(["fill","stroke"],function(a){d.addAnimSetter(a,function(b){b.elem.attr(a,p.prototype.tweenColors(i(b.start),i(b.end),b.pos))})});w(q.prototype,"getAxes",function(a){var b=this.options.colorAxis;a.call(this);this.colorAxis=[];b&&new p(this,b)});w(x.prototype,"getAllItems",function(a){var b=[],c=this.chart.colorAxis[0];c&&(c.options.dataClasses?b=b.concat(c.getDataClassLegendSymbols()):b.push(c),
+h(c.series,function(a){a.options.showInLegend=!1}));return b.concat(a.call(this))});q={pointAttrToOptions:{stroke:"borderColor","stroke-width":"borderWidth",fill:"color",dashstyle:"dashStyle"},pointArrayMap:["value"],axisTypes:["xAxis","yAxis","colorAxis"],optionalAxis:"colorAxis",trackerGroups:["group","markerGroup","dataLabelsGroup"],getSymbol:n,parallelArrays:["x","y","value"],colorKey:"value",translateColors:function(){var a=this,b=this.options.nullColor,c=this.colorAxis,f=this.colorKey;h(this.data,
+function(e){var d=e[f];if(d=e.options.color||(d===null?b:c&&d!==void 0?c.toColor(d,e):e.color||a.color))e.color=d})}};u.plotOptions.heatmap=j(u.plotOptions.scatter,{animation:!1,borderWidth:0,nullColor:"#F8F8F8",dataLabels:{formatter:function(){return this.point.value},inside:!0,verticalAlign:"middle",crop:!1,overflow:!1,padding:0},marker:null,pointRange:null,tooltip:{pointFormat:"{point.x}, {point.y}: {point.value}<br/>"},states:{normal:{animation:!0},hover:{halo:!1,brightness:0.2}}});o.heatmap=
+v(o.scatter,j(q,{type:"heatmap",pointArrayMap:["y","value"],hasPointSpecificOptions:!0,pointClass:v(y,{setVisible:function(a){var b=this,c=a?"show":"hide";h(["graphic","dataLabel"],function(a){if(b[a])b[a][c]()})}}),supportsDrilldown:!0,getExtremesFromAll:!0,directTouch:!0,init:function(){var a;o.scatter.prototype.init.apply(this,arguments);a=this.options;a.pointRange=k(a.pointRange,a.colsize||1);this.yAxis.axisPointRange=a.rowsize||1},translate:function(){var a=this.options,b=this.xAxis,c=this.yAxis,
+f=function(a,b,c){return Math.min(Math.max(b,a),c)};this.generatePoints();h(this.points,function(e){var d=(a.colsize||1)/2,g=(a.rowsize||1)/2,h=f(Math.round(b.len-b.translate(e.x-d,0,1,0,1)),0,b.len),d=f(Math.round(b.len-b.translate(e.x+d,0,1,0,1)),0,b.len),i=f(Math.round(c.translate(e.y-g,0,1,0,1)),0,c.len),g=f(Math.round(c.translate(e.y+g,0,1,0,1)),0,c.len);e.plotX=e.clientX=(h+d)/2;e.plotY=(i+g)/2;e.shapeType="rect";e.shapeArgs={x:Math.min(h,d),y:Math.min(i,g),width:Math.abs(d-h),height:Math.abs(g-
+i)}});this.translateColors();this.chart.hasRendered&&h(this.points,function(a){a.shapeArgs.fill=a.options.color||a.color})},drawPoints:o.column.prototype.drawPoints,animate:n,getBox:n,drawLegendSymbol:s.drawRectangle,getExtremes:function(){t.prototype.getExtremes.call(this,this.valueData);this.valueMin=this.dataMin;this.valueMax=this.dataMax;t.prototype.getExtremes.call(this)}}))});

data/app/assets/javascripts/highstock/modules/heatmap.src.js

@@ -0,0 +1,711 @@
+/**
+ * @license Highcharts JS v4.1.10 (2015-12-07)
+ *
+ * (c) 2011-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+/* eslint indent: [2, 4] */
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function (Highcharts) {
+
+
+    var UNDEFINED,
+        Axis = Highcharts.Axis,
+        Chart = Highcharts.Chart,
+        Color = Highcharts.Color,
+        Legend = Highcharts.Legend,
+        LegendSymbolMixin = Highcharts.LegendSymbolMixin,
+        Series = Highcharts.Series,
+        Point = Highcharts.Point,
+
+        defaultOptions = Highcharts.getOptions(),
+        each = Highcharts.each,
+        extend = Highcharts.extend,
+        extendClass = Highcharts.extendClass,
+        merge = Highcharts.merge,
+        pick = Highcharts.pick,
+        seriesTypes = Highcharts.seriesTypes,
+        wrap = Highcharts.wrap,
+        noop = function () {};
+
+    
+
+
+    /**
+     * The ColorAxis object for inclusion in gradient legends
+     */
+    var ColorAxis = Highcharts.ColorAxis = function () {
+        this.isColorAxis = true;
+        this.init.apply(this, arguments);
+    };
+    extend(ColorAxis.prototype, Axis.prototype);
+    extend(ColorAxis.prototype, {
+        defaultColorAxisOptions: {
+            lineWidth: 0,
+            minPadding: 0,
+            maxPadding: 0,
+            gridLineWidth: 1,
+            tickPixelInterval: 72,
+            startOnTick: true,
+            endOnTick: true,
+            offset: 0,
+            marker: {
+                animation: {
+                    duration: 50
+                },
+                color: 'gray',
+                width: 0.01
+            },
+            labels: {
+                overflow: 'justify'
+            },
+            minColor: '#EFEFFF',
+            maxColor: '#003875',
+            tickLength: 5
+        },
+        init: function (chart, userOptions) {
+            var horiz = chart.options.legend.layout !== 'vertical',
+                options;
+
+            // Build the options
+            options = merge(this.defaultColorAxisOptions, {
+                side: horiz ? 2 : 1,
+                reversed: !horiz
+            }, userOptions, {
+                opposite: !horiz,
+                showEmpty: false,
+                title: null,
+                isColor: true
+            });
+
+            Axis.prototype.init.call(this, chart, options);
+
+            // Base init() pushes it to the xAxis array, now pop it again
+            //chart[this.isXAxis ? 'xAxis' : 'yAxis'].pop();
+
+            // Prepare data classes
+            if (userOptions.dataClasses) {
+                this.initDataClasses(userOptions);
+            }
+            this.initStops(userOptions);
+
+            // Override original axis properties
+            this.horiz = horiz;
+            this.zoomEnabled = false;
+        },
+
+        /*
+         * Return an intermediate color between two colors, according to pos where 0
+         * is the from color and 1 is the to color.
+         * NOTE: Changes here should be copied
+         * to the same function in drilldown.src.js and solid-gauge-src.js.
+         */
+        tweenColors: function (from, to, pos) {
+            // Check for has alpha, because rgba colors perform worse due to lack of
+            // support in WebKit.
+            var hasAlpha,
+                ret;
+
+            // Unsupported color, return to-color (#3920)
+            if (!to.rgba.length || !from.rgba.length) {
+                ret = to.input || 'none';
+
+            // Interpolate
+            } else {
+                from = from.rgba;
+                to = to.rgba;
+                hasAlpha = (to[3] !== 1 || from[3] !== 1);
+                ret = (hasAlpha ? 'rgba(' : 'rgb(') +
+                    Math.round(to[0] + (from[0] - to[0]) * (1 - pos)) + ',' +
+                    Math.round(to[1] + (from[1] - to[1]) * (1 - pos)) + ',' +
+                    Math.round(to[2] + (from[2] - to[2]) * (1 - pos)) +
+                    (hasAlpha ? (',' + (to[3] + (from[3] - to[3]) * (1 - pos))) : '') + ')';
+            }
+            return ret;
+        },
+
+        initDataClasses: function (userOptions) {
+            var axis = this,
+                chart = this.chart,
+                dataClasses,
+                colorCounter = 0,
+                options = this.options,
+                len = userOptions.dataClasses.length;
+            this.dataClasses = dataClasses = [];
+            this.legendItems = [];
+
+            each(userOptions.dataClasses, function (dataClass, i) {
+                var colors;
+
+                dataClass = merge(dataClass);
+                dataClasses.push(dataClass);
+                if (!dataClass.color) {
+                    if (options.dataClassColor === 'category') {
+                        colors = chart.options.colors;
+                        dataClass.color = colors[colorCounter++];
+                        // loop back to zero
+                        if (colorCounter === colors.length) {
+                            colorCounter = 0;
+                        }
+                    } else {
+                        dataClass.color = axis.tweenColors(
+                            Color(options.minColor),
+                            Color(options.maxColor),
+                            len < 2 ? 0.5 : i / (len - 1) // #3219
+                        );
+                    }
+                }
+            });
+        },
+
+        initStops: function (userOptions) {
+            this.stops = userOptions.stops || [
+                [0, this.options.minColor],
+                [1, this.options.maxColor]
+            ];
+            each(this.stops, function (stop) {
+                stop.color = Color(stop[1]);
+            });
+        },
+
+        /**
+         * Extend the setOptions method to process extreme colors and color
+         * stops.
+         */
+        setOptions: function (userOptions) {
+            Axis.prototype.setOptions.call(this, userOptions);
+
+            this.options.crosshair = this.options.marker;
+            this.coll = 'colorAxis';
+        },
+
+        setAxisSize: function () {
+            var symbol = this.legendSymbol,
+                chart = this.chart,
+                x,
+                y,
+                width,
+                height;
+
+            if (symbol) {
+                this.left = x = symbol.attr('x');
+                this.top = y = symbol.attr('y');
+                this.width = width = symbol.attr('width');
+                this.height = height = symbol.attr('height');
+                this.right = chart.chartWidth - x - width;
+                this.bottom = chart.chartHeight - y - height;
+
+                this.len = this.horiz ? width : height;
+                this.pos = this.horiz ? x : y;
+            }
+        },
+
+        /**
+         * Translate from a value to a color
+         */
+        toColor: function (value, point) {
+            var pos,
+                stops = this.stops,
+                from,
+                to,
+                color,
+                dataClasses = this.dataClasses,
+                dataClass,
+                i;
+
+            if (dataClasses) {
+                i = dataClasses.length;
+                while (i--) {
+                    dataClass = dataClasses[i];
+                    from = dataClass.from;
+                    to = dataClass.to;
+                    if ((from === UNDEFINED || value >= from) && (to === UNDEFINED || value <= to)) {
+                        color = dataClass.color;
+                        if (point) {
+                            point.dataClass = i;
+                        }
+                        break;
+                    }
+                }
+
+            } else {
+
+                if (this.isLog) {
+                    value = this.val2lin(value);
+                }
+                pos = 1 - ((this.max - value) / ((this.max - this.min) || 1));
+                i = stops.length;
+                while (i--) {
+                    if (pos > stops[i][0]) {
+                        break;
+                    }
+                }
+                from = stops[i] || stops[i + 1];
+                to = stops[i + 1] || from;
+
+                // The position within the gradient
+                pos = 1 - (to[0] - pos) / ((to[0] - from[0]) || 1);
+
+                color = this.tweenColors(
+                    from.color,
+                    to.color,
+                    pos
+                );
+            }
+            return color;
+        },
+
+        /**
+         * Override the getOffset method to add the whole axis groups inside the legend.
+         */
+        getOffset: function () {
+            var group = this.legendGroup,
+                sideOffset = this.chart.axisOffset[this.side];
+
+            if (group) {
+
+                // Hook for the getOffset method to add groups to this parent group
+                this.axisParent = group;
+
+                // Call the base
+                Axis.prototype.getOffset.call(this);
+
+                // First time only
+                if (!this.added) {
+
+                    this.added = true;
+
+                    this.labelLeft = 0;
+                    this.labelRight = this.width;
+                }
+                // Reset it to avoid color axis reserving space
+                this.chart.axisOffset[this.side] = sideOffset;
+            }
+        },
+
+        /**
+         * Create the color gradient
+         */
+        setLegendColor: function () {
+            var grad,
+                horiz = this.horiz,
+                options = this.options,
+                reversed = this.reversed,
+                one = reversed ? 1 : 0,
+                zero = reversed ? 0 : 1;
+
+            grad = horiz ? [one, 0, zero, 0] : [0, zero, 0, one]; // #3190
+            this.legendColor = {
+                linearGradient: { x1: grad[0], y1: grad[1], x2: grad[2], y2: grad[3] },
+                stops: options.stops || [
+                    [0, options.minColor],
+                    [1, options.maxColor]
+                ]
+            };
+        },
+
+        /**
+         * The color axis appears inside the legend and has its own legend symbol
+         */
+        drawLegendSymbol: function (legend, item) {
+            var padding = legend.padding,
+                legendOptions = legend.options,
+                horiz = this.horiz,
+                width = pick(legendOptions.symbolWidth, horiz ? 200 : 12),
+                height = pick(legendOptions.symbolHeight, horiz ? 12 : 200),
+                labelPadding = pick(legendOptions.labelPadding, horiz ? 16 : 30),
+                itemDistance = pick(legendOptions.itemDistance, 10);
+
+            this.setLegendColor();
+
+            // Create the gradient
+            item.legendSymbol = this.chart.renderer.rect(
+                0,
+                legend.baseline - 11,
+                width,
+                height
+            ).attr({
+                zIndex: 1
+            }).add(item.legendGroup);
+
+            // Set how much space this legend item takes up
+            this.legendItemWidth = width + padding + (horiz ? itemDistance : labelPadding);
+            this.legendItemHeight = height + padding + (horiz ? labelPadding : 0);
+        },
+        /**
+         * Fool the legend
+         */
+        setState: noop,
+        visible: true,
+        setVisible: noop,
+        getSeriesExtremes: function () {
+            var series;
+            if (this.series.length) {
+                series = this.series[0];
+                this.dataMin = series.valueMin;
+                this.dataMax = series.valueMax;
+            }
+        },
+        drawCrosshair: function (e, point) {
+            var plotX = point && point.plotX,
+                plotY = point && point.plotY,
+                crossPos,
+                axisPos = this.pos,
+                axisLen = this.len;
+
+            if (point) {
+                crossPos = this.toPixels(point[point.series.colorKey]);
+                if (crossPos < axisPos) {
+                    crossPos = axisPos - 2;
+                } else if (crossPos > axisPos + axisLen) {
+                    crossPos = axisPos + axisLen + 2;
+                }
+
+                point.plotX = crossPos;
+                point.plotY = this.len - crossPos;
+                Axis.prototype.drawCrosshair.call(this, e, point);
+                point.plotX = plotX;
+                point.plotY = plotY;
+
+                if (this.cross) {
+                    this.cross
+                        .attr({
+                            fill: this.crosshair.color
+                        })
+                        .add(this.legendGroup);
+                }
+            }
+        },
+        getPlotLinePath: function (a, b, c, d, pos) {
+            return typeof pos === 'number' ? // crosshairs only // #3969 pos can be 0 !!
+                (this.horiz ?
+                    ['M', pos - 4, this.top - 6, 'L', pos + 4, this.top - 6, pos, this.top, 'Z'] :
+                    ['M', this.left, pos, 'L', this.left - 6, pos + 6, this.left - 6, pos - 6, 'Z']
+                ) :
+                Axis.prototype.getPlotLinePath.call(this, a, b, c, d);
+        },
+
+        update: function (newOptions, redraw) {
+            var chart = this.chart,
+                legend = chart.legend;
+
+            each(this.series, function (series) {
+                series.isDirtyData = true; // Needed for Axis.update when choropleth colors change
+            });
+
+            // When updating data classes, destroy old items and make sure new ones are created (#3207)
+            if (newOptions.dataClasses && legend.allItems) {
+                each(legend.allItems, function (item) {
+                    if (item.isDataClass) {
+                        item.legendGroup.destroy();
+                    }
+                });
+                chart.isDirtyLegend = true;
+            }
+
+            // Keep the options structure updated for export. Unlike xAxis and yAxis, the colorAxis is
+            // not an array. (#3207)
+            chart.options[this.coll] = merge(this.userOptions, newOptions);
+
+            Axis.prototype.update.call(this, newOptions, redraw);
+            if (this.legendItem) {
+                this.setLegendColor();
+                legend.colorizeItem(this, true);
+            }
+        },
+
+        /**
+         * Get the legend item symbols for data classes
+         */
+        getDataClassLegendSymbols: function () {
+            var axis = this,
+                chart = this.chart,
+                legendItems = this.legendItems,
+                legendOptions = chart.options.legend,
+                valueDecimals = legendOptions.valueDecimals,
+                valueSuffix = legendOptions.valueSuffix || '',
+                name;
+
+            if (!legendItems.length) {
+                each(this.dataClasses, function (dataClass, i) {
+                    var vis = true,
+                        from = dataClass.from,
+                        to = dataClass.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 += Highcharts.numberFormat(from, valueDecimals) + valueSuffix;
+                    }
+                    if (from !== UNDEFINED && to !== UNDEFINED) {
+                        name += ' - ';
+                    }
+                    if (to !== UNDEFINED) {
+                        name += Highcharts.numberFormat(to, valueDecimals) + valueSuffix;
+                    }
+
+                    // Add a mock object to the legend items
+                    legendItems.push(extend({
+                        chart: chart,
+                        name: name,
+                        options: {},
+                        drawLegendSymbol: LegendSymbolMixin.drawRectangle,
+                        visible: true,
+                        setState: noop,
+                        isDataClass: true,
+                        setVisible: function () {
+                            vis = this.visible = !vis;
+                            each(axis.series, function (series) {
+                                each(series.points, function (point) {
+                                    if (point.dataClass === i) {
+                                        point.setVisible(vis);
+                                    }
+                                });
+                            });
+
+                            chart.legend.colorizeItem(this, vis);
+                        }
+                    }, dataClass));
+                });
+            }
+            return legendItems;
+        },
+        name: '' // Prevents 'undefined' in legend in IE8
+    });
+
+    /**
+     * Handle animation of the color attributes directly
+     */
+    each(['fill', 'stroke'], function (prop) {
+        Highcharts.addAnimSetter(prop, function (fx) {
+            fx.elem.attr(prop, ColorAxis.prototype.tweenColors(Color(fx.start), Color(fx.end), fx.pos));
+        });
+    });
+
+    /**
+     * Extend the chart getAxes method to also get the color axis
+     */
+    wrap(Chart.prototype, 'getAxes', function (proceed) {
+
+        var options = this.options,
+            colorAxisOptions = options.colorAxis;
+
+        proceed.call(this);
+
+        this.colorAxis = [];
+        if (colorAxisOptions) {
+            new ColorAxis(this, colorAxisOptions); // eslint-disable-line no-new
+        }
+    });
+
+
+    /**
+     * Wrap the legend getAllItems method to add the color axis. This also removes the
+     * axis' own series to prevent them from showing up individually.
+     */
+    wrap(Legend.prototype, 'getAllItems', function (proceed) {
+        var allItems = [],
+            colorAxis = this.chart.colorAxis[0];
+
+        if (colorAxis) {
+
+            // Data classes
+            if (colorAxis.options.dataClasses) {
+                allItems = allItems.concat(colorAxis.getDataClassLegendSymbols());
+            // Gradient legend
+            } else {
+                // Add this axis on top
+                allItems.push(colorAxis);
+            }
+
+            // Don't add the color axis' series
+            each(colorAxis.series, function (series) {
+                series.options.showInLegend = false;
+            });
+        }
+
+        return allItems.concat(proceed.call(this));
+    });
+    /**
+     * Mixin for maps and heatmaps
+     */
+    var colorPointMixin = {
+        /**
+         * Set the visibility of a single point
+         */
+        setVisible: function (vis) {
+            var point = this,
+                method = vis ? 'show' : 'hide';
+
+            // Show and hide associated elements
+            each(['graphic', 'dataLabel'], function (key) {
+                if (point[key]) {
+                    point[key][method]();
+                }
+            });
+        }
+    };
+    var colorSeriesMixin = {
+
+        pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+            stroke: 'borderColor',
+            'stroke-width': 'borderWidth',
+            fill: 'color',
+            dashstyle: 'dashStyle'
+        },
+        pointArrayMap: ['value'],
+        axisTypes: ['xAxis', 'yAxis', 'colorAxis'],
+        optionalAxis: 'colorAxis',
+        trackerGroups: ['group', 'markerGroup', 'dataLabelsGroup'],
+        getSymbol: noop,
+        parallelArrays: ['x', 'y', 'value'],
+        colorKey: 'value',
+
+        /**
+         * In choropleth maps, the color is a result of the value, so this needs translation too
+         */
+        translateColors: function () {
+            var series = this,
+                nullColor = this.options.nullColor,
+                colorAxis = this.colorAxis,
+                colorKey = this.colorKey;
+
+            each(this.data, function (point) {
+                var value = point[colorKey],
+                    color;
+
+                color = point.options.color ||
+                    (value === null ? nullColor : (colorAxis && value !== undefined) ? colorAxis.toColor(value, point) : point.color || series.color);
+
+                if (color) {
+                    point.color = color;
+                }
+            });
+        }
+    };
+
+    /**
+     * Extend the default options with map options
+     */
+    defaultOptions.plotOptions.heatmap = merge(defaultOptions.plotOptions.scatter, {
+        animation: false,
+        borderWidth: 0,
+        nullColor: '#F8F8F8',
+        dataLabels: {
+            formatter: function () { // #2945
+                return this.point.value;
+            },
+            inside: true,
+            verticalAlign: 'middle',
+            crop: false,
+            overflow: false,
+            padding: 0 // #3837
+        },
+        marker: null,
+        pointRange: null, // dynamically set to colsize by default
+        tooltip: {
+            pointFormat: '{point.x}, {point.y}: {point.value}<br/>'
+        },
+        states: {
+            normal: {
+                animation: true
+            },
+            hover: {
+                halo: false,  // #3406, halo is not required on heatmaps
+                brightness: 0.2
+            }
+        }
+    });
+
+    // The Heatmap series type
+    seriesTypes.heatmap = extendClass(seriesTypes.scatter, merge(colorSeriesMixin, {
+        type: 'heatmap',
+        pointArrayMap: ['y', 'value'],
+        hasPointSpecificOptions: true,
+        pointClass: extendClass(Point, colorPointMixin),
+        supportsDrilldown: true,
+        getExtremesFromAll: true,
+        directTouch: true,
+
+        /**
+         * Override the init method to add point ranges on both axes.
+         */
+        init: function () {
+            var options;
+            seriesTypes.scatter.prototype.init.apply(this, arguments);
+
+            options = this.options;
+            options.pointRange = pick(options.pointRange, options.colsize || 1); // #3758, prevent resetting in setData
+            this.yAxis.axisPointRange = options.rowsize || 1; // general point range
+        },
+        translate: function () {
+            var series = this,
+                options = series.options,
+                xAxis = series.xAxis,
+                yAxis = series.yAxis,
+                between = function (x, a, b) {
+                    return Math.min(Math.max(a, x), b);
+                };
+
+            series.generatePoints();
+
+            each(series.points, function (point) {
+                var xPad = (options.colsize || 1) / 2,
+                    yPad = (options.rowsize || 1) / 2,
+                    x1 = between(Math.round(xAxis.len - xAxis.translate(point.x - xPad, 0, 1, 0, 1)), 0, xAxis.len),
+                    x2 = between(Math.round(xAxis.len - xAxis.translate(point.x + xPad, 0, 1, 0, 1)), 0, xAxis.len),
+                    y1 = between(Math.round(yAxis.translate(point.y - yPad, 0, 1, 0, 1)), 0, yAxis.len),
+                    y2 = between(Math.round(yAxis.translate(point.y + yPad, 0, 1, 0, 1)), 0, yAxis.len);
+
+                // Set plotX and plotY for use in K-D-Tree and more
+                point.plotX = point.clientX = (x1 + x2) / 2;
+                point.plotY = (y1 + y2) / 2;
+
+                point.shapeType = 'rect';
+                point.shapeArgs = {
+                    x: Math.min(x1, x2),
+                    y: Math.min(y1, y2),
+                    width: Math.abs(x2 - x1),
+                    height: Math.abs(y2 - y1)
+                };
+            });
+
+            series.translateColors();
+
+            // Make sure colors are updated on colorAxis update (#2893)
+            if (this.chart.hasRendered) {
+                each(series.points, function (point) {
+                    point.shapeArgs.fill = point.options.color || point.color; // #3311
+                });
+            }
+        },
+        drawPoints: seriesTypes.column.prototype.drawPoints,
+        animate: noop,
+        getBox: noop,
+        drawLegendSymbol: LegendSymbolMixin.drawRectangle,
+
+        getExtremes: function () {
+            // Get the extremes from the value data
+            Series.prototype.getExtremes.call(this, this.valueData);
+            this.valueMin = this.dataMin;
+            this.valueMax = this.dataMax;
+
+            // Get the extremes from the y data
+            Series.prototype.getExtremes.call(this);
+        }
+
+    }));
+
+
+}));