highstock-rails 1.3.10 → 2.1.10

data/app/assets/javascripts/highstock/modules/solid-gauge.js

@@ -0,0 +1,14 @@
+/*
+  Highstock JS v2.1.10 (2015-12-07)
+ Solid angular gauge module
+
+ (c) 2010-2014 Torstein Honsi
+
+ License: www.highcharts.com/license
+*/
+(function(a){typeof module==="object"&&module.exports?module.exports=a:a(Highcharts)})(function(a){var q=a.getOptions().plotOptions,r=a.pInt,s=a.pick,j=a.each,k;q.solidgauge=a.merge(q.gauge,{colorByPoint:!0});k={initDataClasses:function(b){var c=this,l=this.chart,d,g=0,e=this.options;this.dataClasses=d=[];j(b.dataClasses,function(f,h){var p,f=a.merge(f);d.push(f);if(!f.color)e.dataClassColor==="category"?(p=l.options.colors,f.color=p[g++],g===p.length&&(g=0)):f.color=c.tweenColors(a.Color(e.minColor),
+a.Color(e.maxColor),h/(b.dataClasses.length-1))})},initStops:function(b){this.stops=b.stops||[[0,this.options.minColor],[1,this.options.maxColor]];j(this.stops,function(b){b.color=a.Color(b[1])})},toColor:function(b,c){var a,d=this.stops,g,e=this.dataClasses,f,h;if(e)for(h=e.length;h--;){if(f=e[h],g=f.from,d=f.to,(g===void 0||b>=g)&&(d===void 0||b<=d)){a=f.color;if(c)c.dataClass=h;break}}else{this.isLog&&(b=this.val2lin(b));a=1-(this.max-b)/(this.max-this.min);for(h=d.length;h--;)if(a>d[h][0])break;
+g=d[h]||d[h+1];d=d[h+1]||g;a=1-(d[0]-a)/(d[0]-g[0]||1);a=this.tweenColors(g.color,d.color,a)}return a},tweenColors:function(b,c,a){var d;!c.rgba.length||!b.rgba.length?b=c.input||"none":(b=b.rgba,c=c.rgba,d=c[3]!==1||b[3]!==1,b=(d?"rgba(":"rgb(")+Math.round(c[0]+(b[0]-c[0])*(1-a))+","+Math.round(c[1]+(b[1]-c[1])*(1-a))+","+Math.round(c[2]+(b[2]-c[2])*(1-a))+(d?","+(c[3]+(b[3]-c[3])*(1-a)):"")+")");return b}};j(["fill","stroke"],function(b){a.addAnimSetter(b,function(c){c.elem.attr(b,k.tweenColors(a.Color(c.start),
+a.Color(c.end),c.pos))})});a.seriesTypes.solidgauge=a.extendClass(a.seriesTypes.gauge,{type:"solidgauge",pointAttrToOptions:{},bindAxes:function(){var b;a.seriesTypes.gauge.prototype.bindAxes.call(this);b=this.yAxis;a.extend(b,k);b.options.dataClasses&&b.initDataClasses(b.options);b.initStops(b.options)},drawPoints:function(){var b=this,c=b.yAxis,l=c.center,d=b.options,g=b.chart.renderer,e=d.overshoot,f=e&&typeof e==="number"?e/180*Math.PI:0;a.each(b.points,function(a){var e=a.graphic,i=c.startAngleRad+
+c.translate(a.y,null,null,null,!0),j=r(s(a.options.radius,d.radius,100))*l[2]/200,m=r(s(a.options.innerRadius,d.innerRadius,60))*l[2]/200,n=c.toColor(a.y,a),o=Math.min(c.startAngleRad,c.endAngleRad),k=Math.max(c.startAngleRad,c.endAngleRad);n==="none"&&(n=a.color||b.color||"none");if(n!=="none")a.color=n;i=Math.max(o-f,Math.min(k+f,i));d.wrap===!1&&(i=Math.max(o,Math.min(k,i)));o=Math.min(i,c.startAngleRad);i=Math.max(i,c.startAngleRad);i-o>2*Math.PI&&(i=o+2*Math.PI);a.shapeArgs=m={x:l[0],y:l[1],
+r:j,innerR:m,start:o,end:i,fill:n};a.startR=j;if(e){if(a=m.d,e.animate(m),a)m.d=a}else a.graphic=g.arc(m).attr({stroke:d.borderColor||"none","stroke-width":d.borderWidth||0,fill:n,"sweep-flag":0}).add(b.group)})},animate:function(b){if(!b)this.startAngleRad=this.yAxis.startAngleRad,a.seriesTypes.pie.prototype.animate.call(this,b)}})});

data/app/assets/javascripts/highstock/modules/solid-gauge.src.js

@@ -0,0 +1,273 @@
+/**
+ * @license  Highstock JS v2.1.10 (2015-12-07)
+ * Solid angular gauge module
+ *
+ * (c) 2010-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+(function (factory) {
+	if (typeof module === 'object' && module.exports) {
+		module.exports = factory;
+	} else {
+		factory(Highcharts);
+	}
+}(function (H) {
+	'use strict';
+
+	var defaultPlotOptions = H.getOptions().plotOptions,
+		pInt = H.pInt,
+		pick = H.pick,
+		each = H.each,
+		colorAxisMethods,
+		UNDEFINED;
+
+	// The default options
+	defaultPlotOptions.solidgauge = H.merge(defaultPlotOptions.gauge, {
+		colorByPoint: true
+	});
+
+
+	// These methods are defined in the ColorAxis object, and copied here.
+	// If we implement an AMD system we should make ColorAxis a dependency.
+	colorAxisMethods = {
+
+
+		initDataClasses: function (userOptions) {
+			var axis = this,
+				chart = this.chart,
+				dataClasses,
+				colorCounter = 0,
+				options = this.options;
+			this.dataClasses = dataClasses = [];
+
+			each(userOptions.dataClasses, function (dataClass, i) {
+				var colors;
+
+				dataClass = H.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(H.Color(options.minColor), H.Color(options.maxColor), i / (userOptions.dataClasses.length - 1));
+					}
+				}
+			});
+		},
+
+		initStops: function (userOptions) {
+			this.stops = userOptions.stops || [
+				[0, this.options.minColor],
+				[1, this.options.maxColor]
+			];
+			each(this.stops, function (stop) {
+				stop.color = H.Color(stop[1]);
+			});
+		},
+		/** 
+		 * 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));
+				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;
+		},
+		/*
+		 * Return an intermediate color between two colors, according to pos where 0
+		 * is the from color and 1 is the to color.
+		 */
+		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;
+		}
+	};
+
+	/**
+	 * Handle animation of the color attributes directly
+	 */
+	each(['fill', 'stroke'], function (prop) {
+		H.addAnimSetter(prop, function (fx) {
+			fx.elem.attr(prop, colorAxisMethods.tweenColors(H.Color(fx.start), H.Color(fx.end), fx.pos));
+		});
+	});
+
+	// The series prototype
+	H.seriesTypes.solidgauge = H.extendClass(H.seriesTypes.gauge, {
+		type: 'solidgauge',
+		pointAttrToOptions: {}, // #4301, don't inherit line marker's attribs
+		bindAxes: function () {
+			var axis;
+			H.seriesTypes.gauge.prototype.bindAxes.call(this);
+
+			axis = this.yAxis;
+			H.extend(axis, colorAxisMethods);
+
+			// Prepare data classes
+			if (axis.options.dataClasses) {
+				axis.initDataClasses(axis.options);
+			}
+			axis.initStops(axis.options);
+		},
+
+		/**
+		 * Draw the points where each point is one needle
+		 */
+		drawPoints: function () {
+			var series = this,
+				yAxis = series.yAxis,
+				center = yAxis.center,
+				options = series.options,
+				renderer = series.chart.renderer,
+				overshoot = options.overshoot,
+				overshootVal = overshoot && typeof overshoot === 'number' ? overshoot / 180 * Math.PI : 0;
+
+			H.each(series.points, function (point) {
+				var graphic = point.graphic,
+					rotation = yAxis.startAngleRad + yAxis.translate(point.y, null, null, null, true),
+					radius = (pInt(pick(point.options.radius, options.radius, 100)) * center[2]) / 200,
+					innerRadius = (pInt(pick(point.options.innerRadius, options.innerRadius, 60)) * center[2]) / 200,
+					shapeArgs,
+					d,
+					toColor = yAxis.toColor(point.y, point),
+					axisMinAngle = Math.min(yAxis.startAngleRad, yAxis.endAngleRad),
+					axisMaxAngle = Math.max(yAxis.startAngleRad, yAxis.endAngleRad),
+					minAngle,
+					maxAngle;
+
+				if (toColor === 'none') { // #3708
+					toColor = point.color || series.color || 'none';
+				}
+				if (toColor !== 'none') {
+					point.color = toColor;
+				}
+
+				// Handle overshoot and clipping to axis max/min
+				rotation = Math.max(axisMinAngle - overshootVal, Math.min(axisMaxAngle + overshootVal, rotation));
+
+				// Handle the wrap option
+				if (options.wrap === false) {
+					rotation = Math.max(axisMinAngle, Math.min(axisMaxAngle, rotation));
+				}
+
+				minAngle = Math.min(rotation, yAxis.startAngleRad);
+				maxAngle = Math.max(rotation, yAxis.startAngleRad);
+
+				if (maxAngle - minAngle > 2 * Math.PI) {
+					maxAngle = minAngle + 2 * Math.PI;
+				}
+
+				point.shapeArgs = shapeArgs = {
+					x: center[0],
+					y: center[1],
+					r: radius,
+					innerR: innerRadius,
+					start: minAngle,
+					end: maxAngle,
+					fill: toColor
+				};
+				point.startR = radius; // For PieSeries.animate
+
+				if (graphic) {
+					d = shapeArgs.d;
+					graphic.animate(shapeArgs);
+					if (d) {
+						shapeArgs.d = d; // animate alters it
+					}
+				} else {					
+					point.graphic = renderer.arc(shapeArgs)
+						.attr({
+							stroke: options.borderColor || 'none',
+							'stroke-width': options.borderWidth || 0,
+							fill: toColor,
+							'sweep-flag': 0
+						})
+						.add(series.group);
+				}
+			});
+		},
+
+		/**
+		 * Extend the pie slice animation by animating from start angle and up
+		 */
+		animate: function (init) {
+
+			if (!init) {
+				this.startAngleRad = this.yAxis.startAngleRad;
+				H.seriesTypes.pie.prototype.animate.call(this, init);
+			}
+		}
+	});
+
+}));

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

@@ -0,0 +1,30 @@
+/*
+ Highstock JS v2.1.10 (2015-12-07)
+
+ (c) 2014 Highsoft AS
+ Authors: Jon Arild Nygard / Oystein Moseng
+
+ License: www.highcharts.com/license
+*/
+(function(f){typeof module==="object"&&module.exports?module.exports=f:f(Highcharts)})(function(f){var j=f.seriesTypes,A=f.map,o=f.merge,t=f.extend,u=f.extendClass,v=f.getOptions().plotOptions,w=function(){},k=f.each,s=f.grep,i=f.pick,m=f.Series,B=f.stableSort,x=f.Color,C=function(a,b,c){var d,c=c||this;for(d in a)a.hasOwnProperty(d)&&b.call(c,a[d],d,a)},y=function(a,b,c,d){d=d||this;a=a||[];k(a,function(e,g){c=b.call(d,c,e,g,a)});return c},r=function(a,b,c){c=c||this;a=b.call(c,a);a!==!1&&r(a,b,
+c)};v.treemap=o(v.scatter,{showInLegend:!1,marker:!1,borderColor:"#E0E0E0",borderWidth:1,dataLabels:{enabled:!0,defer:!1,verticalAlign:"middle",formatter:function(){return this.point.name||this.point.id},inside:!0},tooltip:{headerFormat:"",pointFormat:"<b>{point.name}</b>: {point.node.val}</b><br/>"},layoutAlgorithm:"sliceAndDice",layoutStartingDirection:"vertical",alternateStartingDirection:!1,levelIsConstant:!0,states:{hover:{borderColor:"#A0A0A0",brightness:j.heatmap?0:0.1,shadow:!1}},drillUpButton:{position:{align:"right",
+x:-10,y:10}}});j.treemap=u(j.scatter,o({pointAttrToOptions:{},pointArrayMap:["value"],axisTypes:j.heatmap?["xAxis","yAxis","colorAxis"]:["xAxis","yAxis"],optionalAxis:"colorAxis",getSymbol:w,parallelArrays:["x","y","value","colorValue"],colorKey:"colorValue",translateColors:j.heatmap&&j.heatmap.prototype.translateColors},{type:"treemap",trackerGroups:["group","dataLabelsGroup"],pointClass:u(f.Point,{setVisible:j.pie.prototype.pointClass.prototype.setVisible}),getListOfParents:function(a,b){var c=
+y(a,function(a,c,b){c=i(c.parent,"");a[c]===void 0&&(a[c]=[]);a[c].push(b);return a},{});C(c,function(a,c,g){c!==""&&f.inArray(c,b)===-1&&(k(a,function(a){g[""].push(a)}),delete g[c])});return c},getTree:function(){var a,b=this;a=A(this.data,function(a){return a.id});a=b.getListOfParents(this.data,a);b.nodeMap=[];a=b.buildNode("",-1,0,a,null);r(this.nodeMap[this.rootNode],function(a){var d=!1,e=a.parent;a.visible=!0;if(e||e==="")d=b.nodeMap[e];return d});r(this.nodeMap[this.rootNode].children,function(a){var b=
+!1;k(a,function(a){a.visible=!0;a.children.length&&(b=(b||[]).concat(a.children))});return b});this.setTreeValues(a);return a},init:function(a,b){m.prototype.init.call(this,a,b);this.options.allowDrillToNode&&this.drillTo()},buildNode:function(a,b,c,d,e){var g=this,h=[],z=g.points[b],q;k(d[a]||[],function(b){q=g.buildNode(g.points[b].id,b,c+1,d,a);h.push(q)});b={id:a,i:b,children:h,level:c,parent:e,visible:!1};g.nodeMap[b.id]=b;if(z)z.node=b;return b},setTreeValues:function(a){var b=this,c=b.options,
+d=0,e=[],g,h=b.points[a.i];k(a.children,function(a){a=b.setTreeValues(a);e.push(a);a.ignore?r(a.children,function(a){var c=!1;k(a,function(a){t(a,{ignore:!0,isLeaf:!1,visible:!1});a.children.length&&(c=(c||[]).concat(a.children))});return c}):d+=a.val});B(e,function(a,c){return a.sortIndex-c.sortIndex});g=i(h&&h.value,d);t(a,{children:e,childrenTotal:d,ignore:!(i(h&&h.visible,!0)&&g>0),isLeaf:a.visible&&!d,levelDynamic:c.levelIsConstant?a.level:a.level-b.nodeMap[b.rootNode].level,name:i(h&&h.name,
+""),sortIndex:i(h&&h.sortIndex,-g),val:g});return a},calculateChildrenAreas:function(a,b){var c=this,d=c.options,e=this.levelMap[a.levelDynamic+1],g=i(c[e&&e.layoutAlgorithm]&&e.layoutAlgorithm,d.layoutAlgorithm),h=d.alternateStartingDirection,f=[],d=s(a.children,function(a){return!a.ignore});if(e&&e.layoutStartingDirection)b.direction=e.layoutStartingDirection==="vertical"?0:1;f=c[g](b,d);k(d,function(a,d){var e=f[d];a.values=o(e,{val:a.childrenTotal,direction:h?1-b.direction:b.direction});a.pointValues=
+o(e,{x:e.x/c.axisRatio,width:e.width/c.axisRatio});a.children.length&&c.calculateChildrenAreas(a,a.values)})},setPointValues:function(){var a=this.xAxis,b=this.yAxis;k(this.points,function(c){var d=c.node.pointValues,e,g,h;d?(e=Math.round(a.translate(d.x,0,0,0,1)),g=Math.round(a.translate(d.x+d.width,0,0,0,1)),h=Math.round(b.translate(d.y,0,0,0,1)),d=Math.round(b.translate(d.y+d.height,0,0,0,1)),c.shapeType="rect",c.shapeArgs={x:Math.min(e,g),y:Math.min(h,d),width:Math.abs(g-e),height:Math.abs(d-
+h)},c.plotX=c.shapeArgs.x+c.shapeArgs.width/2,c.plotY=c.shapeArgs.y+c.shapeArgs.height/2):(delete c.plotX,delete c.plotY)})},setColorRecursive:function(a,b){var c=this,d,e;if(a){d=c.points[a.i];e=c.levelMap[a.levelDynamic];b=i(d&&d.options.color,e&&e.color,b);if(d)d.color=b;a.children.length&&k(a.children,function(a){c.setColorRecursive(a,b)})}},algorithmGroup:function(a,b,c,d){this.height=a;this.width=b;this.plot=d;this.startDirection=this.direction=c;this.lH=this.nH=this.lW=this.nW=this.total=0;
+this.elArr=[];this.lP={total:0,lH:0,nH:0,lW:0,nW:0,nR:0,lR:0,aspectRatio:function(a,c){return Math.max(a/c,c/a)}};this.addElement=function(a){this.lP.total=this.elArr[this.elArr.length-1];this.total+=a;this.direction===0?(this.lW=this.nW,this.lP.lH=this.lP.total/this.lW,this.lP.lR=this.lP.aspectRatio(this.lW,this.lP.lH),this.nW=this.total/this.height,this.lP.nH=this.lP.total/this.nW,this.lP.nR=this.lP.aspectRatio(this.nW,this.lP.nH)):(this.lH=this.nH,this.lP.lW=this.lP.total/this.lH,this.lP.lR=this.lP.aspectRatio(this.lP.lW,
+this.lH),this.nH=this.total/this.width,this.lP.nW=this.lP.total/this.nH,this.lP.nR=this.lP.aspectRatio(this.lP.nW,this.nH));this.elArr.push(a)};this.reset=function(){this.lW=this.nW=0;this.elArr=[];this.total=0}},algorithmCalcPoints:function(a,b,c,d){var e,g,h,f,q=c.lW,n=c.lH,l=c.plot,i,j=0,p=c.elArr.length-1;b?(q=c.nW,n=c.nH):i=c.elArr[c.elArr.length-1];k(c.elArr,function(a){if(b||j<p)c.direction===0?(e=l.x,g=l.y,h=q,f=a/h):(e=l.x,g=l.y,f=n,h=a/f),d.push({x:e,y:g,width:h,height:f}),c.direction===
+0?l.y+=f:l.x+=h;j+=1});c.reset();c.direction===0?c.width-=q:c.height-=n;l.y=l.parent.y+(l.parent.height-c.height);l.x=l.parent.x+(l.parent.width-c.width);if(a)c.direction=1-c.direction;b||c.addElement(i)},algorithmLowAspectRatio:function(a,b,c){var d=[],e=this,g,f={x:b.x,y:b.y,parent:b},i=0,j=c.length-1,n=new this.algorithmGroup(b.height,b.width,b.direction,f);k(c,function(c){g=b.width*b.height*(c.val/b.val);n.addElement(g);n.lP.nR>n.lP.lR&&e.algorithmCalcPoints(a,!1,n,d,f);i===j&&e.algorithmCalcPoints(a,
+!0,n,d,f);i+=1});return d},algorithmFill:function(a,b,c){var d=[],e,f=b.direction,h=b.x,i=b.y,j=b.width,n=b.height,l,o,m,p;k(c,function(c){e=b.width*b.height*(c.val/b.val);l=h;o=i;f===0?(p=n,m=e/p,j-=m,h+=m):(m=j,p=e/m,n-=p,i+=p);d.push({x:l,y:o,width:m,height:p});a&&(f=1-f)});return d},strip:function(a,b){return this.algorithmLowAspectRatio(!1,a,b)},squarified:function(a,b){return this.algorithmLowAspectRatio(!0,a,b)},sliceAndDice:function(a,b){return this.algorithmFill(!0,a,b)},stripes:function(a,
+b){return this.algorithmFill(!1,a,b)},translate:function(){var a,b;m.prototype.translate.call(this);this.rootNode=i(this.options.rootId,"");this.levelMap=y(this.options.levels,function(a,b){a[b.level]=b;return a},{});b=this.tree=this.getTree();this.axisRatio=this.xAxis.len/this.yAxis.len;this.nodeMap[""].pointValues=a={x:0,y:0,width:100,height:100};this.nodeMap[""].values=a=o(a,{width:a.width*this.axisRatio,direction:this.options.layoutStartingDirection==="vertical"?0:1,val:b.val});this.calculateChildrenAreas(b,
+a);this.colorAxis?this.translateColors():this.options.colorByPoint||this.setColorRecursive(this.tree,void 0);b=this.nodeMap[this.rootNode].pointValues;this.xAxis.setExtremes(b.x,b.x+b.width,!1);this.yAxis.setExtremes(b.y,b.y+b.height,!1);this.xAxis.setScale();this.yAxis.setScale();this.setPointValues()},drawDataLabels:function(){var a=this,b=s(a.points,function(a){return a.node.visible}),c,d;k(b,function(b){d=a.levelMap[b.node.levelDynamic];c={style:{}};if(!b.node.isLeaf)c.enabled=!1;if(d&&d.dataLabels)c=
+o(c,d.dataLabels),a._hasPointLabels=!0;if(b.shapeArgs)c.style.width=b.shapeArgs.width;b.dlOptions=o(c,b.options.dataLabels)});m.prototype.drawDataLabels.call(this)},alignDataLabel:j.column.prototype.alignDataLabel,pointAttribs:function(a,b){var c=this.levelMap[a.node.levelDynamic]||{},d=this.options,e=b&&d.states[b]||{},c={stroke:a.borderColor||c.borderColor||e.borderColor||d.borderColor,"stroke-width":i(a.borderWidth,c.borderWidth,e.borderWidth,d.borderWidth),dashstyle:a.borderDashStyle||c.borderDashStyle||
+e.borderDashStyle||d.borderDashStyle,fill:a.color||this.color,zIndex:b==="hover"?1:0};if(a.node.level<=this.nodeMap[this.rootNode].level)c.fill="none",c["stroke-width"]=0;else if(a.node.isLeaf){if(b)c.fill=x(c.fill).brighten(e.brightness).get()}else c.fill=i(d.interactByLeaf,!d.allowDrillToNode)?"none":x(c.fill).setOpacity(b==="hover"?0.75:0.15).get();return c},drawPoints:function(){var a=this,b=s(a.points,function(a){return a.node.visible});k(b,function(c){var b="levelGroup-"+c.node.levelDynamic;
+a[b]||(a[b]=a.chart.renderer.g(b).attr({zIndex:1E3-c.node.levelDynamic}).add(a.group));c.group=a[b];c.pointAttr={"":a.pointAttribs(c),hover:a.pointAttribs(c,"hover"),select:{}}});j.column.prototype.drawPoints.call(this);a.options.allowDrillToNode&&k(b,function(b){var d;if(b.graphic)d=b.drillId=a.options.interactByLeaf?a.drillToByLeaf(b):a.drillToByGroup(b),b.graphic.css({cursor:d?"pointer":"default"})})},drillTo:function(){var a=this;f.addEvent(a,"click",function(b){var b=b.point,c=b.drillId,d;c&&
+(d=a.nodeMap[a.rootNode].name||a.rootNode,b.setState(""),a.drillToNode(c),a.showDrillUpButton(d))})},drillToByGroup:function(a){var b=!1;if(a.node.level-this.nodeMap[this.rootNode].level===1&&!a.node.isLeaf)b=a.id;return b},drillToByLeaf:function(a){var b=!1;if(a.node.parent!==this.rootNode&&a.node.isLeaf)for(a=a.node;!b;)if(a=this.nodeMap[a.parent],a.parent===this.rootNode)b=a.id;return b},drillUp:function(){var a=null;this.rootNode&&(a=this.nodeMap[this.rootNode],a=a.parent!==null?this.nodeMap[a.parent]:
+this.nodeMap[""]);if(a!==null)this.drillToNode(a.id),a.id===""?this.drillUpButton=this.drillUpButton.destroy():(a=this.nodeMap[a.parent],this.showDrillUpButton(a.name||a.id))},drillToNode:function(a){this.options.rootId=a;this.isDirty=!0;this.chart.redraw()},showDrillUpButton:function(a){var b=this,a=a||"< Back",c=b.options.drillUpButton,d,e;if(c.text)a=c.text;this.drillUpButton?this.drillUpButton.attr({text:a}).align():(e=(d=c.theme)&&d.states,this.drillUpButton=this.chart.renderer.button(a,null,
+null,function(){b.drillUp()},d,e&&e.hover,e&&e.select).attr({align:c.position.align,zIndex:9}).add().align(c.position,!1,c.relativeTo||"plotBox"))},buildKDTree:w,drawLegendSymbol:f.LegendSymbolMixin.drawRectangle,getExtremes:function(){m.prototype.getExtremes.call(this,this.colorValueData);this.valueMin=this.dataMin;this.valueMax=this.dataMax;m.prototype.getExtremes.call(this)},getExtremesFromAll:!0,bindAxes:function(){var a={endOnTick:!1,gridLineWidth:0,lineWidth:0,min:0,dataMin:0,minPadding:0,max:100,
+dataMax:100,maxPadding:0,startOnTick:!1,title:null,tickPositions:[]};m.prototype.bindAxes.call(this);f.extend(this.yAxis.options,a);f.extend(this.xAxis.options,a)}}))});

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

@@ -0,0 +1,868 @@
+/**
+ * @license Highstock JS v2.1.10 (2015-12-07)
+ *
+ * (c) 2014 Highsoft AS
+ * Authors: Jon Arild Nygard / Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+
+(function (factory) {
+	if (typeof module === 'object' && module.exports) {
+		module.exports = factory;
+	} else {
+		factory(Highcharts);
+	}
+}(function (H) {
+	var seriesTypes = H.seriesTypes,
+		map = H.map,
+		merge = H.merge,
+		extend = H.extend,
+		extendClass = H.extendClass,
+		defaultOptions = H.getOptions(),
+		plotOptions = defaultOptions.plotOptions,
+		noop = function () {
+		},
+		each = H.each,
+		grep = H.grep,
+		pick = H.pick,
+		Series = H.Series,
+		stableSort = H.stableSort,
+		Color = H.Color,
+		eachObject = function (list, func, context) {
+			var key;
+			context = context || this;
+			for (key in list) {
+				if (list.hasOwnProperty(key)) {
+					func.call(context, list[key], key, list);
+				}
+			}
+		},
+		reduce = function (arr, func, previous, context) {
+			context = context || this;
+			arr = arr || []; // @note should each be able to handle empty values automatically?
+			each(arr, function (current, i) {
+				previous = func.call(context, previous, current, i, arr);
+			});
+			return previous;
+		},
+		// @todo find correct name for this function. 
+		recursive = function (item, func, context) {
+			var next;
+			context = context || this;
+			next = func.call(context, item);
+			if (next !== false) {
+				recursive(next, func, context);
+			}
+		};
+
+	// Define default options
+	plotOptions.treemap = merge(plotOptions.scatter, {
+		showInLegend: false,
+		marker: false,
+		borderColor: '#E0E0E0',
+		borderWidth: 1,
+		dataLabels: {
+			enabled: true,
+			defer: false,
+			verticalAlign: 'middle',
+			formatter: function () { // #2945
+				return this.point.name || this.point.id;
+			},
+			inside: true
+		},
+		tooltip: {
+			headerFormat: '',
+			pointFormat: '<b>{point.name}</b>: {point.node.val}</b><br/>'
+		},
+		layoutAlgorithm: 'sliceAndDice',
+		layoutStartingDirection: 'vertical',
+		alternateStartingDirection: false,
+		levelIsConstant: true,
+		states: {
+			hover: {
+				borderColor: '#A0A0A0',
+				brightness: seriesTypes.heatmap ? 0 : 0.1,
+				shadow: false
+			}
+		},
+		drillUpButton: {
+			position: { 
+				align: 'right',
+				x: -10,
+				y: 10
+			}
+		}
+	});
+	
+	// Stolen from heatmap	
+	var colorSeriesMixin = {
+		// mapping between SVG attributes and the corresponding options
+		pointAttrToOptions: {},
+		pointArrayMap: ['value'],
+		axisTypes: seriesTypes.heatmap ? ['xAxis', 'yAxis', 'colorAxis'] : ['xAxis', 'yAxis'],
+		optionalAxis: 'colorAxis',
+		getSymbol: noop,
+		parallelArrays: ['x', 'y', 'value', 'colorValue'],
+		colorKey: 'colorValue', // Point color option key
+		translateColors: seriesTypes.heatmap && seriesTypes.heatmap.prototype.translateColors
+	};
+
+	// The Treemap series type
+	seriesTypes.treemap = extendClass(seriesTypes.scatter, merge(colorSeriesMixin, {
+		type: 'treemap',
+		trackerGroups: ['group', 'dataLabelsGroup'],
+		pointClass: extendClass(H.Point, {
+			setVisible: seriesTypes.pie.prototype.pointClass.prototype.setVisible
+		}),
+		/**
+		 * Creates an object map from parent id to childrens index.
+		 * @param {Array} data List of points set in options.
+		 * @param {string} data[].parent Parent id of point.
+		 * @param {Array} ids List of all point ids.
+		 * @return {Object} Map from parent id to children index in data.
+		 */
+		getListOfParents: function (data, ids) {
+			var listOfParents = reduce(data, function (prev, curr, i) {
+				var parent = pick(curr.parent, '');
+				if (prev[parent] === undefined) {
+					prev[parent] = [];
+				}
+				prev[parent].push(i);
+				return prev;
+			}, {});
+
+			// If parent does not exist, hoist parent to root of tree.
+			eachObject(listOfParents, function (children, parent, list) {
+				if ((parent !== '') && (H.inArray(parent, ids) === -1)) {
+					each(children, function (child) {
+						list[''].push(child);
+					});
+					delete list[parent];
+				}
+			});
+			return listOfParents;
+		},
+		/**
+		* Creates a tree structured object from the series points
+		*/
+		getTree: function () {
+			var tree,
+				series = this,
+				allIds = map(this.data, function (d) {
+					return d.id;
+				}),
+				parentList = series.getListOfParents(this.data, allIds);
+
+			series.nodeMap = [];
+			tree = series.buildNode('', -1, 0, parentList, null);
+			recursive(this.nodeMap[this.rootNode], function (node) {
+				var next = false,
+					p = node.parent;
+				node.visible = true;
+				if (p || p === '') {
+					next = series.nodeMap[p];
+				}
+				return next;
+			});
+			recursive(this.nodeMap[this.rootNode].children, function (children) {
+				var next = false;
+				each(children, function (child) {
+					child.visible = true;
+					if (child.children.length) {
+						next = (next || []).concat(child.children);
+					}
+				});
+				return next;
+			});
+			this.setTreeValues(tree);
+			return tree;
+		},
+		init: function (chart, options) {
+			var series = this;
+			Series.prototype.init.call(series, chart, options);
+			if (series.options.allowDrillToNode) {
+				series.drillTo();
+			}
+		},
+		buildNode: function (id, i, level, list, parent) {
+			var series = this,
+				children = [],
+				point = series.points[i],
+				node,
+				child;
+
+			// Actions
+			each((list[id] || []), function (i) {
+				child = series.buildNode(series.points[i].id, i, (level + 1), list, id);
+				children.push(child);
+			});
+			node = {
+				id: id,
+				i: i,
+				children: children,
+				level: level,
+				parent: parent,
+				visible: false // @todo move this to better location
+			};
+			series.nodeMap[node.id] = node;
+			if (point) {
+				point.node = node;
+			}
+			return node;
+		},
+		setTreeValues: function (tree) {
+			var series = this,
+				options = series.options,
+				childrenTotal = 0,
+				children = [],
+				val,
+				point = series.points[tree.i];
+
+			// First give the children some values
+			each(tree.children, function (child) {
+				child = series.setTreeValues(child);
+				children.push(child);
+
+				if (!child.ignore) {
+					childrenTotal += child.val;
+				} else {
+					// @todo Add predicate to avoid looping already ignored children
+					recursive(child.children, function (children) {
+						var next = false;
+						each(children, function (node) {
+							extend(node, {
+								ignore: true,
+								isLeaf: false,
+								visible: false
+							});
+							if (node.children.length) {
+								next = (next || []).concat(node.children);
+							}
+						});
+						return next;
+					});
+				}
+			});
+			// Sort the children
+			stableSort(children, function (a, b) {
+				return a.sortIndex - b.sortIndex;
+			});
+			// Set the values
+			val = pick(point && point.value, childrenTotal);
+			extend(tree, {
+				children: children,
+				childrenTotal: childrenTotal,
+				// Ignore this node if point is not visible
+				ignore: !(pick(point && point.visible, true) && (val > 0)),
+				isLeaf: tree.visible && !childrenTotal,
+				levelDynamic: (options.levelIsConstant ? tree.level : (tree.level - series.nodeMap[series.rootNode].level)),
+				name: pick(point && point.name, ''),
+				sortIndex: pick(point && point.sortIndex, -val),
+				val: val
+			});
+			return tree;
+		},
+		/**
+		 * Recursive function which calculates the area for all children of a node.
+		 * @param {Object} node The node which is parent to the children.
+		 * @param {Object} area The rectangular area of the parent.
+		 */
+		calculateChildrenAreas: function (parent, area) {
+			var series = this,
+				options = series.options,
+				level = this.levelMap[parent.levelDynamic + 1],
+				algorithm = pick((series[level && level.layoutAlgorithm] && level.layoutAlgorithm), options.layoutAlgorithm),
+				alternate = options.alternateStartingDirection,
+				childrenValues = [],
+				children;
+
+			// Collect all children which should be included
+			children = grep(parent.children, function (n) {
+				return !n.ignore;
+			});
+
+			if (level && level.layoutStartingDirection) {
+				area.direction = level.layoutStartingDirection === 'vertical' ? 0 : 1;
+			}
+			childrenValues = series[algorithm](area, children);
+			each(children, function (child, index) {
+				var values = childrenValues[index];
+				child.values = merge(values, {
+					val: child.childrenTotal,
+					direction: (alternate ? 1 - area.direction : area.direction)
+				});
+				child.pointValues = merge(values, {
+					x: (values.x / series.axisRatio),
+					width: (values.width / series.axisRatio) 
+				});
+				// If node has children, then call method recursively
+				if (child.children.length) {
+					series.calculateChildrenAreas(child, child.values);
+				}
+			});
+		},
+		setPointValues: function () {
+			var series = this,
+				xAxis = series.xAxis,
+				yAxis = series.yAxis;
+			each(series.points, function (point) {
+				var node = point.node,
+					values = node.pointValues,
+					x1,
+					x2,
+					y1,
+					y2;
+				// Points which is ignored, have no values.
+				if (values) {
+					x1 = Math.round(xAxis.translate(values.x, 0, 0, 0, 1));
+					x2 = Math.round(xAxis.translate(values.x + values.width, 0, 0, 0, 1));
+					y1 = Math.round(yAxis.translate(values.y, 0, 0, 0, 1));
+					y2 = Math.round(yAxis.translate(values.y + values.height, 0, 0, 0, 1));
+					// Set point values
+					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)
+					};
+					point.plotX = point.shapeArgs.x + (point.shapeArgs.width / 2);
+					point.plotY = point.shapeArgs.y + (point.shapeArgs.height / 2);
+				} else {
+					// Reset visibility
+					delete point.plotX;
+					delete point.plotY;
+				}
+			});
+		},
+		setColorRecursive: function (node, color) {
+			var series = this,
+				point,
+				level;
+			if (node) {
+				point = series.points[node.i];
+				level = series.levelMap[node.levelDynamic];
+				// Select either point color, level color or inherited color.
+				color = pick(point && point.options.color, level && level.color, color);
+				if (point) {
+					point.color = color;
+				}
+				// Do it all again with the children	
+				if (node.children.length) {
+					each(node.children, function (child) {
+						series.setColorRecursive(child, color);
+					});
+				}
+			}
+		},
+		algorithmGroup: function (h, w, d, p) {
+			this.height = h;
+			this.width = w;
+			this.plot = p;
+			this.direction = d;
+			this.startDirection = d;
+			this.total = 0;
+			this.nW = 0;
+			this.lW = 0;
+			this.nH = 0;
+			this.lH = 0;
+			this.elArr = [];
+			this.lP = {
+				total: 0,
+				lH: 0,
+				nH: 0,
+				lW: 0,
+				nW: 0,
+				nR: 0,
+				lR: 0,
+				aspectRatio: function (w, h) {
+					return Math.max((w / h), (h / w));
+				}
+			};
+			this.addElement = function (el) {
+				this.lP.total = this.elArr[this.elArr.length - 1];
+				this.total = this.total + el;
+				if (this.direction === 0) {
+					// Calculate last point old aspect ratio
+					this.lW = this.nW;
+					this.lP.lH = this.lP.total / this.lW;
+					this.lP.lR = this.lP.aspectRatio(this.lW, this.lP.lH);
+					// Calculate last point new aspect ratio
+					this.nW = this.total / this.height;
+					this.lP.nH = this.lP.total / this.nW;
+					this.lP.nR = this.lP.aspectRatio(this.nW, this.lP.nH);
+				} else {
+					// Calculate last point old aspect ratio
+					this.lH = this.nH;
+					this.lP.lW = this.lP.total / this.lH;
+					this.lP.lR = this.lP.aspectRatio(this.lP.lW, this.lH);
+					// Calculate last point new aspect ratio
+					this.nH = this.total / this.width;
+					this.lP.nW = this.lP.total / this.nH;
+					this.lP.nR = this.lP.aspectRatio(this.lP.nW, this.nH);
+				}
+				this.elArr.push(el);						
+			};
+			this.reset = function () {
+				this.nW = 0;
+				this.lW = 0;
+				this.elArr = [];
+				this.total = 0;
+			};
+		},
+		algorithmCalcPoints: function (directionChange, last, group, childrenArea) {
+			var pX,
+				pY,
+				pW,
+				pH,
+				gW = group.lW,
+				gH = group.lH,
+				plot = group.plot,
+				keep,
+				i = 0,
+				end = group.elArr.length - 1;
+			if (last) {
+				gW = group.nW;
+				gH = group.nH;
+			} else {
+				keep = group.elArr[group.elArr.length - 1];
+			}
+			each(group.elArr, function (p) {
+				if (last || (i < end)) {
+					if (group.direction === 0) {
+						pX = plot.x;
+						pY = plot.y; 
+						pW = gW;
+						pH = p / pW;
+					} else {
+						pX = plot.x;
+						pY = plot.y;
+						pH = gH;
+						pW = p / pH;
+					}
+					childrenArea.push({
+						x: pX,
+						y: pY,
+						width: pW,
+						height: pH
+					});
+					if (group.direction === 0) {
+						plot.y = plot.y + pH;
+					} else {
+						plot.x = plot.x + pW;
+					}						
+				}
+				i = i + 1;
+			});
+			// Reset variables
+			group.reset();
+			if (group.direction === 0) {
+				group.width = group.width - gW;
+			} else {
+				group.height = group.height - gH;
+			}
+			plot.y = plot.parent.y + (plot.parent.height - group.height);
+			plot.x = plot.parent.x + (plot.parent.width - group.width);
+			if (directionChange) {
+				group.direction = 1 - group.direction;
+			}
+			// If not last, then add uncalculated element
+			if (!last) {
+				group.addElement(keep);
+			}
+		},
+		algorithmLowAspectRatio: function (directionChange, parent, children) {
+			var childrenArea = [],
+				series = this,
+				pTot,
+				plot = {
+					x: parent.x,
+					y: parent.y,
+					parent: parent
+				},
+				direction = parent.direction,
+				i = 0,
+				end = children.length - 1,
+				group = new this.algorithmGroup(parent.height, parent.width, direction, plot);
+			// Loop through and calculate all areas
+			each(children, function (child) {
+				pTot = (parent.width * parent.height) * (child.val / parent.val);
+				group.addElement(pTot);
+				if (group.lP.nR > group.lP.lR) {
+					series.algorithmCalcPoints(directionChange, false, group, childrenArea, plot);
+				}
+				// If last child, then calculate all remaining areas
+				if (i === end) {
+					series.algorithmCalcPoints(directionChange, true, group, childrenArea, plot);
+				}
+				i = i + 1;
+			});
+			return childrenArea;
+		},
+		algorithmFill: function (directionChange, parent, children) {
+			var childrenArea = [],
+				pTot,
+				direction = parent.direction,
+				x = parent.x,
+				y = parent.y,
+				width = parent.width,
+				height = parent.height,
+				pX,
+				pY,
+				pW,
+				pH;
+			each(children, function (child) {
+				pTot = (parent.width * parent.height) * (child.val / parent.val);
+				pX = x;
+				pY = y;
+				if (direction === 0) {
+					pH = height;
+					pW = pTot / pH;
+					width = width - pW;
+					x = x + pW;
+				} else {
+					pW = width;
+					pH = pTot / pW;
+					height = height - pH;
+					y = y + pH;
+				}
+				childrenArea.push({
+					x: pX,
+					y: pY,
+					width: pW,
+					height: pH
+				});
+				if (directionChange) {
+					direction = 1 - direction;
+				}
+			});
+			return childrenArea;
+		},
+		strip: function (parent, children) {
+			return this.algorithmLowAspectRatio(false, parent, children);
+		},
+		squarified: function (parent, children) {
+			return this.algorithmLowAspectRatio(true, parent, children);
+		},
+		sliceAndDice: function (parent, children) {
+			return this.algorithmFill(true, parent, children);
+		},
+		stripes: function (parent, children) {
+			return this.algorithmFill(false, parent, children);
+		},
+		translate: function () {
+			var pointValues,
+				seriesArea,
+				tree,
+				val;
+
+			// Call prototype function
+			Series.prototype.translate.call(this);
+
+			// Assign variables
+			this.rootNode = pick(this.options.rootId, '');
+			// Create a object map from level to options
+			this.levelMap = reduce(this.options.levels, function (arr, item) {
+				arr[item.level] = item;
+				return arr;
+			}, {});
+			tree = this.tree = this.getTree(); // @todo Only if series.isDirtyData is true
+
+			// Calculate plotting values.
+			this.axisRatio = (this.xAxis.len / this.yAxis.len);
+			this.nodeMap[''].pointValues = pointValues = { x: 0, y: 0, width: 100, height: 100 };
+			this.nodeMap[''].values = seriesArea = merge(pointValues, {
+				width: (pointValues.width * this.axisRatio),
+				direction: (this.options.layoutStartingDirection === 'vertical' ? 0 : 1),
+				val: tree.val
+			});
+			this.calculateChildrenAreas(tree, seriesArea);
+
+			// Logic for point colors
+			if (this.colorAxis) {
+				this.translateColors();
+			} else if (!this.options.colorByPoint) {
+				this.setColorRecursive(this.tree, undefined);
+			}
+
+			// Update axis extremes according to the root node.
+			val = this.nodeMap[this.rootNode].pointValues;
+			this.xAxis.setExtremes(val.x, val.x + val.width, false);
+			this.yAxis.setExtremes(val.y, val.y + val.height, false);
+			this.xAxis.setScale();
+			this.yAxis.setScale();
+
+			// Assign values to points.
+			this.setPointValues();
+		},
+		/**
+		 * Extend drawDataLabels with logic to handle custom options related to the treemap series:
+		 * - Points which is not a leaf node, has dataLabels disabled by default.
+		 * - Options set on series.levels is merged in.
+		 * - Width of the dataLabel is set to match the width of the point shape.
+		 */
+		drawDataLabels: function () {
+			var series = this,
+				points = grep(series.points, function (n) {
+					return n.node.visible;
+				}),
+				options,
+				level;
+			each(points, function (point) {
+				level = series.levelMap[point.node.levelDynamic];
+				// Set options to new object to avoid problems with scope
+				options = { style: {} };
+
+				// If not a leaf, then label should be disabled as default
+				if (!point.node.isLeaf) {
+					options.enabled = false;
+				}
+
+				// If options for level exists, include them as well
+				if (level && level.dataLabels) {
+					options = merge(options, level.dataLabels);
+					series._hasPointLabels = true;
+				}
+
+				// Set dataLabel width to the width of the point shape.
+				if (point.shapeArgs) {
+					options.style.width = point.shapeArgs.width;
+				}
+
+				// Merge custom options with point options
+				point.dlOptions = merge(options, point.options.dataLabels);
+			});
+			Series.prototype.drawDataLabels.call(this);
+		},
+		alignDataLabel: seriesTypes.column.prototype.alignDataLabel,
+
+		/**
+		 * Get presentational attributes
+		 */
+		pointAttribs: function (point, state) {
+			var level = this.levelMap[point.node.levelDynamic] || {},
+				options = this.options,
+				attr,
+				stateOptions = (state && options.states[state]) || {};
+
+			// Set attributes by precedence. Point trumps level trumps series. Stroke width uses pick
+			// because it can be 0.
+			attr = {
+				'stroke': point.borderColor || level.borderColor || stateOptions.borderColor || options.borderColor,
+				'stroke-width': pick(point.borderWidth, level.borderWidth, stateOptions.borderWidth, options.borderWidth),
+				'dashstyle': point.borderDashStyle || level.borderDashStyle || stateOptions.borderDashStyle || options.borderDashStyle,
+				'fill': point.color || this.color,
+				'zIndex': state === 'hover' ? 1 : 0
+			};
+
+			if (point.node.level <= this.nodeMap[this.rootNode].level) {
+				// Hide levels above the current view
+				attr.fill = 'none';
+				attr['stroke-width'] = 0;
+			} else if (!point.node.isLeaf) {
+				// If not a leaf, then remove fill
+				// @todo let users set the opacity
+				attr.fill = pick(options.interactByLeaf, !options.allowDrillToNode) ? 'none' : Color(attr.fill).setOpacity(state === 'hover' ? 0.75 : 0.15).get();
+			} else if (state) {
+				// Brighten and hoist the hover nodes
+				attr.fill = Color(attr.fill).brighten(stateOptions.brightness).get();
+			}
+
+			return attr;
+		},
+
+		/**
+		* Extending ColumnSeries drawPoints
+		*/
+		drawPoints: function () {
+			var series = this,
+				points = grep(series.points, function (n) {
+					return n.node.visible;
+				});
+
+			each(points, function (point) {
+				var groupKey = 'levelGroup-' + point.node.levelDynamic;
+				if (!series[groupKey]) {
+					series[groupKey] = series.chart.renderer.g(groupKey)
+						.attr({
+							zIndex: 1000 - point.node.levelDynamic // @todo Set the zIndex based upon the number of levels, instead of using 1000
+						})
+						.add(series.group);
+				}
+				point.group = series[groupKey];
+				// Preliminary code in prepraration for HC5 that uses pointAttribs for all series
+				point.pointAttr = {
+					'': series.pointAttribs(point),
+					'hover': series.pointAttribs(point, 'hover'),
+					'select': {}
+				};
+			});
+			// Call standard drawPoints
+			seriesTypes.column.prototype.drawPoints.call(this);
+
+			// If drillToNode is allowed, set a point cursor on clickables & add drillId to point 
+			if (series.options.allowDrillToNode) {
+				each(points, function (point) {
+					var cursor,
+						drillId;
+					if (point.graphic) {
+						drillId = point.drillId = series.options.interactByLeaf ? series.drillToByLeaf(point) : series.drillToByGroup(point);
+						cursor = drillId ? 'pointer' : 'default';
+						point.graphic.css({ cursor: cursor });
+					}
+				});
+			}
+		},
+		/**
+		* Add drilling on the suitable points
+		*/
+		drillTo: function () {
+			var series = this;
+			H.addEvent(series, 'click', function (event) {
+				var point = event.point,
+					drillId = point.drillId,
+					drillName;
+				// If a drill id is returned, add click event and cursor. 
+				if (drillId) {
+					drillName = series.nodeMap[series.rootNode].name || series.rootNode;
+					point.setState(''); // Remove hover
+					series.drillToNode(drillId);
+					series.showDrillUpButton(drillName);
+				}
+			});
+		},
+		/**
+		* Finds the drill id for a parent node.
+		* Returns false if point should not have a click event
+		* @param {Object} point
+		* @return {string || boolean} Drill to id or false when point should not have a click event
+		*/
+		drillToByGroup: function (point) {
+			var series = this,
+				drillId = false;
+			if ((point.node.level - series.nodeMap[series.rootNode].level) === 1 && !point.node.isLeaf) {
+				drillId = point.id;
+			}
+			return drillId;
+		},
+		/**
+		* Finds the drill id for a leaf node.
+		* Returns false if point should not have a click event
+		* @param {Object} point
+		* @return {string || boolean} Drill to id or false when point should not have a click event
+		*/
+		drillToByLeaf: function (point) {
+			var series = this,
+				drillId = false,
+				nodeParent;
+			if ((point.node.parent !== series.rootNode) && (point.node.isLeaf)) {
+				nodeParent = point.node;
+				while (!drillId) {
+					nodeParent = series.nodeMap[nodeParent.parent];
+					if (nodeParent.parent === series.rootNode) {
+						drillId = nodeParent.id;
+					}
+				}
+			}
+			return drillId;
+		},
+		drillUp: function () {
+			var drillPoint = null,
+				node,
+				parent;
+			if (this.rootNode) {
+				node = this.nodeMap[this.rootNode];
+				if (node.parent !== null) {
+					drillPoint = this.nodeMap[node.parent];
+				} else {
+					drillPoint = this.nodeMap[''];
+				}
+			}
+
+			if (drillPoint !== null) {
+				this.drillToNode(drillPoint.id);
+				if (drillPoint.id === '') {
+					this.drillUpButton = this.drillUpButton.destroy();
+				} else {
+					parent = this.nodeMap[drillPoint.parent];
+					this.showDrillUpButton((parent.name || parent.id));
+				}
+			} 
+		},
+		drillToNode: function (id) {
+			this.options.rootId = id;
+			this.isDirty = true; // Force redraw
+			this.chart.redraw();
+		},
+		showDrillUpButton: function (name) {
+			var series = this,
+				backText = (name || '< Back'),
+				buttonOptions = series.options.drillUpButton,
+				attr,
+				states;
+
+			if (buttonOptions.text) {
+				backText = buttonOptions.text;
+			}
+			if (!this.drillUpButton) {
+				attr = buttonOptions.theme;
+				states = attr && attr.states;
+							
+				this.drillUpButton = this.chart.renderer.button(
+					backText,
+					null,
+					null,
+					function () {
+						series.drillUp(); 
+					},
+					attr, 
+					states && states.hover,
+					states && states.select
+				)
+				.attr({
+					align: buttonOptions.position.align,
+					zIndex: 9
+				})
+				.add()
+				.align(buttonOptions.position, false, buttonOptions.relativeTo || 'plotBox');
+			} else {
+				this.drillUpButton.attr({
+					text: backText
+				})
+				.align();
+			}
+		},
+		buildKDTree: noop,
+		drawLegendSymbol: H.LegendSymbolMixin.drawRectangle,
+		getExtremes: function () {
+			// Get the extremes from the value data
+			Series.prototype.getExtremes.call(this, this.colorValueData);
+			this.valueMin = this.dataMin;
+			this.valueMax = this.dataMax;
+
+			// Get the extremes from the y data
+			Series.prototype.getExtremes.call(this);
+		},
+		getExtremesFromAll: true,
+		bindAxes: function () {
+			var treeAxis = {
+				endOnTick: false,
+				gridLineWidth: 0,
+				lineWidth: 0,
+				min: 0,
+				dataMin: 0,
+				minPadding: 0,
+				max: 100,
+				dataMax: 100,
+				maxPadding: 0,
+				startOnTick: false,
+				title: null,
+				tickPositions: []
+			};
+			Series.prototype.bindAxes.call(this);
+			H.extend(this.yAxis.options, treeAxis);
+			H.extend(this.xAxis.options, treeAxis);
+		}
+	}));
+}));