diff --git a/assets/css/statbot.css b/assets/css/statbot.css
index 381f806..329f7d1 100644
--- a/assets/css/statbot.css
+++ b/assets/css/statbot.css
@@ -186,6 +186,31 @@ ul.menu-list-dropped {
width: 150px;
}
+aside {
+ padding: 0.3em 1em;
+ border-radius: 3px;
+ color: #fff;
+}
+
+/* Other Styles :D */
+.success {
+ background: rgb(28, 184, 65); /* this is a green */
+}
+
+.error {
+ background: rgb(202, 60, 60); /* this is a maroon */
+}
+
+.warning {
+ background: rgb(223, 117, 20); /* this is an orange */
+}
+.secondary {
+ background: rgb(66, 184, 221); /* this is a light blue*/
+}
+.primary {
+ background: #1f8dd6;
+}
+
/* -- Responsive Styles (Media Queries) ------------------------------------- */
/*
diff --git a/assets/js/highcharts.js b/assets/js/highcharts.js
new file mode 100644
index 0000000..817f029
--- /dev/null
+++ b/assets/js/highcharts.js
@@ -0,0 +1,29014 @@
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ *
+ * Standalone Highcharts Framework
+ *
+ * License: MIT License
+ */
+
+
+/*global Highcharts */
+var HighchartsAdapter = (function () {
+
+var UNDEFINED,
+ doc = document,
+ emptyArray = [],
+ timers = [],
+ animSetters = {},
+ Fx;
+
+Math.easeInOutSine = function (t, b, c, d) {
+ return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b;
+};
+
+
+
+/**
+ * Extend given object with custom events
+ */
+function augment(obj) {
+ function removeOneEvent(el, type, fn) {
+ el.removeEventListener(type, fn, false);
+ }
+
+ function IERemoveOneEvent(el, type, fn) {
+ fn = el.HCProxiedMethods[fn.toString()];
+ el.detachEvent('on' + type, fn);
+ }
+
+ function removeAllEvents(el, type) {
+ var events = el.HCEvents,
+ remove,
+ types,
+ len,
+ n;
+
+ if (el.removeEventListener) {
+ remove = removeOneEvent;
+ } else if (el.attachEvent) {
+ remove = IERemoveOneEvent;
+ } else {
+ return; // break on non-DOM events
+ }
+
+
+ if (type) {
+ types = {};
+ types[type] = true;
+ } else {
+ types = events;
+ }
+
+ for (n in types) {
+ if (events[n]) {
+ len = events[n].length;
+ while (len--) {
+ remove(el, n, events[n][len]);
+ }
+ }
+ }
+ }
+
+ if (!obj.HCExtended) {
+ Highcharts.extend(obj, {
+ HCExtended: true,
+
+ HCEvents: {},
+
+ bind: function (name, fn) {
+ var el = this,
+ events = this.HCEvents,
+ wrappedFn;
+
+ // handle DOM events in modern browsers
+ if (el.addEventListener) {
+ el.addEventListener(name, fn, false);
+
+ // handle old IE implementation
+ } else if (el.attachEvent) {
+
+ wrappedFn = function (e) {
+ e.target = e.srcElement || window; // #2820
+ fn.call(el, e);
+ };
+
+ if (!el.HCProxiedMethods) {
+ el.HCProxiedMethods = {};
+ }
+
+ // link wrapped fn with original fn, so we can get this in removeEvent
+ el.HCProxiedMethods[fn.toString()] = wrappedFn;
+
+ el.attachEvent('on' + name, wrappedFn);
+ }
+
+
+ if (events[name] === UNDEFINED) {
+ events[name] = [];
+ }
+
+ events[name].push(fn);
+ },
+
+ unbind: function (name, fn) {
+ var events,
+ index;
+
+ if (name) {
+ events = this.HCEvents[name] || [];
+ if (fn) {
+ index = HighchartsAdapter.inArray(fn, events);
+ if (index > -1) {
+ events.splice(index, 1);
+ this.HCEvents[name] = events;
+ }
+ if (this.removeEventListener) {
+ removeOneEvent(this, name, fn);
+ } else if (this.attachEvent) {
+ IERemoveOneEvent(this, name, fn);
+ }
+ } else {
+ removeAllEvents(this, name);
+ this.HCEvents[name] = [];
+ }
+ } else {
+ removeAllEvents(this);
+ this.HCEvents = {};
+ }
+ },
+
+ trigger: function (name, args) {
+ var events = this.HCEvents[name] || [],
+ target = this,
+ len = events.length,
+ i,
+ preventDefault,
+ fn;
+
+ // Attach a simple preventDefault function to skip default handler if called
+ preventDefault = function () {
+ args.defaultPrevented = true;
+ };
+
+ for (i = 0; i < len; i++) {
+ fn = events[i];
+
+ // args is never null here
+ if (args.stopped) {
+ return;
+ }
+
+ args.preventDefault = preventDefault;
+ args.target = target;
+
+ // If the type is not set, we're running a custom event (#2297). If it is set,
+ // we're running a browser event, and setting it will cause en error in
+ // IE8 (#2465).
+ if (!args.type) {
+ args.type = name;
+ }
+
+
+
+ // If the event handler return false, prevent the default handler from executing
+ if (fn.call(this, args) === false) {
+ args.preventDefault();
+ }
+ }
+ }
+ });
+ }
+
+ return obj;
+}
+
+
+return {
+
+ /**
+ * Initialize the adapter. This is run once as Highcharts is first run.
+ */
+ init: function (pathAnim) {
+
+ /**
+ * Compatibility section to add support for legacy IE. This can be removed if old IE
+ * support is not needed.
+ */
+ if (!doc.defaultView) {
+ this._getStyle = function (el, prop) {
+ var val;
+ if (el.style[prop]) {
+ return el.style[prop];
+ } else {
+ if (prop === 'opacity') {
+ prop = 'filter';
+ }
+ /*jslint unparam: true*/
+ val = el.currentStyle[prop.replace(/\-(\w)/g, function (a, b) { return b.toUpperCase(); })];
+ if (prop === 'filter') {
+ val = val.replace(
+ /alpha\(opacity=([0-9]+)\)/,
+ function (a, b) {
+ return b / 100;
+ }
+ );
+ }
+ /*jslint unparam: false*/
+ return val === '' ? 1 : val;
+ }
+ };
+ this.adapterRun = function (elem, method) {
+ var alias = { width: 'clientWidth', height: 'clientHeight' }[method];
+
+ if (alias) {
+ elem.style.zoom = 1;
+ return elem[alias] - 2 * parseInt(HighchartsAdapter._getStyle(elem, 'padding'), 10);
+ }
+ };
+ }
+
+ if (!Array.prototype.forEach) {
+ this.each = function (arr, fn) { // legacy
+ var i = 0,
+ len = arr.length;
+ for (; i < len; i++) {
+ if (fn.call(arr[i], arr[i], i, arr) === false) {
+ return i;
+ }
+ }
+ };
+ }
+
+ if (!Array.prototype.indexOf) {
+ this.inArray = function (item, arr) {
+ var len,
+ i = 0;
+
+ if (arr) {
+ len = arr.length;
+
+ for (; i < len; i++) {
+ if (arr[i] === item) {
+ return i;
+ }
+ }
+ }
+
+ return -1;
+ };
+ }
+
+ if (!Array.prototype.filter) {
+ this.grep = function (elements, callback) {
+ var ret = [],
+ i = 0,
+ length = elements.length;
+
+ for (; i < length; i++) {
+ if (!!callback(elements[i], i)) {
+ ret.push(elements[i]);
+ }
+ }
+
+ return ret;
+ };
+ }
+
+ //--- End compatibility section ---
+
+
+ /**
+ * Start of animation specific code
+ */
+ Fx = function (elem, options, prop) {
+ this.options = options;
+ this.elem = elem;
+ this.prop = prop;
+ };
+ Fx.prototype = {
+
+ update: function () {
+ var styles,
+ paths = this.paths,
+ elem = this.elem,
+ elemelem = elem.element; // if destroyed, it is null
+
+ // Animation setter defined from outside
+ if (animSetters[this.prop]) {
+ animSetters[this.prop](this);
+
+ // Animating a path definition on SVGElement
+ } else if (paths && elemelem) {
+ elem.attr('d', pathAnim.step(paths[0], paths[1], this.now, this.toD));
+
+ // Other animations on SVGElement
+ } else if (elem.attr) {
+ if (elemelem) {
+ elem.attr(this.prop, this.now);
+ }
+
+ // HTML styles
+ } else {
+ styles = {};
+ styles[this.prop] = this.now + this.unit;
+ Highcharts.css(elem, styles);
+ }
+
+ if (this.options.step) {
+ this.options.step.call(this.elem, this.now, this);
+ }
+
+ },
+ custom: function (from, to, unit) {
+ var self = this,
+ t = function (gotoEnd) {
+ return self.step(gotoEnd);
+ },
+ i;
+
+ this.startTime = +new Date();
+ this.start = from;
+ this.end = to;
+ this.unit = unit;
+ this.now = this.start;
+ this.pos = this.state = 0;
+
+ t.elem = this.elem;
+
+ if (t() && timers.push(t) === 1) {
+ t.timerId = setInterval(function () {
+
+ for (i = 0; i < timers.length; i++) {
+ if (!timers[i]()) {
+ timers.splice(i--, 1);
+ }
+ }
+
+ if (!timers.length) {
+ clearInterval(t.timerId);
+ }
+ }, 13);
+ }
+ },
+
+ step: function (gotoEnd) {
+ var t = +new Date(),
+ ret,
+ done,
+ options = this.options,
+ elem = this.elem,
+ i;
+
+ if (elem.attr && !elem.element) { // #2616, element including flag is destroyed
+ ret = false;
+
+ } else if (gotoEnd || t >= options.duration + this.startTime) {
+ this.now = this.end;
+ this.pos = this.state = 1;
+ this.update();
+
+ this.options.curAnim[this.prop] = true;
+
+ done = true;
+ for (i in options.curAnim) {
+ if (options.curAnim[i] !== true) {
+ done = false;
+ }
+ }
+
+ if (done) {
+ if (options.complete) {
+ options.complete.call(elem);
+ }
+ }
+ ret = false;
+
+ } else {
+ var n = t - this.startTime;
+ this.state = n / options.duration;
+ this.pos = options.easing(n, 0, 1, options.duration);
+ this.now = this.start + ((this.end - this.start) * this.pos);
+ this.update();
+ ret = true;
+ }
+ return ret;
+ }
+ };
+
+ /**
+ * The adapter animate method
+ */
+ this.animate = function (el, prop, opt) {
+ var start,
+ unit = '',
+ end,
+ fx,
+ args,
+ name,
+ PX = 'px';
+
+ if (typeof opt !== 'object' || opt === null) {
+ args = arguments;
+ opt = {
+ duration: args[2],
+ easing: args[3],
+ complete: args[4]
+ };
+ }
+ if (typeof opt.duration !== 'number') {
+ opt.duration = 400;
+ }
+ opt.easing = Math[opt.easing] || Math.easeInOutSine;
+ opt.curAnim = Highcharts.extend({}, prop);
+
+ for (name in prop) {
+ fx = new Fx(el, opt, name);
+ end = null;
+
+ if (name === 'd') {
+ fx.paths = pathAnim.init(
+ el,
+ el.d,
+ prop.d
+ );
+ fx.toD = prop.d;
+ start = 0;
+ end = 1;
+ } else if (el.attr) {
+ start = el.attr(name);
+ } else {
+ start = parseFloat(HighchartsAdapter._getStyle(el, name)) || 0;
+ if (name !== 'opacity') {
+ unit = PX;
+ }
+ }
+
+ if (!end) {
+ end = prop[name];
+ }
+ if (end.match && end.match(PX)) {
+ end = end.replace(/px/g, ''); // #4351
+ }
+ fx.custom(start, end, unit);
+ }
+ };
+ },
+
+ /**
+ * Internal method to return CSS value for given element and property
+ */
+ _getStyle: function (el, prop) {
+ return window.getComputedStyle(el, undefined).getPropertyValue(prop);
+ },
+
+ /**
+ * Add an animation setter for a specific property
+ */
+ addAnimSetter: function (prop, fn) {
+ animSetters[prop] = fn;
+ },
+
+ /**
+ * Downloads a script and executes a callback when done.
+ * @param {String} scriptLocation
+ * @param {Function} callback
+ */
+ getScript: function (scriptLocation, callback) {
+ // We cannot assume that Assets class from mootools-more is available so instead insert a script tag to download script.
+ var head = doc.getElementsByTagName('head')[0],
+ script = doc.createElement('script');
+
+ script.type = 'text/javascript';
+ script.src = scriptLocation;
+ script.onload = callback;
+
+ head.appendChild(script);
+ },
+
+ /**
+ * Return the index of an item in an array, or -1 if not found
+ */
+ inArray: function (item, arr) {
+ return arr.indexOf ? arr.indexOf(item) : emptyArray.indexOf.call(arr, item);
+ },
+
+
+ /**
+ * A direct link to adapter methods
+ */
+ adapterRun: function (elem, method) {
+ return parseInt(HighchartsAdapter._getStyle(elem, method), 10);
+ },
+
+ /**
+ * Filter an array
+ */
+ grep: function (elements, callback) {
+ return emptyArray.filter.call(elements, callback);
+ },
+
+ /**
+ * Map an array
+ */
+ map: function (arr, fn) {
+ var results = [], i = 0, len = arr.length;
+
+ for (; i < len; i++) {
+ results[i] = fn.call(arr[i], arr[i], i, arr);
+ }
+
+ return results;
+ },
+
+ /**
+ * Get the element's offset position, corrected by overflow:auto. Loosely based on jQuery's offset method.
+ */
+ offset: function (el) {
+ var docElem = document.documentElement,
+ box = el.getBoundingClientRect();
+
+ return {
+ top: box.top + (window.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0),
+ left: box.left + (window.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0)
+ };
+ },
+
+ /**
+ * Add an event listener
+ */
+ addEvent: function (el, type, fn) {
+ augment(el).bind(type, fn);
+ },
+
+ /**
+ * Remove event added with addEvent
+ */
+ removeEvent: function (el, type, fn) {
+ augment(el).unbind(type, fn);
+ },
+
+ /**
+ * Fire an event on a custom object
+ */
+ fireEvent: function (el, type, eventArguments, defaultFunction) {
+ var e;
+
+ if (doc.createEvent && (el.dispatchEvent || el.fireEvent)) {
+ e = doc.createEvent('Events');
+ e.initEvent(type, true, true);
+ e.target = el;
+
+ Highcharts.extend(e, eventArguments);
+
+ if (el.dispatchEvent) {
+ el.dispatchEvent(e);
+ } else {
+ el.fireEvent(type, e);
+ }
+
+ } else if (el.HCExtended === true) {
+ eventArguments = eventArguments || {};
+ el.trigger(type, eventArguments);
+ }
+
+ if (eventArguments && eventArguments.defaultPrevented) {
+ defaultFunction = null;
+ }
+
+ if (defaultFunction) {
+ defaultFunction(eventArguments);
+ }
+ },
+
+ washMouseEvent: function (e) {
+ return e;
+ },
+
+
+ /**
+ * Stop running animation
+ */
+ stop: function (el) {
+
+ var i = timers.length,
+ timer;
+
+ // Remove timers related to this element (#4519)
+ while (i--) {
+ timer = timers[i];
+ if (timer.elem === el) {
+ timers.splice(i, 1);
+ }
+ }
+ },
+
+ /**
+ * Utility for iterating over an array. Parameters are reversed compared to jQuery.
+ * @param {Array} arr
+ * @param {Function} fn
+ */
+ each: function (arr, fn) { // modern browsers
+ return Array.prototype.forEach.call(arr, fn);
+ }
+};
+}());
+
+
+// ==ClosureCompiler==
+// @compilation_level SIMPLE_OPTIMIZATIONS
+
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ *
+ * (c) 2009-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+// JSLint options:
+/*global Highcharts, HighchartsAdapter, document, window, navigator, setInterval, clearInterval, clearTimeout, setTimeout, location, jQuery, $, console, each, grep */
+/*jslint ass: true, sloppy: true, forin: true, plusplus: true, nomen: true, vars: true, regexp: true, newcap: true, browser: true, continue: true, white: true */
+(function () {
+
+
+// encapsulated variables
+var UNDEFINED,
+ doc = document,
+ win = window,
+ math = Math,
+ mathRound = math.round,
+ mathFloor = math.floor,
+ mathCeil = math.ceil,
+ mathMax = math.max,
+ mathMin = math.min,
+ mathAbs = math.abs,
+ mathCos = math.cos,
+ mathSin = math.sin,
+ mathPI = math.PI,
+ deg2rad = mathPI * 2 / 360,
+
+
+ // some variables
+ userAgent = navigator.userAgent,
+ isOpera = win.opera,
+ isMS = /(msie|trident|edge)/i.test(userAgent) && !isOpera,
+ docMode8 = doc.documentMode === 8,
+ isWebKit = !isMS && /AppleWebKit/.test(userAgent),
+ isFirefox = /Firefox/.test(userAgent),
+ isTouchDevice = /(Mobile|Android|Windows Phone)/.test(userAgent),
+ SVG_NS = 'http://www.w3.org/2000/svg',
+ hasSVG = !!doc.createElementNS && !!doc.createElementNS(SVG_NS, 'svg').createSVGRect,
+ hasBidiBug = isFirefox && parseInt(userAgent.split('Firefox/')[1], 10) < 4, // issue #38
+ useCanVG = !hasSVG && !isMS && !!doc.createElement('canvas').getContext,
+ Renderer,
+ hasTouch,
+ symbolSizes = {},
+ idCounter = 0,
+ garbageBin,
+ defaultOptions,
+ dateFormat, // function
+ pathAnim,
+ timeUnits,
+ noop = function () { return UNDEFINED; },
+ charts = [],
+ chartCount = 0,
+ PRODUCT = 'Highcharts 4.1.9',
+ VERSION = '/Highstock 2.1.9',
+
+ // some constants for frequently used strings
+ DIV = 'div',
+ ABSOLUTE = 'absolute',
+ RELATIVE = 'relative',
+ HIDDEN = 'hidden',
+ PREFIX = 'highcharts-',
+ VISIBLE = 'visible',
+ PX = 'px',
+ NONE = 'none',
+ M = 'M',
+ L = 'L',
+ numRegex = /^[0-9]+$/,
+ NORMAL_STATE = '',
+ HOVER_STATE = 'hover',
+ SELECT_STATE = 'select',
+ marginNames = ['plotTop', 'marginRight', 'marginBottom', 'plotLeft'],
+
+ // Object for extending Axis
+ AxisPlotLineOrBandExtension,
+
+ // constants for attributes
+ STROKE_WIDTH = 'stroke-width',
+
+ // time methods, changed based on whether or not UTC is used
+ Date, // Allow using a different Date class
+ makeTime,
+ timezoneOffset,
+ getTimezoneOffset,
+ getMinutes,
+ getHours,
+ getDay,
+ getDate,
+ getMonth,
+ getFullYear,
+ setMilliseconds,
+ setSeconds,
+ setMinutes,
+ setHours,
+ setDate,
+ setMonth,
+ setFullYear,
+
+
+ // lookup over the types and the associated classes
+ seriesTypes = {},
+ Highcharts;
+
+// The Highcharts namespace
+Highcharts = win.Highcharts = win.Highcharts ? error(16, true) : {};
+
+Highcharts.seriesTypes = seriesTypes;
+
+
+
+/**
+ * Extend an object with the members of another
+ * @param {Object} a The object to be extended
+ * @param {Object} b The object to add to the first one
+ */
+var extend = Highcharts.extend = function (a, b) {
+ var n;
+ if (!a) {
+ a = {};
+ }
+ for (n in b) {
+ a[n] = b[n];
+ }
+ return a;
+};
+
+/**
+ * Deep merge two or more objects and return a third object. If the first argument is
+ * true, the contents of the second object is copied into the first object.
+ * Previously this function redirected to jQuery.extend(true), but this had two limitations.
+ * First, it deep merged arrays, which lead to workarounds in Highcharts. Second,
+ * it copied properties from extended prototypes.
+ */
+function merge() {
+ var i,
+ args = arguments,
+ len,
+ ret = {},
+ doCopy = function (copy, original) {
+ var value, key;
+
+ // An object is replacing a primitive
+ if (typeof copy !== 'object') {
+ copy = {};
+ }
+
+ for (key in original) {
+ if (original.hasOwnProperty(key)) {
+ value = original[key];
+
+ // Copy the contents of objects, but not arrays or DOM nodes
+ if (value && typeof value === 'object' && Object.prototype.toString.call(value) !== '[object Array]' &&
+ key !== 'renderTo' && typeof value.nodeType !== 'number') {
+ copy[key] = doCopy(copy[key] || {}, value);
+
+ // Primitives and arrays are copied over directly
+ } else {
+ copy[key] = original[key];
+ }
+ }
+ }
+ return copy;
+ };
+
+ // If first argument is true, copy into the existing object. Used in setOptions.
+ if (args[0] === true) {
+ ret = args[1];
+ args = Array.prototype.slice.call(args, 2);
+ }
+
+ // For each argument, extend the return
+ len = args.length;
+ for (i = 0; i < len; i++) {
+ ret = doCopy(ret, args[i]);
+ }
+
+ return ret;
+}
+
+/**
+ * Shortcut for parseInt
+ * @param {Object} s
+ * @param {Number} mag Magnitude
+ */
+function pInt(s, mag) {
+ return parseInt(s, mag || 10);
+}
+
+/**
+ * Check for string
+ * @param {Object} s
+ */
+function isString(s) {
+ return typeof s === 'string';
+}
+
+/**
+ * Check for object
+ * @param {Object} obj
+ */
+function isObject(obj) {
+ return obj && typeof obj === 'object';
+}
+
+/**
+ * Check for array
+ * @param {Object} obj
+ */
+function isArray(obj) {
+ return Object.prototype.toString.call(obj) === '[object Array]';
+}
+
+/**
+ * Check for number
+ * @param {Object} n
+ */
+function isNumber(n) {
+ return typeof n === 'number';
+}
+
+function log2lin(num) {
+ return math.log(num) / math.LN10;
+}
+function lin2log(num) {
+ return math.pow(10, num);
+}
+
+/**
+ * Remove last occurence of an item from an array
+ * @param {Array} arr
+ * @param {Mixed} item
+ */
+function erase(arr, item) {
+ var i = arr.length;
+ while (i--) {
+ if (arr[i] === item) {
+ arr.splice(i, 1);
+ break;
+ }
+ }
+ //return arr;
+}
+
+/**
+ * Returns true if the object is not null or undefined. Like MooTools' $.defined.
+ * @param {Object} obj
+ */
+function defined(obj) {
+ return obj !== UNDEFINED && obj !== null;
+}
+
+/**
+ * Set or get an attribute or an object of attributes. Can't use jQuery attr because
+ * it attempts to set expando properties on the SVG element, which is not allowed.
+ *
+ * @param {Object} elem The DOM element to receive the attribute(s)
+ * @param {String|Object} prop The property or an abject of key-value pairs
+ * @param {String} value The value if a single property is set
+ */
+function attr(elem, prop, value) {
+ var key,
+ ret;
+
+ // if the prop is a string
+ if (isString(prop)) {
+ // set the value
+ if (defined(value)) {
+ elem.setAttribute(prop, value);
+
+ // get the value
+ } else if (elem && elem.getAttribute) { // elem not defined when printing pie demo...
+ ret = elem.getAttribute(prop);
+ }
+
+ // else if prop is defined, it is a hash of key/value pairs
+ } else if (defined(prop) && isObject(prop)) {
+ for (key in prop) {
+ elem.setAttribute(key, prop[key]);
+ }
+ }
+ return ret;
+}
+/**
+ * Check if an element is an array, and if not, make it into an array. Like
+ * MooTools' $.splat.
+ */
+function splat(obj) {
+ return isArray(obj) ? obj : [obj];
+}
+
+
+/**
+ * Return the first value that is defined. Like MooTools' $.pick.
+ */
+var pick = Highcharts.pick = function () {
+ var args = arguments,
+ i,
+ arg,
+ length = args.length;
+ for (i = 0; i < length; i++) {
+ arg = args[i];
+ if (arg !== UNDEFINED && arg !== null) {
+ return arg;
+ }
+ }
+};
+
+/**
+ * Set CSS on a given element
+ * @param {Object} el
+ * @param {Object} styles Style object with camel case property names
+ */
+function css(el, styles) {
+ if (isMS && !hasSVG) { // #2686
+ if (styles && styles.opacity !== UNDEFINED) {
+ styles.filter = 'alpha(opacity=' + (styles.opacity * 100) + ')';
+ }
+ }
+ extend(el.style, styles);
+}
+
+/**
+ * Utility function to create element with attributes and styles
+ * @param {Object} tag
+ * @param {Object} attribs
+ * @param {Object} styles
+ * @param {Object} parent
+ * @param {Object} nopad
+ */
+function createElement(tag, attribs, styles, parent, nopad) {
+ var el = doc.createElement(tag);
+ if (attribs) {
+ extend(el, attribs);
+ }
+ if (nopad) {
+ css(el, {padding: 0, border: NONE, margin: 0});
+ }
+ if (styles) {
+ css(el, styles);
+ }
+ if (parent) {
+ parent.appendChild(el);
+ }
+ return el;
+}
+
+/**
+ * Extend a prototyped class by new members
+ * @param {Object} parent
+ * @param {Object} members
+ */
+function extendClass(parent, members) {
+ var object = function () { return UNDEFINED; };
+ object.prototype = new parent();
+ extend(object.prototype, members);
+ return object;
+}
+
+/**
+ * Pad a string to a given length by adding 0 to the beginning
+ * @param {Number} number
+ * @param {Number} length
+ */
+function pad(number, length) {
+ // Create an array of the remaining length +1 and join it with 0's
+ return new Array((length || 2) + 1 - String(number).length).join(0) + number;
+}
+
+/**
+ * Return a length based on either the integer value, or a percentage of a base.
+ */
+function relativeLength (value, base) {
+ return (/%$/).test(value) ? base * parseFloat(value) / 100 : parseFloat(value);
+}
+
+/**
+ * Wrap a method with extended functionality, preserving the original function
+ * @param {Object} obj The context object that the method belongs to
+ * @param {String} method The name of the method to extend
+ * @param {Function} func A wrapper function callback. This function is called with the same arguments
+ * as the original function, except that the original function is unshifted and passed as the first
+ * argument.
+ */
+var wrap = Highcharts.wrap = function (obj, method, func) {
+ var proceed = obj[method];
+ obj[method] = function () {
+ var args = Array.prototype.slice.call(arguments);
+ args.unshift(proceed);
+ return func.apply(this, args);
+ };
+};
+
+
+function getTZOffset(timestamp) {
+ return ((getTimezoneOffset && getTimezoneOffset(timestamp)) || timezoneOffset || 0) * 60000;
+}
+
+/**
+ * Based on http://www.php.net/manual/en/function.strftime.php
+ * @param {String} format
+ * @param {Number} timestamp
+ * @param {Boolean} capitalize
+ */
+dateFormat = function (format, timestamp, capitalize) {
+ if (!defined(timestamp) || isNaN(timestamp)) {
+ return defaultOptions.lang.invalidDate || '';
+ }
+ format = pick(format, '%Y-%m-%d %H:%M:%S');
+
+ var date = new Date(timestamp - getTZOffset(timestamp)),
+ key, // used in for constuct below
+ // get the basic time values
+ hours = date[getHours](),
+ day = date[getDay](),
+ dayOfMonth = date[getDate](),
+ month = date[getMonth](),
+ fullYear = date[getFullYear](),
+ lang = defaultOptions.lang,
+ langWeekdays = lang.weekdays,
+
+ // List all format keys. Custom formats can be added from the outside.
+ replacements = extend({
+
+ // Day
+ 'a': langWeekdays[day].substr(0, 3), // Short weekday, like 'Mon'
+ 'A': langWeekdays[day], // Long weekday, like 'Monday'
+ 'd': pad(dayOfMonth), // Two digit day of the month, 01 to 31
+ 'e': dayOfMonth, // Day of the month, 1 through 31
+ 'w': day,
+
+ // Week (none implemented)
+ //'W': weekNumber(),
+
+ // Month
+ 'b': lang.shortMonths[month], // Short month, like 'Jan'
+ 'B': lang.months[month], // Long month, like 'January'
+ 'm': pad(month + 1), // Two digit month number, 01 through 12
+
+ // Year
+ 'y': fullYear.toString().substr(2, 2), // Two digits year, like 09 for 2009
+ 'Y': fullYear, // Four digits year, like 2009
+
+ // Time
+ 'H': pad(hours), // Two digits hours in 24h format, 00 through 23
+ 'k': hours, // Hours in 24h format, 0 through 23
+ 'I': pad((hours % 12) || 12), // Two digits hours in 12h format, 00 through 11
+ 'l': (hours % 12) || 12, // Hours in 12h format, 1 through 12
+ 'M': pad(date[getMinutes]()), // Two digits minutes, 00 through 59
+ 'p': hours < 12 ? 'AM' : 'PM', // Upper case AM or PM
+ 'P': hours < 12 ? 'am' : 'pm', // Lower case AM or PM
+ 'S': pad(date.getSeconds()), // Two digits seconds, 00 through 59
+ 'L': pad(mathRound(timestamp % 1000), 3) // Milliseconds (naming from Ruby)
+ }, Highcharts.dateFormats);
+
+
+ // do the replaces
+ for (key in replacements) {
+ while (format.indexOf('%' + key) !== -1) { // regex would do it in one line, but this is faster
+ format = format.replace('%' + key, typeof replacements[key] === 'function' ? replacements[key](timestamp) : replacements[key]);
+ }
+ }
+
+ // Optionally capitalize the string and return
+ return capitalize ? format.substr(0, 1).toUpperCase() + format.substr(1) : format;
+};
+
+/**
+ * Format a single variable. Similar to sprintf, without the % prefix.
+ */
+function formatSingle(format, val) {
+ var floatRegex = /f$/,
+ decRegex = /\.([0-9])/,
+ lang = defaultOptions.lang,
+ decimals;
+
+ if (floatRegex.test(format)) { // float
+ decimals = format.match(decRegex);
+ decimals = decimals ? decimals[1] : -1;
+ if (val !== null) {
+ val = Highcharts.numberFormat(
+ val,
+ decimals,
+ lang.decimalPoint,
+ format.indexOf(',') > -1 ? lang.thousandsSep : ''
+ );
+ }
+ } else {
+ val = dateFormat(format, val);
+ }
+ return val;
+}
+
+/**
+ * Format a string according to a subset of the rules of Python's String.format method.
+ */
+function format(str, ctx) {
+ var splitter = '{',
+ isInside = false,
+ segment,
+ valueAndFormat,
+ path,
+ i,
+ len,
+ ret = [],
+ val,
+ index;
+
+ while ((index = str.indexOf(splitter)) !== -1) {
+
+ segment = str.slice(0, index);
+ if (isInside) { // we're on the closing bracket looking back
+
+ valueAndFormat = segment.split(':');
+ path = valueAndFormat.shift().split('.'); // get first and leave format
+ len = path.length;
+ val = ctx;
+
+ // Assign deeper paths
+ for (i = 0; i < len; i++) {
+ val = val[path[i]];
+ }
+
+ // Format the replacement
+ if (valueAndFormat.length) {
+ val = formatSingle(valueAndFormat.join(':'), val);
+ }
+
+ // Push the result and advance the cursor
+ ret.push(val);
+
+ } else {
+ ret.push(segment);
+
+ }
+ str = str.slice(index + 1); // the rest
+ isInside = !isInside; // toggle
+ splitter = isInside ? '}' : '{'; // now look for next matching bracket
+ }
+ ret.push(str);
+ return ret.join('');
+}
+
+/**
+ * Get the magnitude of a number
+ */
+function getMagnitude(num) {
+ return math.pow(10, mathFloor(math.log(num) / math.LN10));
+}
+
+/**
+ * Take an interval and normalize it to multiples of 1, 2, 2.5 and 5
+ * @param {Number} interval
+ * @param {Array} multiples
+ * @param {Number} magnitude
+ * @param {Object} options
+ */
+function normalizeTickInterval(interval, multiples, magnitude, allowDecimals, preventExceed) {
+ var normalized,
+ i,
+ retInterval = interval;
+
+ // round to a tenfold of 1, 2, 2.5 or 5
+ magnitude = pick(magnitude, 1);
+ normalized = interval / magnitude;
+
+ // multiples for a linear scale
+ if (!multiples) {
+ multiples = [1, 2, 2.5, 5, 10];
+
+ // the allowDecimals option
+ if (allowDecimals === false) {
+ if (magnitude === 1) {
+ multiples = [1, 2, 5, 10];
+ } else if (magnitude <= 0.1) {
+ multiples = [1 / magnitude];
+ }
+ }
+ }
+
+ // normalize the interval to the nearest multiple
+ for (i = 0; i < multiples.length; i++) {
+ retInterval = multiples[i];
+ if ((preventExceed && retInterval * magnitude >= interval) || // only allow tick amounts smaller than natural
+ (!preventExceed && (normalized <= (multiples[i] + (multiples[i + 1] || multiples[i])) / 2))) {
+ break;
+ }
+ }
+
+ // multiply back to the correct magnitude
+ retInterval *= magnitude;
+
+ return retInterval;
+}
+
+
+/**
+ * Utility method that sorts an object array and keeping the order of equal items.
+ * ECMA script standard does not specify the behaviour when items are equal.
+ */
+function stableSort(arr, sortFunction) {
+ var length = arr.length,
+ sortValue,
+ i;
+
+ // Add index to each item
+ for (i = 0; i < length; i++) {
+ arr[i].ss_i = i; // stable sort index
+ }
+
+ arr.sort(function (a, b) {
+ sortValue = sortFunction(a, b);
+ return sortValue === 0 ? a.ss_i - b.ss_i : sortValue;
+ });
+
+ // Remove index from items
+ for (i = 0; i < length; i++) {
+ delete arr[i].ss_i; // stable sort index
+ }
+}
+
+/**
+ * Non-recursive method to find the lowest member of an array. Math.min raises a maximum
+ * call stack size exceeded error in Chrome when trying to apply more than 150.000 points. This
+ * method is slightly slower, but safe.
+ */
+function arrayMin(data) {
+ var i = data.length,
+ min = data[0];
+
+ while (i--) {
+ if (data[i] < min) {
+ min = data[i];
+ }
+ }
+ return min;
+}
+
+/**
+ * Non-recursive method to find the lowest member of an array. Math.min raises a maximum
+ * call stack size exceeded error in Chrome when trying to apply more than 150.000 points. This
+ * method is slightly slower, but safe.
+ */
+function arrayMax(data) {
+ var i = data.length,
+ max = data[0];
+
+ while (i--) {
+ if (data[i] > max) {
+ max = data[i];
+ }
+ }
+ return max;
+}
+
+/**
+ * Utility method that destroys any SVGElement or VMLElement that are properties on the given object.
+ * It loops all properties and invokes destroy if there is a destroy method. The property is
+ * then delete'ed.
+ * @param {Object} The object to destroy properties on
+ * @param {Object} Exception, do not destroy this property, only delete it.
+ */
+function destroyObjectProperties(obj, except) {
+ var n;
+ for (n in obj) {
+ // If the object is non-null and destroy is defined
+ if (obj[n] && obj[n] !== except && obj[n].destroy) {
+ // Invoke the destroy
+ obj[n].destroy();
+ }
+
+ // Delete the property from the object.
+ delete obj[n];
+ }
+}
+
+
+/**
+ * Discard an element by moving it to the bin and delete
+ * @param {Object} The HTML node to discard
+ */
+function discardElement(element) {
+ // create a garbage bin element, not part of the DOM
+ if (!garbageBin) {
+ garbageBin = createElement(DIV);
+ }
+
+ // move the node and empty bin
+ if (element) {
+ garbageBin.appendChild(element);
+ }
+ garbageBin.innerHTML = '';
+}
+
+/**
+ * Provide error messages for debugging, with links to online explanation
+ */
+function error (code, stop) {
+ var msg = 'Highcharts error #' + code + ': www.highcharts.com/errors/' + code;
+ if (stop) {
+ throw msg;
+ }
+ // else ...
+ if (win.console) {
+ console.log(msg);
+ }
+}
+
+/**
+ * Fix JS round off float errors
+ * @param {Number} num
+ */
+function correctFloat(num, prec) {
+ return parseFloat(
+ num.toPrecision(prec || 14)
+ );
+}
+
+/**
+ * Set the global animation to either a given value, or fall back to the
+ * given chart's animation option
+ * @param {Object} animation
+ * @param {Object} chart
+ */
+function setAnimation(animation, chart) {
+ chart.renderer.globalAnimation = pick(animation, chart.animation);
+}
+
+/**
+ * The time unit lookup
+ */
+timeUnits = {
+ millisecond: 1,
+ second: 1000,
+ minute: 60000,
+ hour: 3600000,
+ day: 24 * 3600000,
+ week: 7 * 24 * 3600000,
+ month: 28 * 24 * 3600000,
+ year: 364 * 24 * 3600000
+};
+
+
+/**
+ * Format a number and return a string based on input settings
+ * @param {Number} number The input number to format
+ * @param {Number} decimals The amount of decimals
+ * @param {String} decPoint The decimal point, defaults to the one given in the lang options
+ * @param {String} thousandsSep The thousands separator, defaults to the one given in the lang options
+ */
+Highcharts.numberFormat = function (number, decimals, decPoint, thousandsSep) {
+ var lang = defaultOptions.lang,
+ // http://kevin.vanzonneveld.net/techblog/article/javascript_equivalent_for_phps_number_format/
+ n = +number || 0,
+ c = decimals === -1 ?
+ mathMin((n.toString().split('.')[1] || '').length, 20) : // Preserve decimals. Not huge numbers (#3793).
+ (isNaN(decimals = mathAbs(decimals)) ? 2 : decimals),
+ d = decPoint === undefined ? lang.decimalPoint : decPoint,
+ t = thousandsSep === undefined ? lang.thousandsSep : thousandsSep,
+ s = n < 0 ? "-" : "",
+ i = String(pInt(n = mathAbs(n).toFixed(c))),
+ j = i.length > 3 ? i.length % 3 : 0;
+
+ return (s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) +
+ (c ? d + mathAbs(n - i).toFixed(c).slice(2) : ""));
+};
+
+
+/**
+ * Path interpolation algorithm used across adapters
+ */
+pathAnim = {
+ /**
+ * Prepare start and end values so that the path can be animated one to one
+ */
+ init: function (elem, fromD, toD) {
+ fromD = fromD || '';
+ var shift = elem.shift,
+ bezier = fromD.indexOf('C') > -1,
+ numParams = bezier ? 7 : 3,
+ endLength,
+ slice,
+ i,
+ start = fromD.split(' '),
+ end = [].concat(toD), // copy
+ startBaseLine,
+ endBaseLine,
+ sixify = function (arr) { // in splines make move points have six parameters like bezier curves
+ i = arr.length;
+ while (i--) {
+ if (arr[i] === M) {
+ arr.splice(i + 1, 0, arr[i + 1], arr[i + 2], arr[i + 1], arr[i + 2]);
+ }
+ }
+ };
+
+ if (bezier) {
+ sixify(start);
+ sixify(end);
+ }
+
+ // pull out the base lines before padding
+ if (elem.isArea) {
+ startBaseLine = start.splice(start.length - 6, 6);
+ endBaseLine = end.splice(end.length - 6, 6);
+ }
+
+ // if shifting points, prepend a dummy point to the end path
+ if (shift <= end.length / numParams && start.length === end.length) {
+ while (shift--) {
+ end = [].concat(end).splice(0, numParams).concat(end);
+ }
+ }
+ elem.shift = 0; // reset for following animations
+
+ // copy and append last point until the length matches the end length
+ if (start.length) {
+ endLength = end.length;
+ while (start.length < endLength) {
+
+ //bezier && sixify(start);
+ slice = [].concat(start).splice(start.length - numParams, numParams);
+ if (bezier) { // disable first control point
+ slice[numParams - 6] = slice[numParams - 2];
+ slice[numParams - 5] = slice[numParams - 1];
+ }
+ start = start.concat(slice);
+ }
+ }
+
+ if (startBaseLine) { // append the base lines for areas
+ start = start.concat(startBaseLine);
+ end = end.concat(endBaseLine);
+ }
+ return [start, end];
+ },
+
+ /**
+ * Interpolate each value of the path and return the array
+ */
+ step: function (start, end, pos, complete) {
+ var ret = [],
+ i = start.length,
+ startVal;
+
+ if (pos === 1) { // land on the final path without adjustment points appended in the ends
+ ret = complete;
+
+ } else if (i === end.length && pos < 1) {
+ while (i--) {
+ startVal = parseFloat(start[i]);
+ ret[i] =
+ isNaN(startVal) ? // a letter instruction like M or L
+ start[i] :
+ pos * (parseFloat(end[i] - startVal)) + startVal;
+
+ }
+ } else { // if animation is finished or length not matching, land on right value
+ ret = end;
+ }
+ return ret;
+ }
+};
+
+
+
+
+
+
+// check for a custom HighchartsAdapter defined prior to this file
+var globalAdapter = win.HighchartsAdapter,
+ adapter = globalAdapter || {};
+
+// Initialize the adapter
+if (globalAdapter) {
+ globalAdapter.init.call(globalAdapter, pathAnim);
+}
+
+
+// Utility functions. If the HighchartsAdapter is not defined, adapter is an empty object
+// and all the utility functions will be null. In that case they are populated by the
+// default adapters below.
+var adapterRun = adapter.adapterRun,
+ getScript = adapter.getScript,
+ inArray = adapter.inArray,
+ each = Highcharts.each = adapter.each,
+ grep = adapter.grep,
+ offset = adapter.offset,
+ map = adapter.map,
+ addEvent = adapter.addEvent,
+ removeEvent = adapter.removeEvent,
+ fireEvent = adapter.fireEvent,
+ washMouseEvent = adapter.washMouseEvent,
+ animate = adapter.animate,
+ stop = adapter.stop;
+
+
+
+
+
+/* ****************************************************************************
+ * Handle the options *
+ *****************************************************************************/
+defaultOptions = {
+ colors: ['#7cb5ec', '#434348', '#90ed7d', '#f7a35c',
+ '#8085e9', '#f15c80', '#e4d354', '#2b908f', '#f45b5b', '#91e8e1'],
+ symbols: ['circle', 'diamond', 'square', 'triangle', 'triangle-down'],
+ lang: {
+ loading: 'Loading...',
+ months: ['January', 'February', 'March', 'April', 'May', 'June', 'July',
+ 'August', 'September', 'October', 'November', 'December'],
+ shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+ weekdays: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+ // invalidDate: '',
+ decimalPoint: '.',
+ numericSymbols: ['k', 'M', 'G', 'T', 'P', 'E'], // SI prefixes used in axis labels
+ resetZoom: 'Reset zoom',
+ resetZoomTitle: 'Reset zoom level 1:1',
+ thousandsSep: ' '
+ },
+ global: {
+ useUTC: true,
+ //timezoneOffset: 0,
+ canvasToolsURL: 'http://code.highcharts.com@product.cdnpath@//Highstock 2.1.9/modules/canvas-tools.js',
+ VMLRadialGradientURL: 'http://code.highcharts.com@product.cdnpath@//Highstock 2.1.9/gfx/vml-radial-gradient.png'
+ },
+ chart: {
+ //animation: true,
+ //alignTicks: false,
+ //reflow: true,
+ //className: null,
+ //events: { load, selection },
+ //margin: [null],
+ //marginTop: null,
+ //marginRight: null,
+ //marginBottom: null,
+ //marginLeft: null,
+ borderColor: '#4572A7',
+ //borderWidth: 0,
+ borderRadius: 0,
+ defaultSeriesType: 'line',
+ ignoreHiddenSeries: true,
+ //inverted: false,
+ //shadow: false,
+ spacing: [10, 10, 15, 10],
+ //spacingTop: 10,
+ //spacingRight: 10,
+ //spacingBottom: 15,
+ //spacingLeft: 10,
+ //style: {
+ // fontFamily: '"Lucida Grande", "Lucida Sans Unicode", Verdana, Arial, Helvetica, sans-serif', // default font
+ // fontSize: '12px'
+ //},
+ backgroundColor: '#FFFFFF',
+ //plotBackgroundColor: null,
+ plotBorderColor: '#C0C0C0',
+ //plotBorderWidth: 0,
+ //plotShadow: false,
+ //zoomType: ''
+ resetZoomButton: {
+ theme: {
+ zIndex: 20
+ },
+ position: {
+ align: 'right',
+ x: -10,
+ //verticalAlign: 'top',
+ y: 10
+ }
+ // relativeTo: 'plot'
+ }
+ },
+ title: {
+ text: 'Chart title',
+ align: 'center',
+ // floating: false,
+ margin: 15,
+ // x: 0,
+ // verticalAlign: 'top',
+ // y: null,
+ style: {
+ color: '#333333',
+ fontSize: '18px'
+ }
+
+ },
+ subtitle: {
+ text: '',
+ align: 'center',
+ // floating: false
+ // x: 0,
+ // verticalAlign: 'top',
+ // y: null,
+ style: {
+ color: '#555555'
+ }
+ },
+
+ plotOptions: {
+ line: { // base series options
+ allowPointSelect: false,
+ showCheckbox: false,
+ animation: {
+ duration: 1000
+ },
+ //connectNulls: false,
+ //cursor: 'default',
+ //clip: true,
+ //dashStyle: null,
+ //enableMouseTracking: true,
+ events: {},
+ //legendIndex: 0,
+ //linecap: 'round',
+ lineWidth: 2,
+ //shadow: false,
+ // stacking: null,
+ marker: {
+ //enabled: true,
+ //symbol: null,
+ lineWidth: 0,
+ radius: 4,
+ lineColor: '#FFFFFF',
+ //fillColor: null,
+ states: { // states for a single point
+ hover: {
+ enabled: true,
+ lineWidthPlus: 1,
+ radiusPlus: 2
+ },
+ select: {
+ fillColor: '#FFFFFF',
+ lineColor: '#000000',
+ lineWidth: 2
+ }
+ }
+ },
+ point: {
+ events: {}
+ },
+ dataLabels: {
+ align: 'center',
+ // defer: true,
+ // enabled: false,
+ formatter: function () {
+ return this.y === null ? '' : Highcharts.numberFormat(this.y, -1);
+ },
+ style: {
+ color: 'contrast',
+ fontSize: '11px',
+ fontWeight: 'bold',
+ textShadow: '0 0 6px contrast, 0 0 3px contrast'
+ },
+ verticalAlign: 'bottom', // above singular point
+ x: 0,
+ y: 0,
+ // backgroundColor: undefined,
+ // borderColor: undefined,
+ // borderRadius: undefined,
+ // borderWidth: undefined,
+ padding: 5
+ // shadow: false
+ },
+ cropThreshold: 300, // draw points outside the plot area when the number of points is less than this
+ pointRange: 0,
+ //pointStart: 0,
+ //pointInterval: 1,
+ //showInLegend: null, // auto: true for standalone series, false for linked series
+ softThreshold: true,
+ states: { // states for the entire series
+ hover: {
+ //enabled: false,
+ lineWidthPlus: 1,
+ marker: {
+ // lineWidth: base + 1,
+ // radius: base + 1
+ },
+ halo: {
+ size: 10,
+ opacity: 0.25
+ }
+ },
+ select: {
+ marker: {}
+ }
+ },
+ stickyTracking: true,
+ //tooltip: {
+ //pointFormat: '\u25CF {series.name}: {point.y}'
+ //valueDecimals: null,
+ //xDateFormat: '%A, %b %e, %Y',
+ //valuePrefix: '',
+ //ySuffix: ''
+ //}
+ turboThreshold: 1000
+ // zIndex: null
+ }
+ },
+ labels: {
+ //items: [],
+ style: {
+ //font: defaultFont,
+ position: ABSOLUTE,
+ color: '#3E576F'
+ }
+ },
+ legend: {
+ enabled: true,
+ align: 'center',
+ //floating: false,
+ layout: 'horizontal',
+ labelFormatter: function () {
+ return this.name;
+ },
+ //borderWidth: 0,
+ borderColor: '#909090',
+ borderRadius: 0,
+ navigation: {
+ // animation: true,
+ activeColor: '#274b6d',
+ // arrowSize: 12
+ inactiveColor: '#CCC'
+ // style: {} // text styles
+ },
+ // margin: 20,
+ // reversed: false,
+ shadow: false,
+ // backgroundColor: null,
+ /*style: {
+ padding: '5px'
+ },*/
+ itemStyle: {
+ color: '#333333',
+ fontSize: '12px',
+ fontWeight: 'bold'
+ },
+ itemHoverStyle: {
+ //cursor: 'pointer', removed as of #601
+ color: '#000'
+ },
+ itemHiddenStyle: {
+ color: '#CCC'
+ },
+ itemCheckboxStyle: {
+ position: ABSOLUTE,
+ width: '13px', // for IE precision
+ height: '13px'
+ },
+ // itemWidth: undefined,
+ // symbolRadius: 0,
+ // symbolWidth: 16,
+ symbolPadding: 5,
+ verticalAlign: 'bottom',
+ // width: undefined,
+ x: 0,
+ y: 0,
+ title: {
+ //text: null,
+ style: {
+ fontWeight: 'bold'
+ }
+ }
+ },
+
+ loading: {
+ // hideDuration: 100,
+ labelStyle: {
+ fontWeight: 'bold',
+ position: RELATIVE,
+ top: '45%'
+ },
+ // showDuration: 0,
+ style: {
+ position: ABSOLUTE,
+ backgroundColor: 'white',
+ opacity: 0.5,
+ textAlign: 'center'
+ }
+ },
+
+ tooltip: {
+ enabled: true,
+ animation: hasSVG,
+ //crosshairs: null,
+ backgroundColor: 'rgba(249, 249, 249, .85)',
+ borderWidth: 1,
+ borderRadius: 3,
+ dateTimeLabelFormats: {
+ millisecond: '%A, %b %e, %H:%M:%S.%L',
+ second: '%A, %b %e, %H:%M:%S',
+ minute: '%A, %b %e, %H:%M',
+ hour: '%A, %b %e, %H:%M',
+ day: '%A, %b %e, %Y',
+ week: 'Week from %A, %b %e, %Y',
+ month: '%B %Y',
+ year: '%Y'
+ },
+ footerFormat: '',
+ //formatter: defaultFormatter,
+ headerFormat: '{point.key}
',
+ pointFormat: '\u25CF {series.name}: {point.y}
',
+ shadow: true,
+ //shape: 'callout',
+ //shared: false,
+ snap: isTouchDevice ? 25 : 10,
+ style: {
+ color: '#333333',
+ cursor: 'default',
+ fontSize: '12px',
+ padding: '8px',
+ pointerEvents: 'none', // #1686 http://caniuse.com/#feat=pointer-events
+ whiteSpace: 'nowrap'
+ }
+ //xDateFormat: '%A, %b %e, %Y',
+ //valueDecimals: null,
+ //valuePrefix: '',
+ //valueSuffix: ''
+ },
+
+ credits: {
+ enabled: true,
+ text: 'Highcharts.com',
+ href: 'http://www.highcharts.com',
+ position: {
+ align: 'right',
+ x: -10,
+ verticalAlign: 'bottom',
+ y: -5
+ },
+ style: {
+ cursor: 'pointer',
+ color: '#909090',
+ fontSize: '9px'
+ }
+ }
+};
+
+
+
+
+// Series defaults
+var defaultPlotOptions = defaultOptions.plotOptions,
+ defaultSeriesOptions = defaultPlotOptions.line;
+
+// set the default time methods
+setTimeMethods();
+
+
+
+/**
+ * Set the time methods globally based on the useUTC option. Time method can be either
+ * local time or UTC (default).
+ */
+function setTimeMethods() {
+ var globalOptions = defaultOptions.global,
+ useUTC = globalOptions.useUTC,
+ GET = useUTC ? 'getUTC' : 'get',
+ SET = useUTC ? 'setUTC' : 'set';
+
+
+ Date = globalOptions.Date || window.Date;
+ timezoneOffset = useUTC && globalOptions.timezoneOffset;
+ getTimezoneOffset = useUTC && globalOptions.getTimezoneOffset;
+ makeTime = function (year, month, date, hours, minutes, seconds) {
+ var d;
+ if (useUTC) {
+ d = Date.UTC.apply(0, arguments);
+ d += getTZOffset(d);
+ } else {
+ d = new Date(
+ year,
+ month,
+ pick(date, 1),
+ pick(hours, 0),
+ pick(minutes, 0),
+ pick(seconds, 0)
+ ).getTime();
+ }
+ return d;
+ };
+ getMinutes = GET + 'Minutes';
+ getHours = GET + 'Hours';
+ getDay = GET + 'Day';
+ getDate = GET + 'Date';
+ getMonth = GET + 'Month';
+ getFullYear = GET + 'FullYear';
+ setMilliseconds = SET + 'Milliseconds';
+ setSeconds = SET + 'Seconds';
+ setMinutes = SET + 'Minutes';
+ setHours = SET + 'Hours';
+ setDate = SET + 'Date';
+ setMonth = SET + 'Month';
+ setFullYear = SET + 'FullYear';
+
+}
+
+/**
+ * Merge the default options with custom options and return the new options structure
+ * @param {Object} options The new custom options
+ */
+function setOptions(options) {
+
+ // Copy in the default options
+ defaultOptions = merge(true, defaultOptions, options);
+
+ // Apply UTC
+ setTimeMethods();
+
+ return defaultOptions;
+}
+
+/**
+ * Get the updated default options. Until 3.0.7, merely exposing defaultOptions for outside modules
+ * wasn't enough because the setOptions method created a new object.
+ */
+function getOptions() {
+ return defaultOptions;
+}
+
+
+
+
+/**
+ * Handle color operations. The object methods are chainable.
+ * @param {String} input The input color in either rbga or hex format
+ */
+var rgbaRegEx = /rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]?(?:\.[0-9]+)?)\s*\)/,
+ hexRegEx = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/,
+ rgbRegEx = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/;
+
+var Color = function (input) {
+ // declare variables
+ var rgba = [], result, stops;
+
+ /**
+ * Parse the input color to rgba array
+ * @param {String} input
+ */
+ function init(input) {
+
+ // Gradients
+ if (input && input.stops) {
+ stops = map(input.stops, function (stop) {
+ return Color(stop[1]);
+ });
+
+ // Solid colors
+ } else {
+ // rgba
+ result = rgbaRegEx.exec(input);
+ if (result) {
+ rgba = [pInt(result[1]), pInt(result[2]), pInt(result[3]), parseFloat(result[4], 10)];
+ } else {
+ // hex
+ result = hexRegEx.exec(input);
+ if (result) {
+ rgba = [pInt(result[1], 16), pInt(result[2], 16), pInt(result[3], 16), 1];
+ } else {
+ // rgb
+ result = rgbRegEx.exec(input);
+ if (result) {
+ rgba = [pInt(result[1]), pInt(result[2]), pInt(result[3]), 1];
+ }
+ }
+ }
+ }
+
+ }
+ /**
+ * Return the color a specified format
+ * @param {String} format
+ */
+ function get(format) {
+ var ret;
+
+ if (stops) {
+ ret = merge(input);
+ ret.stops = [].concat(ret.stops);
+ each(stops, function (stop, i) {
+ ret.stops[i] = [ret.stops[i][0], stop.get(format)];
+ });
+
+ // it's NaN if gradient colors on a column chart
+ } else if (rgba && !isNaN(rgba[0])) {
+ if (format === 'rgb') {
+ ret = 'rgb(' + rgba[0] + ',' + rgba[1] + ',' + rgba[2] + ')';
+ } else if (format === 'a') {
+ ret = rgba[3];
+ } else {
+ ret = 'rgba(' + rgba.join(',') + ')';
+ }
+ } else {
+ ret = input;
+ }
+ return ret;
+ }
+
+ /**
+ * Brighten the color
+ * @param {Number} alpha
+ */
+ function brighten(alpha) {
+ if (stops) {
+ each(stops, function (stop) {
+ stop.brighten(alpha);
+ });
+
+ } else if (isNumber(alpha) && alpha !== 0) {
+ var i;
+ for (i = 0; i < 3; i++) {
+ rgba[i] += pInt(alpha * 255);
+
+ if (rgba[i] < 0) {
+ rgba[i] = 0;
+ }
+ if (rgba[i] > 255) {
+ rgba[i] = 255;
+ }
+ }
+ }
+ return this;
+ }
+ /**
+ * Set the color's opacity to a given alpha value
+ * @param {Number} alpha
+ */
+ function setOpacity(alpha) {
+ rgba[3] = alpha;
+ return this;
+ }
+
+ // initialize: parse the input
+ init(input);
+
+ // public methods
+ return {
+ get: get,
+ brighten: brighten,
+ rgba: rgba,
+ setOpacity: setOpacity,
+ raw: input
+ };
+};
+
+
+
+
+/**
+ * A wrapper object for SVG elements
+ */
+function SVGElement() {}
+
+SVGElement.prototype = {
+
+ // Default base for animation
+ opacity: 1,
+ // For labels, these CSS properties are applied to the node directly
+ textProps: ['fontSize', 'fontWeight', 'fontFamily', 'fontStyle', 'color',
+ 'lineHeight', 'width', 'textDecoration', 'textOverflow', 'textShadow'],
+
+ /**
+ * Initialize the SVG renderer
+ * @param {Object} renderer
+ * @param {String} nodeName
+ */
+ init: function (renderer, nodeName) {
+ var wrapper = this;
+ wrapper.element = nodeName === 'span' ?
+ createElement(nodeName) :
+ doc.createElementNS(SVG_NS, nodeName);
+ wrapper.renderer = renderer;
+ },
+
+ /**
+ * Animate a given attribute
+ * @param {Object} params
+ * @param {Number} options The same options as in jQuery animation
+ * @param {Function} complete Function to perform at the end of animation
+ */
+ animate: function (params, options, complete) {
+ var animOptions = pick(options, this.renderer.globalAnimation, true);
+ stop(this); // stop regardless of animation actually running, or reverting to .attr (#607)
+ if (animOptions) {
+ animOptions = merge(animOptions, {}); //#2625
+ if (complete) { // allows using a callback with the global animation without overwriting it
+ animOptions.complete = complete;
+ }
+ animate(this, params, animOptions);
+ } else {
+ this.attr(params, null, complete);
+ }
+ return this;
+ },
+
+ /**
+ * Build an SVG gradient out of a common JavaScript configuration object
+ */
+ colorGradient: function (color, prop, elem) {
+ var renderer = this.renderer,
+ colorObject,
+ gradName,
+ gradAttr,
+ radAttr,
+ gradients,
+ gradientObject,
+ stops,
+ stopColor,
+ stopOpacity,
+ radialReference,
+ n,
+ id,
+ key = [];
+
+ // Apply linear or radial gradients
+ if (color.linearGradient) {
+ gradName = 'linearGradient';
+ } else if (color.radialGradient) {
+ gradName = 'radialGradient';
+ }
+
+ if (gradName) {
+ gradAttr = color[gradName];
+ gradients = renderer.gradients;
+ stops = color.stops;
+ radialReference = elem.radialReference;
+
+ // Keep < 2.2 kompatibility
+ if (isArray(gradAttr)) {
+ color[gradName] = gradAttr = {
+ x1: gradAttr[0],
+ y1: gradAttr[1],
+ x2: gradAttr[2],
+ y2: gradAttr[3],
+ gradientUnits: 'userSpaceOnUse'
+ };
+ }
+
+ // Correct the radial gradient for the radial reference system
+ if (gradName === 'radialGradient' && radialReference && !defined(gradAttr.gradientUnits)) {
+ radAttr = gradAttr; // Save the radial attributes for updating
+ gradAttr = merge(gradAttr,
+ renderer.getRadialAttr(radialReference, radAttr),
+ { gradientUnits: 'userSpaceOnUse' }
+ );
+ }
+
+ // Build the unique key to detect whether we need to create a new element (#1282)
+ for (n in gradAttr) {
+ if (n !== 'id') {
+ key.push(n, gradAttr[n]);
+ }
+ }
+ for (n in stops) {
+ key.push(stops[n]);
+ }
+ key = key.join(',');
+
+ // Check if a gradient object with the same config object is created within this renderer
+ if (gradients[key]) {
+ id = gradients[key].attr('id');
+
+ } else {
+
+ // Set the id and create the element
+ gradAttr.id = id = PREFIX + idCounter++;
+ gradients[key] = gradientObject = renderer.createElement(gradName)
+ .attr(gradAttr)
+ .add(renderer.defs);
+
+ gradientObject.radAttr = radAttr;
+
+ // The gradient needs to keep a list of stops to be able to destroy them
+ gradientObject.stops = [];
+ each(stops, function (stop) {
+ var stopObject;
+ if (stop[1].indexOf('rgba') === 0) {
+ colorObject = Color(stop[1]);
+ stopColor = colorObject.get('rgb');
+ stopOpacity = colorObject.get('a');
+ } else {
+ stopColor = stop[1];
+ stopOpacity = 1;
+ }
+ stopObject = renderer.createElement('stop').attr({
+ offset: stop[0],
+ 'stop-color': stopColor,
+ 'stop-opacity': stopOpacity
+ }).add(gradientObject);
+
+ // Add the stop element to the gradient
+ gradientObject.stops.push(stopObject);
+ });
+ }
+
+ // Set the reference to the gradient object
+ elem.setAttribute(prop, 'url(' + renderer.url + '#' + id + ')');
+ elem.gradient = key;
+ }
+ },
+
+ /**
+ * Apply a polyfill to the text-stroke CSS property, by copying the text element
+ * and apply strokes to the copy.
+ *
+ * Contrast checks at http://jsfiddle.net/highcharts/43soe9m1/2/
+ *
+ * docs: update default, document the polyfill and the limitations on hex colors and pixel values, document contrast pseudo-color
+ */
+ applyTextShadow: function (textShadow) {
+ var elem = this.element,
+ tspans,
+ hasContrast = textShadow.indexOf('contrast') !== -1,
+ styles = {},
+ forExport = this.renderer.forExport,
+ // IE10 and IE11 report textShadow in elem.style even though it doesn't work. Check
+ // this again with new IE release. In exports, the rendering is passed to PhantomJS.
+ supports = forExport || (elem.style.textShadow !== UNDEFINED && !isMS);
+
+ // When the text shadow is set to contrast, use dark stroke for light text and vice versa
+ if (hasContrast) {
+ styles.textShadow = textShadow = textShadow.replace(/contrast/g, this.renderer.getContrast(elem.style.fill));
+ }
+
+ // Safari with retina displays as well as PhantomJS bug (#3974). Firefox does not tolerate this,
+ // it removes the text shadows.
+ if (isWebKit || forExport) {
+ styles.textRendering = 'geometricPrecision';
+ }
+
+ /* Selective side-by-side testing in supported browser (http://jsfiddle.net/highcharts/73L1ptrh/)
+ if (elem.textContent.indexOf('2.') === 0) {
+ elem.style['text-shadow'] = 'none';
+ supports = false;
+ }
+ // */
+
+ // No reason to polyfill, we've got native support
+ if (supports) {
+ this.css(styles); // Apply altered textShadow or textRendering workaround
+ } else {
+
+ this.fakeTS = true; // Fake text shadow
+
+ // In order to get the right y position of the clones,
+ // copy over the y setter
+ this.ySetter = this.xSetter;
+
+ tspans = [].slice.call(elem.getElementsByTagName('tspan'));
+ each(textShadow.split(/\s?,\s?/g), function (textShadow) {
+ var firstChild = elem.firstChild,
+ color,
+ strokeWidth;
+
+ textShadow = textShadow.split(' ');
+ color = textShadow[textShadow.length - 1];
+
+ // Approximately tune the settings to the text-shadow behaviour
+ strokeWidth = textShadow[textShadow.length - 2];
+
+ if (strokeWidth) {
+ each(tspans, function (tspan, y) {
+ var clone;
+
+ // Let the first line start at the correct X position
+ if (y === 0) {
+ tspan.setAttribute('x', elem.getAttribute('x'));
+ y = elem.getAttribute('y');
+ tspan.setAttribute('y', y || 0);
+ if (y === null) {
+ elem.setAttribute('y', 0);
+ }
+ }
+
+ // Create the clone and apply shadow properties
+ clone = tspan.cloneNode(1);
+ attr(clone, {
+ 'class': PREFIX + 'text-shadow',
+ 'fill': color,
+ 'stroke': color,
+ 'stroke-opacity': 1 / mathMax(pInt(strokeWidth), 3),
+ 'stroke-width': strokeWidth,
+ 'stroke-linejoin': 'round'
+ });
+ elem.insertBefore(clone, firstChild);
+ });
+ }
+ });
+ }
+ },
+
+ /**
+ * Set or get a given attribute
+ * @param {Object|String} hash
+ * @param {Mixed|Undefined} val
+ */
+ attr: function (hash, val, complete) {
+ var key,
+ value,
+ element = this.element,
+ hasSetSymbolSize,
+ ret = this,
+ skipAttr;
+
+ // single key-value pair
+ if (typeof hash === 'string' && val !== UNDEFINED) {
+ key = hash;
+ hash = {};
+ hash[key] = val;
+ }
+
+ // used as a getter: first argument is a string, second is undefined
+ if (typeof hash === 'string') {
+ ret = (this[hash + 'Getter'] || this._defaultGetter).call(this, hash, element);
+
+ // setter
+ } else {
+
+ for (key in hash) {
+ value = hash[key];
+ skipAttr = false;
+
+
+
+ if (this.symbolName && /^(x|y|width|height|r|start|end|innerR|anchorX|anchorY)/.test(key)) {
+ if (!hasSetSymbolSize) {
+ this.symbolAttr(hash);
+ hasSetSymbolSize = true;
+ }
+ skipAttr = true;
+ }
+
+ if (this.rotation && (key === 'x' || key === 'y')) {
+ this.doTransform = true;
+ }
+
+ if (!skipAttr) {
+ (this[key + 'Setter'] || this._defaultSetter).call(this, value, key, element);
+ }
+
+ // Let the shadow follow the main element
+ if (this.shadows && /^(width|height|visibility|x|y|d|transform|cx|cy|r)$/.test(key)) {
+ this.updateShadows(key, value);
+ }
+ }
+
+ // Update transform. Do this outside the loop to prevent redundant updating for batch setting
+ // of attributes.
+ if (this.doTransform) {
+ this.updateTransform();
+ this.doTransform = false;
+ }
+
+ }
+
+ // In accordance with animate, run a complete callback
+ if (complete) {
+ complete();
+ }
+
+ return ret;
+ },
+
+ updateShadows: function (key, value) {
+ var shadows = this.shadows,
+ i = shadows.length;
+ while (i--) {
+ shadows[i].setAttribute(
+ key,
+ key === 'height' ?
+ mathMax(value - (shadows[i].cutHeight || 0), 0) :
+ key === 'd' ? this.d : value
+ );
+ }
+ },
+
+ /**
+ * Add a class name to an element
+ */
+ addClass: function (className) {
+ var element = this.element,
+ currentClassName = attr(element, 'class') || '';
+
+ if (currentClassName.indexOf(className) === -1) {
+ attr(element, 'class', currentClassName + ' ' + className);
+ }
+ return this;
+ },
+ /* hasClass and removeClass are not (yet) needed
+ hasClass: function (className) {
+ return attr(this.element, 'class').indexOf(className) !== -1;
+ },
+ removeClass: function (className) {
+ attr(this.element, 'class', attr(this.element, 'class').replace(className, ''));
+ return this;
+ },
+ */
+
+ /**
+ * If one of the symbol size affecting parameters are changed,
+ * check all the others only once for each call to an element's
+ * .attr() method
+ * @param {Object} hash
+ */
+ symbolAttr: function (hash) {
+ var wrapper = this;
+
+ each(['x', 'y', 'r', 'start', 'end', 'width', 'height', 'innerR', 'anchorX', 'anchorY'], function (key) {
+ wrapper[key] = pick(hash[key], wrapper[key]);
+ });
+
+ wrapper.attr({
+ d: wrapper.renderer.symbols[wrapper.symbolName](
+ wrapper.x,
+ wrapper.y,
+ wrapper.width,
+ wrapper.height,
+ wrapper
+ )
+ });
+ },
+
+ /**
+ * Apply a clipping path to this object
+ * @param {String} id
+ */
+ clip: function (clipRect) {
+ return this.attr('clip-path', clipRect ? 'url(' + this.renderer.url + '#' + clipRect.id + ')' : NONE);
+ },
+
+ /**
+ * Calculate the coordinates needed for drawing a rectangle crisply and return the
+ * calculated attributes
+ * @param {Number} strokeWidth
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} width
+ * @param {Number} height
+ */
+ crisp: function (rect) {
+
+ var wrapper = this,
+ key,
+ attribs = {},
+ normalizer,
+ strokeWidth = rect.strokeWidth || wrapper.strokeWidth || 0;
+
+ normalizer = mathRound(strokeWidth) % 2 / 2; // mathRound because strokeWidth can sometimes have roundoff errors
+
+ // normalize for crisp edges
+ rect.x = mathFloor(rect.x || wrapper.x || 0) + normalizer;
+ rect.y = mathFloor(rect.y || wrapper.y || 0) + normalizer;
+ rect.width = mathFloor((rect.width || wrapper.width || 0) - 2 * normalizer);
+ rect.height = mathFloor((rect.height || wrapper.height || 0) - 2 * normalizer);
+ rect.strokeWidth = strokeWidth;
+
+ for (key in rect) {
+ if (wrapper[key] !== rect[key]) { // only set attribute if changed
+ wrapper[key] = attribs[key] = rect[key];
+ }
+ }
+
+ return attribs;
+ },
+
+ /**
+ * Set styles for the element
+ * @param {Object} styles
+ */
+ css: function (styles) {
+ var elemWrapper = this,
+ oldStyles = elemWrapper.styles,
+ newStyles = {},
+ elem = elemWrapper.element,
+ textWidth,
+ n,
+ serializedCss = '',
+ hyphenate,
+ hasNew = !oldStyles;
+
+ // convert legacy
+ if (styles && styles.color) {
+ styles.fill = styles.color;
+ }
+
+ // Filter out existing styles to increase performance (#2640)
+ if (oldStyles) {
+ for (n in styles) {
+ if (styles[n] !== oldStyles[n]) {
+ newStyles[n] = styles[n];
+ hasNew = true;
+ }
+ }
+ }
+ if (hasNew) {
+ textWidth = elemWrapper.textWidth =
+ (styles && styles.width && elem.nodeName.toLowerCase() === 'text' && pInt(styles.width)) ||
+ elemWrapper.textWidth; // #3501
+
+ // Merge the new styles with the old ones
+ if (oldStyles) {
+ styles = extend(
+ oldStyles,
+ newStyles
+ );
+ }
+
+ // store object
+ elemWrapper.styles = styles;
+
+ if (textWidth && (useCanVG || (!hasSVG && elemWrapper.renderer.forExport))) {
+ delete styles.width;
+ }
+
+ // serialize and set style attribute
+ if (isMS && !hasSVG) {
+ css(elemWrapper.element, styles);
+ } else {
+ /*jslint unparam: true*/
+ hyphenate = function (a, b) { return '-' + b.toLowerCase(); };
+ /*jslint unparam: false*/
+ for (n in styles) {
+ serializedCss += n.replace(/([A-Z])/g, hyphenate) + ':' + styles[n] + ';';
+ }
+ attr(elem, 'style', serializedCss); // #1881
+ }
+
+
+ // re-build text
+ if (textWidth && elemWrapper.added) {
+ elemWrapper.renderer.buildText(elemWrapper);
+ }
+ }
+
+ return elemWrapper;
+ },
+
+ /**
+ * Add an event listener
+ * @param {String} eventType
+ * @param {Function} handler
+ */
+ on: function (eventType, handler) {
+ var svgElement = this,
+ element = svgElement.element;
+
+ // touch
+ if (hasTouch && eventType === 'click') {
+ element.ontouchstart = function (e) {
+ svgElement.touchEventFired = Date.now();
+ e.preventDefault();
+ handler.call(element, e);
+ };
+ element.onclick = function (e) {
+ if (userAgent.indexOf('Android') === -1 || Date.now() - (svgElement.touchEventFired || 0) > 1100) { // #2269
+ handler.call(element, e);
+ }
+ };
+ } else {
+ // simplest possible event model for internal use
+ element['on' + eventType] = handler;
+ }
+ return this;
+ },
+
+ /**
+ * Set the coordinates needed to draw a consistent radial gradient across
+ * pie slices regardless of positioning inside the chart. The format is
+ * [centerX, centerY, diameter] in pixels.
+ */
+ setRadialReference: function (coordinates) {
+ var existingGradient = this.renderer.gradients[this.element.gradient];
+
+ this.element.radialReference = coordinates;
+
+ // On redrawing objects with an existing gradient, the gradient needs
+ // to be repositioned (#3801)
+ if (existingGradient && existingGradient.radAttr) {
+ existingGradient.animate(
+ this.renderer.getRadialAttr(
+ coordinates,
+ existingGradient.radAttr
+ )
+ );
+ }
+
+ return this;
+ },
+
+ /**
+ * Move an object and its children by x and y values
+ * @param {Number} x
+ * @param {Number} y
+ */
+ translate: function (x, y) {
+ return this.attr({
+ translateX: x,
+ translateY: y
+ });
+ },
+
+ /**
+ * Invert a group, rotate and flip
+ */
+ invert: function () {
+ var wrapper = this;
+ wrapper.inverted = true;
+ wrapper.updateTransform();
+ return wrapper;
+ },
+
+ /**
+ * Private method to update the transform attribute based on internal
+ * properties
+ */
+ updateTransform: function () {
+ var wrapper = this,
+ translateX = wrapper.translateX || 0,
+ translateY = wrapper.translateY || 0,
+ scaleX = wrapper.scaleX,
+ scaleY = wrapper.scaleY,
+ inverted = wrapper.inverted,
+ rotation = wrapper.rotation,
+ element = wrapper.element,
+ transform;
+
+ // flipping affects translate as adjustment for flipping around the group's axis
+ if (inverted) {
+ translateX += wrapper.attr('width');
+ translateY += wrapper.attr('height');
+ }
+
+ // Apply translate. Nearly all transformed elements have translation, so instead
+ // of checking for translate = 0, do it always (#1767, #1846).
+ transform = ['translate(' + translateX + ',' + translateY + ')'];
+
+ // apply rotation
+ if (inverted) {
+ transform.push('rotate(90) scale(-1,1)');
+ } else if (rotation) { // text rotation
+ transform.push('rotate(' + rotation + ' ' + (element.getAttribute('x') || 0) + ' ' + (element.getAttribute('y') || 0) + ')');
+
+ // Delete bBox memo when the rotation changes
+ //delete wrapper.bBox;
+ }
+
+ // apply scale
+ if (defined(scaleX) || defined(scaleY)) {
+ transform.push('scale(' + pick(scaleX, 1) + ' ' + pick(scaleY, 1) + ')');
+ }
+
+ if (transform.length) {
+ element.setAttribute('transform', transform.join(' '));
+ }
+ },
+ /**
+ * Bring the element to the front
+ */
+ toFront: function () {
+ var element = this.element;
+ element.parentNode.appendChild(element);
+ return this;
+ },
+
+
+ /**
+ * Break down alignment options like align, verticalAlign, x and y
+ * to x and y relative to the chart.
+ *
+ * @param {Object} alignOptions
+ * @param {Boolean} alignByTranslate
+ * @param {String[Object} box The box to align to, needs a width and height. When the
+ * box is a string, it refers to an object in the Renderer. For example, when
+ * box is 'spacingBox', it refers to Renderer.spacingBox which holds width, height
+ * x and y properties.
+ *
+ */
+ align: function (alignOptions, alignByTranslate, box) {
+ var align,
+ vAlign,
+ x,
+ y,
+ attribs = {},
+ alignTo,
+ renderer = this.renderer,
+ alignedObjects = renderer.alignedObjects;
+
+ // First call on instanciate
+ if (alignOptions) {
+ this.alignOptions = alignOptions;
+ this.alignByTranslate = alignByTranslate;
+ if (!box || isString(box)) { // boxes other than renderer handle this internally
+ this.alignTo = alignTo = box || 'renderer';
+ erase(alignedObjects, this); // prevent duplicates, like legendGroup after resize
+ alignedObjects.push(this);
+ box = null; // reassign it below
+ }
+
+ // When called on resize, no arguments are supplied
+ } else {
+ alignOptions = this.alignOptions;
+ alignByTranslate = this.alignByTranslate;
+ alignTo = this.alignTo;
+ }
+
+ box = pick(box, renderer[alignTo], renderer);
+
+ // Assign variables
+ align = alignOptions.align;
+ vAlign = alignOptions.verticalAlign;
+ x = (box.x || 0) + (alignOptions.x || 0); // default: left align
+ y = (box.y || 0) + (alignOptions.y || 0); // default: top align
+
+ // Align
+ if (align === 'right' || align === 'center') {
+ x += (box.width - (alignOptions.width || 0)) /
+ { right: 1, center: 2 }[align];
+ }
+ attribs[alignByTranslate ? 'translateX' : 'x'] = mathRound(x);
+
+
+ // Vertical align
+ if (vAlign === 'bottom' || vAlign === 'middle') {
+ y += (box.height - (alignOptions.height || 0)) /
+ ({ bottom: 1, middle: 2 }[vAlign] || 1);
+
+ }
+ attribs[alignByTranslate ? 'translateY' : 'y'] = mathRound(y);
+
+ // Animate only if already placed
+ this[this.placed ? 'animate' : 'attr'](attribs);
+ this.placed = true;
+ this.alignAttr = attribs;
+
+ return this;
+ },
+
+ /**
+ * Get the bounding box (width, height, x and y) for the element
+ */
+ getBBox: function (reload) {
+ var wrapper = this,
+ bBox,// = wrapper.bBox,
+ renderer = wrapper.renderer,
+ width,
+ height,
+ rotation = wrapper.rotation,
+ element = wrapper.element,
+ styles = wrapper.styles,
+ rad = rotation * deg2rad,
+ textStr = wrapper.textStr,
+ textShadow,
+ elemStyle = element.style,
+ toggleTextShadowShim,
+ cacheKey;
+
+ if (textStr !== UNDEFINED) {
+
+ // Properties that affect bounding box
+ cacheKey = ['', rotation || 0, styles && styles.fontSize, element.style.width].join(',');
+
+ // Since numbers are monospaced, and numerical labels appear a lot in a chart,
+ // we assume that a label of n characters has the same bounding box as others
+ // of the same length.
+ if (textStr === '' || numRegex.test(textStr)) {
+ cacheKey = 'num:' + textStr.toString().length + cacheKey;
+
+ // Caching all strings reduces rendering time by 4-5%.
+ } else {
+ cacheKey = textStr + cacheKey;
+ }
+ }
+
+ if (cacheKey && !reload) {
+ bBox = renderer.cache[cacheKey];
+ }
+
+ // No cache found
+ if (!bBox) {
+
+ // SVG elements
+ if (element.namespaceURI === SVG_NS || renderer.forExport) {
+ try { // Fails in Firefox if the container has display: none.
+
+ // When the text shadow shim is used, we need to hide the fake shadows
+ // to get the correct bounding box (#3872)
+ toggleTextShadowShim = this.fakeTS && function (display) {
+ each(element.querySelectorAll('.' + PREFIX + 'text-shadow'), function (tspan) {
+ tspan.style.display = display;
+ });
+ };
+
+ // Workaround for #3842, Firefox reporting wrong bounding box for shadows
+ if (isFirefox && elemStyle.textShadow) {
+ textShadow = elemStyle.textShadow;
+ elemStyle.textShadow = '';
+ } else if (toggleTextShadowShim) {
+ toggleTextShadowShim(NONE);
+ }
+
+ bBox = element.getBBox ?
+ // SVG: use extend because IE9 is not allowed to change width and height in case
+ // of rotation (below)
+ extend({}, element.getBBox()) :
+ // Canvas renderer and legacy IE in export mode
+ {
+ width: element.offsetWidth,
+ height: element.offsetHeight
+ };
+
+ // #3842
+ if (textShadow) {
+ elemStyle.textShadow = textShadow;
+ } else if (toggleTextShadowShim) {
+ toggleTextShadowShim('');
+ }
+ } catch (e) {}
+
+ // If the bBox is not set, the try-catch block above failed. The other condition
+ // is for Opera that returns a width of -Infinity on hidden elements.
+ if (!bBox || bBox.width < 0) {
+ bBox = { width: 0, height: 0 };
+ }
+
+
+ // VML Renderer or useHTML within SVG
+ } else {
+
+ bBox = wrapper.htmlGetBBox();
+
+ }
+
+ // True SVG elements as well as HTML elements in modern browsers using the .useHTML option
+ // need to compensated for rotation
+ if (renderer.isSVG) {
+ width = bBox.width;
+ height = bBox.height;
+
+ // Workaround for wrong bounding box in IE9 and IE10 (#1101, #1505, #1669, #2568)
+ if (isMS && styles && styles.fontSize === '11px' && height.toPrecision(3) === '16.9') {
+ bBox.height = height = 14;
+ }
+
+ // Adjust for rotated text
+ if (rotation) {
+ bBox.width = mathAbs(height * mathSin(rad)) + mathAbs(width * mathCos(rad));
+ bBox.height = mathAbs(height * mathCos(rad)) + mathAbs(width * mathSin(rad));
+ }
+ }
+
+ // Cache it
+ if (cacheKey) {
+ renderer.cache[cacheKey] = bBox;
+ }
+ }
+ return bBox;
+ },
+
+ /**
+ * Show the element
+ */
+ show: function (inherit) {
+ return this.attr({ visibility: inherit ? 'inherit' : VISIBLE });
+ },
+
+ /**
+ * Hide the element
+ */
+ hide: function () {
+ return this.attr({ visibility: HIDDEN });
+ },
+
+ fadeOut: function (duration) {
+ var elemWrapper = this;
+ elemWrapper.animate({
+ opacity: 0
+ }, {
+ duration: duration || 150,
+ complete: function () {
+ elemWrapper.attr({ y: -9999 }); // #3088, assuming we're only using this for tooltips
+ }
+ });
+ },
+
+ /**
+ * Add the element
+ * @param {Object|Undefined} parent Can be an element, an element wrapper or undefined
+ * to append the element to the renderer.box.
+ */
+ add: function (parent) {
+
+ var renderer = this.renderer,
+ element = this.element,
+ inserted;
+
+ if (parent) {
+ this.parentGroup = parent;
+ }
+
+ // mark as inverted
+ this.parentInverted = parent && parent.inverted;
+
+ // build formatted text
+ if (this.textStr !== undefined) {
+ renderer.buildText(this);
+ }
+
+ // Mark as added
+ this.added = true;
+
+ // If we're adding to renderer root, or other elements in the group
+ // have a z index, we need to handle it
+ if (!parent || parent.handleZ || this.zIndex) {
+ inserted = this.zIndexSetter();
+ }
+
+ // If zIndex is not handled, append at the end
+ if (!inserted) {
+ (parent ? parent.element : renderer.box).appendChild(element);
+ }
+
+ // fire an event for internal hooks
+ if (this.onAdd) {
+ this.onAdd();
+ }
+
+ return this;
+ },
+
+ /**
+ * Removes a child either by removeChild or move to garbageBin.
+ * Issue 490; in VML removeChild results in Orphaned nodes according to sIEve, discardElement does not.
+ */
+ safeRemoveChild: function (element) {
+ var parentNode = element.parentNode;
+ if (parentNode) {
+ parentNode.removeChild(element);
+ }
+ },
+
+ /**
+ * Destroy the element and element wrapper
+ */
+ destroy: function () {
+ var wrapper = this,
+ element = wrapper.element || {},
+ shadows = wrapper.shadows,
+ parentToClean = wrapper.renderer.isSVG && element.nodeName === 'SPAN' && wrapper.parentGroup,
+ grandParent,
+ key,
+ i;
+
+ // remove events
+ element.onclick = element.onmouseout = element.onmouseover = element.onmousemove = element.point = null;
+ stop(wrapper); // stop running animations
+
+ if (wrapper.clipPath) {
+ wrapper.clipPath = wrapper.clipPath.destroy();
+ }
+
+ // Destroy stops in case this is a gradient object
+ if (wrapper.stops) {
+ for (i = 0; i < wrapper.stops.length; i++) {
+ wrapper.stops[i] = wrapper.stops[i].destroy();
+ }
+ wrapper.stops = null;
+ }
+
+ // remove element
+ wrapper.safeRemoveChild(element);
+
+ // destroy shadows
+ if (shadows) {
+ each(shadows, function (shadow) {
+ wrapper.safeRemoveChild(shadow);
+ });
+ }
+
+ // In case of useHTML, clean up empty containers emulating SVG groups (#1960, #2393, #2697).
+ while (parentToClean && parentToClean.div && parentToClean.div.childNodes.length === 0) {
+ grandParent = parentToClean.parentGroup;
+ wrapper.safeRemoveChild(parentToClean.div);
+ delete parentToClean.div;
+ parentToClean = grandParent;
+ }
+
+ // remove from alignObjects
+ if (wrapper.alignTo) {
+ erase(wrapper.renderer.alignedObjects, wrapper);
+ }
+
+ for (key in wrapper) {
+ delete wrapper[key];
+ }
+
+ return null;
+ },
+
+ /**
+ * Add a shadow to the element. Must be done after the element is added to the DOM
+ * @param {Boolean|Object} shadowOptions
+ */
+ shadow: function (shadowOptions, group, cutOff) {
+ var shadows = [],
+ i,
+ shadow,
+ element = this.element,
+ strokeWidth,
+ shadowWidth,
+ shadowElementOpacity,
+
+ // compensate for inverted plot area
+ transform;
+
+
+ if (shadowOptions) {
+ shadowWidth = pick(shadowOptions.width, 3);
+ shadowElementOpacity = (shadowOptions.opacity || 0.15) / shadowWidth;
+ transform = this.parentInverted ?
+ '(-1,-1)' :
+ '(' + pick(shadowOptions.offsetX, 1) + ', ' + pick(shadowOptions.offsetY, 1) + ')';
+ for (i = 1; i <= shadowWidth; i++) {
+ shadow = element.cloneNode(0);
+ strokeWidth = (shadowWidth * 2) + 1 - (2 * i);
+ attr(shadow, {
+ 'isShadow': 'true',
+ 'stroke': shadowOptions.color || 'black',
+ 'stroke-opacity': shadowElementOpacity * i,
+ 'stroke-width': strokeWidth,
+ 'transform': 'translate' + transform,
+ 'fill': NONE
+ });
+ if (cutOff) {
+ attr(shadow, 'height', mathMax(attr(shadow, 'height') - strokeWidth, 0));
+ shadow.cutHeight = strokeWidth;
+ }
+
+ if (group) {
+ group.element.appendChild(shadow);
+ } else {
+ element.parentNode.insertBefore(shadow, element);
+ }
+
+ shadows.push(shadow);
+ }
+
+ this.shadows = shadows;
+ }
+ return this;
+
+ },
+
+ xGetter: function (key) {
+ if (this.element.nodeName === 'circle') {
+ key = { x: 'cx', y: 'cy' }[key] || key;
+ }
+ return this._defaultGetter(key);
+ },
+
+ /**
+ * Get the current value of an attribute or pseudo attribute, used mainly
+ * for animation.
+ */
+ _defaultGetter: function (key) {
+ var ret = pick(this[key], this.element ? this.element.getAttribute(key) : null, 0);
+
+ if (/^[\-0-9\.]+$/.test(ret)) { // is numerical
+ ret = parseFloat(ret);
+ }
+ return ret;
+ },
+
+
+ dSetter: function (value, key, element) {
+ if (value && value.join) { // join path
+ value = value.join(' ');
+ }
+ if (/(NaN| {2}|^$)/.test(value)) {
+ value = 'M 0 0';
+ }
+ element.setAttribute(key, value);
+
+ this[key] = value;
+ },
+ dashstyleSetter: function (value) {
+ var i;
+ value = value && value.toLowerCase();
+ if (value) {
+ value = value
+ .replace('shortdashdotdot', '3,1,1,1,1,1,')
+ .replace('shortdashdot', '3,1,1,1')
+ .replace('shortdot', '1,1,')
+ .replace('shortdash', '3,1,')
+ .replace('longdash', '8,3,')
+ .replace(/dot/g, '1,3,')
+ .replace('dash', '4,3,')
+ .replace(/,$/, '')
+ .split(','); // ending comma
+
+ i = value.length;
+ while (i--) {
+ value[i] = pInt(value[i]) * this['stroke-width'];
+ }
+ value = value.join(',')
+ .replace('NaN', 'none'); // #3226
+ this.element.setAttribute('stroke-dasharray', value);
+ }
+ },
+ alignSetter: function (value) {
+ this.element.setAttribute('text-anchor', { left: 'start', center: 'middle', right: 'end' }[value]);
+ },
+ opacitySetter: function (value, key, element) {
+ this[key] = value;
+ element.setAttribute(key, value);
+ },
+ titleSetter: function (value) {
+ var titleNode = this.element.getElementsByTagName('title')[0];
+ if (!titleNode) {
+ titleNode = doc.createElementNS(SVG_NS, 'title');
+ this.element.appendChild(titleNode);
+ }
+ titleNode.appendChild(
+ doc.createTextNode(
+ (String(pick(value), '')).replace(/<[^>]*>/g, '') // #3276, #3895
+ )
+ );
+ },
+ textSetter: function (value) {
+ if (value !== this.textStr) {
+ // Delete bBox memo when the text changes
+ delete this.bBox;
+
+ this.textStr = value;
+ if (this.added) {
+ this.renderer.buildText(this);
+ }
+ }
+ },
+ fillSetter: function (value, key, element) {
+ if (typeof value === 'string') {
+ element.setAttribute(key, value);
+ } else if (value) {
+ this.colorGradient(value, key, element);
+ }
+ },
+ visibilitySetter: function (value, key, element) {
+ // IE9-11 doesn't handle visibilty:inherit well, so we remove the attribute instead (#2881, #3909)
+ if (value === 'inherit') {
+ element.removeAttribute(key);
+ } else {
+ element.setAttribute(key, value);
+ }
+ },
+ zIndexSetter: function (value, key) {
+ var renderer = this.renderer,
+ parentGroup = this.parentGroup,
+ parentWrapper = parentGroup || renderer,
+ parentNode = parentWrapper.element || renderer.box,
+ childNodes,
+ otherElement,
+ otherZIndex,
+ element = this.element,
+ inserted,
+ run = this.added,
+ i;
+
+ if (defined(value)) {
+ element.setAttribute(key, value); // So we can read it for other elements in the group
+ value = +value;
+ if (this[key] === value) { // Only update when needed (#3865)
+ run = false;
+ }
+ this[key] = value;
+ }
+
+ // Insert according to this and other elements' zIndex. Before .add() is called,
+ // nothing is done. Then on add, or by later calls to zIndexSetter, the node
+ // is placed on the right place in the DOM.
+ if (run) {
+ value = this.zIndex;
+
+ if (value && parentGroup) {
+ parentGroup.handleZ = true;
+ }
+
+ childNodes = parentNode.childNodes;
+ for (i = 0; i < childNodes.length && !inserted; i++) {
+ otherElement = childNodes[i];
+ otherZIndex = attr(otherElement, 'zIndex');
+ if (otherElement !== element && (
+ // Insert before the first element with a higher zIndex
+ pInt(otherZIndex) > value ||
+ // If no zIndex given, insert before the first element with a zIndex
+ (!defined(value) && defined(otherZIndex))
+
+ )) {
+ parentNode.insertBefore(element, otherElement);
+ inserted = true;
+ }
+ }
+ if (!inserted) {
+ parentNode.appendChild(element);
+ }
+ }
+ return inserted;
+ },
+ _defaultSetter: function (value, key, element) {
+ element.setAttribute(key, value);
+ }
+};
+
+// Some shared setters and getters
+SVGElement.prototype.yGetter = SVGElement.prototype.xGetter;
+SVGElement.prototype.translateXSetter = SVGElement.prototype.translateYSetter =
+ SVGElement.prototype.rotationSetter = SVGElement.prototype.verticalAlignSetter =
+ SVGElement.prototype.scaleXSetter = SVGElement.prototype.scaleYSetter = function (value, key) {
+ this[key] = value;
+ this.doTransform = true;
+};
+
+// WebKit and Batik have problems with a stroke-width of zero, so in this case we remove the
+// stroke attribute altogether. #1270, #1369, #3065, #3072.
+SVGElement.prototype['stroke-widthSetter'] = SVGElement.prototype.strokeSetter = function (value, key, element) {
+ this[key] = value;
+ // Only apply the stroke attribute if the stroke width is defined and larger than 0
+ if (this.stroke && this['stroke-width']) {
+ this.strokeWidth = this['stroke-width'];
+ SVGElement.prototype.fillSetter.call(this, this.stroke, 'stroke', element); // use prototype as instance may be overridden
+ element.setAttribute('stroke-width', this['stroke-width']);
+ this.hasStroke = true;
+ } else if (key === 'stroke-width' && value === 0 && this.hasStroke) {
+ element.removeAttribute('stroke');
+ this.hasStroke = false;
+ }
+};
+
+
+/**
+ * The default SVG renderer
+ */
+var SVGRenderer = function () {
+ this.init.apply(this, arguments);
+};
+SVGRenderer.prototype = {
+ Element: SVGElement,
+
+ /**
+ * Initialize the SVGRenderer
+ * @param {Object} container
+ * @param {Number} width
+ * @param {Number} height
+ * @param {Boolean} forExport
+ */
+ init: function (container, width, height, style, forExport, allowHTML) {
+ var renderer = this,
+ loc = location,
+ boxWrapper,
+ element,
+ desc;
+
+ boxWrapper = renderer.createElement('svg')
+ .attr({
+ version: '1.1'
+ })
+ .css(this.getStyle(style));
+ element = boxWrapper.element;
+ container.appendChild(element);
+
+ // For browsers other than IE, add the namespace attribute (#1978)
+ if (container.innerHTML.indexOf('xmlns') === -1) {
+ attr(element, 'xmlns', SVG_NS);
+ }
+
+ // object properties
+ renderer.isSVG = true;
+ renderer.box = element;
+ renderer.boxWrapper = boxWrapper;
+ renderer.alignedObjects = [];
+
+ // Page url used for internal references. #24, #672, #1070
+ renderer.url = (isFirefox || isWebKit) && doc.getElementsByTagName('base').length ?
+ loc.href
+ .replace(/#.*?$/, '') // remove the hash
+ .replace(/([\('\)])/g, '\\$1') // escape parantheses and quotes
+ .replace(/ /g, '%20') : // replace spaces (needed for Safari only)
+ '';
+
+ // Add description
+ desc = this.createElement('desc').add();
+ desc.element.appendChild(doc.createTextNode('Created with ' + PRODUCT + ' ' + VERSION));
+
+
+ renderer.defs = this.createElement('defs').add();
+ renderer.allowHTML = allowHTML;
+ renderer.forExport = forExport;
+ renderer.gradients = {}; // Object where gradient SvgElements are stored
+ renderer.cache = {}; // Cache for numerical bounding boxes
+
+ renderer.setSize(width, height, false);
+
+
+
+ // Issue 110 workaround:
+ // In Firefox, if a div is positioned by percentage, its pixel position may land
+ // between pixels. The container itself doesn't display this, but an SVG element
+ // inside this container will be drawn at subpixel precision. In order to draw
+ // sharp lines, this must be compensated for. This doesn't seem to work inside
+ // iframes though (like in jsFiddle).
+ var subPixelFix, rect;
+ if (isFirefox && container.getBoundingClientRect) {
+ renderer.subPixelFix = subPixelFix = function () {
+ css(container, { left: 0, top: 0 });
+ rect = container.getBoundingClientRect();
+ css(container, {
+ left: (mathCeil(rect.left) - rect.left) + PX,
+ top: (mathCeil(rect.top) - rect.top) + PX
+ });
+ };
+
+ // run the fix now
+ subPixelFix();
+
+ // run it on resize
+ addEvent(win, 'resize', subPixelFix);
+ }
+ },
+
+ getStyle: function (style) {
+ return (this.style = extend({
+ fontFamily: '"Lucida Grande", "Lucida Sans Unicode", Arial, Helvetica, sans-serif', // default font
+ fontSize: '12px'
+ }, style));
+ },
+
+ /**
+ * Detect whether the renderer is hidden. This happens when one of the parent elements
+ * has display: none. #608.
+ */
+ isHidden: function () {
+ return !this.boxWrapper.getBBox().width;
+ },
+
+ /**
+ * Destroys the renderer and its allocated members.
+ */
+ destroy: function () {
+ var renderer = this,
+ rendererDefs = renderer.defs;
+ renderer.box = null;
+ renderer.boxWrapper = renderer.boxWrapper.destroy();
+
+ // Call destroy on all gradient elements
+ destroyObjectProperties(renderer.gradients || {});
+ renderer.gradients = null;
+
+ // Defs are null in VMLRenderer
+ // Otherwise, destroy them here.
+ if (rendererDefs) {
+ renderer.defs = rendererDefs.destroy();
+ }
+
+ // Remove sub pixel fix handler
+ // We need to check that there is a handler, otherwise all functions that are registered for event 'resize' are removed
+ // See issue #982
+ if (renderer.subPixelFix) {
+ removeEvent(win, 'resize', renderer.subPixelFix);
+ }
+
+ renderer.alignedObjects = null;
+
+ return null;
+ },
+
+ /**
+ * Create a wrapper for an SVG element
+ * @param {Object} nodeName
+ */
+ createElement: function (nodeName) {
+ var wrapper = new this.Element();
+ wrapper.init(this, nodeName);
+ return wrapper;
+ },
+
+ /**
+ * Dummy function for use in canvas renderer
+ */
+ draw: function () {},
+
+ /**
+ * Get converted radial gradient attributes
+ */
+ getRadialAttr: function (radialReference, gradAttr) {
+ return {
+ cx: (radialReference[0] - radialReference[2] / 2) + gradAttr.cx * radialReference[2],
+ cy: (radialReference[1] - radialReference[2] / 2) + gradAttr.cy * radialReference[2],
+ r: gradAttr.r * radialReference[2]
+ };
+ },
+
+ /**
+ * Parse a simple HTML string into SVG tspans
+ *
+ * @param {Object} textNode The parent text SVG node
+ */
+ buildText: function (wrapper) {
+ var textNode = wrapper.element,
+ renderer = this,
+ forExport = renderer.forExport,
+ textStr = pick(wrapper.textStr, '').toString(),
+ hasMarkup = textStr.indexOf('<') !== -1,
+ lines,
+ childNodes = textNode.childNodes,
+ styleRegex,
+ hrefRegex,
+ parentX = attr(textNode, 'x'),
+ textStyles = wrapper.styles,
+ width = wrapper.textWidth,
+ textLineHeight = textStyles && textStyles.lineHeight,
+ textShadow = textStyles && textStyles.textShadow,
+ ellipsis = textStyles && textStyles.textOverflow === 'ellipsis',
+ i = childNodes.length,
+ tempParent = width && !wrapper.added && this.box,
+ getLineHeight = function (tspan) {
+ return textLineHeight ?
+ pInt(textLineHeight) :
+ renderer.fontMetrics(
+ /(px|em)$/.test(tspan && tspan.style.fontSize) ?
+ tspan.style.fontSize :
+ ((textStyles && textStyles.fontSize) || renderer.style.fontSize || 12),
+ tspan
+ ).h;
+ },
+ unescapeAngleBrackets = function (inputStr) {
+ return inputStr.replace(/</g, '<').replace(/>/g, '>');
+ };
+
+ /// remove old text
+ while (i--) {
+ textNode.removeChild(childNodes[i]);
+ }
+
+ // Skip tspans, add text directly to text node. The forceTSpan is a hook
+ // used in text outline hack.
+ if (!hasMarkup && !textShadow && !ellipsis && textStr.indexOf(' ') === -1) {
+ textNode.appendChild(doc.createTextNode(unescapeAngleBrackets(textStr)));
+ return;
+
+ // Complex strings, add more logic
+ } else {
+
+ styleRegex = /<.*style="([^"]+)".*>/;
+ hrefRegex = /<.*href="(http[^"]+)".*>/;
+
+ if (tempParent) {
+ tempParent.appendChild(textNode); // attach it to the DOM to read offset width
+ }
+
+ if (hasMarkup) {
+ lines = textStr
+ .replace(/<(b|strong)>/g, '')
+ .replace(/<(i|em)>/g, '')
+ .replace(//g, '')
+ .split(//g);
+
+ } else {
+ lines = [textStr];
+ }
+
+
+ // remove empty line at end
+ if (lines[lines.length - 1] === '') {
+ lines.pop();
+ }
+
+
+ // build the lines
+ each(lines, function (line, lineNo) {
+ var spans, spanNo = 0;
+
+ line = line.replace(//g, '|||');
+ spans = line.split('|||');
+
+ each(spans, function (span) {
+ if (span !== '' || spans.length === 1) {
+ var attributes = {},
+ tspan = doc.createElementNS(SVG_NS, 'tspan'),
+ spanStyle; // #390
+ if (styleRegex.test(span)) {
+ spanStyle = span.match(styleRegex)[1].replace(/(;| |^)color([ :])/, '$1fill$2');
+ attr(tspan, 'style', spanStyle);
+ }
+ if (hrefRegex.test(span) && !forExport) { // Not for export - #1529
+ attr(tspan, 'onclick', 'location.href=\"' + span.match(hrefRegex)[1] + '\"');
+ css(tspan, { cursor: 'pointer' });
+ }
+
+ span = unescapeAngleBrackets(span.replace(/<(.|\n)*?>/g, '') || ' ');
+
+ // Nested tags aren't supported, and cause crash in Safari (#1596)
+ if (span !== ' ') {
+
+ // add the text node
+ tspan.appendChild(doc.createTextNode(span));
+
+ if (!spanNo) { // first span in a line, align it to the left
+ if (lineNo && parentX !== null) {
+ attributes.x = parentX;
+ }
+ } else {
+ attributes.dx = 0; // #16
+ }
+
+ // add attributes
+ attr(tspan, attributes);
+
+ // Append it
+ textNode.appendChild(tspan);
+
+ // first span on subsequent line, add the line height
+ if (!spanNo && lineNo) {
+
+ // allow getting the right offset height in exporting in IE
+ if (!hasSVG && forExport) {
+ css(tspan, { display: 'block' });
+ }
+
+ // Set the line height based on the font size of either
+ // the text element or the tspan element
+ attr(
+ tspan,
+ 'dy',
+ getLineHeight(tspan)
+ );
+ }
+
+ /*if (width) {
+ renderer.breakText(wrapper, width);
+ }*/
+
+ // Check width and apply soft breaks or ellipsis
+ if (width) {
+ var words = span.replace(/([^\^])-/g, '$1- ').split(' '), // #1273
+ hasWhiteSpace = spans.length > 1 || lineNo || (words.length > 1 && textStyles.whiteSpace !== 'nowrap'),
+ tooLong,
+ wasTooLong,
+ actualWidth,
+ rest = [],
+ dy = getLineHeight(tspan),
+ softLineNo = 1,
+ rotation = wrapper.rotation,
+ wordStr = span, // for ellipsis
+ cursor = wordStr.length, // binary search cursor
+ bBox;
+
+ while ((hasWhiteSpace || ellipsis) && (words.length || rest.length)) {
+ wrapper.rotation = 0; // discard rotation when computing box
+ bBox = wrapper.getBBox(true);
+ actualWidth = bBox.width;
+
+ // Old IE cannot measure the actualWidth for SVG elements (#2314)
+ if (!hasSVG && renderer.forExport) {
+ actualWidth = renderer.measureSpanWidth(tspan.firstChild.data, wrapper.styles);
+ }
+
+ tooLong = actualWidth > width;
+
+ // For ellipsis, do a binary search for the correct string length
+ if (wasTooLong === undefined) {
+ wasTooLong = tooLong; // First time
+ }
+ if (ellipsis && wasTooLong) {
+ cursor /= 2;
+
+ if (wordStr === '' || (!tooLong && cursor < 0.5)) {
+ words = []; // All ok, break out
+ } else {
+ if (tooLong) {
+ wasTooLong = true;
+ }
+ wordStr = span.substring(0, wordStr.length + (tooLong ? -1 : 1) * mathCeil(cursor));
+ words = [wordStr + (width > 3 ? '\u2026' : '')];
+ tspan.removeChild(tspan.firstChild);
+ }
+
+ // Looping down, this is the first word sequence that is not too long,
+ // so we can move on to build the next line.
+ } else if (!tooLong || words.length === 1) {
+ words = rest;
+ rest = [];
+
+ if (words.length) {
+ softLineNo++;
+
+ tspan = doc.createElementNS(SVG_NS, 'tspan');
+ attr(tspan, {
+ dy: dy,
+ x: parentX
+ });
+ if (spanStyle) { // #390
+ attr(tspan, 'style', spanStyle);
+ }
+ textNode.appendChild(tspan);
+ }
+ if (actualWidth > width) { // a single word is pressing it out
+ width = actualWidth;
+ }
+ } else { // append to existing line tspan
+ tspan.removeChild(tspan.firstChild);
+ rest.unshift(words.pop());
+ }
+ if (words.length) {
+ tspan.appendChild(doc.createTextNode(words.join(' ').replace(/- /g, '-')));
+ }
+ }
+ if (wasTooLong) {
+ wrapper.attr('title', wrapper.textStr);
+ }
+ wrapper.rotation = rotation;
+ }
+
+ spanNo++;
+ }
+ }
+ });
+ });
+ if (tempParent) {
+ tempParent.removeChild(textNode); // attach it to the DOM to read offset width
+ }
+
+ // Apply the text shadow
+ if (textShadow && wrapper.applyTextShadow) {
+ wrapper.applyTextShadow(textShadow);
+ }
+ }
+ },
+
+
+
+ /*
+ breakText: function (wrapper, width) {
+ var bBox = wrapper.getBBox(),
+ node = wrapper.element,
+ textLength = node.textContent.length,
+ pos = mathRound(width * textLength / bBox.width), // try this position first, based on average character width
+ increment = 0,
+ finalPos;
+
+ if (bBox.width > width) {
+ while (finalPos === undefined) {
+ textLength = node.getSubStringLength(0, pos);
+
+ if (textLength <= width) {
+ if (increment === -1) {
+ finalPos = pos;
+ } else {
+ increment = 1;
+ }
+ } else {
+ if (increment === 1) {
+ finalPos = pos - 1;
+ } else {
+ increment = -1;
+ }
+ }
+ pos += increment;
+ }
+ }
+ console.log(finalPos, node.getSubStringLength(0, finalPos))
+ },
+ */
+
+ /**
+ * Returns white for dark colors and black for bright colors
+ */
+ getContrast: function (color) {
+ color = Color(color).rgba;
+ return color[0] + color[1] + color[2] > 384 ? '#000000' : '#FFFFFF';
+ },
+
+ /**
+ * Create a button with preset states
+ * @param {String} text
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Function} callback
+ * @param {Object} normalState
+ * @param {Object} hoverState
+ * @param {Object} pressedState
+ */
+ button: function (text, x, y, callback, normalState, hoverState, pressedState, disabledState, shape) {
+ var label = this.label(text, x, y, shape, null, null, null, null, 'button'),
+ curState = 0,
+ stateOptions,
+ stateStyle,
+ normalStyle,
+ hoverStyle,
+ pressedStyle,
+ disabledStyle,
+ verticalGradient = { x1: 0, y1: 0, x2: 0, y2: 1 };
+
+ // Normal state - prepare the attributes
+ normalState = merge({
+ 'stroke-width': 1,
+ stroke: '#CCCCCC',
+ fill: {
+ linearGradient: verticalGradient,
+ stops: [
+ [0, '#FEFEFE'],
+ [1, '#F6F6F6']
+ ]
+ },
+ r: 2,
+ padding: 5,
+ style: {
+ color: 'black'
+ }
+ }, normalState);
+ normalStyle = normalState.style;
+ delete normalState.style;
+
+ // Hover state
+ hoverState = merge(normalState, {
+ stroke: '#68A',
+ fill: {
+ linearGradient: verticalGradient,
+ stops: [
+ [0, '#FFF'],
+ [1, '#ACF']
+ ]
+ }
+ }, hoverState);
+ hoverStyle = hoverState.style;
+ delete hoverState.style;
+
+ // Pressed state
+ pressedState = merge(normalState, {
+ stroke: '#68A',
+ fill: {
+ linearGradient: verticalGradient,
+ stops: [
+ [0, '#9BD'],
+ [1, '#CDF']
+ ]
+ }
+ }, pressedState);
+ pressedStyle = pressedState.style;
+ delete pressedState.style;
+
+ // Disabled state
+ disabledState = merge(normalState, {
+ style: {
+ color: '#CCC'
+ }
+ }, disabledState);
+ disabledStyle = disabledState.style;
+ delete disabledState.style;
+
+ // Add the events. IE9 and IE10 need mouseover and mouseout to funciton (#667).
+ addEvent(label.element, isMS ? 'mouseover' : 'mouseenter', function () {
+ if (curState !== 3) {
+ label.attr(hoverState)
+ .css(hoverStyle);
+ }
+ });
+ addEvent(label.element, isMS ? 'mouseout' : 'mouseleave', function () {
+ if (curState !== 3) {
+ stateOptions = [normalState, hoverState, pressedState][curState];
+ stateStyle = [normalStyle, hoverStyle, pressedStyle][curState];
+ label.attr(stateOptions)
+ .css(stateStyle);
+ }
+ });
+
+ label.setState = function (state) {
+ label.state = curState = state;
+ if (!state) {
+ label.attr(normalState)
+ .css(normalStyle);
+ } else if (state === 2) {
+ label.attr(pressedState)
+ .css(pressedStyle);
+ } else if (state === 3) {
+ label.attr(disabledState)
+ .css(disabledStyle);
+ }
+ };
+
+ return label
+ .on('click', function (e) {
+ if (curState !== 3) {
+ callback.call(label, e);
+ }
+ })
+ .attr(normalState)
+ .css(extend({ cursor: 'default' }, normalStyle));
+ },
+
+ /**
+ * Make a straight line crisper by not spilling out to neighbour pixels
+ * @param {Array} points
+ * @param {Number} width
+ */
+ crispLine: function (points, width) {
+ // points format: [M, 0, 0, L, 100, 0]
+ // normalize to a crisp line
+ if (points[1] === points[4]) {
+ // Substract due to #1129. Now bottom and left axis gridlines behave the same.
+ points[1] = points[4] = mathRound(points[1]) - (width % 2 / 2);
+ }
+ if (points[2] === points[5]) {
+ points[2] = points[5] = mathRound(points[2]) + (width % 2 / 2);
+ }
+ return points;
+ },
+
+
+ /**
+ * Draw a path
+ * @param {Array} path An SVG path in array form
+ */
+ path: function (path) {
+ var attr = {
+ fill: NONE
+ };
+ if (isArray(path)) {
+ attr.d = path;
+ } else if (isObject(path)) { // attributes
+ extend(attr, path);
+ }
+ return this.createElement('path').attr(attr);
+ },
+
+ /**
+ * Draw and return an SVG circle
+ * @param {Number} x The x position
+ * @param {Number} y The y position
+ * @param {Number} r The radius
+ */
+ circle: function (x, y, r) {
+ var attr = isObject(x) ?
+ x :
+ {
+ x: x,
+ y: y,
+ r: r
+ },
+ wrapper = this.createElement('circle');
+
+ wrapper.xSetter = function (value) {
+ this.element.setAttribute('cx', value);
+ };
+ wrapper.ySetter = function (value) {
+ this.element.setAttribute('cy', value);
+ };
+ return wrapper.attr(attr);
+ },
+
+ /**
+ * Draw and return an arc
+ * @param {Number} x X position
+ * @param {Number} y Y position
+ * @param {Number} r Radius
+ * @param {Number} innerR Inner radius like used in donut charts
+ * @param {Number} start Starting angle
+ * @param {Number} end Ending angle
+ */
+ arc: function (x, y, r, innerR, start, end) {
+ var arc;
+
+ if (isObject(x)) {
+ y = x.y;
+ r = x.r;
+ innerR = x.innerR;
+ start = x.start;
+ end = x.end;
+ x = x.x;
+ }
+
+ // Arcs are defined as symbols for the ability to set
+ // attributes in attr and animate
+ arc = this.symbol('arc', x || 0, y || 0, r || 0, r || 0, {
+ innerR: innerR || 0,
+ start: start || 0,
+ end: end || 0
+ });
+ arc.r = r; // #959
+ return arc;
+ },
+
+ /**
+ * Draw and return a rectangle
+ * @param {Number} x Left position
+ * @param {Number} y Top position
+ * @param {Number} width
+ * @param {Number} height
+ * @param {Number} r Border corner radius
+ * @param {Number} strokeWidth A stroke width can be supplied to allow crisp drawing
+ */
+ rect: function (x, y, width, height, r, strokeWidth) {
+
+ r = isObject(x) ? x.r : r;
+
+ var wrapper = this.createElement('rect'),
+ attribs = isObject(x) ? x : x === UNDEFINED ? {} : {
+ x: x,
+ y: y,
+ width: mathMax(width, 0),
+ height: mathMax(height, 0)
+ };
+
+ if (strokeWidth !== UNDEFINED) {
+ attribs.strokeWidth = strokeWidth;
+ attribs = wrapper.crisp(attribs);
+ }
+
+ if (r) {
+ attribs.r = r;
+ }
+
+ wrapper.rSetter = function (value) {
+ attr(this.element, {
+ rx: value,
+ ry: value
+ });
+ };
+
+ return wrapper.attr(attribs);
+ },
+
+ /**
+ * Resize the box and re-align all aligned elements
+ * @param {Object} width
+ * @param {Object} height
+ * @param {Boolean} animate
+ *
+ */
+ setSize: function (width, height, animate) {
+ var renderer = this,
+ alignedObjects = renderer.alignedObjects,
+ i = alignedObjects.length;
+
+ renderer.width = width;
+ renderer.height = height;
+
+ renderer.boxWrapper[pick(animate, true) ? 'animate' : 'attr']({
+ width: width,
+ height: height
+ });
+
+ while (i--) {
+ alignedObjects[i].align();
+ }
+ },
+
+ /**
+ * Create a group
+ * @param {String} name The group will be given a class name of 'highcharts-{name}'.
+ * This can be used for styling and scripting.
+ */
+ g: function (name) {
+ var elem = this.createElement('g');
+ return defined(name) ? elem.attr({ 'class': PREFIX + name }) : elem;
+ },
+
+ /**
+ * Display an image
+ * @param {String} src
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} width
+ * @param {Number} height
+ */
+ image: function (src, x, y, width, height) {
+ var attribs = {
+ preserveAspectRatio: NONE
+ },
+ elemWrapper;
+
+ // optional properties
+ if (arguments.length > 1) {
+ extend(attribs, {
+ x: x,
+ y: y,
+ width: width,
+ height: height
+ });
+ }
+
+ elemWrapper = this.createElement('image').attr(attribs);
+
+ // set the href in the xlink namespace
+ if (elemWrapper.element.setAttributeNS) {
+ elemWrapper.element.setAttributeNS('http://www.w3.org/1999/xlink',
+ 'href', src);
+ } else {
+ // could be exporting in IE
+ // using href throws "not supported" in ie7 and under, requries regex shim to fix later
+ elemWrapper.element.setAttribute('hc-svg-href', src);
+ }
+ return elemWrapper;
+ },
+
+ /**
+ * Draw a symbol out of pre-defined shape paths from the namespace 'symbol' object.
+ *
+ * @param {Object} symbol
+ * @param {Object} x
+ * @param {Object} y
+ * @param {Object} radius
+ * @param {Object} options
+ */
+ symbol: function (symbol, x, y, width, height, options) {
+
+ var obj,
+
+ // get the symbol definition function
+ symbolFn = this.symbols[symbol],
+
+ // check if there's a path defined for this symbol
+ path = symbolFn && symbolFn(
+ mathRound(x),
+ mathRound(y),
+ width,
+ height,
+ options
+ ),
+
+ imageElement,
+ imageRegex = /^url\((.*?)\)$/,
+ imageSrc,
+ imageSize,
+ centerImage;
+
+ if (path) {
+
+ obj = this.path(path);
+ // expando properties for use in animate and attr
+ extend(obj, {
+ symbolName: symbol,
+ x: x,
+ y: y,
+ width: width,
+ height: height
+ });
+ if (options) {
+ extend(obj, options);
+ }
+
+
+ // image symbols
+ } else if (imageRegex.test(symbol)) {
+
+ // On image load, set the size and position
+ centerImage = function (img, size) {
+ if (img.element) { // it may be destroyed in the meantime (#1390)
+ img.attr({
+ width: size[0],
+ height: size[1]
+ });
+
+ if (!img.alignByTranslate) { // #185
+ img.translate(
+ mathRound((width - size[0]) / 2), // #1378
+ mathRound((height - size[1]) / 2)
+ );
+ }
+ }
+ };
+
+ imageSrc = symbol.match(imageRegex)[1];
+ imageSize = symbolSizes[imageSrc] || (options && options.width && options.height && [options.width, options.height]);
+
+ // Ireate the image synchronously, add attribs async
+ obj = this.image(imageSrc)
+ .attr({
+ x: x,
+ y: y
+ });
+ obj.isImg = true;
+
+ if (imageSize) {
+ centerImage(obj, imageSize);
+ } else {
+ // Initialize image to be 0 size so export will still function if there's no cached sizes.
+ obj.attr({ width: 0, height: 0 });
+
+ // Create a dummy JavaScript image to get the width and height. Due to a bug in IE < 8,
+ // the created element must be assigned to a variable in order to load (#292).
+ imageElement = createElement('img', {
+ onload: function () {
+
+ // Special case for SVGs on IE11, the width is not accessible until the image is
+ // part of the DOM (#2854).
+ if (this.width === 0) {
+ css(this, {
+ position: ABSOLUTE,
+ top: '-999em'
+ });
+ document.body.appendChild(this);
+ }
+
+ // Center the image
+ centerImage(obj, symbolSizes[imageSrc] = [this.width, this.height]);
+
+ // Clean up after #2854 workaround.
+ if (this.parentNode) {
+ this.parentNode.removeChild(this);
+ }
+ },
+ src: imageSrc
+ });
+ }
+ }
+
+ return obj;
+ },
+
+ /**
+ * An extendable collection of functions for defining symbol paths.
+ */
+ symbols: {
+ 'circle': function (x, y, w, h) {
+ var cpw = 0.166 * w;
+ return [
+ M, x + w / 2, y,
+ 'C', x + w + cpw, y, x + w + cpw, y + h, x + w / 2, y + h,
+ 'C', x - cpw, y + h, x - cpw, y, x + w / 2, y,
+ 'Z'
+ ];
+ },
+
+ 'square': function (x, y, w, h) {
+ return [
+ M, x, y,
+ L, x + w, y,
+ x + w, y + h,
+ x, y + h,
+ 'Z'
+ ];
+ },
+
+ 'triangle': function (x, y, w, h) {
+ return [
+ M, x + w / 2, y,
+ L, x + w, y + h,
+ x, y + h,
+ 'Z'
+ ];
+ },
+
+ 'triangle-down': function (x, y, w, h) {
+ return [
+ M, x, y,
+ L, x + w, y,
+ x + w / 2, y + h,
+ 'Z'
+ ];
+ },
+ 'diamond': function (x, y, w, h) {
+ return [
+ M, x + w / 2, y,
+ L, x + w, y + h / 2,
+ x + w / 2, y + h,
+ x, y + h / 2,
+ 'Z'
+ ];
+ },
+ 'arc': function (x, y, w, h, options) {
+ var start = options.start,
+ radius = options.r || w || h,
+ end = options.end - 0.001, // to prevent cos and sin of start and end from becoming equal on 360 arcs (related: #1561)
+ innerRadius = options.innerR,
+ open = options.open,
+ cosStart = mathCos(start),
+ sinStart = mathSin(start),
+ cosEnd = mathCos(end),
+ sinEnd = mathSin(end),
+ longArc = options.end - start < mathPI ? 0 : 1;
+
+ return [
+ M,
+ x + radius * cosStart,
+ y + radius * sinStart,
+ 'A', // arcTo
+ radius, // x radius
+ radius, // y radius
+ 0, // slanting
+ longArc, // long or short arc
+ 1, // clockwise
+ x + radius * cosEnd,
+ y + radius * sinEnd,
+ open ? M : L,
+ x + innerRadius * cosEnd,
+ y + innerRadius * sinEnd,
+ 'A', // arcTo
+ innerRadius, // x radius
+ innerRadius, // y radius
+ 0, // slanting
+ longArc, // long or short arc
+ 0, // clockwise
+ x + innerRadius * cosStart,
+ y + innerRadius * sinStart,
+
+ open ? '' : 'Z' // close
+ ];
+ },
+
+ /**
+ * Callout shape used for default tooltips, also used for rounded rectangles in VML
+ */
+ callout: function (x, y, w, h, options) {
+ var arrowLength = 6,
+ halfDistance = 6,
+ r = mathMin((options && options.r) || 0, w, h),
+ safeDistance = r + halfDistance,
+ anchorX = options && options.anchorX,
+ anchorY = options && options.anchorY,
+ path;
+
+ path = [
+ 'M', x + r, y,
+ 'L', x + w - r, y, // top side
+ 'C', x + w, y, x + w, y, x + w, y + r, // top-right corner
+ 'L', x + w, y + h - r, // right side
+ 'C', x + w, y + h, x + w, y + h, x + w - r, y + h, // bottom-right corner
+ 'L', x + r, y + h, // bottom side
+ 'C', x, y + h, x, y + h, x, y + h - r, // bottom-left corner
+ 'L', x, y + r, // left side
+ 'C', x, y, x, y, x + r, y // top-right corner
+ ];
+
+ if (anchorX && anchorX > w && anchorY > y + safeDistance && anchorY < y + h - safeDistance) { // replace right side
+ path.splice(13, 3,
+ 'L', x + w, anchorY - halfDistance,
+ x + w + arrowLength, anchorY,
+ x + w, anchorY + halfDistance,
+ x + w, y + h - r
+ );
+ } else if (anchorX && anchorX < 0 && anchorY > y + safeDistance && anchorY < y + h - safeDistance) { // replace left side
+ path.splice(33, 3,
+ 'L', x, anchorY + halfDistance,
+ x - arrowLength, anchorY,
+ x, anchorY - halfDistance,
+ x, y + r
+ );
+ } else if (anchorY && anchorY > h && anchorX > x + safeDistance && anchorX < x + w - safeDistance) { // replace bottom
+ path.splice(23, 3,
+ 'L', anchorX + halfDistance, y + h,
+ anchorX, y + h + arrowLength,
+ anchorX - halfDistance, y + h,
+ x + r, y + h
+ );
+ } else if (anchorY && anchorY < 0 && anchorX > x + safeDistance && anchorX < x + w - safeDistance) { // replace top
+ path.splice(3, 3,
+ 'L', anchorX - halfDistance, y,
+ anchorX, y - arrowLength,
+ anchorX + halfDistance, y,
+ w - r, y
+ );
+ }
+ return path;
+ }
+ },
+
+ /**
+ * Define a clipping rectangle
+ * @param {String} id
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} width
+ * @param {Number} height
+ */
+ clipRect: function (x, y, width, height) {
+ var wrapper,
+ id = PREFIX + idCounter++,
+
+ clipPath = this.createElement('clipPath').attr({
+ id: id
+ }).add(this.defs);
+
+ wrapper = this.rect(x, y, width, height, 0).add(clipPath);
+ wrapper.id = id;
+ wrapper.clipPath = clipPath;
+ wrapper.count = 0;
+
+ return wrapper;
+ },
+
+
+
+
+
+ /**
+ * Add text to the SVG object
+ * @param {String} str
+ * @param {Number} x Left position
+ * @param {Number} y Top position
+ * @param {Boolean} useHTML Use HTML to render the text
+ */
+ text: function (str, x, y, useHTML) {
+
+ // declare variables
+ var renderer = this,
+ fakeSVG = useCanVG || (!hasSVG && renderer.forExport),
+ wrapper,
+ attr = {};
+
+ if (useHTML && (renderer.allowHTML || !renderer.forExport)) {
+ return renderer.html(str, x, y);
+ }
+
+ attr.x = Math.round(x || 0); // X is always needed for line-wrap logic
+ if (y) {
+ attr.y = Math.round(y);
+ }
+ if (str || str === 0) {
+ attr.text = str;
+ }
+
+ wrapper = renderer.createElement('text')
+ .attr(attr);
+
+ // Prevent wrapping from creating false offsetWidths in export in legacy IE (#1079, #1063)
+ if (fakeSVG) {
+ wrapper.css({
+ position: ABSOLUTE
+ });
+ }
+
+ if (!useHTML) {
+ wrapper.xSetter = function (value, key, element) {
+ var tspans = element.getElementsByTagName('tspan'),
+ tspan,
+ parentVal = element.getAttribute(key),
+ i;
+ for (i = 0; i < tspans.length; i++) {
+ tspan = tspans[i];
+ // If the x values are equal, the tspan represents a linebreak
+ if (tspan.getAttribute(key) === parentVal) {
+ tspan.setAttribute(key, value);
+ }
+ }
+ element.setAttribute(key, value);
+ };
+ }
+
+ return wrapper;
+ },
+
+ /**
+ * Utility to return the baseline offset and total line height from the font size
+ */
+ fontMetrics: function (fontSize, elem) {
+ var lineHeight,
+ baseline,
+ style;
+
+ fontSize = fontSize || this.style.fontSize;
+ if (!fontSize && elem && win.getComputedStyle) {
+ elem = elem.element || elem; // SVGElement
+ style = win.getComputedStyle(elem, "");
+ fontSize = style && style.fontSize; // #4309, the style doesn't exist inside a hidden iframe in Firefox
+ }
+ fontSize = /px/.test(fontSize) ? pInt(fontSize) : /em/.test(fontSize) ? parseFloat(fontSize) * 12 : 12;
+
+ // Empirical values found by comparing font size and bounding box height.
+ // Applies to the default font family. http://jsfiddle.net/highcharts/7xvn7/
+ lineHeight = fontSize < 24 ? fontSize + 3 : mathRound(fontSize * 1.2);
+ baseline = mathRound(lineHeight * 0.8);
+
+ return {
+ h: lineHeight,
+ b: baseline,
+ f: fontSize
+ };
+ },
+
+ /**
+ * Correct X and Y positioning of a label for rotation (#1764)
+ */
+ rotCorr: function (baseline, rotation, alterY) {
+ var y = baseline;
+ if (rotation && alterY) {
+ y = mathMax(y * mathCos(rotation * deg2rad), 4);
+ }
+ return {
+ x: (-baseline / 3) * mathSin(rotation * deg2rad),
+ y: y
+ };
+ },
+
+ /**
+ * Add a label, a text item that can hold a colored or gradient background
+ * as well as a border and shadow.
+ * @param {string} str
+ * @param {Number} x
+ * @param {Number} y
+ * @param {String} shape
+ * @param {Number} anchorX In case the shape has a pointer, like a flag, this is the
+ * coordinates it should be pinned to
+ * @param {Number} anchorY
+ * @param {Boolean} baseline Whether to position the label relative to the text baseline,
+ * like renderer.text, or to the upper border of the rectangle.
+ * @param {String} className Class name for the group
+ */
+ label: function (str, x, y, shape, anchorX, anchorY, useHTML, baseline, className) {
+
+ var renderer = this,
+ wrapper = renderer.g(className),
+ text = renderer.text('', 0, 0, useHTML)
+ .attr({
+ zIndex: 1
+ }),
+ //.add(wrapper),
+ box,
+ bBox,
+ alignFactor = 0,
+ padding = 3,
+ paddingLeft = 0,
+ width,
+ height,
+ wrapperX,
+ wrapperY,
+ crispAdjust = 0,
+ deferredAttr = {},
+ baselineOffset,
+ needsBox;
+
+ /**
+ * This function runs after the label is added to the DOM (when the bounding box is
+ * available), and after the text of the label is updated to detect the new bounding
+ * box and reflect it in the border box.
+ */
+ function updateBoxSize() {
+ var boxX,
+ boxY,
+ style = text.element.style;
+
+ bBox = (width === undefined || height === undefined || wrapper.styles.textAlign) && defined(text.textStr) &&
+ text.getBBox(); //#3295 && 3514 box failure when string equals 0
+ wrapper.width = (width || bBox.width || 0) + 2 * padding + paddingLeft;
+ wrapper.height = (height || bBox.height || 0) + 2 * padding;
+
+ // update the label-scoped y offset
+ baselineOffset = padding + renderer.fontMetrics(style && style.fontSize, text).b;
+
+
+ if (needsBox) {
+
+ // create the border box if it is not already present
+ if (!box) {
+ boxX = mathRound(-alignFactor * padding) + crispAdjust;
+ boxY = (baseline ? -baselineOffset : 0) + crispAdjust;
+
+ wrapper.box = box = shape ?
+ renderer.symbol(shape, boxX, boxY, wrapper.width, wrapper.height, deferredAttr) :
+ renderer.rect(boxX, boxY, wrapper.width, wrapper.height, 0, deferredAttr[STROKE_WIDTH]);
+
+ if (!box.isImg) { // #4324, fill "none" causes it to be ignored by mouse events in IE
+ box.attr('fill', NONE);
+ }
+ box.add(wrapper);
+ }
+
+ // apply the box attributes
+ if (!box.isImg) { // #1630
+ box.attr(extend({
+ width: mathRound(wrapper.width),
+ height: mathRound(wrapper.height)
+ }, deferredAttr));
+ }
+ deferredAttr = null;
+ }
+ }
+
+ /**
+ * This function runs after setting text or padding, but only if padding is changed
+ */
+ function updateTextPadding() {
+ var styles = wrapper.styles,
+ textAlign = styles && styles.textAlign,
+ x = paddingLeft + padding * (1 - alignFactor),
+ y;
+
+ // determin y based on the baseline
+ y = baseline ? 0 : baselineOffset;
+
+ // compensate for alignment
+ if (defined(width) && bBox && (textAlign === 'center' || textAlign === 'right')) {
+ x += { center: 0.5, right: 1 }[textAlign] * (width - bBox.width);
+ }
+
+ // update if anything changed
+ if (x !== text.x || y !== text.y) {
+ text.attr('x', x);
+ if (y !== UNDEFINED) {
+ text.attr('y', y);
+ }
+ }
+
+ // record current values
+ text.x = x;
+ text.y = y;
+ }
+
+ /**
+ * Set a box attribute, or defer it if the box is not yet created
+ * @param {Object} key
+ * @param {Object} value
+ */
+ function boxAttr(key, value) {
+ if (box) {
+ box.attr(key, value);
+ } else {
+ deferredAttr[key] = value;
+ }
+ }
+
+ /**
+ * After the text element is added, get the desired size of the border box
+ * and add it before the text in the DOM.
+ */
+ wrapper.onAdd = function () {
+ text.add(wrapper);
+ wrapper.attr({
+ text: (str || str === 0) ? str : '', // alignment is available now // #3295: 0 not rendered if given as a value
+ x: x,
+ y: y
+ });
+
+ if (box && defined(anchorX)) {
+ wrapper.attr({
+ anchorX: anchorX,
+ anchorY: anchorY
+ });
+ }
+ };
+
+ /*
+ * Add specific attribute setters.
+ */
+
+ // only change local variables
+ wrapper.widthSetter = function (value) {
+ width = value;
+ };
+ wrapper.heightSetter = function (value) {
+ height = value;
+ };
+ wrapper.paddingSetter = function (value) {
+ if (defined(value) && value !== padding) {
+ padding = wrapper.padding = value;
+ updateTextPadding();
+ }
+ };
+ wrapper.paddingLeftSetter = function (value) {
+ if (defined(value) && value !== paddingLeft) {
+ paddingLeft = value;
+ updateTextPadding();
+ }
+ };
+
+
+ // change local variable and prevent setting attribute on the group
+ wrapper.alignSetter = function (value) {
+ alignFactor = { left: 0, center: 0.5, right: 1 }[value];
+ };
+
+ // apply these to the box and the text alike
+ wrapper.textSetter = function (value) {
+ if (value !== UNDEFINED) {
+ text.textSetter(value);
+ }
+ updateBoxSize();
+ updateTextPadding();
+ };
+
+ // apply these to the box but not to the text
+ wrapper['stroke-widthSetter'] = function (value, key) {
+ if (value) {
+ needsBox = true;
+ }
+ crispAdjust = value % 2 / 2;
+ boxAttr(key, value);
+ };
+ wrapper.strokeSetter = wrapper.fillSetter = wrapper.rSetter = function (value, key) {
+ if (key === 'fill' && value) {
+ needsBox = true;
+ }
+ boxAttr(key, value);
+ };
+ wrapper.anchorXSetter = function (value, key) {
+ anchorX = value;
+ boxAttr(key, mathRound(value) - crispAdjust - wrapperX);
+ };
+ wrapper.anchorYSetter = function (value, key) {
+ anchorY = value;
+ boxAttr(key, value - wrapperY);
+ };
+
+ // rename attributes
+ wrapper.xSetter = function (value) {
+ wrapper.x = value; // for animation getter
+ if (alignFactor) {
+ value -= alignFactor * ((width || bBox.width) + padding);
+ }
+ wrapperX = mathRound(value);
+ wrapper.attr('translateX', wrapperX);
+ };
+ wrapper.ySetter = function (value) {
+ wrapperY = wrapper.y = mathRound(value);
+ wrapper.attr('translateY', wrapperY);
+ };
+
+ // Redirect certain methods to either the box or the text
+ var baseCss = wrapper.css;
+ return extend(wrapper, {
+ /**
+ * Pick up some properties and apply them to the text instead of the wrapper
+ */
+ css: function (styles) {
+ if (styles) {
+ var textStyles = {};
+ styles = merge(styles); // create a copy to avoid altering the original object (#537)
+ each(wrapper.textProps, function (prop) {
+ if (styles[prop] !== UNDEFINED) {
+ textStyles[prop] = styles[prop];
+ delete styles[prop];
+ }
+ });
+ text.css(textStyles);
+ }
+ return baseCss.call(wrapper, styles);
+ },
+ /**
+ * Return the bounding box of the box, not the group
+ */
+ getBBox: function () {
+ return {
+ width: bBox.width + 2 * padding,
+ height: bBox.height + 2 * padding,
+ x: bBox.x - padding,
+ y: bBox.y - padding
+ };
+ },
+ /**
+ * Apply the shadow to the box
+ */
+ shadow: function (b) {
+ if (box) {
+ box.shadow(b);
+ }
+ return wrapper;
+ },
+ /**
+ * Destroy and release memory.
+ */
+ destroy: function () {
+
+ // Added by button implementation
+ removeEvent(wrapper.element, 'mouseenter');
+ removeEvent(wrapper.element, 'mouseleave');
+
+ if (text) {
+ text = text.destroy();
+ }
+ if (box) {
+ box = box.destroy();
+ }
+ // Call base implementation to destroy the rest
+ SVGElement.prototype.destroy.call(wrapper);
+
+ // Release local pointers (#1298)
+ wrapper = renderer = updateBoxSize = updateTextPadding = boxAttr = null;
+ }
+ });
+ }
+}; // end SVGRenderer
+
+
+// general renderer
+Renderer = SVGRenderer;
+
+
+// extend SvgElement for useHTML option
+extend(SVGElement.prototype, {
+ /**
+ * Apply CSS to HTML elements. This is used in text within SVG rendering and
+ * by the VML renderer
+ */
+ htmlCss: function (styles) {
+ var wrapper = this,
+ element = wrapper.element,
+ textWidth = styles && element.tagName === 'SPAN' && styles.width;
+
+ if (textWidth) {
+ delete styles.width;
+ wrapper.textWidth = textWidth;
+ wrapper.updateTransform();
+ }
+ if (styles && styles.textOverflow === 'ellipsis') {
+ styles.whiteSpace = 'nowrap';
+ styles.overflow = 'hidden';
+ }
+ wrapper.styles = extend(wrapper.styles, styles);
+ css(wrapper.element, styles);
+
+ return wrapper;
+ },
+
+ /**
+ * VML and useHTML method for calculating the bounding box based on offsets
+ * @param {Boolean} refresh Whether to force a fresh value from the DOM or to
+ * use the cached value
+ *
+ * @return {Object} A hash containing values for x, y, width and height
+ */
+
+ htmlGetBBox: function () {
+ var wrapper = this,
+ element = wrapper.element;
+
+ // faking getBBox in exported SVG in legacy IE
+ // faking getBBox in exported SVG in legacy IE (is this a duplicate of the fix for #1079?)
+ if (element.nodeName === 'text') {
+ element.style.position = ABSOLUTE;
+ }
+
+ return {
+ x: element.offsetLeft,
+ y: element.offsetTop,
+ width: element.offsetWidth,
+ height: element.offsetHeight
+ };
+ },
+
+ /**
+ * VML override private method to update elements based on internal
+ * properties based on SVG transform
+ */
+ htmlUpdateTransform: function () {
+ // aligning non added elements is expensive
+ if (!this.added) {
+ this.alignOnAdd = true;
+ return;
+ }
+
+ var wrapper = this,
+ renderer = wrapper.renderer,
+ elem = wrapper.element,
+ translateX = wrapper.translateX || 0,
+ translateY = wrapper.translateY || 0,
+ x = wrapper.x || 0,
+ y = wrapper.y || 0,
+ align = wrapper.textAlign || 'left',
+ alignCorrection = { left: 0, center: 0.5, right: 1 }[align],
+ shadows = wrapper.shadows,
+ styles = wrapper.styles;
+
+ // apply translate
+ css(elem, {
+ marginLeft: translateX,
+ marginTop: translateY
+ });
+ if (shadows) { // used in labels/tooltip
+ each(shadows, function (shadow) {
+ css(shadow, {
+ marginLeft: translateX + 1,
+ marginTop: translateY + 1
+ });
+ });
+ }
+
+ // apply inversion
+ if (wrapper.inverted) { // wrapper is a group
+ each(elem.childNodes, function (child) {
+ renderer.invertChild(child, elem);
+ });
+ }
+
+ if (elem.tagName === 'SPAN') {
+
+ var width,
+ rotation = wrapper.rotation,
+ baseline,
+ textWidth = pInt(wrapper.textWidth),
+ currentTextTransform = [rotation, align, elem.innerHTML, wrapper.textWidth, wrapper.textAlign].join(',');
+
+ if (currentTextTransform !== wrapper.cTT) { // do the calculations and DOM access only if properties changed
+
+
+ baseline = renderer.fontMetrics(elem.style.fontSize).b;
+
+ // Renderer specific handling of span rotation
+ if (defined(rotation)) {
+ wrapper.setSpanRotation(rotation, alignCorrection, baseline);
+ }
+
+ width = pick(wrapper.elemWidth, elem.offsetWidth);
+
+ // Update textWidth
+ if (width > textWidth && /[ \-]/.test(elem.textContent || elem.innerText)) { // #983, #1254
+ css(elem, {
+ width: textWidth + PX,
+ display: 'block',
+ whiteSpace: (styles && styles.whiteSpace) || 'normal' // #3331
+ });
+ width = textWidth;
+ }
+
+ wrapper.getSpanCorrection(width, baseline, alignCorrection, rotation, align);
+ }
+
+ // apply position with correction
+ css(elem, {
+ left: (x + (wrapper.xCorr || 0)) + PX,
+ top: (y + (wrapper.yCorr || 0)) + PX
+ });
+
+ // force reflow in webkit to apply the left and top on useHTML element (#1249)
+ if (isWebKit) {
+ baseline = elem.offsetHeight; // assigned to baseline for JSLint purpose
+ }
+
+ // record current text transform
+ wrapper.cTT = currentTextTransform;
+ }
+ },
+
+ /**
+ * Set the rotation of an individual HTML span
+ */
+ setSpanRotation: function (rotation, alignCorrection, baseline) {
+ var rotationStyle = {},
+ cssTransformKey = isMS ? '-ms-transform' : isWebKit ? '-webkit-transform' : isFirefox ? 'MozTransform' : isOpera ? '-o-transform' : '';
+
+ rotationStyle[cssTransformKey] = rotationStyle.transform = 'rotate(' + rotation + 'deg)';
+ rotationStyle[cssTransformKey + (isFirefox ? 'Origin' : '-origin')] = rotationStyle.transformOrigin = (alignCorrection * 100) + '% ' + baseline + 'px';
+ css(this.element, rotationStyle);
+ },
+
+ /**
+ * Get the correction in X and Y positioning as the element is rotated.
+ */
+ getSpanCorrection: function (width, baseline, alignCorrection) {
+ this.xCorr = -width * alignCorrection;
+ this.yCorr = -baseline;
+ }
+});
+
+// Extend SvgRenderer for useHTML option.
+extend(SVGRenderer.prototype, {
+ /**
+ * Create HTML text node. This is used by the VML renderer as well as the SVG
+ * renderer through the useHTML option.
+ *
+ * @param {String} str
+ * @param {Number} x
+ * @param {Number} y
+ */
+ html: function (str, x, y) {
+ var wrapper = this.createElement('span'),
+ element = wrapper.element,
+ renderer = wrapper.renderer;
+
+ // Text setter
+ wrapper.textSetter = function (value) {
+ if (value !== element.innerHTML) {
+ delete this.bBox;
+ }
+ element.innerHTML = this.textStr = value;
+ wrapper.htmlUpdateTransform();
+ };
+
+ // Various setters which rely on update transform
+ wrapper.xSetter = wrapper.ySetter = wrapper.alignSetter = wrapper.rotationSetter = function (value, key) {
+ if (key === 'align') {
+ key = 'textAlign'; // Do not overwrite the SVGElement.align method. Same as VML.
+ }
+ wrapper[key] = value;
+ wrapper.htmlUpdateTransform();
+ };
+
+ // Set the default attributes
+ wrapper.attr({
+ text: str,
+ x: mathRound(x),
+ y: mathRound(y)
+ })
+ .css({
+ position: ABSOLUTE,
+ fontFamily: this.style.fontFamily,
+ fontSize: this.style.fontSize
+ });
+
+ // Keep the whiteSpace style outside the wrapper.styles collection
+ element.style.whiteSpace = 'nowrap';
+
+ // Use the HTML specific .css method
+ wrapper.css = wrapper.htmlCss;
+
+ // This is specific for HTML within SVG
+ if (renderer.isSVG) {
+ wrapper.add = function (svgGroupWrapper) {
+
+ var htmlGroup,
+ container = renderer.box.parentNode,
+ parentGroup,
+ parents = [];
+
+ this.parentGroup = svgGroupWrapper;
+
+ // Create a mock group to hold the HTML elements
+ if (svgGroupWrapper) {
+ htmlGroup = svgGroupWrapper.div;
+ if (!htmlGroup) {
+
+ // Read the parent chain into an array and read from top down
+ parentGroup = svgGroupWrapper;
+ while (parentGroup) {
+
+ parents.push(parentGroup);
+
+ // Move up to the next parent group
+ parentGroup = parentGroup.parentGroup;
+ }
+
+ // Ensure dynamically updating position when any parent is translated
+ each(parents.reverse(), function (parentGroup) {
+ var htmlGroupStyle,
+ cls = attr(parentGroup.element, 'class');
+
+ if (cls) {
+ cls = { className: cls };
+ } // else null
+
+ // Create a HTML div and append it to the parent div to emulate
+ // the SVG group structure
+ htmlGroup = parentGroup.div = parentGroup.div || createElement(DIV, cls, {
+ position: ABSOLUTE,
+ left: (parentGroup.translateX || 0) + PX,
+ top: (parentGroup.translateY || 0) + PX
+ }, htmlGroup || container); // the top group is appended to container
+
+ // Shortcut
+ htmlGroupStyle = htmlGroup.style;
+
+ // Set listeners to update the HTML div's position whenever the SVG group
+ // position is changed
+ extend(parentGroup, {
+ translateXSetter: function (value, key) {
+ htmlGroupStyle.left = value + PX;
+ parentGroup[key] = value;
+ parentGroup.doTransform = true;
+ },
+ translateYSetter: function (value, key) {
+ htmlGroupStyle.top = value + PX;
+ parentGroup[key] = value;
+ parentGroup.doTransform = true;
+ }
+ });
+
+ // These properties are set as attributes on the SVG group, and as
+ // identical CSS properties on the div. (#3542)
+ each(['opacity', 'visibility'], function (prop) {
+ wrap(parentGroup, prop + 'Setter', function (proceed, value, key, elem) {
+ proceed.call(this, value, key, elem);
+ htmlGroupStyle[key] = value;
+ });
+ });
+ });
+
+ }
+ } else {
+ htmlGroup = container;
+ }
+
+ htmlGroup.appendChild(element);
+
+ // Shared with VML:
+ wrapper.added = true;
+ if (wrapper.alignOnAdd) {
+ wrapper.htmlUpdateTransform();
+ }
+
+ return wrapper;
+ };
+ }
+ return wrapper;
+ }
+});
+
+/**
+ * The Tick class
+ */
+function Tick(axis, pos, type, noLabel) {
+ this.axis = axis;
+ this.pos = pos;
+ this.type = type || '';
+ this.isNew = true;
+
+ if (!type && !noLabel) {
+ this.addLabel();
+ }
+}
+
+Tick.prototype = {
+ /**
+ * Write the tick label
+ */
+ addLabel: function () {
+ var tick = this,
+ axis = tick.axis,
+ options = axis.options,
+ chart = axis.chart,
+ categories = axis.categories,
+ names = axis.names,
+ pos = tick.pos,
+ labelOptions = options.labels,
+ str,
+ tickPositions = axis.tickPositions,
+ isFirst = pos === tickPositions[0],
+ isLast = pos === tickPositions[tickPositions.length - 1],
+ value = categories ?
+ pick(categories[pos], names[pos], pos) :
+ pos,
+ label = tick.label,
+ tickPositionInfo = tickPositions.info,
+ dateTimeLabelFormat;
+
+ // Set the datetime label format. If a higher rank is set for this position, use that. If not,
+ // use the general format.
+ if (axis.isDatetimeAxis && tickPositionInfo) {
+ dateTimeLabelFormat = options.dateTimeLabelFormats[tickPositionInfo.higherRanks[pos] || tickPositionInfo.unitName];
+ }
+ // set properties for access in render method
+ tick.isFirst = isFirst;
+ tick.isLast = isLast;
+
+ // get the string
+ str = axis.labelFormatter.call({
+ axis: axis,
+ chart: chart,
+ isFirst: isFirst,
+ isLast: isLast,
+ dateTimeLabelFormat: dateTimeLabelFormat,
+ value: axis.isLog ? correctFloat(lin2log(value)) : value
+ });
+
+ // prepare CSS
+ //css = width && { width: mathMax(1, mathRound(width - 2 * (labelOptions.padding || 10))) + PX };
+
+ // first call
+ if (!defined(label)) {
+
+ tick.label = label =
+ defined(str) && labelOptions.enabled ?
+ chart.renderer.text(
+ str,
+ 0,
+ 0,
+ labelOptions.useHTML
+ )
+ //.attr(attr)
+ // without position absolute, IE export sometimes is wrong
+ .css(merge(labelOptions.style))
+ .add(axis.labelGroup) :
+ null;
+ tick.labelLength = label && label.getBBox().width; // Un-rotated length
+ tick.rotation = 0; // Base value to detect change for new calls to getBBox
+
+ // update
+ } else if (label) {
+ label.attr({ text: str });
+ }
+ },
+
+ /**
+ * Get the offset height or width of the label
+ */
+ getLabelSize: function () {
+ return this.label ?
+ this.label.getBBox()[this.axis.horiz ? 'height' : 'width'] :
+ 0;
+ },
+
+ /**
+ * Handle the label overflow by adjusting the labels to the left and right edge, or
+ * hide them if they collide into the neighbour label.
+ */
+ handleOverflow: function (xy) {
+ var axis = this.axis,
+ pxPos = xy.x,
+ chartWidth = axis.chart.chartWidth,
+ spacing = axis.chart.spacing,
+ leftBound = pick(axis.labelLeft, mathMin(axis.pos, spacing[3])),
+ rightBound = pick(axis.labelRight, mathMax(axis.pos + axis.len, chartWidth - spacing[1])),
+ label = this.label,
+ rotation = this.rotation,
+ factor = { left: 0, center: 0.5, right: 1 }[axis.labelAlign],
+ labelWidth = label.getBBox().width,
+ slotWidth = axis.slotWidth,
+ xCorrection = factor,
+ goRight = 1,
+ leftPos,
+ rightPos,
+ textWidth,
+ css = {};
+
+ // Check if the label overshoots the chart spacing box. If it does, move it.
+ // If it now overshoots the slotWidth, add ellipsis.
+ if (!rotation) {
+ leftPos = pxPos - factor * labelWidth;
+ rightPos = pxPos + (1 - factor) * labelWidth;
+
+ if (leftPos < leftBound) {
+ slotWidth = xy.x + slotWidth * (1 - factor) - leftBound;
+ } else if (rightPos > rightBound) {
+ slotWidth = rightBound - xy.x + slotWidth * factor;
+ goRight = -1;
+ }
+
+ slotWidth = mathMin(axis.slotWidth, slotWidth); // #4177
+ if (slotWidth < axis.slotWidth && axis.labelAlign === 'center') {
+ xy.x += goRight * (axis.slotWidth - slotWidth - xCorrection * (axis.slotWidth - mathMin(labelWidth, slotWidth)));
+ }
+ // If the label width exceeds the available space, set a text width to be
+ // picked up below. Also, if a width has been set before, we need to set a new
+ // one because the reported labelWidth will be limited by the box (#3938).
+ if (labelWidth > slotWidth || (axis.autoRotation && label.styles.width)) {
+ textWidth = slotWidth;
+ }
+
+ // Add ellipsis to prevent rotated labels to be clipped against the edge of the chart
+ } else if (rotation < 0 && pxPos - factor * labelWidth < leftBound) {
+ textWidth = mathRound(pxPos / mathCos(rotation * deg2rad) - leftBound);
+ } else if (rotation > 0 && pxPos + factor * labelWidth > rightBound) {
+ textWidth = mathRound((chartWidth - pxPos) / mathCos(rotation * deg2rad));
+ }
+
+ if (textWidth) {
+ css.width = textWidth;
+ if (!axis.options.labels.style.textOverflow) {
+ css.textOverflow = 'ellipsis';
+ }
+ label.css(css);
+ }
+ },
+
+ /**
+ * Get the x and y position for ticks and labels
+ */
+ getPosition: function (horiz, pos, tickmarkOffset, old) {
+ var axis = this.axis,
+ chart = axis.chart,
+ cHeight = (old && chart.oldChartHeight) || chart.chartHeight;
+
+ return {
+ x: horiz ?
+ axis.translate(pos + tickmarkOffset, null, null, old) + axis.transB :
+ axis.left + axis.offset + (axis.opposite ? ((old && chart.oldChartWidth) || chart.chartWidth) - axis.right - axis.left : 0),
+
+ y: horiz ?
+ cHeight - axis.bottom + axis.offset - (axis.opposite ? axis.height : 0) :
+ cHeight - axis.translate(pos + tickmarkOffset, null, null, old) - axis.transB
+ };
+
+ },
+
+ /**
+ * Get the x, y position of the tick label
+ */
+ getLabelPosition: function (x, y, label, horiz, labelOptions, tickmarkOffset, index, step) {
+ var axis = this.axis,
+ transA = axis.transA,
+ reversed = axis.reversed,
+ staggerLines = axis.staggerLines,
+ rotCorr = axis.tickRotCorr || { x: 0, y: 0 },
+ yOffset = pick(labelOptions.y, rotCorr.y + (axis.side === 2 ? 8 : -(label.getBBox().height / 2))),
+ line;
+
+ x = x + labelOptions.x + rotCorr.x - (tickmarkOffset && horiz ?
+ tickmarkOffset * transA * (reversed ? -1 : 1) : 0);
+ y = y + yOffset - (tickmarkOffset && !horiz ?
+ tickmarkOffset * transA * (reversed ? 1 : -1) : 0);
+
+ // Correct for staggered labels
+ if (staggerLines) {
+ line = (index / (step || 1) % staggerLines);
+ y += line * (axis.labelOffset / staggerLines);
+ }
+
+ return {
+ x: x,
+ y: mathRound(y)
+ };
+ },
+
+ /**
+ * Extendible method to return the path of the marker
+ */
+ getMarkPath: function (x, y, tickLength, tickWidth, horiz, renderer) {
+ return renderer.crispLine([
+ M,
+ x,
+ y,
+ L,
+ x + (horiz ? 0 : -tickLength),
+ y + (horiz ? tickLength : 0)
+ ], tickWidth);
+ },
+
+ /**
+ * Put everything in place
+ *
+ * @param index {Number}
+ * @param old {Boolean} Use old coordinates to prepare an animation into new position
+ */
+ render: function (index, old, opacity) {
+ var tick = this,
+ axis = tick.axis,
+ options = axis.options,
+ chart = axis.chart,
+ renderer = chart.renderer,
+ horiz = axis.horiz,
+ type = tick.type,
+ label = tick.label,
+ pos = tick.pos,
+ labelOptions = options.labels,
+ gridLine = tick.gridLine,
+ gridPrefix = type ? type + 'Grid' : 'grid',
+ tickPrefix = type ? type + 'Tick' : 'tick',
+ gridLineWidth = options[gridPrefix + 'LineWidth'],
+ gridLineColor = options[gridPrefix + 'LineColor'],
+ dashStyle = options[gridPrefix + 'LineDashStyle'],
+ tickLength = options[tickPrefix + 'Length'],
+ tickWidth = pick(options[tickPrefix + 'Width'], !type && axis.isXAxis ? 1 : 0), // X axis defaults to 1
+ tickColor = options[tickPrefix + 'Color'],
+ tickPosition = options[tickPrefix + 'Position'],
+ gridLinePath,
+ mark = tick.mark,
+ markPath,
+ step = /*axis.labelStep || */labelOptions.step,
+ attribs,
+ show = true,
+ tickmarkOffset = axis.tickmarkOffset,
+ xy = tick.getPosition(horiz, pos, tickmarkOffset, old),
+ x = xy.x,
+ y = xy.y,
+ reverseCrisp = ((horiz && x === axis.pos + axis.len) || (!horiz && y === axis.pos)) ? -1 : 1; // #1480, #1687
+
+ opacity = pick(opacity, 1);
+ this.isActive = true;
+
+ // create the grid line
+ if (gridLineWidth) {
+ gridLinePath = axis.getPlotLinePath(pos + tickmarkOffset, gridLineWidth * reverseCrisp, old, true);
+
+ if (gridLine === UNDEFINED) {
+ attribs = {
+ stroke: gridLineColor,
+ 'stroke-width': gridLineWidth
+ };
+ if (dashStyle) {
+ attribs.dashstyle = dashStyle;
+ }
+ if (!type) {
+ attribs.zIndex = 1;
+ }
+ if (old) {
+ attribs.opacity = 0;
+ }
+ tick.gridLine = gridLine =
+ gridLineWidth ?
+ renderer.path(gridLinePath)
+ .attr(attribs).add(axis.gridGroup) :
+ null;
+ }
+
+ // If the parameter 'old' is set, the current call will be followed
+ // by another call, therefore do not do any animations this time
+ if (!old && gridLine && gridLinePath) {
+ gridLine[tick.isNew ? 'attr' : 'animate']({
+ d: gridLinePath,
+ opacity: opacity
+ });
+ }
+ }
+
+ // create the tick mark
+ if (tickWidth && tickLength) {
+
+ // negate the length
+ if (tickPosition === 'inside') {
+ tickLength = -tickLength;
+ }
+ if (axis.opposite) {
+ tickLength = -tickLength;
+ }
+
+ markPath = tick.getMarkPath(x, y, tickLength, tickWidth * reverseCrisp, horiz, renderer);
+ if (mark) { // updating
+ mark.animate({
+ d: markPath,
+ opacity: opacity
+ });
+ } else { // first time
+ tick.mark = renderer.path(
+ markPath
+ ).attr({
+ stroke: tickColor,
+ 'stroke-width': tickWidth,
+ opacity: opacity
+ }).add(axis.axisGroup);
+ }
+ }
+
+ // the label is created on init - now move it into place
+ if (label && !isNaN(x)) {
+ label.xy = xy = tick.getLabelPosition(x, y, label, horiz, labelOptions, tickmarkOffset, index, step);
+
+ // Apply show first and show last. If the tick is both first and last, it is
+ // a single centered tick, in which case we show the label anyway (#2100).
+ if ((tick.isFirst && !tick.isLast && !pick(options.showFirstLabel, 1)) ||
+ (tick.isLast && !tick.isFirst && !pick(options.showLastLabel, 1))) {
+ show = false;
+
+ // Handle label overflow and show or hide accordingly
+ } else if (horiz && !axis.isRadial && !labelOptions.step && !labelOptions.rotation && !old && opacity !== 0) {
+ tick.handleOverflow(xy);
+ }
+
+ // apply step
+ if (step && index % step) {
+ // show those indices dividable by step
+ show = false;
+ }
+
+ // Set the new position, and show or hide
+ if (show && !isNaN(xy.y)) {
+ xy.opacity = opacity;
+ label[tick.isNew ? 'attr' : 'animate'](xy);
+ tick.isNew = false;
+ } else {
+ label.attr('y', -9999); // #1338
+ }
+ }
+ },
+
+ /**
+ * Destructor for the tick prototype
+ */
+ destroy: function () {
+ destroyObjectProperties(this, this.axis);
+ }
+};
+
+
+
+/**
+ * The object wrapper for plot lines and plot bands
+ * @param {Object} options
+ */
+Highcharts.PlotLineOrBand = function (axis, options) {
+ this.axis = axis;
+
+ if (options) {
+ this.options = options;
+ this.id = options.id;
+ }
+};
+
+Highcharts.PlotLineOrBand.prototype = {
+
+ /**
+ * Render the plot line or plot band. If it is already existing,
+ * move it.
+ */
+ render: function () {
+ var plotLine = this,
+ axis = plotLine.axis,
+ horiz = axis.horiz,
+ options = plotLine.options,
+ optionsLabel = options.label,
+ label = plotLine.label,
+ width = options.width,
+ to = options.to,
+ from = options.from,
+ isBand = defined(from) && defined(to),
+ value = options.value,
+ dashStyle = options.dashStyle,
+ svgElem = plotLine.svgElem,
+ path = [],
+ addEvent,
+ eventType,
+ xs,
+ ys,
+ x,
+ y,
+ color = options.color,
+ zIndex = options.zIndex,
+ events = options.events,
+ attribs = {},
+ renderer = axis.chart.renderer;
+
+ // logarithmic conversion
+ if (axis.isLog) {
+ from = log2lin(from);
+ to = log2lin(to);
+ value = log2lin(value);
+ }
+
+ // plot line
+ if (width) {
+ path = axis.getPlotLinePath(value, width);
+ attribs = {
+ stroke: color,
+ 'stroke-width': width
+ };
+ if (dashStyle) {
+ attribs.dashstyle = dashStyle;
+ }
+ } else if (isBand) { // plot band
+
+ path = axis.getPlotBandPath(from, to, options);
+ if (color) {
+ attribs.fill = color;
+ }
+ if (options.borderWidth) {
+ attribs.stroke = options.borderColor;
+ attribs['stroke-width'] = options.borderWidth;
+ }
+ } else {
+ return;
+ }
+ // zIndex
+ if (defined(zIndex)) {
+ attribs.zIndex = zIndex;
+ }
+
+ // common for lines and bands
+ if (svgElem) {
+ if (path) {
+ svgElem.animate({
+ d: path
+ }, null, svgElem.onGetPath);
+ } else {
+ svgElem.hide();
+ svgElem.onGetPath = function () {
+ svgElem.show();
+ };
+ if (label) {
+ plotLine.label = label = label.destroy();
+ }
+ }
+ } else if (path && path.length) {
+ plotLine.svgElem = svgElem = renderer.path(path)
+ .attr(attribs).add();
+
+ // events
+ if (events) {
+ addEvent = function (eventType) {
+ svgElem.on(eventType, function (e) {
+ events[eventType].apply(plotLine, [e]);
+ });
+ };
+ for (eventType in events) {
+ addEvent(eventType);
+ }
+ }
+ }
+
+ // the plot band/line label
+ if (optionsLabel && defined(optionsLabel.text) && path && path.length && axis.width > 0 && axis.height > 0) {
+ // apply defaults
+ optionsLabel = merge({
+ align: horiz && isBand && 'center',
+ x: horiz ? !isBand && 4 : 10,
+ verticalAlign : !horiz && isBand && 'middle',
+ y: horiz ? isBand ? 16 : 10 : isBand ? 6 : -4,
+ rotation: horiz && !isBand && 90
+ }, optionsLabel);
+
+ // add the SVG element
+ if (!label) {
+ attribs = {
+ align: optionsLabel.textAlign || optionsLabel.align,
+ rotation: optionsLabel.rotation
+ };
+ if (defined(zIndex)) {
+ attribs.zIndex = zIndex;
+ }
+ plotLine.label = label = renderer.text(
+ optionsLabel.text,
+ 0,
+ 0,
+ optionsLabel.useHTML
+ )
+ .attr(attribs)
+ .css(optionsLabel.style)
+ .add();
+ }
+
+ // get the bounding box and align the label
+ // #3000 changed to better handle choice between plotband or plotline
+ xs = [path[1], path[4], (isBand ? path[6] : path[1])];
+ ys = [path[2], path[5], (isBand ? path[7] : path[2])];
+ x = arrayMin(xs);
+ y = arrayMin(ys);
+
+ label.align(optionsLabel, false, {
+ x: x,
+ y: y,
+ width: arrayMax(xs) - x,
+ height: arrayMax(ys) - y
+ });
+ label.show();
+
+ } else if (label) { // move out of sight
+ label.hide();
+ }
+
+ // chainable
+ return plotLine;
+ },
+
+ /**
+ * Remove the plot line or band
+ */
+ destroy: function () {
+ // remove it from the lookup
+ erase(this.axis.plotLinesAndBands, this);
+
+ delete this.axis;
+ destroyObjectProperties(this);
+ }
+};
+
+/**
+ * Object with members for extending the Axis prototype
+ */
+
+AxisPlotLineOrBandExtension = {
+
+ /**
+ * Create the path for a plot band
+ */
+ getPlotBandPath: function (from, to) {
+ var toPath = this.getPlotLinePath(to, null, null, true),
+ path = this.getPlotLinePath(from, null, null, true);
+
+ if (path && toPath && path.toString() !== toPath.toString()) { // #3836
+ path.push(
+ toPath[4],
+ toPath[5],
+ toPath[1],
+ toPath[2]
+ );
+ } else { // outside the axis area
+ path = null;
+ }
+
+ return path;
+ },
+
+ addPlotBand: function (options) {
+ return this.addPlotBandOrLine(options, 'plotBands');
+ },
+
+ addPlotLine: function (options) {
+ return this.addPlotBandOrLine(options, 'plotLines');
+ },
+
+ /**
+ * Add a plot band or plot line after render time
+ *
+ * @param options {Object} The plotBand or plotLine configuration object
+ */
+ addPlotBandOrLine: function (options, coll) {
+ var obj = new Highcharts.PlotLineOrBand(this, options).render(),
+ userOptions = this.userOptions;
+
+ if (obj) { // #2189
+ // Add it to the user options for exporting and Axis.update
+ if (coll) {
+ userOptions[coll] = userOptions[coll] || [];
+ userOptions[coll].push(options);
+ }
+ this.plotLinesAndBands.push(obj);
+ }
+
+ return obj;
+ },
+
+ /**
+ * Remove a plot band or plot line from the chart by id
+ * @param {Object} id
+ */
+ removePlotBandOrLine: function (id) {
+ var plotLinesAndBands = this.plotLinesAndBands,
+ options = this.options,
+ userOptions = this.userOptions,
+ i = plotLinesAndBands.length;
+ while (i--) {
+ if (plotLinesAndBands[i].id === id) {
+ plotLinesAndBands[i].destroy();
+ }
+ }
+ each([options.plotLines || [], userOptions.plotLines || [], options.plotBands || [], userOptions.plotBands || []], function (arr) {
+ i = arr.length;
+ while (i--) {
+ if (arr[i].id === id) {
+ erase(arr, arr[i]);
+ }
+ }
+ });
+ }
+};
+
+
+
+/**
+ * Create a new axis object
+ * @param {Object} chart
+ * @param {Object} options
+ */
+var Axis = Highcharts.Axis = function () {
+ this.init.apply(this, arguments);
+};
+
+Axis.prototype = {
+
+ /**
+ * Default options for the X axis - the Y axis has extended defaults
+ */
+ defaultOptions: {
+ // allowDecimals: null,
+ // alternateGridColor: null,
+ // categories: [],
+ dateTimeLabelFormats: {
+ millisecond: '%H:%M:%S.%L',
+ second: '%H:%M:%S',
+ minute: '%H:%M',
+ hour: '%H:%M',
+ day: '%e. %b',
+ week: '%e. %b',
+ month: '%b \'%y',
+ year: '%Y'
+ },
+ endOnTick: false,
+ gridLineColor: '#D8D8D8',
+ // gridLineDashStyle: 'solid',
+ // gridLineWidth: 0,
+ // reversed: false,
+
+ labels: {
+ enabled: true,
+ // rotation: 0,
+ // align: 'center',
+ // step: null,
+ style: {
+ color: '#606060',
+ cursor: 'default',
+ fontSize: '11px'
+ },
+ x: 0,
+ y: 15
+ /*formatter: function () {
+ return this.value;
+ },*/
+ },
+ lineColor: '#C0D0E0',
+ lineWidth: 1,
+ //linkedTo: null,
+ //max: undefined,
+ //min: undefined,
+ minPadding: 0.01,
+ maxPadding: 0.01,
+ //minRange: null,
+ minorGridLineColor: '#E0E0E0',
+ // minorGridLineDashStyle: null,
+ minorGridLineWidth: 1,
+ minorTickColor: '#A0A0A0',
+ //minorTickInterval: null,
+ minorTickLength: 2,
+ minorTickPosition: 'outside', // inside or outside
+ //minorTickWidth: 0,
+ //opposite: false,
+ //offset: 0,
+ //plotBands: [{
+ // events: {},
+ // zIndex: 1,
+ // labels: { align, x, verticalAlign, y, style, rotation, textAlign }
+ //}],
+ //plotLines: [{
+ // events: {}
+ // dashStyle: {}
+ // zIndex:
+ // labels: { align, x, verticalAlign, y, style, rotation, textAlign }
+ //}],
+ //reversed: false,
+ // showFirstLabel: true,
+ // showLastLabel: true,
+ startOfWeek: 1,
+ startOnTick: false,
+ tickColor: '#C0D0E0',
+ //tickInterval: null,
+ tickLength: 10,
+ tickmarkPlacement: 'between', // on or between
+ tickPixelInterval: 100,
+ tickPosition: 'outside',
+ //tickWidth: 1,
+ title: {
+ //text: null,
+ align: 'middle', // low, middle or high
+ //margin: 0 for horizontal, 10 for vertical axes,
+ //rotation: 0,
+ //side: 'outside',
+ style: {
+ color: '#707070'
+ }
+ //x: 0,
+ //y: 0
+ },
+ type: 'linear' // linear, logarithmic or datetime
+ //visible: true
+ },
+
+ /**
+ * This options set extends the defaultOptions for Y axes
+ */
+ defaultYAxisOptions: {
+ endOnTick: true,
+ gridLineWidth: 1,
+ tickPixelInterval: 72,
+ showLastLabel: true,
+ labels: {
+ x: -8,
+ y: 3
+ },
+ lineWidth: 0,
+ maxPadding: 0.05,
+ minPadding: 0.05,
+ startOnTick: true,
+ //tickWidth: 0,
+ title: {
+ rotation: 270,
+ text: 'Values'
+ },
+ stackLabels: {
+ enabled: false,
+ //align: dynamic,
+ //y: dynamic,
+ //x: dynamic,
+ //verticalAlign: dynamic,
+ //textAlign: dynamic,
+ //rotation: 0,
+ formatter: function () {
+ return Highcharts.numberFormat(this.total, -1);
+ },
+ style: merge(defaultPlotOptions.line.dataLabels.style, { color: '#000000' })
+ }
+ },
+
+ /**
+ * These options extend the defaultOptions for left axes
+ */
+ defaultLeftAxisOptions: {
+ labels: {
+ x: -15,
+ y: null
+ },
+ title: {
+ rotation: 270
+ }
+ },
+
+ /**
+ * These options extend the defaultOptions for right axes
+ */
+ defaultRightAxisOptions: {
+ labels: {
+ x: 15,
+ y: null
+ },
+ title: {
+ rotation: 90
+ }
+ },
+
+ /**
+ * These options extend the defaultOptions for bottom axes
+ */
+ defaultBottomAxisOptions: {
+ labels: {
+ autoRotation: [-45],
+ x: 0,
+ y: null // based on font size
+ // overflow: undefined,
+ // staggerLines: null
+ },
+ title: {
+ rotation: 0
+ }
+ },
+ /**
+ * These options extend the defaultOptions for top axes
+ */
+ defaultTopAxisOptions: {
+ labels: {
+ autoRotation: [-45],
+ x: 0,
+ y: -15
+ // overflow: undefined
+ // staggerLines: null
+ },
+ title: {
+ rotation: 0
+ }
+ },
+
+ /**
+ * Initialize the axis
+ */
+ init: function (chart, userOptions) {
+
+
+ var isXAxis = userOptions.isX,
+ axis = this;
+
+ axis.chart = chart;
+
+ // Flag, is the axis horizontal
+ axis.horiz = chart.inverted ? !isXAxis : isXAxis;
+
+ // Flag, isXAxis
+ axis.isXAxis = isXAxis;
+ axis.coll = isXAxis ? 'xAxis' : 'yAxis';
+
+ axis.opposite = userOptions.opposite; // needed in setOptions
+ axis.side = userOptions.side || (axis.horiz ?
+ (axis.opposite ? 0 : 2) : // top : bottom
+ (axis.opposite ? 1 : 3)); // right : left
+
+ axis.setOptions(userOptions);
+
+
+ var options = this.options,
+ type = options.type,
+ isDatetimeAxis = type === 'datetime';
+
+ axis.labelFormatter = options.labels.formatter || axis.defaultLabelFormatter; // can be overwritten by dynamic format
+
+
+ // Flag, stagger lines or not
+ axis.userOptions = userOptions;
+
+ //axis.axisTitleMargin = UNDEFINED,// = options.title.margin,
+ axis.minPixelPadding = 0;
+
+ axis.reversed = options.reversed;
+ axis.visible = options.visible !== false;
+ axis.zoomEnabled = options.zoomEnabled !== false;
+
+ // Initial categories
+ axis.categories = options.categories || type === 'category';
+ axis.names = axis.names || []; // Preserve on update (#3830)
+
+ // Elements
+ //axis.axisGroup = UNDEFINED;
+ //axis.gridGroup = UNDEFINED;
+ //axis.axisTitle = UNDEFINED;
+ //axis.axisLine = UNDEFINED;
+
+ // Shorthand types
+ axis.isLog = type === 'logarithmic';
+ axis.isDatetimeAxis = isDatetimeAxis;
+
+ // Flag, if axis is linked to another axis
+ axis.isLinked = defined(options.linkedTo);
+ // Linked axis.
+ //axis.linkedParent = UNDEFINED;
+
+ // Tick positions
+ //axis.tickPositions = UNDEFINED; // array containing predefined positions
+ // Tick intervals
+ //axis.tickInterval = UNDEFINED;
+ //axis.minorTickInterval = UNDEFINED;
+
+
+ // Major ticks
+ axis.ticks = {};
+ axis.labelEdge = [];
+ // Minor ticks
+ axis.minorTicks = {};
+
+ // List of plotLines/Bands
+ axis.plotLinesAndBands = [];
+
+ // Alternate bands
+ axis.alternateBands = {};
+
+ // Axis metrics
+ //axis.left = UNDEFINED;
+ //axis.top = UNDEFINED;
+ //axis.width = UNDEFINED;
+ //axis.height = UNDEFINED;
+ //axis.bottom = UNDEFINED;
+ //axis.right = UNDEFINED;
+ //axis.transA = UNDEFINED;
+ //axis.transB = UNDEFINED;
+ //axis.oldTransA = UNDEFINED;
+ axis.len = 0;
+ //axis.oldMin = UNDEFINED;
+ //axis.oldMax = UNDEFINED;
+ //axis.oldUserMin = UNDEFINED;
+ //axis.oldUserMax = UNDEFINED;
+ //axis.oldAxisLength = UNDEFINED;
+ axis.minRange = axis.userMinRange = options.minRange || options.maxZoom;
+ axis.range = options.range;
+ axis.offset = options.offset || 0;
+
+
+ // Dictionary for stacks
+ axis.stacks = {};
+ axis.oldStacks = {};
+ axis.stacksTouched = 0;
+
+ // Min and max in the data
+ //axis.dataMin = UNDEFINED,
+ //axis.dataMax = UNDEFINED,
+
+ // The axis range
+ axis.max = null;
+ axis.min = null;
+
+ // User set min and max
+ //axis.userMin = UNDEFINED,
+ //axis.userMax = UNDEFINED,
+
+ // Crosshair options
+ axis.crosshair = pick(options.crosshair, splat(chart.options.tooltip.crosshairs)[isXAxis ? 0 : 1], false);
+ // Run Axis
+
+ var eventType,
+ events = axis.options.events;
+
+ // Register
+ if (inArray(axis, chart.axes) === -1) { // don't add it again on Axis.update()
+ if (isXAxis && !this.isColorAxis) { // #2713
+ chart.axes.splice(chart.xAxis.length, 0, axis);
+ } else {
+ chart.axes.push(axis);
+ }
+
+ chart[axis.coll].push(axis);
+ }
+
+ axis.series = axis.series || []; // populated by Series
+
+ // inverted charts have reversed xAxes as default
+ if (chart.inverted && isXAxis && axis.reversed === UNDEFINED) {
+ axis.reversed = true;
+ }
+
+ axis.removePlotBand = axis.removePlotBandOrLine;
+ axis.removePlotLine = axis.removePlotBandOrLine;
+
+
+ // register event listeners
+ for (eventType in events) {
+ addEvent(axis, eventType, events[eventType]);
+ }
+
+ // extend logarithmic axis
+ if (axis.isLog) {
+ axis.val2lin = log2lin;
+ axis.lin2val = lin2log;
+ }
+ },
+
+ /**
+ * Merge and set options
+ */
+ setOptions: function (userOptions) {
+ this.options = merge(
+ this.defaultOptions,
+ this.isXAxis ? {} : this.defaultYAxisOptions,
+ [this.defaultTopAxisOptions, this.defaultRightAxisOptions,
+ this.defaultBottomAxisOptions, this.defaultLeftAxisOptions][this.side],
+ merge(
+ defaultOptions[this.coll], // if set in setOptions (#1053)
+ userOptions
+ )
+ );
+ },
+
+ /**
+ * The default label formatter. The context is a special config object for the label.
+ */
+ defaultLabelFormatter: function () {
+ var axis = this.axis,
+ value = this.value,
+ categories = axis.categories,
+ dateTimeLabelFormat = this.dateTimeLabelFormat,
+ numericSymbols = defaultOptions.lang.numericSymbols,
+ i = numericSymbols && numericSymbols.length,
+ multi,
+ ret,
+ formatOption = axis.options.labels.format,
+
+ // make sure the same symbol is added for all labels on a linear axis
+ numericSymbolDetector = axis.isLog ? value : axis.tickInterval;
+
+ if (formatOption) {
+ ret = format(formatOption, this);
+
+ } else if (categories) {
+ ret = value;
+
+ } else if (dateTimeLabelFormat) { // datetime axis
+ ret = dateFormat(dateTimeLabelFormat, value);
+
+ } else if (i && numericSymbolDetector >= 1000) {
+ // Decide whether we should add a numeric symbol like k (thousands) or M (millions).
+ // If we are to enable this in tooltip or other places as well, we can move this
+ // logic to the numberFormatter and enable it by a parameter.
+ while (i-- && ret === UNDEFINED) {
+ multi = Math.pow(1000, i + 1);
+ if (numericSymbolDetector >= multi && (value * 10) % multi === 0 && numericSymbols[i] !== null) {
+ ret = Highcharts.numberFormat(value / multi, -1) + numericSymbols[i];
+ }
+ }
+ }
+
+ if (ret === UNDEFINED) {
+ if (mathAbs(value) >= 10000) { // add thousands separators
+ ret = Highcharts.numberFormat(value, -1);
+
+ } else { // small numbers
+ ret = Highcharts.numberFormat(value, -1, UNDEFINED, ''); // #2466
+ }
+ }
+
+ return ret;
+ },
+
+ /**
+ * Get the minimum and maximum for the series of each axis
+ */
+ getSeriesExtremes: function () {
+ var axis = this,
+ chart = axis.chart;
+
+ axis.hasVisibleSeries = false;
+
+ // Reset properties in case we're redrawing (#3353)
+ axis.dataMin = axis.dataMax = axis.threshold = null;
+ axis.softThreshold = !axis.isXAxis;
+
+ if (axis.buildStacks) {
+ axis.buildStacks();
+ }
+
+ // loop through this axis' series
+ each(axis.series, function (series) {
+
+ if (series.visible || !chart.options.chart.ignoreHiddenSeries) {
+
+ var seriesOptions = series.options,
+ xData,
+ threshold = seriesOptions.threshold,
+ seriesDataMin,
+ seriesDataMax;
+
+ axis.hasVisibleSeries = true;
+
+ // Validate threshold in logarithmic axes
+ if (axis.isLog && threshold <= 0) {
+ threshold = null;
+ }
+
+ // Get dataMin and dataMax for X axes
+ if (axis.isXAxis) {
+ xData = series.xData;
+ if (xData.length) {
+ axis.dataMin = mathMin(pick(axis.dataMin, xData[0]), arrayMin(xData));
+ axis.dataMax = mathMax(pick(axis.dataMax, xData[0]), arrayMax(xData));
+ }
+
+ // Get dataMin and dataMax for Y axes, as well as handle stacking and processed data
+ } else {
+
+ // Get this particular series extremes
+ series.getExtremes();
+ seriesDataMax = series.dataMax;
+ seriesDataMin = series.dataMin;
+
+ // Get the dataMin and dataMax so far. If percentage is used, the min and max are
+ // always 0 and 100. If seriesDataMin and seriesDataMax is null, then series
+ // doesn't have active y data, we continue with nulls
+ if (defined(seriesDataMin) && defined(seriesDataMax)) {
+ axis.dataMin = mathMin(pick(axis.dataMin, seriesDataMin), seriesDataMin);
+ axis.dataMax = mathMax(pick(axis.dataMax, seriesDataMax), seriesDataMax);
+ }
+
+ // Adjust to threshold
+ if (defined(threshold)) {
+ axis.threshold = threshold;
+ }
+ // If any series has a hard threshold, it takes precedence
+ if (!seriesOptions.softThreshold || axis.isLog) {
+ axis.softThreshold = false;
+ }
+ }
+ }
+ });
+ },
+
+ /**
+ * Translate from axis value to pixel position on the chart, or back
+ *
+ */
+ translate: function (val, backwards, cvsCoord, old, handleLog, pointPlacement) {
+ var axis = this.linkedParent || this, // #1417
+ sign = 1,
+ cvsOffset = 0,
+ localA = old ? axis.oldTransA : axis.transA,
+ localMin = old ? axis.oldMin : axis.min,
+ returnValue,
+ minPixelPadding = axis.minPixelPadding,
+ doPostTranslate = (axis.doPostTranslate || (axis.isLog && handleLog)) && axis.lin2val;
+
+ if (!localA) {
+ localA = axis.transA;
+ }
+
+ // In vertical axes, the canvas coordinates start from 0 at the top like in
+ // SVG.
+ if (cvsCoord) {
+ sign *= -1; // canvas coordinates inverts the value
+ cvsOffset = axis.len;
+ }
+
+ // Handle reversed axis
+ if (axis.reversed) {
+ sign *= -1;
+ cvsOffset -= sign * (axis.sector || axis.len);
+ }
+
+ // From pixels to value
+ if (backwards) { // reverse translation
+
+ val = val * sign + cvsOffset;
+ val -= minPixelPadding;
+ returnValue = val / localA + localMin; // from chart pixel to value
+ if (doPostTranslate) { // log and ordinal axes
+ returnValue = axis.lin2val(returnValue);
+ }
+
+ // From value to pixels
+ } else {
+ if (doPostTranslate) { // log and ordinal axes
+ val = axis.val2lin(val);
+ }
+ if (pointPlacement === 'between') {
+ pointPlacement = 0.5;
+ }
+ returnValue = sign * (val - localMin) * localA + cvsOffset + (sign * minPixelPadding) +
+ (isNumber(pointPlacement) ? localA * pointPlacement * axis.pointRange : 0);
+ }
+
+ return returnValue;
+ },
+
+ /**
+ * Utility method to translate an axis value to pixel position.
+ * @param {Number} value A value in terms of axis units
+ * @param {Boolean} paneCoordinates Whether to return the pixel coordinate relative to the chart
+ * or just the axis/pane itself.
+ */
+ toPixels: function (value, paneCoordinates) {
+ return this.translate(value, false, !this.horiz, null, true) + (paneCoordinates ? 0 : this.pos);
+ },
+
+ /*
+ * Utility method to translate a pixel position in to an axis value
+ * @param {Number} pixel The pixel value coordinate
+ * @param {Boolean} paneCoordiantes Whether the input pixel is relative to the chart or just the
+ * axis/pane itself.
+ */
+ toValue: function (pixel, paneCoordinates) {
+ return this.translate(pixel - (paneCoordinates ? 0 : this.pos), true, !this.horiz, null, true);
+ },
+
+ /**
+ * Create the path for a plot line that goes from the given value on
+ * this axis, across the plot to the opposite side
+ * @param {Number} value
+ * @param {Number} lineWidth Used for calculation crisp line
+ * @param {Number] old Use old coordinates (for resizing and rescaling)
+ */
+ getPlotLinePath: function (value, lineWidth, old, force, translatedValue) {
+ var axis = this,
+ chart = axis.chart,
+ axisLeft = axis.left,
+ axisTop = axis.top,
+ x1,
+ y1,
+ x2,
+ y2,
+ cHeight = (old && chart.oldChartHeight) || chart.chartHeight,
+ cWidth = (old && chart.oldChartWidth) || chart.chartWidth,
+ skip,
+ transB = axis.transB,
+ /**
+ * Check if x is between a and b. If not, either move to a/b or skip,
+ * depending on the force parameter.
+ */
+ between = function (x, a, b) {
+ if (x < a || x > b) {
+ if (force) {
+ x = mathMin(mathMax(a, x), b);
+ } else {
+ skip = true;
+ }
+ }
+ return x;
+ };
+
+ translatedValue = pick(translatedValue, axis.translate(value, null, null, old));
+ x1 = x2 = mathRound(translatedValue + transB);
+ y1 = y2 = mathRound(cHeight - translatedValue - transB);
+
+ if (isNaN(translatedValue)) { // no min or max
+ skip = true;
+
+ } else if (axis.horiz) {
+ y1 = axisTop;
+ y2 = cHeight - axis.bottom;
+ x1 = x2 = between(x1, axisLeft, axisLeft + axis.width);
+ } else {
+ x1 = axisLeft;
+ x2 = cWidth - axis.right;
+ y1 = y2 = between(y1, axisTop, axisTop + axis.height);
+ }
+ return skip && !force ?
+ null :
+ chart.renderer.crispLine([M, x1, y1, L, x2, y2], lineWidth || 1);
+ },
+
+ /**
+ * Set the tick positions of a linear axis to round values like whole tens or every five.
+ */
+ getLinearTickPositions: function (tickInterval, min, max) {
+ var pos,
+ lastPos,
+ roundedMin = correctFloat(mathFloor(min / tickInterval) * tickInterval),
+ roundedMax = correctFloat(mathCeil(max / tickInterval) * tickInterval),
+ tickPositions = [];
+
+ // For single points, add a tick regardless of the relative position (#2662)
+ if (min === max && isNumber(min)) {
+ return [min];
+ }
+
+ // Populate the intermediate values
+ pos = roundedMin;
+ while (pos <= roundedMax) {
+
+ // Place the tick on the rounded value
+ tickPositions.push(pos);
+
+ // Always add the raw tickInterval, not the corrected one.
+ pos = correctFloat(pos + tickInterval);
+
+ // If the interval is not big enough in the current min - max range to actually increase
+ // the loop variable, we need to break out to prevent endless loop. Issue #619
+ if (pos === lastPos) {
+ break;
+ }
+
+ // Record the last value
+ lastPos = pos;
+ }
+ return tickPositions;
+ },
+
+ /**
+ * Return the minor tick positions. For logarithmic axes, reuse the same logic
+ * as for major ticks.
+ */
+ getMinorTickPositions: function () {
+ var axis = this,
+ options = axis.options,
+ tickPositions = axis.tickPositions,
+ minorTickInterval = axis.minorTickInterval,
+ minorTickPositions = [],
+ pos,
+ i,
+ pointRangePadding = axis.pointRangePadding || 0,
+ min = axis.min - pointRangePadding, // #1498
+ max = axis.max + pointRangePadding, // #1498
+ range = max - min,
+ len;
+
+ // If minor ticks get too dense, they are hard to read, and may cause long running script. So we don't draw them.
+ if (range && range / minorTickInterval < axis.len / 3) { // #3875
+
+ if (axis.isLog) {
+ len = tickPositions.length;
+ for (i = 1; i < len; i++) {
+ minorTickPositions = minorTickPositions.concat(
+ axis.getLogTickPositions(minorTickInterval, tickPositions[i - 1], tickPositions[i], true)
+ );
+ }
+ } else if (axis.isDatetimeAxis && options.minorTickInterval === 'auto') { // #1314
+ minorTickPositions = minorTickPositions.concat(
+ axis.getTimeTicks(
+ axis.normalizeTimeTickInterval(minorTickInterval),
+ min,
+ max,
+ options.startOfWeek
+ )
+ );
+ } else {
+ for (pos = min + (tickPositions[0] - min) % minorTickInterval; pos <= max; pos += minorTickInterval) {
+ minorTickPositions.push(pos);
+ }
+ }
+ }
+
+ if(minorTickPositions.length !== 0) { // don't change the extremes, when there is no minor ticks
+ axis.trimTicks(minorTickPositions, options.startOnTick, options.endOnTick); // #3652 #3743 #1498
+ }
+ return minorTickPositions;
+ },
+
+ /**
+ * Adjust the min and max for the minimum range. Keep in mind that the series data is
+ * not yet processed, so we don't have information on data cropping and grouping, or
+ * updated axis.pointRange or series.pointRange. The data can't be processed until
+ * we have finally established min and max.
+ */
+ adjustForMinRange: function () {
+ var axis = this,
+ options = axis.options,
+ min = axis.min,
+ max = axis.max,
+ zoomOffset,
+ spaceAvailable = axis.dataMax - axis.dataMin >= axis.minRange,
+ closestDataRange,
+ i,
+ distance,
+ xData,
+ loopLength,
+ minArgs,
+ maxArgs,
+ minRange;
+
+ // Set the automatic minimum range based on the closest point distance
+ if (axis.isXAxis && axis.minRange === UNDEFINED && !axis.isLog) {
+
+ if (defined(options.min) || defined(options.max)) {
+ axis.minRange = null; // don't do this again
+
+ } else {
+
+ // Find the closest distance between raw data points, as opposed to
+ // closestPointRange that applies to processed points (cropped and grouped)
+ each(axis.series, function (series) {
+ xData = series.xData;
+ loopLength = series.xIncrement ? 1 : xData.length - 1;
+ for (i = loopLength; i > 0; i--) {
+ distance = xData[i] - xData[i - 1];
+ if (closestDataRange === UNDEFINED || distance < closestDataRange) {
+ closestDataRange = distance;
+ }
+ }
+ });
+ axis.minRange = mathMin(closestDataRange * 5, axis.dataMax - axis.dataMin);
+ }
+ }
+
+ // if minRange is exceeded, adjust
+ if (max - min < axis.minRange) {
+ minRange = axis.minRange;
+ zoomOffset = (minRange - max + min) / 2;
+
+ // if min and max options have been set, don't go beyond it
+ minArgs = [min - zoomOffset, pick(options.min, min - zoomOffset)];
+ if (spaceAvailable) { // if space is available, stay within the data range
+ minArgs[2] = axis.dataMin;
+ }
+ min = arrayMax(minArgs);
+
+ maxArgs = [min + minRange, pick(options.max, min + minRange)];
+ if (spaceAvailable) { // if space is availabe, stay within the data range
+ maxArgs[2] = axis.dataMax;
+ }
+
+ max = arrayMin(maxArgs);
+
+ // now if the max is adjusted, adjust the min back
+ if (max - min < minRange) {
+ minArgs[0] = max - minRange;
+ minArgs[1] = pick(options.min, max - minRange);
+ min = arrayMax(minArgs);
+ }
+ }
+
+ // Record modified extremes
+ axis.min = min;
+ axis.max = max;
+ },
+
+ /**
+ * Update translation information
+ */
+ setAxisTranslation: function (saveOld) {
+ var axis = this,
+ range = axis.max - axis.min,
+ pointRange = axis.axisPointRange || 0,
+ closestPointRange,
+ minPointOffset = 0,
+ pointRangePadding = 0,
+ linkedParent = axis.linkedParent,
+ ordinalCorrection,
+ hasCategories = !!axis.categories,
+ transA = axis.transA,
+ isXAxis = axis.isXAxis;
+
+ // Adjust translation for padding. Y axis with categories need to go through the same (#1784).
+ if (isXAxis || hasCategories || pointRange) {
+ if (linkedParent) {
+ minPointOffset = linkedParent.minPointOffset;
+ pointRangePadding = linkedParent.pointRangePadding;
+
+ } else {
+ each(axis.series, function (series) {
+ var seriesPointRange = hasCategories ? 1 : (isXAxis ? series.pointRange : (axis.axisPointRange || 0)), // #2806
+ pointPlacement = series.options.pointPlacement,
+ seriesClosestPointRange = series.closestPointRange;
+
+ pointRange = mathMax(pointRange, seriesPointRange);
+
+ if (!axis.single) {
+ // minPointOffset is the value padding to the left of the axis in order to make
+ // room for points with a pointRange, typically columns. When the pointPlacement option
+ // is 'between' or 'on', this padding does not apply.
+ minPointOffset = mathMax(
+ minPointOffset,
+ isString(pointPlacement) ? 0 : seriesPointRange / 2
+ );
+
+ // Determine the total padding needed to the length of the axis to make room for the
+ // pointRange. If the series' pointPlacement is 'on', no padding is added.
+ pointRangePadding = mathMax(
+ pointRangePadding,
+ pointPlacement === 'on' ? 0 : seriesPointRange
+ );
+ }
+
+ // Set the closestPointRange
+ if (!series.noSharedTooltip && defined(seriesClosestPointRange)) {
+ closestPointRange = defined(closestPointRange) ?
+ mathMin(closestPointRange, seriesClosestPointRange) :
+ seriesClosestPointRange;
+ }
+ });
+ }
+
+ // Record minPointOffset and pointRangePadding
+ ordinalCorrection = axis.ordinalSlope && closestPointRange ? axis.ordinalSlope / closestPointRange : 1; // #988, #1853
+ axis.minPointOffset = minPointOffset = minPointOffset * ordinalCorrection;
+ axis.pointRangePadding = pointRangePadding = pointRangePadding * ordinalCorrection;
+
+ // pointRange means the width reserved for each point, like in a column chart
+ axis.pointRange = mathMin(pointRange, range);
+
+ // closestPointRange means the closest distance between points. In columns
+ // it is mostly equal to pointRange, but in lines pointRange is 0 while closestPointRange
+ // is some other value
+ if (isXAxis) {
+ axis.closestPointRange = closestPointRange;
+ }
+ }
+
+ // Secondary values
+ if (saveOld) {
+ axis.oldTransA = transA;
+ }
+ axis.translationSlope = axis.transA = transA = axis.len / ((range + pointRangePadding) || 1);
+ axis.transB = axis.horiz ? axis.left : axis.bottom; // translation addend
+ axis.minPixelPadding = transA * minPointOffset;
+ },
+
+ minFromRange: function () {
+ return this.max - this.range;
+ },
+
+ /**
+ * Set the tick positions to round values and optionally extend the extremes
+ * to the nearest tick
+ */
+ setTickInterval: function (secondPass) {
+ var axis = this,
+ chart = axis.chart,
+ options = axis.options,
+ isLog = axis.isLog,
+ isDatetimeAxis = axis.isDatetimeAxis,
+ isXAxis = axis.isXAxis,
+ isLinked = axis.isLinked,
+ maxPadding = options.maxPadding,
+ minPadding = options.minPadding,
+ length,
+ linkedParentExtremes,
+ tickIntervalOption = options.tickInterval,
+ minTickInterval,
+ tickPixelIntervalOption = options.tickPixelInterval,
+ categories = axis.categories,
+ threshold = axis.threshold,
+ softThreshold = axis.softThreshold,
+ thresholdMin,
+ thresholdMax,
+ hardMin,
+ hardMax;
+
+ if (!isDatetimeAxis && !categories && !isLinked) {
+ this.getTickAmount();
+ }
+
+ // Min or max set either by zooming/setExtremes or initial options
+ hardMin = pick(axis.userMin, options.min);
+ hardMax = pick(axis.userMax, options.max);
+
+ // Linked axis gets the extremes from the parent axis
+ if (isLinked) {
+ axis.linkedParent = chart[axis.coll][options.linkedTo];
+ linkedParentExtremes = axis.linkedParent.getExtremes();
+ axis.min = pick(linkedParentExtremes.min, linkedParentExtremes.dataMin);
+ axis.max = pick(linkedParentExtremes.max, linkedParentExtremes.dataMax);
+ if (options.type !== axis.linkedParent.options.type) {
+ error(11, 1); // Can't link axes of different type
+ }
+
+ // Initial min and max from the extreme data values
+ } else {
+
+ // Adjust to hard threshold
+ if (!softThreshold && defined(threshold)) {
+ if (axis.dataMin >= threshold) {
+ thresholdMin = threshold;
+ minPadding = 0;
+ } else if (axis.dataMax <= threshold) {
+ thresholdMax = threshold;
+ maxPadding = 0;
+ }
+ }
+
+ axis.min = pick(hardMin, thresholdMin, axis.dataMin);
+ axis.max = pick(hardMax, thresholdMax, axis.dataMax);
+
+ }
+
+ if (isLog) {
+ if (!secondPass && mathMin(axis.min, pick(axis.dataMin, axis.min)) <= 0) { // #978
+ error(10, 1); // Can't plot negative values on log axis
+ }
+ // The correctFloat cures #934, float errors on full tens. But it
+ // was too aggressive for #4360 because of conversion back to lin,
+ // therefore use precision 15.
+ axis.min = correctFloat(log2lin(axis.min), 15);
+ axis.max = correctFloat(log2lin(axis.max), 15);
+ }
+
+ // handle zoomed range
+ if (axis.range && defined(axis.max)) {
+ axis.userMin = axis.min = hardMin = mathMax(axis.min, axis.minFromRange()); // #618
+ axis.userMax = hardMax = axis.max;
+
+ axis.range = null; // don't use it when running setExtremes
+ }
+
+ // Hook for adjusting this.min and this.max. Used by bubble series.
+ if (axis.beforePadding) {
+ axis.beforePadding();
+ }
+
+ // adjust min and max for the minimum range
+ axis.adjustForMinRange();
+
+ // Pad the values to get clear of the chart's edges. To avoid tickInterval taking the padding
+ // into account, we do this after computing tick interval (#1337).
+ if (!categories && !axis.axisPointRange && !axis.usePercentage && !isLinked && defined(axis.min) && defined(axis.max)) {
+ length = axis.max - axis.min;
+ if (length) {
+ if (!defined(hardMin) && minPadding) {
+ axis.min -= length * minPadding;
+ }
+ if (!defined(hardMax) && maxPadding) {
+ axis.max += length * maxPadding;
+ }
+ }
+ }
+
+ // Stay within floor and ceiling
+ if (isNumber(options.floor)) {
+ axis.min = mathMax(axis.min, options.floor);
+ }
+ if (isNumber(options.ceiling)) {
+ axis.max = mathMin(axis.max, options.ceiling);
+ }
+
+ // When the threshold is soft, adjust the extreme value only if
+ // the data extreme and the padded extreme land on either side of the threshold. For example,
+ // a series of [0, 1, 2, 3] would make the yAxis add a tick for -1 because of the
+ // default minPadding and startOnTick options. This is prevented by the softThreshold
+ // option.
+ if (softThreshold && defined(axis.dataMin)) {
+ threshold = threshold || 0;
+ if (!defined(hardMin) && axis.min < threshold && axis.dataMin >= threshold) {
+ axis.min = threshold;
+ } else if (!defined(hardMax) && axis.max > threshold && axis.dataMax <= threshold) {
+ axis.max = threshold;
+ }
+ }
+
+
+ // get tickInterval
+ if (axis.min === axis.max || axis.min === undefined || axis.max === undefined) {
+ axis.tickInterval = 1;
+ } else if (isLinked && !tickIntervalOption &&
+ tickPixelIntervalOption === axis.linkedParent.options.tickPixelInterval) {
+ axis.tickInterval = tickIntervalOption = axis.linkedParent.tickInterval;
+ } else {
+ axis.tickInterval = pick(
+ tickIntervalOption,
+ this.tickAmount ? ((axis.max - axis.min) / mathMax(this.tickAmount - 1, 1)) : undefined,
+ categories ? // for categoried axis, 1 is default, for linear axis use tickPix
+ 1 :
+ // don't let it be more than the data range
+ (axis.max - axis.min) * tickPixelIntervalOption / mathMax(axis.len, tickPixelIntervalOption)
+ );
+ }
+
+ // Now we're finished detecting min and max, crop and group series data. This
+ // is in turn needed in order to find tick positions in ordinal axes.
+ if (isXAxis && !secondPass) {
+ each(axis.series, function (series) {
+ series.processData(axis.min !== axis.oldMin || axis.max !== axis.oldMax);
+ });
+ }
+
+ // set the translation factor used in translate function
+ axis.setAxisTranslation(true);
+
+ // hook for ordinal axes and radial axes
+ if (axis.beforeSetTickPositions) {
+ axis.beforeSetTickPositions();
+ }
+
+ // hook for extensions, used in Highstock ordinal axes
+ if (axis.postProcessTickInterval) {
+ axis.tickInterval = axis.postProcessTickInterval(axis.tickInterval);
+ }
+
+ // In column-like charts, don't cramp in more ticks than there are points (#1943)
+ if (axis.pointRange) {
+ axis.tickInterval = mathMax(axis.pointRange, axis.tickInterval);
+ }
+
+ // Before normalizing the tick interval, handle minimum tick interval. This applies only if tickInterval is not defined.
+ minTickInterval = pick(options.minTickInterval, axis.isDatetimeAxis && axis.closestPointRange);
+ if (!tickIntervalOption && axis.tickInterval < minTickInterval) {
+ axis.tickInterval = minTickInterval;
+ }
+
+ // for linear axes, get magnitude and normalize the interval
+ if (!isDatetimeAxis && !isLog && !tickIntervalOption) {
+ axis.tickInterval = normalizeTickInterval(
+ axis.tickInterval,
+ null,
+ getMagnitude(axis.tickInterval),
+ // If the tick interval is between 0.5 and 5 and the axis max is in the order of
+ // thousands, chances are we are dealing with years. Don't allow decimals. #3363.
+ pick(options.allowDecimals, !(axis.tickInterval > 0.5 && axis.tickInterval < 5 && axis.max > 1000 && axis.max < 9999)),
+ !!this.tickAmount
+ );
+ }
+
+ // Prevent ticks from getting so close that we can't draw the labels
+ if (!this.tickAmount && this.len) { // Color axis with disabled legend has no length
+ axis.tickInterval = axis.unsquish();
+ }
+
+ this.setTickPositions();
+ },
+
+ /**
+ * Now we have computed the normalized tickInterval, get the tick positions
+ */
+ setTickPositions: function () {
+
+ var options = this.options,
+ tickPositions,
+ tickPositionsOption = options.tickPositions,
+ tickPositioner = options.tickPositioner,
+ startOnTick = options.startOnTick,
+ endOnTick = options.endOnTick,
+ single;
+
+ // Set the tickmarkOffset
+ this.tickmarkOffset = (this.categories && options.tickmarkPlacement === 'between' &&
+ this.tickInterval === 1) ? 0.5 : 0; // #3202
+
+
+ // get minorTickInterval
+ this.minorTickInterval = options.minorTickInterval === 'auto' && this.tickInterval ?
+ this.tickInterval / 5 : options.minorTickInterval;
+
+ // Find the tick positions
+ this.tickPositions = tickPositions = tickPositionsOption && tickPositionsOption.slice(); // Work on a copy (#1565)
+ if (!tickPositions) {
+
+ if (this.isDatetimeAxis) {
+ tickPositions = this.getTimeTicks(
+ this.normalizeTimeTickInterval(this.tickInterval, options.units),
+ this.min,
+ this.max,
+ options.startOfWeek,
+ this.ordinalPositions,
+ this.closestPointRange,
+ true
+ );
+ } else if (this.isLog) {
+ tickPositions = this.getLogTickPositions(this.tickInterval, this.min, this.max);
+ } else {
+ tickPositions = this.getLinearTickPositions(this.tickInterval, this.min, this.max);
+ }
+
+ // Too dense ticks, keep only the first and last (#4477)
+ if (tickPositions.length > this.len) {
+ tickPositions = [tickPositions[0], tickPositions.pop()];
+ }
+
+ this.tickPositions = tickPositions;
+
+ // Run the tick positioner callback, that allows modifying auto tick positions.
+ if (tickPositioner) {
+ tickPositioner = tickPositioner.apply(this, [this.min, this.max]);
+ if (tickPositioner) {
+ this.tickPositions = tickPositions = tickPositioner;
+ }
+ }
+
+ }
+
+ if (!this.isLinked) {
+
+ // reset min/max or remove extremes based on start/end on tick
+ this.trimTicks(tickPositions, startOnTick, endOnTick);
+
+ // When there is only one point, or all points have the same value on this axis, then min
+ // and max are equal and tickPositions.length is 0 or 1. In this case, add some padding
+ // in order to center the point, but leave it with one tick. #1337.
+ if (this.min === this.max && defined(this.min) && !this.tickAmount) {
+ // Substract half a unit (#2619, #2846, #2515, #3390)
+ single = true;
+ this.min -= 0.5;
+ this.max += 0.5;
+ }
+ this.single = single;
+
+ if (!tickPositionsOption && !tickPositioner) {
+ this.adjustTickAmount();
+ }
+ }
+ },
+
+ /**
+ * Handle startOnTick and endOnTick by either adapting to padding min/max or rounded min/max
+ */
+ trimTicks: function (tickPositions, startOnTick, endOnTick) {
+ var roundedMin = tickPositions[0],
+ roundedMax = tickPositions[tickPositions.length - 1],
+ minPointOffset = this.minPointOffset || 0;
+
+ if (startOnTick) {
+ this.min = roundedMin;
+ } else if (this.min - minPointOffset > roundedMin) {
+ tickPositions.shift();
+ }
+
+ if (endOnTick) {
+ this.max = roundedMax;
+ } else if (this.max + minPointOffset < roundedMax) {
+ tickPositions.pop();
+ }
+
+ // If no tick are left, set one tick in the middle (#3195)
+ if (tickPositions.length === 0 && defined(roundedMin)) {
+ tickPositions.push((roundedMax + roundedMin) / 2);
+ }
+ },
+
+ /**
+ * Set the max ticks of either the x and y axis collection
+ */
+ getTickAmount: function () {
+ var others = {}, // Whether there is another axis to pair with this one
+ hasOther,
+ options = this.options,
+ tickAmount = options.tickAmount,
+ tickPixelInterval = options.tickPixelInterval;
+
+ if (!defined(options.tickInterval) && this.len < tickPixelInterval && !this.isRadial &&
+ !this.isLog && options.startOnTick && options.endOnTick) {
+ tickAmount = 2;
+ }
+
+ if (!tickAmount && this.chart.options.chart.alignTicks !== false && options.alignTicks !== false) {
+ // Check if there are multiple axes in the same pane
+ each(this.chart[this.coll], function (axis) {
+ var options = axis.options,
+ horiz = axis.horiz,
+ key = [horiz ? options.left : options.top, horiz ? options.width : options.height, options.pane].join(',');
+
+ if (axis.series.length) { // #4442
+ if (others[key]) {
+ hasOther = true; // #4201
+ } else {
+ others[key] = 1;
+ }
+ }
+ });
+
+ if (hasOther) {
+ // Add 1 because 4 tick intervals require 5 ticks (including first and last)
+ tickAmount = mathCeil(this.len / tickPixelInterval) + 1;
+ }
+ }
+
+ // For tick amounts of 2 and 3, compute five ticks and remove the intermediate ones. This
+ // prevents the axis from adding ticks that are too far away from the data extremes.
+ if (tickAmount < 4) {
+ this.finalTickAmt = tickAmount;
+ tickAmount = 5;
+ }
+
+ this.tickAmount = tickAmount;
+ },
+
+ /**
+ * When using multiple axes, adjust the number of ticks to match the highest
+ * number of ticks in that group
+ */
+ adjustTickAmount: function () {
+ var tickInterval = this.tickInterval,
+ tickPositions = this.tickPositions,
+ tickAmount = this.tickAmount,
+ finalTickAmt = this.finalTickAmt,
+ currentTickAmount = tickPositions && tickPositions.length,
+ i,
+ len;
+
+ if (currentTickAmount < tickAmount) { // TODO: Check #3411
+ while (tickPositions.length < tickAmount) {
+ tickPositions.push(correctFloat(
+ tickPositions[tickPositions.length - 1] + tickInterval
+ ));
+ }
+ this.transA *= (currentTickAmount - 1) / (tickAmount - 1);
+ this.max = tickPositions[tickPositions.length - 1];
+
+ // We have too many ticks, run second pass to try to reduce ticks
+ } else if (currentTickAmount > tickAmount) {
+ this.tickInterval *= 2;
+ this.setTickPositions();
+ }
+
+ // The finalTickAmt property is set in getTickAmount
+ if (defined(finalTickAmt)) {
+ i = len = tickPositions.length;
+ while (i--) {
+ if (
+ (finalTickAmt === 3 && i % 2 === 1) || // Remove every other tick
+ (finalTickAmt <= 2 && i > 0 && i < len - 1) // Remove all but first and last
+ ) {
+ tickPositions.splice(i, 1);
+ }
+ }
+ this.finalTickAmt = UNDEFINED;
+ }
+ },
+
+ /**
+ * Set the scale based on data min and max, user set min and max or options
+ *
+ */
+ setScale: function () {
+ var axis = this,
+ isDirtyData,
+ isDirtyAxisLength;
+
+ axis.oldMin = axis.min;
+ axis.oldMax = axis.max;
+ axis.oldAxisLength = axis.len;
+
+ // set the new axisLength
+ axis.setAxisSize();
+ //axisLength = horiz ? axisWidth : axisHeight;
+ isDirtyAxisLength = axis.len !== axis.oldAxisLength;
+
+ // is there new data?
+ each(axis.series, function (series) {
+ if (series.isDirtyData || series.isDirty ||
+ series.xAxis.isDirty) { // when x axis is dirty, we need new data extremes for y as well
+ isDirtyData = true;
+ }
+ });
+
+ // do we really need to go through all this?
+ if (isDirtyAxisLength || isDirtyData || axis.isLinked || axis.forceRedraw ||
+ axis.userMin !== axis.oldUserMin || axis.userMax !== axis.oldUserMax) {
+
+ if (axis.resetStacks) {
+ axis.resetStacks();
+ }
+
+ axis.forceRedraw = false;
+
+ // get data extremes if needed
+ axis.getSeriesExtremes();
+
+ // get fixed positions based on tickInterval
+ axis.setTickInterval();
+
+ // record old values to decide whether a rescale is necessary later on (#540)
+ axis.oldUserMin = axis.userMin;
+ axis.oldUserMax = axis.userMax;
+
+ // Mark as dirty if it is not already set to dirty and extremes have changed. #595.
+ if (!axis.isDirty) {
+ axis.isDirty = isDirtyAxisLength || axis.min !== axis.oldMin || axis.max !== axis.oldMax;
+ }
+ } else if (axis.cleanStacks) {
+ axis.cleanStacks();
+ }
+ },
+
+ /**
+ * Set the extremes and optionally redraw
+ * @param {Number} newMin
+ * @param {Number} newMax
+ * @param {Boolean} redraw
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ * @param {Object} eventArguments
+ *
+ */
+ setExtremes: function (newMin, newMax, redraw, animation, eventArguments) {
+ var axis = this,
+ chart = axis.chart;
+
+ redraw = pick(redraw, true); // defaults to true
+
+ each(axis.series, function (serie) {
+ delete serie.kdTree;
+ });
+
+ // Extend the arguments with min and max
+ eventArguments = extend(eventArguments, {
+ min: newMin,
+ max: newMax
+ });
+
+ // Fire the event
+ fireEvent(axis, 'setExtremes', eventArguments, function () { // the default event handler
+
+ axis.userMin = newMin;
+ axis.userMax = newMax;
+ axis.eventArgs = eventArguments;
+
+ if (redraw) {
+ chart.redraw(animation);
+ }
+ });
+ },
+
+ /**
+ * Overridable method for zooming chart. Pulled out in a separate method to allow overriding
+ * in stock charts.
+ */
+ zoom: function (newMin, newMax) {
+ var dataMin = this.dataMin,
+ dataMax = this.dataMax,
+ options = this.options,
+ min = mathMin(dataMin, pick(options.min, dataMin)),
+ max = mathMax(dataMax, pick(options.max, dataMax));
+
+ // Prevent pinch zooming out of range. Check for defined is for #1946. #1734.
+ if (!this.allowZoomOutside) {
+ if (defined(dataMin) && newMin <= min) {
+ newMin = min;
+ }
+ if (defined(dataMax) && newMax >= max) {
+ newMax = max;
+ }
+ }
+
+ // In full view, displaying the reset zoom button is not required
+ this.displayBtn = newMin !== UNDEFINED || newMax !== UNDEFINED;
+
+ // Do it
+ this.setExtremes(
+ newMin,
+ newMax,
+ false,
+ UNDEFINED,
+ { trigger: 'zoom' }
+ );
+ return true;
+ },
+
+ /**
+ * Update the axis metrics
+ */
+ setAxisSize: function () {
+ var chart = this.chart,
+ options = this.options,
+ offsetLeft = options.offsetLeft || 0,
+ offsetRight = options.offsetRight || 0,
+ horiz = this.horiz,
+ width = pick(options.width, chart.plotWidth - offsetLeft + offsetRight),
+ height = pick(options.height, chart.plotHeight),
+ top = pick(options.top, chart.plotTop),
+ left = pick(options.left, chart.plotLeft + offsetLeft),
+ percentRegex = /%$/;
+
+ // Check for percentage based input values
+ if (percentRegex.test(height)) {
+ height = parseFloat(height) / 100 * chart.plotHeight;
+ }
+ if (percentRegex.test(top)) {
+ top = parseFloat(top) / 100 * chart.plotHeight + chart.plotTop;
+ }
+
+ // Expose basic values to use in Series object and navigator
+ this.left = left;
+ this.top = top;
+ this.width = width;
+ this.height = height;
+ this.bottom = chart.chartHeight - height - top;
+ this.right = chart.chartWidth - width - left;
+
+ // Direction agnostic properties
+ this.len = mathMax(horiz ? width : height, 0); // mathMax fixes #905
+ this.pos = horiz ? left : top; // distance from SVG origin
+ },
+
+ /**
+ * Get the actual axis extremes
+ */
+ getExtremes: function () {
+ var axis = this,
+ isLog = axis.isLog;
+
+ return {
+ min: isLog ? correctFloat(lin2log(axis.min)) : axis.min,
+ max: isLog ? correctFloat(lin2log(axis.max)) : axis.max,
+ dataMin: axis.dataMin,
+ dataMax: axis.dataMax,
+ userMin: axis.userMin,
+ userMax: axis.userMax
+ };
+ },
+
+ /**
+ * Get the zero plane either based on zero or on the min or max value.
+ * Used in bar and area plots
+ */
+ getThreshold: function (threshold) {
+ var axis = this,
+ isLog = axis.isLog,
+ realMin = isLog ? lin2log(axis.min) : axis.min,
+ realMax = isLog ? lin2log(axis.max) : axis.max;
+
+ // With a threshold of null, make the columns/areas rise from the top or bottom
+ // depending on the value, assuming an actual threshold of 0 (#4233).
+ if (threshold === null) {
+ threshold = realMax < 0 ? realMax : realMin;
+ } else if (realMin > threshold) {
+ threshold = realMin;
+ } else if (realMax < threshold) {
+ threshold = realMax;
+ }
+
+ return axis.translate(threshold, 0, 1, 0, 1);
+ },
+
+ /**
+ * Compute auto alignment for the axis label based on which side the axis is on
+ * and the given rotation for the label
+ */
+ autoLabelAlign: function (rotation) {
+ var ret,
+ angle = (pick(rotation, 0) - (this.side * 90) + 720) % 360;
+
+ if (angle > 15 && angle < 165) {
+ ret = 'right';
+ } else if (angle > 195 && angle < 345) {
+ ret = 'left';
+ } else {
+ ret = 'center';
+ }
+ return ret;
+ },
+
+ /**
+ * Prevent the ticks from getting so close we can't draw the labels. On a horizontal
+ * axis, this is handled by rotating the labels, removing ticks and adding ellipsis.
+ * On a vertical axis remove ticks and add ellipsis.
+ */
+ unsquish: function () {
+ var chart = this.chart,
+ ticks = this.ticks,
+ labelOptions = this.options.labels,
+ horiz = this.horiz,
+ tickInterval = this.tickInterval,
+ newTickInterval = tickInterval,
+ slotSize = this.len / (((this.categories ? 1 : 0) + this.max - this.min) / tickInterval),
+ rotation,
+ rotationOption = labelOptions.rotation,
+ labelMetrics = chart.renderer.fontMetrics(labelOptions.style.fontSize, ticks[0] && ticks[0].label),
+ step,
+ bestScore = Number.MAX_VALUE,
+ autoRotation,
+ // Return the multiple of tickInterval that is needed to avoid collision
+ getStep = function (spaceNeeded) {
+ var step = spaceNeeded / (slotSize || 1);
+ step = step > 1 ? mathCeil(step) : 1;
+ return step * tickInterval;
+ };
+
+ if (horiz) {
+ autoRotation = !labelOptions.staggerLines && !labelOptions.step && ( // #3971
+ defined(rotationOption) ?
+ [rotationOption] :
+ slotSize < pick(labelOptions.autoRotationLimit, 80) && labelOptions.autoRotation
+ );
+
+ if (autoRotation) {
+
+ // Loop over the given autoRotation options, and determine which gives the best score. The
+ // best score is that with the lowest number of steps and a rotation closest to horizontal.
+ each(autoRotation, function (rot) {
+ var score;
+
+ if (rot === rotationOption || (rot && rot >= -90 && rot <= 90)) { // #3891
+
+ step = getStep(mathAbs(labelMetrics.h / mathSin(deg2rad * rot)));
+
+ score = step + mathAbs(rot / 360);
+
+ if (score < bestScore) {
+ bestScore = score;
+ rotation = rot;
+ newTickInterval = step;
+ }
+ }
+ });
+ }
+
+ } else if (!labelOptions.step) { // #4411
+ newTickInterval = getStep(labelMetrics.h);
+ }
+
+ this.autoRotation = autoRotation;
+ this.labelRotation = pick(rotation, rotationOption);
+
+ return newTickInterval;
+ },
+
+ renderUnsquish: function () {
+ var chart = this.chart,
+ renderer = chart.renderer,
+ tickPositions = this.tickPositions,
+ ticks = this.ticks,
+ labelOptions = this.options.labels,
+ horiz = this.horiz,
+ margin = chart.margin,
+ slotCount = this.categories ? tickPositions.length : tickPositions.length - 1,
+ slotWidth = this.slotWidth = (horiz && !labelOptions.step && !labelOptions.rotation &&
+ ((this.staggerLines || 1) * chart.plotWidth) / slotCount) ||
+ (!horiz && ((margin[3] && (margin[3] - chart.spacing[3])) || chart.chartWidth * 0.33)), // #1580, #1931,
+ innerWidth = mathMax(1, mathRound(slotWidth - 2 * (labelOptions.padding || 5))),
+ attr = {},
+ labelMetrics = renderer.fontMetrics(labelOptions.style.fontSize, ticks[0] && ticks[0].label),
+ textOverflowOption = labelOptions.style.textOverflow,
+ css,
+ labelLength = 0,
+ label,
+ i,
+ pos;
+
+ // Set rotation option unless it is "auto", like in gauges
+ if (!isString(labelOptions.rotation)) {
+ attr.rotation = labelOptions.rotation || 0; // #4443
+ }
+
+ // Handle auto rotation on horizontal axis
+ if (this.autoRotation) {
+
+ // Get the longest label length
+ each(tickPositions, function (tick) {
+ tick = ticks[tick];
+ if (tick && tick.labelLength > labelLength) {
+ labelLength = tick.labelLength;
+ }
+ });
+
+ // Apply rotation only if the label is too wide for the slot, and
+ // the label is wider than its height.
+ if (labelLength > innerWidth && labelLength > labelMetrics.h) {
+ attr.rotation = this.labelRotation;
+ } else {
+ this.labelRotation = 0;
+ }
+
+ // Handle word-wrap or ellipsis on vertical axis
+ } else if (slotWidth) {
+ // For word-wrap or ellipsis
+ css = { width: innerWidth + PX };
+
+ if (!textOverflowOption) {
+ css.textOverflow = 'clip';
+
+ // On vertical axis, only allow word wrap if there is room for more lines.
+ i = tickPositions.length;
+ while (!horiz && i--) {
+ pos = tickPositions[i];
+ label = ticks[pos].label;
+ if (label) {
+ // Reset ellipsis in order to get the correct bounding box (#4070)
+ if (label.styles.textOverflow === 'ellipsis') {
+ label.css({ textOverflow: 'clip' });
+ }
+ if (label.getBBox().height > this.len / tickPositions.length - (labelMetrics.h - labelMetrics.f)) {
+ label.specCss = { textOverflow: 'ellipsis' };
+ }
+ }
+ }
+ }
+ }
+
+
+ // Add ellipsis if the label length is significantly longer than ideal
+ if (attr.rotation) {
+ css = {
+ width: (labelLength > chart.chartHeight * 0.5 ? chart.chartHeight * 0.33 : chart.chartHeight) + PX
+ };
+ if (!textOverflowOption) {
+ css.textOverflow = 'ellipsis';
+ }
+ }
+
+ // Set the explicit or automatic label alignment
+ this.labelAlign = attr.align = labelOptions.align || this.autoLabelAlign(this.labelRotation);
+
+ // Apply general and specific CSS
+ each(tickPositions, function (pos) {
+ var tick = ticks[pos],
+ label = tick && tick.label;
+ if (label) {
+ label.attr(attr); // This needs to go before the CSS in old IE (#4502)
+ if (css) {
+ label.css(merge(css, label.specCss));
+ }
+ delete label.specCss;
+ tick.rotation = attr.rotation;
+ }
+ });
+
+ // TODO: Why not part of getLabelPosition?
+ this.tickRotCorr = renderer.rotCorr(labelMetrics.b, this.labelRotation || 0, this.side === 2);
+ },
+
+ /**
+ * Return true if the axis has associated data
+ */
+ hasData: function () {
+ return this.hasVisibleSeries || (defined(this.min) && defined(this.max) && !!this.tickPositions);
+ },
+
+ /**
+ * Render the tick labels to a preliminary position to get their sizes
+ */
+ getOffset: function () {
+ var axis = this,
+ chart = axis.chart,
+ renderer = chart.renderer,
+ options = axis.options,
+ tickPositions = axis.tickPositions,
+ ticks = axis.ticks,
+ horiz = axis.horiz,
+ side = axis.side,
+ invertedSide = chart.inverted ? [1, 0, 3, 2][side] : side,
+ hasData,
+ showAxis,
+ titleOffset = 0,
+ titleOffsetOption,
+ titleMargin = 0,
+ axisTitleOptions = options.title,
+ labelOptions = options.labels,
+ labelOffset = 0, // reset
+ labelOffsetPadded,
+ axisOffset = chart.axisOffset,
+ clipOffset = chart.clipOffset,
+ clip,
+ directionFactor = [-1, 1, 1, -1][side],
+ n,
+ axisParent = axis.axisParent, // Used in color axis
+ lineHeightCorrection;
+
+ // For reuse in Axis.render
+ hasData = axis.hasData();
+ axis.showAxis = showAxis = hasData || pick(options.showEmpty, true);
+
+ // Set/reset staggerLines
+ axis.staggerLines = axis.horiz && labelOptions.staggerLines;
+
+ // Create the axisGroup and gridGroup elements on first iteration
+ if (!axis.axisGroup) {
+ axis.gridGroup = renderer.g('grid')
+ .attr({ zIndex: options.gridZIndex || 1 })
+ .add(axisParent);
+ axis.axisGroup = renderer.g('axis')
+ .attr({ zIndex: options.zIndex || 2 })
+ .add(axisParent);
+ axis.labelGroup = renderer.g('axis-labels')
+ .attr({ zIndex: labelOptions.zIndex || 7 })
+ .addClass(PREFIX + axis.coll.toLowerCase() + '-labels')
+ .add(axisParent);
+ }
+
+ if (hasData || axis.isLinked) {
+
+ // Generate ticks
+ each(tickPositions, function (pos) {
+ if (!ticks[pos]) {
+ ticks[pos] = new Tick(axis, pos);
+ } else {
+ ticks[pos].addLabel(); // update labels depending on tick interval
+ }
+ });
+
+ axis.renderUnsquish();
+
+ each(tickPositions, function (pos) {
+ // left side must be align: right and right side must have align: left for labels
+ if (side === 0 || side === 2 || { 1: 'left', 3: 'right' }[side] === axis.labelAlign) {
+
+ // get the highest offset
+ labelOffset = mathMax(
+ ticks[pos].getLabelSize(),
+ labelOffset
+ );
+ }
+ });
+
+ if (axis.staggerLines) {
+ labelOffset *= axis.staggerLines;
+ axis.labelOffset = labelOffset;
+ }
+
+
+ } else { // doesn't have data
+ for (n in ticks) {
+ ticks[n].destroy();
+ delete ticks[n];
+ }
+ }
+
+ if (axisTitleOptions && axisTitleOptions.text && axisTitleOptions.enabled !== false) {
+ if (!axis.axisTitle) {
+ axis.axisTitle = renderer.text(
+ axisTitleOptions.text,
+ 0,
+ 0,
+ axisTitleOptions.useHTML
+ )
+ .attr({
+ zIndex: 7,
+ rotation: axisTitleOptions.rotation || 0,
+ align:
+ axisTitleOptions.textAlign ||
+ { low: 'left', middle: 'center', high: 'right' }[axisTitleOptions.align]
+ })
+ .addClass(PREFIX + this.coll.toLowerCase() + '-title')
+ .css(axisTitleOptions.style)
+ .add(axis.axisGroup);
+ axis.axisTitle.isNew = true;
+ }
+
+ if (showAxis) {
+ titleOffset = axis.axisTitle.getBBox()[horiz ? 'height' : 'width'];
+ titleOffsetOption = axisTitleOptions.offset;
+ titleMargin = defined(titleOffsetOption) ? 0 : pick(axisTitleOptions.margin, horiz ? 5 : 10);
+ }
+
+ // hide or show the title depending on whether showEmpty is set
+ axis.axisTitle[showAxis ? 'show' : 'hide']();
+ }
+
+ // handle automatic or user set offset
+ axis.offset = directionFactor * pick(options.offset, axisOffset[side]);
+
+ axis.tickRotCorr = axis.tickRotCorr || { x: 0, y: 0 }; // polar
+ lineHeightCorrection = side === 2 ? axis.tickRotCorr.y : 0;
+ labelOffsetPadded = labelOffset + titleMargin +
+ (labelOffset && (directionFactor * (horiz ? pick(labelOptions.y, axis.tickRotCorr.y + 8) : labelOptions.x) - lineHeightCorrection));
+ axis.axisTitleMargin = pick(titleOffsetOption, labelOffsetPadded);
+
+ axisOffset[side] = mathMax(
+ axisOffset[side],
+ axis.axisTitleMargin + titleOffset + directionFactor * axis.offset,
+ labelOffsetPadded // #3027
+ );
+
+ // Decide the clipping needed to keep the graph inside the plot area and axis lines
+ clip = options.offset ? 0 : mathFloor(options.lineWidth / 2) * 2; // #4308, #4371
+ clipOffset[invertedSide] = mathMax(clipOffset[invertedSide], clip);
+ },
+
+ /**
+ * Get the path for the axis line
+ */
+ getLinePath: function (lineWidth) {
+ var chart = this.chart,
+ opposite = this.opposite,
+ offset = this.offset,
+ horiz = this.horiz,
+ lineLeft = this.left + (opposite ? this.width : 0) + offset,
+ lineTop = chart.chartHeight - this.bottom - (opposite ? this.height : 0) + offset;
+
+ if (opposite) {
+ lineWidth *= -1; // crispify the other way - #1480, #1687
+ }
+
+ return chart.renderer.crispLine([
+ M,
+ horiz ?
+ this.left :
+ lineLeft,
+ horiz ?
+ lineTop :
+ this.top,
+ L,
+ horiz ?
+ chart.chartWidth - this.right :
+ lineLeft,
+ horiz ?
+ lineTop :
+ chart.chartHeight - this.bottom
+ ], lineWidth);
+ },
+
+ /**
+ * Position the title
+ */
+ getTitlePosition: function () {
+ // compute anchor points for each of the title align options
+ var horiz = this.horiz,
+ axisLeft = this.left,
+ axisTop = this.top,
+ axisLength = this.len,
+ axisTitleOptions = this.options.title,
+ margin = horiz ? axisLeft : axisTop,
+ opposite = this.opposite,
+ offset = this.offset,
+ xOption = axisTitleOptions.x || 0,
+ yOption = axisTitleOptions.y || 0,
+ fontSize = pInt(axisTitleOptions.style.fontSize || 12),
+
+ // the position in the length direction of the axis
+ alongAxis = {
+ low: margin + (horiz ? 0 : axisLength),
+ middle: margin + axisLength / 2,
+ high: margin + (horiz ? axisLength : 0)
+ }[axisTitleOptions.align],
+
+ // the position in the perpendicular direction of the axis
+ offAxis = (horiz ? axisTop + this.height : axisLeft) +
+ (horiz ? 1 : -1) * // horizontal axis reverses the margin
+ (opposite ? -1 : 1) * // so does opposite axes
+ this.axisTitleMargin +
+ (this.side === 2 ? fontSize : 0);
+
+ return {
+ x: horiz ?
+ alongAxis + xOption :
+ offAxis + (opposite ? this.width : 0) + offset + xOption,
+ y: horiz ?
+ offAxis + yOption - (opposite ? this.height : 0) + offset :
+ alongAxis + yOption
+ };
+ },
+
+ /**
+ * Render the axis
+ */
+ render: function () {
+ var axis = this,
+ chart = axis.chart,
+ renderer = chart.renderer,
+ options = axis.options,
+ isLog = axis.isLog,
+ isLinked = axis.isLinked,
+ tickPositions = axis.tickPositions,
+ axisTitle = axis.axisTitle,
+ ticks = axis.ticks,
+ minorTicks = axis.minorTicks,
+ alternateBands = axis.alternateBands,
+ stackLabelOptions = options.stackLabels,
+ alternateGridColor = options.alternateGridColor,
+ tickmarkOffset = axis.tickmarkOffset,
+ lineWidth = options.lineWidth,
+ linePath,
+ hasRendered = chart.hasRendered,
+ slideInTicks = hasRendered && defined(axis.oldMin) && !isNaN(axis.oldMin),
+ showAxis = axis.showAxis,
+ globalAnimation = renderer.globalAnimation,
+ from,
+ to;
+
+ // Reset
+ axis.labelEdge.length = 0;
+ //axis.justifyToPlot = overflow === 'justify';
+ axis.overlap = false;
+
+ // Mark all elements inActive before we go over and mark the active ones
+ each([ticks, minorTicks, alternateBands], function (coll) {
+ var pos;
+ for (pos in coll) {
+ coll[pos].isActive = false;
+ }
+ });
+
+ // If the series has data draw the ticks. Else only the line and title
+ if (axis.hasData() || isLinked) {
+
+ // minor ticks
+ if (axis.minorTickInterval && !axis.categories) {
+ each(axis.getMinorTickPositions(), function (pos) {
+ if (!minorTicks[pos]) {
+ minorTicks[pos] = new Tick(axis, pos, 'minor');
+ }
+
+ // render new ticks in old position
+ if (slideInTicks && minorTicks[pos].isNew) {
+ minorTicks[pos].render(null, true);
+ }
+
+ minorTicks[pos].render(null, false, 1);
+ });
+ }
+
+ // Major ticks. Pull out the first item and render it last so that
+ // we can get the position of the neighbour label. #808.
+ if (tickPositions.length) { // #1300
+ each(tickPositions, function (pos, i) {
+
+ // linked axes need an extra check to find out if
+ if (!isLinked || (pos >= axis.min && pos <= axis.max)) {
+
+ if (!ticks[pos]) {
+ ticks[pos] = new Tick(axis, pos);
+ }
+
+ // render new ticks in old position
+ if (slideInTicks && ticks[pos].isNew) {
+ ticks[pos].render(i, true, 0.1);
+ }
+
+ ticks[pos].render(i);
+ }
+
+ });
+ // In a categorized axis, the tick marks are displayed between labels. So
+ // we need to add a tick mark and grid line at the left edge of the X axis.
+ if (tickmarkOffset && (axis.min === 0 || axis.single)) {
+ if (!ticks[-1]) {
+ ticks[-1] = new Tick(axis, -1, null, true);
+ }
+ ticks[-1].render(-1);
+ }
+
+ }
+
+ // alternate grid color
+ if (alternateGridColor) {
+ each(tickPositions, function (pos, i) {
+ to = tickPositions[i + 1] !== UNDEFINED ? tickPositions[i + 1] + tickmarkOffset : axis.max - tickmarkOffset;
+ if (i % 2 === 0 && pos < axis.max && to <= axis.max - tickmarkOffset) { // #2248
+ if (!alternateBands[pos]) {
+ alternateBands[pos] = new Highcharts.PlotLineOrBand(axis);
+ }
+ from = pos + tickmarkOffset; // #949
+ alternateBands[pos].options = {
+ from: isLog ? lin2log(from) : from,
+ to: isLog ? lin2log(to) : to,
+ color: alternateGridColor
+ };
+ alternateBands[pos].render();
+ alternateBands[pos].isActive = true;
+ }
+ });
+ }
+
+ // custom plot lines and bands
+ if (!axis._addedPlotLB) { // only first time
+ each((options.plotLines || []).concat(options.plotBands || []), function (plotLineOptions) {
+ axis.addPlotBandOrLine(plotLineOptions);
+ });
+ axis._addedPlotLB = true;
+ }
+
+ } // end if hasData
+
+ // Remove inactive ticks
+ each([ticks, minorTicks, alternateBands], function (coll) {
+ var pos,
+ i,
+ forDestruction = [],
+ delay = globalAnimation ? globalAnimation.duration || 500 : 0,
+ destroyInactiveItems = function () {
+ i = forDestruction.length;
+ while (i--) {
+ // When resizing rapidly, the same items may be destroyed in different timeouts,
+ // or the may be reactivated
+ if (coll[forDestruction[i]] && !coll[forDestruction[i]].isActive) {
+ coll[forDestruction[i]].destroy();
+ delete coll[forDestruction[i]];
+ }
+ }
+
+ };
+
+ for (pos in coll) {
+
+ if (!coll[pos].isActive) {
+ // Render to zero opacity
+ coll[pos].render(pos, false, 0);
+ coll[pos].isActive = false;
+ forDestruction.push(pos);
+ }
+ }
+
+ // When the objects are finished fading out, destroy them
+ if (coll === alternateBands || !chart.hasRendered || !delay) {
+ destroyInactiveItems();
+ } else if (delay) {
+ setTimeout(destroyInactiveItems, delay);
+ }
+ });
+
+ // Static items. As the axis group is cleared on subsequent calls
+ // to render, these items are added outside the group.
+ // axis line
+ if (lineWidth) {
+ linePath = axis.getLinePath(lineWidth);
+ if (!axis.axisLine) {
+ axis.axisLine = renderer.path(linePath)
+ .attr({
+ stroke: options.lineColor,
+ 'stroke-width': lineWidth,
+ zIndex: 7
+ })
+ .add(axis.axisGroup);
+ } else {
+ axis.axisLine.animate({ d: linePath });
+ }
+
+ // show or hide the line depending on options.showEmpty
+ axis.axisLine[showAxis ? 'show' : 'hide']();
+ }
+
+ if (axisTitle && showAxis) {
+
+ axisTitle[axisTitle.isNew ? 'attr' : 'animate'](
+ axis.getTitlePosition()
+ );
+ axisTitle.isNew = false;
+ }
+
+ // Stacked totals:
+ if (stackLabelOptions && stackLabelOptions.enabled) {
+ axis.renderStackTotals();
+ }
+ // End stacked totals
+
+ axis.isDirty = false;
+ },
+
+ /**
+ * Redraw the axis to reflect changes in the data or axis extremes
+ */
+ redraw: function () {
+
+ if (this.visible) {
+ // render the axis
+ this.render();
+
+ // move plot lines and bands
+ each(this.plotLinesAndBands, function (plotLine) {
+ plotLine.render();
+ });
+ }
+
+ // mark associated series as dirty and ready for redraw
+ each(this.series, function (series) {
+ series.isDirty = true;
+ });
+
+ },
+
+ /**
+ * Destroys an Axis instance.
+ */
+ destroy: function (keepEvents) {
+ var axis = this,
+ stacks = axis.stacks,
+ stackKey,
+ plotLinesAndBands = axis.plotLinesAndBands,
+ i;
+
+ // Remove the events
+ if (!keepEvents) {
+ removeEvent(axis);
+ }
+
+ // Destroy each stack total
+ for (stackKey in stacks) {
+ destroyObjectProperties(stacks[stackKey]);
+
+ stacks[stackKey] = null;
+ }
+
+ // Destroy collections
+ each([axis.ticks, axis.minorTicks, axis.alternateBands], function (coll) {
+ destroyObjectProperties(coll);
+ });
+ i = plotLinesAndBands.length;
+ while (i--) { // #1975
+ plotLinesAndBands[i].destroy();
+ }
+
+ // Destroy local variables
+ each(['stackTotalGroup', 'axisLine', 'axisTitle', 'axisGroup', 'cross', 'gridGroup', 'labelGroup'], function (prop) {
+ if (axis[prop]) {
+ axis[prop] = axis[prop].destroy();
+ }
+ });
+
+ // Destroy crosshair
+ if (this.cross) {
+ this.cross.destroy();
+ }
+ },
+
+ /**
+ * Draw the crosshair
+ */
+ drawCrosshair: function (e, point) { // docs: Missing docs for Axis.crosshair. Also for properties.
+
+ var path,
+ options = this.crosshair,
+ animation = options.animation,
+ pos,
+ attribs,
+ categorized;
+
+ if (
+ // Disabled in options
+ !this.crosshair ||
+ // Snap
+ ((defined(point) || !pick(this.crosshair.snap, true)) === false) ||
+ // Not on this axis (#4095, #2888)
+ (point && point.series && point.series[this.coll] !== this)
+ ) {
+ this.hideCrosshair();
+
+ } else {
+
+ // Get the path
+ if (!pick(options.snap, true)) {
+ pos = (this.horiz ? e.chartX - this.pos : this.len - e.chartY + this.pos);
+ } else if (defined(point)) {
+ /*jslint eqeq: true*/
+ pos = this.isXAxis ? point.plotX : this.len - point.plotY; // #3834
+ /*jslint eqeq: false*/
+ }
+
+ if (this.isRadial) {
+ path = this.getPlotLinePath(this.isXAxis ? point.x : pick(point.stackY, point.y)) || null; // #3189
+ } else {
+ path = this.getPlotLinePath(null, null, null, null, pos) || null; // #3189
+ }
+
+ if (path === null) {
+ this.hideCrosshair();
+ return;
+ }
+
+ // Draw the cross
+ if (this.cross) {
+ this.cross
+ .attr({ visibility: VISIBLE })[animation ? 'animate' : 'attr']({ d: path }, animation);
+ } else {
+ categorized = this.categories && !this.isRadial;
+ attribs = {
+ 'stroke-width': options.width || (categorized ? this.transA : 1),
+ stroke: options.color || (categorized ? 'rgba(155,200,255,0.2)' : '#C0C0C0'),
+ zIndex: options.zIndex || 2
+ };
+ if (options.dashStyle) {
+ attribs.dashstyle = options.dashStyle;
+ }
+ this.cross = this.chart.renderer.path(path).attr(attribs).add();
+ }
+
+ }
+
+ },
+
+ /**
+ * Hide the crosshair.
+ */
+ hideCrosshair: function () {
+ if (this.cross) {
+ this.cross.hide();
+ }
+ }
+}; // end Axis
+
+extend(Axis.prototype, AxisPlotLineOrBandExtension);
+
+
+
+/**
+ * Set the tick positions to a time unit that makes sense, for example
+ * on the first of each month or on every Monday. Return an array
+ * with the time positions. Used in datetime axes as well as for grouping
+ * data on a datetime axis.
+ *
+ * @param {Object} normalizedInterval The interval in axis values (ms) and the count
+ * @param {Number} min The minimum in axis values
+ * @param {Number} max The maximum in axis values
+ * @param {Number} startOfWeek
+ */
+Axis.prototype.getTimeTicks = function (normalizedInterval, min, max, startOfWeek) {
+ var tickPositions = [],
+ i,
+ higherRanks = {},
+ useUTC = defaultOptions.global.useUTC,
+ minYear, // used in months and years as a basis for Date.UTC()
+ minDate = new Date(min - getTZOffset(min)),
+ interval = normalizedInterval.unitRange,
+ count = normalizedInterval.count;
+
+ if (defined(min)) { // #1300
+ minDate[setMilliseconds](interval >= timeUnits.second ? 0 : // #3935
+ count * mathFloor(minDate.getMilliseconds() / count)); // #3652, #3654
+
+ if (interval >= timeUnits.second) { // second
+ minDate[setSeconds](interval >= timeUnits.minute ? 0 : // #3935
+ count * mathFloor(minDate.getSeconds() / count));
+ }
+
+ if (interval >= timeUnits.minute) { // minute
+ minDate[setMinutes](interval >= timeUnits.hour ? 0 :
+ count * mathFloor(minDate[getMinutes]() / count));
+ }
+
+ if (interval >= timeUnits.hour) { // hour
+ minDate[setHours](interval >= timeUnits.day ? 0 :
+ count * mathFloor(minDate[getHours]() / count));
+ }
+
+ if (interval >= timeUnits.day) { // day
+ minDate[setDate](interval >= timeUnits.month ? 1 :
+ count * mathFloor(minDate[getDate]() / count));
+ }
+
+ if (interval >= timeUnits.month) { // month
+ minDate[setMonth](interval >= timeUnits.year ? 0 :
+ count * mathFloor(minDate[getMonth]() / count));
+ minYear = minDate[getFullYear]();
+ }
+
+ if (interval >= timeUnits.year) { // year
+ minYear -= minYear % count;
+ minDate[setFullYear](minYear);
+ }
+
+ // week is a special case that runs outside the hierarchy
+ if (interval === timeUnits.week) {
+ // get start of current week, independent of count
+ minDate[setDate](minDate[getDate]() - minDate[getDay]() +
+ pick(startOfWeek, 1));
+ }
+
+
+ // get tick positions
+ i = 1;
+ if (timezoneOffset || getTimezoneOffset) {
+ minDate = minDate.getTime();
+ minDate = new Date(minDate + getTZOffset(minDate));
+ }
+ minYear = minDate[getFullYear]();
+ var time = minDate.getTime(),
+ minMonth = minDate[getMonth](),
+ minDateDate = minDate[getDate](),
+ localTimezoneOffset = (timeUnits.day +
+ (useUTC ? getTZOffset(minDate) : minDate.getTimezoneOffset() * 60 * 1000)
+ ) % timeUnits.day; // #950, #3359
+
+ // iterate and add tick positions at appropriate values
+ while (time < max) {
+ tickPositions.push(time);
+
+ // if the interval is years, use Date.UTC to increase years
+ if (interval === timeUnits.year) {
+ time = makeTime(minYear + i * count, 0);
+
+ // if the interval is months, use Date.UTC to increase months
+ } else if (interval === timeUnits.month) {
+ time = makeTime(minYear, minMonth + i * count);
+
+ // if we're using global time, the interval is not fixed as it jumps
+ // one hour at the DST crossover
+ } else if (!useUTC && (interval === timeUnits.day || interval === timeUnits.week)) {
+ time = makeTime(minYear, minMonth, minDateDate +
+ i * count * (interval === timeUnits.day ? 1 : 7));
+
+ // else, the interval is fixed and we use simple addition
+ } else {
+ time += interval * count;
+ }
+
+ i++;
+ }
+
+ // push the last time
+ tickPositions.push(time);
+
+
+ // mark new days if the time is dividible by day (#1649, #1760)
+ each(grep(tickPositions, function (time) {
+ return interval <= timeUnits.hour && time % timeUnits.day === localTimezoneOffset;
+ }), function (time) {
+ higherRanks[time] = 'day';
+ });
+ }
+
+
+ // record information on the chosen unit - for dynamic label formatter
+ tickPositions.info = extend(normalizedInterval, {
+ higherRanks: higherRanks,
+ totalRange: interval * count
+ });
+
+ return tickPositions;
+};
+
+/**
+ * Get a normalized tick interval for dates. Returns a configuration object with
+ * unit range (interval), count and name. Used to prepare data for getTimeTicks.
+ * Previously this logic was part of getTimeTicks, but as getTimeTicks now runs
+ * of segments in stock charts, the normalizing logic was extracted in order to
+ * prevent it for running over again for each segment having the same interval.
+ * #662, #697.
+ */
+Axis.prototype.normalizeTimeTickInterval = function (tickInterval, unitsOption) {
+ var units = unitsOption || [[
+ 'millisecond', // unit name
+ [1, 2, 5, 10, 20, 25, 50, 100, 200, 500] // allowed multiples
+ ], [
+ 'second',
+ [1, 2, 5, 10, 15, 30]
+ ], [
+ 'minute',
+ [1, 2, 5, 10, 15, 30]
+ ], [
+ 'hour',
+ [1, 2, 3, 4, 6, 8, 12]
+ ], [
+ 'day',
+ [1, 2]
+ ], [
+ 'week',
+ [1, 2]
+ ], [
+ 'month',
+ [1, 2, 3, 4, 6]
+ ], [
+ 'year',
+ null
+ ]],
+ unit = units[units.length - 1], // default unit is years
+ interval = timeUnits[unit[0]],
+ multiples = unit[1],
+ count,
+ i;
+
+ // loop through the units to find the one that best fits the tickInterval
+ for (i = 0; i < units.length; i++) {
+ unit = units[i];
+ interval = timeUnits[unit[0]];
+ multiples = unit[1];
+
+
+ if (units[i + 1]) {
+ // lessThan is in the middle between the highest multiple and the next unit.
+ var lessThan = (interval * multiples[multiples.length - 1] +
+ timeUnits[units[i + 1][0]]) / 2;
+
+ // break and keep the current unit
+ if (tickInterval <= lessThan) {
+ break;
+ }
+ }
+ }
+
+ // prevent 2.5 years intervals, though 25, 250 etc. are allowed
+ if (interval === timeUnits.year && tickInterval < 5 * interval) {
+ multiples = [1, 2, 5];
+ }
+
+ // get the count
+ count = normalizeTickInterval(
+ tickInterval / interval,
+ multiples,
+ unit[0] === 'year' ? mathMax(getMagnitude(tickInterval / interval), 1) : 1 // #1913, #2360
+ );
+
+ return {
+ unitRange: interval,
+ count: count,
+ unitName: unit[0]
+ };
+};
+
+/**
+ * Methods defined on the Axis prototype
+ */
+
+/**
+ * Set the tick positions of a logarithmic axis
+ */
+Axis.prototype.getLogTickPositions = function (interval, min, max, minor) {
+ var axis = this,
+ options = axis.options,
+ axisLength = axis.len,
+ // Since we use this method for both major and minor ticks,
+ // use a local variable and return the result
+ positions = [];
+
+ // Reset
+ if (!minor) {
+ axis._minorAutoInterval = null;
+ }
+
+ // First case: All ticks fall on whole logarithms: 1, 10, 100 etc.
+ if (interval >= 0.5) {
+ interval = mathRound(interval);
+ positions = axis.getLinearTickPositions(interval, min, max);
+
+ // Second case: We need intermediary ticks. For example
+ // 1, 2, 4, 6, 8, 10, 20, 40 etc.
+ } else if (interval >= 0.08) {
+ var roundedMin = mathFloor(min),
+ intermediate,
+ i,
+ j,
+ len,
+ pos,
+ lastPos,
+ break2;
+
+ if (interval > 0.3) {
+ intermediate = [1, 2, 4];
+ } else if (interval > 0.15) { // 0.2 equals five minor ticks per 1, 10, 100 etc
+ intermediate = [1, 2, 4, 6, 8];
+ } else { // 0.1 equals ten minor ticks per 1, 10, 100 etc
+ intermediate = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ }
+
+ for (i = roundedMin; i < max + 1 && !break2; i++) {
+ len = intermediate.length;
+ for (j = 0; j < len && !break2; j++) {
+ pos = log2lin(lin2log(i) * intermediate[j]);
+ if (pos > min && (!minor || lastPos <= max) && lastPos !== UNDEFINED) { // #1670, lastPos is #3113
+ positions.push(lastPos);
+ }
+
+ if (lastPos > max) {
+ break2 = true;
+ }
+ lastPos = pos;
+ }
+ }
+
+ // Third case: We are so deep in between whole logarithmic values that
+ // we might as well handle the tick positions like a linear axis. For
+ // example 1.01, 1.02, 1.03, 1.04.
+ } else {
+ var realMin = lin2log(min),
+ realMax = lin2log(max),
+ tickIntervalOption = options[minor ? 'minorTickInterval' : 'tickInterval'],
+ filteredTickIntervalOption = tickIntervalOption === 'auto' ? null : tickIntervalOption,
+ tickPixelIntervalOption = options.tickPixelInterval / (minor ? 5 : 1),
+ totalPixelLength = minor ? axisLength / axis.tickPositions.length : axisLength;
+
+ interval = pick(
+ filteredTickIntervalOption,
+ axis._minorAutoInterval,
+ (realMax - realMin) * tickPixelIntervalOption / (totalPixelLength || 1)
+ );
+
+ interval = normalizeTickInterval(
+ interval,
+ null,
+ getMagnitude(interval)
+ );
+
+ positions = map(axis.getLinearTickPositions(
+ interval,
+ realMin,
+ realMax
+ ), log2lin);
+
+ if (!minor) {
+ axis._minorAutoInterval = interval / 5;
+ }
+ }
+
+ // Set the axis-level tickInterval variable
+ if (!minor) {
+ axis.tickInterval = interval;
+ }
+ return positions;
+};
+
+/**
+ * The tooltip object
+ * @param {Object} chart The chart instance
+ * @param {Object} options Tooltip options
+ */
+var Tooltip = Highcharts.Tooltip = function () {
+ this.init.apply(this, arguments);
+};
+
+Tooltip.prototype = {
+
+ init: function (chart, options) {
+
+ var borderWidth = options.borderWidth,
+ style = options.style,
+ padding = pInt(style.padding);
+
+ // Save the chart and options
+ this.chart = chart;
+ this.options = options;
+
+ // Keep track of the current series
+ //this.currentSeries = UNDEFINED;
+
+ // List of crosshairs
+ this.crosshairs = [];
+
+ // Current values of x and y when animating
+ this.now = { x: 0, y: 0 };
+
+ // The tooltip is initially hidden
+ this.isHidden = true;
+
+
+ // create the label
+ this.label = chart.renderer.label('', 0, 0, options.shape || 'callout', null, null, options.useHTML, null, 'tooltip')
+ .attr({
+ padding: padding,
+ fill: options.backgroundColor,
+ 'stroke-width': borderWidth,
+ r: options.borderRadius,
+ zIndex: 8
+ })
+ .css(style)
+ .css({ padding: 0 }) // Remove it from VML, the padding is applied as an attribute instead (#1117)
+ .add()
+ .attr({ y: -9999 }); // #2301, #2657
+
+ // When using canVG the shadow shows up as a gray circle
+ // even if the tooltip is hidden.
+ if (!useCanVG) {
+ this.label.shadow(options.shadow);
+ }
+
+ // Public property for getting the shared state.
+ this.shared = options.shared;
+ },
+
+ /**
+ * Destroy the tooltip and its elements.
+ */
+ destroy: function () {
+ // Destroy and clear local variables
+ if (this.label) {
+ this.label = this.label.destroy();
+ }
+ clearTimeout(this.hideTimer);
+ clearTimeout(this.tooltipTimeout);
+ },
+
+ /**
+ * Provide a soft movement for the tooltip
+ *
+ * @param {Number} x
+ * @param {Number} y
+ * @private
+ */
+ move: function (x, y, anchorX, anchorY) {
+ var tooltip = this,
+ now = tooltip.now,
+ animate = tooltip.options.animation !== false && !tooltip.isHidden &&
+ // When we get close to the target position, abort animation and land on the right place (#3056)
+ (mathAbs(x - now.x) > 1 || mathAbs(y - now.y) > 1),
+ skipAnchor = tooltip.followPointer || tooltip.len > 1;
+
+ // Get intermediate values for animation
+ extend(now, {
+ x: animate ? (2 * now.x + x) / 3 : x,
+ y: animate ? (now.y + y) / 2 : y,
+ anchorX: skipAnchor ? UNDEFINED : animate ? (2 * now.anchorX + anchorX) / 3 : anchorX,
+ anchorY: skipAnchor ? UNDEFINED : animate ? (now.anchorY + anchorY) / 2 : anchorY
+ });
+
+ // Move to the intermediate value
+ tooltip.label.attr(now);
+
+
+ // Run on next tick of the mouse tracker
+ if (animate) {
+
+ // Never allow two timeouts
+ clearTimeout(this.tooltipTimeout);
+
+ // Set the fixed interval ticking for the smooth tooltip
+ this.tooltipTimeout = setTimeout(function () {
+ // The interval function may still be running during destroy, so check that the chart is really there before calling.
+ if (tooltip) {
+ tooltip.move(x, y, anchorX, anchorY);
+ }
+ }, 32);
+
+ }
+ },
+
+ /**
+ * Hide the tooltip
+ */
+ hide: function (delay) {
+ var tooltip = this,
+ hoverPoints;
+
+ clearTimeout(this.hideTimer); // disallow duplicate timers (#1728, #1766)
+ if (!this.isHidden) {
+ hoverPoints = this.chart.hoverPoints;
+
+ this.hideTimer = setTimeout(function () {
+ tooltip.label.fadeOut();
+ tooltip.isHidden = true;
+ }, pick(delay, this.options.hideDelay, 500));
+ }
+ },
+
+ /**
+ * Extendable method to get the anchor position of the tooltip
+ * from a point or set of points
+ */
+ getAnchor: function (points, mouseEvent) {
+ var ret,
+ chart = this.chart,
+ inverted = chart.inverted,
+ plotTop = chart.plotTop,
+ plotLeft = chart.plotLeft,
+ plotX = 0,
+ plotY = 0,
+ yAxis,
+ xAxis;
+
+ points = splat(points);
+
+ // Pie uses a special tooltipPos
+ ret = points[0].tooltipPos;
+
+ // When tooltip follows mouse, relate the position to the mouse
+ if (this.followPointer && mouseEvent) {
+ if (mouseEvent.chartX === UNDEFINED) {
+ mouseEvent = chart.pointer.normalize(mouseEvent);
+ }
+ ret = [
+ mouseEvent.chartX - chart.plotLeft,
+ mouseEvent.chartY - plotTop
+ ];
+ }
+ // When shared, use the average position
+ if (!ret) {
+ each(points, function (point) {
+ yAxis = point.series.yAxis;
+ xAxis = point.series.xAxis;
+ plotX += point.plotX + (!inverted && xAxis ? xAxis.left - plotLeft : 0);
+ plotY += (point.plotLow ? (point.plotLow + point.plotHigh) / 2 : point.plotY) +
+ (!inverted && yAxis ? yAxis.top - plotTop : 0); // #1151
+ });
+
+ plotX /= points.length;
+ plotY /= points.length;
+
+ ret = [
+ inverted ? chart.plotWidth - plotY : plotX,
+ this.shared && !inverted && points.length > 1 && mouseEvent ?
+ mouseEvent.chartY - plotTop : // place shared tooltip next to the mouse (#424)
+ inverted ? chart.plotHeight - plotX : plotY
+ ];
+ }
+
+ return map(ret, mathRound);
+ },
+
+ /**
+ * Place the tooltip in a chart without spilling over
+ * and not covering the point it self.
+ */
+ getPosition: function (boxWidth, boxHeight, point) {
+
+ var chart = this.chart,
+ distance = this.distance,
+ ret = {},
+ h = point.h || 0, // #4117
+ swapped,
+ first = ['y', chart.chartHeight, boxHeight, point.plotY + chart.plotTop, chart.plotTop, chart.plotTop + chart.plotHeight],
+ second = ['x', chart.chartWidth, boxWidth, point.plotX + chart.plotLeft, chart.plotLeft, chart.plotLeft + chart.plotWidth],
+ // The far side is right or bottom
+ preferFarSide = pick(point.ttBelow, (chart.inverted && !point.negative) || (!chart.inverted && point.negative)),
+ /**
+ * Handle the preferred dimension. When the preferred dimension is tooltip
+ * on top or bottom of the point, it will look for space there.
+ */
+ firstDimension = function (dim, outerSize, innerSize, point, min, max) {
+ var roomLeft = innerSize < point - distance,
+ roomRight = point + distance + innerSize < outerSize,
+ alignedLeft = point - distance - innerSize,
+ alignedRight = point + distance;
+
+ if (preferFarSide && roomRight) {
+ ret[dim] = alignedRight;
+ } else if (!preferFarSide && roomLeft) {
+ ret[dim] = alignedLeft;
+ } else if (roomLeft) {
+ ret[dim] = mathMin(max - innerSize, alignedLeft - h < 0 ? alignedLeft : alignedLeft - h);
+ } else if (roomRight) {
+ ret[dim] = mathMax(min, alignedRight + h + innerSize > outerSize ? alignedRight : alignedRight + h);
+ } else {
+ return false;
+ }
+ },
+ /**
+ * Handle the secondary dimension. If the preferred dimension is tooltip
+ * on top or bottom of the point, the second dimension is to align the tooltip
+ * above the point, trying to align center but allowing left or right
+ * align within the chart box.
+ */
+ secondDimension = function (dim, outerSize, innerSize, point) {
+ // Too close to the edge, return false and swap dimensions
+ if (point < distance || point > outerSize - distance) {
+ return false;
+
+ // Align left/top
+ } else if (point < innerSize / 2) {
+ ret[dim] = 1;
+ // Align right/bottom
+ } else if (point > outerSize - innerSize / 2) {
+ ret[dim] = outerSize - innerSize - 2;
+ // Align center
+ } else {
+ ret[dim] = point - innerSize / 2;
+ }
+ },
+ /**
+ * Swap the dimensions
+ */
+ swap = function (count) {
+ var temp = first;
+ first = second;
+ second = temp;
+ swapped = count;
+ },
+ run = function () {
+ if (firstDimension.apply(0, first) !== false) {
+ if (secondDimension.apply(0, second) === false && !swapped) {
+ swap(true);
+ run();
+ }
+ } else if (!swapped) {
+ swap(true);
+ run();
+ } else {
+ ret.x = ret.y = 0;
+ }
+ };
+
+ // Under these conditions, prefer the tooltip on the side of the point
+ if (chart.inverted || this.len > 1) {
+ swap();
+ }
+ run();
+
+ return ret;
+
+ },
+
+ /**
+ * In case no user defined formatter is given, this will be used. Note that the context
+ * here is an object holding point, series, x, y etc.
+ */
+ defaultFormatter: function (tooltip) {
+ var items = this.points || splat(this),
+ s;
+
+ // build the header
+ s = [tooltip.tooltipFooterHeaderFormatter(items[0])]; //#3397: abstraction to enable formatting of footer and header
+
+ // build the values
+ s = s.concat(tooltip.bodyFormatter(items));
+
+ // footer
+ s.push(tooltip.tooltipFooterHeaderFormatter(items[0], true)); //#3397: abstraction to enable formatting of footer and header
+
+ return s.join('');
+ },
+
+ /**
+ * Refresh the tooltip's text and position.
+ * @param {Object} point
+ */
+ refresh: function (point, mouseEvent) {
+ var tooltip = this,
+ chart = tooltip.chart,
+ label = tooltip.label,
+ options = tooltip.options,
+ x,
+ y,
+ anchor,
+ textConfig = {},
+ text,
+ pointConfig = [],
+ formatter = options.formatter || tooltip.defaultFormatter,
+ hoverPoints = chart.hoverPoints,
+ borderColor,
+ shared = tooltip.shared,
+ currentSeries;
+
+ clearTimeout(this.hideTimer);
+
+ // get the reference point coordinates (pie charts use tooltipPos)
+ tooltip.followPointer = splat(point)[0].series.tooltipOptions.followPointer;
+ anchor = tooltip.getAnchor(point, mouseEvent);
+ x = anchor[0];
+ y = anchor[1];
+
+ // shared tooltip, array is sent over
+ if (shared && !(point.series && point.series.noSharedTooltip)) {
+
+ // hide previous hoverPoints and set new
+
+ chart.hoverPoints = point;
+ if (hoverPoints) {
+ each(hoverPoints, function (point) {
+ point.setState();
+ });
+ }
+
+ each(point, function (item) {
+ item.setState(HOVER_STATE);
+
+ pointConfig.push(item.getLabelConfig());
+ });
+
+ textConfig = {
+ x: point[0].category,
+ y: point[0].y
+ };
+ textConfig.points = pointConfig;
+ this.len = pointConfig.length;
+ point = point[0];
+
+ // single point tooltip
+ } else {
+ textConfig = point.getLabelConfig();
+ }
+ text = formatter.call(textConfig, tooltip);
+
+ // register the current series
+ currentSeries = point.series;
+ this.distance = pick(currentSeries.tooltipOptions.distance, 16);
+
+ // update the inner HTML
+ if (text === false) {
+ this.hide();
+ } else {
+
+ // show it
+ if (tooltip.isHidden) {
+ stop(label);
+ label.attr('opacity', 1).show();
+ }
+
+ // update text
+ label.attr({
+ text: text
+ });
+
+ // set the stroke color of the box
+ borderColor = options.borderColor || point.color || currentSeries.color || '#606060';
+ label.attr({
+ stroke: borderColor
+ });
+ tooltip.updatePosition({
+ plotX: x,
+ plotY: y,
+ negative: point.negative,
+ ttBelow: point.ttBelow,
+ h: anchor[2] || 0
+ });
+
+ this.isHidden = false;
+ }
+ fireEvent(chart, 'tooltipRefresh', {
+ text: text,
+ x: x + chart.plotLeft,
+ y: y + chart.plotTop,
+ borderColor: borderColor
+ });
+ },
+
+ /**
+ * Find the new position and perform the move
+ */
+ updatePosition: function (point) {
+ var chart = this.chart,
+ label = this.label,
+ pos = (this.options.positioner || this.getPosition).call(
+ this,
+ label.width,
+ label.height,
+ point
+ );
+
+ // do the move
+ this.move(
+ mathRound(pos.x),
+ mathRound(pos.y || 0), // can be undefined (#3977)
+ point.plotX + chart.plotLeft,
+ point.plotY + chart.plotTop
+ );
+ },
+
+ /**
+ * Get the best X date format based on the closest point range on the axis.
+ */
+ getXDateFormat: function (point, options, xAxis) {
+ var xDateFormat,
+ dateTimeLabelFormats = options.dateTimeLabelFormats,
+ closestPointRange = xAxis && xAxis.closestPointRange,
+ n,
+ blank = '01-01 00:00:00.000',
+ strpos = {
+ millisecond: 15,
+ second: 12,
+ minute: 9,
+ hour: 6,
+ day: 3
+ },
+ date,
+ lastN = 'millisecond'; // for sub-millisecond data, #4223
+
+ if (closestPointRange) {
+ date = dateFormat('%m-%d %H:%M:%S.%L', point.x);
+ for (n in timeUnits) {
+
+ // If the range is exactly one week and we're looking at a Sunday/Monday, go for the week format
+ if (closestPointRange === timeUnits.week && +dateFormat('%w', point.x) === xAxis.options.startOfWeek &&
+ date.substr(6) === blank.substr(6)) {
+ n = 'week';
+ break;
+
+ // The first format that is too great for the range
+ } else if (timeUnits[n] > closestPointRange) {
+ n = lastN;
+ break;
+
+ // If the point is placed every day at 23:59, we need to show
+ // the minutes as well. #2637.
+ } else if (strpos[n] && date.substr(strpos[n]) !== blank.substr(strpos[n])) {
+ break;
+ }
+
+ // Weeks are outside the hierarchy, only apply them on Mondays/Sundays like in the first condition
+ if (n !== 'week') {
+ lastN = n;
+ }
+ }
+
+ if (n) {
+ xDateFormat = dateTimeLabelFormats[n];
+ }
+ } else {
+ xDateFormat = dateTimeLabelFormats.day;
+ }
+
+ return xDateFormat || dateTimeLabelFormats.year; // #2546, 2581
+ },
+
+ /**
+ * Format the footer/header of the tooltip
+ * #3397: abstraction to enable formatting of footer and header
+ */
+ tooltipFooterHeaderFormatter: function (point, isFooter) {
+ var footOrHead = isFooter ? 'footer' : 'header',
+ series = point.series,
+ tooltipOptions = series.tooltipOptions,
+ xDateFormat = tooltipOptions.xDateFormat,
+ xAxis = series.xAxis,
+ isDateTime = xAxis && xAxis.options.type === 'datetime' && isNumber(point.key),
+ formatString = tooltipOptions[footOrHead+'Format'];
+
+ // Guess the best date format based on the closest point distance (#568, #3418)
+ if (isDateTime && !xDateFormat) {
+ xDateFormat = this.getXDateFormat(point, tooltipOptions, xAxis);
+ }
+
+ // Insert the footer date format if any
+ if (isDateTime && xDateFormat) {
+ formatString = formatString.replace('{point.key}', '{point.key:' + xDateFormat + '}');
+ }
+
+ return format(formatString, {
+ point: point,
+ series: series
+ });
+ },
+
+ /**
+ * Build the body (lines) of the tooltip by iterating over the items and returning one entry for each item,
+ * abstracting this functionality allows to easily overwrite and extend it.
+ */
+ bodyFormatter: function (items) {
+ return map(items, function (item) {
+ var tooltipOptions = item.series.tooltipOptions;
+ return (tooltipOptions.pointFormatter || item.point.tooltipFormatter).call(item.point, tooltipOptions.pointFormat);
+ });
+ }
+
+};
+
+
+
+var hoverChartIndex;
+
+// Global flag for touch support
+hasTouch = doc.documentElement.ontouchstart !== UNDEFINED;
+
+/**
+ * The mouse tracker object. All methods starting with "on" are primary DOM event handlers.
+ * Subsequent methods should be named differently from what they are doing.
+ * @param {Object} chart The Chart instance
+ * @param {Object} options The root options object
+ */
+var Pointer = Highcharts.Pointer = function (chart, options) {
+ this.init(chart, options);
+};
+
+Pointer.prototype = {
+ /**
+ * Initialize Pointer
+ */
+ init: function (chart, options) {
+
+ var chartOptions = options.chart,
+ chartEvents = chartOptions.events,
+ zoomType = useCanVG ? '' : chartOptions.zoomType,
+ inverted = chart.inverted,
+ zoomX,
+ zoomY;
+
+ // Store references
+ this.options = options;
+ this.chart = chart;
+
+ // Zoom status
+ this.zoomX = zoomX = /x/.test(zoomType);
+ this.zoomY = zoomY = /y/.test(zoomType);
+ this.zoomHor = (zoomX && !inverted) || (zoomY && inverted);
+ this.zoomVert = (zoomY && !inverted) || (zoomX && inverted);
+ this.hasZoom = zoomX || zoomY;
+
+ // Do we need to handle click on a touch device?
+ this.runChartClick = chartEvents && !!chartEvents.click;
+
+ this.pinchDown = [];
+ this.lastValidTouch = {};
+
+ if (Highcharts.Tooltip && options.tooltip.enabled) {
+ chart.tooltip = new Tooltip(chart, options.tooltip);
+ this.followTouchMove = pick(options.tooltip.followTouchMove, true);
+ }
+
+ this.setDOMEvents();
+ },
+
+ /**
+ * Add crossbrowser support for chartX and chartY
+ * @param {Object} e The event object in standard browsers
+ */
+ normalize: function (e, chartPosition) {
+ var chartX,
+ chartY,
+ ePos;
+
+ // common IE normalizing
+ e = e || window.event;
+
+ // Framework specific normalizing (#1165)
+ e = washMouseEvent(e);
+
+ // More IE normalizing, needs to go after washMouseEvent
+ if (!e.target) {
+ e.target = e.srcElement;
+ }
+
+ // iOS (#2757)
+ ePos = e.touches ? (e.touches.length ? e.touches.item(0) : e.changedTouches[0]) : e;
+
+ // Get mouse position
+ if (!chartPosition) {
+ this.chartPosition = chartPosition = offset(this.chart.container);
+ }
+
+ // chartX and chartY
+ if (ePos.pageX === UNDEFINED) { // IE < 9. #886.
+ chartX = mathMax(e.x, e.clientX - chartPosition.left); // #2005, #2129: the second case is
+ // for IE10 quirks mode within framesets
+ chartY = e.y;
+ } else {
+ chartX = ePos.pageX - chartPosition.left;
+ chartY = ePos.pageY - chartPosition.top;
+ }
+
+ return extend(e, {
+ chartX: mathRound(chartX),
+ chartY: mathRound(chartY)
+ });
+ },
+
+ /**
+ * Get the click position in terms of axis values.
+ *
+ * @param {Object} e A pointer event
+ */
+ getCoordinates: function (e) {
+ var coordinates = {
+ xAxis: [],
+ yAxis: []
+ };
+
+ each(this.chart.axes, function (axis) {
+ coordinates[axis.isXAxis ? 'xAxis' : 'yAxis'].push({
+ axis: axis,
+ value: axis.toValue(e[axis.horiz ? 'chartX' : 'chartY'])
+ });
+ });
+ return coordinates;
+ },
+
+ /**
+ * With line type charts with a single tracker, get the point closest to the mouse.
+ * Run Point.onMouseOver and display tooltip for the point or points.
+ */
+ runPointActions: function (e) {
+
+ var pointer = this,
+ chart = pointer.chart,
+ series = chart.series,
+ tooltip = chart.tooltip,
+ shared = tooltip ? tooltip.shared : false,
+ followPointer,
+ hoverPoint = chart.hoverPoint,
+ hoverSeries = chart.hoverSeries,
+ i,
+ distance = Number.MAX_VALUE, // #4511
+ anchor,
+ noSharedTooltip,
+ stickToHoverSeries,
+ directTouch,
+ kdpoints = [],
+ kdpoint,
+ kdpointT;
+
+ // For hovering over the empty parts of the plot area (hoverSeries is undefined).
+ // If there is one series with point tracking (combo chart), don't go to nearest neighbour.
+ if (!shared && !hoverSeries) {
+ for (i = 0; i < series.length; i++) {
+ if (series[i].directTouch || !series[i].options.stickyTracking) {
+ series = [];
+ }
+ }
+ }
+
+ // If it has a hoverPoint and that series requires direct touch (like columns, #3899), or we're on
+ // a noSharedTooltip series among shared tooltip series (#4546), use the hoverPoint . Otherwise,
+ // search the k-d tree.
+ stickToHoverSeries = hoverSeries && (shared ? hoverSeries.noSharedTooltip : hoverSeries.directTouch);
+ if (stickToHoverSeries && hoverPoint) {
+ kdpoint = hoverPoint;
+
+ // Handle shared tooltip or cases where a series is not yet hovered
+ } else {
+ // Find nearest points on all series
+ each(series, function (s) {
+ // Skip hidden series
+ noSharedTooltip = s.noSharedTooltip && shared;
+ directTouch = !shared && s.directTouch;
+ if (s.visible && !noSharedTooltip && !directTouch && pick(s.options.enableMouseTracking, true)) { // #3821
+ kdpointT = s.searchPoint(e, !noSharedTooltip && s.kdDimensions === 1); // #3828
+ if (kdpointT) {
+ kdpoints.push(kdpointT);
+ }
+ }
+ });
+ // Find absolute nearest point
+ each(kdpoints, function (p) {
+ if (p && typeof p.dist === 'number' && p.dist < distance) {
+ distance = p.dist;
+ kdpoint = p;
+ }
+ });
+ }
+
+ // Refresh tooltip for kdpoint if new hover point or tooltip was hidden // #3926, #4200
+ if (kdpoint && (kdpoint !== this.prevKDPoint || (tooltip && tooltip.isHidden))) {
+ // Draw tooltip if necessary
+ if (shared && !kdpoint.series.noSharedTooltip) {
+ i = kdpoints.length;
+ while (i--) {
+ if (kdpoints[i].clientX !== kdpoint.clientX || kdpoints[i].series.noSharedTooltip) {
+ kdpoints.splice(i, 1);
+ }
+ }
+ if (kdpoints.length && tooltip) {
+ tooltip.refresh(kdpoints, e);
+ }
+
+ // Do mouseover on all points (#3919, #3985, #4410)
+ each(kdpoints, function (point) {
+ point.onMouseOver(e, point !== ((hoverSeries && hoverSeries.directTouch && hoverPoint) || kdpoint));
+ });
+ } else {
+ if (tooltip) {
+ tooltip.refresh(kdpoint, e);
+ }
+ if(!hoverSeries || !hoverSeries.directTouch) { // #4448
+ kdpoint.onMouseOver(e);
+ }
+ }
+ this.prevKDPoint = kdpoint;
+
+ // Update positions (regardless of kdpoint or hoverPoint)
+ } else {
+ followPointer = hoverSeries && hoverSeries.tooltipOptions.followPointer;
+ if (tooltip && followPointer && !tooltip.isHidden) {
+ anchor = tooltip.getAnchor([{}], e);
+ tooltip.updatePosition({ plotX: anchor[0], plotY: anchor[1] });
+ }
+ }
+
+ // Start the event listener to pick up the tooltip
+ if (tooltip && !pointer._onDocumentMouseMove) {
+ pointer._onDocumentMouseMove = function (e) {
+ if (charts[hoverChartIndex]) {
+ charts[hoverChartIndex].pointer.onDocumentMouseMove(e);
+ }
+ };
+ addEvent(doc, 'mousemove', pointer._onDocumentMouseMove);
+ }
+
+ // Crosshair
+ each(chart.axes, function (axis) {
+ axis.drawCrosshair(e, pick(kdpoint, hoverPoint));
+ });
+
+
+ },
+
+
+
+ /**
+ * Reset the tracking by hiding the tooltip, the hover series state and the hover point
+ *
+ * @param allowMove {Boolean} Instead of destroying the tooltip altogether, allow moving it if possible
+ */
+ reset: function (allowMove, delay) {
+ var pointer = this,
+ chart = pointer.chart,
+ hoverSeries = chart.hoverSeries,
+ hoverPoint = chart.hoverPoint,
+ hoverPoints = chart.hoverPoints,
+ tooltip = chart.tooltip,
+ tooltipPoints = tooltip && tooltip.shared ? hoverPoints : hoverPoint;
+
+ // Narrow in allowMove
+ allowMove = allowMove && tooltip && tooltipPoints;
+
+ // Check if the points have moved outside the plot area, #1003
+ if (allowMove && splat(tooltipPoints)[0].plotX === UNDEFINED) {
+ allowMove = false;
+ }
+ // Just move the tooltip, #349
+ if (allowMove) {
+ tooltip.refresh(tooltipPoints);
+ if (hoverPoint) { // #2500
+ hoverPoint.setState(hoverPoint.state, true);
+ each(chart.axes, function (axis) {
+ if (pick(axis.options.crosshair && axis.options.crosshair.snap, true)) {
+ axis.drawCrosshair(null, hoverPoint);
+ } else {
+ axis.hideCrosshair();
+ }
+ });
+
+ }
+
+ // Full reset
+ } else {
+
+ if (hoverPoint) {
+ hoverPoint.onMouseOut();
+ }
+
+ if (hoverPoints) {
+ each(hoverPoints, function (point) {
+ point.setState();
+ });
+ }
+
+ if (hoverSeries) {
+ hoverSeries.onMouseOut();
+ }
+
+ if (tooltip) {
+ tooltip.hide(delay);
+ }
+
+ if (pointer._onDocumentMouseMove) {
+ removeEvent(doc, 'mousemove', pointer._onDocumentMouseMove);
+ pointer._onDocumentMouseMove = null;
+ }
+
+ // Remove crosshairs
+ each(chart.axes, function (axis) {
+ axis.hideCrosshair();
+ });
+
+ pointer.hoverX = chart.hoverPoints = chart.hoverPoint = null;
+
+ }
+ },
+
+ /**
+ * Scale series groups to a certain scale and translation
+ */
+ scaleGroups: function (attribs, clip) {
+
+ var chart = this.chart,
+ seriesAttribs;
+
+ // Scale each series
+ each(chart.series, function (series) {
+ seriesAttribs = attribs || series.getPlotBox(); // #1701
+ if (series.xAxis && series.xAxis.zoomEnabled) {
+ series.group.attr(seriesAttribs);
+ if (series.markerGroup) {
+ series.markerGroup.attr(seriesAttribs);
+ series.markerGroup.clip(clip ? chart.clipRect : null);
+ }
+ if (series.dataLabelsGroup) {
+ series.dataLabelsGroup.attr(seriesAttribs);
+ }
+ }
+ });
+
+ // Clip
+ chart.clipRect.attr(clip || chart.clipBox);
+ },
+
+ /**
+ * Start a drag operation
+ */
+ dragStart: function (e) {
+ var chart = this.chart;
+
+ // Record the start position
+ chart.mouseIsDown = e.type;
+ chart.cancelClick = false;
+ chart.mouseDownX = this.mouseDownX = e.chartX;
+ chart.mouseDownY = this.mouseDownY = e.chartY;
+ },
+
+ /**
+ * Perform a drag operation in response to a mousemove event while the mouse is down
+ */
+ drag: function (e) {
+
+ var chart = this.chart,
+ chartOptions = chart.options.chart,
+ chartX = e.chartX,
+ chartY = e.chartY,
+ zoomHor = this.zoomHor,
+ zoomVert = this.zoomVert,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop,
+ plotWidth = chart.plotWidth,
+ plotHeight = chart.plotHeight,
+ clickedInside,
+ size,
+ selectionMarker = this.selectionMarker,
+ mouseDownX = this.mouseDownX,
+ mouseDownY = this.mouseDownY,
+ panKey = chartOptions.panKey && e[chartOptions.panKey + 'Key'];
+
+ // If the device supports both touch and mouse (like IE11), and we are touch-dragging
+ // inside the plot area, don't handle the mouse event. #4339.
+ if (selectionMarker && selectionMarker.touch) {
+ return;
+ }
+
+ // If the mouse is outside the plot area, adjust to cooordinates
+ // inside to prevent the selection marker from going outside
+ if (chartX < plotLeft) {
+ chartX = plotLeft;
+ } else if (chartX > plotLeft + plotWidth) {
+ chartX = plotLeft + plotWidth;
+ }
+
+ if (chartY < plotTop) {
+ chartY = plotTop;
+ } else if (chartY > plotTop + plotHeight) {
+ chartY = plotTop + plotHeight;
+ }
+
+ // determine if the mouse has moved more than 10px
+ this.hasDragged = Math.sqrt(
+ Math.pow(mouseDownX - chartX, 2) +
+ Math.pow(mouseDownY - chartY, 2)
+ );
+
+ if (this.hasDragged > 10) {
+ clickedInside = chart.isInsidePlot(mouseDownX - plotLeft, mouseDownY - plotTop);
+
+ // make a selection
+ if (chart.hasCartesianSeries && (this.zoomX || this.zoomY) && clickedInside && !panKey) {
+ if (!selectionMarker) {
+ this.selectionMarker = selectionMarker = chart.renderer.rect(
+ plotLeft,
+ plotTop,
+ zoomHor ? 1 : plotWidth,
+ zoomVert ? 1 : plotHeight,
+ 0
+ )
+ .attr({
+ fill: chartOptions.selectionMarkerFill || 'rgba(69,114,167,0.25)',
+ zIndex: 7
+ })
+ .add();
+ }
+ }
+
+ // adjust the width of the selection marker
+ if (selectionMarker && zoomHor) {
+ size = chartX - mouseDownX;
+ selectionMarker.attr({
+ width: mathAbs(size),
+ x: (size > 0 ? 0 : size) + mouseDownX
+ });
+ }
+ // adjust the height of the selection marker
+ if (selectionMarker && zoomVert) {
+ size = chartY - mouseDownY;
+ selectionMarker.attr({
+ height: mathAbs(size),
+ y: (size > 0 ? 0 : size) + mouseDownY
+ });
+ }
+
+ // panning
+ if (clickedInside && !selectionMarker && chartOptions.panning) {
+ chart.pan(e, chartOptions.panning);
+ }
+ }
+ },
+
+ /**
+ * On mouse up or touch end across the entire document, drop the selection.
+ */
+ drop: function (e) {
+ var pointer = this,
+ chart = this.chart,
+ hasPinched = this.hasPinched;
+
+ if (this.selectionMarker) {
+ var selectionData = {
+ xAxis: [],
+ yAxis: [],
+ originalEvent: e.originalEvent || e
+ },
+ selectionBox = this.selectionMarker,
+ selectionLeft = selectionBox.attr ? selectionBox.attr('x') : selectionBox.x,
+ selectionTop = selectionBox.attr ? selectionBox.attr('y') : selectionBox.y,
+ selectionWidth = selectionBox.attr ? selectionBox.attr('width') : selectionBox.width,
+ selectionHeight = selectionBox.attr ? selectionBox.attr('height') : selectionBox.height,
+ runZoom;
+
+ // a selection has been made
+ if (this.hasDragged || hasPinched) {
+
+ // record each axis' min and max
+ each(chart.axes, function (axis) {
+ if (axis.zoomEnabled && defined(axis.min) && (hasPinched || pointer[{ xAxis: 'zoomX', yAxis: 'zoomY' }[axis.coll]])) { // #859, #3569
+ var horiz = axis.horiz,
+ minPixelPadding = e.type === 'touchend' ? axis.minPixelPadding: 0, // #1207, #3075
+ selectionMin = axis.toValue((horiz ? selectionLeft : selectionTop) + minPixelPadding),
+ selectionMax = axis.toValue((horiz ? selectionLeft + selectionWidth : selectionTop + selectionHeight) - minPixelPadding);
+
+ selectionData[axis.coll].push({
+ axis: axis,
+ min: mathMin(selectionMin, selectionMax), // for reversed axes
+ max: mathMax(selectionMin, selectionMax)
+ });
+ runZoom = true;
+ }
+ });
+ if (runZoom) {
+ fireEvent(chart, 'selection', selectionData, function (args) {
+ chart.zoom(extend(args, hasPinched ? { animation: false } : null));
+ });
+ }
+
+ }
+ this.selectionMarker = this.selectionMarker.destroy();
+
+ // Reset scaling preview
+ if (hasPinched) {
+ this.scaleGroups();
+ }
+ }
+
+ // Reset all
+ if (chart) { // it may be destroyed on mouse up - #877
+ css(chart.container, { cursor: chart._cursor });
+ chart.cancelClick = this.hasDragged > 10; // #370
+ chart.mouseIsDown = this.hasDragged = this.hasPinched = false;
+ this.pinchDown = [];
+ }
+ },
+
+ onContainerMouseDown: function (e) {
+
+ e = this.normalize(e);
+
+ // issue #295, dragging not always working in Firefox
+ if (e.preventDefault) {
+ e.preventDefault();
+ }
+
+ this.dragStart(e);
+ },
+
+
+
+ onDocumentMouseUp: function (e) {
+ if (charts[hoverChartIndex]) {
+ charts[hoverChartIndex].pointer.drop(e);
+ }
+ },
+
+ /**
+ * Special handler for mouse move that will hide the tooltip when the mouse leaves the plotarea.
+ * Issue #149 workaround. The mouseleave event does not always fire.
+ */
+ onDocumentMouseMove: function (e) {
+ var chart = this.chart,
+ chartPosition = this.chartPosition;
+
+ e = this.normalize(e, chartPosition);
+
+ // If we're outside, hide the tooltip
+ if (chartPosition && !this.inClass(e.target, 'highcharts-tracker') &&
+ !chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
+ this.reset();
+ }
+ },
+
+ /**
+ * When mouse leaves the container, hide the tooltip.
+ */
+ onContainerMouseLeave: function () {
+ var chart = charts[hoverChartIndex];
+ if (chart) {
+ chart.pointer.reset();
+ chart.pointer.chartPosition = null; // also reset the chart position, used in #149 fix
+ }
+ },
+
+ // The mousemove, touchmove and touchstart event handler
+ onContainerMouseMove: function (e) {
+
+ var chart = this.chart;
+
+ hoverChartIndex = chart.index;
+
+ e = this.normalize(e);
+ e.returnValue = false; // #2251, #3224
+
+ if (chart.mouseIsDown === 'mousedown') {
+ this.drag(e);
+ }
+
+ // Show the tooltip and run mouse over events (#977)
+ if ((this.inClass(e.target, 'highcharts-tracker') ||
+ chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) && !chart.openMenu) {
+ this.runPointActions(e);
+ }
+ },
+
+ /**
+ * Utility to detect whether an element has, or has a parent with, a specific
+ * class name. Used on detection of tracker objects and on deciding whether
+ * hovering the tooltip should cause the active series to mouse out.
+ */
+ inClass: function (element, className) {
+ var elemClassName;
+ while (element) {
+ elemClassName = attr(element, 'class');
+ if (elemClassName) {
+ if (elemClassName.indexOf(className) !== -1) {
+ return true;
+ } else if (elemClassName.indexOf(PREFIX + 'container') !== -1) {
+ return false;
+ }
+ }
+ element = element.parentNode;
+ }
+ },
+
+ onTrackerMouseOut: function (e) {
+ var series = this.chart.hoverSeries,
+ relatedTarget = e.relatedTarget || e.toElement;
+
+ if (series && !series.options.stickyTracking &&
+ !this.inClass(relatedTarget, PREFIX + 'tooltip') &&
+ !this.inClass(relatedTarget, PREFIX + 'series-' + series.index)) { // #2499, #4465
+ series.onMouseOut();
+ }
+ },
+
+ onContainerClick: function (e) {
+ var chart = this.chart,
+ hoverPoint = chart.hoverPoint,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop;
+
+ e = this.normalize(e);
+ e.originalEvent = e; // #3913
+
+ if (!chart.cancelClick) {
+
+ // On tracker click, fire the series and point events. #783, #1583
+ if (hoverPoint && this.inClass(e.target, PREFIX + 'tracker')) {
+
+ // the series click event
+ fireEvent(hoverPoint.series, 'click', extend(e, {
+ point: hoverPoint
+ }));
+
+ // the point click event
+ if (chart.hoverPoint) { // it may be destroyed (#1844)
+ hoverPoint.firePointEvent('click', e);
+ }
+
+ // When clicking outside a tracker, fire a chart event
+ } else {
+ extend(e, this.getCoordinates(e));
+
+ // fire a click event in the chart
+ if (chart.isInsidePlot(e.chartX - plotLeft, e.chartY - plotTop)) {
+ fireEvent(chart, 'click', e);
+ }
+ }
+
+
+ }
+ },
+
+ /**
+ * Set the JS DOM events on the container and document. This method should contain
+ * a one-to-one assignment between methods and their handlers. Any advanced logic should
+ * be moved to the handler reflecting the event's name.
+ */
+ setDOMEvents: function () {
+
+ var pointer = this,
+ container = pointer.chart.container;
+
+ container.onmousedown = function (e) {
+ pointer.onContainerMouseDown(e);
+ };
+ container.onmousemove = function (e) {
+ pointer.onContainerMouseMove(e);
+ };
+ container.onclick = function (e) {
+ pointer.onContainerClick(e);
+ };
+ addEvent(container, 'mouseleave', pointer.onContainerMouseLeave);
+ if (chartCount === 1) {
+ addEvent(doc, 'mouseup', pointer.onDocumentMouseUp);
+ }
+ if (hasTouch) {
+ container.ontouchstart = function (e) {
+ pointer.onContainerTouchStart(e);
+ };
+ container.ontouchmove = function (e) {
+ pointer.onContainerTouchMove(e);
+ };
+ if (chartCount === 1) {
+ addEvent(doc, 'touchend', pointer.onDocumentTouchEnd);
+ }
+ }
+
+ },
+
+ /**
+ * Destroys the Pointer object and disconnects DOM events.
+ */
+ destroy: function () {
+ var prop;
+
+ removeEvent(this.chart.container, 'mouseleave', this.onContainerMouseLeave);
+ if (!chartCount) {
+ removeEvent(doc, 'mouseup', this.onDocumentMouseUp);
+ removeEvent(doc, 'touchend', this.onDocumentTouchEnd);
+ }
+
+ // memory and CPU leak
+ clearInterval(this.tooltipTimeout);
+
+ for (prop in this) {
+ this[prop] = null;
+ }
+ }
+};
+
+
+
+
+/* Support for touch devices */
+extend(Highcharts.Pointer.prototype, {
+
+ /**
+ * Run translation operations
+ */
+ pinchTranslate: function (pinchDown, touches, transform, selectionMarker, clip, lastValidTouch) {
+ if (this.zoomHor || this.pinchHor) {
+ this.pinchTranslateDirection(true, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch);
+ }
+ if (this.zoomVert || this.pinchVert) {
+ this.pinchTranslateDirection(false, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch);
+ }
+ },
+
+ /**
+ * Run translation operations for each direction (horizontal and vertical) independently
+ */
+ pinchTranslateDirection: function (horiz, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch, forcedScale) {
+ var chart = this.chart,
+ xy = horiz ? 'x' : 'y',
+ XY = horiz ? 'X' : 'Y',
+ sChartXY = 'chart' + XY,
+ wh = horiz ? 'width' : 'height',
+ plotLeftTop = chart['plot' + (horiz ? 'Left' : 'Top')],
+ selectionWH,
+ selectionXY,
+ clipXY,
+ scale = forcedScale || 1,
+ inverted = chart.inverted,
+ bounds = chart.bounds[horiz ? 'h' : 'v'],
+ singleTouch = pinchDown.length === 1,
+ touch0Start = pinchDown[0][sChartXY],
+ touch0Now = touches[0][sChartXY],
+ touch1Start = !singleTouch && pinchDown[1][sChartXY],
+ touch1Now = !singleTouch && touches[1][sChartXY],
+ outOfBounds,
+ transformScale,
+ scaleKey,
+ setScale = function () {
+ if (!singleTouch && mathAbs(touch0Start - touch1Start) > 20) { // Don't zoom if fingers are too close on this axis
+ scale = forcedScale || mathAbs(touch0Now - touch1Now) / mathAbs(touch0Start - touch1Start);
+ }
+
+ clipXY = ((plotLeftTop - touch0Now) / scale) + touch0Start;
+ selectionWH = chart['plot' + (horiz ? 'Width' : 'Height')] / scale;
+ };
+
+ // Set the scale, first pass
+ setScale();
+
+ selectionXY = clipXY; // the clip position (x or y) is altered if out of bounds, the selection position is not
+
+ // Out of bounds
+ if (selectionXY < bounds.min) {
+ selectionXY = bounds.min;
+ outOfBounds = true;
+ } else if (selectionXY + selectionWH > bounds.max) {
+ selectionXY = bounds.max - selectionWH;
+ outOfBounds = true;
+ }
+
+ // Is the chart dragged off its bounds, determined by dataMin and dataMax?
+ if (outOfBounds) {
+
+ // Modify the touchNow position in order to create an elastic drag movement. This indicates
+ // to the user that the chart is responsive but can't be dragged further.
+ touch0Now -= 0.8 * (touch0Now - lastValidTouch[xy][0]);
+ if (!singleTouch) {
+ touch1Now -= 0.8 * (touch1Now - lastValidTouch[xy][1]);
+ }
+
+ // Set the scale, second pass to adapt to the modified touchNow positions
+ setScale();
+
+ } else {
+ lastValidTouch[xy] = [touch0Now, touch1Now];
+ }
+
+ // Set geometry for clipping, selection and transformation
+ if (!inverted) { // TODO: implement clipping for inverted charts
+ clip[xy] = clipXY - plotLeftTop;
+ clip[wh] = selectionWH;
+ }
+ scaleKey = inverted ? (horiz ? 'scaleY' : 'scaleX') : 'scale' + XY;
+ transformScale = inverted ? 1 / scale : scale;
+
+ selectionMarker[wh] = selectionWH;
+ selectionMarker[xy] = selectionXY;
+ transform[scaleKey] = scale;
+ transform['translate' + XY] = (transformScale * plotLeftTop) + (touch0Now - (transformScale * touch0Start));
+ },
+
+ /**
+ * Handle touch events with two touches
+ */
+ pinch: function (e) {
+
+ var self = this,
+ chart = self.chart,
+ pinchDown = self.pinchDown,
+ touches = e.touches,
+ touchesLength = touches.length,
+ lastValidTouch = self.lastValidTouch,
+ hasZoom = self.hasZoom,
+ selectionMarker = self.selectionMarker,
+ transform = {},
+ fireClickEvent = touchesLength === 1 && ((self.inClass(e.target, PREFIX + 'tracker') &&
+ chart.runTrackerClick) || self.runChartClick),
+ clip = {};
+
+ // Don't initiate panning until the user has pinched. This prevents us from
+ // blocking page scrolling as users scroll down a long page (#4210).
+ if (touchesLength > 1) {
+ self.initiated = true;
+ }
+
+ // On touch devices, only proceed to trigger click if a handler is defined
+ if (hasZoom && self.initiated && !fireClickEvent) {
+ e.preventDefault();
+ }
+
+ // Normalize each touch
+ map(touches, function (e) {
+ return self.normalize(e);
+ });
+
+ // Register the touch start position
+ if (e.type === 'touchstart') {
+ each(touches, function (e, i) {
+ pinchDown[i] = { chartX: e.chartX, chartY: e.chartY };
+ });
+ lastValidTouch.x = [pinchDown[0].chartX, pinchDown[1] && pinchDown[1].chartX];
+ lastValidTouch.y = [pinchDown[0].chartY, pinchDown[1] && pinchDown[1].chartY];
+
+ // Identify the data bounds in pixels
+ each(chart.axes, function (axis) {
+ if (axis.zoomEnabled) {
+ var bounds = chart.bounds[axis.horiz ? 'h' : 'v'],
+ minPixelPadding = axis.minPixelPadding,
+ min = axis.toPixels(pick(axis.options.min, axis.dataMin)),
+ max = axis.toPixels(pick(axis.options.max, axis.dataMax)),
+ absMin = mathMin(min, max),
+ absMax = mathMax(min, max);
+
+ // Store the bounds for use in the touchmove handler
+ bounds.min = mathMin(axis.pos, absMin - minPixelPadding);
+ bounds.max = mathMax(axis.pos + axis.len, absMax + minPixelPadding);
+ }
+ });
+ self.res = true; // reset on next move
+
+ // Event type is touchmove, handle panning and pinching
+ } else if (pinchDown.length) { // can be 0 when releasing, if touchend fires first
+
+
+ // Set the marker
+ if (!selectionMarker) {
+ self.selectionMarker = selectionMarker = extend({
+ destroy: noop,
+ touch: true
+ }, chart.plotBox);
+ }
+
+ self.pinchTranslate(pinchDown, touches, transform, selectionMarker, clip, lastValidTouch);
+
+ self.hasPinched = hasZoom;
+
+ // Scale and translate the groups to provide visual feedback during pinching
+ self.scaleGroups(transform, clip);
+
+ // Optionally move the tooltip on touchmove
+ if (!hasZoom && self.followTouchMove && touchesLength === 1) {
+ this.runPointActions(self.normalize(e));
+ } else if (self.res) {
+ self.res = false;
+ this.reset(false, 0);
+ }
+ }
+ },
+
+ /**
+ * General touch handler shared by touchstart and touchmove.
+ */
+ touch: function (e, start) {
+ var chart = this.chart;
+
+ hoverChartIndex = chart.index;
+
+ if (e.touches.length === 1) {
+
+ e = this.normalize(e);
+
+ if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop) && !chart.openMenu) {
+
+ // Run mouse events and display tooltip etc
+ if (start) {
+ this.runPointActions(e);
+ }
+
+ this.pinch(e);
+
+ } else if (start) {
+ // Hide the tooltip on touching outside the plot area (#1203)
+ this.reset();
+ }
+
+ } else if (e.touches.length === 2) {
+ this.pinch(e);
+ }
+ },
+
+ onContainerTouchStart: function (e) {
+ this.touch(e, true);
+ },
+
+ onContainerTouchMove: function (e) {
+ this.touch(e);
+ },
+
+ onDocumentTouchEnd: function (e) {
+ if (charts[hoverChartIndex]) {
+ charts[hoverChartIndex].pointer.drop(e);
+ }
+ }
+
+});
+
+
+if (win.PointerEvent || win.MSPointerEvent) {
+
+ // The touches object keeps track of the points being touched at all times
+ var touches = {},
+ hasPointerEvent = !!win.PointerEvent,
+ getWebkitTouches = function () {
+ var key, fake = [];
+ fake.item = function (i) { return this[i]; };
+ for (key in touches) {
+ if (touches.hasOwnProperty(key)) {
+ fake.push({
+ pageX: touches[key].pageX,
+ pageY: touches[key].pageY,
+ target: touches[key].target
+ });
+ }
+ }
+ return fake;
+ },
+ translateMSPointer = function (e, method, wktype, callback) {
+ var p;
+ e = e.originalEvent || e;
+ if ((e.pointerType === 'touch' || e.pointerType === e.MSPOINTER_TYPE_TOUCH) && charts[hoverChartIndex]) {
+ callback(e);
+ p = charts[hoverChartIndex].pointer;
+ p[method]({
+ type: wktype,
+ target: e.currentTarget,
+ preventDefault: noop,
+ touches: getWebkitTouches()
+ });
+ }
+ };
+
+ /**
+ * Extend the Pointer prototype with methods for each event handler and more
+ */
+ extend(Pointer.prototype, {
+ onContainerPointerDown: function (e) {
+ translateMSPointer(e, 'onContainerTouchStart', 'touchstart', function (e) {
+ touches[e.pointerId] = { pageX: e.pageX, pageY: e.pageY, target: e.currentTarget };
+ });
+ },
+ onContainerPointerMove: function (e) {
+ translateMSPointer(e, 'onContainerTouchMove', 'touchmove', function (e) {
+ touches[e.pointerId] = { pageX: e.pageX, pageY: e.pageY };
+ if (!touches[e.pointerId].target) {
+ touches[e.pointerId].target = e.currentTarget;
+ }
+ });
+ },
+ onDocumentPointerUp: function (e) {
+ translateMSPointer(e, 'onDocumentTouchEnd', 'touchend', function (e) {
+ delete touches[e.pointerId];
+ });
+ },
+
+ /**
+ * Add or remove the MS Pointer specific events
+ */
+ batchMSEvents: function (fn) {
+ fn(this.chart.container, hasPointerEvent ? 'pointerdown' : 'MSPointerDown', this.onContainerPointerDown);
+ fn(this.chart.container, hasPointerEvent ? 'pointermove' : 'MSPointerMove', this.onContainerPointerMove);
+ fn(doc, hasPointerEvent ? 'pointerup' : 'MSPointerUp', this.onDocumentPointerUp);
+ }
+ });
+
+ // Disable default IE actions for pinch and such on chart element
+ wrap(Pointer.prototype, 'init', function (proceed, chart, options) {
+ proceed.call(this, chart, options);
+ if (this.hasZoom) { // #4014
+ css(chart.container, {
+ '-ms-touch-action': NONE,
+ 'touch-action': NONE
+ });
+ }
+ });
+
+ // Add IE specific touch events to chart
+ wrap(Pointer.prototype, 'setDOMEvents', function (proceed) {
+ proceed.apply(this);
+ if (this.hasZoom || this.followTouchMove) {
+ this.batchMSEvents(addEvent);
+ }
+ });
+ // Destroy MS events also
+ wrap(Pointer.prototype, 'destroy', function (proceed) {
+ this.batchMSEvents(removeEvent);
+ proceed.call(this);
+ });
+}
+
+
+/**
+ * The overview of the chart's series
+ */
+var Legend = Highcharts.Legend = function (chart, options) {
+ this.init(chart, options);
+};
+
+Legend.prototype = {
+
+ /**
+ * Initialize the legend
+ */
+ init: function (chart, options) {
+
+ var legend = this,
+ itemStyle = options.itemStyle,
+ padding,
+ itemMarginTop = options.itemMarginTop || 0;
+
+ this.options = options;
+
+ if (!options.enabled) {
+ return;
+ }
+
+ legend.itemStyle = itemStyle;
+ legend.itemHiddenStyle = merge(itemStyle, options.itemHiddenStyle);
+ legend.itemMarginTop = itemMarginTop;
+ legend.padding = padding = pick(options.padding, 8);
+ legend.initialItemX = padding;
+ legend.initialItemY = padding - 5; // 5 is the number of pixels above the text
+ legend.maxItemWidth = 0;
+ legend.chart = chart;
+ legend.itemHeight = 0;
+ legend.symbolWidth = pick(options.symbolWidth, 16);
+ legend.pages = [];
+
+
+ // Render it
+ legend.render();
+
+ // move checkboxes
+ addEvent(legend.chart, 'endResize', function () {
+ legend.positionCheckboxes();
+ });
+
+ },
+
+ /**
+ * Set the colors for the legend item
+ * @param {Object} item A Series or Point instance
+ * @param {Object} visible Dimmed or colored
+ */
+ colorizeItem: function (item, visible) {
+ var legend = this,
+ options = legend.options,
+ legendItem = item.legendItem,
+ legendLine = item.legendLine,
+ legendSymbol = item.legendSymbol,
+ hiddenColor = legend.itemHiddenStyle.color,
+ textColor = visible ? options.itemStyle.color : hiddenColor,
+ symbolColor = visible ? (item.legendColor || item.color || '#CCC') : hiddenColor,
+ markerOptions = item.options && item.options.marker,
+ symbolAttr = { fill: symbolColor },
+ key,
+ val;
+
+ if (legendItem) {
+ legendItem.css({ fill: textColor, color: textColor }); // color for #1553, oldIE
+ }
+ if (legendLine) {
+ legendLine.attr({ stroke: symbolColor });
+ }
+
+ if (legendSymbol) {
+
+ // Apply marker options
+ if (markerOptions && legendSymbol.isMarker) { // #585
+ symbolAttr.stroke = symbolColor;
+ markerOptions = item.convertAttribs(markerOptions);
+ for (key in markerOptions) {
+ val = markerOptions[key];
+ if (val !== UNDEFINED) {
+ symbolAttr[key] = val;
+ }
+ }
+ }
+
+ legendSymbol.attr(symbolAttr);
+ }
+ },
+
+ /**
+ * Position the legend item
+ * @param {Object} item A Series or Point instance
+ */
+ positionItem: function (item) {
+ var legend = this,
+ options = legend.options,
+ symbolPadding = options.symbolPadding,
+ ltr = !options.rtl,
+ legendItemPos = item._legendItemPos,
+ itemX = legendItemPos[0],
+ itemY = legendItemPos[1],
+ checkbox = item.checkbox,
+ legendGroup = item.legendGroup;
+
+ if (legendGroup && legendGroup.element) {
+ legendGroup.translate(
+ ltr ? itemX : legend.legendWidth - itemX - 2 * symbolPadding - 4,
+ itemY
+ );
+ }
+
+ if (checkbox) {
+ checkbox.x = itemX;
+ checkbox.y = itemY;
+ }
+ },
+
+ /**
+ * Destroy a single legend item
+ * @param {Object} item The series or point
+ */
+ destroyItem: function (item) {
+ var checkbox = item.checkbox;
+
+ // destroy SVG elements
+ each(['legendItem', 'legendLine', 'legendSymbol', 'legendGroup'], function (key) {
+ if (item[key]) {
+ item[key] = item[key].destroy();
+ }
+ });
+
+ if (checkbox) {
+ discardElement(item.checkbox);
+ }
+ },
+
+ /**
+ * Destroys the legend.
+ */
+ destroy: function () {
+ var legend = this,
+ legendGroup = legend.group,
+ box = legend.box;
+
+ if (box) {
+ legend.box = box.destroy();
+ }
+
+ if (legendGroup) {
+ legend.group = legendGroup.destroy();
+ }
+ },
+
+ /**
+ * Position the checkboxes after the width is determined
+ */
+ positionCheckboxes: function (scrollOffset) {
+ var alignAttr = this.group.alignAttr,
+ translateY,
+ clipHeight = this.clipHeight || this.legendHeight;
+
+ if (alignAttr) {
+ translateY = alignAttr.translateY;
+ each(this.allItems, function (item) {
+ var checkbox = item.checkbox,
+ top;
+
+ if (checkbox) {
+ top = (translateY + checkbox.y + (scrollOffset || 0) + 3);
+ css(checkbox, {
+ left: (alignAttr.translateX + item.checkboxOffset + checkbox.x - 20) + PX,
+ top: top + PX,
+ display: top > translateY - 6 && top < translateY + clipHeight - 6 ? '' : NONE
+ });
+ }
+ });
+ }
+ },
+
+ /**
+ * Render the legend title on top of the legend
+ */
+ renderTitle: function () {
+ var options = this.options,
+ padding = this.padding,
+ titleOptions = options.title,
+ titleHeight = 0,
+ bBox;
+
+ if (titleOptions.text) {
+ if (!this.title) {
+ this.title = this.chart.renderer.label(titleOptions.text, padding - 3, padding - 4, null, null, null, null, null, 'legend-title')
+ .attr({ zIndex: 1 })
+ .css(titleOptions.style)
+ .add(this.group);
+ }
+ bBox = this.title.getBBox();
+ titleHeight = bBox.height;
+ this.offsetWidth = bBox.width; // #1717
+ this.contentGroup.attr({ translateY: titleHeight });
+ }
+ this.titleHeight = titleHeight;
+ },
+
+ /**
+ * Set the legend item text
+ */
+ setText: function (item) {
+ var options = this.options;
+ item.legendItem.attr({
+ text: options.labelFormat ? format(options.labelFormat, item) : options.labelFormatter.call(item)
+ });
+ },
+
+ /**
+ * Render a single specific legend item
+ * @param {Object} item A series or point
+ */
+ renderItem: function (item) {
+ var legend = this,
+ chart = legend.chart,
+ renderer = chart.renderer,
+ options = legend.options,
+ horizontal = options.layout === 'horizontal',
+ symbolWidth = legend.symbolWidth,
+ symbolPadding = options.symbolPadding,
+ itemStyle = legend.itemStyle,
+ itemHiddenStyle = legend.itemHiddenStyle,
+ padding = legend.padding,
+ itemDistance = horizontal ? pick(options.itemDistance, 20) : 0,
+ ltr = !options.rtl,
+ itemHeight,
+ widthOption = options.width,
+ itemMarginBottom = options.itemMarginBottom || 0,
+ itemMarginTop = legend.itemMarginTop,
+ initialItemX = legend.initialItemX,
+ bBox,
+ itemWidth,
+ li = item.legendItem,
+ series = item.series && item.series.drawLegendSymbol ? item.series : item,
+ seriesOptions = series.options,
+ showCheckbox = legend.createCheckboxForItem && seriesOptions && seriesOptions.showCheckbox,
+ useHTML = options.useHTML;
+
+ if (!li) { // generate it once, later move it
+
+ // Generate the group box
+ // A group to hold the symbol and text. Text is to be appended in Legend class.
+ item.legendGroup = renderer.g('legend-item')
+ .attr({ zIndex: 1 })
+ .add(legend.scrollGroup);
+
+ // Generate the list item text and add it to the group
+ item.legendItem = li = renderer.text(
+ '',
+ ltr ? symbolWidth + symbolPadding : -symbolPadding,
+ legend.baseline || 0,
+ useHTML
+ )
+ .css(merge(item.visible ? itemStyle : itemHiddenStyle)) // merge to prevent modifying original (#1021)
+ .attr({
+ align: ltr ? 'left' : 'right',
+ zIndex: 2
+ })
+ .add(item.legendGroup);
+
+ // Get the baseline for the first item - the font size is equal for all
+ if (!legend.baseline) {
+ legend.fontMetrics = renderer.fontMetrics(itemStyle.fontSize, li);
+ legend.baseline = legend.fontMetrics.f + 3 + itemMarginTop;
+ li.attr('y', legend.baseline);
+ }
+
+ // Draw the legend symbol inside the group box
+ series.drawLegendSymbol(legend, item);
+
+ if (legend.setItemEvents) {
+ legend.setItemEvents(item, li, useHTML, itemStyle, itemHiddenStyle);
+ }
+
+ // Colorize the items
+ legend.colorizeItem(item, item.visible);
+
+ // add the HTML checkbox on top
+ if (showCheckbox) {
+ legend.createCheckboxForItem(item);
+ }
+ }
+
+ // Always update the text
+ legend.setText(item);
+
+ // calculate the positions for the next line
+ bBox = li.getBBox();
+
+ itemWidth = item.checkboxOffset =
+ options.itemWidth ||
+ item.legendItemWidth ||
+ symbolWidth + symbolPadding + bBox.width + itemDistance + (showCheckbox ? 20 : 0);
+ legend.itemHeight = itemHeight = mathRound(item.legendItemHeight || bBox.height);
+
+ // if the item exceeds the width, start a new line
+ if (horizontal && legend.itemX - initialItemX + itemWidth >
+ (widthOption || (chart.chartWidth - 2 * padding - initialItemX - options.x))) {
+ legend.itemX = initialItemX;
+ legend.itemY += itemMarginTop + legend.lastLineHeight + itemMarginBottom;
+ legend.lastLineHeight = 0; // reset for next line (#915, #3976)
+ }
+
+ // If the item exceeds the height, start a new column
+ /*if (!horizontal && legend.itemY + options.y + itemHeight > chart.chartHeight - spacingTop - spacingBottom) {
+ legend.itemY = legend.initialItemY;
+ legend.itemX += legend.maxItemWidth;
+ legend.maxItemWidth = 0;
+ }*/
+
+ // Set the edge positions
+ legend.maxItemWidth = mathMax(legend.maxItemWidth, itemWidth);
+ legend.lastItemY = itemMarginTop + legend.itemY + itemMarginBottom;
+ legend.lastLineHeight = mathMax(itemHeight, legend.lastLineHeight); // #915
+
+ // cache the position of the newly generated or reordered items
+ item._legendItemPos = [legend.itemX, legend.itemY];
+
+ // advance
+ if (horizontal) {
+ legend.itemX += itemWidth;
+
+ } else {
+ legend.itemY += itemMarginTop + itemHeight + itemMarginBottom;
+ legend.lastLineHeight = itemHeight;
+ }
+
+ // the width of the widest item
+ legend.offsetWidth = widthOption || mathMax(
+ (horizontal ? legend.itemX - initialItemX - itemDistance : itemWidth) + padding,
+ legend.offsetWidth
+ );
+ },
+
+ /**
+ * Get all items, which is one item per series for normal series and one item per point
+ * for pie series.
+ */
+ getAllItems: function () {
+ var allItems = [];
+ each(this.chart.series, function (series) {
+ var seriesOptions = series.options;
+
+ // Handle showInLegend. If the series is linked to another series, defaults to false.
+ if (!pick(seriesOptions.showInLegend, !defined(seriesOptions.linkedTo) ? UNDEFINED : false, true)) {
+ return;
+ }
+
+ // use points or series for the legend item depending on legendType
+ allItems = allItems.concat(
+ series.legendItems ||
+ (seriesOptions.legendType === 'point' ?
+ series.data :
+ series)
+ );
+ });
+ return allItems;
+ },
+
+ /**
+ * Adjust the chart margins by reserving space for the legend on only one side
+ * of the chart. If the position is set to a corner, top or bottom is reserved
+ * for horizontal legends and left or right for vertical ones.
+ */
+ adjustMargins: function (margin, spacing) {
+ var chart = this.chart,
+ options = this.options,
+ // Use the first letter of each alignment option in order to detect the side
+ alignment = options.align.charAt(0) + options.verticalAlign.charAt(0) + options.layout.charAt(0); // #4189 - use charAt(x) notation instead of [x] for IE7
+
+ if (this.display && !options.floating) {
+
+ each([
+ /(lth|ct|rth)/,
+ /(rtv|rm|rbv)/,
+ /(rbh|cb|lbh)/,
+ /(lbv|lm|ltv)/
+ ], function (alignments, side) {
+ if (alignments.test(alignment) && !defined(margin[side])) {
+ // Now we have detected on which side of the chart we should reserve space for the legend
+ chart[marginNames[side]] = mathMax(
+ chart[marginNames[side]],
+ chart.legend[(side + 1) % 2 ? 'legendHeight' : 'legendWidth'] +
+ [1, -1, -1, 1][side] * options[(side % 2) ? 'x' : 'y'] +
+ pick(options.margin, 12) +
+ spacing[side]
+ );
+ }
+ });
+ }
+ },
+
+ /**
+ * Render the legend. This method can be called both before and after
+ * chart.render. If called after, it will only rearrange items instead
+ * of creating new ones.
+ */
+ render: function () {
+ var legend = this,
+ chart = legend.chart,
+ renderer = chart.renderer,
+ legendGroup = legend.group,
+ allItems,
+ display,
+ legendWidth,
+ legendHeight,
+ box = legend.box,
+ options = legend.options,
+ padding = legend.padding,
+ legendBorderWidth = options.borderWidth,
+ legendBackgroundColor = options.backgroundColor;
+
+ legend.itemX = legend.initialItemX;
+ legend.itemY = legend.initialItemY;
+ legend.offsetWidth = 0;
+ legend.lastItemY = 0;
+
+ if (!legendGroup) {
+ legend.group = legendGroup = renderer.g('legend')
+ .attr({ zIndex: 7 })
+ .add();
+ legend.contentGroup = renderer.g()
+ .attr({ zIndex: 1 }) // above background
+ .add(legendGroup);
+ legend.scrollGroup = renderer.g()
+ .add(legend.contentGroup);
+ }
+
+ legend.renderTitle();
+
+ // add each series or point
+ allItems = legend.getAllItems();
+
+ // sort by legendIndex
+ stableSort(allItems, function (a, b) {
+ return ((a.options && a.options.legendIndex) || 0) - ((b.options && b.options.legendIndex) || 0);
+ });
+
+ // reversed legend
+ if (options.reversed) {
+ allItems.reverse();
+ }
+
+ legend.allItems = allItems;
+ legend.display = display = !!allItems.length;
+
+ // render the items
+ legend.lastLineHeight = 0;
+ each(allItems, function (item) {
+ legend.renderItem(item);
+ });
+
+ // Get the box
+ legendWidth = (options.width || legend.offsetWidth) + padding;
+ legendHeight = legend.lastItemY + legend.lastLineHeight + legend.titleHeight;
+ legendHeight = legend.handleOverflow(legendHeight);
+ legendHeight += padding;
+
+ // Draw the border and/or background
+ if (legendBorderWidth || legendBackgroundColor) {
+
+ if (!box) {
+ legend.box = box = renderer.rect(
+ 0,
+ 0,
+ legendWidth,
+ legendHeight,
+ options.borderRadius,
+ legendBorderWidth || 0
+ ).attr({
+ stroke: options.borderColor,
+ 'stroke-width': legendBorderWidth || 0,
+ fill: legendBackgroundColor || NONE
+ })
+ .add(legendGroup)
+ .shadow(options.shadow);
+ box.isNew = true;
+
+ } else if (legendWidth > 0 && legendHeight > 0) {
+ box[box.isNew ? 'attr' : 'animate'](
+ box.crisp({ width: legendWidth, height: legendHeight })
+ );
+ box.isNew = false;
+ }
+
+ // hide the border if no items
+ box[display ? 'show' : 'hide']();
+ }
+
+ legend.legendWidth = legendWidth;
+ legend.legendHeight = legendHeight;
+
+ // Now that the legend width and height are established, put the items in the
+ // final position
+ each(allItems, function (item) {
+ legend.positionItem(item);
+ });
+
+ // 1.x compatibility: positioning based on style
+ /*var props = ['left', 'right', 'top', 'bottom'],
+ prop,
+ i = 4;
+ while (i--) {
+ prop = props[i];
+ if (options.style[prop] && options.style[prop] !== 'auto') {
+ options[i < 2 ? 'align' : 'verticalAlign'] = prop;
+ options[i < 2 ? 'x' : 'y'] = pInt(options.style[prop]) * (i % 2 ? -1 : 1);
+ }
+ }*/
+
+ if (display) {
+ legendGroup.align(extend({
+ width: legendWidth,
+ height: legendHeight
+ }, options), true, 'spacingBox');
+ }
+
+ if (!chart.isResizing) {
+ this.positionCheckboxes();
+ }
+ },
+
+ /**
+ * Set up the overflow handling by adding navigation with up and down arrows below the
+ * legend.
+ */
+ handleOverflow: function (legendHeight) {
+ var legend = this,
+ chart = this.chart,
+ renderer = chart.renderer,
+ options = this.options,
+ optionsY = options.y,
+ alignTop = options.verticalAlign === 'top',
+ spaceHeight = chart.spacingBox.height + (alignTop ? -optionsY : optionsY) - this.padding,
+ maxHeight = options.maxHeight,
+ clipHeight,
+ clipRect = this.clipRect,
+ navOptions = options.navigation,
+ animation = pick(navOptions.animation, true),
+ arrowSize = navOptions.arrowSize || 12,
+ nav = this.nav,
+ pages = this.pages,
+ padding = this.padding,
+ lastY,
+ allItems = this.allItems,
+ clipToHeight = function (height) {
+ clipRect.attr({
+ height: height
+ });
+
+ // useHTML
+ if (legend.contentGroup.div) {
+ legend.contentGroup.div.style.clip = 'rect(' + padding + 'px,9999px,' + (padding + height) + 'px,0)';
+ }
+ };
+
+
+ // Adjust the height
+ if (options.layout === 'horizontal') {
+ spaceHeight /= 2;
+ }
+ if (maxHeight) {
+ spaceHeight = mathMin(spaceHeight, maxHeight);
+ }
+
+ // Reset the legend height and adjust the clipping rectangle
+ pages.length = 0;
+ if (legendHeight > spaceHeight) {
+
+ this.clipHeight = clipHeight = mathMax(spaceHeight - 20 - this.titleHeight - padding, 0);
+ this.currentPage = pick(this.currentPage, 1);
+ this.fullHeight = legendHeight;
+
+ // Fill pages with Y positions so that the top of each a legend item defines
+ // the scroll top for each page (#2098)
+ each(allItems, function (item, i) {
+ var y = item._legendItemPos[1],
+ h = mathRound(item.legendItem.getBBox().height),
+ len = pages.length;
+
+ if (!len || (y - pages[len - 1] > clipHeight && (lastY || y) !== pages[len - 1])) {
+ pages.push(lastY || y);
+ len++;
+ }
+
+ if (i === allItems.length - 1 && y + h - pages[len - 1] > clipHeight) {
+ pages.push(y);
+ }
+ if (y !== lastY) {
+ lastY = y;
+ }
+ });
+
+ // Only apply clipping if needed. Clipping causes blurred legend in PDF export (#1787)
+ if (!clipRect) {
+ clipRect = legend.clipRect = renderer.clipRect(0, padding, 9999, 0);
+ legend.contentGroup.clip(clipRect);
+ }
+
+ clipToHeight(clipHeight);
+
+ // Add navigation elements
+ if (!nav) {
+ this.nav = nav = renderer.g().attr({ zIndex: 1 }).add(this.group);
+ this.up = renderer.symbol('triangle', 0, 0, arrowSize, arrowSize)
+ .on('click', function () {
+ legend.scroll(-1, animation);
+ })
+ .add(nav);
+ this.pager = renderer.text('', 15, 10)
+ .css(navOptions.style)
+ .add(nav);
+ this.down = renderer.symbol('triangle-down', 0, 0, arrowSize, arrowSize)
+ .on('click', function () {
+ legend.scroll(1, animation);
+ })
+ .add(nav);
+ }
+
+ // Set initial position
+ legend.scroll(0);
+
+ legendHeight = spaceHeight;
+
+ } else if (nav) {
+ clipToHeight(chart.chartHeight);
+ nav.hide();
+ this.scrollGroup.attr({
+ translateY: 1
+ });
+ this.clipHeight = 0; // #1379
+ }
+
+ return legendHeight;
+ },
+
+ /**
+ * Scroll the legend by a number of pages
+ * @param {Object} scrollBy
+ * @param {Object} animation
+ */
+ scroll: function (scrollBy, animation) {
+ var pages = this.pages,
+ pageCount = pages.length,
+ currentPage = this.currentPage + scrollBy,
+ clipHeight = this.clipHeight,
+ navOptions = this.options.navigation,
+ activeColor = navOptions.activeColor,
+ inactiveColor = navOptions.inactiveColor,
+ pager = this.pager,
+ padding = this.padding,
+ scrollOffset;
+
+ // When resizing while looking at the last page
+ if (currentPage > pageCount) {
+ currentPage = pageCount;
+ }
+
+ if (currentPage > 0) {
+
+ if (animation !== UNDEFINED) {
+ setAnimation(animation, this.chart);
+ }
+
+ this.nav.attr({
+ translateX: padding,
+ translateY: clipHeight + this.padding + 7 + this.titleHeight,
+ visibility: VISIBLE
+ });
+ this.up.attr({
+ fill: currentPage === 1 ? inactiveColor : activeColor
+ })
+ .css({
+ cursor: currentPage === 1 ? 'default' : 'pointer'
+ });
+ pager.attr({
+ text: currentPage + '/' + pageCount
+ });
+ this.down.attr({
+ x: 18 + this.pager.getBBox().width, // adjust to text width
+ fill: currentPage === pageCount ? inactiveColor : activeColor
+ })
+ .css({
+ cursor: currentPage === pageCount ? 'default' : 'pointer'
+ });
+
+ scrollOffset = -pages[currentPage - 1] + this.initialItemY;
+
+ this.scrollGroup.animate({
+ translateY: scrollOffset
+ });
+
+ this.currentPage = currentPage;
+ this.positionCheckboxes(scrollOffset);
+ }
+
+ }
+
+};
+
+/*
+ * LegendSymbolMixin
+ */
+
+var LegendSymbolMixin = Highcharts.LegendSymbolMixin = {
+
+ /**
+ * Get the series' symbol in the legend
+ *
+ * @param {Object} legend The legend object
+ * @param {Object} item The series (this) or point
+ */
+ drawRectangle: function (legend, item) {
+ var symbolHeight = legend.options.symbolHeight || legend.fontMetrics.f;
+
+ item.legendSymbol = this.chart.renderer.rect(
+ 0,
+ legend.baseline - symbolHeight + 1, // #3988
+ legend.symbolWidth,
+ symbolHeight,
+ legend.options.symbolRadius || 0
+ ).attr({
+ zIndex: 3
+ }).add(item.legendGroup);
+
+ },
+
+ /**
+ * Get the series' symbol in the legend. This method should be overridable to create custom
+ * symbols through Highcharts.seriesTypes[type].prototype.drawLegendSymbols.
+ *
+ * @param {Object} legend The legend object
+ */
+ drawLineMarker: function (legend) {
+
+ var options = this.options,
+ markerOptions = options.marker,
+ radius,
+ legendSymbol,
+ symbolWidth = legend.symbolWidth,
+ renderer = this.chart.renderer,
+ legendItemGroup = this.legendGroup,
+ verticalCenter = legend.baseline - mathRound(legend.fontMetrics.b * 0.3),
+ attr;
+
+ // Draw the line
+ if (options.lineWidth) {
+ attr = {
+ 'stroke-width': options.lineWidth
+ };
+ if (options.dashStyle) {
+ attr.dashstyle = options.dashStyle;
+ }
+ this.legendLine = renderer.path([
+ M,
+ 0,
+ verticalCenter,
+ L,
+ symbolWidth,
+ verticalCenter
+ ])
+ .attr(attr)
+ .add(legendItemGroup);
+ }
+
+ // Draw the marker
+ if (markerOptions && markerOptions.enabled !== false) {
+ radius = markerOptions.radius;
+ this.legendSymbol = legendSymbol = renderer.symbol(
+ this.symbol,
+ (symbolWidth / 2) - radius,
+ verticalCenter - radius,
+ 2 * radius,
+ 2 * radius
+ )
+ .add(legendItemGroup);
+ legendSymbol.isMarker = true;
+ }
+ }
+};
+
+// Workaround for #2030, horizontal legend items not displaying in IE11 Preview,
+// and for #2580, a similar drawing flaw in Firefox 26.
+// TODO: Explore if there's a general cause for this. The problem may be related
+// to nested group elements, as the legend item texts are within 4 group elements.
+if (/Trident\/7\.0/.test(userAgent) || isFirefox) {
+ wrap(Legend.prototype, 'positionItem', function (proceed, item) {
+ var legend = this,
+ runPositionItem = function () { // If chart destroyed in sync, this is undefined (#2030)
+ if (item._legendItemPos) {
+ proceed.call(legend, item);
+ }
+ };
+
+ // Do it now, for export and to get checkbox placement
+ runPositionItem();
+
+ // Do it after to work around the core issue
+ setTimeout(runPositionItem);
+ });
+}
+
+
+/**
+ * The chart class
+ * @param {Object} options
+ * @param {Function} callback Function to run when the chart has loaded
+ */
+var Chart = Highcharts.Chart = function () {
+ this.init.apply(this, arguments);
+};
+
+Chart.prototype = {
+
+ /**
+ * Hook for modules
+ */
+ callbacks: [],
+
+ /**
+ * Initialize the chart
+ */
+ init: function (userOptions, callback) {
+
+ // Handle regular options
+ var options,
+ seriesOptions = userOptions.series; // skip merging data points to increase performance
+
+ userOptions.series = null;
+ options = merge(defaultOptions, userOptions); // do the merge
+ options.series = userOptions.series = seriesOptions; // set back the series data
+ this.userOptions = userOptions;
+
+ var optionsChart = options.chart;
+
+ // Create margin & spacing array
+ this.margin = this.splashArray('margin', optionsChart);
+ this.spacing = this.splashArray('spacing', optionsChart);
+
+ var chartEvents = optionsChart.events;
+
+ //this.runChartClick = chartEvents && !!chartEvents.click;
+ this.bounds = { h: {}, v: {} }; // Pixel data bounds for touch zoom
+
+ this.callback = callback;
+ this.isResizing = 0;
+ this.options = options;
+ //chartTitleOptions = UNDEFINED;
+ //chartSubtitleOptions = UNDEFINED;
+
+ this.axes = [];
+ this.series = [];
+ this.hasCartesianSeries = optionsChart.showAxes;
+ //this.axisOffset = UNDEFINED;
+ //this.maxTicks = UNDEFINED; // handle the greatest amount of ticks on grouped axes
+ //this.inverted = UNDEFINED;
+ //this.loadingShown = UNDEFINED;
+ //this.container = UNDEFINED;
+ //this.chartWidth = UNDEFINED;
+ //this.chartHeight = UNDEFINED;
+ //this.marginRight = UNDEFINED;
+ //this.marginBottom = UNDEFINED;
+ //this.containerWidth = UNDEFINED;
+ //this.containerHeight = UNDEFINED;
+ //this.oldChartWidth = UNDEFINED;
+ //this.oldChartHeight = UNDEFINED;
+
+ //this.renderTo = UNDEFINED;
+ //this.renderToClone = UNDEFINED;
+
+ //this.spacingBox = UNDEFINED
+
+ //this.legend = UNDEFINED;
+
+ // Elements
+ //this.chartBackground = UNDEFINED;
+ //this.plotBackground = UNDEFINED;
+ //this.plotBGImage = UNDEFINED;
+ //this.plotBorder = UNDEFINED;
+ //this.loadingDiv = UNDEFINED;
+ //this.loadingSpan = UNDEFINED;
+
+ var chart = this,
+ eventType;
+
+ // Add the chart to the global lookup
+ chart.index = charts.length;
+ charts.push(chart);
+ chartCount++;
+
+ // Set up auto resize
+ if (optionsChart.reflow !== false) {
+ addEvent(chart, 'load', function () {
+ chart.initReflow();
+ });
+ }
+
+ // Chart event handlers
+ if (chartEvents) {
+ for (eventType in chartEvents) {
+ addEvent(chart, eventType, chartEvents[eventType]);
+ }
+ }
+
+ chart.xAxis = [];
+ chart.yAxis = [];
+
+ // Expose methods and variables
+ chart.animation = useCanVG ? false : pick(optionsChart.animation, true);
+ chart.pointCount = chart.colorCounter = chart.symbolCounter = 0;
+
+ chart.firstRender();
+ },
+
+ /**
+ * Initialize an individual series, called internally before render time
+ */
+ initSeries: function (options) {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ type = options.type || optionsChart.type || optionsChart.defaultSeriesType,
+ series,
+ constr = seriesTypes[type];
+
+ // No such series type
+ if (!constr) {
+ error(17, true);
+ }
+
+ series = new constr();
+ series.init(this, options);
+ return series;
+ },
+
+ /**
+ * Check whether a given point is within the plot area
+ *
+ * @param {Number} plotX Pixel x relative to the plot area
+ * @param {Number} plotY Pixel y relative to the plot area
+ * @param {Boolean} inverted Whether the chart is inverted
+ */
+ isInsidePlot: function (plotX, plotY, inverted) {
+ var x = inverted ? plotY : plotX,
+ y = inverted ? plotX : plotY;
+
+ return x >= 0 &&
+ x <= this.plotWidth &&
+ y >= 0 &&
+ y <= this.plotHeight;
+ },
+
+ /**
+ * Redraw legend, axes or series based on updated data
+ *
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ */
+ redraw: function (animation) {
+ var chart = this,
+ axes = chart.axes,
+ series = chart.series,
+ pointer = chart.pointer,
+ legend = chart.legend,
+ redrawLegend = chart.isDirtyLegend,
+ hasStackedSeries,
+ hasDirtyStacks,
+ hasCartesianSeries = chart.hasCartesianSeries,
+ isDirtyBox = chart.isDirtyBox, // todo: check if it has actually changed?
+ seriesLength = series.length,
+ i = seriesLength,
+ serie,
+ renderer = chart.renderer,
+ isHiddenChart = renderer.isHidden(),
+ afterRedraw = [];
+
+ setAnimation(animation, chart);
+
+ if (isHiddenChart) {
+ chart.cloneRenderTo();
+ }
+
+ // Adjust title layout (reflow multiline text)
+ chart.layOutTitles();
+
+ // link stacked series
+ while (i--) {
+ serie = series[i];
+
+ if (serie.options.stacking) {
+ hasStackedSeries = true;
+
+ if (serie.isDirty) {
+ hasDirtyStacks = true;
+ break;
+ }
+ }
+ }
+ if (hasDirtyStacks) { // mark others as dirty
+ i = seriesLength;
+ while (i--) {
+ serie = series[i];
+ if (serie.options.stacking) {
+ serie.isDirty = true;
+ }
+ }
+ }
+
+ // Handle updated data in the series
+ each(series, function (serie) {
+ if (serie.isDirty) {
+ if (serie.options.legendType === 'point') {
+ if (serie.updateTotals) {
+ serie.updateTotals();
+ }
+ redrawLegend = true;
+ }
+ }
+ });
+
+ // handle added or removed series
+ if (redrawLegend && legend.options.enabled) { // series or pie points are added or removed
+ // draw legend graphics
+ legend.render();
+
+ chart.isDirtyLegend = false;
+ }
+
+ // reset stacks
+ if (hasStackedSeries) {
+ chart.getStacks();
+ }
+
+
+ if (hasCartesianSeries) {
+ if (!chart.isResizing) {
+
+ // reset maxTicks
+ chart.maxTicks = null;
+
+ // set axes scales
+ each(axes, function (axis) {
+ axis.setScale();
+ });
+ }
+ }
+
+ chart.getMargins(); // #3098
+
+ if (hasCartesianSeries) {
+ // If one axis is dirty, all axes must be redrawn (#792, #2169)
+ each(axes, function (axis) {
+ if (axis.isDirty) {
+ isDirtyBox = true;
+ }
+ });
+
+ // redraw axes
+ each(axes, function (axis) {
+
+ // Fire 'afterSetExtremes' only if extremes are set
+ var key = axis.min + ',' + axis.max;
+ if (axis.extKey !== key) { // #821, #4452
+ axis.extKey = key;
+ afterRedraw.push(function () { // prevent a recursive call to chart.redraw() (#1119)
+ fireEvent(axis, 'afterSetExtremes', extend(axis.eventArgs, axis.getExtremes())); // #747, #751
+ delete axis.eventArgs;
+ });
+ }
+ if (isDirtyBox || hasStackedSeries) {
+ axis.redraw();
+ }
+ });
+ }
+
+ // the plot areas size has changed
+ if (isDirtyBox) {
+ chart.drawChartBox();
+ }
+
+
+ // redraw affected series
+ each(series, function (serie) {
+ if (serie.isDirty && serie.visible &&
+ (!serie.isCartesian || serie.xAxis)) { // issue #153
+ serie.redraw();
+ }
+ });
+
+ // move tooltip or reset
+ if (pointer) {
+ pointer.reset(true);
+ }
+
+ // redraw if canvas
+ renderer.draw();
+
+ // fire the event
+ fireEvent(chart, 'redraw'); // jQuery breaks this when calling it from addEvent. Overwrites chart.redraw
+
+ if (isHiddenChart) {
+ chart.cloneRenderTo(true);
+ }
+
+ // Fire callbacks that are put on hold until after the redraw
+ each(afterRedraw, function (callback) {
+ callback.call();
+ });
+ },
+
+ /**
+ * Get an axis, series or point object by id.
+ * @param id {String} The id as given in the configuration options
+ */
+ get: function (id) {
+ var chart = this,
+ axes = chart.axes,
+ series = chart.series;
+
+ var i,
+ j,
+ points;
+
+ // search axes
+ for (i = 0; i < axes.length; i++) {
+ if (axes[i].options.id === id) {
+ return axes[i];
+ }
+ }
+
+ // search series
+ for (i = 0; i < series.length; i++) {
+ if (series[i].options.id === id) {
+ return series[i];
+ }
+ }
+
+ // search points
+ for (i = 0; i < series.length; i++) {
+ points = series[i].points || [];
+ for (j = 0; j < points.length; j++) {
+ if (points[j].id === id) {
+ return points[j];
+ }
+ }
+ }
+ return null;
+ },
+
+ /**
+ * Create the Axis instances based on the config options
+ */
+ getAxes: function () {
+ var chart = this,
+ options = this.options,
+ xAxisOptions = options.xAxis = splat(options.xAxis || {}),
+ yAxisOptions = options.yAxis = splat(options.yAxis || {}),
+ optionsArray,
+ axis;
+
+ // make sure the options are arrays and add some members
+ each(xAxisOptions, function (axis, i) {
+ axis.index = i;
+ axis.isX = true;
+ });
+
+ each(yAxisOptions, function (axis, i) {
+ axis.index = i;
+ });
+
+ // concatenate all axis options into one array
+ optionsArray = xAxisOptions.concat(yAxisOptions);
+
+ each(optionsArray, function (axisOptions) {
+ axis = new Axis(chart, axisOptions);
+ });
+ },
+
+
+ /**
+ * Get the currently selected points from all series
+ */
+ getSelectedPoints: function () {
+ var points = [];
+ each(this.series, function (serie) {
+ points = points.concat(grep(serie.points || [], function (point) {
+ return point.selected;
+ }));
+ });
+ return points;
+ },
+
+ /**
+ * Get the currently selected series
+ */
+ getSelectedSeries: function () {
+ return grep(this.series, function (serie) {
+ return serie.selected;
+ });
+ },
+
+ /**
+ * Show the title and subtitle of the chart
+ *
+ * @param titleOptions {Object} New title options
+ * @param subtitleOptions {Object} New subtitle options
+ *
+ */
+ setTitle: function (titleOptions, subtitleOptions, redraw) {
+ var chart = this,
+ options = chart.options,
+ chartTitleOptions,
+ chartSubtitleOptions;
+
+ chartTitleOptions = options.title = merge(options.title, titleOptions);
+ chartSubtitleOptions = options.subtitle = merge(options.subtitle, subtitleOptions);
+
+ // add title and subtitle
+ each([
+ ['title', titleOptions, chartTitleOptions],
+ ['subtitle', subtitleOptions, chartSubtitleOptions]
+ ], function (arr) {
+ var name = arr[0],
+ title = chart[name],
+ titleOptions = arr[1],
+ chartTitleOptions = arr[2];
+
+ if (title && titleOptions) {
+ chart[name] = title = title.destroy(); // remove old
+ }
+
+ if (chartTitleOptions && chartTitleOptions.text && !title) {
+ chart[name] = chart.renderer.text(
+ chartTitleOptions.text,
+ 0,
+ 0,
+ chartTitleOptions.useHTML
+ )
+ .attr({
+ align: chartTitleOptions.align,
+ 'class': PREFIX + name,
+ zIndex: chartTitleOptions.zIndex || 4
+ })
+ .css(chartTitleOptions.style)
+ .add();
+ }
+ });
+ chart.layOutTitles(redraw);
+ },
+
+ /**
+ * Lay out the chart titles and cache the full offset height for use in getMargins
+ */
+ layOutTitles: function (redraw) {
+ var titleOffset = 0,
+ title = this.title,
+ subtitle = this.subtitle,
+ options = this.options,
+ titleOptions = options.title,
+ subtitleOptions = options.subtitle,
+ requiresDirtyBox,
+ renderer = this.renderer,
+ autoWidth = this.spacingBox.width - 44; // 44 makes room for default context button
+
+ if (title) {
+ title
+ .css({ width: (titleOptions.width || autoWidth) + PX })
+ .align(extend({
+ y: renderer.fontMetrics(titleOptions.style.fontSize, title).b - 3
+ }, titleOptions), false, 'spacingBox');
+
+ if (!titleOptions.floating && !titleOptions.verticalAlign) {
+ titleOffset = title.getBBox().height;
+ }
+ }
+ if (subtitle) {
+ subtitle
+ .css({ width: (subtitleOptions.width || autoWidth) + PX })
+ .align(extend({
+ y: titleOffset + (titleOptions.margin - 13) + renderer.fontMetrics(subtitleOptions.style.fontSize, title).b
+ }, subtitleOptions), false, 'spacingBox');
+
+ if (!subtitleOptions.floating && !subtitleOptions.verticalAlign) {
+ titleOffset = mathCeil(titleOffset + subtitle.getBBox().height);
+ }
+ }
+
+ requiresDirtyBox = this.titleOffset !== titleOffset;
+ this.titleOffset = titleOffset; // used in getMargins
+
+ if (!this.isDirtyBox && requiresDirtyBox) {
+ this.isDirtyBox = requiresDirtyBox;
+ // Redraw if necessary (#2719, #2744)
+ if (this.hasRendered && pick(redraw, true) && this.isDirtyBox) {
+ this.redraw();
+ }
+ }
+ },
+
+ /**
+ * Get chart width and height according to options and container size
+ */
+ getChartSize: function () {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ widthOption = optionsChart.width,
+ heightOption = optionsChart.height,
+ renderTo = chart.renderToClone || chart.renderTo;
+
+ // get inner width and height from jQuery (#824)
+ if (!defined(widthOption)) {
+ chart.containerWidth = adapterRun(renderTo, 'width');
+ }
+ if (!defined(heightOption)) {
+ chart.containerHeight = adapterRun(renderTo, 'height');
+ }
+
+ chart.chartWidth = mathMax(0, widthOption || chart.containerWidth || 600); // #1393, 1460
+ chart.chartHeight = mathMax(0, pick(heightOption,
+ // the offsetHeight of an empty container is 0 in standard browsers, but 19 in IE7:
+ chart.containerHeight > 19 ? chart.containerHeight : 400));
+ },
+
+ /**
+ * Create a clone of the chart's renderTo div and place it outside the viewport to allow
+ * size computation on chart.render and chart.redraw
+ */
+ cloneRenderTo: function (revert) {
+ var clone = this.renderToClone,
+ container = this.container;
+
+ // Destroy the clone and bring the container back to the real renderTo div
+ if (revert) {
+ if (clone) {
+ this.renderTo.appendChild(container);
+ discardElement(clone);
+ delete this.renderToClone;
+ }
+
+ // Set up the clone
+ } else {
+ if (container && container.parentNode === this.renderTo) {
+ this.renderTo.removeChild(container); // do not clone this
+ }
+ this.renderToClone = clone = this.renderTo.cloneNode(0);
+ css(clone, {
+ position: ABSOLUTE,
+ top: '-9999px',
+ display: 'block' // #833
+ });
+ if (clone.style.setProperty) { // #2631
+ clone.style.setProperty('display', 'block', 'important');
+ }
+ doc.body.appendChild(clone);
+ if (container) {
+ clone.appendChild(container);
+ }
+ }
+ },
+
+ /**
+ * Get the containing element, determine the size and create the inner container
+ * div to hold the chart
+ */
+ getContainer: function () {
+ var chart = this,
+ container,
+ options = chart.options,
+ optionsChart = options.chart,
+ chartWidth,
+ chartHeight,
+ renderTo,
+ indexAttrName = 'data-highcharts-chart',
+ oldChartIndex,
+ Ren,
+ containerId;
+
+ chart.renderTo = renderTo = optionsChart.renderTo;
+ containerId = PREFIX + idCounter++;
+
+ if (isString(renderTo)) {
+ chart.renderTo = renderTo = doc.getElementById(renderTo);
+ }
+
+ // Display an error if the renderTo is wrong
+ if (!renderTo) {
+ error(13, true);
+ }
+
+ // If the container already holds a chart, destroy it. The check for hasRendered is there
+ // because web pages that are saved to disk from the browser, will preserve the data-highcharts-chart
+ // attribute and the SVG contents, but not an interactive chart. So in this case,
+ // charts[oldChartIndex] will point to the wrong chart if any (#2609).
+ oldChartIndex = pInt(attr(renderTo, indexAttrName));
+ if (!isNaN(oldChartIndex) && charts[oldChartIndex] && charts[oldChartIndex].hasRendered) {
+ charts[oldChartIndex].destroy();
+ }
+
+ // Make a reference to the chart from the div
+ attr(renderTo, indexAttrName, chart.index);
+
+ // remove previous chart
+ renderTo.innerHTML = '';
+
+ // If the container doesn't have an offsetWidth, it has or is a child of a node
+ // that has display:none. We need to temporarily move it out to a visible
+ // state to determine the size, else the legend and tooltips won't render
+ // properly. The allowClone option is used in sparklines as a micro optimization,
+ // saving about 1-2 ms each chart.
+ if (!optionsChart.skipClone && !renderTo.offsetWidth) {
+ chart.cloneRenderTo();
+ }
+
+ // get the width and height
+ chart.getChartSize();
+ chartWidth = chart.chartWidth;
+ chartHeight = chart.chartHeight;
+
+ // create the inner container
+ chart.container = container = createElement(DIV, {
+ className: PREFIX + 'container' +
+ (optionsChart.className ? ' ' + optionsChart.className : ''),
+ id: containerId
+ }, extend({
+ position: RELATIVE,
+ overflow: HIDDEN, // needed for context menu (avoid scrollbars) and
+ // content overflow in IE
+ width: chartWidth + PX,
+ height: chartHeight + PX,
+ textAlign: 'left',
+ lineHeight: 'normal', // #427
+ zIndex: 0, // #1072
+ '-webkit-tap-highlight-color': 'rgba(0,0,0,0)'
+ }, optionsChart.style),
+ chart.renderToClone || renderTo
+ );
+
+ // cache the cursor (#1650)
+ chart._cursor = container.style.cursor;
+
+ // Initialize the renderer
+ Ren = Highcharts[optionsChart.renderer] || Renderer;
+ chart.renderer = new Ren(
+ container,
+ chartWidth,
+ chartHeight,
+ optionsChart.style,
+ optionsChart.forExport,
+ options.exporting && options.exporting.allowHTML
+ );
+
+ if (useCanVG) {
+ // If we need canvg library, extend and configure the renderer
+ // to get the tracker for translating mouse events
+ chart.renderer.create(chart, container, chartWidth, chartHeight);
+ }
+ // Add a reference to the charts index
+ chart.renderer.chartIndex = chart.index;
+ },
+
+ /**
+ * Calculate margins by rendering axis labels in a preliminary position. Title,
+ * subtitle and legend have already been rendered at this stage, but will be
+ * moved into their final positions
+ */
+ getMargins: function (skipAxes) {
+ var chart = this,
+ spacing = chart.spacing,
+ margin = chart.margin,
+ titleOffset = chart.titleOffset;
+
+ chart.resetMargins();
+
+ // Adjust for title and subtitle
+ if (titleOffset && !defined(margin[0])) {
+ chart.plotTop = mathMax(chart.plotTop, titleOffset + chart.options.title.margin + spacing[0]);
+ }
+
+ // Adjust for legend
+ chart.legend.adjustMargins(margin, spacing);
+
+ // adjust for scroller
+ if (chart.extraBottomMargin) {
+ chart.marginBottom += chart.extraBottomMargin;
+ }
+ if (chart.extraTopMargin) {
+ chart.plotTop += chart.extraTopMargin;
+ }
+ if (!skipAxes) {
+ this.getAxisMargins();
+ }
+ },
+
+ getAxisMargins: function () {
+
+ var chart = this,
+ axisOffset = chart.axisOffset = [0, 0, 0, 0], // top, right, bottom, left
+ margin = chart.margin;
+
+ // pre-render axes to get labels offset width
+ if (chart.hasCartesianSeries) {
+ each(chart.axes, function (axis) {
+ if (axis.visible) {
+ axis.getOffset();
+ }
+ });
+ }
+
+ // Add the axis offsets
+ each(marginNames, function (m, side) {
+ if (!defined(margin[side])) {
+ chart[m] += axisOffset[side];
+ }
+ });
+
+ chart.setChartSize();
+
+ },
+
+ /**
+ * Resize the chart to its container if size is not explicitly set
+ */
+ reflow: function (e) {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ renderTo = chart.renderTo,
+ width = optionsChart.width || adapterRun(renderTo, 'width'),
+ height = optionsChart.height || adapterRun(renderTo, 'height'),
+ target = e ? e.target : win, // #805 - MooTools doesn't supply e
+ doReflow = function () {
+ if (chart.container) { // It may have been destroyed in the meantime (#1257)
+ chart.setSize(width, height, false);
+ chart.hasUserSize = null;
+ }
+ };
+
+ // Width and height checks for display:none. Target is doc in IE8 and Opera,
+ // win in Firefox, Chrome and IE9.
+ if (!chart.hasUserSize && !chart.isPrinting && width && height && (target === win || target === doc)) { // #1093
+ if (width !== chart.containerWidth || height !== chart.containerHeight) {
+ clearTimeout(chart.reflowTimeout);
+ if (e) { // Called from window.resize
+ chart.reflowTimeout = setTimeout(doReflow, 100);
+ } else { // Called directly (#2224)
+ doReflow();
+ }
+ }
+ chart.containerWidth = width;
+ chart.containerHeight = height;
+ }
+ },
+
+ /**
+ * Add the event handlers necessary for auto resizing
+ */
+ initReflow: function () {
+ var chart = this,
+ reflow = function (e) {
+ chart.reflow(e);
+ };
+
+
+ addEvent(win, 'resize', reflow);
+ addEvent(chart, 'destroy', function () {
+ removeEvent(win, 'resize', reflow);
+ });
+ },
+
+ /**
+ * Resize the chart to a given width and height
+ * @param {Number} width
+ * @param {Number} height
+ * @param {Object|Boolean} animation
+ */
+ setSize: function (width, height, animation) {
+ var chart = this,
+ chartWidth,
+ chartHeight,
+ fireEndResize,
+ renderer = chart.renderer,
+ globalAnimation;
+
+ // Handle the isResizing counter
+ chart.isResizing += 1;
+ fireEndResize = function () {
+ if (chart) {
+ fireEvent(chart, 'endResize', null, function () {
+ chart.isResizing -= 1;
+ });
+ }
+ };
+
+ // set the animation for the current process
+ setAnimation(animation, chart);
+
+ chart.oldChartHeight = chart.chartHeight;
+ chart.oldChartWidth = chart.chartWidth;
+ if (defined(width)) {
+ chart.chartWidth = chartWidth = mathMax(0, mathRound(width));
+ chart.hasUserSize = !!chartWidth;
+ }
+ if (defined(height)) {
+ chart.chartHeight = chartHeight = mathMax(0, mathRound(height));
+ }
+
+ // Resize the container with the global animation applied if enabled (#2503)
+ globalAnimation = renderer.globalAnimation;
+ (globalAnimation ? animate : css)(chart.container, {
+ width: chartWidth + PX,
+ height: chartHeight + PX
+ }, globalAnimation);
+
+ chart.setChartSize(true);
+ renderer.setSize(chartWidth, chartHeight, animation);
+
+ // handle axes
+ chart.maxTicks = null;
+ each(chart.axes, function (axis) {
+ axis.isDirty = true;
+ axis.setScale();
+ });
+
+ // make sure non-cartesian series are also handled
+ each(chart.series, function (serie) {
+ serie.isDirty = true;
+ });
+
+ chart.isDirtyLegend = true; // force legend redraw
+ chart.isDirtyBox = true; // force redraw of plot and chart border
+
+ chart.layOutTitles(); // #2857
+ chart.getMargins();
+
+ chart.redraw(animation);
+
+
+ chart.oldChartHeight = null;
+ fireEvent(chart, 'resize');
+
+ // Fire endResize and set isResizing back. If animation is disabled, fire without delay
+ globalAnimation = renderer.globalAnimation; // Reassign it before using it, it may have changed since the top of this function.
+ if (globalAnimation === false) {
+ fireEndResize();
+ } else { // else set a timeout with the animation duration
+ setTimeout(fireEndResize, (globalAnimation && globalAnimation.duration) || 500);
+ }
+ },
+
+ /**
+ * Set the public chart properties. This is done before and after the pre-render
+ * to determine margin sizes
+ */
+ setChartSize: function (skipAxes) {
+ var chart = this,
+ inverted = chart.inverted,
+ renderer = chart.renderer,
+ chartWidth = chart.chartWidth,
+ chartHeight = chart.chartHeight,
+ optionsChart = chart.options.chart,
+ spacing = chart.spacing,
+ clipOffset = chart.clipOffset,
+ clipX,
+ clipY,
+ plotLeft,
+ plotTop,
+ plotWidth,
+ plotHeight,
+ plotBorderWidth;
+
+ chart.plotLeft = plotLeft = mathRound(chart.plotLeft);
+ chart.plotTop = plotTop = mathRound(chart.plotTop);
+ chart.plotWidth = plotWidth = mathMax(0, mathRound(chartWidth - plotLeft - chart.marginRight));
+ chart.plotHeight = plotHeight = mathMax(0, mathRound(chartHeight - plotTop - chart.marginBottom));
+
+ chart.plotSizeX = inverted ? plotHeight : plotWidth;
+ chart.plotSizeY = inverted ? plotWidth : plotHeight;
+
+ chart.plotBorderWidth = optionsChart.plotBorderWidth || 0;
+
+ // Set boxes used for alignment
+ chart.spacingBox = renderer.spacingBox = {
+ x: spacing[3],
+ y: spacing[0],
+ width: chartWidth - spacing[3] - spacing[1],
+ height: chartHeight - spacing[0] - spacing[2]
+ };
+ chart.plotBox = renderer.plotBox = {
+ x: plotLeft,
+ y: plotTop,
+ width: plotWidth,
+ height: plotHeight
+ };
+
+ plotBorderWidth = 2 * mathFloor(chart.plotBorderWidth / 2);
+ clipX = mathCeil(mathMax(plotBorderWidth, clipOffset[3]) / 2);
+ clipY = mathCeil(mathMax(plotBorderWidth, clipOffset[0]) / 2);
+ chart.clipBox = {
+ x: clipX,
+ y: clipY,
+ width: mathFloor(chart.plotSizeX - mathMax(plotBorderWidth, clipOffset[1]) / 2 - clipX),
+ height: mathMax(0, mathFloor(chart.plotSizeY - mathMax(plotBorderWidth, clipOffset[2]) / 2 - clipY))
+ };
+
+ if (!skipAxes) {
+ each(chart.axes, function (axis) {
+ axis.setAxisSize();
+ axis.setAxisTranslation();
+ });
+ }
+ },
+
+ /**
+ * Initial margins before auto size margins are applied
+ */
+ resetMargins: function () {
+ var chart = this;
+
+ each(marginNames, function (m, side) {
+ chart[m] = pick(chart.margin[side], chart.spacing[side]);
+ });
+ chart.axisOffset = [0, 0, 0, 0]; // top, right, bottom, left
+ chart.clipOffset = [0, 0, 0, 0];
+ },
+
+ /**
+ * Draw the borders and backgrounds for chart and plot area
+ */
+ drawChartBox: function () {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ renderer = chart.renderer,
+ chartWidth = chart.chartWidth,
+ chartHeight = chart.chartHeight,
+ chartBackground = chart.chartBackground,
+ plotBackground = chart.plotBackground,
+ plotBorder = chart.plotBorder,
+ plotBGImage = chart.plotBGImage,
+ chartBorderWidth = optionsChart.borderWidth || 0,
+ chartBackgroundColor = optionsChart.backgroundColor,
+ plotBackgroundColor = optionsChart.plotBackgroundColor,
+ plotBackgroundImage = optionsChart.plotBackgroundImage,
+ plotBorderWidth = optionsChart.plotBorderWidth || 0,
+ mgn,
+ bgAttr,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop,
+ plotWidth = chart.plotWidth,
+ plotHeight = chart.plotHeight,
+ plotBox = chart.plotBox,
+ clipRect = chart.clipRect,
+ clipBox = chart.clipBox;
+
+ // Chart area
+ mgn = chartBorderWidth + (optionsChart.shadow ? 8 : 0);
+
+ if (chartBorderWidth || chartBackgroundColor) {
+ if (!chartBackground) {
+
+ bgAttr = {
+ fill: chartBackgroundColor || NONE
+ };
+ if (chartBorderWidth) { // #980
+ bgAttr.stroke = optionsChart.borderColor;
+ bgAttr['stroke-width'] = chartBorderWidth;
+ }
+ chart.chartBackground = renderer.rect(mgn / 2, mgn / 2, chartWidth - mgn, chartHeight - mgn,
+ optionsChart.borderRadius, chartBorderWidth)
+ .attr(bgAttr)
+ .addClass(PREFIX + 'background')
+ .add()
+ .shadow(optionsChart.shadow);
+
+ } else { // resize
+ chartBackground.animate(
+ chartBackground.crisp({ width: chartWidth - mgn, height: chartHeight - mgn })
+ );
+ }
+ }
+
+
+ // Plot background
+ if (plotBackgroundColor) {
+ if (!plotBackground) {
+ chart.plotBackground = renderer.rect(plotLeft, plotTop, plotWidth, plotHeight, 0)
+ .attr({
+ fill: plotBackgroundColor
+ })
+ .add()
+ .shadow(optionsChart.plotShadow);
+ } else {
+ plotBackground.animate(plotBox);
+ }
+ }
+ if (plotBackgroundImage) {
+ if (!plotBGImage) {
+ chart.plotBGImage = renderer.image(plotBackgroundImage, plotLeft, plotTop, plotWidth, plotHeight)
+ .add();
+ } else {
+ plotBGImage.animate(plotBox);
+ }
+ }
+
+ // Plot clip
+ if (!clipRect) {
+ chart.clipRect = renderer.clipRect(clipBox);
+ } else {
+ clipRect.animate({
+ width: clipBox.width,
+ height: clipBox.height
+ });
+ }
+
+ // Plot area border
+ if (plotBorderWidth) {
+ if (!plotBorder) {
+ chart.plotBorder = renderer.rect(plotLeft, plotTop, plotWidth, plotHeight, 0, -plotBorderWidth)
+ .attr({
+ stroke: optionsChart.plotBorderColor,
+ 'stroke-width': plotBorderWidth,
+ fill: NONE,
+ zIndex: 1
+ })
+ .add();
+ } else {
+ plotBorder.animate(
+ plotBorder.crisp({ x: plotLeft, y: plotTop, width: plotWidth, height: plotHeight, strokeWidth: -plotBorderWidth }) //#3282 plotBorder should be negative
+ );
+ }
+ }
+
+ // reset
+ chart.isDirtyBox = false;
+ },
+
+ /**
+ * Detect whether a certain chart property is needed based on inspecting its options
+ * and series. This mainly applies to the chart.invert property, and in extensions to
+ * the chart.angular and chart.polar properties.
+ */
+ propFromSeries: function () {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ klass,
+ seriesOptions = chart.options.series,
+ i,
+ value;
+
+
+ each(['inverted', 'angular', 'polar'], function (key) {
+
+ // The default series type's class
+ klass = seriesTypes[optionsChart.type || optionsChart.defaultSeriesType];
+
+ // Get the value from available chart-wide properties
+ value = (
+ chart[key] || // 1. it is set before
+ optionsChart[key] || // 2. it is set in the options
+ (klass && klass.prototype[key]) // 3. it's default series class requires it
+ );
+
+ // 4. Check if any the chart's series require it
+ i = seriesOptions && seriesOptions.length;
+ while (!value && i--) {
+ klass = seriesTypes[seriesOptions[i].type];
+ if (klass && klass.prototype[key]) {
+ value = true;
+ }
+ }
+
+ // Set the chart property
+ chart[key] = value;
+ });
+
+ },
+
+ /**
+ * Link two or more series together. This is done initially from Chart.render,
+ * and after Chart.addSeries and Series.remove.
+ */
+ linkSeries: function () {
+ var chart = this,
+ chartSeries = chart.series;
+
+ // Reset links
+ each(chartSeries, function (series) {
+ series.linkedSeries.length = 0;
+ });
+
+ // Apply new links
+ each(chartSeries, function (series) {
+ var linkedTo = series.options.linkedTo;
+ if (isString(linkedTo)) {
+ if (linkedTo === ':previous') {
+ linkedTo = chart.series[series.index - 1];
+ } else {
+ linkedTo = chart.get(linkedTo);
+ }
+ if (linkedTo) {
+ linkedTo.linkedSeries.push(series);
+ series.linkedParent = linkedTo;
+ series.visible = pick(series.options.visible, linkedTo.options.visible, series.visible); // #3879
+ }
+ }
+ });
+ },
+
+ /**
+ * Render series for the chart
+ */
+ renderSeries: function () {
+ each(this.series, function (serie) {
+ serie.translate();
+ serie.render();
+ });
+ },
+
+ /**
+ * Render labels for the chart
+ */
+ renderLabels: function () {
+ var chart = this,
+ labels = chart.options.labels;
+ if (labels.items) {
+ each(labels.items, function (label) {
+ var style = extend(labels.style, label.style),
+ x = pInt(style.left) + chart.plotLeft,
+ y = pInt(style.top) + chart.plotTop + 12;
+
+ // delete to prevent rewriting in IE
+ delete style.left;
+ delete style.top;
+
+ chart.renderer.text(
+ label.html,
+ x,
+ y
+ )
+ .attr({ zIndex: 2 })
+ .css(style)
+ .add();
+
+ });
+ }
+ },
+
+ /**
+ * Render all graphics for the chart
+ */
+ render: function () {
+ var chart = this,
+ axes = chart.axes,
+ renderer = chart.renderer,
+ options = chart.options,
+ tempWidth,
+ tempHeight,
+ redoHorizontal,
+ redoVertical;
+
+ // Title
+ chart.setTitle();
+
+
+ // Legend
+ chart.legend = new Legend(chart, options.legend);
+
+ // Get stacks
+ if (chart.getStacks) {
+ chart.getStacks();
+ }
+
+ // Get chart margins
+ chart.getMargins(true);
+ chart.setChartSize();
+
+ // Record preliminary dimensions for later comparison
+ tempWidth = chart.plotWidth;
+ tempHeight = chart.plotHeight = chart.plotHeight - 13; // 13 is the most common height of X axis labels
+
+ // Get margins by pre-rendering axes
+ each(axes, function (axis) {
+ axis.setScale();
+ });
+ chart.getAxisMargins();
+
+ // If the plot area size has changed significantly, calculate tick positions again
+ redoHorizontal = tempWidth / chart.plotWidth > 1.1;
+ redoVertical = tempHeight / chart.plotHeight > 1.1;
+
+ if (redoHorizontal || redoVertical) {
+
+ chart.maxTicks = null; // reset for second pass
+ each(axes, function (axis) {
+ if ((axis.horiz && redoHorizontal) || (!axis.horiz && redoVertical)) {
+ axis.setTickInterval(true); // update to reflect the new margins
+ }
+ });
+ chart.getMargins(); // second pass to check for new labels
+ }
+
+ // Draw the borders and backgrounds
+ chart.drawChartBox();
+
+
+ // Axes
+ if (chart.hasCartesianSeries) {
+ each(axes, function (axis) {
+ if (axis.visible) {
+ axis.render();
+ }
+ });
+ }
+
+ // The series
+ if (!chart.seriesGroup) {
+ chart.seriesGroup = renderer.g('series-group')
+ .attr({ zIndex: 3 })
+ .add();
+ }
+ chart.renderSeries();
+
+ // Labels
+ chart.renderLabels();
+
+ // Credits
+ chart.showCredits(options.credits);
+
+ // Set flag
+ chart.hasRendered = true;
+
+ },
+
+ /**
+ * Show chart credits based on config options
+ */
+ showCredits: function (credits) {
+ if (credits.enabled && !this.credits) {
+ this.credits = this.renderer.text(
+ credits.text,
+ 0,
+ 0
+ )
+ .on('click', function () {
+ if (credits.href) {
+ location.href = credits.href;
+ }
+ })
+ .attr({
+ align: credits.position.align,
+ zIndex: 8
+ })
+ .css(credits.style)
+ .add()
+ .align(credits.position);
+ }
+ },
+
+ /**
+ * Clean up memory usage
+ */
+ destroy: function () {
+ var chart = this,
+ axes = chart.axes,
+ series = chart.series,
+ container = chart.container,
+ i,
+ parentNode = container && container.parentNode;
+
+ // fire the chart.destoy event
+ fireEvent(chart, 'destroy');
+
+ // Delete the chart from charts lookup array
+ charts[chart.index] = UNDEFINED;
+ chartCount--;
+ chart.renderTo.removeAttribute('data-highcharts-chart');
+
+ // remove events
+ removeEvent(chart);
+
+ // ==== Destroy collections:
+ // Destroy axes
+ i = axes.length;
+ while (i--) {
+ axes[i] = axes[i].destroy();
+ }
+
+ // Destroy each series
+ i = series.length;
+ while (i--) {
+ series[i] = series[i].destroy();
+ }
+
+ // ==== Destroy chart properties:
+ each(['title', 'subtitle', 'chartBackground', 'plotBackground', 'plotBGImage',
+ 'plotBorder', 'seriesGroup', 'clipRect', 'credits', 'pointer', 'scroller',
+ 'rangeSelector', 'legend', 'resetZoomButton', 'tooltip', 'renderer'], function (name) {
+ var prop = chart[name];
+
+ if (prop && prop.destroy) {
+ chart[name] = prop.destroy();
+ }
+ });
+
+ // remove container and all SVG
+ if (container) { // can break in IE when destroyed before finished loading
+ container.innerHTML = '';
+ removeEvent(container);
+ if (parentNode) {
+ discardElement(container);
+ }
+
+ }
+
+ // clean it all up
+ for (i in chart) {
+ delete chart[i];
+ }
+
+ },
+
+
+ /**
+ * VML namespaces can't be added until after complete. Listening
+ * for Perini's doScroll hack is not enough.
+ */
+ isReadyToRender: function () {
+ var chart = this;
+
+ // Note: in spite of JSLint's complaints, win == win.top is required
+ /*jslint eqeq: true*/
+ if ((!hasSVG && (win == win.top && doc.readyState !== 'complete')) || (useCanVG && !win.canvg)) {
+ /*jslint eqeq: false*/
+ if (useCanVG) {
+ // Delay rendering until canvg library is downloaded and ready
+ CanVGController.push(function () { chart.firstRender(); }, chart.options.global.canvasToolsURL);
+ } else {
+ doc.attachEvent('onreadystatechange', function () {
+ doc.detachEvent('onreadystatechange', chart.firstRender);
+ if (doc.readyState === 'complete') {
+ chart.firstRender();
+ }
+ });
+ }
+ return false;
+ }
+ return true;
+ },
+
+ /**
+ * Prepare for first rendering after all data are loaded
+ */
+ firstRender: function () {
+ var chart = this,
+ options = chart.options,
+ callback = chart.callback;
+
+ // Check whether the chart is ready to render
+ if (!chart.isReadyToRender()) {
+ return;
+ }
+
+ // Create the container
+ chart.getContainer();
+
+ // Run an early event after the container and renderer are established
+ fireEvent(chart, 'init');
+
+
+ chart.resetMargins();
+ chart.setChartSize();
+
+ // Set the common chart properties (mainly invert) from the given series
+ chart.propFromSeries();
+
+ // get axes
+ chart.getAxes();
+
+ // Initialize the series
+ each(options.series || [], function (serieOptions) {
+ chart.initSeries(serieOptions);
+ });
+
+ chart.linkSeries();
+
+ // Run an event after axes and series are initialized, but before render. At this stage,
+ // the series data is indexed and cached in the xData and yData arrays, so we can access
+ // those before rendering. Used in Highstock.
+ fireEvent(chart, 'beforeRender');
+
+ // depends on inverted and on margins being set
+ if (Highcharts.Pointer) {
+ chart.pointer = new Pointer(chart, options);
+ }
+
+ chart.render();
+
+ // add canvas
+ chart.renderer.draw();
+ // run callbacks
+ if (callback) {
+ callback.apply(chart, [chart]);
+ }
+ each(chart.callbacks, function (fn) {
+ if (chart.index !== UNDEFINED) { // Chart destroyed in its own callback (#3600)
+ fn.apply(chart, [chart]);
+ }
+ });
+
+ // Fire the load event
+ fireEvent(chart, 'load');
+
+ // If the chart was rendered outside the top container, put it back in (#3679)
+ chart.cloneRenderTo(true);
+
+ },
+
+ /**
+ * Creates arrays for spacing and margin from given options.
+ */
+ splashArray: function (target, options) {
+ var oVar = options[target],
+ tArray = isObject(oVar) ? oVar : [oVar, oVar, oVar, oVar];
+
+ return [pick(options[target + 'Top'], tArray[0]),
+ pick(options[target + 'Right'], tArray[1]),
+ pick(options[target + 'Bottom'], tArray[2]),
+ pick(options[target + 'Left'], tArray[3])];
+ }
+}; // end Chart
+
+
+
+var CenteredSeriesMixin = Highcharts.CenteredSeriesMixin = {
+ /**
+ * Get the center of the pie based on the size and center options relative to the
+ * plot area. Borrowed by the polar and gauge series types.
+ */
+ getCenter: function () {
+
+ var options = this.options,
+ chart = this.chart,
+ slicingRoom = 2 * (options.slicedOffset || 0),
+ handleSlicingRoom,
+ plotWidth = chart.plotWidth - 2 * slicingRoom,
+ plotHeight = chart.plotHeight - 2 * slicingRoom,
+ centerOption = options.center,
+ positions = [pick(centerOption[0], '50%'), pick(centerOption[1], '50%'), options.size || '100%', options.innerSize || 0],
+ smallestSize = mathMin(plotWidth, plotHeight),
+ i,
+ value;
+
+ for (i = 0; i < 4; ++i) {
+ value = positions[i];
+ handleSlicingRoom = i < 2 || (i === 2 && /%$/.test(value));
+
+ // i == 0: centerX, relative to width
+ // i == 1: centerY, relative to height
+ // i == 2: size, relative to smallestSize
+ // i == 3: innerSize, relative to size
+ positions[i] = relativeLength(value, [plotWidth, plotHeight, smallestSize, positions[2]][i]) +
+ (handleSlicingRoom ? slicingRoom : 0);
+
+ }
+ // innerSize cannot be larger than size (#3632)
+ if (positions[3] > positions[2]) {
+ positions[3] = positions[2];
+ }
+ return positions;
+ }
+};
+
+
+
+/**
+ * The Point object and prototype. Inheritable and used as base for PiePoint
+ */
+var Point = function () {};
+Point.prototype = {
+
+ /**
+ * Initialize the point
+ * @param {Object} series The series object containing this point
+ * @param {Object} options The data in either number, array or object format
+ */
+ init: function (series, options, x) {
+
+ var point = this,
+ colors;
+ point.series = series;
+ point.color = series.color; // #3445
+ point.applyOptions(options, x);
+ point.pointAttr = {};
+
+ if (series.options.colorByPoint) {
+ colors = series.options.colors || series.chart.options.colors;
+ point.color = point.color || colors[series.colorCounter++];
+ // loop back to zero
+ if (series.colorCounter === colors.length) {
+ series.colorCounter = 0;
+ }
+ }
+
+ series.chart.pointCount++;
+ return point;
+ },
+ /**
+ * Apply the options containing the x and y data and possible some extra properties.
+ * This is called on point init or from point.update.
+ *
+ * @param {Object} options
+ */
+ applyOptions: function (options, x) {
+ var point = this,
+ series = point.series,
+ pointValKey = series.options.pointValKey || series.pointValKey;
+
+ options = Point.prototype.optionsToObject.call(this, options);
+
+ // copy options directly to point
+ extend(point, options);
+ point.options = point.options ? extend(point.options, options) : options;
+
+ // For higher dimension series types. For instance, for ranges, point.y is mapped to point.low.
+ if (pointValKey) {
+ point.y = point[pointValKey];
+ }
+
+ // If no x is set by now, get auto incremented value. All points must have an
+ // x value, however the y value can be null to create a gap in the series
+ if (point.x === UNDEFINED && series) {
+ point.x = x === UNDEFINED ? series.autoIncrement() : x;
+ }
+
+ return point;
+ },
+
+ /**
+ * Transform number or array configs into objects
+ */
+ optionsToObject: function (options) {
+ var ret = {},
+ series = this.series,
+ keys = series.options.keys,
+ pointArrayMap = keys || series.pointArrayMap || ['y'],
+ valueCount = pointArrayMap.length,
+ firstItemType,
+ i = 0,
+ j = 0;
+
+ if (typeof options === 'number' || options === null) {
+ ret[pointArrayMap[0]] = options;
+
+ } else if (isArray(options)) {
+ // with leading x value
+ if (!keys && options.length > valueCount) {
+ firstItemType = typeof options[0];
+ if (firstItemType === 'string') {
+ ret.name = options[0];
+ } else if (firstItemType === 'number') {
+ ret.x = options[0];
+ }
+ i++;
+ }
+ while (j < valueCount) {
+ if (!keys || options[i] !== undefined) { // Skip undefined positions for keys
+ ret[pointArrayMap[j]] = options[i];
+ }
+ i++;
+ j++;
+ }
+ } else if (typeof options === 'object') {
+ ret = options;
+
+ // This is the fastest way to detect if there are individual point dataLabels that need
+ // to be considered in drawDataLabels. These can only occur in object configs.
+ if (options.dataLabels) {
+ series._hasPointLabels = true;
+ }
+
+ // Same approach as above for markers
+ if (options.marker) {
+ series._hasPointMarkers = true;
+ }
+ }
+ return ret;
+ },
+
+ /**
+ * Destroy a point to clear memory. Its reference still stays in series.data.
+ */
+ destroy: function () {
+ var point = this,
+ series = point.series,
+ chart = series.chart,
+ hoverPoints = chart.hoverPoints,
+ prop;
+
+ chart.pointCount--;
+
+ if (hoverPoints) {
+ point.setState();
+ erase(hoverPoints, point);
+ if (!hoverPoints.length) {
+ chart.hoverPoints = null;
+ }
+
+ }
+ if (point === chart.hoverPoint) {
+ point.onMouseOut();
+ }
+
+ // remove all events
+ if (point.graphic || point.dataLabel) { // removeEvent and destroyElements are performance expensive
+ removeEvent(point);
+ point.destroyElements();
+ }
+
+ if (point.legendItem) { // pies have legend items
+ chart.legend.destroyItem(point);
+ }
+
+ for (prop in point) {
+ point[prop] = null;
+ }
+
+
+ },
+
+ /**
+ * Destroy SVG elements associated with the point
+ */
+ destroyElements: function () {
+ var point = this,
+ props = ['graphic', 'dataLabel', 'dataLabelUpper', 'connector', 'shadowGroup'],
+ prop,
+ i = 6;
+ while (i--) {
+ prop = props[i];
+ if (point[prop]) {
+ point[prop] = point[prop].destroy();
+ }
+ }
+ },
+
+ /**
+ * Return the configuration hash needed for the data label and tooltip formatters
+ */
+ getLabelConfig: function () {
+ return {
+ x: this.category,
+ y: this.y,
+ color: this.color,
+ key: this.name || this.category,
+ series: this.series,
+ point: this,
+ percentage: this.percentage,
+ total: this.total || this.stackTotal
+ };
+ },
+
+ /**
+ * Extendable method for formatting each point's tooltip line
+ *
+ * @return {String} A string to be concatenated in to the common tooltip text
+ */
+ tooltipFormatter: function (pointFormat) {
+
+ // Insert options for valueDecimals, valuePrefix, and valueSuffix
+ var series = this.series,
+ seriesTooltipOptions = series.tooltipOptions,
+ valueDecimals = pick(seriesTooltipOptions.valueDecimals, ''),
+ valuePrefix = seriesTooltipOptions.valuePrefix || '',
+ valueSuffix = seriesTooltipOptions.valueSuffix || '';
+
+ // Loop over the point array map and replace unformatted values with sprintf formatting markup
+ each(series.pointArrayMap || ['y'], function (key) {
+ key = '{point.' + key; // without the closing bracket
+ if (valuePrefix || valueSuffix) {
+ pointFormat = pointFormat.replace(key + '}', valuePrefix + key + '}' + valueSuffix);
+ }
+ pointFormat = pointFormat.replace(key + '}', key + ':,.' + valueDecimals + 'f}');
+ });
+
+ return format(pointFormat, {
+ point: this,
+ series: this.series
+ });
+ },
+
+ /**
+ * Fire an event on the Point object. Must not be renamed to fireEvent, as this
+ * causes a name clash in MooTools
+ * @param {String} eventType
+ * @param {Object} eventArgs Additional event arguments
+ * @param {Function} defaultFunction Default event handler
+ */
+ firePointEvent: function (eventType, eventArgs, defaultFunction) {
+ var point = this,
+ series = this.series,
+ seriesOptions = series.options;
+
+ // load event handlers on demand to save time on mouseover/out
+ if (seriesOptions.point.events[eventType] || (point.options && point.options.events && point.options.events[eventType])) {
+ this.importEvents();
+ }
+
+ // add default handler if in selection mode
+ if (eventType === 'click' && seriesOptions.allowPointSelect) {
+ defaultFunction = function (event) {
+ // Control key is for Windows, meta (= Cmd key) for Mac, Shift for Opera
+ if (point.select) { // Could be destroyed by prior event handlers (#2911)
+ point.select(null, event.ctrlKey || event.metaKey || event.shiftKey);
+ }
+ };
+ }
+
+ fireEvent(this, eventType, eventArgs, defaultFunction);
+ },
+ visible: true
+};
+
+/**
+ * @classDescription The base function which all other series types inherit from. The data in the series is stored
+ * in various arrays.
+ *
+ * - First, series.options.data contains all the original config options for
+ * each point whether added by options or methods like series.addPoint.
+ * - Next, series.data contains those values converted to points, but in case the series data length
+ * exceeds the cropThreshold, or if the data is grouped, series.data doesn't contain all the points. It
+ * only contains the points that have been created on demand.
+ * - Then there's series.points that contains all currently visible point objects. In case of cropping,
+ * the cropped-away points are not part of this array. The series.points array starts at series.cropStart
+ * compared to series.data and series.options.data. If however the series data is grouped, these can't
+ * be correlated one to one.
+ * - series.xData and series.processedXData contain clean x values, equivalent to series.data and series.points.
+ * - series.yData and series.processedYData contain clean x values, equivalent to series.data and series.points.
+ *
+ * @param {Object} chart
+ * @param {Object} options
+ */
+var Series = Highcharts.Series = function () {};
+
+Series.prototype = {
+
+ isCartesian: true,
+ type: 'line',
+ pointClass: Point,
+ sorted: true, // requires the data to be sorted
+ requireSorting: true,
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ stroke: 'lineColor',
+ 'stroke-width': 'lineWidth',
+ fill: 'fillColor',
+ r: 'radius'
+ },
+ directTouch: false,
+ axisTypes: ['xAxis', 'yAxis'],
+ colorCounter: 0,
+ parallelArrays: ['x', 'y'], // each point's x and y values are stored in this.xData and this.yData
+ init: function (chart, options) {
+ var series = this,
+ eventType,
+ events,
+ chartSeries = chart.series,
+ sortByIndex = function (a, b) {
+ return pick(a.options.index, a._i) - pick(b.options.index, b._i);
+ };
+
+ series.chart = chart;
+ series.options = options = series.setOptions(options); // merge with plotOptions
+ series.linkedSeries = [];
+
+ // bind the axes
+ series.bindAxes();
+
+ // set some variables
+ extend(series, {
+ name: options.name,
+ state: NORMAL_STATE,
+ pointAttr: {},
+ visible: options.visible !== false, // true by default
+ selected: options.selected === true // false by default
+ });
+
+ // special
+ if (useCanVG) {
+ options.animation = false;
+ }
+
+ // register event listeners
+ events = options.events;
+ for (eventType in events) {
+ addEvent(series, eventType, events[eventType]);
+ }
+ if (
+ (events && events.click) ||
+ (options.point && options.point.events && options.point.events.click) ||
+ options.allowPointSelect
+ ) {
+ chart.runTrackerClick = true;
+ }
+
+ series.getColor();
+ series.getSymbol();
+
+ // Set the data
+ each(series.parallelArrays, function (key) {
+ series[key + 'Data'] = [];
+ });
+ series.setData(options.data, false);
+
+ // Mark cartesian
+ if (series.isCartesian) {
+ chart.hasCartesianSeries = true;
+ }
+
+ // Register it in the chart
+ chartSeries.push(series);
+ series._i = chartSeries.length - 1;
+
+ // Sort series according to index option (#248, #1123, #2456)
+ stableSort(chartSeries, sortByIndex);
+ if (this.yAxis) {
+ stableSort(this.yAxis.series, sortByIndex);
+ }
+
+ each(chartSeries, function (series, i) {
+ series.index = i;
+ series.name = series.name || 'Series ' + (i + 1);
+ });
+
+ },
+
+ /**
+ * Set the xAxis and yAxis properties of cartesian series, and register the series
+ * in the axis.series array
+ */
+ bindAxes: function () {
+ var series = this,
+ seriesOptions = series.options,
+ chart = series.chart,
+ axisOptions;
+
+ each(series.axisTypes || [], function (AXIS) { // repeat for xAxis and yAxis
+
+ each(chart[AXIS], function (axis) { // loop through the chart's axis objects
+ axisOptions = axis.options;
+
+ // apply if the series xAxis or yAxis option mathches the number of the
+ // axis, or if undefined, use the first axis
+ if ((seriesOptions[AXIS] === axisOptions.index) ||
+ (seriesOptions[AXIS] !== UNDEFINED && seriesOptions[AXIS] === axisOptions.id) ||
+ (seriesOptions[AXIS] === UNDEFINED && axisOptions.index === 0)) {
+
+ // register this series in the axis.series lookup
+ axis.series.push(series);
+
+ // set this series.xAxis or series.yAxis reference
+ series[AXIS] = axis;
+
+ // mark dirty for redraw
+ axis.isDirty = true;
+ }
+ });
+
+ // The series needs an X and an Y axis
+ if (!series[AXIS] && series.optionalAxis !== AXIS) {
+ error(18, true);
+ }
+
+ });
+ },
+
+ /**
+ * For simple series types like line and column, the data values are held in arrays like
+ * xData and yData for quick lookup to find extremes and more. For multidimensional series
+ * like bubble and map, this can be extended with arrays like zData and valueData by
+ * adding to the series.parallelArrays array.
+ */
+ updateParallelArrays: function (point, i) {
+ var series = point.series,
+ args = arguments,
+ fn = typeof i === 'number' ?
+ // Insert the value in the given position
+ function (key) {
+ var val = key === 'y' && series.toYData ? series.toYData(point) : point[key];
+ series[key + 'Data'][i] = val;
+ } :
+ // Apply the method specified in i with the following arguments as arguments
+ function (key) {
+ Array.prototype[i].apply(series[key + 'Data'], Array.prototype.slice.call(args, 2));
+ };
+
+ each(series.parallelArrays, fn);
+ },
+
+ /**
+ * Return an auto incremented x value based on the pointStart and pointInterval options.
+ * This is only used if an x value is not given for the point that calls autoIncrement.
+ */
+ autoIncrement: function () {
+
+ var options = this.options,
+ xIncrement = this.xIncrement,
+ date,
+ pointInterval,
+ pointIntervalUnit = options.pointIntervalUnit;
+
+ xIncrement = pick(xIncrement, options.pointStart, 0);
+
+ this.pointInterval = pointInterval = pick(this.pointInterval, options.pointInterval, 1);
+
+ // Added code for pointInterval strings
+ if (pointIntervalUnit === 'month' || pointIntervalUnit === 'year') {
+ date = new Date(xIncrement);
+ date = (pointIntervalUnit === 'month') ?
+ +date[setMonth](date[getMonth]() + pointInterval) :
+ +date[setFullYear](date[getFullYear]() + pointInterval);
+ pointInterval = date - xIncrement;
+ }
+
+ this.xIncrement = xIncrement + pointInterval;
+ return xIncrement;
+ },
+
+ /**
+ * Divide the series data into segments divided by null values.
+ */
+ getSegments: function () {
+ var series = this,
+ lastNull = -1,
+ segments = [],
+ i,
+ points = series.points,
+ pointsLength = points.length;
+
+ if (pointsLength) { // no action required for []
+
+ // if connect nulls, just remove null points
+ if (series.options.connectNulls) {
+ i = pointsLength;
+ while (i--) {
+ if (points[i].y === null) {
+ points.splice(i, 1);
+ }
+ }
+ if (points.length) {
+ segments = [points];
+ }
+
+ // else, split on null points
+ } else {
+ each(points, function (point, i) {
+ if (point.y === null) {
+ if (i > lastNull + 1) {
+ segments.push(points.slice(lastNull + 1, i));
+ }
+ lastNull = i;
+ } else if (i === pointsLength - 1) { // last value
+ segments.push(points.slice(lastNull + 1, i + 1));
+ }
+ });
+ }
+ }
+
+ // register it
+ series.segments = segments;
+ },
+
+ /**
+ * Set the series options by merging from the options tree
+ * @param {Object} itemOptions
+ */
+ setOptions: function (itemOptions) {
+ var chart = this.chart,
+ chartOptions = chart.options,
+ plotOptions = chartOptions.plotOptions,
+ userOptions = chart.userOptions || {},
+ userPlotOptions = userOptions.plotOptions || {},
+ typeOptions = plotOptions[this.type],
+ options,
+ zones;
+
+ this.userOptions = itemOptions;
+
+ // General series options take precedence over type options because otherwise, default
+ // type options like column.animation would be overwritten by the general option.
+ // But issues have been raised here (#3881), and the solution may be to distinguish
+ // between default option and userOptions like in the tooltip below.
+ options = merge(
+ typeOptions,
+ plotOptions.series,
+ itemOptions
+ );
+
+ // The tooltip options are merged between global and series specific options
+ this.tooltipOptions = merge(
+ defaultOptions.tooltip,
+ defaultOptions.plotOptions[this.type].tooltip,
+ userOptions.tooltip,
+ userPlotOptions.series && userPlotOptions.series.tooltip,
+ userPlotOptions[this.type] && userPlotOptions[this.type].tooltip,
+ itemOptions.tooltip
+ );
+
+ // Delete marker object if not allowed (#1125)
+ if (typeOptions.marker === null) {
+ delete options.marker;
+ }
+
+ // Handle color zones
+ this.zoneAxis = options.zoneAxis;
+ zones = this.zones = (options.zones || []).slice();
+ if ((options.negativeColor || options.negativeFillColor) && !options.zones) {
+ zones.push({
+ value: options[this.zoneAxis + 'Threshold'] || options.threshold || 0,
+ color: options.negativeColor,
+ fillColor: options.negativeFillColor
+ });
+ }
+ if (zones.length) { // Push one extra zone for the rest
+ if (defined(zones[zones.length - 1].value)) {
+ zones.push({
+ color: this.color,
+ fillColor: this.fillColor
+ });
+ }
+ }
+ return options;
+ },
+
+ getCyclic: function (prop, value, defaults) {
+ var i,
+ userOptions = this.userOptions,
+ indexName = '_' + prop + 'Index',
+ counterName = prop + 'Counter';
+
+ if (!value) {
+ if (defined(userOptions[indexName])) { // after Series.update()
+ i = userOptions[indexName];
+ } else {
+ userOptions[indexName] = i = this.chart[counterName] % defaults.length;
+ this.chart[counterName] += 1;
+ }
+ value = defaults[i];
+ }
+ this[prop] = value;
+ },
+
+ /**
+ * Get the series' color
+ */
+ getColor: function () {
+ if (this.options.colorByPoint) {
+ this.options.color = null; // #4359, selected slice got series.color even when colorByPoint was set.
+ } else {
+ this.getCyclic('color', this.options.color || defaultPlotOptions[this.type].color, this.chart.options.colors);
+ }
+ },
+ /**
+ * Get the series' symbol
+ */
+ getSymbol: function () {
+ var seriesMarkerOption = this.options.marker;
+
+ this.getCyclic('symbol', seriesMarkerOption.symbol, this.chart.options.symbols);
+
+ // don't substract radius in image symbols (#604)
+ if (/^url/.test(this.symbol)) {
+ seriesMarkerOption.radius = 0;
+ }
+ },
+
+ drawLegendSymbol: LegendSymbolMixin.drawLineMarker,
+
+ /**
+ * Replace the series data with a new set of data
+ * @param {Object} data
+ * @param {Object} redraw
+ */
+ setData: function (data, redraw, animation, updatePoints) {
+ var series = this,
+ oldData = series.points,
+ oldDataLength = (oldData && oldData.length) || 0,
+ dataLength,
+ options = series.options,
+ chart = series.chart,
+ firstPoint = null,
+ xAxis = series.xAxis,
+ hasCategories = xAxis && !!xAxis.categories,
+ i,
+ turboThreshold = options.turboThreshold,
+ pt,
+ xData = this.xData,
+ yData = this.yData,
+ pointArrayMap = series.pointArrayMap,
+ valueCount = pointArrayMap && pointArrayMap.length;
+
+ data = data || [];
+ dataLength = data.length;
+ redraw = pick(redraw, true);
+
+ // If the point count is the same as is was, just run Point.update which is
+ // cheaper, allows animation, and keeps references to points.
+ if (updatePoints !== false && dataLength && oldDataLength === dataLength && !series.cropped && !series.hasGroupedData && series.visible) {
+ each(data, function (point, i) {
+ if (oldData[i].update) { // Linked, previously hidden series (#3709)
+ oldData[i].update(point, false, null, false);
+ }
+ });
+
+ } else {
+
+ // Reset properties
+ series.xIncrement = null;
+ series.pointRange = hasCategories ? 1 : options.pointRange;
+
+ series.colorCounter = 0; // for series with colorByPoint (#1547)
+
+ // Update parallel arrays
+ each(this.parallelArrays, function (key) {
+ series[key + 'Data'].length = 0;
+ });
+
+ // In turbo mode, only one- or twodimensional arrays of numbers are allowed. The
+ // first value is tested, and we assume that all the rest are defined the same
+ // way. Although the 'for' loops are similar, they are repeated inside each
+ // if-else conditional for max performance.
+ if (turboThreshold && dataLength > turboThreshold) {
+
+ // find the first non-null point
+ i = 0;
+ while (firstPoint === null && i < dataLength) {
+ firstPoint = data[i];
+ i++;
+ }
+
+
+ if (isNumber(firstPoint)) { // assume all points are numbers
+ var x = pick(options.pointStart, 0),
+ pointInterval = pick(options.pointInterval, 1);
+
+ for (i = 0; i < dataLength; i++) {
+ xData[i] = x;
+ yData[i] = data[i];
+ x += pointInterval;
+ }
+ series.xIncrement = x;
+ } else if (isArray(firstPoint)) { // assume all points are arrays
+ if (valueCount) { // [x, low, high] or [x, o, h, l, c]
+ for (i = 0; i < dataLength; i++) {
+ pt = data[i];
+ xData[i] = pt[0];
+ yData[i] = pt.slice(1, valueCount + 1);
+ }
+ } else { // [x, y]
+ for (i = 0; i < dataLength; i++) {
+ pt = data[i];
+ xData[i] = pt[0];
+ yData[i] = pt[1];
+ }
+ }
+ } else {
+ error(12); // Highcharts expects configs to be numbers or arrays in turbo mode
+ }
+ } else {
+ for (i = 0; i < dataLength; i++) {
+ if (data[i] !== UNDEFINED) { // stray commas in oldIE
+ pt = { series: series };
+ series.pointClass.prototype.applyOptions.apply(pt, [data[i]]);
+ series.updateParallelArrays(pt, i);
+ if (hasCategories && defined(pt.name)) { // #4401
+ xAxis.names[pt.x] = pt.name; // #2046
+ }
+ }
+ }
+ }
+
+ // Forgetting to cast strings to numbers is a common caveat when handling CSV or JSON
+ if (isString(yData[0])) {
+ error(14, true);
+ }
+
+ series.data = [];
+ series.options.data = data;
+ //series.zData = zData;
+
+ // destroy old points
+ i = oldDataLength;
+ while (i--) {
+ if (oldData[i] && oldData[i].destroy) {
+ oldData[i].destroy();
+ }
+ }
+
+ // reset minRange (#878)
+ if (xAxis) {
+ xAxis.minRange = xAxis.userMinRange;
+ }
+
+ // redraw
+ series.isDirty = series.isDirtyData = chart.isDirtyBox = true;
+ animation = false;
+ }
+
+ // Typically for pie series, points need to be processed and generated
+ // prior to rendering the legend
+ if (options.legendType === 'point') { // docs: legendType now supported on more series types (at least column and pie)
+ this.processData();
+ this.generatePoints();
+ }
+
+ if (redraw) {
+ chart.redraw(animation);
+ }
+ },
+
+ /**
+ * Process the data by cropping away unused data points if the series is longer
+ * than the crop threshold. This saves computing time for lage series.
+ */
+ processData: function (force) {
+ var series = this,
+ processedXData = series.xData, // copied during slice operation below
+ processedYData = series.yData,
+ dataLength = processedXData.length,
+ croppedData,
+ cropStart = 0,
+ cropped,
+ distance,
+ closestPointRange,
+ xAxis = series.xAxis,
+ i, // loop variable
+ options = series.options,
+ cropThreshold = options.cropThreshold,
+ getExtremesFromAll = series.getExtremesFromAll || options.getExtremesFromAll, // #4599
+ isCartesian = series.isCartesian,
+ xExtremes,
+ min,
+ max;
+
+ // If the series data or axes haven't changed, don't go through this. Return false to pass
+ // the message on to override methods like in data grouping.
+ if (isCartesian && !series.isDirty && !xAxis.isDirty && !series.yAxis.isDirty && !force) {
+ return false;
+ }
+
+ if (xAxis) {
+ xExtremes = xAxis.getExtremes(); // corrected for log axis (#3053)
+ min = xExtremes.min;
+ max = xExtremes.max;
+ }
+
+ // optionally filter out points outside the plot area
+ if (isCartesian && series.sorted && !getExtremesFromAll && (!cropThreshold || dataLength > cropThreshold || series.forceCrop)) {
+
+ // it's outside current extremes
+ if (processedXData[dataLength - 1] < min || processedXData[0] > max) {
+ processedXData = [];
+ processedYData = [];
+
+ // only crop if it's actually spilling out
+ } else if (processedXData[0] < min || processedXData[dataLength - 1] > max) {
+ croppedData = this.cropData(series.xData, series.yData, min, max);
+ processedXData = croppedData.xData;
+ processedYData = croppedData.yData;
+ cropStart = croppedData.start;
+ cropped = true;
+ }
+ }
+
+
+ // Find the closest distance between processed points
+ for (i = processedXData.length - 1; i >= 0; i--) {
+ distance = processedXData[i] - processedXData[i - 1];
+
+ if (distance > 0 && (closestPointRange === UNDEFINED || distance < closestPointRange)) {
+ closestPointRange = distance;
+
+ // Unsorted data is not supported by the line tooltip, as well as data grouping and
+ // navigation in Stock charts (#725) and width calculation of columns (#1900)
+ } else if (distance < 0 && series.requireSorting) {
+ error(15);
+ }
+ }
+
+ // Record the properties
+ series.cropped = cropped; // undefined or true
+ series.cropStart = cropStart;
+ series.processedXData = processedXData;
+ series.processedYData = processedYData;
+
+ if (options.pointRange === null) { // null means auto, as for columns, candlesticks and OHLC
+ series.pointRange = closestPointRange || 1;
+ }
+ series.closestPointRange = closestPointRange;
+
+ },
+
+ /**
+ * Iterate over xData and crop values between min and max. Returns object containing crop start/end
+ * cropped xData with corresponding part of yData, dataMin and dataMax within the cropped range
+ */
+ cropData: function (xData, yData, min, max) {
+ var dataLength = xData.length,
+ cropStart = 0,
+ cropEnd = dataLength,
+ cropShoulder = pick(this.cropShoulder, 1), // line-type series need one point outside
+ i;
+
+ // iterate up to find slice start
+ for (i = 0; i < dataLength; i++) {
+ if (xData[i] >= min) {
+ cropStart = mathMax(0, i - cropShoulder);
+ break;
+ }
+ }
+
+ // proceed to find slice end
+ for (; i < dataLength; i++) {
+ if (xData[i] > max) {
+ cropEnd = i + cropShoulder;
+ break;
+ }
+ }
+
+ return {
+ xData: xData.slice(cropStart, cropEnd),
+ yData: yData.slice(cropStart, cropEnd),
+ start: cropStart,
+ end: cropEnd
+ };
+ },
+
+
+ /**
+ * Generate the data point after the data has been processed by cropping away
+ * unused points and optionally grouped in Highcharts Stock.
+ */
+ generatePoints: function () {
+ var series = this,
+ options = series.options,
+ dataOptions = options.data,
+ data = series.data,
+ dataLength,
+ processedXData = series.processedXData,
+ processedYData = series.processedYData,
+ pointClass = series.pointClass,
+ processedDataLength = processedXData.length,
+ cropStart = series.cropStart || 0,
+ cursor,
+ hasGroupedData = series.hasGroupedData,
+ point,
+ points = [],
+ i;
+
+ if (!data && !hasGroupedData) {
+ var arr = [];
+ arr.length = dataOptions.length;
+ data = series.data = arr;
+ }
+
+ for (i = 0; i < processedDataLength; i++) {
+ cursor = cropStart + i;
+ if (!hasGroupedData) {
+ if (data[cursor]) {
+ point = data[cursor];
+ } else if (dataOptions[cursor] !== UNDEFINED) { // #970
+ data[cursor] = point = (new pointClass()).init(series, dataOptions[cursor], processedXData[i]);
+ }
+ points[i] = point;
+ } else {
+ // splat the y data in case of ohlc data array
+ points[i] = (new pointClass()).init(series, [processedXData[i]].concat(splat(processedYData[i])));
+ }
+ points[i].index = cursor; // For faster access in Point.update
+ }
+
+ // Hide cropped-away points - this only runs when the number of points is above cropThreshold, or when
+ // swithching view from non-grouped data to grouped data (#637)
+ if (data && (processedDataLength !== (dataLength = data.length) || hasGroupedData)) {
+ for (i = 0; i < dataLength; i++) {
+ if (i === cropStart && !hasGroupedData) { // when has grouped data, clear all points
+ i += processedDataLength;
+ }
+ if (data[i]) {
+ data[i].destroyElements();
+ data[i].plotX = UNDEFINED; // #1003
+ }
+ }
+ }
+
+ series.data = data;
+ series.points = points;
+ },
+
+ /**
+ * Calculate Y extremes for visible data
+ */
+ getExtremes: function (yData) {
+ var xAxis = this.xAxis,
+ yAxis = this.yAxis,
+ xData = this.processedXData,
+ yDataLength,
+ activeYData = [],
+ activeCounter = 0,
+ xExtremes = xAxis.getExtremes(), // #2117, need to compensate for log X axis
+ xMin = xExtremes.min,
+ xMax = xExtremes.max,
+ validValue,
+ withinRange,
+ x,
+ y,
+ i,
+ j;
+
+ yData = yData || this.stackedYData || this.processedYData;
+ yDataLength = yData.length;
+
+ for (i = 0; i < yDataLength; i++) {
+
+ x = xData[i];
+ y = yData[i];
+
+ // For points within the visible range, including the first point outside the
+ // visible range, consider y extremes
+ validValue = y !== null && y !== UNDEFINED && (!yAxis.isLog || (y.length || y > 0));
+ withinRange = this.getExtremesFromAll || this.options.getExtremesFromAll || this.cropped ||
+ ((xData[i + 1] || x) >= xMin && (xData[i - 1] || x) <= xMax);
+
+ if (validValue && withinRange) {
+
+ j = y.length;
+ if (j) { // array, like ohlc or range data
+ while (j--) {
+ if (y[j] !== null) {
+ activeYData[activeCounter++] = y[j];
+ }
+ }
+ } else {
+ activeYData[activeCounter++] = y;
+ }
+ }
+ }
+ this.dataMin = arrayMin(activeYData);
+ this.dataMax = arrayMax(activeYData);
+ },
+
+ /**
+ * Translate data points from raw data values to chart specific positioning data
+ * needed later in drawPoints, drawGraph and drawTracker.
+ */
+ translate: function () {
+ if (!this.processedXData) { // hidden series
+ this.processData();
+ }
+ this.generatePoints();
+ var series = this,
+ options = series.options,
+ stacking = options.stacking,
+ xAxis = series.xAxis,
+ categories = xAxis.categories,
+ yAxis = series.yAxis,
+ points = series.points,
+ dataLength = points.length,
+ hasModifyValue = !!series.modifyValue,
+ i,
+ pointPlacement = options.pointPlacement,
+ dynamicallyPlaced = pointPlacement === 'between' || isNumber(pointPlacement),
+ threshold = options.threshold,
+ stackThreshold = options.startFromThreshold ? threshold : 0,
+ plotX,
+ plotY,
+ lastPlotX,
+ stackIndicator,
+ closestPointRangePx = Number.MAX_VALUE;
+
+ // Translate each point
+ for (i = 0; i < dataLength; i++) {
+ var point = points[i],
+ xValue = point.x,
+ yValue = point.y,
+ yBottom = point.low,
+ stack = stacking && yAxis.stacks[(series.negStacks && yValue < (stackThreshold ? 0 : threshold) ? '-' : '') + series.stackKey],
+ pointStack,
+ stackValues;
+
+ // Discard disallowed y values for log axes (#3434)
+ if (yAxis.isLog && yValue !== null && yValue <= 0) {
+ point.y = yValue = null;
+ error(10);
+ }
+
+ // Get the plotX translation
+ point.plotX = plotX = mathMin(mathMax(-1e5, xAxis.translate(xValue, 0, 0, 0, 1, pointPlacement, this.type === 'flags')), 1e5); // #3923
+
+
+ // Calculate the bottom y value for stacked series
+ if (stacking && series.visible && stack && stack[xValue]) {
+ stackIndicator = series.getStackIndicator(stackIndicator, xValue, series.index);
+ pointStack = stack[xValue];
+ stackValues = pointStack.points[stackIndicator.key];
+ yBottom = stackValues[0];
+ yValue = stackValues[1];
+
+ if (yBottom === stackThreshold) {
+ yBottom = pick(threshold, yAxis.min);
+ }
+ if (yAxis.isLog && yBottom <= 0) { // #1200, #1232
+ yBottom = null;
+ }
+
+ point.total = point.stackTotal = pointStack.total;
+ point.percentage = pointStack.total && (point.y / pointStack.total * 100);
+ point.stackY = yValue;
+
+ // Place the stack label
+ pointStack.setOffset(series.pointXOffset || 0, series.barW || 0);
+
+ }
+
+ // Set translated yBottom or remove it
+ point.yBottom = defined(yBottom) ?
+ yAxis.translate(yBottom, 0, 1, 0, 1) :
+ null;
+
+ // general hook, used for Highstock compare mode
+ if (hasModifyValue) {
+ yValue = series.modifyValue(yValue, point);
+ }
+
+ // Set the the plotY value, reset it for redraws
+ point.plotY = plotY = (typeof yValue === 'number' && yValue !== Infinity) ?
+ mathMin(mathMax(-1e5, yAxis.translate(yValue, 0, 1, 0, 1)), 1e5) : // #3201
+ UNDEFINED;
+ point.isInside = plotY !== UNDEFINED && plotY >= 0 && plotY <= yAxis.len && // #3519
+ plotX >= 0 && plotX <= xAxis.len;
+
+
+ // Set client related positions for mouse tracking
+ point.clientX = dynamicallyPlaced ? xAxis.translate(xValue, 0, 0, 0, 1) : plotX; // #1514
+
+ point.negative = point.y < (threshold || 0);
+
+ // some API data
+ point.category = categories && categories[point.x] !== UNDEFINED ?
+ categories[point.x] : point.x;
+
+ // Determine auto enabling of markers (#3635)
+ if (i) {
+ closestPointRangePx = mathMin(closestPointRangePx, mathAbs(plotX - lastPlotX));
+ }
+ lastPlotX = plotX;
+
+ }
+
+ series.closestPointRangePx = closestPointRangePx;
+
+ // now that we have the cropped data, build the segments
+ series.getSegments();
+ },
+
+ /**
+ * Set the clipping for the series. For animated series it is called twice, first to initiate
+ * animating the clip then the second time without the animation to set the final clip.
+ */
+ setClip: function (animation) {
+ var chart = this.chart,
+ options = this.options,
+ renderer = chart.renderer,
+ inverted = chart.inverted,
+ seriesClipBox = this.clipBox,
+ clipBox = seriesClipBox || chart.clipBox,
+ sharedClipKey = this.sharedClipKey || ['_sharedClip', animation && animation.duration, animation && animation.easing, clipBox.height, options.xAxis, options.yAxis].join(','), // #4526
+ clipRect = chart[sharedClipKey],
+ markerClipRect = chart[sharedClipKey + 'm'];
+
+ // If a clipping rectangle with the same properties is currently present in the chart, use that.
+ if (!clipRect) {
+
+ // When animation is set, prepare the initial positions
+ if (animation) {
+ clipBox.width = 0;
+
+ chart[sharedClipKey + 'm'] = markerClipRect = renderer.clipRect(
+ -99, // include the width of the first marker
+ inverted ? -chart.plotLeft : -chart.plotTop,
+ 99,
+ inverted ? chart.chartWidth : chart.chartHeight
+ );
+ }
+ chart[sharedClipKey] = clipRect = renderer.clipRect(clipBox);
+
+ }
+ if (animation) {
+ clipRect.count += 1;
+ }
+
+ if (options.clip !== false) {
+ this.group.clip(animation || seriesClipBox ? clipRect : chart.clipRect);
+ this.markerGroup.clip(markerClipRect);
+ this.sharedClipKey = sharedClipKey;
+ }
+
+ // Remove the shared clipping rectangle when all series are shown
+ if (!animation) {
+ clipRect.count -= 1;
+ if (clipRect.count <= 0 && sharedClipKey && chart[sharedClipKey]) {
+ if (!seriesClipBox) {
+ chart[sharedClipKey] = chart[sharedClipKey].destroy();
+ }
+ if (chart[sharedClipKey + 'm']) {
+ chart[sharedClipKey + 'm'] = chart[sharedClipKey + 'm'].destroy();
+ }
+ }
+ }
+ },
+
+ /**
+ * Animate in the series
+ */
+ animate: function (init) {
+ var series = this,
+ chart = series.chart,
+ clipRect,
+ animation = series.options.animation,
+ sharedClipKey;
+
+ // Animation option is set to true
+ if (animation && !isObject(animation)) {
+ animation = defaultPlotOptions[series.type].animation;
+ }
+
+ // Initialize the animation. Set up the clipping rectangle.
+ if (init) {
+
+ series.setClip(animation);
+
+ // Run the animation
+ } else {
+ sharedClipKey = this.sharedClipKey;
+ clipRect = chart[sharedClipKey];
+ if (clipRect) {
+ clipRect.animate({
+ width: chart.plotSizeX
+ }, animation);
+ }
+ if (chart[sharedClipKey + 'm']) {
+ chart[sharedClipKey + 'm'].animate({
+ width: chart.plotSizeX + 99
+ }, animation);
+ }
+
+ // Delete this function to allow it only once
+ series.animate = null;
+
+ }
+ },
+
+ /**
+ * This runs after animation to land on the final plot clipping
+ */
+ afterAnimate: function () {
+ this.setClip();
+ fireEvent(this, 'afterAnimate');
+ },
+
+ /**
+ * Draw the markers
+ */
+ drawPoints: function () {
+ var series = this,
+ pointAttr,
+ points = series.points,
+ chart = series.chart,
+ plotX,
+ plotY,
+ i,
+ point,
+ radius,
+ symbol,
+ isImage,
+ graphic,
+ options = series.options,
+ seriesMarkerOptions = options.marker,
+ seriesPointAttr = series.pointAttr[''],
+ pointMarkerOptions,
+ hasPointMarker,
+ enabled,
+ isInside,
+ markerGroup = series.markerGroup,
+ xAxis = series.xAxis,
+ globallyEnabled = pick(
+ seriesMarkerOptions.enabled,
+ xAxis.isRadial,
+ series.closestPointRangePx > 2 * seriesMarkerOptions.radius
+ );
+
+ if (seriesMarkerOptions.enabled !== false || series._hasPointMarkers) {
+
+ i = points.length;
+ while (i--) {
+ point = points[i];
+ plotX = mathFloor(point.plotX); // #1843
+ plotY = point.plotY;
+ graphic = point.graphic;
+ pointMarkerOptions = point.marker || {};
+ hasPointMarker = !!point.marker;
+ enabled = (globallyEnabled && pointMarkerOptions.enabled === UNDEFINED) || pointMarkerOptions.enabled;
+ isInside = point.isInside;
+
+ // only draw the point if y is defined
+ if (enabled && plotY !== UNDEFINED && !isNaN(plotY) && point.y !== null) {
+
+ // shortcuts
+ pointAttr = point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE] || seriesPointAttr;
+ radius = pointAttr.r;
+ symbol = pick(pointMarkerOptions.symbol, series.symbol);
+ isImage = symbol.indexOf('url') === 0;
+
+ if (graphic) { // update
+ graphic[isInside ? 'show' : 'hide'](true) // Since the marker group isn't clipped, each individual marker must be toggled
+ .animate(extend({
+ x: plotX - radius,
+ y: plotY - radius
+ }, graphic.symbolName ? { // don't apply to image symbols #507
+ width: 2 * radius,
+ height: 2 * radius
+ } : {}));
+ } else if (isInside && (radius > 0 || isImage)) {
+ point.graphic = graphic = chart.renderer.symbol(
+ symbol,
+ plotX - radius,
+ plotY - radius,
+ 2 * radius,
+ 2 * radius,
+ hasPointMarker ? pointMarkerOptions : seriesMarkerOptions
+ )
+ .attr(pointAttr)
+ .add(markerGroup);
+ }
+
+ } else if (graphic) {
+ point.graphic = graphic.destroy(); // #1269
+ }
+ }
+ }
+
+ },
+
+ /**
+ * Convert state properties from API naming conventions to SVG attributes
+ *
+ * @param {Object} options API options object
+ * @param {Object} base1 SVG attribute object to inherit from
+ * @param {Object} base2 Second level SVG attribute object to inherit from
+ */
+ convertAttribs: function (options, base1, base2, base3) {
+ var conversion = this.pointAttrToOptions,
+ attr,
+ option,
+ obj = {};
+
+ options = options || {};
+ base1 = base1 || {};
+ base2 = base2 || {};
+ base3 = base3 || {};
+
+ for (attr in conversion) {
+ option = conversion[attr];
+ obj[attr] = pick(options[option], base1[attr], base2[attr], base3[attr]);
+ }
+ return obj;
+ },
+
+ /**
+ * Get the state attributes. Each series type has its own set of attributes
+ * that are allowed to change on a point's state change. Series wide attributes are stored for
+ * all series, and additionally point specific attributes are stored for all
+ * points with individual marker options. If such options are not defined for the point,
+ * a reference to the series wide attributes is stored in point.pointAttr.
+ */
+ getAttribs: function () {
+ var series = this,
+ seriesOptions = series.options,
+ normalOptions = defaultPlotOptions[series.type].marker ? seriesOptions.marker : seriesOptions,
+ stateOptions = normalOptions.states,
+ stateOptionsHover = stateOptions[HOVER_STATE],
+ pointStateOptionsHover,
+ seriesColor = series.color,
+ seriesNegativeColor = series.options.negativeColor,
+ normalDefaults = {
+ stroke: seriesColor,
+ fill: seriesColor
+ },
+ points = series.points || [], // #927
+ i,
+ j,
+ threshold,
+ point,
+ seriesPointAttr = [],
+ pointAttr,
+ pointAttrToOptions = series.pointAttrToOptions,
+ hasPointSpecificOptions = series.hasPointSpecificOptions,
+ defaultLineColor = normalOptions.lineColor,
+ defaultFillColor = normalOptions.fillColor,
+ turboThreshold = seriesOptions.turboThreshold,
+ zones = series.zones,
+ zoneAxis = series.zoneAxis || 'y',
+ attr,
+ key;
+
+ // series type specific modifications
+ if (seriesOptions.marker) { // line, spline, area, areaspline, scatter
+
+ // if no hover radius is given, default to normal radius + 2
+ stateOptionsHover.radius = stateOptionsHover.radius || normalOptions.radius + stateOptionsHover.radiusPlus;
+ stateOptionsHover.lineWidth = stateOptionsHover.lineWidth || normalOptions.lineWidth + stateOptionsHover.lineWidthPlus;
+
+ } else { // column, bar, pie
+
+ // if no hover color is given, brighten the normal color
+ stateOptionsHover.color = stateOptionsHover.color ||
+ Color(stateOptionsHover.color || seriesColor)
+ .brighten(stateOptionsHover.brightness).get();
+
+ // if no hover negativeColor is given, brighten the normal negativeColor
+ stateOptionsHover.negativeColor = stateOptionsHover.negativeColor ||
+ Color(stateOptionsHover.negativeColor || seriesNegativeColor)
+ .brighten(stateOptionsHover.brightness).get();
+ }
+
+ // general point attributes for the series normal state
+ seriesPointAttr[NORMAL_STATE] = series.convertAttribs(normalOptions, normalDefaults);
+
+ // HOVER_STATE and SELECT_STATE states inherit from normal state except the default radius
+ each([HOVER_STATE, SELECT_STATE], function (state) {
+ seriesPointAttr[state] =
+ series.convertAttribs(stateOptions[state], seriesPointAttr[NORMAL_STATE]);
+ });
+
+ // set it
+ series.pointAttr = seriesPointAttr;
+
+
+ // Generate the point-specific attribute collections if specific point
+ // options are given. If not, create a referance to the series wide point
+ // attributes
+ i = points.length;
+ if (!turboThreshold || i < turboThreshold || hasPointSpecificOptions) {
+ while (i--) {
+ point = points[i];
+ normalOptions = (point.options && point.options.marker) || point.options;
+ if (normalOptions && normalOptions.enabled === false) {
+ normalOptions.radius = 0;
+ }
+
+ if (zones.length) {
+ j = 0;
+ threshold = zones[j];
+ while (point[zoneAxis] >= threshold.value) {
+ threshold = zones[++j];
+ }
+
+ point.color = point.fillColor = pick(threshold.color, series.color); // #3636, #4267, #4430 - inherit color from series, when color is undefined
+
+ }
+
+ hasPointSpecificOptions = seriesOptions.colorByPoint || point.color; // #868
+
+ // check if the point has specific visual options
+ if (point.options) {
+ for (key in pointAttrToOptions) {
+ if (defined(normalOptions[pointAttrToOptions[key]])) {
+ hasPointSpecificOptions = true;
+ }
+ }
+ }
+
+ // a specific marker config object is defined for the individual point:
+ // create it's own attribute collection
+ if (hasPointSpecificOptions) {
+ normalOptions = normalOptions || {};
+ pointAttr = [];
+ stateOptions = normalOptions.states || {}; // reassign for individual point
+ pointStateOptionsHover = stateOptions[HOVER_STATE] = stateOptions[HOVER_STATE] || {};
+
+ // Handle colors for column and pies
+ if (!seriesOptions.marker || (point.negative && !pointStateOptionsHover.fillColor && !stateOptionsHover.fillColor)) { // column, bar, point or negative threshold for series with markers (#3636)
+ // If no hover color is given, brighten the normal color. #1619, #2579
+ pointStateOptionsHover[series.pointAttrToOptions.fill] = pointStateOptionsHover.color || (!point.options.color && stateOptionsHover[(point.negative && seriesNegativeColor ? 'negativeColor' : 'color')]) ||
+ Color(point.color)
+ .brighten(pointStateOptionsHover.brightness || stateOptionsHover.brightness)
+ .get();
+ }
+
+ // normal point state inherits series wide normal state
+ attr = { color: point.color }; // #868
+ if (!defaultFillColor) { // Individual point color or negative color markers (#2219)
+ attr.fillColor = point.color;
+ }
+ if (!defaultLineColor) {
+ attr.lineColor = point.color; // Bubbles take point color, line markers use white
+ }
+ // Color is explicitly set to null or undefined (#1288, #4068)
+ if (normalOptions.hasOwnProperty('color') && !normalOptions.color) {
+ delete normalOptions.color;
+ }
+ pointAttr[NORMAL_STATE] = series.convertAttribs(extend(attr, normalOptions), seriesPointAttr[NORMAL_STATE]);
+
+ // inherit from point normal and series hover
+ pointAttr[HOVER_STATE] = series.convertAttribs(
+ stateOptions[HOVER_STATE],
+ seriesPointAttr[HOVER_STATE],
+ pointAttr[NORMAL_STATE]
+ );
+
+ // inherit from point normal and series hover
+ pointAttr[SELECT_STATE] = series.convertAttribs(
+ stateOptions[SELECT_STATE],
+ seriesPointAttr[SELECT_STATE],
+ pointAttr[NORMAL_STATE]
+ );
+
+
+ // no marker config object is created: copy a reference to the series-wide
+ // attribute collection
+ } else {
+ pointAttr = seriesPointAttr;
+ }
+
+ point.pointAttr = pointAttr;
+ }
+ }
+ },
+
+ /**
+ * Clear DOM objects and free up memory
+ */
+ destroy: function () {
+ var series = this,
+ chart = series.chart,
+ issue134 = /AppleWebKit\/533/.test(userAgent),
+ destroy,
+ i,
+ data = series.data || [],
+ point,
+ prop,
+ axis;
+
+ // add event hook
+ fireEvent(series, 'destroy');
+
+ // remove all events
+ removeEvent(series);
+
+ // erase from axes
+ each(series.axisTypes || [], function (AXIS) {
+ axis = series[AXIS];
+ if (axis) {
+ erase(axis.series, series);
+ axis.isDirty = axis.forceRedraw = true;
+ }
+ });
+
+ // remove legend items
+ if (series.legendItem) {
+ series.chart.legend.destroyItem(series);
+ }
+
+ // destroy all points with their elements
+ i = data.length;
+ while (i--) {
+ point = data[i];
+ if (point && point.destroy) {
+ point.destroy();
+ }
+ }
+ series.points = null;
+
+ // Clear the animation timeout if we are destroying the series during initial animation
+ clearTimeout(series.animationTimeout);
+
+ // Destroy all SVGElements associated to the series
+ for (prop in series) {
+ if (series[prop] instanceof SVGElement && !series[prop].survive) { // Survive provides a hook for not destroying
+
+ // issue 134 workaround
+ destroy = issue134 && prop === 'group' ?
+ 'hide' :
+ 'destroy';
+
+ series[prop][destroy]();
+ }
+ }
+
+ // remove from hoverSeries
+ if (chart.hoverSeries === series) {
+ chart.hoverSeries = null;
+ }
+ erase(chart.series, series);
+
+ // clear all members
+ for (prop in series) {
+ delete series[prop];
+ }
+ },
+
+ /**
+ * Return the graph path of a segment
+ */
+ getSegmentPath: function (segment) {
+ var series = this,
+ segmentPath = [],
+ step = series.options.step;
+
+ // build the segment line
+ each(segment, function (point, i) {
+
+ var plotX = point.plotX,
+ plotY = point.plotY,
+ lastPoint;
+
+ if (series.getPointSpline) { // generate the spline as defined in the SplineSeries object
+ segmentPath.push.apply(segmentPath, series.getPointSpline(segment, point, i));
+
+ } else {
+
+ // moveTo or lineTo
+ segmentPath.push(i ? L : M);
+
+ // step line?
+ if (step && i) {
+ lastPoint = segment[i - 1];
+ if (step === 'right') {
+ segmentPath.push(
+ lastPoint.plotX,
+ plotY,
+ L
+ );
+
+ } else if (step === 'center') {
+ segmentPath.push(
+ (lastPoint.plotX + plotX) / 2,
+ lastPoint.plotY,
+ L,
+ (lastPoint.plotX + plotX) / 2,
+ plotY,
+ L
+ );
+
+ } else {
+ segmentPath.push(
+ plotX,
+ lastPoint.plotY,
+ L
+ );
+ }
+ }
+
+ // normal line to next point
+ segmentPath.push(
+ point.plotX,
+ point.plotY
+ );
+ }
+ });
+
+ return segmentPath;
+ },
+
+ /**
+ * Get the graph path
+ */
+ getGraphPath: function () {
+ var series = this,
+ graphPath = [],
+ segmentPath,
+ singlePoints = []; // used in drawTracker
+
+ // Divide into segments and build graph and area paths
+ each(series.segments, function (segment) {
+
+ segmentPath = series.getSegmentPath(segment);
+
+ // add the segment to the graph, or a single point for tracking
+ if (segment.length > 1) {
+ graphPath = graphPath.concat(segmentPath);
+ } else {
+ singlePoints.push(segment[0]);
+ }
+ });
+
+ // Record it for use in drawGraph and drawTracker, and return graphPath
+ series.singlePoints = singlePoints;
+ series.graphPath = graphPath;
+
+ return graphPath;
+
+ },
+
+ /**
+ * Draw the actual graph
+ */
+ drawGraph: function () {
+ var series = this,
+ options = this.options,
+ props = [['graph', options.lineColor || this.color, options.dashStyle]],
+ lineWidth = options.lineWidth,
+ roundCap = options.linecap !== 'square',
+ graphPath = this.getGraphPath(),
+ fillColor = (this.fillGraph && this.color) || NONE, // polygon series use filled graph
+ zones = this.zones;
+
+ each(zones, function (threshold, i) {
+ props.push(['zoneGraph' + i, threshold.color || series.color, threshold.dashStyle || options.dashStyle]);
+ });
+
+ // Draw the graph
+ each(props, function (prop, i) {
+ var graphKey = prop[0],
+ graph = series[graphKey],
+ attribs;
+
+ if (graph) {
+ graph.animate({ d: graphPath });
+
+ } else if ((lineWidth || fillColor) && graphPath.length) { // #1487
+ attribs = {
+ stroke: prop[1],
+ 'stroke-width': lineWidth,
+ fill: fillColor,
+ zIndex: 1 // #1069
+ };
+ if (prop[2]) {
+ attribs.dashstyle = prop[2];
+ } else if (roundCap) {
+ attribs['stroke-linecap'] = attribs['stroke-linejoin'] = 'round';
+ }
+
+ series[graphKey] = series.chart.renderer.path(graphPath)
+ .attr(attribs)
+ .add(series.group)
+ .shadow((i < 2) && options.shadow); // add shadow to normal series (0) or to first zone (1) #3932
+ }
+ });
+ },
+
+ /**
+ * Clip the graphs into the positive and negative coloured graphs
+ */
+ applyZones: function () {
+ var series = this,
+ chart = this.chart,
+ renderer = chart.renderer,
+ zones = this.zones,
+ translatedFrom,
+ translatedTo,
+ clips = this.clips || [],
+ clipAttr,
+ graph = this.graph,
+ area = this.area,
+ chartSizeMax = mathMax(chart.chartWidth, chart.chartHeight),
+ axis = this[(this.zoneAxis || 'y') + 'Axis'],
+ extremes,
+ reversed = axis.reversed,
+ inverted = chart.inverted,
+ horiz = axis.horiz,
+ pxRange,
+ pxPosMin,
+ pxPosMax,
+ ignoreZones = false;
+
+ if (zones.length && (graph || area) && axis.min !== UNDEFINED) {
+ // The use of the Color Threshold assumes there are no gaps
+ // so it is safe to hide the original graph and area
+ if (graph) {
+ graph.hide();
+ }
+ if (area) {
+ area.hide();
+ }
+
+ // Create the clips
+ extremes = axis.getExtremes();
+ each(zones, function (threshold, i) {
+
+ translatedFrom = reversed ?
+ (horiz ? chart.plotWidth : 0) :
+ (horiz ? 0 : axis.toPixels(extremes.min));
+ translatedFrom = mathMin(mathMax(pick(translatedTo, translatedFrom), 0), chartSizeMax);
+ translatedTo = mathMin(mathMax(mathRound(axis.toPixels(pick(threshold.value, extremes.max), true)), 0), chartSizeMax);
+
+ if (ignoreZones) {
+ translatedFrom = translatedTo = axis.toPixels(extremes.max);
+ }
+
+ pxRange = Math.abs(translatedFrom - translatedTo);
+ pxPosMin = mathMin(translatedFrom, translatedTo);
+ pxPosMax = mathMax(translatedFrom, translatedTo);
+ if (axis.isXAxis) {
+ clipAttr = {
+ x: inverted ? pxPosMax : pxPosMin,
+ y: 0,
+ width: pxRange,
+ height: chartSizeMax
+ };
+ if (!horiz) {
+ clipAttr.x = chart.plotHeight - clipAttr.x;
+ }
+ } else {
+ clipAttr = {
+ x: 0,
+ y: inverted ? pxPosMax : pxPosMin,
+ width: chartSizeMax,
+ height: pxRange
+ };
+ if (horiz) {
+ clipAttr.y = chart.plotWidth - clipAttr.y;
+ }
+ }
+
+ /// VML SUPPPORT
+ if (chart.inverted && renderer.isVML) {
+ if (axis.isXAxis) {
+ clipAttr = {
+ x: 0,
+ y: reversed ? pxPosMin : pxPosMax,
+ height: clipAttr.width,
+ width: chart.chartWidth
+ };
+ } else {
+ clipAttr = {
+ x: clipAttr.y - chart.plotLeft - chart.spacingBox.x,
+ y: 0,
+ width: clipAttr.height,
+ height: chart.chartHeight
+ };
+ }
+ }
+ /// END OF VML SUPPORT
+
+ if (clips[i]) {
+ clips[i].animate(clipAttr);
+ } else {
+ clips[i] = renderer.clipRect(clipAttr);
+
+ if (graph) {
+ series['zoneGraph' + i].clip(clips[i]);
+ }
+
+ if (area) {
+ series['zoneArea' + i].clip(clips[i]);
+ }
+ }
+ // if this zone extends out of the axis, ignore the others
+ ignoreZones = threshold.value > extremes.max;
+ });
+ this.clips = clips;
+ }
+ },
+
+ /**
+ * Initialize and perform group inversion on series.group and series.markerGroup
+ */
+ invertGroups: function () {
+ var series = this,
+ chart = series.chart;
+
+ // Pie, go away (#1736)
+ if (!series.xAxis) {
+ return;
+ }
+
+ // A fixed size is needed for inversion to work
+ function setInvert() {
+ var size = {
+ width: series.yAxis.len,
+ height: series.xAxis.len
+ };
+
+ each(['group', 'markerGroup'], function (groupName) {
+ if (series[groupName]) {
+ series[groupName].attr(size).invert();
+ }
+ });
+ }
+
+ addEvent(chart, 'resize', setInvert); // do it on resize
+ addEvent(series, 'destroy', function () {
+ removeEvent(chart, 'resize', setInvert);
+ });
+
+ // Do it now
+ setInvert(); // do it now
+
+ // On subsequent render and redraw, just do setInvert without setting up events again
+ series.invertGroups = setInvert;
+ },
+
+ /**
+ * General abstraction for creating plot groups like series.group, series.dataLabelsGroup and
+ * series.markerGroup. On subsequent calls, the group will only be adjusted to the updated plot size.
+ */
+ plotGroup: function (prop, name, visibility, zIndex, parent) {
+ var group = this[prop],
+ isNew = !group;
+
+ // Generate it on first call
+ if (isNew) {
+ this[prop] = group = this.chart.renderer.g(name)
+ .attr({
+ visibility: visibility,
+ zIndex: zIndex || 0.1 // IE8 needs this
+ })
+ .add(parent);
+
+ group.addClass('highcharts-series-' + this.index);
+ }
+
+ // Place it on first and subsequent (redraw) calls
+ group[isNew ? 'attr' : 'animate'](this.getPlotBox());
+ return group;
+ },
+
+ /**
+ * Get the translation and scale for the plot area of this series
+ */
+ getPlotBox: function () {
+ var chart = this.chart,
+ xAxis = this.xAxis,
+ yAxis = this.yAxis;
+
+ // Swap axes for inverted (#2339)
+ if (chart.inverted) {
+ xAxis = yAxis;
+ yAxis = this.xAxis;
+ }
+ return {
+ translateX: xAxis ? xAxis.left : chart.plotLeft,
+ translateY: yAxis ? yAxis.top : chart.plotTop,
+ scaleX: 1, // #1623
+ scaleY: 1
+ };
+ },
+
+ /**
+ * Render the graph and markers
+ */
+ render: function () {
+ var series = this,
+ chart = series.chart,
+ group,
+ options = series.options,
+ animation = options.animation,
+ // Animation doesn't work in IE8 quirks when the group div is hidden,
+ // and looks bad in other oldIE
+ animDuration = (animation && !!series.animate && chart.renderer.isSVG && pick(animation.duration, 500)) || 0,
+ visibility = series.visible ? VISIBLE : HIDDEN,
+ zIndex = options.zIndex,
+ hasRendered = series.hasRendered,
+ chartSeriesGroup = chart.seriesGroup;
+
+ // the group
+ group = series.plotGroup(
+ 'group',
+ 'series',
+ visibility,
+ zIndex,
+ chartSeriesGroup
+ );
+
+ series.markerGroup = series.plotGroup(
+ 'markerGroup',
+ 'markers',
+ visibility,
+ zIndex,
+ chartSeriesGroup
+ );
+
+ // initiate the animation
+ if (animDuration) {
+ series.animate(true);
+ }
+
+ // cache attributes for shapes
+ series.getAttribs();
+
+ // SVGRenderer needs to know this before drawing elements (#1089, #1795)
+ group.inverted = series.isCartesian ? chart.inverted : false;
+
+ // draw the graph if any
+ if (series.drawGraph) {
+ series.drawGraph();
+ series.applyZones();
+ }
+
+ each(series.points, function (point) {
+ if (point.redraw) {
+ point.redraw();
+ }
+ });
+
+ // draw the data labels (inn pies they go before the points)
+ if (series.drawDataLabels) {
+ series.drawDataLabels();
+ }
+
+ // draw the points
+ if (series.visible) {
+ series.drawPoints();
+ }
+
+
+ // draw the mouse tracking area
+ if (series.drawTracker && series.options.enableMouseTracking !== false) {
+ series.drawTracker();
+ }
+
+ // Handle inverted series and tracker groups
+ if (chart.inverted) {
+ series.invertGroups();
+ }
+
+ // Initial clipping, must be defined after inverting groups for VML. Applies to columns etc. (#3839).
+ if (options.clip !== false && !series.sharedClipKey && !hasRendered) {
+ group.clip(chart.clipRect);
+ }
+
+ // Run the animation
+ if (animDuration) {
+ series.animate();
+ }
+
+ // Call the afterAnimate function on animation complete (but don't overwrite the animation.complete option
+ // which should be available to the user).
+ if (!hasRendered) {
+ if (animDuration) {
+ series.animationTimeout = setTimeout(function () {
+ series.afterAnimate();
+ }, animDuration);
+ } else {
+ series.afterAnimate();
+ }
+ }
+
+ series.isDirty = series.isDirtyData = false; // means data is in accordance with what you see
+ // (See #322) series.isDirty = series.isDirtyData = false; // means data is in accordance with what you see
+ series.hasRendered = true;
+ },
+
+ /**
+ * Redraw the series after an update in the axes.
+ */
+ redraw: function () {
+ var series = this,
+ chart = series.chart,
+ wasDirtyData = series.isDirtyData, // cache it here as it is set to false in render, but used after
+ wasDirty = series.isDirty,
+ group = series.group,
+ xAxis = series.xAxis,
+ yAxis = series.yAxis;
+
+ // reposition on resize
+ if (group) {
+ if (chart.inverted) {
+ group.attr({
+ width: chart.plotWidth,
+ height: chart.plotHeight
+ });
+ }
+
+ group.animate({
+ translateX: pick(xAxis && xAxis.left, chart.plotLeft),
+ translateY: pick(yAxis && yAxis.top, chart.plotTop)
+ });
+ }
+
+ series.translate();
+ series.render();
+ if (wasDirtyData) {
+ fireEvent(series, 'updatedData');
+ }
+ if (wasDirty || wasDirtyData) { // #3945 recalculate the kdtree when dirty
+ delete this.kdTree; // #3868 recalculate the kdtree with dirty data
+ }
+ },
+
+ /**
+ * KD Tree && PointSearching Implementation
+ */
+
+ kdDimensions: 1,
+ kdAxisArray: ['clientX', 'plotY'],
+
+ searchPoint: function (e, compareX) {
+ var series = this,
+ xAxis = series.xAxis,
+ yAxis = series.yAxis,
+ inverted = series.chart.inverted;
+
+ return this.searchKDTree({
+ clientX: inverted ? xAxis.len - e.chartY + xAxis.pos : e.chartX - xAxis.pos,
+ plotY: inverted ? yAxis.len - e.chartX + yAxis.pos : e.chartY - yAxis.pos
+ }, compareX);
+ },
+
+ buildKDTree: function () {
+ var series = this,
+ dimensions = series.kdDimensions;
+
+ // Internal function
+ function _kdtree(points, depth, dimensions) {
+ var axis, median, length = points && points.length;
+
+ if (length) {
+
+ // alternate between the axis
+ axis = series.kdAxisArray[depth % dimensions];
+
+ // sort point array
+ points.sort(function(a, b) {
+ return a[axis] - b[axis];
+ });
+
+ median = Math.floor(length / 2);
+
+ // build and return nod
+ return {
+ point: points[median],
+ left: _kdtree(points.slice(0, median), depth + 1, dimensions),
+ right: _kdtree(points.slice(median + 1), depth + 1, dimensions)
+ };
+
+ }
+ }
+
+ // Start the recursive build process with a clone of the points array and null points filtered out (#3873)
+ function startRecursive() {
+ var points = grep(series.points || [], function (point) { // #4390
+ return point.y !== null;
+ });
+
+ series.kdTree = _kdtree(points, dimensions, dimensions);
+ }
+ delete series.kdTree;
+
+ if (series.options.kdSync) { // For testing tooltips, don't build async
+ startRecursive();
+ } else {
+ setTimeout(startRecursive);
+ }
+ },
+
+ searchKDTree: function (point, compareX) {
+ var series = this,
+ kdX = this.kdAxisArray[0],
+ kdY = this.kdAxisArray[1],
+ kdComparer = compareX ? 'distX' : 'dist';
+
+ // Set the one and two dimensional distance on the point object
+ function setDistance(p1, p2) {
+ var x = (defined(p1[kdX]) && defined(p2[kdX])) ? Math.pow(p1[kdX] - p2[kdX], 2) : null,
+ y = (defined(p1[kdY]) && defined(p2[kdY])) ? Math.pow(p1[kdY] - p2[kdY], 2) : null,
+ r = (x || 0) + (y || 0);
+
+ p2.dist = defined(r) ? Math.sqrt(r) : Number.MAX_VALUE;
+ p2.distX = defined(x) ? Math.sqrt(x) : Number.MAX_VALUE;
+ }
+ function _search(search, tree, depth, dimensions) {
+ var point = tree.point,
+ axis = series.kdAxisArray[depth % dimensions],
+ tdist,
+ sideA,
+ sideB,
+ ret = point,
+ nPoint1,
+ nPoint2;
+
+ setDistance(search, point);
+
+ // Pick side based on distance to splitting point
+ tdist = search[axis] - point[axis];
+ sideA = tdist < 0 ? 'left' : 'right';
+ sideB = tdist < 0 ? 'right' : 'left';
+
+ // End of tree
+ if (tree[sideA]) {
+ nPoint1 =_search(search, tree[sideA], depth + 1, dimensions);
+
+ ret = (nPoint1[kdComparer] < ret[kdComparer] ? nPoint1 : point);
+ }
+ if (tree[sideB]) {
+ // compare distance to current best to splitting point to decide wether to check side B or not
+ if (Math.sqrt(tdist * tdist) < ret[kdComparer]) {
+ nPoint2 = _search(search, tree[sideB], depth + 1, dimensions);
+ ret = (nPoint2[kdComparer] < ret[kdComparer] ? nPoint2 : ret);
+ }
+ }
+
+ return ret;
+ }
+
+ if (!this.kdTree) {
+ this.buildKDTree();
+ }
+
+ if (this.kdTree) {
+ return _search(point,
+ this.kdTree, this.kdDimensions, this.kdDimensions);
+ }
+ }
+
+}; // end Series prototype
+
+
+
+/**
+ * The class for stack items
+ */
+function StackItem(axis, options, isNegative, x, stackOption) {
+
+ var inverted = axis.chart.inverted;
+
+ this.axis = axis;
+
+ // Tells if the stack is negative
+ this.isNegative = isNegative;
+
+ // Save the options to be able to style the label
+ this.options = options;
+
+ // Save the x value to be able to position the label later
+ this.x = x;
+
+ // Initialize total value
+ this.total = null;
+
+ // This will keep each points' extremes stored by series.index and point index
+ this.points = {};
+
+ // Save the stack option on the series configuration object, and whether to treat it as percent
+ this.stack = stackOption;
+
+ // The align options and text align varies on whether the stack is negative and
+ // if the chart is inverted or not.
+ // First test the user supplied value, then use the dynamic.
+ this.alignOptions = {
+ align: options.align || (inverted ? (isNegative ? 'left' : 'right') : 'center'),
+ verticalAlign: options.verticalAlign || (inverted ? 'middle' : (isNegative ? 'bottom' : 'top')),
+ y: pick(options.y, inverted ? 4 : (isNegative ? 14 : -6)),
+ x: pick(options.x, inverted ? (isNegative ? -6 : 6) : 0)
+ };
+
+ this.textAlign = options.textAlign || (inverted ? (isNegative ? 'right' : 'left') : 'center');
+}
+
+StackItem.prototype = {
+ destroy: function () {
+ destroyObjectProperties(this, this.axis);
+ },
+
+ /**
+ * Renders the stack total label and adds it to the stack label group.
+ */
+ render: function (group) {
+ var options = this.options,
+ formatOption = options.format,
+ str = formatOption ?
+ format(formatOption, this) :
+ options.formatter.call(this); // format the text in the label
+
+ // Change the text to reflect the new total and set visibility to hidden in case the serie is hidden
+ if (this.label) {
+ this.label.attr({text: str, visibility: HIDDEN});
+ // Create new label
+ } else {
+ this.label =
+ this.axis.chart.renderer.text(str, null, null, options.useHTML) // dummy positions, actual position updated with setOffset method in columnseries
+ .css(options.style) // apply style
+ .attr({
+ align: this.textAlign, // fix the text-anchor
+ rotation: options.rotation, // rotation
+ visibility: HIDDEN // hidden until setOffset is called
+ })
+ .add(group); // add to the labels-group
+ }
+ },
+
+ /**
+ * Sets the offset that the stack has from the x value and repositions the label.
+ */
+ setOffset: function (xOffset, xWidth) {
+ var stackItem = this,
+ axis = stackItem.axis,
+ chart = axis.chart,
+ inverted = chart.inverted,
+ reversed = axis.reversed,
+ neg = (this.isNegative && !reversed) || (!this.isNegative && reversed), // #4056
+ y = axis.translate(axis.usePercentage ? 100 : this.total, 0, 0, 0, 1), // stack value translated mapped to chart coordinates
+ yZero = axis.translate(0), // stack origin
+ h = mathAbs(y - yZero), // stack height
+ x = chart.xAxis[0].translate(this.x) + xOffset, // stack x position
+ plotHeight = chart.plotHeight,
+ stackBox = { // this is the box for the complete stack
+ x: inverted ? (neg ? y : y - h) : x,
+ y: inverted ? plotHeight - x - xWidth : (neg ? (plotHeight - y - h) : plotHeight - y),
+ width: inverted ? h : xWidth,
+ height: inverted ? xWidth : h
+ },
+ label = this.label,
+ alignAttr;
+
+ if (label) {
+ label.align(this.alignOptions, null, stackBox); // align the label to the box
+
+ // Set visibility (#678)
+ alignAttr = label.alignAttr;
+ label[this.options.crop === false || chart.isInsidePlot(alignAttr.x, alignAttr.y) ? 'show' : 'hide'](true);
+ }
+ }
+};
+
+/**
+ * Generate stacks for each series and calculate stacks total values
+ */
+Chart.prototype.getStacks = function () {
+ var chart = this;
+
+ // reset stacks for each yAxis
+ each(chart.yAxis, function (axis) {
+ if (axis.stacks && axis.hasVisibleSeries) {
+ axis.oldStacks = axis.stacks;
+ }
+ });
+
+ each(chart.series, function (series) {
+ if (series.options.stacking && (series.visible === true || chart.options.chart.ignoreHiddenSeries === false)) {
+ series.stackKey = series.type + pick(series.options.stack, '');
+ }
+ });
+};
+
+
+// Stacking methods defined on the Axis prototype
+
+/**
+ * Build the stacks from top down
+ */
+Axis.prototype.buildStacks = function () {
+ var series = this.series,
+ reversedStacks = pick(this.options.reversedStacks, true),
+ i = series.length;
+ if (!this.isXAxis) {
+ this.usePercentage = false;
+ while (i--) {
+ series[reversedStacks ? i : series.length - i - 1].setStackedPoints();
+ }
+ // Loop up again to compute percent stack
+ if (this.usePercentage) {
+ for (i = 0; i < series.length; i++) {
+ series[i].setPercentStacks();
+ }
+ }
+ }
+};
+
+Axis.prototype.renderStackTotals = function () {
+ var axis = this,
+ chart = axis.chart,
+ renderer = chart.renderer,
+ stacks = axis.stacks,
+ stackKey,
+ oneStack,
+ stackCategory,
+ stackTotalGroup = axis.stackTotalGroup;
+
+ // Create a separate group for the stack total labels
+ if (!stackTotalGroup) {
+ axis.stackTotalGroup = stackTotalGroup =
+ renderer.g('stack-labels')
+ .attr({
+ visibility: VISIBLE,
+ zIndex: 6
+ })
+ .add();
+ }
+
+ // plotLeft/Top will change when y axis gets wider so we need to translate the
+ // stackTotalGroup at every render call. See bug #506 and #516
+ stackTotalGroup.translate(chart.plotLeft, chart.plotTop);
+
+ // Render each stack total
+ for (stackKey in stacks) {
+ oneStack = stacks[stackKey];
+ for (stackCategory in oneStack) {
+ oneStack[stackCategory].render(stackTotalGroup);
+ }
+ }
+};
+
+/**
+ * Set all the stacks to initial states and destroy unused ones.
+ */
+Axis.prototype.resetStacks = function () {
+ var stacks = this.stacks,
+ type,
+ i;
+ if (!this.isXAxis) {
+ for (type in stacks) {
+ for (i in stacks[type]) {
+
+ // Clean up memory after point deletion (#1044, #4320)
+ if (stacks[type][i].touched < this.stacksTouched) {
+ stacks[type][i].destroy();
+ delete stacks[type][i];
+
+ // Reset stacks
+ } else {
+ stacks[type][i].total = null;
+ stacks[type][i].cum = 0;
+ }
+ }
+ }
+ }
+};
+
+Axis.prototype.cleanStacks = function () {
+ var stacks, type, i;
+
+ if (!this.isXAxis) {
+ if (this.oldStacks) {
+ stacks = this.stacks = this.oldStacks;
+ }
+
+ // reset stacks
+ for (type in stacks) {
+ for (i in stacks[type]) {
+ stacks[type][i].cum = stacks[type][i].total;
+ }
+ }
+ }
+};
+
+
+// Stacking methods defnied for Series prototype
+
+/**
+ * Adds series' points value to corresponding stack
+ */
+Series.prototype.setStackedPoints = function () {
+ if (!this.options.stacking || (this.visible !== true && this.chart.options.chart.ignoreHiddenSeries !== false)) {
+ return;
+ }
+
+ var series = this,
+ xData = series.processedXData,
+ yData = series.processedYData,
+ stackedYData = [],
+ yDataLength = yData.length,
+ seriesOptions = series.options,
+ threshold = seriesOptions.threshold,
+ stackThreshold = seriesOptions.startFromThreshold ? threshold : 0,
+ stackOption = seriesOptions.stack,
+ stacking = seriesOptions.stacking,
+ stackKey = series.stackKey,
+ negKey = '-' + stackKey,
+ negStacks = series.negStacks,
+ yAxis = series.yAxis,
+ stacks = yAxis.stacks,
+ oldStacks = yAxis.oldStacks,
+ stackIndicator,
+ isNegative,
+ stack,
+ other,
+ key,
+ pointKey,
+ i,
+ x,
+ y;
+
+
+ yAxis.stacksTouched += 1;
+
+ // loop over the non-null y values and read them into a local array
+ for (i = 0; i < yDataLength; i++) {
+ x = xData[i];
+ y = yData[i];
+ stackIndicator = series.getStackIndicator(stackIndicator, x, series.index);
+ pointKey = stackIndicator.key;
+ // Read stacked values into a stack based on the x value,
+ // the sign of y and the stack key. Stacking is also handled for null values (#739)
+ isNegative = negStacks && y < (stackThreshold ? 0 : threshold);
+ key = isNegative ? negKey : stackKey;
+
+ // Create empty object for this stack if it doesn't exist yet
+ if (!stacks[key]) {
+ stacks[key] = {};
+ }
+
+ // Initialize StackItem for this x
+ if (!stacks[key][x]) {
+ if (oldStacks[key] && oldStacks[key][x]) {
+ stacks[key][x] = oldStacks[key][x];
+ stacks[key][x].total = null;
+ } else {
+ stacks[key][x] = new StackItem(yAxis, yAxis.options.stackLabels, isNegative, x, stackOption);
+ }
+ }
+
+ // If the StackItem doesn't exist, create it first
+ stack = stacks[key][x];
+ //stack.points[pointKey] = [stack.cum || stackThreshold];
+ stack.points[pointKey] = [pick(stack.cum, stackThreshold)];
+ stack.touched = yAxis.stacksTouched;
+
+
+ // Add value to the stack total
+ if (stacking === 'percent') {
+
+ // Percent stacked column, totals are the same for the positive and negative stacks
+ other = isNegative ? stackKey : negKey;
+ if (negStacks && stacks[other] && stacks[other][x]) {
+ other = stacks[other][x];
+ stack.total = other.total = mathMax(other.total, stack.total) + mathAbs(y) || 0;
+
+ // Percent stacked areas
+ } else {
+ stack.total = correctFloat(stack.total + (mathAbs(y) || 0));
+ }
+ } else {
+ stack.total = correctFloat(stack.total + (y || 0));
+ }
+
+ stack.cum = pick(stack.cum, stackThreshold) + (y || 0);
+
+ stack.points[pointKey].push(stack.cum);
+ stackedYData[i] = stack.cum;
+
+ }
+
+ if (stacking === 'percent') {
+ yAxis.usePercentage = true;
+ }
+
+ this.stackedYData = stackedYData; // To be used in getExtremes
+
+ // Reset old stacks
+ yAxis.oldStacks = {};
+};
+
+/**
+ * Iterate over all stacks and compute the absolute values to percent
+ */
+Series.prototype.setPercentStacks = function () {
+ var series = this,
+ stackKey = series.stackKey,
+ stacks = series.yAxis.stacks,
+ processedXData = series.processedXData,
+ stackIndicator;
+
+ each([stackKey, '-' + stackKey], function (key) {
+ var i = processedXData.length,
+ x,
+ stack,
+ pointExtremes,
+ totalFactor;
+
+ while (i--) {
+ x = processedXData[i];
+ stackIndicator = series.getStackIndicator(stackIndicator, x, series.index);
+ stack = stacks[key] && stacks[key][x];
+ pointExtremes = stack && stack.points[stackIndicator.key];
+ if (pointExtremes) {
+ totalFactor = stack.total ? 100 / stack.total : 0;
+ pointExtremes[0] = correctFloat(pointExtremes[0] * totalFactor); // Y bottom value
+ pointExtremes[1] = correctFloat(pointExtremes[1] * totalFactor); // Y value
+ series.stackedYData[i] = pointExtremes[1];
+ }
+ }
+ });
+};
+
+/**
+* Get stack indicator, according to it's x-value, to determine points with the same x-value
+*/
+Series.prototype.getStackIndicator = function(stackIndicator, x, index) {
+ if (!defined(stackIndicator) || stackIndicator.x !== x) {
+ stackIndicator = {
+ x: x,
+ index: 0
+ };
+ } else {
+ stackIndicator.index++;
+ }
+
+ stackIndicator.key = [index, x, stackIndicator.index].join(',');
+
+ return stackIndicator;
+};
+
+
+
+// Extend the Chart prototype for dynamic methods
+extend(Chart.prototype, {
+
+ /**
+ * Add a series dynamically after time
+ *
+ * @param {Object} options The config options
+ * @param {Boolean} redraw Whether to redraw the chart after adding. Defaults to true.
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ *
+ * @return {Object} series The newly created series object
+ */
+ addSeries: function (options, redraw, animation) {
+ var series,
+ chart = this;
+
+ if (options) {
+ redraw = pick(redraw, true); // defaults to true
+
+ fireEvent(chart, 'addSeries', { options: options }, function () {
+ series = chart.initSeries(options);
+
+ chart.isDirtyLegend = true; // the series array is out of sync with the display
+ chart.linkSeries();
+ if (redraw) {
+ chart.redraw(animation);
+ }
+ });
+ }
+
+ return series;
+ },
+
+ /**
+ * Add an axis to the chart
+ * @param {Object} options The axis option
+ * @param {Boolean} isX Whether it is an X axis or a value axis
+ */
+ addAxis: function (options, isX, redraw, animation) {
+ var key = isX ? 'xAxis' : 'yAxis',
+ chartOptions = this.options,
+ axis;
+
+ /*jslint unused: false*/
+ axis = new Axis(this, merge(options, {
+ index: this[key].length,
+ isX: isX
+ }));
+ /*jslint unused: true*/
+
+ // Push the new axis options to the chart options
+ chartOptions[key] = splat(chartOptions[key] || {});
+ chartOptions[key].push(options);
+
+ if (pick(redraw, true)) {
+ this.redraw(animation);
+ }
+ },
+
+ /**
+ * Dim the chart and show a loading text or symbol
+ * @param {String} str An optional text to show in the loading label instead of the default one
+ */
+ showLoading: function (str) {
+ var chart = this,
+ options = chart.options,
+ loadingDiv = chart.loadingDiv,
+ loadingOptions = options.loading,
+ setLoadingSize = function () {
+ if (loadingDiv) {
+ css(loadingDiv, {
+ left: chart.plotLeft + PX,
+ top: chart.plotTop + PX,
+ width: chart.plotWidth + PX,
+ height: chart.plotHeight + PX
+ });
+ }
+ };
+
+ // create the layer at the first call
+ if (!loadingDiv) {
+ chart.loadingDiv = loadingDiv = createElement(DIV, {
+ className: PREFIX + 'loading'
+ }, extend(loadingOptions.style, {
+ zIndex: 10,
+ display: NONE
+ }), chart.container);
+
+ chart.loadingSpan = createElement(
+ 'span',
+ null,
+ loadingOptions.labelStyle,
+ loadingDiv
+ );
+ addEvent(chart, 'redraw', setLoadingSize); // #1080
+ }
+
+ // update text
+ chart.loadingSpan.innerHTML = str || options.lang.loading;
+
+ // show it
+ if (!chart.loadingShown) {
+ css(loadingDiv, {
+ opacity: 0,
+ display: ''
+ });
+ animate(loadingDiv, {
+ opacity: loadingOptions.style.opacity
+ }, {
+ duration: loadingOptions.showDuration || 0
+ });
+ chart.loadingShown = true;
+ }
+ setLoadingSize();
+ },
+
+ /**
+ * Hide the loading layer
+ */
+ hideLoading: function () {
+ var options = this.options,
+ loadingDiv = this.loadingDiv;
+
+ if (loadingDiv) {
+ animate(loadingDiv, {
+ opacity: 0
+ }, {
+ duration: options.loading.hideDuration || 100,
+ complete: function () {
+ css(loadingDiv, { display: NONE });
+ }
+ });
+ }
+ this.loadingShown = false;
+ }
+});
+
+// extend the Point prototype for dynamic methods
+extend(Point.prototype, {
+ /**
+ * Update the point with new options (typically x/y data) and optionally redraw the series.
+ *
+ * @param {Object} options Point options as defined in the series.data array
+ * @param {Boolean} redraw Whether to redraw the chart or wait for an explicit call
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ *
+ */
+ update: function (options, redraw, animation, runEvent) {
+ var point = this,
+ series = point.series,
+ graphic = point.graphic,
+ i,
+ chart = series.chart,
+ seriesOptions = series.options,
+ names = series.xAxis && series.xAxis.names;
+
+ redraw = pick(redraw, true);
+
+ function update() {
+
+ point.applyOptions(options);
+
+ // Update visuals
+ if (point.y === null && graphic) { // #4146
+ point.graphic = graphic.destroy();
+ }
+ if (isObject(options) && !isArray(options)) {
+ // Defer the actual redraw until getAttribs has been called (#3260)
+ point.redraw = function () {
+ if (graphic && graphic.element) {
+ if (options && options.marker && options.marker.symbol) {
+ point.graphic = graphic.destroy();
+ }
+ }
+ if (options && options.dataLabels && point.dataLabel) { // #2468
+ point.dataLabel = point.dataLabel.destroy();
+ }
+ point.redraw = null;
+ };
+ }
+
+ // record changes in the parallel arrays
+ i = point.index;
+ series.updateParallelArrays(point, i);
+ if (names && point.name) {
+ names[point.x] = point.name;
+ }
+
+ seriesOptions.data[i] = point.options;
+
+ // redraw
+ series.isDirty = series.isDirtyData = true;
+ if (!series.fixedBox && series.hasCartesianSeries) { // #1906, #2320
+ chart.isDirtyBox = true;
+ }
+
+ if (seriesOptions.legendType === 'point') { // #1831, #1885
+ chart.isDirtyLegend = true;
+ }
+ if (redraw) {
+ chart.redraw(animation);
+ }
+ }
+
+ // Fire the event with a default handler of doing the update
+ if (runEvent === false) { // When called from setData
+ update();
+ } else {
+ point.firePointEvent('update', { options: options }, update);
+ }
+ },
+
+ /**
+ * Remove a point and optionally redraw the series and if necessary the axes
+ * @param {Boolean} redraw Whether to redraw the chart or wait for an explicit call
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ */
+ remove: function (redraw, animation) {
+ this.series.removePoint(inArray(this, this.series.data), redraw, animation);
+ }
+});
+
+// Extend the series prototype for dynamic methods
+extend(Series.prototype, {
+ /**
+ * Add a point dynamically after chart load time
+ * @param {Object} options Point options as given in series.data
+ * @param {Boolean} redraw Whether to redraw the chart or wait for an explicit call
+ * @param {Boolean} shift If shift is true, a point is shifted off the start
+ * of the series as one is appended to the end.
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ */
+ addPoint: function (options, redraw, shift, animation) {
+ var series = this,
+ seriesOptions = series.options,
+ data = series.data,
+ graph = series.graph,
+ area = series.area,
+ chart = series.chart,
+ names = series.xAxis && series.xAxis.names,
+ currentShift = (graph && graph.shift) || 0,
+ shiftShapes = ['graph', 'area'],
+ dataOptions = seriesOptions.data,
+ point,
+ isInTheMiddle,
+ xData = series.xData,
+ i,
+ x;
+
+ setAnimation(animation, chart);
+
+ // Make graph animate sideways
+ if (shift) {
+ i = series.zones.length;
+ while (i--) {
+ shiftShapes.push('zoneGraph' + i, 'zoneArea' + i);
+ }
+ each(shiftShapes, function (shape) {
+ if (series[shape]) {
+ series[shape].shift = currentShift + (seriesOptions.step ? 2 : 1);
+ }
+ });
+ }
+ if (area) {
+ area.isArea = true; // needed in animation, both with and without shift
+ }
+
+ // Optional redraw, defaults to true
+ redraw = pick(redraw, true);
+
+ // Get options and push the point to xData, yData and series.options. In series.generatePoints
+ // the Point instance will be created on demand and pushed to the series.data array.
+ point = { series: series };
+ series.pointClass.prototype.applyOptions.apply(point, [options]);
+ x = point.x;
+
+ // Get the insertion point
+ i = xData.length;
+ if (series.requireSorting && x < xData[i - 1]) {
+ isInTheMiddle = true;
+ while (i && xData[i - 1] > x) {
+ i--;
+ }
+ }
+
+ series.updateParallelArrays(point, 'splice', i, 0, 0); // insert undefined item
+ series.updateParallelArrays(point, i); // update it
+
+ if (names && point.name) {
+ names[x] = point.name;
+ }
+ dataOptions.splice(i, 0, options);
+
+ if (isInTheMiddle) {
+ series.data.splice(i, 0, null);
+ series.processData();
+ }
+
+ // Generate points to be added to the legend (#1329)
+ if (seriesOptions.legendType === 'point') {
+ series.generatePoints();
+ }
+
+ // Shift the first point off the parallel arrays
+ // todo: consider series.removePoint(i) method
+ if (shift) {
+ if (data[0] && data[0].remove) {
+ data[0].remove(false);
+ } else {
+ data.shift();
+ series.updateParallelArrays(point, 'shift');
+
+ dataOptions.shift();
+ }
+ }
+
+ // redraw
+ series.isDirty = true;
+ series.isDirtyData = true;
+ if (redraw) {
+ series.getAttribs(); // #1937
+ chart.redraw();
+ }
+ },
+
+ /**
+ * Remove a point (rendered or not), by index
+ */
+ removePoint: function (i, redraw, animation) {
+
+ var series = this,
+ data = series.data,
+ point = data[i],
+ points = series.points,
+ chart = series.chart,
+ remove = function () {
+
+ if (data.length === points.length) {
+ points.splice(i, 1);
+ }
+ data.splice(i, 1);
+ series.options.data.splice(i, 1);
+ series.updateParallelArrays(point || { series: series }, 'splice', i, 1);
+
+ if (point) {
+ point.destroy();
+ }
+
+ // redraw
+ series.isDirty = true;
+ series.isDirtyData = true;
+ if (redraw) {
+ chart.redraw();
+ }
+ };
+
+ setAnimation(animation, chart);
+ redraw = pick(redraw, true);
+
+ // Fire the event with a default handler of removing the point
+ if (point) {
+ point.firePointEvent('remove', null, remove);
+ } else {
+ remove();
+ }
+ },
+
+ /**
+ * Remove a series and optionally redraw the chart
+ *
+ * @param {Boolean} redraw Whether to redraw the chart or wait for an explicit call
+ * @param {Boolean|Object} animation Whether to apply animation, and optionally animation
+ * configuration
+ */
+
+ remove: function (redraw, animation) {
+ var series = this,
+ chart = series.chart;
+ redraw = pick(redraw, true);
+
+ if (!series.isRemoving) { /* prevent triggering native event in jQuery
+ (calling the remove function from the remove event) */
+ series.isRemoving = true;
+
+ // fire the event with a default handler of removing the point
+ fireEvent(series, 'remove', null, function () {
+
+
+ // destroy elements
+ series.destroy();
+
+
+ // redraw
+ chart.isDirtyLegend = chart.isDirtyBox = true;
+ chart.linkSeries();
+
+ if (redraw) {
+ chart.redraw(animation);
+ }
+ });
+
+ }
+ series.isRemoving = false;
+ },
+
+ /**
+ * Update the series with a new set of options
+ */
+ update: function (newOptions, redraw) {
+ var series = this,
+ chart = this.chart,
+ // must use user options when changing type because this.options is merged
+ // in with type specific plotOptions
+ oldOptions = this.userOptions,
+ oldType = this.type,
+ proto = seriesTypes[oldType].prototype,
+ preserve = ['group', 'markerGroup', 'dataLabelsGroup'],
+ n;
+
+ // If we're changing type or zIndex, create new groups (#3380, #3404)
+ if ((newOptions.type && newOptions.type !== oldType) || newOptions.zIndex !== undefined) {
+ preserve.length = 0;
+ }
+
+ // Make sure groups are not destroyed (#3094)
+ each(preserve, function (prop) {
+ preserve[prop] = series[prop];
+ delete series[prop];
+ });
+
+ // Do the merge, with some forced options
+ newOptions = merge(oldOptions, {
+ animation: false,
+ index: this.index,
+ pointStart: this.xData[0] // when updating after addPoint
+ }, { data: this.options.data }, newOptions);
+
+ // Destroy the series and delete all properties. Reinsert all methods
+ // and properties from the new type prototype (#2270, #3719)
+ this.remove(false);
+ for (n in proto) {
+ this[n] = UNDEFINED;
+ }
+ extend(this, seriesTypes[newOptions.type || oldType].prototype);
+
+ // Re-register groups (#3094)
+ each(preserve, function (prop) {
+ series[prop] = preserve[prop];
+ });
+
+ this.init(chart, newOptions);
+ chart.linkSeries(); // Links are lost in this.remove (#3028)
+ if (pick(redraw, true)) {
+ chart.redraw(false);
+ }
+ }
+});
+
+// Extend the Axis.prototype for dynamic methods
+extend(Axis.prototype, {
+
+ /**
+ * Update the axis with a new options structure
+ */
+ update: function (newOptions, redraw) {
+ var chart = this.chart;
+
+ newOptions = chart.options[this.coll][this.options.index] = merge(this.userOptions, newOptions);
+
+ this.destroy(true);
+ this._addedPlotLB = this.chart._labelPanes = UNDEFINED; // #1611, #2887, #4314
+
+ this.init(chart, extend(newOptions, { events: UNDEFINED }));
+
+ chart.isDirtyBox = true;
+ if (pick(redraw, true)) {
+ chart.redraw();
+ }
+ },
+
+ /**
+ * Remove the axis from the chart
+ */
+ remove: function (redraw) {
+ var chart = this.chart,
+ key = this.coll, // xAxis or yAxis
+ axisSeries = this.series,
+ i = axisSeries.length;
+
+ // Remove associated series (#2687)
+ while (i--) {
+ if (axisSeries[i]) {
+ axisSeries[i].remove(false);
+ }
+ }
+
+ // Remove the axis
+ erase(chart.axes, this);
+ erase(chart[key], this);
+ chart.options[key].splice(this.options.index, 1);
+ each(chart[key], function (axis, i) { // Re-index, #1706
+ axis.options.index = i;
+ });
+ this.destroy();
+ chart.isDirtyBox = true;
+
+ if (pick(redraw, true)) {
+ chart.redraw();
+ }
+ },
+
+ /**
+ * Update the axis title by options
+ */
+ setTitle: function (newTitleOptions, redraw) {
+ this.update({ title: newTitleOptions }, redraw);
+ },
+
+ /**
+ * Set new axis categories and optionally redraw
+ * @param {Array} categories
+ * @param {Boolean} redraw
+ */
+ setCategories: function (categories, redraw) {
+ this.update({ categories: categories }, redraw);
+ }
+
+});
+
+
+
+
+/**
+ * LineSeries object
+ */
+var LineSeries = extendClass(Series);
+seriesTypes.line = LineSeries;
+
+
+
+/**
+ * Set the default options for area
+ */
+defaultPlotOptions.area = merge(defaultSeriesOptions, {
+ softThreshold: false,
+ threshold: 0
+ // trackByArea: false,
+ // lineColor: null, // overrides color, but lets fillColor be unaltered
+ // fillOpacity: 0.75,
+ // fillColor: null
+});
+
+/**
+ * AreaSeries object
+ */
+var AreaSeries = extendClass(Series, {
+ type: 'area',
+ /**
+ * For stacks, don't split segments on null values. Instead, draw null values with
+ * no marker. Also insert dummy points for any X position that exists in other series
+ * in the stack.
+ */
+ getSegments: function () {
+ var series = this,
+ segments = [],
+ segment = [],
+ keys = [],
+ xAxis = this.xAxis,
+ yAxis = this.yAxis,
+ stack = yAxis.stacks[this.stackKey],
+ pointMap = {},
+ plotX,
+ plotY,
+ points = this.points,
+ connectNulls = this.options.connectNulls,
+ stackIndicator,
+ i,
+ x;
+
+ if (this.options.stacking && !this.cropped) { // cropped causes artefacts in Stock, and perf issue
+ // Create a map where we can quickly look up the points by their X value.
+ for (i = 0; i < points.length; i++) {
+ pointMap[points[i].x] = points[i];
+ }
+
+ // Sort the keys (#1651)
+ for (x in stack) {
+ if (stack[x].total !== null) { // nulled after switching between grouping and not (#1651, #2336)
+ keys.push(+x);
+ }
+ }
+ keys.sort(function (a, b) {
+ return a - b;
+ });
+
+ each(keys, function (x) {
+ var threshold = null,
+ stackPoint;
+
+ if (connectNulls && (!pointMap[x] || pointMap[x].y === null)) { // #1836
+ return;
+
+ // The point exists, push it to the segment
+ } else if (pointMap[x]) {
+ segment.push(pointMap[x]);
+
+ // There is no point for this X value in this series, so we
+ // insert a dummy point in order for the areas to be drawn
+ // correctly.
+ } else {
+
+ // Loop down the stack to find the series below this one that has
+ // a value (#1991)
+ for (i = series.index; i <= yAxis.series.length; i++) {
+ stackIndicator = series.getStackIndicator(null, x, i);
+ stackPoint = stack[x].points[stackIndicator.key];
+ if (stackPoint) {
+ threshold = stackPoint[1];
+ break;
+ }
+ }
+
+ plotX = xAxis.translate(x);
+ plotY = yAxis.getThreshold(threshold);
+ segment.push({
+ y: null,
+ plotX: plotX,
+ clientX: plotX,
+ plotY: plotY,
+ yBottom: plotY,
+ onMouseOver: noop
+ });
+ }
+ });
+
+ if (segment.length) {
+ segments.push(segment);
+ }
+
+ } else {
+ Series.prototype.getSegments.call(this);
+ segments = this.segments;
+ }
+
+ this.segments = segments;
+ },
+
+ /**
+ * Extend the base Series getSegmentPath method by adding the path for the area.
+ * This path is pushed to the series.areaPath property.
+ */
+ getSegmentPath: function (segment) {
+
+ var segmentPath = Series.prototype.getSegmentPath.call(this, segment), // call base method
+ areaSegmentPath = [].concat(segmentPath), // work on a copy for the area path
+ i,
+ options = this.options,
+ segLength = segmentPath.length,
+ translatedThreshold = this.yAxis.getThreshold(options.threshold), // #2181
+ yBottom;
+
+ if (segLength === 3) { // for animation from 1 to two points
+ areaSegmentPath.push(L, segmentPath[1], segmentPath[2]);
+ }
+ if (options.stacking && !this.closedStacks) {
+
+ // Follow stack back. Todo: implement areaspline. A general solution could be to
+ // reverse the entire graphPath of the previous series, though may be hard with
+ // splines and with series with different extremes
+ for (i = segment.length - 1; i >= 0; i--) {
+
+ yBottom = pick(segment[i].yBottom, translatedThreshold);
+
+ // step line?
+ if (i < segment.length - 1 && options.step) {
+ areaSegmentPath.push(segment[i + 1].plotX, yBottom);
+ }
+
+ areaSegmentPath.push(segment[i].plotX, yBottom);
+ }
+
+ } else { // follow zero line back
+ this.closeSegment(areaSegmentPath, segment, translatedThreshold);
+ }
+ this.areaPath = this.areaPath.concat(areaSegmentPath);
+ return segmentPath;
+ },
+
+ /**
+ * Extendable method to close the segment path of an area. This is overridden in polar
+ * charts.
+ */
+ closeSegment: function (path, segment, translatedThreshold) {
+ path.push(
+ L,
+ segment[segment.length - 1].plotX,
+ translatedThreshold,
+ L,
+ segment[0].plotX,
+ translatedThreshold
+ );
+ },
+
+ /**
+ * Draw the graph and the underlying area. This method calls the Series base
+ * function and adds the area. The areaPath is calculated in the getSegmentPath
+ * method called from Series.prototype.drawGraph.
+ */
+ drawGraph: function () {
+
+ // Define or reset areaPath
+ this.areaPath = [];
+
+ // Call the base method
+ Series.prototype.drawGraph.apply(this);
+
+ // Define local variables
+ var series = this,
+ areaPath = this.areaPath,
+ options = this.options,
+ zones = this.zones,
+ props = [['area', this.color, options.fillColor]]; // area name, main color, fill color
+
+ each(zones, function (threshold, i) {
+ props.push(['zoneArea' + i, threshold.color || series.color, threshold.fillColor || options.fillColor]);
+ });
+ each(props, function (prop) {
+ var areaKey = prop[0],
+ area = series[areaKey];
+
+ // Create or update the area
+ if (area) { // update
+ area.animate({ d: areaPath });
+
+ } else { // create
+ series[areaKey] = series.chart.renderer.path(areaPath)
+ .attr({
+ fill: pick(
+ prop[2],
+ Color(prop[1]).setOpacity(pick(options.fillOpacity, 0.75)).get()
+ ),
+ zIndex: 0 // #1069
+ }).add(series.group);
+ }
+ });
+ },
+
+ drawLegendSymbol: LegendSymbolMixin.drawRectangle
+});
+
+seriesTypes.area = AreaSeries;
+
+
+/**
+ * Set the default options for spline
+ */
+defaultPlotOptions.spline = merge(defaultSeriesOptions);
+
+/**
+ * SplineSeries object
+ */
+var SplineSeries = extendClass(Series, {
+ type: 'spline',
+
+ /**
+ * Get the spline segment from a given point's previous neighbour to the given point
+ */
+ getPointSpline: function (segment, point, i) {
+ var smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc
+ denom = smoothing + 1,
+ plotX = point.plotX,
+ plotY = point.plotY,
+ lastPoint = segment[i - 1],
+ nextPoint = segment[i + 1],
+ leftContX,
+ leftContY,
+ rightContX,
+ rightContY,
+ ret;
+
+ // find control points
+ if (lastPoint && nextPoint) {
+
+ var lastX = lastPoint.plotX,
+ lastY = lastPoint.plotY,
+ nextX = nextPoint.plotX,
+ nextY = nextPoint.plotY,
+ correction;
+
+ leftContX = (smoothing * plotX + lastX) / denom;
+ leftContY = (smoothing * plotY + lastY) / denom;
+ rightContX = (smoothing * plotX + nextX) / denom;
+ rightContY = (smoothing * plotY + nextY) / denom;
+
+ // have the two control points make a straight line through main point
+ correction = ((rightContY - leftContY) * (rightContX - plotX)) /
+ (rightContX - leftContX) + plotY - rightContY;
+
+ leftContY += correction;
+ rightContY += correction;
+
+ // to prevent false extremes, check that control points are between
+ // neighbouring points' y values
+ if (leftContY > lastY && leftContY > plotY) {
+ leftContY = mathMax(lastY, plotY);
+ rightContY = 2 * plotY - leftContY; // mirror of left control point
+ } else if (leftContY < lastY && leftContY < plotY) {
+ leftContY = mathMin(lastY, plotY);
+ rightContY = 2 * plotY - leftContY;
+ }
+ if (rightContY > nextY && rightContY > plotY) {
+ rightContY = mathMax(nextY, plotY);
+ leftContY = 2 * plotY - rightContY;
+ } else if (rightContY < nextY && rightContY < plotY) {
+ rightContY = mathMin(nextY, plotY);
+ leftContY = 2 * plotY - rightContY;
+ }
+
+ // record for drawing in next point
+ point.rightContX = rightContX;
+ point.rightContY = rightContY;
+
+ }
+
+ // Visualize control points for debugging
+ /*
+ if (leftContX) {
+ this.chart.renderer.circle(leftContX + this.chart.plotLeft, leftContY + this.chart.plotTop, 2)
+ .attr({
+ stroke: 'red',
+ 'stroke-width': 1,
+ fill: 'none'
+ })
+ .add();
+ this.chart.renderer.path(['M', leftContX + this.chart.plotLeft, leftContY + this.chart.plotTop,
+ 'L', plotX + this.chart.plotLeft, plotY + this.chart.plotTop])
+ .attr({
+ stroke: 'red',
+ 'stroke-width': 1
+ })
+ .add();
+ this.chart.renderer.circle(rightContX + this.chart.plotLeft, rightContY + this.chart.plotTop, 2)
+ .attr({
+ stroke: 'green',
+ 'stroke-width': 1,
+ fill: 'none'
+ })
+ .add();
+ this.chart.renderer.path(['M', rightContX + this.chart.plotLeft, rightContY + this.chart.plotTop,
+ 'L', plotX + this.chart.plotLeft, plotY + this.chart.plotTop])
+ .attr({
+ stroke: 'green',
+ 'stroke-width': 1
+ })
+ .add();
+ }
+ */
+
+ // moveTo or lineTo
+ if (!i) {
+ ret = [M, plotX, plotY];
+ } else { // curve from last point to this
+ ret = [
+ 'C',
+ lastPoint.rightContX || lastPoint.plotX,
+ lastPoint.rightContY || lastPoint.plotY,
+ leftContX || plotX,
+ leftContY || plotY,
+ plotX,
+ plotY
+ ];
+ lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
+ }
+ return ret;
+ }
+});
+seriesTypes.spline = SplineSeries;
+
+
+
+/**
+ * Set the default options for areaspline
+ */
+defaultPlotOptions.areaspline = merge(defaultPlotOptions.area);
+
+/**
+ * AreaSplineSeries object
+ */
+var areaProto = AreaSeries.prototype,
+ AreaSplineSeries = extendClass(SplineSeries, {
+ type: 'areaspline',
+ closedStacks: true, // instead of following the previous graph back, follow the threshold back
+
+ // Mix in methods from the area series
+ getSegmentPath: areaProto.getSegmentPath,
+ closeSegment: areaProto.closeSegment,
+ drawGraph: areaProto.drawGraph,
+ drawLegendSymbol: LegendSymbolMixin.drawRectangle
+ });
+
+seriesTypes.areaspline = AreaSplineSeries;
+
+
+
+/**
+ * Set the default options for column
+ */
+defaultPlotOptions.column = merge(defaultSeriesOptions, {
+ borderColor: '#FFFFFF',
+ //borderWidth: 1,
+ borderRadius: 0,
+ //colorByPoint: undefined,
+ groupPadding: 0.2,
+ //grouping: true,
+ marker: null, // point options are specified in the base options
+ pointPadding: 0.1,
+ //pointWidth: null,
+ minPointLength: 0,
+ cropThreshold: 50, // when there are more points, they will not animate out of the chart on xAxis.setExtremes
+ pointRange: null, // null means auto, meaning 1 in a categorized axis and least distance between points if not categories
+ states: {
+ hover: {
+ brightness: 0.1,
+ shadow: false,
+ halo: false
+ },
+ select: {
+ color: '#C0C0C0',
+ borderColor: '#000000',
+ shadow: false
+ }
+ },
+ dataLabels: {
+ align: null, // auto
+ verticalAlign: null, // auto
+ y: null
+ },
+ softThreshold: false,
+ startFromThreshold: true, // docs (but false doesn't work well): http://jsfiddle.net/highcharts/hz8fopan/14/
+ stickyTracking: false,
+ tooltip: {
+ distance: 6
+ },
+ threshold: 0
+});
+
+/**
+ * ColumnSeries object
+ */
+var ColumnSeries = extendClass(Series, {
+ type: 'column',
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ stroke: 'borderColor',
+ fill: 'color',
+ r: 'borderRadius'
+ },
+ cropShoulder: 0,
+ directTouch: true, // When tooltip is not shared, this series (and derivatives) requires direct touch/hover. KD-tree does not apply.
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ negStacks: true, // use separate negative stacks, unlike area stacks where a negative
+ // point is substracted from previous (#1910)
+
+ /**
+ * Initialize the series
+ */
+ init: function () {
+ Series.prototype.init.apply(this, arguments);
+
+ var series = this,
+ chart = series.chart;
+
+ // if the series is added dynamically, force redraw of other
+ // series affected by a new column
+ if (chart.hasRendered) {
+ each(chart.series, function (otherSeries) {
+ if (otherSeries.type === series.type) {
+ otherSeries.isDirty = true;
+ }
+ });
+ }
+ },
+
+ /**
+ * Return the width and x offset of the columns adjusted for grouping, groupPadding, pointPadding,
+ * pointWidth etc.
+ */
+ getColumnMetrics: function () {
+
+ var series = this,
+ options = series.options,
+ xAxis = series.xAxis,
+ yAxis = series.yAxis,
+ reversedXAxis = xAxis.reversed,
+ stackKey,
+ stackGroups = {},
+ columnIndex,
+ columnCount = 0;
+
+ // Get the total number of column type series.
+ // This is called on every series. Consider moving this logic to a
+ // chart.orderStacks() function and call it on init, addSeries and removeSeries
+ if (options.grouping === false) {
+ columnCount = 1;
+ } else {
+ each(series.chart.series, function (otherSeries) {
+ var otherOptions = otherSeries.options,
+ otherYAxis = otherSeries.yAxis;
+ if (otherSeries.type === series.type && otherSeries.visible &&
+ yAxis.len === otherYAxis.len && yAxis.pos === otherYAxis.pos) { // #642, #2086
+ if (otherOptions.stacking) {
+ stackKey = otherSeries.stackKey;
+ if (stackGroups[stackKey] === UNDEFINED) {
+ stackGroups[stackKey] = columnCount++;
+ }
+ columnIndex = stackGroups[stackKey];
+ } else if (otherOptions.grouping !== false) { // #1162
+ columnIndex = columnCount++;
+ }
+ otherSeries.columnIndex = columnIndex;
+ }
+ });
+ }
+
+ var categoryWidth = mathMin(
+ mathAbs(xAxis.transA) * (xAxis.ordinalSlope || options.pointRange || xAxis.closestPointRange || xAxis.tickInterval || 1), // #2610
+ xAxis.len // #1535
+ ),
+ groupPadding = categoryWidth * options.groupPadding,
+ groupWidth = categoryWidth - 2 * groupPadding,
+ pointOffsetWidth = groupWidth / columnCount,
+ pointWidth = mathMin(
+ options.maxPointWidth || xAxis.len,
+ pick(options.pointWidth, pointOffsetWidth * (1 - 2 * options.pointPadding))
+ ),
+ pointPadding = (pointOffsetWidth - pointWidth) / 2,
+ colIndex = (reversedXAxis ?
+ columnCount - (series.columnIndex || 0) : // #1251
+ series.columnIndex) || 0,
+ pointXOffset = pointPadding + (groupPadding + colIndex *
+ pointOffsetWidth - (categoryWidth / 2)) *
+ (reversedXAxis ? -1 : 1);
+
+ // Save it for reading in linked series (Error bars particularly)
+ return (series.columnMetrics = {
+ width: pointWidth,
+ offset: pointXOffset
+ });
+
+ },
+
+ /**
+ * Make the columns crisp. The edges are rounded to the nearest full pixel.
+ */
+ crispCol: function (x, y, w, h) {
+ var chart = this.chart,
+ borderWidth = this.borderWidth,
+ xCrisp = -(borderWidth % 2 ? 0.5 : 0),
+ yCrisp = borderWidth % 2 ? 0.5 : 1,
+ right,
+ bottom,
+ fromTop;
+
+ if (chart.inverted && chart.renderer.isVML) {
+ yCrisp += 1;
+ }
+
+ // Horizontal. We need to first compute the exact right edge, then round it
+ // and compute the width from there.
+ right = Math.round(x + w) + xCrisp;
+ x = Math.round(x) + xCrisp;
+ w = right - x;
+
+ // Vertical
+ fromTop = mathAbs(y) <= 0.5; // #4504
+ bottom = Math.round(y + h) + yCrisp;
+ y = Math.round(y) + yCrisp;
+ h = bottom - y;
+
+ // Top edges are exceptions
+ if (fromTop) {
+ y -= 1;
+ h += 1;
+ }
+
+ return {
+ x: x,
+ y: y,
+ width: w,
+ height: h
+ };
+ },
+
+ /**
+ * Translate each point to the plot area coordinate system and find shape positions
+ */
+ translate: function () {
+ var series = this,
+ chart = series.chart,
+ options = series.options,
+ borderWidth = series.borderWidth = pick(
+ options.borderWidth,
+ series.closestPointRange * series.xAxis.transA < 2 ? 0 : 1 // #3635
+ ),
+ yAxis = series.yAxis,
+ threshold = options.threshold,
+ translatedThreshold = series.translatedThreshold = yAxis.getThreshold(threshold),
+ minPointLength = pick(options.minPointLength, 5),
+ metrics = series.getColumnMetrics(),
+ pointWidth = metrics.width,
+ seriesBarW = series.barW = mathMax(pointWidth, 1 + 2 * borderWidth), // postprocessed for border width
+ pointXOffset = series.pointXOffset = metrics.offset;
+
+ if (chart.inverted) {
+ translatedThreshold -= 0.5; // #3355
+ }
+
+ // When the pointPadding is 0, we want the columns to be packed tightly, so we allow individual
+ // columns to have individual sizes. When pointPadding is greater, we strive for equal-width
+ // columns (#2694).
+ if (options.pointPadding) {
+ seriesBarW = mathCeil(seriesBarW);
+ }
+
+ Series.prototype.translate.apply(series);
+
+ // Record the new values
+ each(series.points, function (point) {
+ var yBottom = mathMin(pick(point.yBottom, translatedThreshold), 9e4), // #3575
+ safeDistance = 999 + mathAbs(yBottom),
+ plotY = mathMin(mathMax(-safeDistance, point.plotY), yAxis.len + safeDistance), // Don't draw too far outside plot area (#1303, #2241, #4264)
+ barX = point.plotX + pointXOffset,
+ barW = seriesBarW,
+ barY = mathMin(plotY, yBottom),
+ up,
+ barH = mathMax(plotY, yBottom) - barY;
+
+ // Handle options.minPointLength
+ if (mathAbs(barH) < minPointLength) {
+ if (minPointLength) {
+ barH = minPointLength;
+ up = (!yAxis.reversed && !point.negative) || (yAxis.reversed && point.negative);
+ barY = mathAbs(barY - translatedThreshold) > minPointLength ? // stacked
+ yBottom - minPointLength : // keep position
+ translatedThreshold - (up ? minPointLength : 0); // #1485, #4051
+ }
+ }
+
+ // Cache for access in polar
+ point.barX = barX;
+ point.pointWidth = pointWidth;
+
+ // Fix the tooltip on center of grouped columns (#1216, #424, #3648)
+ point.tooltipPos = chart.inverted ?
+ [yAxis.len + yAxis.pos - chart.plotLeft - plotY, series.xAxis.len - barX - barW / 2, barH] :
+ [barX + barW / 2, plotY + yAxis.pos - chart.plotTop, barH];
+
+ // Register shape type and arguments to be used in drawPoints
+ point.shapeType = 'rect';
+ point.shapeArgs = series.crispCol(barX, barY, barW, barH);
+ });
+
+ },
+
+ getSymbol: noop,
+
+ /**
+ * Use a solid rectangle like the area series types
+ */
+ drawLegendSymbol: LegendSymbolMixin.drawRectangle,
+
+
+ /**
+ * Columns have no graph
+ */
+ drawGraph: noop,
+
+ /**
+ * Draw the columns. For bars, the series.group is rotated, so the same coordinates
+ * apply for columns and bars. This method is inherited by scatter series.
+ *
+ */
+ drawPoints: function () {
+ var series = this,
+ chart = this.chart,
+ options = series.options,
+ renderer = chart.renderer,
+ animationLimit = options.animationLimit || 250,
+ shapeArgs,
+ pointAttr;
+
+ // draw the columns
+ each(series.points, function (point) {
+ var plotY = point.plotY,
+ graphic = point.graphic,
+ borderAttr;
+
+ if (plotY !== UNDEFINED && !isNaN(plotY) && point.y !== null) {
+ shapeArgs = point.shapeArgs;
+
+ borderAttr = defined(series.borderWidth) ? {
+ 'stroke-width': series.borderWidth
+ } : {};
+
+ pointAttr = point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE] || series.pointAttr[NORMAL_STATE];
+
+ if (graphic) { // update
+ stop(graphic);
+ graphic.attr(borderAttr)[chart.pointCount < animationLimit ? 'animate' : 'attr'](merge(shapeArgs));
+
+ } else {
+ point.graphic = graphic = renderer[point.shapeType](shapeArgs)
+ .attr(borderAttr)
+ .attr(pointAttr)
+ .add(point.group || series.group)
+ .shadow(options.shadow, null, options.stacking && !options.borderRadius);
+ }
+
+ } else if (graphic) {
+ point.graphic = graphic.destroy(); // #1269
+ }
+ });
+ },
+
+ /**
+ * Animate the column heights one by one from zero
+ * @param {Boolean} init Whether to initialize the animation or run it
+ */
+ animate: function (init) {
+ var series = this,
+ yAxis = this.yAxis,
+ options = series.options,
+ inverted = this.chart.inverted,
+ attr = {},
+ translatedThreshold;
+
+ if (hasSVG) { // VML is too slow anyway
+ if (init) {
+ attr.scaleY = 0.001;
+ translatedThreshold = mathMin(yAxis.pos + yAxis.len, mathMax(yAxis.pos, yAxis.toPixels(options.threshold)));
+ if (inverted) {
+ attr.translateX = translatedThreshold - yAxis.len;
+ } else {
+ attr.translateY = translatedThreshold;
+ }
+ series.group.attr(attr);
+
+ } else { // run the animation
+
+ attr.scaleY = 1;
+ attr[inverted ? 'translateX' : 'translateY'] = yAxis.pos;
+ series.group.animate(attr, series.options.animation);
+
+ // delete this function to allow it only once
+ series.animate = null;
+ }
+ }
+ },
+
+ /**
+ * Remove this series from the chart
+ */
+ remove: function () {
+ var series = this,
+ chart = series.chart;
+
+ // column and bar series affects other series of the same type
+ // as they are either stacked or grouped
+ if (chart.hasRendered) {
+ each(chart.series, function (otherSeries) {
+ if (otherSeries.type === series.type) {
+ otherSeries.isDirty = true;
+ }
+ });
+ }
+
+ Series.prototype.remove.apply(series, arguments);
+ }
+});
+seriesTypes.column = ColumnSeries;
+
+
+/**
+ * Set the default options for bar
+ */
+defaultPlotOptions.bar = merge(defaultPlotOptions.column);
+/**
+ * The Bar series class
+ */
+var BarSeries = extendClass(ColumnSeries, {
+ type: 'bar',
+ inverted: true
+});
+seriesTypes.bar = BarSeries;
+
+
+
+/**
+ * Set the default options for scatter
+ */
+defaultPlotOptions.scatter = merge(defaultSeriesOptions, {
+ lineWidth: 0,
+ marker: {
+ enabled: true // Overrides auto-enabling in line series (#3647)
+ },
+ tooltip: {
+ headerFormat: '\u25CF {series.name}
',
+ pointFormat: 'x: {point.x}
y: {point.y}
'
+ }
+});
+
+/**
+ * The scatter series class
+ */
+var ScatterSeries = extendClass(Series, {
+ type: 'scatter',
+ sorted: false,
+ requireSorting: false,
+ noSharedTooltip: true,
+ trackerGroups: ['group', 'markerGroup', 'dataLabelsGroup'],
+ takeOrdinalPosition: false, // #2342
+ kdDimensions: 2,
+ drawGraph: function () {
+ if (this.options.lineWidth) {
+ Series.prototype.drawGraph.call(this);
+ }
+ }
+});
+
+seriesTypes.scatter = ScatterSeries;
+
+
+
+/**
+ * Set the default options for pie
+ */
+defaultPlotOptions.pie = merge(defaultSeriesOptions, {
+ borderColor: '#FFFFFF',
+ borderWidth: 1,
+ center: [null, null],
+ clip: false,
+ colorByPoint: true, // always true for pies
+ dataLabels: {
+ // align: null,
+ // connectorWidth: 1,
+ // connectorColor: point.color,
+ // connectorPadding: 5,
+ distance: 30,
+ enabled: true,
+ formatter: function () { // #2945
+ return this.y === null ? undefined : this.point.name;
+ },
+ // softConnector: true,
+ x: 0
+ // y: 0
+ },
+ ignoreHiddenPoint: true,
+ //innerSize: 0,
+ legendType: 'point',
+ marker: null, // point options are specified in the base options
+ size: null,
+ showInLegend: false,
+ slicedOffset: 10,
+ states: {
+ hover: {
+ brightness: 0.1,
+ shadow: false
+ }
+ },
+ stickyTracking: false,
+ tooltip: {
+ followPointer: true
+ }
+});
+
+/**
+ * Extended point object for pies
+ */
+var PiePoint = extendClass(Point, {
+ /**
+ * Initiate the pie slice
+ */
+ init: function () {
+
+ Point.prototype.init.apply(this, arguments);
+
+ var point = this,
+ toggleSlice;
+
+ point.name = pick(point.name, 'Slice');
+
+ // add event listener for select
+ toggleSlice = function (e) {
+ point.slice(e.type === 'select');
+ };
+ addEvent(point, 'select', toggleSlice);
+ addEvent(point, 'unselect', toggleSlice);
+
+ return point;
+ },
+
+ /**
+ * Toggle the visibility of the pie slice
+ * @param {Boolean} vis Whether to show the slice or not. If undefined, the
+ * visibility is toggled
+ */
+ setVisible: function (vis, redraw) {
+ var point = this,
+ series = point.series,
+ chart = series.chart,
+ ignoreHiddenPoint = series.options.ignoreHiddenPoint;
+
+ redraw = pick(redraw, ignoreHiddenPoint);
+
+ if (vis !== point.visible) {
+
+ // If called without an argument, toggle visibility
+ point.visible = point.options.visible = vis = vis === UNDEFINED ? !point.visible : vis;
+ series.options.data[inArray(point, series.data)] = point.options; // update userOptions.data
+
+ // Show and hide associated elements. This is performed regardless of redraw or not,
+ // because chart.redraw only handles full series.
+ each(['graphic', 'dataLabel', 'connector', 'shadowGroup'], function (key) {
+ if (point[key]) {
+ point[key][vis ? 'show' : 'hide'](true);
+ }
+ });
+
+ if (point.legendItem) {
+ chart.legend.colorizeItem(point, vis);
+ }
+
+ // #4170, hide halo after hiding point
+ if (!vis && point.state === 'hover') {
+ point.setState('');
+ }
+
+ // Handle ignore hidden slices
+ if (ignoreHiddenPoint) {
+ series.isDirty = true;
+ }
+
+ if (redraw) {
+ chart.redraw();
+ }
+ }
+ },
+
+ /**
+ * Set or toggle whether the slice is cut out from the pie
+ * @param {Boolean} sliced When undefined, the slice state is toggled
+ * @param {Boolean} redraw Whether to redraw the chart. True by default.
+ */
+ slice: function (sliced, redraw, animation) {
+ var point = this,
+ series = point.series,
+ chart = series.chart,
+ translation;
+
+ setAnimation(animation, chart);
+
+ // redraw is true by default
+ redraw = pick(redraw, true);
+
+ // if called without an argument, toggle
+ point.sliced = point.options.sliced = sliced = defined(sliced) ? sliced : !point.sliced;
+ series.options.data[inArray(point, series.data)] = point.options; // update userOptions.data
+
+ translation = sliced ? point.slicedTranslation : {
+ translateX: 0,
+ translateY: 0
+ };
+
+ point.graphic.animate(translation);
+
+ if (point.shadowGroup) {
+ point.shadowGroup.animate(translation);
+ }
+
+ },
+
+ haloPath: function (size) {
+ var shapeArgs = this.shapeArgs,
+ chart = this.series.chart;
+
+ return this.sliced || !this.visible ? [] : this.series.chart.renderer.symbols.arc(chart.plotLeft + shapeArgs.x, chart.plotTop + shapeArgs.y, shapeArgs.r + size, shapeArgs.r + size, {
+ innerR: this.shapeArgs.r,
+ start: shapeArgs.start,
+ end: shapeArgs.end
+ });
+ }
+});
+
+/**
+ * The Pie series class
+ */
+var PieSeries = {
+ type: 'pie',
+ isCartesian: false,
+ pointClass: PiePoint,
+ requireSorting: false,
+ directTouch: true,
+ noSharedTooltip: true,
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ axisTypes: [],
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ stroke: 'borderColor',
+ 'stroke-width': 'borderWidth',
+ fill: 'color'
+ },
+
+ /**
+ * Animate the pies in
+ */
+ animate: function (init) {
+ var series = this,
+ points = series.points,
+ startAngleRad = series.startAngleRad;
+
+ if (!init) {
+ each(points, function (point) {
+ var graphic = point.graphic,
+ args = point.shapeArgs;
+
+ if (graphic) {
+ // start values
+ graphic.attr({
+ r: point.startR || (series.center[3] / 2), // animate from inner radius (#779)
+ start: startAngleRad,
+ end: startAngleRad
+ });
+
+ // animate
+ graphic.animate({
+ r: args.r,
+ start: args.start,
+ end: args.end
+ }, series.options.animation);
+ }
+ });
+
+ // delete this function to allow it only once
+ series.animate = null;
+ }
+ },
+
+ /**
+ * Recompute total chart sum and update percentages of points.
+ */
+ updateTotals: function () {
+ var i,
+ total = 0,
+ points = this.points,
+ len = points.length,
+ point,
+ ignoreHiddenPoint = this.options.ignoreHiddenPoint;
+
+ // Get the total sum
+ for (i = 0; i < len; i++) {
+ point = points[i];
+ total += (ignoreHiddenPoint && !point.visible) ? 0 : point.y;
+ }
+ this.total = total;
+
+ // Set each point's properties
+ for (i = 0; i < len; i++) {
+ point = points[i];
+ point.percentage = (total > 0 && (point.visible || !ignoreHiddenPoint)) ? point.y / total * 100 : 0;
+ point.total = total;
+ }
+ },
+
+ /**
+ * Extend the generatePoints method by adding total and percentage properties to each point
+ */
+ generatePoints: function () {
+ Series.prototype.generatePoints.call(this);
+ this.updateTotals();
+ },
+
+ /**
+ * Do translation for pie slices
+ */
+ translate: function (positions) {
+ this.generatePoints();
+
+ var series = this,
+ cumulative = 0,
+ precision = 1000, // issue #172
+ options = series.options,
+ slicedOffset = options.slicedOffset,
+ connectorOffset = slicedOffset + options.borderWidth,
+ start,
+ end,
+ angle,
+ startAngle = options.startAngle || 0,
+ startAngleRad = series.startAngleRad = mathPI / 180 * (startAngle - 90),
+ endAngleRad = series.endAngleRad = mathPI / 180 * ((pick(options.endAngle, startAngle + 360)) - 90),
+ circ = endAngleRad - startAngleRad, //2 * mathPI,
+ points = series.points,
+ radiusX, // the x component of the radius vector for a given point
+ radiusY,
+ labelDistance = options.dataLabels.distance,
+ ignoreHiddenPoint = options.ignoreHiddenPoint,
+ i,
+ len = points.length,
+ point;
+
+ // Get positions - either an integer or a percentage string must be given.
+ // If positions are passed as a parameter, we're in a recursive loop for adjusting
+ // space for data labels.
+ if (!positions) {
+ series.center = positions = series.getCenter();
+ }
+
+ // utility for getting the x value from a given y, used for anticollision logic in data labels
+ series.getX = function (y, left) {
+
+ angle = math.asin(mathMin((y - positions[1]) / (positions[2] / 2 + labelDistance), 1));
+
+ return positions[0] +
+ (left ? -1 : 1) *
+ (mathCos(angle) * (positions[2] / 2 + labelDistance));
+ };
+
+ // Calculate the geometry for each point
+ for (i = 0; i < len; i++) {
+
+ point = points[i];
+
+ // set start and end angle
+ start = startAngleRad + (cumulative * circ);
+ if (!ignoreHiddenPoint || point.visible) {
+ cumulative += point.percentage / 100;
+ }
+ end = startAngleRad + (cumulative * circ);
+
+ // set the shape
+ point.shapeType = 'arc';
+ point.shapeArgs = {
+ x: positions[0],
+ y: positions[1],
+ r: positions[2] / 2,
+ innerR: positions[3] / 2,
+ start: mathRound(start * precision) / precision,
+ end: mathRound(end * precision) / precision
+ };
+
+ // The angle must stay within -90 and 270 (#2645)
+ angle = (end + start) / 2;
+ if (angle > 1.5 * mathPI) {
+ angle -= 2 * mathPI;
+ } else if (angle < -mathPI / 2) {
+ angle += 2 * mathPI;
+ }
+
+ // Center for the sliced out slice
+ point.slicedTranslation = {
+ translateX: mathRound(mathCos(angle) * slicedOffset),
+ translateY: mathRound(mathSin(angle) * slicedOffset)
+ };
+
+ // set the anchor point for tooltips
+ radiusX = mathCos(angle) * positions[2] / 2;
+ radiusY = mathSin(angle) * positions[2] / 2;
+ point.tooltipPos = [
+ positions[0] + radiusX * 0.7,
+ positions[1] + radiusY * 0.7
+ ];
+
+ point.half = angle < -mathPI / 2 || angle > mathPI / 2 ? 1 : 0;
+ point.angle = angle;
+
+ // set the anchor point for data labels
+ connectorOffset = mathMin(connectorOffset, labelDistance / 2); // #1678
+ point.labelPos = [
+ positions[0] + radiusX + mathCos(angle) * labelDistance, // first break of connector
+ positions[1] + radiusY + mathSin(angle) * labelDistance, // a/a
+ positions[0] + radiusX + mathCos(angle) * connectorOffset, // second break, right outside pie
+ positions[1] + radiusY + mathSin(angle) * connectorOffset, // a/a
+ positions[0] + radiusX, // landing point for connector
+ positions[1] + radiusY, // a/a
+ labelDistance < 0 ? // alignment
+ 'center' :
+ point.half ? 'right' : 'left', // alignment
+ angle // center angle
+ ];
+
+ }
+ },
+
+ drawGraph: null,
+
+ /**
+ * Draw the data points
+ */
+ drawPoints: function () {
+ var series = this,
+ chart = series.chart,
+ renderer = chart.renderer,
+ groupTranslation,
+ //center,
+ graphic,
+ //group,
+ shadow = series.options.shadow,
+ shadowGroup,
+ shapeArgs,
+ attr;
+
+ if (shadow && !series.shadowGroup) {
+ series.shadowGroup = renderer.g('shadow')
+ .add(series.group);
+ }
+
+ // draw the slices
+ each(series.points, function (point) {
+ if (point.y !== null) {
+ graphic = point.graphic;
+ shapeArgs = point.shapeArgs;
+ shadowGroup = point.shadowGroup;
+
+ // put the shadow behind all points
+ if (shadow && !shadowGroup) {
+ shadowGroup = point.shadowGroup = renderer.g('shadow')
+ .add(series.shadowGroup);
+ }
+
+ // if the point is sliced, use special translation, else use plot area traslation
+ groupTranslation = point.sliced ? point.slicedTranslation : {
+ translateX: 0,
+ translateY: 0
+ };
+
+ //group.translate(groupTranslation[0], groupTranslation[1]);
+ if (shadowGroup) {
+ shadowGroup.attr(groupTranslation);
+ }
+
+ // draw the slice
+ if (graphic) {
+ graphic
+ .setRadialReference(series.center)
+ .animate(extend(shapeArgs, groupTranslation));
+ } else {
+ attr = { 'stroke-linejoin': 'round' };
+ if (!point.visible) {
+ attr.visibility = 'hidden';
+ }
+
+ point.graphic = graphic = renderer[point.shapeType](shapeArgs)
+ .setRadialReference(series.center)
+ .attr(
+ point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE]
+ )
+ .attr(attr)
+ .attr(groupTranslation)
+ .add(series.group)
+ .shadow(shadow, shadowGroup);
+ }
+ }
+ });
+
+ },
+
+
+ searchPoint: noop,
+
+ /**
+ * Utility for sorting data labels
+ */
+ sortByAngle: function (points, sign) {
+ points.sort(function (a, b) {
+ return a.angle !== undefined && (b.angle - a.angle) * sign;
+ });
+ },
+
+ /**
+ * Use a simple symbol from LegendSymbolMixin
+ */
+ drawLegendSymbol: LegendSymbolMixin.drawRectangle,
+
+ /**
+ * Use the getCenter method from drawLegendSymbol
+ */
+ getCenter: CenteredSeriesMixin.getCenter,
+
+ /**
+ * Pies don't have point marker symbols
+ */
+ getSymbol: noop
+
+};
+PieSeries = extendClass(Series, PieSeries);
+seriesTypes.pie = PieSeries;
+
+
+
+/**
+ * Draw the data labels
+ */
+Series.prototype.drawDataLabels = function () {
+
+ var series = this,
+ seriesOptions = series.options,
+ cursor = seriesOptions.cursor,
+ options = seriesOptions.dataLabels,
+ points = series.points,
+ pointOptions,
+ generalOptions,
+ hasRendered = series.hasRendered || 0,
+ str,
+ dataLabelsGroup,
+ renderer = series.chart.renderer;
+
+ if (options.enabled || series._hasPointLabels) {
+
+ // Process default alignment of data labels for columns
+ if (series.dlProcessOptions) {
+ series.dlProcessOptions(options);
+ }
+
+ // Create a separate group for the data labels to avoid rotation
+ dataLabelsGroup = series.plotGroup(
+ 'dataLabelsGroup',
+ 'data-labels',
+ options.defer ? HIDDEN : VISIBLE,
+ options.zIndex || 6
+ );
+
+ if (pick(options.defer, true)) {
+ dataLabelsGroup.attr({ opacity: +hasRendered }); // #3300
+ if (!hasRendered) {
+ addEvent(series, 'afterAnimate', function () {
+ if (series.visible) { // #3023, #3024
+ dataLabelsGroup.show();
+ }
+ dataLabelsGroup[seriesOptions.animation ? 'animate' : 'attr']({ opacity: 1 }, { duration: 200 });
+ });
+ }
+ }
+
+ // Make the labels for each point
+ generalOptions = options;
+ each(points, function (point) {
+
+ var enabled,
+ dataLabel = point.dataLabel,
+ labelConfig,
+ attr,
+ name,
+ rotation,
+ connector = point.connector,
+ isNew = true,
+ style,
+ moreStyle = {};
+
+ // Determine if each data label is enabled
+ pointOptions = point.dlOptions || (point.options && point.options.dataLabels); // dlOptions is used in treemaps
+ enabled = pick(pointOptions && pointOptions.enabled, generalOptions.enabled); // #2282
+
+
+ // If the point is outside the plot area, destroy it. #678, #820
+ if (dataLabel && !enabled) {
+ point.dataLabel = dataLabel.destroy();
+
+ // Individual labels are disabled if the are explicitly disabled
+ // in the point options, or if they fall outside the plot area.
+ } else if (enabled) {
+
+ // Create individual options structure that can be extended without
+ // affecting others
+ options = merge(generalOptions, pointOptions);
+ style = options.style;
+
+ rotation = options.rotation;
+
+ // Get the string
+ labelConfig = point.getLabelConfig();
+ str = options.format ?
+ format(options.format, labelConfig) :
+ options.formatter.call(labelConfig, options);
+
+ // Determine the color
+ style.color = pick(options.color, style.color, series.color, 'black');
+
+
+ // update existing label
+ if (dataLabel) {
+
+ if (defined(str)) {
+ dataLabel
+ .attr({
+ text: str
+ });
+ isNew = false;
+
+ } else { // #1437 - the label is shown conditionally
+ point.dataLabel = dataLabel = dataLabel.destroy();
+ if (connector) {
+ point.connector = connector.destroy();
+ }
+ }
+
+ // create new label
+ } else if (defined(str)) {
+ attr = {
+ //align: align,
+ fill: options.backgroundColor,
+ stroke: options.borderColor,
+ 'stroke-width': options.borderWidth,
+ r: options.borderRadius || 0,
+ rotation: rotation,
+ padding: options.padding,
+ zIndex: 1
+ };
+
+ // Get automated contrast color
+ if (style.color === 'contrast') {
+ moreStyle.color = options.inside || options.distance < 0 || !!seriesOptions.stacking ?
+ renderer.getContrast(point.color || series.color) :
+ '#000000';
+ }
+ if (cursor) {
+ moreStyle.cursor = cursor;
+ }
+
+
+ // Remove unused attributes (#947)
+ for (name in attr) {
+ if (attr[name] === UNDEFINED) {
+ delete attr[name];
+ }
+ }
+
+ dataLabel = point.dataLabel = renderer[rotation ? 'text' : 'label']( // labels don't support rotation
+ str,
+ 0,
+ -999,
+ options.shape,
+ null,
+ null,
+ options.useHTML
+ )
+ .attr(attr)
+ .css(extend(style, moreStyle))
+ .add(dataLabelsGroup)
+ .shadow(options.shadow);
+
+ }
+
+ if (dataLabel) {
+ // Now the data label is created and placed at 0,0, so we need to align it
+ series.alignDataLabel(point, dataLabel, options, null, isNew);
+ }
+ }
+ });
+ }
+};
+
+/**
+ * Align each individual data label
+ */
+Series.prototype.alignDataLabel = function (point, dataLabel, options, alignTo, isNew) {
+ var chart = this.chart,
+ inverted = chart.inverted,
+ plotX = pick(point.plotX, -999),
+ plotY = pick(point.plotY, -999),
+ bBox = dataLabel.getBBox(),
+ baseline = chart.renderer.fontMetrics(options.style.fontSize).b,
+ rotCorr, // rotation correction
+ // Math.round for rounding errors (#2683), alignTo to allow column labels (#2700)
+ visible = this.visible && (point.series.forceDL || chart.isInsidePlot(plotX, mathRound(plotY), inverted) ||
+ (alignTo && chart.isInsidePlot(plotX, inverted ? alignTo.x + 1 : alignTo.y + alignTo.height - 1, inverted))),
+ alignAttr; // the final position;
+
+ if (visible) {
+
+ // The alignment box is a singular point
+ alignTo = extend({
+ x: inverted ? chart.plotWidth - plotY : plotX,
+ y: mathRound(inverted ? chart.plotHeight - plotX : plotY),
+ width: 0,
+ height: 0
+ }, alignTo);
+
+ // Add the text size for alignment calculation
+ extend(options, {
+ width: bBox.width,
+ height: bBox.height
+ });
+
+ // Allow a hook for changing alignment in the last moment, then do the alignment
+ if (options.rotation) { // Fancy box alignment isn't supported for rotated text
+ rotCorr = chart.renderer.rotCorr(baseline, options.rotation); // #3723
+ dataLabel[isNew ? 'attr' : 'animate']({
+ x: alignTo.x + options.x + alignTo.width / 2 + rotCorr.x,
+ y: alignTo.y + options.y + alignTo.height / 2
+ })
+ .attr({ // #3003
+ align: options.align
+ });
+ } else {
+ dataLabel.align(options, null, alignTo);
+ alignAttr = dataLabel.alignAttr;
+
+ // Handle justify or crop
+ if (pick(options.overflow, 'justify') === 'justify') {
+ this.justifyDataLabel(dataLabel, options, alignAttr, bBox, alignTo, isNew);
+
+ } else if (pick(options.crop, true)) {
+ // Now check that the data label is within the plot area
+ visible = chart.isInsidePlot(alignAttr.x, alignAttr.y) && chart.isInsidePlot(alignAttr.x + bBox.width, alignAttr.y + bBox.height);
+
+ }
+
+ // When we're using a shape, make it possible with a connector or an arrow pointing to thie point
+ if (options.shape) {
+ dataLabel.attr({
+ anchorX: point.plotX,
+ anchorY: point.plotY
+ });
+ }
+
+ }
+ }
+
+ // Show or hide based on the final aligned position
+ if (!visible) {
+ stop(dataLabel);
+ dataLabel.attr({ y: -999 });
+ dataLabel.placed = false; // don't animate back in
+ }
+
+};
+
+/**
+ * If data labels fall partly outside the plot area, align them back in, in a way that
+ * doesn't hide the point.
+ */
+Series.prototype.justifyDataLabel = function (dataLabel, options, alignAttr, bBox, alignTo, isNew) {
+ var chart = this.chart,
+ align = options.align,
+ verticalAlign = options.verticalAlign,
+ off,
+ justified,
+ padding = dataLabel.box ? 0 : (dataLabel.padding || 0);
+
+ // Off left
+ off = alignAttr.x + padding;
+ if (off < 0) {
+ if (align === 'right') {
+ options.align = 'left';
+ } else {
+ options.x = -off;
+ }
+ justified = true;
+ }
+
+ // Off right
+ off = alignAttr.x + bBox.width - padding;
+ if (off > chart.plotWidth) {
+ if (align === 'left') {
+ options.align = 'right';
+ } else {
+ options.x = chart.plotWidth - off;
+ }
+ justified = true;
+ }
+
+ // Off top
+ off = alignAttr.y + padding;
+ if (off < 0) {
+ if (verticalAlign === 'bottom') {
+ options.verticalAlign = 'top';
+ } else {
+ options.y = -off;
+ }
+ justified = true;
+ }
+
+ // Off bottom
+ off = alignAttr.y + bBox.height - padding;
+ if (off > chart.plotHeight) {
+ if (verticalAlign === 'top') {
+ options.verticalAlign = 'bottom';
+ } else {
+ options.y = chart.plotHeight - off;
+ }
+ justified = true;
+ }
+
+ if (justified) {
+ dataLabel.placed = !isNew;
+ dataLabel.align(options, null, alignTo);
+ }
+};
+
+/**
+ * Override the base drawDataLabels method by pie specific functionality
+ */
+if (seriesTypes.pie) {
+ seriesTypes.pie.prototype.drawDataLabels = function () {
+ var series = this,
+ data = series.data,
+ point,
+ chart = series.chart,
+ options = series.options.dataLabels,
+ connectorPadding = pick(options.connectorPadding, 10),
+ connectorWidth = pick(options.connectorWidth, 1),
+ plotWidth = chart.plotWidth,
+ plotHeight = chart.plotHeight,
+ connector,
+ connectorPath,
+ softConnector = pick(options.softConnector, true),
+ distanceOption = options.distance,
+ seriesCenter = series.center,
+ radius = seriesCenter[2] / 2,
+ centerY = seriesCenter[1],
+ outside = distanceOption > 0,
+ dataLabel,
+ dataLabelWidth,
+ labelPos,
+ labelHeight,
+ halves = [// divide the points into right and left halves for anti collision
+ [], // right
+ [] // left
+ ],
+ x,
+ y,
+ visibility,
+ rankArr,
+ i,
+ j,
+ overflow = [0, 0, 0, 0], // top, right, bottom, left
+ sort = function (a, b) {
+ return b.y - a.y;
+ };
+
+ // get out if not enabled
+ if (!series.visible || (!options.enabled && !series._hasPointLabels)) {
+ return;
+ }
+
+ // run parent method
+ Series.prototype.drawDataLabels.apply(series);
+
+ // arrange points for detection collision
+ each(data, function (point) {
+ if (point.dataLabel && point.visible) { // #407, #2510
+ halves[point.half].push(point);
+ }
+ });
+
+ /* Loop over the points in each half, starting from the top and bottom
+ * of the pie to detect overlapping labels.
+ */
+ i = 2;
+ while (i--) {
+
+ var slots = [],
+ slotsLength,
+ usedSlots = [],
+ points = halves[i],
+ pos,
+ bottom,
+ length = points.length,
+ slotIndex;
+
+ if (!length) {
+ continue;
+ }
+
+ // Sort by angle
+ series.sortByAngle(points, i - 0.5);
+
+ // Assume equal label heights on either hemisphere (#2630)
+ j = labelHeight = 0;
+ while (!labelHeight && points[j]) { // #1569
+ labelHeight = points[j] && points[j].dataLabel && (points[j].dataLabel.getBBox().height || 21); // 21 is for #968
+ j++;
+ }
+
+ // Only do anti-collision when we are outside the pie and have connectors (#856)
+ if (distanceOption > 0) {
+
+ // Build the slots
+ bottom = mathMin(centerY + radius + distanceOption, chart.plotHeight);
+ for (pos = mathMax(0, centerY - radius - distanceOption); pos <= bottom; pos += labelHeight) {
+ slots.push(pos);
+ }
+ slotsLength = slots.length;
+
+
+ /* Visualize the slots
+ if (!series.slotElements) {
+ series.slotElements = [];
+ }
+ if (i === 1) {
+ series.slotElements.forEach(function (elem) {
+ elem.destroy();
+ });
+ series.slotElements.length = 0;
+ }
+
+ slots.forEach(function (pos, no) {
+ var slotX = series.getX(pos, i) + chart.plotLeft - (i ? 100 : 0),
+ slotY = pos + chart.plotTop;
+
+ if (!isNaN(slotX)) {
+ series.slotElements.push(chart.renderer.rect(slotX, slotY - 7, 100, labelHeight, 1)
+ .attr({
+ 'stroke-width': 1,
+ stroke: 'silver',
+ fill: 'rgba(0,0,255,0.1)'
+ })
+ .add());
+ series.slotElements.push(chart.renderer.text('Slot '+ no, slotX, slotY + 4)
+ .attr({
+ fill: 'silver'
+ }).add());
+ }
+ });
+ // */
+
+ // if there are more values than available slots, remove lowest values
+ if (length > slotsLength) {
+ // create an array for sorting and ranking the points within each quarter
+ rankArr = [].concat(points);
+ rankArr.sort(sort);
+ j = length;
+ while (j--) {
+ rankArr[j].rank = j;
+ }
+ j = length;
+ while (j--) {
+ if (points[j].rank >= slotsLength) {
+ points.splice(j, 1);
+ }
+ }
+ length = points.length;
+ }
+
+ // The label goes to the nearest open slot, but not closer to the edge than
+ // the label's index.
+ for (j = 0; j < length; j++) {
+
+ point = points[j];
+ labelPos = point.labelPos;
+
+ var closest = 9999,
+ distance,
+ slotI;
+
+ // find the closest slot index
+ for (slotI = 0; slotI < slotsLength; slotI++) {
+ distance = mathAbs(slots[slotI] - labelPos[1]);
+ if (distance < closest) {
+ closest = distance;
+ slotIndex = slotI;
+ }
+ }
+
+ // if that slot index is closer to the edges of the slots, move it
+ // to the closest appropriate slot
+ if (slotIndex < j && slots[j] !== null) { // cluster at the top
+ slotIndex = j;
+ } else if (slotsLength < length - j + slotIndex && slots[j] !== null) { // cluster at the bottom
+ slotIndex = slotsLength - length + j;
+ while (slots[slotIndex] === null) { // make sure it is not taken
+ slotIndex++;
+ }
+ } else {
+ // Slot is taken, find next free slot below. In the next run, the next slice will find the
+ // slot above these, because it is the closest one
+ while (slots[slotIndex] === null) { // make sure it is not taken
+ slotIndex++;
+ }
+ }
+
+ usedSlots.push({ i: slotIndex, y: slots[slotIndex] });
+ slots[slotIndex] = null; // mark as taken
+ }
+ // sort them in order to fill in from the top
+ usedSlots.sort(sort);
+ }
+
+ // now the used slots are sorted, fill them up sequentially
+ for (j = 0; j < length; j++) {
+
+ var slot, naturalY;
+
+ point = points[j];
+ labelPos = point.labelPos;
+ dataLabel = point.dataLabel;
+ visibility = point.visible === false ? HIDDEN : 'inherit';
+ naturalY = labelPos[1];
+
+ if (distanceOption > 0) {
+ slot = usedSlots.pop();
+ slotIndex = slot.i;
+
+ // if the slot next to currrent slot is free, the y value is allowed
+ // to fall back to the natural position
+ y = slot.y;
+ if ((naturalY > y && slots[slotIndex + 1] !== null) ||
+ (naturalY < y && slots[slotIndex - 1] !== null)) {
+ y = mathMin(mathMax(0, naturalY), chart.plotHeight);
+ }
+
+ } else {
+ y = naturalY;
+ }
+
+ // get the x - use the natural x position for first and last slot, to prevent the top
+ // and botton slice connectors from touching each other on either side
+ x = options.justify ?
+ seriesCenter[0] + (i ? -1 : 1) * (radius + distanceOption) :
+ series.getX(y === centerY - radius - distanceOption || y === centerY + radius + distanceOption ? naturalY : y, i);
+
+
+ // Record the placement and visibility
+ dataLabel._attr = {
+ visibility: visibility,
+ align: labelPos[6]
+ };
+ dataLabel._pos = {
+ x: x + options.x +
+ ({ left: connectorPadding, right: -connectorPadding }[labelPos[6]] || 0),
+ y: y + options.y - 10 // 10 is for the baseline (label vs text)
+ };
+ dataLabel.connX = x;
+ dataLabel.connY = y;
+
+
+ // Detect overflowing data labels
+ if (this.options.size === null) {
+ dataLabelWidth = dataLabel.width;
+ // Overflow left
+ if (x - dataLabelWidth < connectorPadding) {
+ overflow[3] = mathMax(mathRound(dataLabelWidth - x + connectorPadding), overflow[3]);
+
+ // Overflow right
+ } else if (x + dataLabelWidth > plotWidth - connectorPadding) {
+ overflow[1] = mathMax(mathRound(x + dataLabelWidth - plotWidth + connectorPadding), overflow[1]);
+ }
+
+ // Overflow top
+ if (y - labelHeight / 2 < 0) {
+ overflow[0] = mathMax(mathRound(-y + labelHeight / 2), overflow[0]);
+
+ // Overflow left
+ } else if (y + labelHeight / 2 > plotHeight) {
+ overflow[2] = mathMax(mathRound(y + labelHeight / 2 - plotHeight), overflow[2]);
+ }
+ }
+ } // for each point
+ } // for each half
+
+ // Do not apply the final placement and draw the connectors until we have verified
+ // that labels are not spilling over.
+ if (arrayMax(overflow) === 0 || this.verifyDataLabelOverflow(overflow)) {
+
+ // Place the labels in the final position
+ this.placeDataLabels();
+
+ // Draw the connectors
+ if (outside && connectorWidth) {
+ each(this.points, function (point) {
+ connector = point.connector;
+ labelPos = point.labelPos;
+ dataLabel = point.dataLabel;
+
+ if (dataLabel && dataLabel._pos && point.visible) {
+ visibility = dataLabel._attr.visibility;
+ x = dataLabel.connX;
+ y = dataLabel.connY;
+ connectorPath = softConnector ? [
+ M,
+ x + (labelPos[6] === 'left' ? 5 : -5), y, // end of the string at the label
+ 'C',
+ x, y, // first break, next to the label
+ 2 * labelPos[2] - labelPos[4], 2 * labelPos[3] - labelPos[5],
+ labelPos[2], labelPos[3], // second break
+ L,
+ labelPos[4], labelPos[5] // base
+ ] : [
+ M,
+ x + (labelPos[6] === 'left' ? 5 : -5), y, // end of the string at the label
+ L,
+ labelPos[2], labelPos[3], // second break
+ L,
+ labelPos[4], labelPos[5] // base
+ ];
+
+ if (connector) {
+ connector.animate({ d: connectorPath });
+ connector.attr('visibility', visibility);
+
+ } else {
+ point.connector = connector = series.chart.renderer.path(connectorPath).attr({
+ 'stroke-width': connectorWidth,
+ stroke: options.connectorColor || point.color || '#606060',
+ visibility: visibility
+ //zIndex: 0 // #2722 (reversed)
+ })
+ .add(series.dataLabelsGroup);
+ }
+ } else if (connector) {
+ point.connector = connector.destroy();
+ }
+ });
+ }
+ }
+ };
+ /**
+ * Perform the final placement of the data labels after we have verified that they
+ * fall within the plot area.
+ */
+ seriesTypes.pie.prototype.placeDataLabels = function () {
+ each(this.points, function (point) {
+ var dataLabel = point.dataLabel,
+ _pos;
+
+ if (dataLabel && point.visible) {
+ _pos = dataLabel._pos;
+ if (_pos) {
+ dataLabel.attr(dataLabel._attr);
+ dataLabel[dataLabel.moved ? 'animate' : 'attr'](_pos);
+ dataLabel.moved = true;
+ } else if (dataLabel) {
+ dataLabel.attr({ y: -999 });
+ }
+ }
+ });
+ };
+
+ seriesTypes.pie.prototype.alignDataLabel = noop;
+
+ /**
+ * Verify whether the data labels are allowed to draw, or we should run more translation and data
+ * label positioning to keep them inside the plot area. Returns true when data labels are ready
+ * to draw.
+ */
+ seriesTypes.pie.prototype.verifyDataLabelOverflow = function (overflow) {
+
+ var center = this.center,
+ options = this.options,
+ centerOption = options.center,
+ minSize = options.minSize || 80,
+ newSize = minSize,
+ ret;
+
+ // Handle horizontal size and center
+ if (centerOption[0] !== null) { // Fixed center
+ newSize = mathMax(center[2] - mathMax(overflow[1], overflow[3]), minSize);
+
+ } else { // Auto center
+ newSize = mathMax(
+ center[2] - overflow[1] - overflow[3], // horizontal overflow
+ minSize
+ );
+ center[0] += (overflow[3] - overflow[1]) / 2; // horizontal center
+ }
+
+ // Handle vertical size and center
+ if (centerOption[1] !== null) { // Fixed center
+ newSize = mathMax(mathMin(newSize, center[2] - mathMax(overflow[0], overflow[2])), minSize);
+
+ } else { // Auto center
+ newSize = mathMax(
+ mathMin(
+ newSize,
+ center[2] - overflow[0] - overflow[2] // vertical overflow
+ ),
+ minSize
+ );
+ center[1] += (overflow[0] - overflow[2]) / 2; // vertical center
+ }
+
+ // If the size must be decreased, we need to run translate and drawDataLabels again
+ if (newSize < center[2]) {
+ center[2] = newSize;
+ center[3] = Math.min(relativeLength(options.innerSize || 0, newSize), newSize); // #3632
+ this.translate(center);
+ each(this.points, function (point) {
+ if (point.dataLabel) {
+ point.dataLabel._pos = null; // reset
+ }
+ });
+
+ if (this.drawDataLabels) {
+ this.drawDataLabels();
+ }
+ // Else, return true to indicate that the pie and its labels is within the plot area
+ } else {
+ ret = true;
+ }
+ return ret;
+ };
+}
+
+if (seriesTypes.column) {
+
+ /**
+ * Override the basic data label alignment by adjusting for the position of the column
+ */
+ seriesTypes.column.prototype.alignDataLabel = function (point, dataLabel, options, alignTo, isNew) {
+ var inverted = this.chart.inverted,
+ series = point.series,
+ dlBox = point.dlBox || point.shapeArgs, // data label box for alignment
+ below = pick(point.below, point.plotY > pick(this.translatedThreshold, series.yAxis.len)), // point.below is used in range series
+ inside = pick(options.inside, !!this.options.stacking); // draw it inside the box?
+
+ // Align to the column itself, or the top of it
+ if (dlBox) { // Area range uses this method but not alignTo
+ alignTo = merge(dlBox);
+
+ if (inverted) {
+ alignTo = {
+ x: series.yAxis.len - alignTo.y - alignTo.height,
+ y: series.xAxis.len - alignTo.x - alignTo.width,
+ width: alignTo.height,
+ height: alignTo.width
+ };
+ }
+
+ // Compute the alignment box
+ if (!inside) {
+ if (inverted) {
+ alignTo.x += below ? 0 : alignTo.width;
+ alignTo.width = 0;
+ } else {
+ alignTo.y += below ? alignTo.height : 0;
+ alignTo.height = 0;
+ }
+ }
+ }
+
+
+ // When alignment is undefined (typically columns and bars), display the individual
+ // point below or above the point depending on the threshold
+ options.align = pick(
+ options.align,
+ !inverted || inside ? 'center' : below ? 'right' : 'left'
+ );
+ options.verticalAlign = pick(
+ options.verticalAlign,
+ inverted || inside ? 'middle' : below ? 'top' : 'bottom'
+ );
+
+ // Call the parent method
+ Series.prototype.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
+ };
+}
+
+
+
+
+
+/**
+ * TrackerMixin for points and graphs
+ */
+
+var TrackerMixin = Highcharts.TrackerMixin = {
+
+ drawTrackerPoint: function () {
+ var series = this,
+ chart = series.chart,
+ pointer = chart.pointer,
+ cursor = series.options.cursor,
+ css = cursor && { cursor: cursor },
+ onMouseOver = function (e) {
+ var target = e.target,
+ point;
+
+ while (target && !point) {
+ point = target.point;
+ target = target.parentNode;
+ }
+
+ if (point !== UNDEFINED && point !== chart.hoverPoint) { // undefined on graph in scatterchart
+ point.onMouseOver(e);
+ }
+ };
+
+ // Add reference to the point
+ each(series.points, function (point) {
+ if (point.graphic) {
+ point.graphic.element.point = point;
+ }
+ if (point.dataLabel) {
+ point.dataLabel.element.point = point;
+ }
+ });
+
+ // Add the event listeners, we need to do this only once
+ if (!series._hasTracking) {
+ each(series.trackerGroups, function (key) {
+ if (series[key]) { // we don't always have dataLabelsGroup
+ series[key]
+ .addClass(PREFIX + 'tracker')
+ .on('mouseover', onMouseOver)
+ .on('mouseout', function (e) { pointer.onTrackerMouseOut(e); })
+ .css(css);
+ if (hasTouch) {
+ series[key].on('touchstart', onMouseOver);
+ }
+ }
+ });
+ series._hasTracking = true;
+ }
+ },
+
+ /**
+ * Draw the tracker object that sits above all data labels and markers to
+ * track mouse events on the graph or points. For the line type charts
+ * the tracker uses the same graphPath, but with a greater stroke width
+ * for better control.
+ */
+ drawTrackerGraph: function () {
+ var series = this,
+ options = series.options,
+ trackByArea = options.trackByArea,
+ trackerPath = [].concat(trackByArea ? series.areaPath : series.graphPath),
+ trackerPathLength = trackerPath.length,
+ chart = series.chart,
+ pointer = chart.pointer,
+ renderer = chart.renderer,
+ snap = chart.options.tooltip.snap,
+ tracker = series.tracker,
+ cursor = options.cursor,
+ css = cursor && { cursor: cursor },
+ singlePoints = series.singlePoints,
+ singlePoint,
+ i,
+ onMouseOver = function () {
+ if (chart.hoverSeries !== series) {
+ series.onMouseOver();
+ }
+ },
+ /*
+ * Empirical lowest possible opacities for TRACKER_FILL for an element to stay invisible but clickable
+ * IE6: 0.002
+ * IE7: 0.002
+ * IE8: 0.002
+ * IE9: 0.00000000001 (unlimited)
+ * IE10: 0.0001 (exporting only)
+ * FF: 0.00000000001 (unlimited)
+ * Chrome: 0.000001
+ * Safari: 0.000001
+ * Opera: 0.00000000001 (unlimited)
+ */
+ TRACKER_FILL = 'rgba(192,192,192,' + (hasSVG ? 0.0001 : 0.002) + ')';
+
+ // Extend end points. A better way would be to use round linecaps,
+ // but those are not clickable in VML.
+ if (trackerPathLength && !trackByArea) {
+ i = trackerPathLength + 1;
+ while (i--) {
+ if (trackerPath[i] === M) { // extend left side
+ trackerPath.splice(i + 1, 0, trackerPath[i + 1] - snap, trackerPath[i + 2], L);
+ }
+ if ((i && trackerPath[i] === M) || i === trackerPathLength) { // extend right side
+ trackerPath.splice(i, 0, L, trackerPath[i - 2] + snap, trackerPath[i - 1]);
+ }
+ }
+ }
+
+ // handle single points
+ for (i = 0; i < singlePoints.length; i++) {
+ singlePoint = singlePoints[i];
+ trackerPath.push(M, singlePoint.plotX - snap, singlePoint.plotY,
+ L, singlePoint.plotX + snap, singlePoint.plotY);
+ }
+
+ // draw the tracker
+ if (tracker) {
+ tracker.attr({ d: trackerPath });
+ } else { // create
+
+ series.tracker = renderer.path(trackerPath)
+ .attr({
+ 'stroke-linejoin': 'round', // #1225
+ visibility: series.visible ? VISIBLE : HIDDEN,
+ stroke: TRACKER_FILL,
+ fill: trackByArea ? TRACKER_FILL : NONE,
+ 'stroke-width' : options.lineWidth + (trackByArea ? 0 : 2 * snap),
+ zIndex: 2
+ })
+ .add(series.group);
+
+ // The tracker is added to the series group, which is clipped, but is covered
+ // by the marker group. So the marker group also needs to capture events.
+ each([series.tracker, series.markerGroup], function (tracker) {
+ tracker.addClass(PREFIX + 'tracker')
+ .on('mouseover', onMouseOver)
+ .on('mouseout', function (e) { pointer.onTrackerMouseOut(e); })
+ .css(css);
+
+ if (hasTouch) {
+ tracker.on('touchstart', onMouseOver);
+ }
+ });
+ }
+ }
+};
+/* End TrackerMixin */
+
+
+/**
+ * Add tracking event listener to the series group, so the point graphics
+ * themselves act as trackers
+ */
+
+if (seriesTypes.column) {
+ ColumnSeries.prototype.drawTracker = TrackerMixin.drawTrackerPoint;
+}
+
+if (seriesTypes.pie) {
+ seriesTypes.pie.prototype.drawTracker = TrackerMixin.drawTrackerPoint;
+}
+
+if (seriesTypes.scatter) {
+ ScatterSeries.prototype.drawTracker = TrackerMixin.drawTrackerPoint;
+}
+
+/*
+ * Extend Legend for item events
+ */
+extend(Legend.prototype, {
+
+ setItemEvents: function (item, legendItem, useHTML, itemStyle, itemHiddenStyle) {
+ var legend = this;
+ // Set the events on the item group, or in case of useHTML, the item itself (#1249)
+ (useHTML ? legendItem : item.legendGroup).on('mouseover', function () {
+ item.setState(HOVER_STATE);
+ legendItem.css(legend.options.itemHoverStyle);
+ })
+ .on('mouseout', function () {
+ legendItem.css(item.visible ? itemStyle : itemHiddenStyle);
+ item.setState();
+ })
+ .on('click', function (event) {
+ var strLegendItemClick = 'legendItemClick',
+ fnLegendItemClick = function () {
+ if (item.setVisible) {
+ item.setVisible();
+ }
+ };
+
+ // Pass over the click/touch event. #4.
+ event = {
+ browserEvent: event
+ };
+
+ // click the name or symbol
+ if (item.firePointEvent) { // point
+ item.firePointEvent(strLegendItemClick, event, fnLegendItemClick);
+ } else {
+ fireEvent(item, strLegendItemClick, event, fnLegendItemClick);
+ }
+ });
+ },
+
+ createCheckboxForItem: function (item) {
+ var legend = this;
+
+ item.checkbox = createElement('input', {
+ type: 'checkbox',
+ checked: item.selected,
+ defaultChecked: item.selected // required by IE7
+ }, legend.options.itemCheckboxStyle, legend.chart.container);
+
+ addEvent(item.checkbox, 'click', function (event) {
+ var target = event.target;
+ fireEvent(item.series || item, 'checkboxClick', { // #3712
+ checked: target.checked,
+ item: item
+ },
+ function () {
+ item.select();
+ }
+ );
+ });
+ }
+});
+
+/*
+ * Add pointer cursor to legend itemstyle in defaultOptions
+ */
+defaultOptions.legend.itemStyle.cursor = 'pointer';
+
+
+/*
+ * Extend the Chart object with interaction
+ */
+
+extend(Chart.prototype, {
+ /**
+ * Display the zoom button
+ */
+ showResetZoom: function () {
+ var chart = this,
+ lang = defaultOptions.lang,
+ btnOptions = chart.options.chart.resetZoomButton,
+ theme = btnOptions.theme,
+ states = theme.states,
+ alignTo = btnOptions.relativeTo === 'chart' ? null : 'plotBox';
+
+ this.resetZoomButton = chart.renderer.button(lang.resetZoom, null, null, function () { chart.zoomOut(); }, theme, states && states.hover)
+ .attr({
+ align: btnOptions.position.align,
+ title: lang.resetZoomTitle
+ })
+ .add()
+ .align(btnOptions.position, false, alignTo);
+
+ },
+
+ /**
+ * Zoom out to 1:1
+ */
+ zoomOut: function () {
+ var chart = this;
+ fireEvent(chart, 'selection', { resetSelection: true }, function () {
+ chart.zoom();
+ });
+ },
+
+ /**
+ * Zoom into a given portion of the chart given by axis coordinates
+ * @param {Object} event
+ */
+ zoom: function (event) {
+ var chart = this,
+ hasZoomed,
+ pointer = chart.pointer,
+ displayButton = false,
+ resetZoomButton;
+
+ // If zoom is called with no arguments, reset the axes
+ if (!event || event.resetSelection) {
+ each(chart.axes, function (axis) {
+ hasZoomed = axis.zoom();
+ });
+ } else { // else, zoom in on all axes
+ each(event.xAxis.concat(event.yAxis), function (axisData) {
+ var axis = axisData.axis,
+ isXAxis = axis.isXAxis;
+
+ // don't zoom more than minRange
+ if (pointer[isXAxis ? 'zoomX' : 'zoomY'] || pointer[isXAxis ? 'pinchX' : 'pinchY']) {
+ hasZoomed = axis.zoom(axisData.min, axisData.max);
+ if (axis.displayBtn) {
+ displayButton = true;
+ }
+ }
+ });
+ }
+
+ // Show or hide the Reset zoom button
+ resetZoomButton = chart.resetZoomButton;
+ if (displayButton && !resetZoomButton) {
+ chart.showResetZoom();
+ } else if (!displayButton && isObject(resetZoomButton)) {
+ chart.resetZoomButton = resetZoomButton.destroy();
+ }
+
+
+ // Redraw
+ if (hasZoomed) {
+ chart.redraw(
+ pick(chart.options.chart.animation, event && event.animation, chart.pointCount < 100) // animation
+ );
+ }
+ },
+
+ /**
+ * Pan the chart by dragging the mouse across the pane. This function is called
+ * on mouse move, and the distance to pan is computed from chartX compared to
+ * the first chartX position in the dragging operation.
+ */
+ pan: function (e, panning) {
+
+ var chart = this,
+ hoverPoints = chart.hoverPoints,
+ doRedraw;
+
+ // remove active points for shared tooltip
+ if (hoverPoints) {
+ each(hoverPoints, function (point) {
+ point.setState();
+ });
+ }
+
+ each(panning === 'xy' ? [1, 0] : [1], function (isX) { // xy is used in maps
+ var mousePos = e[isX ? 'chartX' : 'chartY'],
+ axis = chart[isX ? 'xAxis' : 'yAxis'][0],
+ startPos = chart[isX ? 'mouseDownX' : 'mouseDownY'],
+ halfPointRange = (axis.pointRange || 0) / 2,
+ extremes = axis.getExtremes(),
+ newMin = axis.toValue(startPos - mousePos, true) + halfPointRange,
+ newMax = axis.toValue(startPos + chart[isX ? 'plotWidth' : 'plotHeight'] - mousePos, true) - halfPointRange,
+ goingLeft = startPos > mousePos; // #3613
+
+ if (axis.series.length &&
+ (goingLeft || newMin > mathMin(extremes.dataMin, extremes.min)) &&
+ (!goingLeft || newMax < mathMax(extremes.dataMax, extremes.max))) {
+ axis.setExtremes(newMin, newMax, false, false, { trigger: 'pan' });
+ doRedraw = true;
+ }
+
+ chart[isX ? 'mouseDownX' : 'mouseDownY'] = mousePos; // set new reference for next run
+ });
+
+ if (doRedraw) {
+ chart.redraw(false);
+ }
+ css(chart.container, { cursor: 'move' });
+ }
+});
+
+/*
+ * Extend the Point object with interaction
+ */
+extend(Point.prototype, {
+ /**
+ * Toggle the selection status of a point
+ * @param {Boolean} selected Whether to select or unselect the point.
+ * @param {Boolean} accumulate Whether to add to the previous selection. By default,
+ * this happens if the control key (Cmd on Mac) was pressed during clicking.
+ */
+ select: function (selected, accumulate) {
+ var point = this,
+ series = point.series,
+ chart = series.chart;
+
+ selected = pick(selected, !point.selected);
+
+ // fire the event with the defalut handler
+ point.firePointEvent(selected ? 'select' : 'unselect', { accumulate: accumulate }, function () {
+ point.selected = point.options.selected = selected;
+ series.options.data[inArray(point, series.data)] = point.options;
+
+ point.setState(selected && SELECT_STATE);
+
+ // unselect all other points unless Ctrl or Cmd + click
+ if (!accumulate) {
+ each(chart.getSelectedPoints(), function (loopPoint) {
+ if (loopPoint.selected && loopPoint !== point) {
+ loopPoint.selected = loopPoint.options.selected = false;
+ series.options.data[inArray(loopPoint, series.data)] = loopPoint.options;
+ loopPoint.setState(NORMAL_STATE);
+ loopPoint.firePointEvent('unselect');
+ }
+ });
+ }
+ });
+ },
+
+ /**
+ * Runs on mouse over the point
+ *
+ * @param {Object} e The event arguments
+ * @param {Boolean} byProximity Falsy for kd points that are closest to the mouse, or to
+ * actually hovered points. True for other points in shared tooltip.
+ */
+ onMouseOver: function (e, byProximity) {
+ var point = this,
+ series = point.series,
+ chart = series.chart,
+ tooltip = chart.tooltip,
+ hoverPoint = chart.hoverPoint;
+
+ if (chart.hoverSeries !== series) {
+ series.onMouseOver();
+ }
+
+ // set normal state to previous series
+ if (hoverPoint && hoverPoint !== point) {
+ hoverPoint.onMouseOut();
+ }
+
+ if (point.series) { // It may have been destroyed, #4130
+
+ // trigger the event
+ point.firePointEvent('mouseOver');
+
+ // update the tooltip
+ if (tooltip && (!tooltip.shared || series.noSharedTooltip)) {
+ tooltip.refresh(point, e);
+ }
+
+ // hover this
+ point.setState(HOVER_STATE);
+ if (!byProximity) {
+ chart.hoverPoint = point;
+ }
+ }
+ },
+
+ /**
+ * Runs on mouse out from the point
+ */
+ onMouseOut: function () {
+ var chart = this.series.chart,
+ hoverPoints = chart.hoverPoints;
+
+ this.firePointEvent('mouseOut');
+
+ if (!hoverPoints || inArray(this, hoverPoints) === -1) { // #887, #2240
+ this.setState();
+ chart.hoverPoint = null;
+ }
+ },
+
+ /**
+ * Import events from the series' and point's options. Only do it on
+ * demand, to save processing time on hovering.
+ */
+ importEvents: function () {
+ if (!this.hasImportedEvents) {
+ var point = this,
+ options = merge(point.series.options.point, point.options),
+ events = options.events,
+ eventType;
+
+ point.events = events;
+
+ for (eventType in events) {
+ addEvent(point, eventType, events[eventType]);
+ }
+ this.hasImportedEvents = true;
+
+ }
+ },
+
+ /**
+ * Set the point's state
+ * @param {String} state
+ */
+ setState: function (state, move) {
+ var point = this,
+ plotX = mathFloor(point.plotX), // #4586
+ plotY = point.plotY,
+ series = point.series,
+ stateOptions = series.options.states,
+ markerOptions = defaultPlotOptions[series.type].marker && series.options.marker,
+ normalDisabled = markerOptions && !markerOptions.enabled,
+ markerStateOptions = markerOptions && markerOptions.states[state],
+ stateDisabled = markerStateOptions && markerStateOptions.enabled === false,
+ stateMarkerGraphic = series.stateMarkerGraphic,
+ pointMarker = point.marker || {},
+ chart = series.chart,
+ radius,
+ halo = series.halo,
+ haloOptions,
+ newSymbol,
+ pointAttr;
+
+ state = state || NORMAL_STATE; // empty string
+ pointAttr = point.pointAttr[state] || series.pointAttr[state];
+
+ if (
+ // already has this state
+ (state === point.state && !move) ||
+ // selected points don't respond to hover
+ (point.selected && state !== SELECT_STATE) ||
+ // series' state options is disabled
+ (stateOptions[state] && stateOptions[state].enabled === false) ||
+ // general point marker's state options is disabled
+ (state && (stateDisabled || (normalDisabled && markerStateOptions.enabled === false))) ||
+ // individual point marker's state options is disabled
+ (state && pointMarker.states && pointMarker.states[state] && pointMarker.states[state].enabled === false) // #1610
+
+ ) {
+ return;
+ }
+
+ // apply hover styles to the existing point
+ if (point.graphic) {
+ radius = markerOptions && point.graphic.symbolName && pointAttr.r;
+ point.graphic.attr(merge(
+ pointAttr,
+ radius ? { // new symbol attributes (#507, #612)
+ x: plotX - radius,
+ y: plotY - radius,
+ width: 2 * radius,
+ height: 2 * radius
+ } : {}
+ ));
+
+ // Zooming in from a range with no markers to a range with markers
+ if (stateMarkerGraphic) {
+ stateMarkerGraphic.hide();
+ }
+ } else {
+ // if a graphic is not applied to each point in the normal state, create a shared
+ // graphic for the hover state
+ if (state && markerStateOptions) {
+ radius = markerStateOptions.radius;
+ newSymbol = pointMarker.symbol || series.symbol;
+
+ // If the point has another symbol than the previous one, throw away the
+ // state marker graphic and force a new one (#1459)
+ if (stateMarkerGraphic && stateMarkerGraphic.currentSymbol !== newSymbol) {
+ stateMarkerGraphic = stateMarkerGraphic.destroy();
+ }
+
+ // Add a new state marker graphic
+ if (!stateMarkerGraphic) {
+ if (newSymbol) {
+ series.stateMarkerGraphic = stateMarkerGraphic = chart.renderer.symbol(
+ newSymbol,
+ plotX - radius,
+ plotY - radius,
+ 2 * radius,
+ 2 * radius
+ )
+ .attr(pointAttr)
+ .add(series.markerGroup);
+ stateMarkerGraphic.currentSymbol = newSymbol;
+ }
+
+ // Move the existing graphic
+ } else {
+ stateMarkerGraphic[move ? 'animate' : 'attr']({ // #1054
+ x: plotX - radius,
+ y: plotY - radius
+ });
+ }
+ }
+
+ if (stateMarkerGraphic) {
+ stateMarkerGraphic[state && chart.isInsidePlot(plotX, plotY, chart.inverted) ? 'show' : 'hide'](); // #2450
+ stateMarkerGraphic.element.point = point; // #4310
+ }
+ }
+
+ // Show me your halo
+ haloOptions = stateOptions[state] && stateOptions[state].halo;
+ if (haloOptions && haloOptions.size) {
+ if (!halo) {
+ series.halo = halo = chart.renderer.path()
+ .add(chart.seriesGroup);
+ }
+ halo.attr(extend({
+ fill: Color(point.color || series.color).setOpacity(haloOptions.opacity).get()
+ }, haloOptions.attributes))[move ? 'animate' : 'attr']({
+ d: point.haloPath(haloOptions.size)
+ });
+ } else if (halo) {
+ halo.attr({ d: [] });
+ }
+
+ point.state = state;
+ },
+
+ haloPath: function (size) {
+ var series = this.series,
+ chart = series.chart,
+ plotBox = series.getPlotBox(),
+ inverted = chart.inverted;
+
+ return chart.renderer.symbols.circle(
+ plotBox.translateX + (inverted ? series.yAxis.len - this.plotY : this.plotX) - size,
+ plotBox.translateY + (inverted ? series.xAxis.len - this.plotX : this.plotY) - size,
+ size * 2,
+ size * 2
+ );
+ }
+});
+
+/*
+ * Extend the Series object with interaction
+ */
+
+extend(Series.prototype, {
+ /**
+ * Series mouse over handler
+ */
+ onMouseOver: function () {
+ var series = this,
+ chart = series.chart,
+ hoverSeries = chart.hoverSeries;
+
+ // set normal state to previous series
+ if (hoverSeries && hoverSeries !== series) {
+ hoverSeries.onMouseOut();
+ }
+
+ // trigger the event, but to save processing time,
+ // only if defined
+ if (series.options.events.mouseOver) {
+ fireEvent(series, 'mouseOver');
+ }
+
+ // hover this
+ series.setState(HOVER_STATE);
+ chart.hoverSeries = series;
+ },
+
+ /**
+ * Series mouse out handler
+ */
+ onMouseOut: function () {
+ // trigger the event only if listeners exist
+ var series = this,
+ options = series.options,
+ chart = series.chart,
+ tooltip = chart.tooltip,
+ hoverPoint = chart.hoverPoint;
+
+ chart.hoverSeries = null; // #182, set to null before the mouseOut event fires
+
+ // trigger mouse out on the point, which must be in this series
+ if (hoverPoint) {
+ hoverPoint.onMouseOut();
+ }
+
+ // fire the mouse out event
+ if (series && options.events.mouseOut) {
+ fireEvent(series, 'mouseOut');
+ }
+
+
+ // hide the tooltip
+ if (tooltip && !options.stickyTracking && (!tooltip.shared || series.noSharedTooltip)) {
+ tooltip.hide();
+ }
+
+ // set normal state
+ series.setState();
+ },
+
+ /**
+ * Set the state of the graph
+ */
+ setState: function (state) {
+ var series = this,
+ options = series.options,
+ graph = series.graph,
+ stateOptions = options.states,
+ lineWidth = options.lineWidth,
+ attribs,
+ i = 0;
+
+ state = state || NORMAL_STATE;
+
+ if (series.state !== state) {
+ series.state = state;
+
+ if (stateOptions[state] && stateOptions[state].enabled === false) {
+ return;
+ }
+
+ if (state) {
+ lineWidth = stateOptions[state].lineWidth || lineWidth + (stateOptions[state].lineWidthPlus || 0); // #4035
+ }
+
+ if (graph && !graph.dashstyle) { // hover is turned off for dashed lines in VML
+ attribs = {
+ 'stroke-width': lineWidth
+ };
+ // use attr because animate will cause any other animation on the graph to stop
+ graph.attr(attribs);
+ while (series['zoneGraph' + i]) {
+ series['zoneGraph' + i].attr(attribs);
+ i = i + 1;
+ }
+ }
+ }
+ },
+
+ /**
+ * Set the visibility of the graph
+ *
+ * @param vis {Boolean} True to show the series, false to hide. If UNDEFINED,
+ * the visibility is toggled.
+ */
+ setVisible: function (vis, redraw) {
+ var series = this,
+ chart = series.chart,
+ legendItem = series.legendItem,
+ showOrHide,
+ ignoreHiddenSeries = chart.options.chart.ignoreHiddenSeries,
+ oldVisibility = series.visible;
+
+ // if called without an argument, toggle visibility
+ series.visible = vis = series.userOptions.visible = vis === UNDEFINED ? !oldVisibility : vis;
+ showOrHide = vis ? 'show' : 'hide';
+
+ // show or hide elements
+ each(['group', 'dataLabelsGroup', 'markerGroup', 'tracker'], function (key) {
+ if (series[key]) {
+ series[key][showOrHide]();
+ }
+ });
+
+
+ // hide tooltip (#1361)
+ if (chart.hoverSeries === series || (chart.hoverPoint && chart.hoverPoint.series) === series) {
+ series.onMouseOut();
+ }
+
+
+ if (legendItem) {
+ chart.legend.colorizeItem(series, vis);
+ }
+
+
+ // rescale or adapt to resized chart
+ series.isDirty = true;
+ // in a stack, all other series are affected
+ if (series.options.stacking) {
+ each(chart.series, function (otherSeries) {
+ if (otherSeries.options.stacking && otherSeries.visible) {
+ otherSeries.isDirty = true;
+ }
+ });
+ }
+
+ // show or hide linked series
+ each(series.linkedSeries, function (otherSeries) {
+ otherSeries.setVisible(vis, false);
+ });
+
+ if (ignoreHiddenSeries) {
+ chart.isDirtyBox = true;
+ }
+ if (redraw !== false) {
+ chart.redraw();
+ }
+
+ fireEvent(series, showOrHide);
+ },
+
+ /**
+ * Show the graph
+ */
+ show: function () {
+ this.setVisible(true);
+ },
+
+ /**
+ * Hide the graph
+ */
+ hide: function () {
+ this.setVisible(false);
+ },
+
+
+ /**
+ * Set the selected state of the graph
+ *
+ * @param selected {Boolean} True to select the series, false to unselect. If
+ * UNDEFINED, the selection state is toggled.
+ */
+ select: function (selected) {
+ var series = this;
+ // if called without an argument, toggle
+ series.selected = selected = (selected === UNDEFINED) ? !series.selected : selected;
+
+ if (series.checkbox) {
+ series.checkbox.checked = selected;
+ }
+
+ fireEvent(series, selected ? 'select' : 'unselect');
+ },
+
+ drawTracker: TrackerMixin.drawTrackerGraph
+});
+
+/* ****************************************************************************
+ * Start ordinal axis logic *
+ *****************************************************************************/
+
+
+wrap(Series.prototype, 'init', function (proceed) {
+ var series = this,
+ xAxis;
+
+ // call the original function
+ proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+
+ xAxis = series.xAxis;
+
+ // Destroy the extended ordinal index on updated data
+ if (xAxis && xAxis.options.ordinal) {
+ addEvent(series, 'updatedData', function () {
+ delete xAxis.ordinalIndex;
+ });
+ }
+});
+
+/**
+ * In an ordinal axis, there might be areas with dense consentrations of points, then large
+ * gaps between some. Creating equally distributed ticks over this entire range
+ * may lead to a huge number of ticks that will later be removed. So instead, break the
+ * positions up in segments, find the tick positions for each segment then concatenize them.
+ * This method is used from both data grouping logic and X axis tick position logic.
+ */
+wrap(Axis.prototype, 'getTimeTicks', function (proceed, normalizedInterval, min, max, startOfWeek, positions, closestDistance, findHigherRanks) {
+
+ var start = 0,
+ end = 0,
+ segmentPositions,
+ higherRanks = {},
+ hasCrossedHigherRank,
+ info,
+ posLength,
+ outsideMax,
+ groupPositions = [],
+ lastGroupPosition = -Number.MAX_VALUE,
+ tickPixelIntervalOption = this.options.tickPixelInterval;
+
+ // The positions are not always defined, for example for ordinal positions when data
+ // has regular interval (#1557, #2090)
+ if ((!this.options.ordinal && !this.options.breaks) || !positions || positions.length < 3 || min === UNDEFINED) {
+ return proceed.call(this, normalizedInterval, min, max, startOfWeek);
+ }
+
+ // Analyze the positions array to split it into segments on gaps larger than 5 times
+ // the closest distance. The closest distance is already found at this point, so
+ // we reuse that instead of computing it again.
+ posLength = positions.length;
+
+ for (; end < posLength; end++) {
+
+ outsideMax = end && positions[end - 1] > max;
+
+ if (positions[end] < min) { // Set the last position before min
+ start = end;
+ }
+
+ if (end === posLength - 1 || positions[end + 1] - positions[end] > closestDistance * 5 || outsideMax) {
+
+ // For each segment, calculate the tick positions from the getTimeTicks utility
+ // function. The interval will be the same regardless of how long the segment is.
+ if (positions[end] > lastGroupPosition) { // #1475
+
+ segmentPositions = proceed.call(this, normalizedInterval, positions[start], positions[end], startOfWeek);
+
+ // Prevent duplicate groups, for example for multiple segments within one larger time frame (#1475)
+ while (segmentPositions.length && segmentPositions[0] <= lastGroupPosition) {
+ segmentPositions.shift();
+ }
+ if (segmentPositions.length) {
+ lastGroupPosition = segmentPositions[segmentPositions.length - 1];
+ }
+
+ groupPositions = groupPositions.concat(segmentPositions);
+ }
+ // Set start of next segment
+ start = end + 1;
+ }
+
+ if (outsideMax) {
+ break;
+ }
+ }
+
+ // Get the grouping info from the last of the segments. The info is the same for
+ // all segments.
+ info = segmentPositions.info;
+
+ // Optionally identify ticks with higher rank, for example when the ticks
+ // have crossed midnight.
+ if (findHigherRanks && info.unitRange <= timeUnits.hour) {
+ end = groupPositions.length - 1;
+
+ // Compare points two by two
+ for (start = 1; start < end; start++) {
+ if (dateFormat('%d', groupPositions[start]) !== dateFormat('%d', groupPositions[start - 1])) {
+ higherRanks[groupPositions[start]] = 'day';
+ hasCrossedHigherRank = true;
+ }
+ }
+
+ // If the complete array has crossed midnight, we want to mark the first
+ // positions also as higher rank
+ if (hasCrossedHigherRank) {
+ higherRanks[groupPositions[0]] = 'day';
+ }
+ info.higherRanks = higherRanks;
+ }
+
+ // Save the info
+ groupPositions.info = info;
+
+
+
+ // Don't show ticks within a gap in the ordinal axis, where the space between
+ // two points is greater than a portion of the tick pixel interval
+ if (findHigherRanks && defined(tickPixelIntervalOption)) { // check for squashed ticks
+
+ var length = groupPositions.length,
+ i = length,
+ itemToRemove,
+ translated,
+ translatedArr = [],
+ lastTranslated,
+ medianDistance,
+ distance,
+ distances = [];
+
+ // Find median pixel distance in order to keep a reasonably even distance between
+ // ticks (#748)
+ while (i--) {
+ translated = this.translate(groupPositions[i]);
+ if (lastTranslated) {
+ distances[i] = lastTranslated - translated;
+ }
+ translatedArr[i] = lastTranslated = translated;
+ }
+ distances.sort();
+ medianDistance = distances[mathFloor(distances.length / 2)];
+ if (medianDistance < tickPixelIntervalOption * 0.6) {
+ medianDistance = null;
+ }
+
+ // Now loop over again and remove ticks where needed
+ i = groupPositions[length - 1] > max ? length - 1 : length; // #817
+ lastTranslated = undefined;
+ while (i--) {
+ translated = translatedArr[i];
+ distance = lastTranslated - translated;
+
+ // Remove ticks that are closer than 0.6 times the pixel interval from the one to the right,
+ // but not if it is close to the median distance (#748).
+ if (lastTranslated && distance < tickPixelIntervalOption * 0.8 &&
+ (medianDistance === null || distance < medianDistance * 0.8)) {
+
+ // Is this a higher ranked position with a normal position to the right?
+ if (higherRanks[groupPositions[i]] && !higherRanks[groupPositions[i + 1]]) {
+
+ // Yes: remove the lower ranked neighbour to the right
+ itemToRemove = i + 1;
+ lastTranslated = translated; // #709
+
+ } else {
+
+ // No: remove this one
+ itemToRemove = i;
+ }
+
+ groupPositions.splice(itemToRemove, 1);
+
+ } else {
+ lastTranslated = translated;
+ }
+ }
+ }
+ return groupPositions;
+});
+
+// Extend the Axis prototype
+extend(Axis.prototype, {
+
+ /**
+ * Calculate the ordinal positions before tick positions are calculated.
+ */
+ beforeSetTickPositions: function () {
+ var axis = this,
+ len,
+ ordinalPositions = [],
+ useOrdinal = false,
+ dist,
+ extremes = axis.getExtremes(),
+ min = extremes.min,
+ max = extremes.max,
+ minIndex,
+ maxIndex,
+ slope,
+ hasBreaks = axis.isXAxis && !!axis.options.breaks,
+ isOrdinal = axis.options.ordinal,
+ i;
+
+ // apply the ordinal logic
+ if (isOrdinal || hasBreaks) { // #4167 YAxis is never ordinal ?
+
+ each(axis.series, function (series, i) {
+
+ if (series.visible !== false && (series.takeOrdinalPosition !== false || hasBreaks)) {
+
+ // concatenate the processed X data into the existing positions, or the empty array
+ ordinalPositions = ordinalPositions.concat(series.processedXData);
+ len = ordinalPositions.length;
+
+ // remove duplicates (#1588)
+ ordinalPositions.sort(function (a, b) {
+ return a - b; // without a custom function it is sorted as strings
+ });
+
+ if (len) {
+ i = len - 1;
+ while (i--) {
+ if (ordinalPositions[i] === ordinalPositions[i + 1]) {
+ ordinalPositions.splice(i, 1);
+ }
+ }
+ }
+ }
+
+ });
+
+ // cache the length
+ len = ordinalPositions.length;
+
+ // Check if we really need the overhead of mapping axis data against the ordinal positions.
+ // If the series consist of evenly spaced data any way, we don't need any ordinal logic.
+ if (len > 2) { // two points have equal distance by default
+ dist = ordinalPositions[1] - ordinalPositions[0];
+ i = len - 1;
+ while (i-- && !useOrdinal) {
+ if (ordinalPositions[i + 1] - ordinalPositions[i] !== dist) {
+ useOrdinal = true;
+ }
+ }
+
+ // When zooming in on a week, prevent axis padding for weekends even though the data within
+ // the week is evenly spaced.
+ if (!axis.options.keepOrdinalPadding && (ordinalPositions[0] - min > dist || max - ordinalPositions[ordinalPositions.length - 1] > dist)) {
+ useOrdinal = true;
+ }
+ }
+
+ // Record the slope and offset to compute the linear values from the array index.
+ // Since the ordinal positions may exceed the current range, get the start and
+ // end positions within it (#719, #665b)
+ if (useOrdinal) {
+
+ // Register
+ axis.ordinalPositions = ordinalPositions;
+
+ // This relies on the ordinalPositions being set. Use mathMax and mathMin to prevent
+ // padding on either sides of the data.
+ minIndex = axis.val2lin(mathMax(min, ordinalPositions[0]), true);
+ maxIndex = mathMax(axis.val2lin(mathMin(max, ordinalPositions[ordinalPositions.length - 1]), true), 1); // #3339
+
+ // Set the slope and offset of the values compared to the indices in the ordinal positions
+ axis.ordinalSlope = slope = (max - min) / (maxIndex - minIndex);
+ axis.ordinalOffset = min - (minIndex * slope);
+
+ } else {
+ axis.ordinalPositions = axis.ordinalSlope = axis.ordinalOffset = UNDEFINED;
+ }
+ }
+ axis.doPostTranslate = (isOrdinal && useOrdinal) || hasBreaks; // #3818, #4196
+ axis.groupIntervalFactor = null; // reset for next run
+ },
+ /**
+ * Translate from a linear axis value to the corresponding ordinal axis position. If there
+ * are no gaps in the ordinal axis this will be the same. The translated value is the value
+ * that the point would have if the axis were linear, using the same min and max.
+ *
+ * @param Number val The axis value
+ * @param Boolean toIndex Whether to return the index in the ordinalPositions or the new value
+ */
+ val2lin: function (val, toIndex) {
+ var axis = this,
+ ordinalPositions = axis.ordinalPositions;
+
+ if (!ordinalPositions) {
+ return val;
+
+ } else {
+
+ var ordinalLength = ordinalPositions.length,
+ i,
+ distance,
+ ordinalIndex;
+
+ // first look for an exact match in the ordinalpositions array
+ i = ordinalLength;
+ while (i--) {
+ if (ordinalPositions[i] === val) {
+ ordinalIndex = i;
+ break;
+ }
+ }
+
+ // if that failed, find the intermediate position between the two nearest values
+ i = ordinalLength - 1;
+ while (i--) {
+ if (val > ordinalPositions[i] || i === 0) { // interpolate
+ distance = (val - ordinalPositions[i]) / (ordinalPositions[i + 1] - ordinalPositions[i]); // something between 0 and 1
+ ordinalIndex = i + distance;
+ break;
+ }
+ }
+ return toIndex ?
+ ordinalIndex :
+ axis.ordinalSlope * (ordinalIndex || 0) + axis.ordinalOffset;
+ }
+ },
+ /**
+ * Translate from linear (internal) to axis value
+ *
+ * @param Number val The linear abstracted value
+ * @param Boolean fromIndex Translate from an index in the ordinal positions rather than a value
+ */
+ lin2val: function (val, fromIndex) {
+ var axis = this,
+ ordinalPositions = axis.ordinalPositions;
+
+ if (!ordinalPositions) { // the visible range contains only equally spaced values
+ return val;
+
+ } else {
+
+ var ordinalSlope = axis.ordinalSlope,
+ ordinalOffset = axis.ordinalOffset,
+ i = ordinalPositions.length - 1,
+ linearEquivalentLeft,
+ linearEquivalentRight,
+ distance;
+
+
+ // Handle the case where we translate from the index directly, used only
+ // when panning an ordinal axis
+ if (fromIndex) {
+
+ if (val < 0) { // out of range, in effect panning to the left
+ val = ordinalPositions[0];
+ } else if (val > i) { // out of range, panning to the right
+ val = ordinalPositions[i];
+ } else { // split it up
+ i = mathFloor(val);
+ distance = val - i; // the decimal
+ }
+
+ // Loop down along the ordinal positions. When the linear equivalent of i matches
+ // an ordinal position, interpolate between the left and right values.
+ } else {
+ while (i--) {
+ linearEquivalentLeft = (ordinalSlope * i) + ordinalOffset;
+ if (val >= linearEquivalentLeft) {
+ linearEquivalentRight = (ordinalSlope * (i + 1)) + ordinalOffset;
+ distance = (val - linearEquivalentLeft) / (linearEquivalentRight - linearEquivalentLeft); // something between 0 and 1
+ break;
+ }
+ }
+ }
+
+ // If the index is within the range of the ordinal positions, return the associated
+ // or interpolated value. If not, just return the value
+ return distance !== UNDEFINED && ordinalPositions[i] !== UNDEFINED ?
+ ordinalPositions[i] + (distance ? distance * (ordinalPositions[i + 1] - ordinalPositions[i]) : 0) :
+ val;
+ }
+ },
+ /**
+ * Get the ordinal positions for the entire data set. This is necessary in chart panning
+ * because we need to find out what points or data groups are available outside the
+ * visible range. When a panning operation starts, if an index for the given grouping
+ * does not exists, it is created and cached. This index is deleted on updated data, so
+ * it will be regenerated the next time a panning operation starts.
+ */
+ getExtendedPositions: function () {
+ var axis = this,
+ chart = axis.chart,
+ grouping = axis.series[0].currentDataGrouping,
+ ordinalIndex = axis.ordinalIndex,
+ key = grouping ? grouping.count + grouping.unitName : 'raw',
+ extremes = axis.getExtremes(),
+ fakeAxis,
+ fakeSeries;
+
+ // If this is the first time, or the ordinal index is deleted by updatedData,
+ // create it.
+ if (!ordinalIndex) {
+ ordinalIndex = axis.ordinalIndex = {};
+ }
+
+
+ if (!ordinalIndex[key]) {
+
+ // Create a fake axis object where the extended ordinal positions are emulated
+ fakeAxis = {
+ series: [],
+ getExtremes: function () {
+ return {
+ min: extremes.dataMin,
+ max: extremes.dataMax
+ };
+ },
+ options: {
+ ordinal: true
+ },
+ val2lin: Axis.prototype.val2lin // #2590
+ };
+
+ // Add the fake series to hold the full data, then apply processData to it
+ each(axis.series, function (series) {
+ fakeSeries = {
+ xAxis: fakeAxis,
+ xData: series.xData,
+ chart: chart,
+ destroyGroupedData: noop
+ };
+ fakeSeries.options = {
+ dataGrouping : grouping ? {
+ enabled: true,
+ forced: true,
+ approximation: 'open', // doesn't matter which, use the fastest
+ units: [[grouping.unitName, [grouping.count]]]
+ } : {
+ enabled: false
+ }
+ };
+ series.processData.apply(fakeSeries);
+
+ fakeAxis.series.push(fakeSeries);
+ });
+
+ // Run beforeSetTickPositions to compute the ordinalPositions
+ axis.beforeSetTickPositions.apply(fakeAxis);
+
+ // Cache it
+ ordinalIndex[key] = fakeAxis.ordinalPositions;
+ }
+ return ordinalIndex[key];
+ },
+
+ /**
+ * Find the factor to estimate how wide the plot area would have been if ordinal
+ * gaps were included. This value is used to compute an imagined plot width in order
+ * to establish the data grouping interval.
+ *
+ * A real world case is the intraday-candlestick
+ * example. Without this logic, it would show the correct data grouping when viewing
+ * a range within each day, but once moving the range to include the gap between two
+ * days, the interval would include the cut-away night hours and the data grouping
+ * would be wrong. So the below method tries to compensate by identifying the most
+ * common point interval, in this case days.
+ *
+ * An opposite case is presented in issue #718. We have a long array of daily data,
+ * then one point is appended one hour after the last point. We expect the data grouping
+ * not to change.
+ *
+ * In the future, if we find cases where this estimation doesn't work optimally, we
+ * might need to add a second pass to the data grouping logic, where we do another run
+ * with a greater interval if the number of data groups is more than a certain fraction
+ * of the desired group count.
+ */
+ getGroupIntervalFactor: function (xMin, xMax, series) {
+ var i = 0,
+ processedXData = series.processedXData,
+ len = processedXData.length,
+ distances = [],
+ median,
+ groupIntervalFactor = this.groupIntervalFactor;
+
+ // Only do this computation for the first series, let the other inherit it (#2416)
+ if (!groupIntervalFactor) {
+
+ // Register all the distances in an array
+ for (; i < len - 1; i++) {
+ distances[i] = processedXData[i + 1] - processedXData[i];
+ }
+
+ // Sort them and find the median
+ distances.sort(function (a, b) {
+ return a - b;
+ });
+ median = distances[mathFloor(len / 2)];
+
+ // Compensate for series that don't extend through the entire axis extent. #1675.
+ xMin = mathMax(xMin, processedXData[0]);
+ xMax = mathMin(xMax, processedXData[len - 1]);
+
+ this.groupIntervalFactor = groupIntervalFactor = (len * median) / (xMax - xMin);
+ }
+
+ // Return the factor needed for data grouping
+ return groupIntervalFactor;
+ },
+
+ /**
+ * Make the tick intervals closer because the ordinal gaps make the ticks spread out or cluster
+ */
+ postProcessTickInterval: function (tickInterval) {
+ // TODO: http://jsfiddle.net/highcharts/FQm4E/1/
+ // This is a case where this algorithm doesn't work optimally. In this case, the
+ // tick labels are spread out per week, but all the gaps reside within weeks. So
+ // we have a situation where the labels are courser than the ordinal gaps, and
+ // thus the tick interval should not be altered
+ var ordinalSlope = this.ordinalSlope;
+
+
+ if (ordinalSlope) {
+ if (!this.options.breaks) {
+ return tickInterval / (ordinalSlope / this.closestPointRange);
+ } else {
+ return this.closestPointRange;
+ }
+ } else {
+ return tickInterval;
+ }
+ }
+});
+
+// Extending the Chart.pan method for ordinal axes
+wrap(Chart.prototype, 'pan', function (proceed, e) {
+ var chart = this,
+ xAxis = chart.xAxis[0],
+ chartX = e.chartX,
+ runBase = false;
+
+ if (xAxis.options.ordinal && xAxis.series.length) {
+
+ var mouseDownX = chart.mouseDownX,
+ extremes = xAxis.getExtremes(),
+ dataMax = extremes.dataMax,
+ min = extremes.min,
+ max = extremes.max,
+ trimmedRange,
+ hoverPoints = chart.hoverPoints,
+ closestPointRange = xAxis.closestPointRange,
+ pointPixelWidth = xAxis.translationSlope * (xAxis.ordinalSlope || closestPointRange),
+ movedUnits = (mouseDownX - chartX) / pointPixelWidth, // how many ordinal units did we move?
+ extendedAxis = { ordinalPositions: xAxis.getExtendedPositions() }, // get index of all the chart's points
+ ordinalPositions,
+ searchAxisLeft,
+ lin2val = xAxis.lin2val,
+ val2lin = xAxis.val2lin,
+ searchAxisRight;
+
+ if (!extendedAxis.ordinalPositions) { // we have an ordinal axis, but the data is equally spaced
+ runBase = true;
+
+ } else if (mathAbs(movedUnits) > 1) {
+
+ // Remove active points for shared tooltip
+ if (hoverPoints) {
+ each(hoverPoints, function (point) {
+ point.setState();
+ });
+ }
+
+ if (movedUnits < 0) {
+ searchAxisLeft = extendedAxis;
+ searchAxisRight = xAxis.ordinalPositions ? xAxis : extendedAxis;
+ } else {
+ searchAxisLeft = xAxis.ordinalPositions ? xAxis : extendedAxis;
+ searchAxisRight = extendedAxis;
+ }
+
+ // In grouped data series, the last ordinal position represents the grouped data, which is
+ // to the left of the real data max. If we don't compensate for this, we will be allowed
+ // to pan grouped data series passed the right of the plot area.
+ ordinalPositions = searchAxisRight.ordinalPositions;
+ if (dataMax > ordinalPositions[ordinalPositions.length - 1]) {
+ ordinalPositions.push(dataMax);
+ }
+
+ // Get the new min and max values by getting the ordinal index for the current extreme,
+ // then add the moved units and translate back to values. This happens on the
+ // extended ordinal positions if the new position is out of range, else it happens
+ // on the current x axis which is smaller and faster.
+ chart.fixedRange = max - min;
+ trimmedRange = xAxis.toFixedRange(null, null,
+ lin2val.apply(searchAxisLeft, [
+ val2lin.apply(searchAxisLeft, [min, true]) + movedUnits, // the new index
+ true // translate from index
+ ]),
+ lin2val.apply(searchAxisRight, [
+ val2lin.apply(searchAxisRight, [max, true]) + movedUnits, // the new index
+ true // translate from index
+ ])
+ );
+
+ // Apply it if it is within the available data range
+ if (trimmedRange.min >= mathMin(extremes.dataMin, min) && trimmedRange.max <= mathMax(dataMax, max)) {
+ xAxis.setExtremes(trimmedRange.min, trimmedRange.max, true, false, { trigger: 'pan' });
+ }
+
+ chart.mouseDownX = chartX; // set new reference for next run
+ css(chart.container, { cursor: 'move' });
+ }
+
+ } else {
+ runBase = true;
+ }
+
+ // revert to the linear chart.pan version
+ if (runBase) {
+ // call the original function
+ proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+ }
+});
+
+
+
+/**
+ * Extend getSegments by identifying gaps in the ordinal data so that we can draw a gap in the
+ * line or area
+ */
+wrap(Series.prototype, 'getSegments', function (proceed) {
+
+ var series = this,
+ segments,
+ gapSize = series.options.gapSize,
+ xAxis = series.xAxis;
+
+ // call base method
+ proceed.apply(this, Array.prototype.slice.call(arguments, 1));
+
+ if (gapSize) {
+
+ // properties
+ segments = series.segments;
+
+ // extension for ordinal breaks
+ each(segments, function (segment, no) {
+ var i = segment.length - 1;
+ while (i--) {
+ if (segment[i].x < xAxis.min && segment[i + 1].x > xAxis.max) {
+ segments.length = 0;
+ break;
+ } else if (segment[i + 1].x - segment[i].x > xAxis.closestPointRange * gapSize) {
+ segments.splice( // insert after this one
+ no + 1,
+ 0,
+ segment.splice(i + 1, segment.length - i)
+ );
+ }
+ }
+ });
+ }
+});
+
+/* ****************************************************************************
+ * End ordinal axis logic *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start data grouping module *
+ ******************************************************************************/
+/*jslint white:true */
+var DATA_GROUPING = 'dataGrouping',
+ seriesProto = Series.prototype,
+ tooltipProto = Tooltip.prototype,
+ baseProcessData = seriesProto.processData,
+ baseGeneratePoints = seriesProto.generatePoints,
+ baseDestroy = seriesProto.destroy,
+ baseTooltipFooterHeaderFormatter = tooltipProto.tooltipFooterHeaderFormatter,
+ NUMBER = 'number',
+
+ commonOptions = {
+ approximation: 'average', // average, open, high, low, close, sum
+ //enabled: null, // (true for stock charts, false for basic),
+ //forced: undefined,
+ groupPixelWidth: 2,
+ // the first one is the point or start value, the second is the start value if we're dealing with range,
+ // the third one is the end value if dealing with a range
+ dateTimeLabelFormats: {
+ millisecond: ['%A, %b %e, %H:%M:%S.%L', '%A, %b %e, %H:%M:%S.%L', '-%H:%M:%S.%L'],
+ second: ['%A, %b %e, %H:%M:%S', '%A, %b %e, %H:%M:%S', '-%H:%M:%S'],
+ minute: ['%A, %b %e, %H:%M', '%A, %b %e, %H:%M', '-%H:%M'],
+ hour: ['%A, %b %e, %H:%M', '%A, %b %e, %H:%M', '-%H:%M'],
+ day: ['%A, %b %e, %Y', '%A, %b %e', '-%A, %b %e, %Y'],
+ week: ['Week from %A, %b %e, %Y', '%A, %b %e', '-%A, %b %e, %Y'],
+ month: ['%B %Y', '%B', '-%B %Y'],
+ year: ['%Y', '%Y', '-%Y']
+ }
+ // smoothed = false, // enable this for navigator series only
+ },
+
+ specificOptions = { // extends common options
+ line: {},
+ spline: {},
+ area: {},
+ areaspline: {},
+ column: {
+ approximation: 'sum',
+ groupPixelWidth: 10
+ },
+ arearange: {
+ approximation: 'range'
+ },
+ areasplinerange: {
+ approximation: 'range'
+ },
+ columnrange: {
+ approximation: 'range',
+ groupPixelWidth: 10
+ },
+ candlestick: {
+ approximation: 'ohlc',
+ groupPixelWidth: 10
+ },
+ ohlc: {
+ approximation: 'ohlc',
+ groupPixelWidth: 5
+ }
+ },
+
+ // units are defined in a separate array to allow complete overriding in case of a user option
+ defaultDataGroupingUnits = [[
+ 'millisecond', // unit name
+ [1, 2, 5, 10, 20, 25, 50, 100, 200, 500] // allowed multiples
+ ], [
+ 'second',
+ [1, 2, 5, 10, 15, 30]
+ ], [
+ 'minute',
+ [1, 2, 5, 10, 15, 30]
+ ], [
+ 'hour',
+ [1, 2, 3, 4, 6, 8, 12]
+ ], [
+ 'day',
+ [1]
+ ], [
+ 'week',
+ [1]
+ ], [
+ 'month',
+ [1, 3, 6]
+ ], [
+ 'year',
+ null
+ ]
+ ],
+
+
+ /**
+ * Define the available approximation types. The data grouping approximations takes an array
+ * or numbers as the first parameter. In case of ohlc, four arrays are sent in as four parameters.
+ * Each array consists only of numbers. In case null values belong to the group, the property
+ * .hasNulls will be set to true on the array.
+ */
+ approximations = {
+ sum: function (arr) {
+ var len = arr.length,
+ ret;
+
+ // 1. it consists of nulls exclusively
+ if (!len && arr.hasNulls) {
+ ret = null;
+ // 2. it has a length and real values
+ } else if (len) {
+ ret = 0;
+ while (len--) {
+ ret += arr[len];
+ }
+ }
+ // 3. it has zero length, so just return undefined
+ // => doNothing()
+
+ return ret;
+ },
+ average: function (arr) {
+ var len = arr.length,
+ ret = approximations.sum(arr);
+
+ // If we have a number, return it divided by the length. If not, return
+ // null or undefined based on what the sum method finds.
+ if (typeof ret === NUMBER && len) {
+ ret = ret / len;
+ }
+
+ return ret;
+ },
+ open: function (arr) {
+ return arr.length ? arr[0] : (arr.hasNulls ? null : UNDEFINED);
+ },
+ high: function (arr) {
+ return arr.length ? arrayMax(arr) : (arr.hasNulls ? null : UNDEFINED);
+ },
+ low: function (arr) {
+ return arr.length ? arrayMin(arr) : (arr.hasNulls ? null : UNDEFINED);
+ },
+ close: function (arr) {
+ return arr.length ? arr[arr.length - 1] : (arr.hasNulls ? null : UNDEFINED);
+ },
+ // ohlc and range are special cases where a multidimensional array is input and an array is output
+ ohlc: function (open, high, low, close) {
+ open = approximations.open(open);
+ high = approximations.high(high);
+ low = approximations.low(low);
+ close = approximations.close(close);
+
+ if (typeof open === NUMBER || typeof high === NUMBER || typeof low === NUMBER || typeof close === NUMBER) {
+ return [open, high, low, close];
+ }
+ // else, return is undefined
+ },
+ range: function (low, high) {
+ low = approximations.low(low);
+ high = approximations.high(high);
+
+ if (typeof low === NUMBER || typeof high === NUMBER) {
+ return [low, high];
+ }
+ // else, return is undefined
+ }
+ };
+
+/*jslint white:false */
+
+/**
+ * Takes parallel arrays of x and y data and groups the data into intervals defined by groupPositions, a collection
+ * of starting x values for each group.
+ */
+seriesProto.groupData = function (xData, yData, groupPositions, approximation) {
+ var series = this,
+ data = series.data,
+ dataOptions = series.options.data,
+ groupedXData = [],
+ groupedYData = [],
+ dataLength = xData.length,
+ pointX,
+ pointY,
+ groupedY,
+ handleYData = !!yData, // when grouping the fake extended axis for panning, we don't need to consider y
+ values = [[], [], [], []],
+ approximationFn = typeof approximation === 'function' ? approximation : approximations[approximation],
+ pointArrayMap = series.pointArrayMap,
+ pointArrayMapLength = pointArrayMap && pointArrayMap.length,
+ i;
+
+ // Start with the first point within the X axis range (#2696)
+ for (i = 0; i <= dataLength; i++) {
+ if (xData[i] >= groupPositions[0]) {
+ break;
+ }
+ }
+
+ for (; i <= dataLength; i++) {
+
+ // when a new group is entered, summarize and initiate the previous group
+ while ((groupPositions[1] !== UNDEFINED && xData[i] >= groupPositions[1]) ||
+ i === dataLength) { // get the last group
+
+ // get group x and y
+ pointX = groupPositions.shift();
+ groupedY = approximationFn.apply(0, values);
+
+ // push the grouped data
+ if (groupedY !== UNDEFINED) {
+ groupedXData.push(pointX);
+ groupedYData.push(groupedY);
+ }
+
+ // reset the aggregate arrays
+ values[0] = [];
+ values[1] = [];
+ values[2] = [];
+ values[3] = [];
+
+ // don't loop beyond the last group
+ if (i === dataLength) {
+ break;
+ }
+ }
+
+ // break out
+ if (i === dataLength) {
+ break;
+ }
+
+ // for each raw data point, push it to an array that contains all values for this specific group
+ if (pointArrayMap) {
+
+ var index = series.cropStart + i,
+ point = (data && data[index]) || series.pointClass.prototype.applyOptions.apply({ series: series }, [dataOptions[index]]),
+ j,
+ val;
+
+ for (j = 0; j < pointArrayMapLength; j++) {
+ val = point[pointArrayMap[j]];
+ if (typeof val === NUMBER) {
+ values[j].push(val);
+ } else if (val === null) {
+ values[j].hasNulls = true;
+ }
+ }
+
+ } else {
+ pointY = handleYData ? yData[i] : null;
+
+ if (typeof pointY === NUMBER) {
+ values[0].push(pointY);
+ } else if (pointY === null) {
+ values[0].hasNulls = true;
+ }
+ }
+ }
+
+ return [groupedXData, groupedYData];
+};
+
+/**
+ * Extend the basic processData method, that crops the data to the current zoom
+ * range, with data grouping logic.
+ */
+seriesProto.processData = function () {
+ var series = this,
+ chart = series.chart,
+ options = series.options,
+ dataGroupingOptions = options[DATA_GROUPING],
+ groupingEnabled = series.allowDG !== false && dataGroupingOptions && pick(dataGroupingOptions.enabled, chart.options._stock),
+ hasGroupedData;
+
+ // run base method
+ series.forceCrop = groupingEnabled; // #334
+ series.groupPixelWidth = null; // #2110
+ series.hasProcessed = true; // #2692
+
+ // skip if processData returns false or if grouping is disabled (in that order)
+ if (baseProcessData.apply(series, arguments) === false || !groupingEnabled) {
+ return;
+
+ } else {
+ series.destroyGroupedData();
+
+ }
+ var i,
+ processedXData = series.processedXData,
+ processedYData = series.processedYData,
+ plotSizeX = chart.plotSizeX,
+ xAxis = series.xAxis,
+ ordinal = xAxis.options.ordinal,
+ groupPixelWidth = series.groupPixelWidth = xAxis.getGroupPixelWidth && xAxis.getGroupPixelWidth(),
+ nonGroupedPointRange = series.pointRange;
+
+ // Execute grouping if the amount of points is greater than the limit defined in groupPixelWidth
+ if (groupPixelWidth) {
+ hasGroupedData = true;
+
+ series.points = null; // force recreation of point instances in series.translate
+
+ var extremes = xAxis.getExtremes(),
+ xMin = extremes.min,
+ xMax = extremes.max,
+ groupIntervalFactor = (ordinal && xAxis.getGroupIntervalFactor(xMin, xMax, series)) || 1,
+ interval = (groupPixelWidth * (xMax - xMin) / plotSizeX) * groupIntervalFactor,
+ groupPositions = xAxis.getTimeTicks(
+ xAxis.normalizeTimeTickInterval(interval, dataGroupingOptions.units || defaultDataGroupingUnits),
+ xMin,
+ xMax,
+ xAxis.options.startOfWeek,
+ processedXData,
+ series.closestPointRange
+ ),
+ groupedXandY = seriesProto.groupData.apply(series, [processedXData, processedYData, groupPositions, dataGroupingOptions.approximation]),
+ groupedXData = groupedXandY[0],
+ groupedYData = groupedXandY[1];
+
+ // prevent the smoothed data to spill out left and right, and make
+ // sure data is not shifted to the left
+ if (dataGroupingOptions.smoothed) {
+ i = groupedXData.length - 1;
+ groupedXData[i] = Math.min(groupedXData[i], xMax);
+ while (i-- && i > 0) {
+ groupedXData[i] += interval / 2;
+ }
+ groupedXData[0] = Math.max(groupedXData[0], xMin);
+ }
+
+ // record what data grouping values were used
+ series.currentDataGrouping = groupPositions.info;
+ if (options.pointRange === null) { // null means auto, as for columns, candlesticks and OHLC
+ series.pointRange = groupPositions.info.totalRange;
+ }
+ series.closestPointRange = groupPositions.info.totalRange;
+
+ // Make sure the X axis extends to show the first group (#2533)
+ if (defined(groupedXData[0]) && groupedXData[0] < xAxis.dataMin) {
+ if (xAxis.min === xAxis.dataMin) {
+ xAxis.min = groupedXData[0];
+ }
+ xAxis.dataMin = groupedXData[0];
+ }
+
+ // set series props
+ series.processedXData = groupedXData;
+ series.processedYData = groupedYData;
+ } else {
+ series.currentDataGrouping = null;
+ series.pointRange = nonGroupedPointRange;
+ }
+ series.hasGroupedData = hasGroupedData;
+};
+
+/**
+ * Destroy the grouped data points. #622, #740
+ */
+seriesProto.destroyGroupedData = function () {
+
+ var groupedData = this.groupedData;
+
+ // clear previous groups
+ each(groupedData || [], function (point, i) {
+ if (point) {
+ groupedData[i] = point.destroy ? point.destroy() : null;
+ }
+ });
+ this.groupedData = null;
+};
+
+/**
+ * Override the generatePoints method by adding a reference to grouped data
+ */
+seriesProto.generatePoints = function () {
+
+ baseGeneratePoints.apply(this);
+
+ // record grouped data in order to let it be destroyed the next time processData runs
+ this.destroyGroupedData(); // #622
+ this.groupedData = this.hasGroupedData ? this.points : null;
+};
+
+/**
+ * Extend the original method, make the tooltip's header reflect the grouped range
+ */
+tooltipProto.tooltipFooterHeaderFormatter = function (point, isFooter) {
+ var tooltip = this,
+ series = point.series,
+ options = series.options,
+ tooltipOptions = series.tooltipOptions,
+ dataGroupingOptions = options.dataGrouping,
+ xDateFormat = tooltipOptions.xDateFormat,
+ xDateFormatEnd,
+ xAxis = series.xAxis,
+ currentDataGrouping,
+ dateTimeLabelFormats,
+ labelFormats,
+ formattedKey,
+ ret;
+
+ // apply only to grouped series
+ if (xAxis && xAxis.options.type === 'datetime' && dataGroupingOptions && isNumber(point.key)) {
+
+ // set variables
+ currentDataGrouping = series.currentDataGrouping;
+ dateTimeLabelFormats = dataGroupingOptions.dateTimeLabelFormats;
+
+ // if we have grouped data, use the grouping information to get the right format
+ if (currentDataGrouping) {
+ labelFormats = dateTimeLabelFormats[currentDataGrouping.unitName];
+ if (currentDataGrouping.count === 1) {
+ xDateFormat = labelFormats[0];
+ } else {
+ xDateFormat = labelFormats[1];
+ xDateFormatEnd = labelFormats[2];
+ }
+ // if not grouped, and we don't have set the xDateFormat option, get the best fit,
+ // so if the least distance between points is one minute, show it, but if the
+ // least distance is one day, skip hours and minutes etc.
+ } else if (!xDateFormat && dateTimeLabelFormats) {
+ xDateFormat = tooltip.getXDateFormat(point, tooltipOptions, xAxis);
+ }
+
+ // now format the key
+ formattedKey = dateFormat(xDateFormat, point.key);
+ if (xDateFormatEnd) {
+ formattedKey += dateFormat(xDateFormatEnd, point.key + currentDataGrouping.totalRange - 1);
+ }
+
+ // return the replaced format
+ ret = tooltipOptions[(isFooter ? 'footer' : 'header') + 'Format'].replace('{point.key}', formattedKey);
+
+ // else, fall back to the regular formatter
+ } else {
+ ret = baseTooltipFooterHeaderFormatter.call(tooltip, point, isFooter);
+ }
+
+ return ret;
+};
+
+/**
+ * Extend the series destroyer
+ */
+seriesProto.destroy = function () {
+ var series = this,
+ groupedData = series.groupedData || [],
+ i = groupedData.length;
+
+ while (i--) {
+ if (groupedData[i]) {
+ groupedData[i].destroy();
+ }
+ }
+ baseDestroy.apply(series);
+};
+
+
+// Handle default options for data grouping. This must be set at runtime because some series types are
+// defined after this.
+wrap(seriesProto, 'setOptions', function (proceed, itemOptions) {
+
+ var options = proceed.call(this, itemOptions),
+ type = this.type,
+ plotOptions = this.chart.options.plotOptions,
+ defaultOptions = defaultPlotOptions[type].dataGrouping;
+
+ if (specificOptions[type]) { // #1284
+ if (!defaultOptions) {
+ defaultOptions = merge(commonOptions, specificOptions[type]);
+ }
+
+ options.dataGrouping = merge(
+ defaultOptions,
+ plotOptions.series && plotOptions.series.dataGrouping, // #1228
+ plotOptions[type].dataGrouping, // Set by the StockChart constructor
+ itemOptions.dataGrouping
+ );
+ }
+
+ if (this.chart.options._stock) {
+ this.requireSorting = true;
+ }
+
+ return options;
+});
+
+
+/**
+ * When resetting the scale reset the hasProccessed flag to avoid taking previous data grouping
+ * of neighbour series into accound when determining group pixel width (#2692).
+ */
+wrap(Axis.prototype, 'setScale', function (proceed) {
+ proceed.call(this);
+ each(this.series, function (series) {
+ series.hasProcessed = false;
+ });
+});
+
+/**
+ * Get the data grouping pixel width based on the greatest defined individual width
+ * of the axis' series, and if whether one of the axes need grouping.
+ */
+Axis.prototype.getGroupPixelWidth = function () {
+
+ var series = this.series,
+ len = series.length,
+ i,
+ groupPixelWidth = 0,
+ doGrouping = false,
+ dataLength,
+ dgOptions;
+
+ // If multiple series are compared on the same x axis, give them the same
+ // group pixel width (#334)
+ i = len;
+ while (i--) {
+ dgOptions = series[i].options.dataGrouping;
+ if (dgOptions) {
+ groupPixelWidth = mathMax(groupPixelWidth, dgOptions.groupPixelWidth);
+
+ }
+ }
+
+ // If one of the series needs grouping, apply it to all (#1634)
+ i = len;
+ while (i--) {
+ dgOptions = series[i].options.dataGrouping;
+
+ if (dgOptions && series[i].hasProcessed) { // #2692
+
+ dataLength = (series[i].processedXData || series[i].data).length;
+
+ // Execute grouping if the amount of points is greater than the limit defined in groupPixelWidth
+ if (series[i].groupPixelWidth || dataLength > (this.chart.plotSizeX / groupPixelWidth) || (dataLength && dgOptions.forced)) {
+ doGrouping = true;
+ }
+ }
+ }
+
+ return doGrouping ? groupPixelWidth : 0;
+};
+
+/**
+ * Force data grouping on all the axis' series.
+ */
+Axis.prototype.setDataGrouping = function (dataGrouping, redraw) {
+ var i;
+
+ redraw = pick(redraw, true);
+
+ if (!dataGrouping) {
+ dataGrouping = {
+ forced: false,
+ units: null
+ };
+ }
+
+ // Axis is instantiated, update all series
+ if (this instanceof Axis) {
+ i = this.series.length;
+ while (i--) {
+ this.series[i].update({
+ dataGrouping: dataGrouping
+ }, false);
+ }
+
+ // Axis not yet instanciated, alter series options
+ } else {
+ each(this.chart.options.series, function (seriesOptions) {
+ seriesOptions.dataGrouping = dataGrouping;
+ }, false);
+ }
+
+ if (redraw) {
+ this.chart.redraw();
+ }
+};
+
+
+
+/* ****************************************************************************
+ * End data grouping module *
+ ******************************************************************************/
+
+/* ****************************************************************************
+ * Start OHLC series code *
+ *****************************************************************************/
+
+// 1 - Set default options
+defaultPlotOptions.ohlc = merge(defaultPlotOptions.column, {
+ lineWidth: 1,
+ tooltip: {
+ pointFormat: '\u25CF {series.name}
' + // docs
+ 'Open: {point.open}
' +
+ 'High: {point.high}
' +
+ 'Low: {point.low}
' +
+ 'Close: {point.close}
'
+ },
+ states: {
+ hover: {
+ lineWidth: 3
+ }
+ },
+ threshold: null
+ //upColor: undefined
+});
+
+// 2 - Create the OHLCSeries object
+var OHLCSeries = extendClass(seriesTypes.column, {
+ type: 'ohlc',
+ pointArrayMap: ['open', 'high', 'low', 'close'], // array point configs are mapped to this
+ toYData: function (point) { // return a plain array for speedy calculation
+ return [point.open, point.high, point.low, point.close];
+ },
+ pointValKey: 'high',
+
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ stroke: 'color',
+ 'stroke-width': 'lineWidth'
+ },
+ upColorProp: 'stroke',
+
+ /**
+ * Postprocess mapping between options and SVG attributes
+ */
+ getAttribs: function () {
+ seriesTypes.column.prototype.getAttribs.apply(this, arguments);
+ var series = this,
+ options = series.options,
+ stateOptions = options.states,
+ upColor = options.upColor || series.color,
+ seriesDownPointAttr = merge(series.pointAttr),
+ upColorProp = series.upColorProp;
+
+ seriesDownPointAttr[''][upColorProp] = upColor;
+ seriesDownPointAttr.hover[upColorProp] = stateOptions.hover.upColor || upColor;
+ seriesDownPointAttr.select[upColorProp] = stateOptions.select.upColor || upColor;
+
+ each(series.points, function (point) {
+ if (point.open < point.close && !point.options.color) {
+ point.pointAttr = seriesDownPointAttr;
+ }
+ });
+ },
+
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis;
+
+ seriesTypes.column.prototype.translate.apply(series);
+
+ // do the translation
+ each(series.points, function (point) {
+ // the graphics
+ if (point.open !== null) {
+ point.plotOpen = yAxis.translate(point.open, 0, 1, 0, 1);
+ }
+ if (point.close !== null) {
+ point.plotClose = yAxis.translate(point.close, 0, 1, 0, 1);
+ }
+
+ });
+ },
+
+ /**
+ * Draw the data points
+ */
+ drawPoints: function () {
+ var series = this,
+ points = series.points,
+ chart = series.chart,
+ pointAttr,
+ plotOpen,
+ plotClose,
+ crispCorr,
+ halfWidth,
+ path,
+ graphic,
+ crispX;
+
+
+ each(points, function (point) {
+ if (point.plotY !== UNDEFINED) {
+
+ graphic = point.graphic;
+ pointAttr = point.pointAttr[point.selected ? 'selected' : ''] || series.pointAttr[NORMAL_STATE];
+
+ // crisp vector coordinates
+ crispCorr = (pointAttr['stroke-width'] % 2) / 2;
+ crispX = mathRound(point.plotX) - crispCorr; // #2596
+ halfWidth = mathRound(point.shapeArgs.width / 2);
+
+ // the vertical stem
+ path = [
+ 'M',
+ crispX, mathRound(point.yBottom),
+ 'L',
+ crispX, mathRound(point.plotY)
+ ];
+
+ // open
+ if (point.open !== null) {
+ plotOpen = mathRound(point.plotOpen) + crispCorr;
+ path.push(
+ 'M',
+ crispX,
+ plotOpen,
+ 'L',
+ crispX - halfWidth,
+ plotOpen
+ );
+ }
+
+ // close
+ if (point.close !== null) {
+ plotClose = mathRound(point.plotClose) + crispCorr;
+ path.push(
+ 'M',
+ crispX,
+ plotClose,
+ 'L',
+ crispX + halfWidth,
+ plotClose
+ );
+ }
+
+ // create and/or update the graphic
+ if (graphic) {
+ graphic
+ .attr(pointAttr) // #3897
+ .animate({ d: path });
+ } else {
+ point.graphic = chart.renderer.path(path)
+ .attr(pointAttr)
+ .add(series.group);
+ }
+
+ }
+
+
+ });
+
+ },
+
+ /**
+ * Disable animation
+ */
+ animate: null
+
+
+});
+seriesTypes.ohlc = OHLCSeries;
+/* ****************************************************************************
+ * End OHLC series code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start Candlestick series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.candlestick = merge(defaultPlotOptions.column, {
+ lineColor: 'black',
+ lineWidth: 1,
+ states: {
+ hover: {
+ lineWidth: 2
+ }
+ },
+ tooltip: defaultPlotOptions.ohlc.tooltip,
+ threshold: null,
+ upColor: 'white'
+ // upLineColor: null
+});
+
+// 2 - Create the CandlestickSeries object
+var CandlestickSeries = extendClass(OHLCSeries, {
+ type: 'candlestick',
+
+ /**
+ * One-to-one mapping from options to SVG attributes
+ */
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ fill: 'color',
+ stroke: 'lineColor',
+ 'stroke-width': 'lineWidth'
+ },
+ upColorProp: 'fill',
+
+ /**
+ * Postprocess mapping between options and SVG attributes
+ */
+ getAttribs: function () {
+ seriesTypes.ohlc.prototype.getAttribs.apply(this, arguments);
+ var series = this,
+ options = series.options,
+ stateOptions = options.states,
+ upLineColor = options.upLineColor || options.lineColor,
+ hoverStroke = stateOptions.hover.upLineColor || upLineColor,
+ selectStroke = stateOptions.select.upLineColor || upLineColor;
+
+ // Add custom line color for points going up (close > open).
+ // Fill is handled by OHLCSeries' getAttribs.
+ each(series.points, function (point) {
+ if (point.open < point.close) {
+
+ // If an individual line color is set, we need to merge the
+ // point attributes, because they are shared between all up
+ // points by inheritance from OHCLSeries.
+ if (point.lineColor) {
+ point.pointAttr = merge(point.pointAttr);
+ upLineColor = point.lineColor;
+ }
+
+ point.pointAttr[''].stroke = upLineColor;
+ point.pointAttr.hover.stroke = hoverStroke;
+ point.pointAttr.select.stroke = selectStroke;
+ }
+ });
+ },
+
+ /**
+ * Draw the data points
+ */
+ drawPoints: function () {
+ var series = this, //state = series.state,
+ points = series.points,
+ chart = series.chart,
+ pointAttr,
+ seriesPointAttr = series.pointAttr[''],
+ plotOpen,
+ plotClose,
+ topBox,
+ bottomBox,
+ hasTopWhisker,
+ hasBottomWhisker,
+ crispCorr,
+ crispX,
+ graphic,
+ path,
+ halfWidth;
+
+
+ each(points, function (point) {
+
+ graphic = point.graphic;
+ if (point.plotY !== UNDEFINED) {
+
+ pointAttr = point.pointAttr[point.selected ? 'selected' : ''] || seriesPointAttr;
+
+ // crisp vector coordinates
+ crispCorr = (pointAttr['stroke-width'] % 2) / 2;
+ crispX = mathRound(point.plotX) - crispCorr; // #2596
+ plotOpen = point.plotOpen;
+ plotClose = point.plotClose;
+ topBox = math.min(plotOpen, plotClose);
+ bottomBox = math.max(plotOpen, plotClose);
+ halfWidth = mathRound(point.shapeArgs.width / 2);
+ hasTopWhisker = mathRound(topBox) !== mathRound(point.plotY);
+ hasBottomWhisker = bottomBox !== point.yBottom;
+ topBox = mathRound(topBox) + crispCorr;
+ bottomBox = mathRound(bottomBox) + crispCorr;
+
+ // create the path
+ path = [
+ 'M',
+ crispX - halfWidth, bottomBox,
+ 'L',
+ crispX - halfWidth, topBox,
+ 'L',
+ crispX + halfWidth, topBox,
+ 'L',
+ crispX + halfWidth, bottomBox,
+ 'Z', // Use a close statement to ensure a nice rectangle #2602
+ 'M',
+ crispX, topBox,
+ 'L',
+ crispX, hasTopWhisker ? mathRound(point.plotY) : topBox, // #460, #2094
+ 'M',
+ crispX, bottomBox,
+ 'L',
+ crispX, hasBottomWhisker ? mathRound(point.yBottom) : bottomBox // #460, #2094
+ ];
+
+ if (graphic) {
+ graphic
+ .attr(pointAttr) // #3897
+ .animate({ d: path });
+ } else {
+ point.graphic = chart.renderer.path(path)
+ .attr(pointAttr)
+ .add(series.group)
+ .shadow(series.options.shadow);
+ }
+
+ }
+ });
+
+ }
+
+
+});
+
+seriesTypes.candlestick = CandlestickSeries;
+
+/* ****************************************************************************
+ * End Candlestick series code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start Flags series code *
+ *****************************************************************************/
+
+var symbols = SVGRenderer.prototype.symbols;
+
+// 1 - set default options
+defaultPlotOptions.flags = merge(defaultPlotOptions.column, {
+ fillColor: 'white',
+ lineWidth: 1,
+ pointRange: 0, // #673
+ //radius: 2,
+ shape: 'flag',
+ stackDistance: 12,
+ states: {
+ hover: {
+ lineColor: 'black',
+ fillColor: '#FCFFC5'
+ }
+ },
+ style: {
+ fontSize: '11px',
+ fontWeight: 'bold',
+ textAlign: 'center'
+ },
+ tooltip: {
+ pointFormat: '{point.text}
'
+ },
+ threshold: null,
+ y: -30
+});
+
+// 2 - Create the CandlestickSeries object
+seriesTypes.flags = extendClass(seriesTypes.column, {
+ type: 'flags',
+ sorted: false,
+ noSharedTooltip: true,
+ allowDG: false,
+ takeOrdinalPosition: false, // #1074
+ trackerGroups: ['markerGroup'],
+ forceCrop: true,
+ /**
+ * Inherit the initialization from base Series
+ */
+ init: Series.prototype.init,
+
+ /**
+ * One-to-one mapping from options to SVG attributes
+ */
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ fill: 'fillColor',
+ stroke: 'color',
+ 'stroke-width': 'lineWidth',
+ r: 'radius'
+ },
+
+ /**
+ * Extend the translate method by placing the point on the related series
+ */
+ translate: function () {
+
+ seriesTypes.column.prototype.translate.apply(this);
+
+ var series = this,
+ options = series.options,
+ chart = series.chart,
+ points = series.points,
+ cursor = points.length - 1,
+ point,
+ lastPoint,
+ optionsOnSeries = options.onSeries,
+ onSeries = optionsOnSeries && chart.get(optionsOnSeries),
+ step = onSeries && onSeries.options.step,
+ onData = onSeries && onSeries.points,
+ i = onData && onData.length,
+ xAxis = series.xAxis,
+ xAxisExt = xAxis.getExtremes(),
+ leftPoint,
+ lastX,
+ rightPoint,
+ currentDataGrouping;
+
+ // relate to a master series
+ if (onSeries && onSeries.visible && i) {
+ currentDataGrouping = onSeries.currentDataGrouping;
+ lastX = onData[i - 1].x + (currentDataGrouping ? currentDataGrouping.totalRange : 0); // #2374
+
+ // sort the data points
+ points.sort(function (a, b) {
+ return (a.x - b.x);
+ });
+
+ while (i-- && points[cursor]) {
+ point = points[cursor];
+ leftPoint = onData[i];
+
+ if (leftPoint.x <= point.x && leftPoint.plotY !== UNDEFINED) {
+ if (point.x <= lastX) { // #803
+
+ point.plotY = leftPoint.plotY;
+
+ // interpolate between points, #666
+ if (leftPoint.x < point.x && !step) {
+ rightPoint = onData[i + 1];
+ if (rightPoint && rightPoint.plotY !== UNDEFINED) {
+ point.plotY +=
+ ((point.x - leftPoint.x) / (rightPoint.x - leftPoint.x)) * // the distance ratio, between 0 and 1
+ (rightPoint.plotY - leftPoint.plotY); // the y distance
+ }
+ }
+ }
+ cursor--;
+ i++; // check again for points in the same x position
+ if (cursor < 0) {
+ break;
+ }
+ }
+ }
+ }
+
+ // Add plotY position and handle stacking
+ each(points, function (point, i) {
+
+ var stackIndex;
+
+ // Undefined plotY means the point is either on axis, outside series range or hidden series.
+ // If the series is outside the range of the x axis it should fall through with
+ // an undefined plotY, but then we must remove the shapeArgs (#847).
+ if (point.plotY === UNDEFINED) {
+ if (point.x >= xAxisExt.min && point.x <= xAxisExt.max) { // we're inside xAxis range
+ point.plotY = chart.chartHeight - xAxis.bottom - (xAxis.opposite ? xAxis.height : 0) + xAxis.offset - chart.plotTop;
+ } else {
+ point.shapeArgs = {}; // 847
+ }
+ }
+ // if multiple flags appear at the same x, order them into a stack
+ lastPoint = points[i - 1];
+ if (lastPoint && lastPoint.plotX === point.plotX) {
+ if (lastPoint.stackIndex === UNDEFINED) {
+ lastPoint.stackIndex = 0;
+ }
+ stackIndex = lastPoint.stackIndex + 1;
+ }
+ point.stackIndex = stackIndex; // #3639
+ });
+
+
+ },
+
+ /**
+ * Draw the markers
+ */
+ drawPoints: function () {
+ var series = this,
+ pointAttr,
+ seriesPointAttr = series.pointAttr[''],
+ points = series.points,
+ chart = series.chart,
+ renderer = chart.renderer,
+ plotX,
+ plotY,
+ options = series.options,
+ optionsY = options.y,
+ shape,
+ i,
+ point,
+ graphic,
+ stackIndex,
+ anchorX,
+ anchorY,
+ outsideRight;
+
+ i = points.length;
+ while (i--) {
+ point = points[i];
+ outsideRight = point.plotX > series.xAxis.len;
+ plotX = point.plotX;
+ if (plotX > 0) { // #3119
+ plotX -= pick(point.lineWidth, options.lineWidth) % 2; // #4285
+ }
+ stackIndex = point.stackIndex;
+ shape = point.options.shape || options.shape;
+ plotY = point.plotY;
+ if (plotY !== UNDEFINED) {
+ plotY = point.plotY + optionsY - (stackIndex !== UNDEFINED && stackIndex * options.stackDistance);
+ }
+ anchorX = stackIndex ? UNDEFINED : point.plotX; // skip connectors for higher level stacked points
+ anchorY = stackIndex ? UNDEFINED : point.plotY;
+
+ graphic = point.graphic;
+
+ // only draw the point if y is defined and the flag is within the visible area
+ if (plotY !== UNDEFINED && plotX >= 0 && !outsideRight) {
+ // shortcuts
+ pointAttr = point.pointAttr[point.selected ? 'select' : ''] || seriesPointAttr;
+ if (graphic) { // update
+ graphic.attr({
+ x: plotX,
+ y: plotY,
+ r: pointAttr.r,
+ anchorX: anchorX,
+ anchorY: anchorY
+ });
+ } else {
+ graphic = point.graphic = renderer.label(
+ point.options.title || options.title || 'A',
+ plotX,
+ plotY,
+ shape,
+ anchorX,
+ anchorY,
+ options.useHTML
+ )
+ .css(merge(options.style, point.style))
+ .attr(pointAttr)
+ .attr({
+ align: shape === 'flag' ? 'left' : 'center',
+ width: options.width,
+ height: options.height
+ })
+ .add(series.markerGroup)
+ .shadow(options.shadow);
+
+ }
+
+ // Set the tooltip anchor position
+ point.tooltipPos = [plotX, plotY];
+
+ } else if (graphic) {
+ point.graphic = graphic.destroy();
+ }
+
+ }
+
+ },
+
+ /**
+ * Extend the column trackers with listeners to expand and contract stacks
+ */
+ drawTracker: function () {
+ var series = this,
+ points = series.points;
+
+ TrackerMixin.drawTrackerPoint.apply(this);
+
+ // Bring each stacked flag up on mouse over, this allows readability of vertically
+ // stacked elements as well as tight points on the x axis. #1924.
+ each(points, function (point) {
+ var graphic = point.graphic;
+ if (graphic) {
+ addEvent(graphic.element, 'mouseover', function () {
+
+ // Raise this point
+ if (point.stackIndex > 0 && !point.raised) {
+ point._y = graphic.y;
+ graphic.attr({
+ y: point._y - 8
+ });
+ point.raised = true;
+ }
+
+ // Revert other raised points
+ each(points, function (otherPoint) {
+ if (otherPoint !== point && otherPoint.raised && otherPoint.graphic) {
+ otherPoint.graphic.attr({
+ y: otherPoint._y
+ });
+ otherPoint.raised = false;
+ }
+ });
+ });
+ }
+ });
+ },
+
+ /**
+ * Disable animation
+ */
+ animate: noop,
+ buildKDTree: noop,
+ setClip: noop
+
+});
+
+// create the flag icon with anchor
+symbols.flag = function (x, y, w, h, options) {
+ var anchorX = (options && options.anchorX) || x,
+ anchorY = (options && options.anchorY) || y;
+
+ return [
+ 'M', anchorX, anchorY,
+ 'L', x, y + h,
+ x, y,
+ x + w, y,
+ x + w, y + h,
+ x, y + h,
+ 'Z'
+ ];
+};
+
+// create the circlepin and squarepin icons with anchor
+each(['circle', 'square'], function (shape) {
+ symbols[shape + 'pin'] = function (x, y, w, h, options) {
+
+ var anchorX = options && options.anchorX,
+ anchorY = options && options.anchorY,
+ path,
+ labelTopOrBottomY;
+
+ // For single-letter flags, make sure circular flags are not taller than their width
+ if (shape === 'circle' && h > w) {
+ x -= mathRound((h - w) / 2);
+ w = h;
+ }
+
+ path = symbols[shape](x, y, w, h);
+
+ if (anchorX && anchorY) {
+ // if the label is below the anchor, draw the connecting line from the top edge of the label
+ // otherwise start drawing from the bottom edge
+ labelTopOrBottomY = (y > anchorY) ? y : y + h;
+ path.push('M', anchorX, labelTopOrBottomY, 'L', anchorX, anchorY);
+ }
+
+ return path;
+ };
+});
+
+// The symbol callbacks are generated on the SVGRenderer object in all browsers. Even
+// VML browsers need this in order to generate shapes in export. Now share
+// them with the VMLRenderer.
+if (Renderer === Highcharts.VMLRenderer) {
+ each(['flag', 'circlepin', 'squarepin'], function (shape) {
+ VMLRenderer.prototype.symbols[shape] = symbols[shape];
+ });
+}
+
+/* ****************************************************************************
+ * End Flags series code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start Scroller code *
+ *****************************************************************************/
+var units = [].concat(defaultDataGroupingUnits), // copy
+ defaultSeriesType,
+
+ // Finding the min or max of a set of variables where we don't know if they are defined,
+ // is a pattern that is repeated several places in Highcharts. Consider making this
+ // a global utility method.
+ numExt = function (extreme) {
+ var numbers = grep(arguments, function (n) { return typeof n === 'number'; });
+ if (numbers.length) {
+ return Math[extreme].apply(0, numbers);
+ }
+ };
+
+// add more resolution to units
+units[4] = ['day', [1, 2, 3, 4]]; // allow more days
+units[5] = ['week', [1, 2, 3]]; // allow more weeks
+
+defaultSeriesType = seriesTypes.areaspline === UNDEFINED ? 'line' : 'areaspline';
+
+extend(defaultOptions, {
+ navigator: {
+ //enabled: true,
+ handles: {
+ backgroundColor: '#ebe7e8',
+ borderColor: '#b2b1b6'
+ },
+ height: 40,
+ margin: 25,
+ maskFill: 'rgba(128,179,236,0.3)',
+ maskInside: true,
+ outlineColor: '#b2b1b6',
+ outlineWidth: 1,
+ series: {
+ type: defaultSeriesType,
+ color: '#4572A7',
+ compare: null,
+ fillOpacity: 0.05,
+ dataGrouping: {
+ approximation: 'average',
+ enabled: true,
+ groupPixelWidth: 2,
+ smoothed: true,
+ units: units
+ },
+ dataLabels: {
+ enabled: false,
+ zIndex: 2 // #1839
+ },
+ id: PREFIX + 'navigator-series',
+ lineColor: null, // Allow color setting while disallowing default candlestick setting (#4602)
+ lineWidth: 1,
+ marker: {
+ enabled: false
+ },
+ pointRange: 0,
+ shadow: false,
+ threshold: null
+ },
+ //top: undefined,
+ xAxis: {
+ tickWidth: 0,
+ lineWidth: 0,
+ gridLineColor: '#EEE',
+ gridLineWidth: 1,
+ tickPixelInterval: 200,
+ labels: {
+ align: 'left',
+ style: {
+ color: '#888'
+ },
+ x: 3,
+ y: -4
+ },
+ crosshair: false
+ },
+ yAxis: {
+ gridLineWidth: 0,
+ startOnTick: false,
+ endOnTick: false,
+ minPadding: 0.1,
+ maxPadding: 0.1,
+ labels: {
+ enabled: false
+ },
+ crosshair: false,
+ title: {
+ text: null
+ },
+ tickWidth: 0
+ }
+ },
+ scrollbar: {
+ //enabled: true
+ height: isTouchDevice ? 20 : 14,
+ barBackgroundColor: '#bfc8d1',
+ barBorderRadius: 0,
+ barBorderWidth: 1,
+ barBorderColor: '#bfc8d1',
+ buttonArrowColor: '#666',
+ buttonBackgroundColor: '#ebe7e8',
+ buttonBorderColor: '#bbb',
+ buttonBorderRadius: 0,
+ buttonBorderWidth: 1,
+ minWidth: 6,
+ rifleColor: '#666',
+ trackBackgroundColor: '#eeeeee',
+ trackBorderColor: '#eeeeee',
+ trackBorderWidth: 1,
+ // trackBorderRadius: 0
+ liveRedraw: hasSVG && !isTouchDevice
+ }
+});
+
+/**
+ * The Scroller class
+ * @param {Object} chart
+ */
+function Scroller(chart) {
+ var chartOptions = chart.options,
+ navigatorOptions = chartOptions.navigator,
+ navigatorEnabled = navigatorOptions.enabled,
+ scrollbarOptions = chartOptions.scrollbar,
+ scrollbarEnabled = scrollbarOptions.enabled,
+ height = navigatorEnabled ? navigatorOptions.height : 0,
+ scrollbarHeight = scrollbarEnabled ? scrollbarOptions.height : 0;
+
+
+ this.handles = [];
+ this.scrollbarButtons = [];
+ this.elementsToDestroy = []; // Array containing the elements to destroy when Scroller is destroyed
+
+ this.chart = chart;
+ this.setBaseSeries();
+
+ this.height = height;
+ this.scrollbarHeight = scrollbarHeight;
+ this.scrollbarEnabled = scrollbarEnabled;
+ this.navigatorEnabled = navigatorEnabled;
+ this.navigatorOptions = navigatorOptions;
+ this.scrollbarOptions = scrollbarOptions;
+ this.outlineHeight = height + scrollbarHeight;
+
+ // Run scroller
+ this.init();
+}
+
+Scroller.prototype = {
+ /**
+ * Draw one of the handles on the side of the zoomed range in the navigator
+ * @param {Number} x The x center for the handle
+ * @param {Number} index 0 for left and 1 for right
+ */
+ drawHandle: function (x, index) {
+ var scroller = this,
+ chart = scroller.chart,
+ renderer = chart.renderer,
+ elementsToDestroy = scroller.elementsToDestroy,
+ handles = scroller.handles,
+ handlesOptions = scroller.navigatorOptions.handles,
+ attr = {
+ fill: handlesOptions.backgroundColor,
+ stroke: handlesOptions.borderColor,
+ 'stroke-width': 1
+ },
+ tempElem;
+
+ // create the elements
+ if (!scroller.rendered) {
+ // the group
+ handles[index] = renderer.g('navigator-handle-' + ['left', 'right'][index])
+ .css({ cursor: 'ew-resize' })
+ .attr({ zIndex: 4 - index }) // zIndex = 3 for right handle, 4 for left
+ .add();
+
+ // the rectangle
+ tempElem = renderer.rect(-4.5, 0, 9, 16, 0, 1)
+ .attr(attr)
+ .add(handles[index]);
+ elementsToDestroy.push(tempElem);
+
+ // the rifles
+ tempElem = renderer.path([
+ 'M',
+ -1.5, 4,
+ 'L',
+ -1.5, 12,
+ 'M',
+ 0.5, 4,
+ 'L',
+ 0.5, 12
+ ]).attr(attr)
+ .add(handles[index]);
+ elementsToDestroy.push(tempElem);
+ }
+
+ // Place it
+ handles[index][chart.isResizing ? 'animate' : 'attr']({
+ translateX: scroller.scrollerLeft + scroller.scrollbarHeight + parseInt(x, 10),
+ translateY: scroller.top + scroller.height / 2 - 8
+ });
+ },
+
+ /**
+ * Draw the scrollbar buttons with arrows
+ * @param {Number} index 0 is left, 1 is right
+ */
+ drawScrollbarButton: function (index) {
+ var scroller = this,
+ chart = scroller.chart,
+ renderer = chart.renderer,
+ elementsToDestroy = scroller.elementsToDestroy,
+ scrollbarButtons = scroller.scrollbarButtons,
+ scrollbarHeight = scroller.scrollbarHeight,
+ scrollbarOptions = scroller.scrollbarOptions,
+ tempElem;
+
+ if (!scroller.rendered) {
+ scrollbarButtons[index] = renderer.g().add(scroller.scrollbarGroup);
+
+ tempElem = renderer.rect(
+ -0.5,
+ -0.5,
+ scrollbarHeight + 1, // +1 to compensate for crispifying in rect method
+ scrollbarHeight + 1,
+ scrollbarOptions.buttonBorderRadius,
+ scrollbarOptions.buttonBorderWidth
+ ).attr({
+ stroke: scrollbarOptions.buttonBorderColor,
+ 'stroke-width': scrollbarOptions.buttonBorderWidth,
+ fill: scrollbarOptions.buttonBackgroundColor
+ }).add(scrollbarButtons[index]);
+ elementsToDestroy.push(tempElem);
+
+ tempElem = renderer.path([
+ 'M',
+ scrollbarHeight / 2 + (index ? -1 : 1), scrollbarHeight / 2 - 3,
+ 'L',
+ scrollbarHeight / 2 + (index ? -1 : 1), scrollbarHeight / 2 + 3,
+ scrollbarHeight / 2 + (index ? 2 : -2), scrollbarHeight / 2
+ ]).attr({
+ fill: scrollbarOptions.buttonArrowColor
+ }).add(scrollbarButtons[index]);
+ elementsToDestroy.push(tempElem);
+ }
+
+ // adjust the right side button to the varying length of the scroll track
+ if (index) {
+ scrollbarButtons[index].attr({
+ translateX: scroller.scrollerWidth - scrollbarHeight
+ });
+ }
+ },
+
+ /**
+ * Render the navigator and scroll bar
+ * @param {Number} min X axis value minimum
+ * @param {Number} max X axis value maximum
+ * @param {Number} pxMin Pixel value minimum
+ * @param {Number} pxMax Pixel value maximum
+ */
+ render: function (min, max, pxMin, pxMax) {
+ var scroller = this,
+ chart = scroller.chart,
+ renderer = chart.renderer,
+ navigatorLeft,
+ navigatorWidth,
+ scrollerLeft,
+ scrollerWidth,
+ scrollbarGroup = scroller.scrollbarGroup,
+ navigatorGroup = scroller.navigatorGroup,
+ scrollbar = scroller.scrollbar,
+ xAxis = scroller.xAxis,
+ scrollbarTrack = scroller.scrollbarTrack,
+ scrollbarHeight = scroller.scrollbarHeight,
+ scrollbarEnabled = scroller.scrollbarEnabled,
+ navigatorOptions = scroller.navigatorOptions,
+ scrollbarOptions = scroller.scrollbarOptions,
+ scrollbarMinWidth = scrollbarOptions.minWidth,
+ height = scroller.height,
+ top = scroller.top,
+ navigatorEnabled = scroller.navigatorEnabled,
+ outlineWidth = navigatorOptions.outlineWidth,
+ halfOutline = outlineWidth / 2,
+ zoomedMin,
+ zoomedMax,
+ range,
+ scrX,
+ scrWidth,
+ scrollbarPad = 0,
+ outlineHeight = scroller.outlineHeight,
+ barBorderRadius = scrollbarOptions.barBorderRadius,
+ strokeWidth,
+ scrollbarStrokeWidth = scrollbarOptions.barBorderWidth,
+ centerBarX,
+ outlineTop = top + halfOutline,
+ verb,
+ unionExtremes;
+
+ // Don't render the navigator until we have data (#486, #4202)
+ if (!defined(min) || isNaN(min)) {
+ return;
+ }
+
+ scroller.navigatorLeft = navigatorLeft = pick(
+ xAxis.left,
+ chart.plotLeft + scrollbarHeight // in case of scrollbar only, without navigator
+ );
+ scroller.navigatorWidth = navigatorWidth = pick(xAxis.len, chart.plotWidth - 2 * scrollbarHeight);
+ scroller.scrollerLeft = scrollerLeft = navigatorLeft - scrollbarHeight;
+ scroller.scrollerWidth = scrollerWidth = scrollerWidth = navigatorWidth + 2 * scrollbarHeight;
+
+ // Set the scroller x axis extremes to reflect the total. The navigator extremes
+ // should always be the extremes of the union of all series in the chart as
+ // well as the navigator series.
+ if (xAxis.getExtremes) {
+ unionExtremes = scroller.getUnionExtremes(true);
+
+ if (unionExtremes && (unionExtremes.dataMin !== xAxis.min || unionExtremes.dataMax !== xAxis.max)) {
+ xAxis.setExtremes(unionExtremes.dataMin, unionExtremes.dataMax, true, false);
+ }
+ }
+
+ // Get the pixel position of the handles
+ pxMin = pick(pxMin, xAxis.translate(min));
+ pxMax = pick(pxMax, xAxis.translate(max));
+ if (isNaN(pxMin) || mathAbs(pxMin) === Infinity) { // Verify (#1851, #2238)
+ pxMin = 0;
+ pxMax = scrollerWidth;
+ }
+
+ // Are we below the minRange? (#2618)
+ if (xAxis.translate(pxMax, true) - xAxis.translate(pxMin, true) < chart.xAxis[0].minRange) {
+ return;
+ }
+
+
+ // handles are allowed to cross, but never exceed the plot area
+ scroller.zoomedMax = mathMin(mathMax(pxMin, pxMax, 0), navigatorWidth);
+ scroller.zoomedMin =
+ mathMax(scroller.fixedWidth ? scroller.zoomedMax - scroller.fixedWidth : mathMin(pxMin, pxMax), 0);
+ scroller.range = scroller.zoomedMax - scroller.zoomedMin;
+ zoomedMax = mathRound(scroller.zoomedMax);
+ zoomedMin = mathRound(scroller.zoomedMin);
+ range = zoomedMax - zoomedMin;
+
+
+
+ // on first render, create all elements
+ if (!scroller.rendered) {
+
+ if (navigatorEnabled) {
+
+ // draw the navigator group
+ scroller.navigatorGroup = navigatorGroup = renderer.g('navigator')
+ .attr({
+ zIndex: 3
+ })
+ .add();
+
+ scroller.leftShade = renderer.rect()
+ .attr({
+ fill: navigatorOptions.maskFill
+ }).add(navigatorGroup);
+
+ if (navigatorOptions.maskInside) {
+ scroller.leftShade.css({ cursor: 'ew-resize '});
+ } else {
+ scroller.rightShade = renderer.rect()
+ .attr({
+ fill: navigatorOptions.maskFill
+ }).add(navigatorGroup);
+ }
+
+
+ scroller.outline = renderer.path()
+ .attr({
+ 'stroke-width': outlineWidth,
+ stroke: navigatorOptions.outlineColor
+ })
+ .add(navigatorGroup);
+ }
+
+ if (scrollbarEnabled) {
+
+ // draw the scrollbar group
+ scroller.scrollbarGroup = scrollbarGroup = renderer.g('scrollbar').add();
+
+ // the scrollbar track
+ strokeWidth = scrollbarOptions.trackBorderWidth;
+ scroller.scrollbarTrack = scrollbarTrack = renderer.rect().attr({
+ x: 0,
+ y: -strokeWidth % 2 / 2,
+ fill: scrollbarOptions.trackBackgroundColor,
+ stroke: scrollbarOptions.trackBorderColor,
+ 'stroke-width': strokeWidth,
+ r: scrollbarOptions.trackBorderRadius || 0,
+ height: scrollbarHeight
+ }).add(scrollbarGroup);
+
+ // the scrollbar itself
+ scroller.scrollbar = scrollbar = renderer.rect()
+ .attr({
+ y: -scrollbarStrokeWidth % 2 / 2,
+ height: scrollbarHeight,
+ fill: scrollbarOptions.barBackgroundColor,
+ stroke: scrollbarOptions.barBorderColor,
+ 'stroke-width': scrollbarStrokeWidth,
+ r: barBorderRadius
+ })
+ .add(scrollbarGroup);
+
+ scroller.scrollbarRifles = renderer.path()
+ .attr({
+ stroke: scrollbarOptions.rifleColor,
+ 'stroke-width': 1
+ })
+ .add(scrollbarGroup);
+ }
+ }
+
+ // place elements
+ verb = chart.isResizing ? 'animate' : 'attr';
+
+ if (navigatorEnabled) {
+ scroller.leftShade[verb](navigatorOptions.maskInside ? {
+ x: navigatorLeft + zoomedMin,
+ y: top,
+ width: zoomedMax - zoomedMin,
+ height: height
+ } : {
+ x: navigatorLeft,
+ y: top,
+ width: zoomedMin,
+ height: height
+ });
+ if (scroller.rightShade) {
+ scroller.rightShade[verb]({
+ x: navigatorLeft + zoomedMax,
+ y: top,
+ width: navigatorWidth - zoomedMax,
+ height: height
+ });
+ }
+
+ scroller.outline[verb]({ d: [
+ M,
+ scrollerLeft, outlineTop, // left
+ L,
+ navigatorLeft + zoomedMin - halfOutline, outlineTop, // upper left of zoomed range
+ navigatorLeft + zoomedMin - halfOutline, outlineTop + outlineHeight, // lower left of z.r.
+ L,
+ navigatorLeft + zoomedMax - halfOutline, outlineTop + outlineHeight, // lower right of z.r.
+ L,
+ navigatorLeft + zoomedMax - halfOutline, outlineTop, // upper right of z.r.
+ scrollerLeft + scrollerWidth, outlineTop // right
+ ].concat(navigatorOptions.maskInside ? [
+ M,
+ navigatorLeft + zoomedMin + halfOutline, outlineTop, // upper left of zoomed range
+ L,
+ navigatorLeft + zoomedMax - halfOutline, outlineTop // upper right of z.r.
+ ] : [])});
+ // draw handles
+ scroller.drawHandle(zoomedMin + halfOutline, 0);
+ scroller.drawHandle(zoomedMax + halfOutline, 1);
+ }
+
+ // draw the scrollbar
+ if (scrollbarEnabled && scrollbarGroup) {
+
+ // draw the buttons
+ scroller.drawScrollbarButton(0);
+ scroller.drawScrollbarButton(1);
+
+ scrollbarGroup[verb]({
+ translateX: scrollerLeft,
+ translateY: mathRound(outlineTop + height)
+ });
+
+ scrollbarTrack[verb]({
+ width: scrollerWidth
+ });
+
+ // prevent the scrollbar from drawing to small (#1246)
+ scrX = scrollbarHeight + zoomedMin;
+ scrWidth = range - scrollbarStrokeWidth;
+ if (scrWidth < scrollbarMinWidth) {
+ scrollbarPad = (scrollbarMinWidth - scrWidth) / 2;
+ scrWidth = scrollbarMinWidth;
+ scrX -= scrollbarPad;
+ }
+ scroller.scrollbarPad = scrollbarPad;
+ scrollbar[verb]({
+ x: mathFloor(scrX) + (scrollbarStrokeWidth % 2 / 2),
+ width: scrWidth
+ });
+
+ centerBarX = scrollbarHeight + zoomedMin + range / 2 - 0.5;
+
+ scroller.scrollbarRifles
+ .attr({
+ visibility: range > 12 ? VISIBLE : HIDDEN
+ })[verb]({
+ d: [
+ M,
+ centerBarX - 3, scrollbarHeight / 4,
+ L,
+ centerBarX - 3, 2 * scrollbarHeight / 3,
+ M,
+ centerBarX, scrollbarHeight / 4,
+ L,
+ centerBarX, 2 * scrollbarHeight / 3,
+ M,
+ centerBarX + 3, scrollbarHeight / 4,
+ L,
+ centerBarX + 3, 2 * scrollbarHeight / 3
+ ]
+ });
+ }
+
+ scroller.scrollbarPad = scrollbarPad;
+ scroller.rendered = true;
+ },
+
+ /**
+ * Set up the mouse and touch events for the navigator and scrollbar
+ */
+ addEvents: function () {
+ var container = this.chart.container,
+ mouseDownHandler = this.mouseDownHandler,
+ mouseMoveHandler = this.mouseMoveHandler,
+ mouseUpHandler = this.mouseUpHandler,
+ _events;
+
+ // Mouse events
+ _events = [
+ [container, 'mousedown', mouseDownHandler],
+ [container, 'mousemove', mouseMoveHandler],
+ [document, 'mouseup', mouseUpHandler]
+ ];
+
+ // Touch events
+ if (hasTouch) {
+ _events.push(
+ [container, 'touchstart', mouseDownHandler],
+ [container, 'touchmove', mouseMoveHandler],
+ [document, 'touchend', mouseUpHandler]
+ );
+ }
+
+ // Add them all
+ each(_events, function (args) {
+ addEvent.apply(null, args);
+ });
+ this._events = _events;
+ },
+
+ /**
+ * Removes the event handlers attached previously with addEvents.
+ */
+ removeEvents: function () {
+
+ each(this._events, function (args) {
+ removeEvent.apply(null, args);
+ });
+ this._events = UNDEFINED;
+ if (this.navigatorEnabled && this.baseSeries) {
+ removeEvent(this.baseSeries, 'updatedData', this.updatedDataHandler);
+ }
+ },
+
+ /**
+ * Initiate the Scroller object
+ */
+ init: function () {
+ var scroller = this,
+ chart = scroller.chart,
+ xAxis,
+ yAxis,
+ scrollbarHeight = scroller.scrollbarHeight,
+ navigatorOptions = scroller.navigatorOptions,
+ height = scroller.height,
+ top = scroller.top,
+ dragOffset,
+ hasDragged,
+ baseSeries = scroller.baseSeries;
+
+ /**
+ * Event handler for the mouse down event.
+ */
+ scroller.mouseDownHandler = function (e) {
+ e = chart.pointer.normalize(e);
+
+ var zoomedMin = scroller.zoomedMin,
+ zoomedMax = scroller.zoomedMax,
+ top = scroller.top,
+ scrollbarHeight = scroller.scrollbarHeight,
+ scrollerLeft = scroller.scrollerLeft,
+ scrollerWidth = scroller.scrollerWidth,
+ navigatorLeft = scroller.navigatorLeft,
+ navigatorWidth = scroller.navigatorWidth,
+ scrollbarPad = scroller.scrollbarPad,
+ range = scroller.range,
+ chartX = e.chartX,
+ chartY = e.chartY,
+ baseXAxis = chart.xAxis[0],
+ fixedMax,
+ ext,
+ handleSensitivity = isTouchDevice ? 10 : 7,
+ left,
+ isOnNavigator;
+
+ if (chartY > top && chartY < top + height + scrollbarHeight) { // we're vertically inside the navigator
+ isOnNavigator = !scroller.scrollbarEnabled || chartY < top + height;
+
+ // grab the left handle
+ if (isOnNavigator && math.abs(chartX - zoomedMin - navigatorLeft) < handleSensitivity) {
+ scroller.grabbedLeft = true;
+ scroller.otherHandlePos = zoomedMax;
+ scroller.fixedExtreme = baseXAxis.max;
+ chart.fixedRange = null;
+
+ // grab the right handle
+ } else if (isOnNavigator && math.abs(chartX - zoomedMax - navigatorLeft) < handleSensitivity) {
+ scroller.grabbedRight = true;
+ scroller.otherHandlePos = zoomedMin;
+ scroller.fixedExtreme = baseXAxis.min;
+ chart.fixedRange = null;
+
+ // grab the zoomed range
+ } else if (chartX > navigatorLeft + zoomedMin - scrollbarPad && chartX < navigatorLeft + zoomedMax + scrollbarPad) {
+ scroller.grabbedCenter = chartX;
+ scroller.fixedWidth = range;
+
+ dragOffset = chartX - zoomedMin;
+
+
+ // shift the range by clicking on shaded areas, scrollbar track or scrollbar buttons
+ } else if (chartX > scrollerLeft && chartX < scrollerLeft + scrollerWidth) {
+
+ // Center around the clicked point
+ if (isOnNavigator) {
+ left = chartX - navigatorLeft - range / 2;
+
+ // Click on scrollbar
+ } else {
+
+ // Click left scrollbar button
+ if (chartX < navigatorLeft) {
+ left = zoomedMin - range * 0.2;
+
+ // Click right scrollbar button
+ } else if (chartX > scrollerLeft + scrollerWidth - scrollbarHeight) {
+ left = zoomedMin + range * 0.2;
+
+ // Click on scrollbar track, shift the scrollbar by one range
+ } else {
+ left = chartX < navigatorLeft + zoomedMin ? // on the left
+ zoomedMin - range :
+ zoomedMax;
+ }
+ }
+ if (left < 0) {
+ left = 0;
+ } else if (left + range >= navigatorWidth) {
+ left = navigatorWidth - range;
+ fixedMax = scroller.getUnionExtremes().dataMax; // #2293, #3543
+ }
+ if (left !== zoomedMin) { // it has actually moved
+ scroller.fixedWidth = range; // #1370
+
+ ext = xAxis.toFixedRange(left, left + range, null, fixedMax);
+ baseXAxis.setExtremes(
+ ext.min,
+ ext.max,
+ true,
+ false,
+ { trigger: 'navigator' }
+ );
+ }
+ }
+
+ }
+ };
+
+ /**
+ * Event handler for the mouse move event.
+ */
+ scroller.mouseMoveHandler = function (e) {
+ var scrollbarHeight = scroller.scrollbarHeight,
+ navigatorLeft = scroller.navigatorLeft,
+ navigatorWidth = scroller.navigatorWidth,
+ scrollerLeft = scroller.scrollerLeft,
+ scrollerWidth = scroller.scrollerWidth,
+ range = scroller.range,
+ chartX;
+
+ // In iOS, a mousemove event with e.pageX === 0 is fired when holding the finger
+ // down in the center of the scrollbar. This should be ignored.
+ if (e.pageX !== 0) {
+
+ e = chart.pointer.normalize(e);
+ chartX = e.chartX;
+
+ // validation for handle dragging
+ if (chartX < navigatorLeft) {
+ chartX = navigatorLeft;
+ } else if (chartX > scrollerLeft + scrollerWidth - scrollbarHeight) {
+ chartX = scrollerLeft + scrollerWidth - scrollbarHeight;
+ }
+
+ // drag left handle
+ if (scroller.grabbedLeft) {
+ hasDragged = true;
+ scroller.render(0, 0, chartX - navigatorLeft, scroller.otherHandlePos);
+
+ // drag right handle
+ } else if (scroller.grabbedRight) {
+ hasDragged = true;
+ scroller.render(0, 0, scroller.otherHandlePos, chartX - navigatorLeft);
+
+ // drag scrollbar or open area in navigator
+ } else if (scroller.grabbedCenter) {
+
+ hasDragged = true;
+ if (chartX < dragOffset) { // outside left
+ chartX = dragOffset;
+ } else if (chartX > navigatorWidth + dragOffset - range) { // outside right
+ chartX = navigatorWidth + dragOffset - range;
+ }
+
+ scroller.render(0, 0, chartX - dragOffset, chartX - dragOffset + range);
+
+ }
+ if (hasDragged && scroller.scrollbarOptions.liveRedraw) {
+ setTimeout(function () {
+ scroller.mouseUpHandler(e);
+ }, 0);
+ }
+ }
+ };
+
+ /**
+ * Event handler for the mouse up event.
+ */
+ scroller.mouseUpHandler = function (e) {
+ var ext,
+ fixedMin,
+ fixedMax;
+
+ if (hasDragged) {
+ // When dragging one handle, make sure the other one doesn't change
+ if (scroller.zoomedMin === scroller.otherHandlePos) {
+ fixedMin = scroller.fixedExtreme;
+ } else if (scroller.zoomedMax === scroller.otherHandlePos) {
+ fixedMax = scroller.fixedExtreme;
+ }
+
+ ext = xAxis.toFixedRange(scroller.zoomedMin, scroller.zoomedMax, fixedMin, fixedMax);
+ chart.xAxis[0].setExtremes(
+ ext.min,
+ ext.max,
+ true,
+ false,
+ {
+ trigger: 'navigator',
+ triggerOp: 'navigator-drag',
+ DOMEvent: e // #1838
+ }
+ );
+ }
+
+ if (e.type !== 'mousemove') {
+ scroller.grabbedLeft = scroller.grabbedRight = scroller.grabbedCenter = scroller.fixedWidth =
+ scroller.fixedExtreme = scroller.otherHandlePos = hasDragged = dragOffset = null;
+ }
+
+ };
+
+
+
+ var xAxisIndex = chart.xAxis.length,
+ yAxisIndex = chart.yAxis.length;
+
+ // make room below the chart
+ chart.extraBottomMargin = scroller.outlineHeight + navigatorOptions.margin;
+
+ if (scroller.navigatorEnabled) {
+ // an x axis is required for scrollbar also
+ scroller.xAxis = xAxis = new Axis(chart, merge({
+ // inherit base xAxis' break and ordinal options
+ breaks: baseSeries && baseSeries.xAxis.options.breaks,
+ ordinal: baseSeries && baseSeries.xAxis.options.ordinal
+ }, navigatorOptions.xAxis, {
+ id: 'navigator-x-axis',
+ isX: true,
+ type: 'datetime',
+ index: xAxisIndex,
+ height: height,
+ offset: 0,
+ offsetLeft: scrollbarHeight,
+ offsetRight: -scrollbarHeight,
+ keepOrdinalPadding: true, // #2436
+ startOnTick: false,
+ endOnTick: false,
+ minPadding: 0,
+ maxPadding: 0,
+ zoomEnabled: false
+ }));
+
+ scroller.yAxis = yAxis = new Axis(chart, merge(navigatorOptions.yAxis, {
+ id: 'navigator-y-axis',
+ alignTicks: false,
+ height: height,
+ offset: 0,
+ index: yAxisIndex,
+ zoomEnabled: false
+ }));
+
+ // If we have a base series, initialize the navigator series
+ if (baseSeries || navigatorOptions.series.data) {
+ scroller.addBaseSeries();
+
+ // If not, set up an event to listen for added series
+ } else if (chart.series.length === 0) {
+
+ wrap(chart, 'redraw', function (proceed, animation) {
+ // We've got one, now add it as base and reset chart.redraw
+ if (chart.series.length > 0 && !scroller.series) {
+ scroller.setBaseSeries();
+ chart.redraw = proceed; // reset
+ }
+ proceed.call(chart, animation);
+ });
+ }
+
+
+ // in case of scrollbar only, fake an x axis to get translation
+ } else {
+ scroller.xAxis = xAxis = {
+ translate: function (value, reverse) {
+ var axis = chart.xAxis[0],
+ ext = axis.getExtremes(),
+ scrollTrackWidth = chart.plotWidth - 2 * scrollbarHeight,
+ min = numExt('min', axis.options.min, ext.dataMin),
+ valueRange = numExt('max', axis.options.max, ext.dataMax) - min;
+
+ return reverse ?
+ // from pixel to value
+ (value * valueRange / scrollTrackWidth) + min :
+ // from value to pixel
+ scrollTrackWidth * (value - min) / valueRange;
+ },
+ toFixedRange: Axis.prototype.toFixedRange
+ };
+ }
+
+
+ /**
+ * For stock charts, extend the Chart.getMargins method so that we can set the final top position
+ * of the navigator once the height of the chart, including the legend, is determined. #367.
+ */
+ wrap(chart, 'getMargins', function (proceed) {
+
+ var legend = this.legend,
+ legendOptions = legend.options;
+
+ proceed.apply(this, [].slice.call(arguments, 1));
+
+ // Compute the top position
+ scroller.top = top = scroller.navigatorOptions.top ||
+ this.chartHeight - scroller.height - scroller.scrollbarHeight - this.spacing[2] -
+ (legendOptions.verticalAlign === 'bottom' && legendOptions.enabled && !legendOptions.floating ?
+ legend.legendHeight + pick(legendOptions.margin, 10) : 0);
+
+ if (xAxis && yAxis) { // false if navigator is disabled (#904)
+
+ xAxis.options.top = yAxis.options.top = top;
+
+ xAxis.setAxisSize();
+ yAxis.setAxisSize();
+ }
+ });
+
+
+ scroller.addEvents();
+ },
+
+ /**
+ * Get the union data extremes of the chart - the outer data extremes of the base
+ * X axis and the navigator axis.
+ */
+ getUnionExtremes: function (returnFalseOnNoBaseSeries) {
+ var baseAxis = this.chart.xAxis[0],
+ navAxis = this.xAxis,
+ navAxisOptions = navAxis.options,
+ baseAxisOptions = baseAxis.options,
+ ret;
+
+ if (!returnFalseOnNoBaseSeries || baseAxis.dataMin !== null) {
+ ret = {
+ dataMin: pick( // #4053
+ navAxisOptions && navAxisOptions.min,
+ numExt(
+ 'min',
+ baseAxisOptions.min,
+ baseAxis.dataMin,
+ navAxis.dataMin
+ )
+ ),
+ dataMax: pick(
+ navAxisOptions && navAxisOptions.max,
+ numExt(
+ 'max',
+ baseAxisOptions.max,
+ baseAxis.dataMax,
+ navAxis.dataMax
+ )
+ )
+ };
+ }
+ return ret;
+ },
+
+ /**
+ * Set the base series. With a bit of modification we should be able to make
+ * this an API method to be called from the outside
+ */
+ setBaseSeries: function (baseSeriesOption) {
+ var chart = this.chart;
+
+ baseSeriesOption = baseSeriesOption || chart.options.navigator.baseSeries;
+
+ // If we're resetting, remove the existing series
+ if (this.series) {
+ this.series.remove();
+ }
+
+ // Set the new base series
+ this.baseSeries = chart.series[baseSeriesOption] ||
+ (typeof baseSeriesOption === 'string' && chart.get(baseSeriesOption)) ||
+ chart.series[0];
+
+ // When run after render, this.xAxis already exists
+ if (this.xAxis) {
+ this.addBaseSeries();
+ }
+ },
+
+ addBaseSeries: function () {
+ var baseSeries = this.baseSeries,
+ baseOptions = baseSeries ? baseSeries.options : {},
+ baseData = baseOptions.data,
+ mergedNavSeriesOptions,
+ navigatorSeriesOptions = this.navigatorOptions.series,
+ navigatorData;
+
+ // remove it to prevent merging one by one
+ navigatorData = navigatorSeriesOptions.data;
+ this.hasNavigatorData = !!navigatorData;
+
+ // Merge the series options
+ mergedNavSeriesOptions = merge(baseOptions, navigatorSeriesOptions, {
+ enableMouseTracking: false,
+ group: 'nav', // for columns
+ padXAxis: false,
+ xAxis: 'navigator-x-axis',
+ yAxis: 'navigator-y-axis',
+ name: 'Navigator',
+ showInLegend: false,
+ isInternal: true,
+ visible: true
+ });
+
+ // set the data back
+ mergedNavSeriesOptions.data = navigatorData || baseData;
+
+ // add the series
+ this.series = this.chart.initSeries(mergedNavSeriesOptions);
+
+ // Respond to updated data in the base series.
+ // Abort if lazy-loading data from the server.
+ if (baseSeries && this.navigatorOptions.adaptToUpdatedData !== false) {
+ addEvent(baseSeries, 'updatedData', this.updatedDataHandler);
+ // Survive Series.update()
+ baseSeries.userOptions.events = extend(baseSeries.userOptions.event, { updatedData: this.updatedDataHandler });
+
+ }
+ },
+
+ updatedDataHandler: function () {
+ var scroller = this.chart.scroller,
+ baseSeries = scroller.baseSeries,
+ baseXAxis = baseSeries.xAxis,
+ baseExtremes = baseXAxis.getExtremes(),
+ baseMin = baseExtremes.min,
+ baseMax = baseExtremes.max,
+ baseDataMin = baseExtremes.dataMin,
+ baseDataMax = baseExtremes.dataMax,
+ range = baseMax - baseMin,
+ stickToMin,
+ stickToMax,
+ newMax,
+ newMin,
+ doRedraw,
+ navigatorSeries = scroller.series,
+ navXData = navigatorSeries.xData,
+ hasSetExtremes = !!baseXAxis.setExtremes;
+
+ // detect whether to move the range
+ stickToMax = baseMax >= navXData[navXData.length - 1] - (this.closestPointRange || 0); // #570
+ stickToMin = baseMin <= baseDataMin;
+
+ // set the navigator series data to the new data of the base series
+ if (!scroller.hasNavigatorData) {
+ navigatorSeries.options.pointStart = baseSeries.xData[0];
+ navigatorSeries.setData(baseSeries.options.data, false);
+ doRedraw = true;
+ }
+
+ // if the zoomed range is already at the min, move it to the right as new data
+ // comes in
+ if (stickToMin) {
+ newMin = baseDataMin;
+ newMax = newMin + range;
+ }
+
+ // if the zoomed range is already at the max, move it to the right as new data
+ // comes in
+ if (stickToMax) {
+ newMax = baseDataMax;
+ if (!stickToMin) { // if stickToMin is true, the new min value is set above
+ newMin = mathMax(newMax - range, navigatorSeries.xData[0]);
+ }
+ }
+
+ // update the extremes
+ if (hasSetExtremes && (stickToMin || stickToMax)) {
+ if (!isNaN(newMin)) {
+ baseXAxis.setExtremes(newMin, newMax, true, false, { trigger: 'updatedData' });
+ }
+
+ // if it is not at any edge, just move the scroller window to reflect the new series data
+ } else {
+ if (doRedraw) {
+ this.chart.redraw(false);
+ }
+
+ scroller.render(
+ mathMax(baseMin, baseDataMin),
+ mathMin(baseMax, baseDataMax)
+ );
+ }
+ },
+
+ /**
+ * Destroys allocated elements.
+ */
+ destroy: function () {
+ var scroller = this;
+
+ // Disconnect events added in addEvents
+ scroller.removeEvents();
+
+ // Destroy properties
+ each([scroller.xAxis, scroller.yAxis, scroller.leftShade, scroller.rightShade, scroller.outline, scroller.scrollbarTrack, scroller.scrollbarRifles, scroller.scrollbarGroup, scroller.scrollbar], function (prop) {
+ if (prop && prop.destroy) {
+ prop.destroy();
+ }
+ });
+ scroller.xAxis = scroller.yAxis = scroller.leftShade = scroller.rightShade = scroller.outline = scroller.scrollbarTrack = scroller.scrollbarRifles = scroller.scrollbarGroup = scroller.scrollbar = null;
+
+ // Destroy elements in collection
+ each([scroller.scrollbarButtons, scroller.handles, scroller.elementsToDestroy], function (coll) {
+ destroyObjectProperties(coll);
+ });
+ }
+};
+
+Highcharts.Scroller = Scroller;
+
+
+/**
+ * For Stock charts, override selection zooming with some special features because
+ * X axis zooming is already allowed by the Navigator and Range selector.
+ */
+wrap(Axis.prototype, 'zoom', function (proceed, newMin, newMax) {
+ var chart = this.chart,
+ chartOptions = chart.options,
+ zoomType = chartOptions.chart.zoomType,
+ previousZoom,
+ navigator = chartOptions.navigator,
+ rangeSelector = chartOptions.rangeSelector,
+ ret;
+
+ if (this.isXAxis && ((navigator && navigator.enabled) ||
+ (rangeSelector && rangeSelector.enabled))) {
+
+ // For x only zooming, fool the chart.zoom method not to create the zoom button
+ // because the property already exists
+ if (zoomType === 'x') {
+ chart.resetZoomButton = 'blocked';
+
+ // For y only zooming, ignore the X axis completely
+ } else if (zoomType === 'y') {
+ ret = false;
+
+ // For xy zooming, record the state of the zoom before zoom selection, then when
+ // the reset button is pressed, revert to this state
+ } else if (zoomType === 'xy') {
+ previousZoom = this.previousZoom;
+ if (defined(newMin)) {
+ this.previousZoom = [this.min, this.max];
+ } else if (previousZoom) {
+ newMin = previousZoom[0];
+ newMax = previousZoom[1];
+ delete this.previousZoom;
+ }
+ }
+
+ }
+ return ret !== UNDEFINED ? ret : proceed.call(this, newMin, newMax);
+});
+
+// Initialize scroller for stock charts
+wrap(Chart.prototype, 'init', function (proceed, options, callback) {
+
+ addEvent(this, 'beforeRender', function () {
+ var options = this.options;
+ if (options.navigator.enabled || options.scrollbar.enabled) {
+ this.scroller = new Scroller(this);
+ }
+ });
+
+ proceed.call(this, options, callback);
+
+});
+
+// Pick up badly formatted point options to addPoint
+wrap(Series.prototype, 'addPoint', function (proceed, options, redraw, shift, animation) {
+ var turboThreshold = this.options.turboThreshold;
+ if (turboThreshold && this.xData.length > turboThreshold && isObject(options) && !isArray(options) && this.chart.scroller) {
+ error(20, true);
+ }
+ proceed.call(this, options, redraw, shift, animation);
+});
+
+/* ****************************************************************************
+ * End Scroller code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start Range Selector code *
+ *****************************************************************************/
+extend(defaultOptions, {
+ rangeSelector: {
+ // allButtonsEnabled: false,
+ // enabled: true,
+ // buttons: {Object}
+ // buttonSpacing: 0,
+ buttonTheme: {
+ width: 28,
+ height: 18,
+ fill: '#f7f7f7',
+ padding: 2,
+ r: 0,
+ 'stroke-width': 0,
+ style: {
+ color: '#444',
+ cursor: 'pointer',
+ fontWeight: 'normal'
+ },
+ zIndex: 7, // #484, #852
+ states: {
+ hover: {
+ fill: '#e7e7e7'
+ },
+ select: {
+ fill: '#e7f0f9',
+ style: {
+ color: 'black',
+ fontWeight: 'bold'
+ }
+ }
+ }
+ },
+ height: 35, // reserved space for buttons and input
+ inputPosition: {
+ align: 'right'
+ },
+ // inputDateFormat: '%b %e, %Y',
+ // inputEditDateFormat: '%Y-%m-%d',
+ // inputEnabled: true,
+ // inputStyle: {},
+ labelStyle: {
+ color: '#666'
+ }
+ // selected: undefined
+ }
+});
+defaultOptions.lang = merge(defaultOptions.lang, {
+ rangeSelectorZoom: 'Zoom',
+ rangeSelectorFrom: 'From',
+ rangeSelectorTo: 'To'
+});
+
+/**
+ * The object constructor for the range selector
+ * @param {Object} chart
+ */
+function RangeSelector(chart) {
+
+ // Run RangeSelector
+ this.init(chart);
+}
+
+RangeSelector.prototype = {
+ /**
+ * The method to run when one of the buttons in the range selectors is clicked
+ * @param {Number} i The index of the button
+ * @param {Object} rangeOptions
+ * @param {Boolean} redraw
+ */
+ clickButton: function (i, redraw) {
+ var rangeSelector = this,
+ selected = rangeSelector.selected,
+ chart = rangeSelector.chart,
+ buttons = rangeSelector.buttons,
+ rangeOptions = rangeSelector.buttonOptions[i],
+ baseAxis = chart.xAxis[0],
+ unionExtremes = (chart.scroller && chart.scroller.getUnionExtremes()) || baseAxis || {},
+ dataMin = unionExtremes.dataMin,
+ dataMax = unionExtremes.dataMax,
+ newMin,
+ newMax = baseAxis && mathRound(mathMin(baseAxis.max, pick(dataMax, baseAxis.max))), // #1568
+ now,
+ type = rangeOptions.type,
+ baseXAxisOptions,
+ range = rangeOptions._range,
+ rangeMin,
+ year,
+ minSetting,
+ rangeSetting,
+ ctx,
+ dataGrouping = rangeOptions.dataGrouping;
+
+ if (dataMin === null || dataMax === null || // chart has no data, base series is removed
+ i === rangeSelector.selected) { // same button is clicked twice
+ return;
+ }
+
+ // Set the fixed range before range is altered
+ chart.fixedRange = range;
+
+ // Apply dataGrouping associated to button
+ if (dataGrouping) {
+ this.forcedDataGrouping = true;
+ Axis.prototype.setDataGrouping.call(baseAxis || { chart: this.chart }, dataGrouping, false);
+ }
+
+ // Apply range
+ if (type === 'month' || type === 'year') {
+ if (!baseAxis) {
+ // This is set to the user options and picked up later when the axis is instantiated
+ // so that we know the min and max.
+ range = rangeOptions;
+ } else {
+ ctx = {
+ range: rangeOptions,
+ max: newMax,
+ dataMin: dataMin,
+ dataMax: dataMax
+ };
+ newMin = baseAxis.minFromRange.call(ctx);
+ if (typeof ctx.newMax === 'number') {
+ newMax = ctx.newMax;
+ }
+ }
+
+ // Fixed times like minutes, hours, days
+ } else if (range) {
+ newMin = mathMax(newMax - range, dataMin);
+ newMax = mathMin(newMin + range, dataMax);
+
+ } else if (type === 'ytd') {
+
+ // On user clicks on the buttons, or a delayed action running from the beforeRender
+ // event (below), the baseAxis is defined.
+ if (baseAxis) {
+
+ // When "ytd" is the pre-selected button for the initial view, its calculation
+ // is delayed and rerun in the beforeRender event (below). When the series
+ // are initialized, but before the chart is rendered, we have access to the xData
+ // array (#942).
+ if (dataMax === UNDEFINED) {
+ dataMin = Number.MAX_VALUE;
+ dataMax = Number.MIN_VALUE;
+ each(chart.series, function (series) {
+ var xData = series.xData; // reassign it to the last item
+ dataMin = mathMin(xData[0], dataMin);
+ dataMax = mathMax(xData[xData.length - 1], dataMax);
+ });
+ redraw = false;
+ }
+ now = new Date(dataMax);
+ year = now.getFullYear();
+ newMin = rangeMin = mathMax(dataMin || 0, Date.UTC(year, 0, 1));
+ now = now.getTime();
+ newMax = mathMin(dataMax || now, now);
+
+ // "ytd" is pre-selected. We don't yet have access to processed point and extremes data
+ // (things like pointStart and pointInterval are missing), so we delay the process (#942)
+ } else {
+ addEvent(chart, 'beforeRender', function () {
+ rangeSelector.clickButton(i);
+ });
+ return;
+ }
+ } else if (type === 'all' && baseAxis) {
+ newMin = dataMin;
+ newMax = dataMax;
+ }
+
+ // Deselect previous button
+ if (buttons[selected]) {
+ buttons[selected].setState(0);
+ }
+ // Select this button
+ if (buttons[i]) {
+ buttons[i].setState(2);
+ }
+
+ // Update the chart
+ if (!baseAxis) {
+ // Axis not yet instanciated. Temporarily set min and range
+ // options and remove them on chart load (#4317).
+ baseXAxisOptions = chart.options.xAxis[0];
+ rangeSetting = baseXAxisOptions.range;
+ baseXAxisOptions.range = range;
+ minSetting = baseXAxisOptions.min;
+ baseXAxisOptions.min = rangeMin;
+ rangeSelector.setSelected(i);
+ addEvent(chart, 'load', function resetMinAndRange() {
+ baseXAxisOptions.range = rangeSetting;
+ baseXAxisOptions.min = minSetting;
+ });
+ } else {
+ // Existing axis object. Set extremes after render time.
+ baseAxis.setExtremes(
+ newMin,
+ newMax,
+ pick(redraw, 1),
+ 0,
+ {
+ trigger: 'rangeSelectorButton',
+ rangeSelectorButton: rangeOptions
+ }
+ );
+ rangeSelector.setSelected(i);
+ }
+ },
+
+ /**
+ * Set the selected option. This method only sets the internal flag, it doesn't
+ * update the buttons or the actual zoomed range.
+ */
+ setSelected: function (selected) {
+ this.selected = this.options.selected = selected;
+ },
+
+ /**
+ * The default buttons for pre-selecting time frames
+ */
+ defaultButtons: [{
+ type: 'month',
+ count: 1,
+ text: '1m'
+ }, {
+ type: 'month',
+ count: 3,
+ text: '3m'
+ }, {
+ type: 'month',
+ count: 6,
+ text: '6m'
+ }, {
+ type: 'ytd',
+ text: 'YTD'
+ }, {
+ type: 'year',
+ count: 1,
+ text: '1y'
+ }, {
+ type: 'all',
+ text: 'All'
+ }],
+
+ /**
+ * Initialize the range selector
+ */
+ init: function (chart) {
+
+ var rangeSelector = this,
+ options = chart.options.rangeSelector,
+ buttonOptions = options.buttons || [].concat(rangeSelector.defaultButtons),
+ selectedOption = options.selected,
+ blurInputs = rangeSelector.blurInputs = function () {
+ var minInput = rangeSelector.minInput,
+ maxInput = rangeSelector.maxInput;
+ if (minInput && minInput.blur) { //#3274 in some case blur is not defined
+ fireEvent(minInput, 'blur'); //#3274
+ }
+ if (maxInput && maxInput.blur) { //#3274 in some case blur is not defined
+ fireEvent(maxInput, 'blur'); //#3274
+ }
+ };
+
+ rangeSelector.chart = chart;
+ rangeSelector.options = options;
+ rangeSelector.buttons = [];
+
+ chart.extraTopMargin = options.height;
+ rangeSelector.buttonOptions = buttonOptions;
+
+ addEvent(chart.container, 'mousedown', blurInputs);
+ addEvent(chart, 'resize', blurInputs);
+
+ // Extend the buttonOptions with actual range
+ each(buttonOptions, rangeSelector.computeButtonRange);
+
+ // zoomed range based on a pre-selected button index
+ if (selectedOption !== UNDEFINED && buttonOptions[selectedOption]) {
+ this.clickButton(selectedOption, false);
+ }
+
+
+ addEvent(chart, 'load', function () {
+ // If a data grouping is applied to the current button, release it when extremes change
+ addEvent(chart.xAxis[0], 'setExtremes', function (e) {
+ if (this.max - this.min !== chart.fixedRange && e.trigger !== 'rangeSelectorButton' &&
+ e.trigger !== 'updatedData' && rangeSelector.forcedDataGrouping) {
+ this.setDataGrouping(false, false);
+ }
+ });
+ // Normalize the pressed button whenever a new range is selected
+ addEvent(chart.xAxis[0], 'afterSetExtremes', function () {
+ rangeSelector.updateButtonStates(true);
+ });
+ });
+ },
+
+ /**
+ * Dynamically update the range selector buttons after a new range has been set
+ */
+ updateButtonStates: function (updating) {
+ var rangeSelector = this,
+ chart = this.chart,
+ baseAxis = chart.xAxis[0],
+ unionExtremes = (chart.scroller && chart.scroller.getUnionExtremes()) || baseAxis,
+ dataMin = unionExtremes.dataMin,
+ dataMax = unionExtremes.dataMax,
+ selected = rangeSelector.selected,
+ allButtonsEnabled = rangeSelector.options.allButtonsEnabled,
+ buttons = rangeSelector.buttons;
+
+ if (updating && chart.fixedRange !== mathRound(baseAxis.max - baseAxis.min)) {
+ if (buttons[selected]) {
+ buttons[selected].setState(0);
+ }
+ rangeSelector.setSelected(null);
+ }
+
+ each(rangeSelector.buttonOptions, function (rangeOptions, i) {
+ var actualRange = mathRound(baseAxis.max - baseAxis.min),
+ range = rangeOptions._range,
+ type = rangeOptions.type,
+ count = rangeOptions.count || 1,
+ // Disable buttons where the range exceeds what is allowed in the current view
+ isTooGreatRange = range > dataMax - dataMin,
+ // Disable buttons where the range is smaller than the minimum range
+ isTooSmallRange = range < baseAxis.minRange,
+ // Disable the All button if we're already showing all
+ isAllButAlreadyShowingAll = rangeOptions.type === 'all' && baseAxis.max - baseAxis.min >= dataMax - dataMin &&
+ buttons[i].state !== 2,
+ // Disable the YTD button if the complete range is within the same year
+ isYTDButNotAvailable = rangeOptions.type === 'ytd' && dateFormat('%Y', dataMin) === dateFormat('%Y', dataMax),
+ // Set a button on export
+ isSelectedForExport = chart.renderer.forExport && i === selected,
+
+ isSameRange = range === actualRange;
+
+ // Months and years have a variable range so we check the extremes
+ if ((type === 'month' || type === 'year') && (actualRange >= { month: 28, year: 365 }[type] * 24 * 36e5 * count) &&
+ (actualRange <= { month: 31, year: 366 }[type] * 24 * 36e5 * count)) {
+ isSameRange = true;
+ }
+ // The new zoom area happens to match the range for a button - mark it selected.
+ // This happens when scrolling across an ordinal gap. It can be seen in the intraday
+ // demos when selecting 1h and scroll across the night gap.
+ if (isSelectedForExport || (isSameRange && i !== selected)) {
+ rangeSelector.setSelected(i);
+ buttons[i].setState(2);
+
+ } else if (!allButtonsEnabled && (isTooGreatRange || isTooSmallRange || isAllButAlreadyShowingAll || isYTDButNotAvailable)) {
+ buttons[i].setState(3);
+
+ } else if (buttons[i].state === 3) {
+ buttons[i].setState(0);
+ }
+ });
+ },
+
+ /**
+ * Compute and cache the range for an individual button
+ */
+ computeButtonRange: function (rangeOptions) {
+ var type = rangeOptions.type,
+ count = rangeOptions.count || 1,
+
+ // these time intervals have a fixed number of milliseconds, as opposed
+ // to month, ytd and year
+ fixedTimes = {
+ millisecond: 1,
+ second: 1000,
+ minute: 60 * 1000,
+ hour: 3600 * 1000,
+ day: 24 * 3600 * 1000,
+ week: 7 * 24 * 3600 * 1000
+ };
+
+ // Store the range on the button object
+ if (fixedTimes[type]) {
+ rangeOptions._range = fixedTimes[type] * count;
+ } else if (type === 'month' || type === 'year') {
+ rangeOptions._range = { month: 30, year: 365 }[type] * 24 * 36e5 * count;
+ }
+ },
+
+ /**
+ * Set the internal and displayed value of a HTML input for the dates
+ * @param {String} name
+ * @param {Number} time
+ */
+ setInputValue: function (name, time) {
+ var options = this.chart.options.rangeSelector;
+
+ if (defined(time)) {
+ this[name + 'Input'].HCTime = time;
+ }
+
+ this[name + 'Input'].value = dateFormat(options.inputEditDateFormat || '%Y-%m-%d', this[name + 'Input'].HCTime);
+ this[name + 'DateBox'].attr({ text: dateFormat(options.inputDateFormat || '%b %e, %Y', this[name + 'Input'].HCTime) });
+ },
+
+ showInput: function (name) {
+ var inputGroup = this.inputGroup,
+ dateBox = this[name + 'DateBox'];
+
+ css(this[name + 'Input'], {
+ left: (inputGroup.translateX + dateBox.x) + PX,
+ top: inputGroup.translateY + PX,
+ width: (dateBox.width - 2) + PX,
+ height: (dateBox.height - 2) + PX,
+ border: '2px solid silver'
+ });
+ },
+
+ hideInput: function (name) {
+ css(this[name + 'Input'], {
+ border: 0,
+ width: '1px',
+ height: '1px'
+ });
+ this.setInputValue(name);
+ },
+
+ /**
+ * Draw either the 'from' or the 'to' HTML input box of the range selector
+ * @param {Object} name
+ */
+ drawInput: function (name) {
+ var rangeSelector = this,
+ chart = rangeSelector.chart,
+ chartStyle = chart.renderer.style,
+ renderer = chart.renderer,
+ options = chart.options.rangeSelector,
+ lang = defaultOptions.lang,
+ div = rangeSelector.div,
+ isMin = name === 'min',
+ input,
+ label,
+ dateBox,
+ inputGroup = this.inputGroup;
+
+ // Create the text label
+ this[name + 'Label'] = label = renderer.label(lang[isMin ? 'rangeSelectorFrom' : 'rangeSelectorTo'], this.inputGroup.offset)
+ .attr({
+ padding: 2
+ })
+ .css(merge(chartStyle, options.labelStyle))
+ .add(inputGroup);
+ inputGroup.offset += label.width + 5;
+
+ // Create an SVG label that shows updated date ranges and and records click events that
+ // bring in the HTML input.
+ this[name + 'DateBox'] = dateBox = renderer.label('', inputGroup.offset)
+ .attr({
+ padding: 2,
+ width: options.inputBoxWidth || 90,
+ height: options.inputBoxHeight || 17,
+ stroke: options.inputBoxBorderColor || 'silver',
+ 'stroke-width': 1
+ })
+ .css(merge({
+ textAlign: 'center',
+ color: '#444'
+ }, chartStyle, options.inputStyle))
+ .on('click', function () {
+ rangeSelector.showInput(name); // If it is already focused, the onfocus event doesn't fire (#3713)
+ rangeSelector[name + 'Input'].focus();
+ })
+ .add(inputGroup);
+ inputGroup.offset += dateBox.width + (isMin ? 10 : 0);
+
+
+ // Create the HTML input element. This is rendered as 1x1 pixel then set to the right size
+ // when focused.
+ this[name + 'Input'] = input = createElement('input', {
+ name: name,
+ className: PREFIX + 'range-selector',
+ type: 'text'
+ }, extend({
+ position: ABSOLUTE,
+ border: 0,
+ width: '1px', // Chrome needs a pixel to see it
+ height: '1px',
+ padding: 0,
+ textAlign: 'center',
+ fontSize: chartStyle.fontSize,
+ fontFamily: chartStyle.fontFamily,
+ top: chart.plotTop + PX // prevent jump on focus in Firefox
+ }, options.inputStyle), div);
+
+ // Blow up the input box
+ input.onfocus = function () {
+ rangeSelector.showInput(name);
+ };
+ // Hide away the input box
+ input.onblur = function () {
+ rangeSelector.hideInput(name);
+ };
+
+ // handle changes in the input boxes
+ input.onchange = function () {
+ var inputValue = input.value,
+ value = (options.inputDateParser || Date.parse)(inputValue),
+ xAxis = chart.xAxis[0],
+ dataMin = xAxis.dataMin,
+ dataMax = xAxis.dataMax;
+
+ // If the value isn't parsed directly to a value by the browser's Date.parse method,
+ // like YYYY-MM-DD in IE, try parsing it a different way
+ if (isNaN(value)) {
+ value = inputValue.split('-');
+ value = Date.UTC(pInt(value[0]), pInt(value[1]) - 1, pInt(value[2]));
+ }
+
+ if (!isNaN(value)) {
+
+ // Correct for timezone offset (#433)
+ if (!defaultOptions.global.useUTC) {
+ value = value + new Date().getTimezoneOffset() * 60 * 1000;
+ }
+
+ // Validate the extremes. If it goes beyound the data min or max, use the
+ // actual data extreme (#2438).
+ if (isMin) {
+ if (value > rangeSelector.maxInput.HCTime) {
+ value = UNDEFINED;
+ } else if (value < dataMin) {
+ value = dataMin;
+ }
+ } else {
+ if (value < rangeSelector.minInput.HCTime) {
+ value = UNDEFINED;
+ } else if (value > dataMax) {
+ value = dataMax;
+ }
+ }
+
+ // Set the extremes
+ if (value !== UNDEFINED) {
+ chart.xAxis[0].setExtremes(
+ isMin ? value : xAxis.min,
+ isMin ? xAxis.max : value,
+ UNDEFINED,
+ UNDEFINED,
+ { trigger: 'rangeSelectorInput' }
+ );
+ }
+ }
+ };
+ },
+
+ /**
+ * Get the position of the range selector buttons and inputs. This can be overridden from outside for custom positioning.
+ */
+ getPosition: function () {
+ var chart = this.chart,
+ options = chart.options.rangeSelector,
+ buttonTop = pick((options.buttonPosition || {}).y, chart.plotTop - chart.axisOffset[0] - options.height);
+
+ return {
+ buttonTop: buttonTop,
+ inputTop: buttonTop - 10
+ };
+ },
+
+ /**
+ * Render the range selector including the buttons and the inputs. The first time render
+ * is called, the elements are created and positioned. On subsequent calls, they are
+ * moved and updated.
+ * @param {Number} min X axis minimum
+ * @param {Number} max X axis maximum
+ */
+ render: function (min, max) {
+
+ var rangeSelector = this,
+ chart = rangeSelector.chart,
+ renderer = chart.renderer,
+ container = chart.container,
+ chartOptions = chart.options,
+ navButtonOptions = chartOptions.exporting && chartOptions.navigation && chartOptions.navigation.buttonOptions,
+ options = chartOptions.rangeSelector,
+ buttons = rangeSelector.buttons,
+ lang = defaultOptions.lang,
+ div = rangeSelector.div,
+ inputGroup = rangeSelector.inputGroup,
+ buttonTheme = options.buttonTheme,
+ buttonPosition = options.buttonPosition || {},
+ inputEnabled = options.inputEnabled,
+ states = buttonTheme && buttonTheme.states,
+ plotLeft = chart.plotLeft,
+ buttonLeft,
+ pos = this.getPosition(),
+ buttonGroup = rangeSelector.group,
+ buttonBBox,
+ rendered = rangeSelector.rendered;
+
+
+ // create the elements
+ if (!rendered) {
+
+ rangeSelector.group = buttonGroup = renderer.g('range-selector-buttons').add();
+
+ rangeSelector.zoomText = renderer.text(lang.rangeSelectorZoom, pick(buttonPosition.x, plotLeft), 15)
+ .css(options.labelStyle)
+ .add(buttonGroup);
+
+ // button starting position
+ buttonLeft = pick(buttonPosition.x, plotLeft) + rangeSelector.zoomText.getBBox().width + 5;
+
+ each(rangeSelector.buttonOptions, function (rangeOptions, i) {
+ buttons[i] = renderer.button(
+ rangeOptions.text,
+ buttonLeft,
+ 0,
+ function () {
+ rangeSelector.clickButton(i);
+ rangeSelector.isActive = true;
+ },
+ buttonTheme,
+ states && states.hover,
+ states && states.select,
+ states && states.disabled
+ )
+ .css({
+ textAlign: 'center'
+ })
+ .add(buttonGroup);
+
+ // increase button position for the next button
+ buttonLeft += buttons[i].width + pick(options.buttonSpacing, 5);
+
+ if (rangeSelector.selected === i) {
+ buttons[i].setState(2);
+ }
+ });
+
+ rangeSelector.updateButtonStates();
+
+ // first create a wrapper outside the container in order to make
+ // the inputs work and make export correct
+ if (inputEnabled !== false) {
+ rangeSelector.div = div = createElement('div', null, {
+ position: 'relative',
+ height: 0,
+ zIndex: 1 // above container
+ });
+
+ container.parentNode.insertBefore(div, container);
+
+ // Create the group to keep the inputs
+ rangeSelector.inputGroup = inputGroup = renderer.g('input-group')
+ .add();
+ inputGroup.offset = 0;
+
+ rangeSelector.drawInput('min');
+ rangeSelector.drawInput('max');
+ }
+ }
+
+ // Set or update the group position
+ buttonGroup[rendered ? 'animate' : 'attr']({
+ translateY: pos.buttonTop
+ });
+
+ if (inputEnabled !== false) {
+
+ // Update the alignment to the updated spacing box
+ inputGroup.align(extend({
+ y: pos.inputTop,
+ width: inputGroup.offset,
+ // Detect collision with the exporting buttons
+ x: navButtonOptions && (pos.inputTop < (navButtonOptions.y || 0) + navButtonOptions.height - chart.spacing[0]) ?
+ -40 : 0
+ }, options.inputPosition), true, chart.spacingBox);
+
+ // Hide if overlapping - inputEnabled is null or undefined
+ if (!defined(inputEnabled)) {
+ buttonBBox = buttonGroup.getBBox();
+ inputGroup[inputGroup.translateX < buttonBBox.x + buttonBBox.width + 10 ? 'hide' : 'show']();
+ }
+
+ // Set or reset the input values
+ rangeSelector.setInputValue('min', min);
+ rangeSelector.setInputValue('max', max);
+ }
+
+ rangeSelector.rendered = true;
+ },
+
+ /**
+ * Destroys allocated elements.
+ */
+ destroy: function () {
+ var minInput = this.minInput,
+ maxInput = this.maxInput,
+ chart = this.chart,
+ blurInputs = this.blurInputs,
+ key;
+
+ removeEvent(chart.container, 'mousedown', blurInputs);
+ removeEvent(chart, 'resize', blurInputs);
+
+ // Destroy elements in collections
+ destroyObjectProperties(this.buttons);
+
+ // Clear input element events
+ if (minInput) {
+ minInput.onfocus = minInput.onblur = minInput.onchange = null;
+ }
+ if (maxInput) {
+ maxInput.onfocus = maxInput.onblur = maxInput.onchange = null;
+ }
+
+ // Destroy HTML and SVG elements
+ for (key in this) {
+ if (this[key] && key !== 'chart') {
+ if (this[key].destroy) { // SVGElement
+ this[key].destroy();
+ } else if (this[key].nodeType) { // HTML element
+ discardElement(this[key]);
+ }
+ }
+ this[key] = null;
+ }
+ }
+};
+
+/**
+ * Add logic to normalize the zoomed range in order to preserve the pressed state of range selector buttons
+ */
+Axis.prototype.toFixedRange = function (pxMin, pxMax, fixedMin, fixedMax) {
+ var fixedRange = this.chart && this.chart.fixedRange,
+ newMin = pick(fixedMin, this.translate(pxMin, true)),
+ newMax = pick(fixedMax, this.translate(pxMax, true)),
+ changeRatio = fixedRange && (newMax - newMin) / fixedRange;
+
+ // If the difference between the fixed range and the actual requested range is
+ // too great, the user is dragging across an ordinal gap, and we need to release
+ // the range selector button.
+ if (changeRatio > 0.7 && changeRatio < 1.3) {
+ if (fixedMax) {
+ newMin = newMax - fixedRange;
+ } else {
+ newMax = newMin + fixedRange;
+ }
+ }
+
+ return {
+ min: newMin,
+ max: newMax
+ };
+};
+
+Axis.prototype.minFromRange = function () {
+ var rangeOptions = this.range,
+ type = rangeOptions.type,
+ timeName = { month: 'Month', year: 'FullYear'}[type],
+ min,
+ max = this.max,
+ dataMin,
+ range,
+ // Get the true range from a start date
+ getTrueRange = function (base, count) {
+ var date = new Date(base);
+ date['set' + timeName](date['get' + timeName]() + count);
+ return date.getTime() - base;
+ };
+
+ if (typeof rangeOptions === 'number') {
+ min = this.max - rangeOptions;
+ range = rangeOptions;
+ } else {
+ min = max + getTrueRange(max, -rangeOptions.count);
+ }
+
+ dataMin = pick(this.dataMin, Number.MIN_VALUE);
+ if (isNaN(min)) {
+ min = dataMin;
+ }
+ if (min <= dataMin) {
+ min = dataMin;
+ if (range === undefined) { // #4501
+ range = getTrueRange(min, rangeOptions.count);
+ }
+ this.newMax = mathMin(min + range, this.dataMax);
+ }
+ if (isNaN(max)) {
+ min = undefined;
+ }
+ return min;
+
+};
+
+// Initialize scroller for stock charts
+wrap(Chart.prototype, 'init', function (proceed, options, callback) {
+
+ addEvent(this, 'init', function () {
+ if (this.options.rangeSelector.enabled) {
+ this.rangeSelector = new RangeSelector(this);
+ }
+ });
+
+ proceed.call(this, options, callback);
+
+});
+
+
+Highcharts.RangeSelector = RangeSelector;
+
+/* ****************************************************************************
+ * End Range Selector code *
+ *****************************************************************************/
+
+
+
+
+
+Chart.prototype.callbacks.push(function (chart) {
+ var extremes,
+ scroller = chart.scroller,
+ rangeSelector = chart.rangeSelector;
+
+ function renderScroller() {
+ extremes = chart.xAxis[0].getExtremes();
+ scroller.render(extremes.min, extremes.max);
+ }
+
+ function renderRangeSelector() {
+ extremes = chart.xAxis[0].getExtremes();
+ if (!isNaN(extremes.min)) {
+ rangeSelector.render(extremes.min, extremes.max);
+ }
+ }
+
+ function afterSetExtremesHandlerScroller(e) {
+ if (e.triggerOp !== 'navigator-drag') {
+ scroller.render(e.min, e.max);
+ }
+ }
+
+ function afterSetExtremesHandlerRangeSelector(e) {
+ rangeSelector.render(e.min, e.max);
+ }
+
+ function destroyEvents() {
+ if (scroller) {
+ removeEvent(chart.xAxis[0], 'afterSetExtremes', afterSetExtremesHandlerScroller);
+ }
+ if (rangeSelector) {
+ removeEvent(chart, 'resize', renderRangeSelector);
+ removeEvent(chart.xAxis[0], 'afterSetExtremes', afterSetExtremesHandlerRangeSelector);
+ }
+ }
+
+ // initiate the scroller
+ if (scroller) {
+ // redraw the scroller on setExtremes
+ addEvent(chart.xAxis[0], 'afterSetExtremes', afterSetExtremesHandlerScroller);
+
+ // redraw the scroller on chart resize or box resize
+ wrap(chart, 'drawChartBox', function (proceed) {
+ var isDirtyBox = this.isDirtyBox;
+ proceed.call(this);
+ if (isDirtyBox) {
+ renderScroller();
+ }
+ });
+
+ // do it now
+ renderScroller();
+ }
+ if (rangeSelector) {
+ // redraw the scroller on setExtremes
+ addEvent(chart.xAxis[0], 'afterSetExtremes', afterSetExtremesHandlerRangeSelector);
+
+ // redraw the scroller chart resize
+ addEvent(chart, 'resize', renderRangeSelector);
+
+ // do it now
+ renderRangeSelector();
+ }
+
+ // Remove resize/afterSetExtremes at chart destroy
+ addEvent(chart, 'destroy', destroyEvents);
+});
+
+
+/**
+ * A wrapper for Chart with all the default values for a Stock chart
+ */
+Highcharts.StockChart = function (options, callback) {
+ var seriesOptions = options.series, // to increase performance, don't merge the data
+ opposite,
+
+ // Always disable startOnTick:true on the main axis when the navigator is enabled (#1090)
+ navigatorEnabled = pick(options.navigator && options.navigator.enabled, true),
+ disableStartOnTick = navigatorEnabled ? {
+ startOnTick: false,
+ endOnTick: false
+ } : null,
+
+ lineOptions = {
+
+ marker: {
+ enabled: false,
+ radius: 2
+ }
+ // gapSize: 0
+ },
+ columnOptions = {
+ shadow: false,
+ borderWidth: 0
+ };
+
+ // apply X axis options to both single and multi y axes
+ options.xAxis = map(splat(options.xAxis || {}), function (xAxisOptions) {
+ return merge({ // defaults
+ minPadding: 0,
+ maxPadding: 0,
+ ordinal: true,
+ title: {
+ text: null
+ },
+ labels: {
+ overflow: 'justify'
+ },
+ showLastLabel: true
+ }, xAxisOptions, // user options
+ { // forced options
+ type: 'datetime',
+ categories: null
+ },
+ disableStartOnTick
+ );
+ });
+
+ // apply Y axis options to both single and multi y axes
+ options.yAxis = map(splat(options.yAxis || {}), function (yAxisOptions) {
+ opposite = pick(yAxisOptions.opposite, true);
+ return merge({ // defaults
+ labels: {
+ y: -2
+ },
+ opposite: opposite,
+ showLastLabel: false,
+ title: {
+ text: null
+ }
+ }, yAxisOptions // user options
+ );
+ });
+
+ options.series = null;
+
+ options = merge({
+ chart: {
+ panning: true,
+ pinchType: 'x'
+ },
+ navigator: {
+ enabled: true
+ },
+ scrollbar: {
+ enabled: true
+ },
+ rangeSelector: {
+ enabled: true
+ },
+ title: {
+ text: null,
+ style: {
+ fontSize: '16px'
+ }
+ },
+ tooltip: {
+ shared: true,
+ crosshairs: true
+ },
+ legend: {
+ enabled: false
+ },
+
+ plotOptions: {
+ line: lineOptions,
+ spline: lineOptions,
+ area: lineOptions,
+ areaspline: lineOptions,
+ arearange: lineOptions,
+ areasplinerange: lineOptions,
+ column: columnOptions,
+ columnrange: columnOptions,
+ candlestick: columnOptions,
+ ohlc: columnOptions
+ }
+
+ },
+ options, // user's options
+
+ { // forced options
+ _stock: true, // internal flag
+ chart: {
+ inverted: false
+ }
+ });
+
+ options.series = seriesOptions;
+
+
+ return new Chart(options, callback);
+};
+
+// Implement the pinchType option
+wrap(Pointer.prototype, 'init', function (proceed, chart, options) {
+
+ var pinchType = options.chart.pinchType || '';
+
+ proceed.call(this, chart, options);
+
+ // Pinch status
+ this.pinchX = this.pinchHor = pinchType.indexOf('x') !== -1;
+ this.pinchY = this.pinchVert = pinchType.indexOf('y') !== -1;
+ this.hasZoom = this.hasZoom || this.pinchHor || this.pinchVert;
+});
+
+// Override the automatic label alignment so that the first Y axis' labels
+// are drawn on top of the grid line, and subsequent axes are drawn outside
+wrap(Axis.prototype, 'autoLabelAlign', function (proceed) {
+ var chart = this.chart,
+ options = this.options,
+ panes = chart._labelPanes = chart._labelPanes || {},
+ key,
+ labelOptions = this.options.labels;
+ if (this.chart.options._stock && this.coll === 'yAxis') {
+ key = options.top + ',' + options.height;
+ if (!panes[key] && labelOptions.enabled) { // do it only for the first Y axis of each pane
+ if (labelOptions.x === 15) { // default
+ labelOptions.x = 0;
+ }
+ if (labelOptions.align === undefined) {
+ labelOptions.align = 'right';
+ }
+ panes[key] = 1;
+ return 'right';
+ }
+ }
+ return proceed.call(this, [].slice.call(arguments, 1));
+});
+
+// Override getPlotLinePath to allow for multipane charts
+wrap(Axis.prototype, 'getPlotLinePath', function (proceed, value, lineWidth, old, force, translatedValue) {
+ var axis = this,
+ series = (this.isLinked && !this.series ? this.linkedParent.series : this.series),
+ chart = axis.chart,
+ renderer = chart.renderer,
+ axisLeft = axis.left,
+ axisTop = axis.top,
+ x1,
+ y1,
+ x2,
+ y2,
+ result = [],
+ axes = [], //#3416 need a default array
+ axes2,
+ uniqueAxes;
+
+ // Ignore in case of color Axis. #3360, #3524
+ if (axis.coll === 'colorAxis') {
+ return proceed.apply(this, [].slice.call(arguments, 1));
+ }
+
+ // Get the related axes based on series
+ axes = (axis.isXAxis ?
+ (defined(axis.options.yAxis) ?
+ [chart.yAxis[axis.options.yAxis]] :
+ map(series, function (S) { return S.yAxis; })
+ ) :
+ (defined(axis.options.xAxis) ?
+ [chart.xAxis[axis.options.xAxis]] :
+ map(series, function (S) { return S.xAxis; })
+ )
+ );
+
+ // Get the related axes based options.*Axis setting #2810
+ axes2 = (axis.isXAxis ? chart.yAxis : chart.xAxis);
+ each(axes2, function (A) {
+ if (defined(A.options.id) ? A.options.id.indexOf('navigator') === -1 : true) {
+ var a = (A.isXAxis ? 'yAxis' : 'xAxis'),
+ rax = (defined(A.options[a]) ? chart[a][A.options[a]] : chart[a][0]);
+
+ if (axis === rax) {
+ axes.push(A);
+ }
+ }
+ });
+
+
+ // Remove duplicates in the axes array. If there are no axes in the axes array,
+ // we are adding an axis without data, so we need to populate this with grid
+ // lines (#2796).
+ uniqueAxes = axes.length ? [] : [axis.isXAxis ? chart.yAxis[0] : chart.xAxis[0]]; //#3742
+ each(axes, function (axis2) {
+ if (inArray(axis2, uniqueAxes) === -1) {
+ uniqueAxes.push(axis2);
+ }
+ });
+
+ translatedValue = pick(translatedValue, axis.translate(value, null, null, old));
+
+ if (!isNaN(translatedValue)) {
+ if (axis.horiz) {
+ each(uniqueAxes, function (axis2) {
+ var skip;
+
+ y1 = axis2.pos;
+ y2 = y1 + axis2.len;
+ x1 = x2 = mathRound(translatedValue + axis.transB);
+
+ if (x1 < axisLeft || x1 > axisLeft + axis.width) { // outside plot area
+ if (force) {
+ x1 = x2 = mathMin(mathMax(axisLeft, x1), axisLeft + axis.width);
+ } else {
+ skip = true;
+ }
+ }
+ if (!skip) {
+ result.push('M', x1, y1, 'L', x2, y2);
+ }
+ });
+ } else {
+ each(uniqueAxes, function (axis2) {
+ var skip;
+
+ x1 = axis2.pos;
+ x2 = x1 + axis2.len;
+ y1 = y2 = mathRound(axisTop + axis.height - translatedValue);
+
+ if (y1 < axisTop || y1 > axisTop + axis.height) { // outside plot area
+ if (force) {
+ y1 = y2 = mathMin(mathMax(axisTop, y1), axis.top + axis.height);
+ } else {
+ skip = true;
+ }
+ }
+ if (!skip) {
+ result.push('M', x1, y1, 'L', x2, y2);
+ }
+ });
+ }
+ }
+ if (result.length > 0) {
+ return renderer.crispPolyLine(result, lineWidth || 1);
+ } else {
+ return null; //#3557 getPlotLinePath in regular Highcharts also returns null
+ }
+});
+
+// Override getPlotBandPath to allow for multipane charts
+Axis.prototype.getPlotBandPath = function (from, to) {
+ var toPath = this.getPlotLinePath(to, null, null, true),
+ path = this.getPlotLinePath(from, null, null, true),
+ result = [],
+ i;
+
+ if (path && toPath && path.toString() !== toPath.toString()) {
+ // Go over each subpath
+ for (i = 0; i < path.length; i += 6) {
+ result.push('M', path[i + 1], path[i + 2], 'L', path[i + 4], path[i + 5], toPath[i + 4], toPath[i + 5], toPath[i + 1], toPath[i + 2]);
+ }
+ } else { // outside the axis area
+ result = null;
+ }
+
+ return result;
+};
+
+// Function to crisp a line with multiple segments
+SVGRenderer.prototype.crispPolyLine = function (points, width) {
+ // points format: [M, 0, 0, L, 100, 0]
+ // normalize to a crisp line
+ var i;
+ for (i = 0; i < points.length; i = i + 6) {
+ if (points[i + 1] === points[i + 4]) {
+ // Substract due to #1129. Now bottom and left axis gridlines behave the same.
+ points[i + 1] = points[i + 4] = mathRound(points[i + 1]) - (width % 2 / 2);
+ }
+ if (points[i + 2] === points[i + 5]) {
+ points[i + 2] = points[i + 5] = mathRound(points[i + 2]) + (width % 2 / 2);
+ }
+ }
+ return points;
+};
+if (Renderer === Highcharts.VMLRenderer) {
+ VMLRenderer.prototype.crispPolyLine = SVGRenderer.prototype.crispPolyLine;
+}
+
+
+// Wrapper to hide the label
+wrap(Axis.prototype, 'hideCrosshair', function (proceed, i) {
+ proceed.call(this, i);
+
+ if (!defined(this.crossLabelArray)) { return; }
+
+ if (defined(i)) {
+ if (this.crossLabelArray[i]) { this.crossLabelArray[i].hide(); }
+ } else {
+ each(this.crossLabelArray, function (crosslabel) {
+ crosslabel.hide();
+ });
+ }
+});
+
+// Wrapper to draw the label
+wrap(Axis.prototype, 'drawCrosshair', function (proceed, e, point) {
+ // Draw the crosshair
+ proceed.call(this, e, point);
+
+ // Check if the label has to be drawn
+ if (!defined(this.crosshair.label) || !this.crosshair.label.enabled || !defined(point)) {
+ return;
+ }
+
+ var chart = this.chart,
+ options = this.options.crosshair.label, // the label's options
+ axis = this.isXAxis ? 'x' : 'y', // axis name
+ horiz = this.horiz, // axis orientation
+ opposite = this.opposite, // axis position
+ left = this.left, // left position
+ top = this.top, // top position
+ crossLabel = this.crossLabel, // reference to the svgElement
+ posx,
+ posy,
+ crossBox,
+ formatOption = options.format,
+ formatFormat = '',
+ limit;
+
+ // If the label does not exist yet, create it.
+ if (!crossLabel) {
+ crossLabel = this.crossLabel = chart.renderer.label()
+ .attr({
+ align: options.align || (horiz ? 'center' : opposite ? (this.labelAlign === 'right' ? 'right' : 'left') : (this.labelAlign === 'left' ? 'left' : 'center')),
+ zIndex: 12,
+ height: horiz ? 16 : UNDEFINED,
+ fill: options.backgroundColor || (this.series[0] && this.series[0].color) || 'gray',
+ padding: pick(options.padding, 2),
+ stroke: options.borderColor || null,
+ 'stroke-width': options.borderWidth || 0
+ })
+ .css(extend({
+ color: 'white',
+ fontWeight: 'normal',
+ fontSize: '11px',
+ textAlign: 'center'
+ }, options.style))
+ .add();
+ }
+
+ if (horiz) {
+ posx = point.plotX + left;
+ posy = top + (opposite ? 0 : this.height);
+ } else {
+ posx = opposite ? this.width + left : 0;
+ posy = point.plotY + top;
+ }
+
+ // if the crosshair goes out of view (too high or too low, hide it and hide the label)
+ if (posy < top || posy > top + this.height) {
+ this.hideCrosshair();
+ return;
+ }
+
+ // TODO: Dynamic date formats like in Series.tooltipHeaderFormat.
+ if (!formatOption && !options.formatter) {
+ if (this.isDatetimeAxis) {
+ formatFormat = '%b %d, %Y';
+ }
+ formatOption = '{value' + (formatFormat ? ':' + formatFormat : '') + '}';
+ }
+
+ // show the label
+ crossLabel.attr({
+ text: formatOption ? format(formatOption, {value: point[axis]}) : options.formatter.call(this, point[axis]),
+ x: posx,
+ y: posy,
+ visibility: VISIBLE
+ });
+ crossBox = crossLabel.getBBox();
+
+ // now it is placed we can correct its position
+ if (horiz) {
+ if (((this.options.tickPosition === 'inside') && !opposite) ||
+ ((this.options.tickPosition !== 'inside') && opposite)) {
+ posy = crossLabel.y - crossBox.height;
+ }
+ } else {
+ posy = crossLabel.y - (crossBox.height / 2);
+ }
+
+ // check the edges
+ if (horiz) {
+ limit = {
+ left: left - crossBox.x,
+ right: left + this.width - crossBox.x
+ };
+ } else {
+ limit = {
+ left: this.labelAlign === 'left' ? left : 0,
+ right: this.labelAlign === 'right' ? left + this.width : chart.chartWidth
+ };
+ }
+
+ // left edge
+ if (crossLabel.translateX < limit.left) {
+ posx += limit.left - crossLabel.translateX;
+ }
+ // right edge
+ if (crossLabel.translateX + crossBox.width >= limit.right) {
+ posx -= crossLabel.translateX + crossBox.width - limit.right;
+ }
+
+ // show the crosslabel
+ crossLabel.attr({x: posx, y: posy, visibility: VISIBLE});
+});
+
+/* ****************************************************************************
+ * Start value compare logic *
+ *****************************************************************************/
+
+var seriesInit = seriesProto.init,
+ seriesProcessData = seriesProto.processData,
+ pointTooltipFormatter = Point.prototype.tooltipFormatter;
+
+/**
+ * Extend series.init by adding a method to modify the y value used for plotting
+ * on the y axis. This method is called both from the axis when finding dataMin
+ * and dataMax, and from the series.translate method.
+ */
+seriesProto.init = function () {
+
+ // Call base method
+ seriesInit.apply(this, arguments);
+
+ // Set comparison mode
+ this.setCompare(this.options.compare);
+};
+
+/**
+ * The setCompare method can be called also from the outside after render time
+ */
+seriesProto.setCompare = function (compare) {
+
+ // Set or unset the modifyValue method
+ this.modifyValue = (compare === 'value' || compare === 'percent') ? function (value, point) {
+ var compareValue = this.compareValue;
+
+ if (value !== UNDEFINED) { // #2601
+
+ // get the modified value
+ value = compare === 'value' ?
+ value - compareValue : // compare value
+ value = 100 * (value / compareValue) - 100; // compare percent
+
+ // record for tooltip etc.
+ if (point) {
+ point.change = value;
+ }
+
+ }
+
+ return value;
+ } : null;
+
+ // Mark dirty
+ if (this.chart.hasRendered) {
+ this.isDirty = true;
+ }
+
+};
+
+/**
+ * Extend series.processData by finding the first y value in the plot area,
+ * used for comparing the following values
+ */
+seriesProto.processData = function () {
+ var series = this,
+ i = 0,
+ processedXData,
+ processedYData,
+ length;
+
+ // call base method
+ seriesProcessData.apply(this, arguments);
+
+ if (series.xAxis && series.processedYData) { // not pies
+
+ // local variables
+ processedXData = series.processedXData;
+ processedYData = series.processedYData;
+ length = processedYData.length;
+
+ // find the first value for comparison
+ for (; i < length; i++) {
+ if (typeof processedYData[i] === NUMBER && processedXData[i] >= series.xAxis.min) {
+ series.compareValue = processedYData[i];
+ break;
+ }
+ }
+ }
+};
+
+/**
+ * Modify series extremes
+ */
+wrap(seriesProto, 'getExtremes', function (proceed) {
+ proceed.apply(this, [].slice.call(arguments, 1));
+
+ if (this.modifyValue) {
+ this.dataMax = this.modifyValue(this.dataMax);
+ this.dataMin = this.modifyValue(this.dataMin);
+ }
+});
+
+/**
+ * Add a utility method, setCompare, to the Y axis
+ */
+Axis.prototype.setCompare = function (compare, redraw) {
+ if (!this.isXAxis) {
+ each(this.series, function (series) {
+ series.setCompare(compare);
+ });
+ if (pick(redraw, true)) {
+ this.chart.redraw();
+ }
+ }
+};
+
+/**
+ * Extend the tooltip formatter by adding support for the point.change variable
+ * as well as the changeDecimals option
+ */
+Point.prototype.tooltipFormatter = function (pointFormat) {
+ var point = this;
+
+ pointFormat = pointFormat.replace(
+ '{point.change}',
+ (point.change > 0 ? '+' : '') + Highcharts.numberFormat(point.change, pick(point.series.tooltipOptions.changeDecimals, 2))
+ );
+
+ return pointTooltipFormatter.apply(this, [pointFormat]);
+};
+
+/* ****************************************************************************
+ * End value compare logic *
+ *****************************************************************************/
+
+
+/**
+ * Extend the Series prototype to create a separate series clip box. This is related
+ * to using multiple panes, and a future pane logic should incorporate this feature (#2754).
+ */
+wrap(Series.prototype, 'render', function (proceed) {
+ // Only do this on stock charts (#2939), and only if the series type handles clipping
+ // in the animate method (#2975).
+ if (this.chart.options._stock && this.xAxis) {
+
+ // First render, initial clip box
+ if (!this.clipBox && this.animate) {
+ this.clipBox = merge(this.chart.clipBox);
+ this.clipBox.width = this.xAxis.len;
+ this.clipBox.height = this.yAxis.len;
+
+ // On redrawing, resizing etc, update the clip rectangle
+ } else if (this.chart[this.sharedClipKey]) {
+ stop(this.chart[this.sharedClipKey]); // #2998
+ this.chart[this.sharedClipKey].attr({
+ width: this.xAxis.len,
+ height: this.yAxis.len
+ });
+ }
+ }
+ proceed.call(this);
+});
+
+
+/**
+ * The Pane object allows options that are common to a set of X and Y axes.
+ *
+ * In the future, this can be extended to basic Highcharts and Highstock.
+ */
+function Pane(options, chart, firstAxis) {
+ this.init.call(this, options, chart, firstAxis);
+}
+
+// Extend the Pane prototype
+extend(Pane.prototype, {
+
+ /**
+ * Initiate the Pane object
+ */
+ init: function (options, chart, firstAxis) {
+ var pane = this,
+ backgroundOption,
+ defaultOptions = pane.defaultOptions;
+
+ pane.chart = chart;
+
+ // Set options. Angular charts have a default background (#3318)
+ pane.options = options = merge(defaultOptions, chart.angular ? { background: {} } : undefined, options);
+
+ backgroundOption = options.background;
+
+ // To avoid having weighty logic to place, update and remove the backgrounds,
+ // push them to the first axis' plot bands and borrow the existing logic there.
+ if (backgroundOption) {
+ each([].concat(splat(backgroundOption)).reverse(), function (config) {
+ var backgroundColor = config.backgroundColor, // if defined, replace the old one (specific for gradients)
+ axisUserOptions = firstAxis.userOptions;
+ config = merge(pane.defaultBackgroundOptions, config);
+ if (backgroundColor) {
+ config.backgroundColor = backgroundColor;
+ }
+ config.color = config.backgroundColor; // due to naming in plotBands
+ firstAxis.options.plotBands.unshift(config);
+ axisUserOptions.plotBands = axisUserOptions.plotBands || []; // #3176
+ if (axisUserOptions.plotBands !== firstAxis.options.plotBands) {
+ axisUserOptions.plotBands.unshift(config);
+ }
+ });
+ }
+ },
+
+ /**
+ * The default options object
+ */
+ defaultOptions: {
+ // background: {conditional},
+ center: ['50%', '50%'],
+ size: '85%',
+ startAngle: 0
+ //endAngle: startAngle + 360
+ },
+
+ /**
+ * The default background options
+ */
+ defaultBackgroundOptions: {
+ shape: 'circle',
+ borderWidth: 1,
+ borderColor: 'silver',
+ backgroundColor: {
+ linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
+ stops: [
+ [0, '#FFF'],
+ [1, '#DDD']
+ ]
+ },
+ from: -Number.MAX_VALUE, // corrected to axis min
+ innerRadius: 0,
+ to: Number.MAX_VALUE, // corrected to axis max
+ outerRadius: '105%'
+ }
+
+});
+
+
+var axisProto = Axis.prototype,
+ tickProto = Tick.prototype;
+
+/**
+ * Augmented methods for the x axis in order to hide it completely, used for the X axis in gauges
+ */
+var hiddenAxisMixin = {
+ getOffset: noop,
+ redraw: function () {
+ this.isDirty = false; // prevent setting Y axis dirty
+ },
+ render: function () {
+ this.isDirty = false; // prevent setting Y axis dirty
+ },
+ setScale: noop,
+ setCategories: noop,
+ setTitle: noop
+};
+
+/**
+ * Augmented methods for the value axis
+ */
+/*jslint unparam: true*/
+var radialAxisMixin = {
+ isRadial: true,
+
+ /**
+ * The default options extend defaultYAxisOptions
+ */
+ defaultRadialGaugeOptions: {
+ labels: {
+ align: 'center',
+ x: 0,
+ y: null // auto
+ },
+ minorGridLineWidth: 0,
+ minorTickInterval: 'auto',
+ minorTickLength: 10,
+ minorTickPosition: 'inside',
+ minorTickWidth: 1,
+ tickLength: 10,
+ tickPosition: 'inside',
+ tickWidth: 2,
+ title: {
+ rotation: 0
+ },
+ zIndex: 2 // behind dials, points in the series group
+ },
+
+ // Circular axis around the perimeter of a polar chart
+ defaultRadialXOptions: {
+ gridLineWidth: 1, // spokes
+ labels: {
+ align: null, // auto
+ distance: 15,
+ x: 0,
+ y: null // auto
+ },
+ maxPadding: 0,
+ minPadding: 0,
+ showLastLabel: false,
+ tickLength: 0
+ },
+
+ // Radial axis, like a spoke in a polar chart
+ defaultRadialYOptions: {
+ gridLineInterpolation: 'circle',
+ labels: {
+ align: 'right',
+ x: -3,
+ y: -2
+ },
+ showLastLabel: false,
+ title: {
+ x: 4,
+ text: null,
+ rotation: 90
+ }
+ },
+
+ /**
+ * Merge and set options
+ */
+ setOptions: function (userOptions) {
+
+ var options = this.options = merge(
+ this.defaultOptions,
+ this.defaultRadialOptions,
+ userOptions
+ );
+
+ // Make sure the plotBands array is instanciated for each Axis (#2649)
+ if (!options.plotBands) {
+ options.plotBands = [];
+ }
+
+ },
+
+ /**
+ * Wrap the getOffset method to return zero offset for title or labels in a radial
+ * axis
+ */
+ getOffset: function () {
+ // Call the Axis prototype method (the method we're in now is on the instance)
+ axisProto.getOffset.call(this);
+
+ // Title or label offsets are not counted
+ this.chart.axisOffset[this.side] = 0;
+
+ // Set the center array
+ this.center = this.pane.center = CenteredSeriesMixin.getCenter.call(this.pane);
+ },
+
+
+ /**
+ * Get the path for the axis line. This method is also referenced in the getPlotLinePath
+ * method.
+ */
+ getLinePath: function (lineWidth, radius) {
+ var center = this.center;
+ radius = pick(radius, center[2] / 2 - this.offset);
+
+ return this.chart.renderer.symbols.arc(
+ this.left + center[0],
+ this.top + center[1],
+ radius,
+ radius,
+ {
+ start: this.startAngleRad,
+ end: this.endAngleRad,
+ open: true,
+ innerR: 0
+ }
+ );
+ },
+
+ /**
+ * Override setAxisTranslation by setting the translation to the difference
+ * in rotation. This allows the translate method to return angle for
+ * any given value.
+ */
+ setAxisTranslation: function () {
+
+ // Call uber method
+ axisProto.setAxisTranslation.call(this);
+
+ // Set transA and minPixelPadding
+ if (this.center) { // it's not defined the first time
+ if (this.isCircular) {
+
+ this.transA = (this.endAngleRad - this.startAngleRad) /
+ ((this.max - this.min) || 1);
+
+
+ } else {
+ this.transA = (this.center[2] / 2) / ((this.max - this.min) || 1);
+ }
+
+ if (this.isXAxis) {
+ this.minPixelPadding = this.transA * this.minPointOffset;
+ } else {
+ // This is a workaround for regression #2593, but categories still don't position correctly.
+ // TODO: Implement true handling of Y axis categories on gauges.
+ this.minPixelPadding = 0;
+ }
+ }
+ },
+
+ /**
+ * In case of auto connect, add one closestPointRange to the max value right before
+ * tickPositions are computed, so that ticks will extend passed the real max.
+ */
+ beforeSetTickPositions: function () {
+ if (this.autoConnect) {
+ this.max += (this.categories && 1) || this.pointRange || this.closestPointRange || 0; // #1197, #2260
+ }
+ },
+
+ /**
+ * Override the setAxisSize method to use the arc's circumference as length. This
+ * allows tickPixelInterval to apply to pixel lengths along the perimeter
+ */
+ setAxisSize: function () {
+
+ axisProto.setAxisSize.call(this);
+
+ if (this.isRadial) {
+
+ // Set the center array
+ this.center = this.pane.center = Highcharts.CenteredSeriesMixin.getCenter.call(this.pane);
+
+ // The sector is used in Axis.translate to compute the translation of reversed axis points (#2570)
+ if (this.isCircular) {
+ this.sector = this.endAngleRad - this.startAngleRad;
+ }
+
+ // Axis len is used to lay out the ticks
+ this.len = this.width = this.height = this.center[2] * pick(this.sector, 1) / 2;
+
+
+ }
+ },
+
+ /**
+ * Returns the x, y coordinate of a point given by a value and a pixel distance
+ * from center
+ */
+ getPosition: function (value, length) {
+ return this.postTranslate(
+ this.isCircular ? this.translate(value) : 0, // #2848
+ pick(this.isCircular ? length : this.translate(value), this.center[2] / 2) - this.offset
+ );
+ },
+
+ /**
+ * Translate from intermediate plotX (angle), plotY (axis.len - radius) to final chart coordinates.
+ */
+ postTranslate: function (angle, radius) {
+
+ var chart = this.chart,
+ center = this.center;
+
+ angle = this.startAngleRad + angle;
+
+ return {
+ x: chart.plotLeft + center[0] + Math.cos(angle) * radius,
+ y: chart.plotTop + center[1] + Math.sin(angle) * radius
+ };
+
+ },
+
+ /**
+ * Find the path for plot bands along the radial axis
+ */
+ getPlotBandPath: function (from, to, options) {
+ var center = this.center,
+ startAngleRad = this.startAngleRad,
+ fullRadius = center[2] / 2,
+ radii = [
+ pick(options.outerRadius, '100%'),
+ options.innerRadius,
+ pick(options.thickness, 10)
+ ],
+ percentRegex = /%$/,
+ start,
+ end,
+ open,
+ isCircular = this.isCircular, // X axis in a polar chart
+ ret;
+
+ // Polygonal plot bands
+ if (this.options.gridLineInterpolation === 'polygon') {
+ ret = this.getPlotLinePath(from).concat(this.getPlotLinePath(to, true));
+
+ // Circular grid bands
+ } else {
+
+ // Keep within bounds
+ from = Math.max(from, this.min);
+ to = Math.min(to, this.max);
+
+ // Plot bands on Y axis (radial axis) - inner and outer radius depend on to and from
+ if (!isCircular) {
+ radii[0] = this.translate(from);
+ radii[1] = this.translate(to);
+ }
+
+ // Convert percentages to pixel values
+ radii = map(radii, function (radius) {
+ if (percentRegex.test(radius)) {
+ radius = (pInt(radius, 10) * fullRadius) / 100;
+ }
+ return radius;
+ });
+
+ // Handle full circle
+ if (options.shape === 'circle' || !isCircular) {
+ start = -Math.PI / 2;
+ end = Math.PI * 1.5;
+ open = true;
+ } else {
+ start = startAngleRad + this.translate(from);
+ end = startAngleRad + this.translate(to);
+ }
+
+
+ ret = this.chart.renderer.symbols.arc(
+ this.left + center[0],
+ this.top + center[1],
+ radii[0],
+ radii[0],
+ {
+ start: Math.min(start, end), // Math is for reversed yAxis (#3606)
+ end: Math.max(start, end),
+ innerR: pick(radii[1], radii[0] - radii[2]),
+ open: open
+ }
+ );
+ }
+
+ return ret;
+ },
+
+ /**
+ * Find the path for plot lines perpendicular to the radial axis.
+ */
+ getPlotLinePath: function (value, reverse) {
+ var axis = this,
+ center = axis.center,
+ chart = axis.chart,
+ end = axis.getPosition(value),
+ xAxis,
+ xy,
+ tickPositions,
+ ret;
+
+ // Spokes
+ if (axis.isCircular) {
+ ret = ['M', center[0] + chart.plotLeft, center[1] + chart.plotTop, 'L', end.x, end.y];
+
+ // Concentric circles
+ } else if (axis.options.gridLineInterpolation === 'circle') {
+ value = axis.translate(value);
+ if (value) { // a value of 0 is in the center
+ ret = axis.getLinePath(0, value);
+ }
+ // Concentric polygons
+ } else {
+ // Find the X axis in the same pane
+ each(chart.xAxis, function (a) {
+ if (a.pane === axis.pane) {
+ xAxis = a;
+ }
+ });
+ ret = [];
+ value = axis.translate(value);
+ tickPositions = xAxis.tickPositions;
+ if (xAxis.autoConnect) {
+ tickPositions = tickPositions.concat([tickPositions[0]]);
+ }
+ // Reverse the positions for concatenation of polygonal plot bands
+ if (reverse) {
+ tickPositions = [].concat(tickPositions).reverse();
+ }
+
+ each(tickPositions, function (pos, i) {
+ xy = xAxis.getPosition(pos, value);
+ ret.push(i ? 'L' : 'M', xy.x, xy.y);
+ });
+
+ }
+ return ret;
+ },
+
+ /**
+ * Find the position for the axis title, by default inside the gauge
+ */
+ getTitlePosition: function () {
+ var center = this.center,
+ chart = this.chart,
+ titleOptions = this.options.title;
+
+ return {
+ x: chart.plotLeft + center[0] + (titleOptions.x || 0),
+ y: chart.plotTop + center[1] - ({ high: 0.5, middle: 0.25, low: 0 }[titleOptions.align] *
+ center[2]) + (titleOptions.y || 0)
+ };
+ }
+
+};
+/*jslint unparam: false*/
+
+/**
+ * Override axisProto.init to mix in special axis instance functions and function overrides
+ */
+wrap(axisProto, 'init', function (proceed, chart, userOptions) {
+ var axis = this,
+ angular = chart.angular,
+ polar = chart.polar,
+ isX = userOptions.isX,
+ isHidden = angular && isX,
+ isCircular,
+ startAngleRad,
+ endAngleRad,
+ options,
+ chartOptions = chart.options,
+ paneIndex = userOptions.pane || 0,
+ pane,
+ paneOptions;
+
+ // Before prototype.init
+ if (angular) {
+ extend(this, isHidden ? hiddenAxisMixin : radialAxisMixin);
+ isCircular = !isX;
+ if (isCircular) {
+ this.defaultRadialOptions = this.defaultRadialGaugeOptions;
+ }
+
+ } else if (polar) {
+ //extend(this, userOptions.isX ? radialAxisMixin : radialAxisMixin);
+ extend(this, radialAxisMixin);
+ isCircular = isX;
+ this.defaultRadialOptions = isX ? this.defaultRadialXOptions : merge(this.defaultYAxisOptions, this.defaultRadialYOptions);
+
+ }
+
+ // Run prototype.init
+ proceed.call(this, chart, userOptions);
+
+ if (!isHidden && (angular || polar)) {
+ options = this.options;
+
+ // Create the pane and set the pane options.
+ if (!chart.panes) {
+ chart.panes = [];
+ }
+ this.pane = pane = chart.panes[paneIndex] = chart.panes[paneIndex] || new Pane(
+ splat(chartOptions.pane)[paneIndex],
+ chart,
+ axis
+ );
+ paneOptions = pane.options;
+
+
+ // Disable certain features on angular and polar axes
+ chart.inverted = false;
+ chartOptions.chart.zoomType = null;
+
+ // Start and end angle options are
+ // given in degrees relative to top, while internal computations are
+ // in radians relative to right (like SVG).
+ this.startAngleRad = startAngleRad = (paneOptions.startAngle - 90) * Math.PI / 180;
+ this.endAngleRad = endAngleRad = (pick(paneOptions.endAngle, paneOptions.startAngle + 360) - 90) * Math.PI / 180;
+ this.offset = options.offset || 0;
+
+ this.isCircular = isCircular;
+
+ // Automatically connect grid lines?
+ if (isCircular && userOptions.max === UNDEFINED && endAngleRad - startAngleRad === 2 * Math.PI) {
+ this.autoConnect = true;
+ }
+ }
+
+});
+
+/**
+ * Add special cases within the Tick class' methods for radial axes.
+ */
+wrap(tickProto, 'getPosition', function (proceed, horiz, pos, tickmarkOffset, old) {
+ var axis = this.axis;
+
+ return axis.getPosition ?
+ axis.getPosition(pos) :
+ proceed.call(this, horiz, pos, tickmarkOffset, old);
+});
+
+/**
+ * Wrap the getLabelPosition function to find the center position of the label
+ * based on the distance option
+ */
+wrap(tickProto, 'getLabelPosition', function (proceed, x, y, label, horiz, labelOptions, tickmarkOffset, index, step) {
+ var axis = this.axis,
+ optionsY = labelOptions.y,
+ ret,
+ centerSlot = 20, // 20 degrees to each side at the top and bottom
+ align = labelOptions.align,
+ angle = ((axis.translate(this.pos) + axis.startAngleRad + Math.PI / 2) / Math.PI * 180) % 360;
+
+ if (axis.isRadial) {
+ ret = axis.getPosition(this.pos, (axis.center[2] / 2) + pick(labelOptions.distance, -25));
+
+ // Automatically rotated
+ if (labelOptions.rotation === 'auto') {
+ label.attr({
+ rotation: angle
+ });
+
+ // Vertically centered
+ } else if (optionsY === null) {
+ optionsY = axis.chart.renderer.fontMetrics(label.styles.fontSize).b - label.getBBox().height / 2;
+ }
+
+ // Automatic alignment
+ if (align === null) {
+ if (axis.isCircular) {
+ if (this.label.getBBox().width > axis.len * axis.tickInterval / (axis.max - axis.min)) { // #3506
+ centerSlot = 0;
+ }
+ if (angle > centerSlot && angle < 180 - centerSlot) {
+ align = 'left'; // right hemisphere
+ } else if (angle > 180 + centerSlot && angle < 360 - centerSlot) {
+ align = 'right'; // left hemisphere
+ } else {
+ align = 'center'; // top or bottom
+ }
+ } else {
+ align = 'center';
+ }
+ label.attr({
+ align: align
+ });
+ }
+
+ ret.x += labelOptions.x;
+ ret.y += optionsY;
+
+ } else {
+ ret = proceed.call(this, x, y, label, horiz, labelOptions, tickmarkOffset, index, step);
+ }
+ return ret;
+});
+
+/**
+ * Wrap the getMarkPath function to return the path of the radial marker
+ */
+wrap(tickProto, 'getMarkPath', function (proceed, x, y, tickLength, tickWidth, horiz, renderer) {
+ var axis = this.axis,
+ endPoint,
+ ret;
+
+ if (axis.isRadial) {
+ endPoint = axis.getPosition(this.pos, axis.center[2] / 2 + tickLength);
+ ret = [
+ 'M',
+ x,
+ y,
+ 'L',
+ endPoint.x,
+ endPoint.y
+ ];
+ } else {
+ ret = proceed.call(this, x, y, tickLength, tickWidth, horiz, renderer);
+ }
+ return ret;
+});
+
+/*
+ * The AreaRangeSeries class
+ *
+ */
+
+/**
+ * Extend the default options with map options
+ */
+defaultPlotOptions.arearange = merge(defaultPlotOptions.area, {
+ lineWidth: 1,
+ marker: null,
+ threshold: null,
+ tooltip: {
+ pointFormat: '\u25CF {series.name}: {point.low} - {point.high}
'
+ },
+ trackByArea: true,
+ dataLabels: {
+ align: null,
+ verticalAlign: null,
+ xLow: 0,
+ xHigh: 0,
+ yLow: 0,
+ yHigh: 0
+ },
+ states: {
+ hover: {
+ halo: false
+ }
+ }
+});
+
+/**
+ * Add the series type
+ */
+seriesTypes.arearange = extendClass(seriesTypes.area, {
+ type: 'arearange',
+ pointArrayMap: ['low', 'high'],
+ dataLabelCollections: ['dataLabel', 'dataLabelUpper'],
+ toYData: function (point) {
+ return [point.low, point.high];
+ },
+ pointValKey: 'low',
+ deferTranslatePolar: true,
+
+ /**
+ * Translate a point's plotHigh from the internal angle and radius measures to
+ * true plotHigh coordinates. This is an addition of the toXY method found in
+ * Polar.js, because it runs too early for arearanges to be considered (#3419).
+ */
+ highToXY: function (point) {
+ // Find the polar plotX and plotY
+ var chart = this.chart,
+ xy = this.xAxis.postTranslate(point.rectPlotX, this.yAxis.len - point.plotHigh);
+ point.plotHighX = xy.x - chart.plotLeft;
+ point.plotHigh = xy.y - chart.plotTop;
+ },
+
+ /**
+ * Extend getSegments to force null points if the higher value is null. #1703.
+ */
+ getSegments: function () {
+ var series = this;
+
+ each(series.points, function (point) {
+ if (!series.options.connectNulls && (point.low === null || point.high === null)) {
+ point.y = null;
+ } else if (point.low === null && point.high !== null) {
+ point.y = point.high;
+ }
+ });
+ Series.prototype.getSegments.call(this);
+ },
+
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis;
+
+ seriesTypes.area.prototype.translate.apply(series);
+
+ // Set plotLow and plotHigh
+ each(series.points, function (point) {
+
+ var low = point.low,
+ high = point.high,
+ plotY = point.plotY;
+
+ if (high === null && low === null) {
+ point.y = null;
+ } else if (low === null) {
+ point.plotLow = point.plotY = null;
+ point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
+ } else if (high === null) {
+ point.plotLow = plotY;
+ point.plotHigh = null;
+ } else {
+ point.plotLow = plotY;
+ point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
+ }
+ });
+
+ // Postprocess plotHigh
+ if (this.chart.polar) {
+ each(this.points, function (point) {
+ series.highToXY(point);
+ });
+ }
+ },
+
+ /**
+ * Extend the line series' getSegmentPath method by applying the segment
+ * path to both lower and higher values of the range
+ */
+ getSegmentPath: function (segment) {
+
+ var lowSegment,
+ highSegment = [],
+ i = segment.length,
+ baseGetSegmentPath = Series.prototype.getSegmentPath,
+ point,
+ linePath,
+ lowerPath,
+ options = this.options,
+ step = options.step,
+ higherPath;
+
+ // Remove nulls from low segment
+ lowSegment = HighchartsAdapter.grep(segment, function (point) {
+ return point.plotLow !== null;
+ });
+
+ // Make a segment with plotX and plotY for the top values
+ while (i--) {
+ point = segment[i];
+ if (point.plotHigh !== null) {
+ highSegment.push({
+ plotX: point.plotHighX || point.plotX, // plotHighX is for polar charts
+ plotY: point.plotHigh
+ });
+ }
+ }
+
+ // Get the paths
+ lowerPath = baseGetSegmentPath.call(this, lowSegment);
+ if (step) {
+ if (step === true) {
+ step = 'left';
+ }
+ options.step = { left: 'right', center: 'center', right: 'left' }[step]; // swap for reading in getSegmentPath
+ }
+ higherPath = baseGetSegmentPath.call(this, highSegment);
+ options.step = step;
+
+ // Create a line on both top and bottom of the range
+ linePath = [].concat(lowerPath, higherPath);
+
+ // For the area path, we need to change the 'move' statement into 'lineTo' or 'curveTo'
+ if (!this.chart.polar) {
+ higherPath[0] = 'L'; // this probably doesn't work for spline
+ }
+ this.areaPath = this.areaPath.concat(lowerPath, higherPath);
+
+ return linePath;
+ },
+
+ /**
+ * Extend the basic drawDataLabels method by running it for both lower and higher
+ * values.
+ */
+ drawDataLabels: function () {
+
+ var data = this.data,
+ length = data.length,
+ i,
+ originalDataLabels = [],
+ seriesProto = Series.prototype,
+ dataLabelOptions = this.options.dataLabels,
+ align = dataLabelOptions.align,
+ inside = dataLabelOptions.inside,
+ point,
+ up,
+ inverted = this.chart.inverted;
+
+ if (dataLabelOptions.enabled || this._hasPointLabels) {
+
+ // Step 1: set preliminary values for plotY and dataLabel and draw the upper labels
+ i = length;
+ while (i--) {
+ point = data[i];
+ if (point) {
+ up = inside ? point.plotHigh < point.plotLow : point.plotHigh > point.plotLow;
+
+ // Set preliminary values
+ point.y = point.high;
+ point._plotY = point.plotY;
+ point.plotY = point.plotHigh;
+
+ // Store original data labels and set preliminary label objects to be picked up
+ // in the uber method
+ originalDataLabels[i] = point.dataLabel;
+ point.dataLabel = point.dataLabelUpper;
+
+ // Set the default offset
+ point.below = up;
+ if (inverted) {
+ if (!align) {
+ dataLabelOptions.align = up ? 'right' : 'left';
+ }
+ dataLabelOptions.x = dataLabelOptions.xHigh;
+ } else {
+ dataLabelOptions.y = dataLabelOptions.yHigh;
+ }
+ }
+ }
+
+ if (seriesProto.drawDataLabels) {
+ seriesProto.drawDataLabels.apply(this, arguments); // #1209
+ }
+
+ // Step 2: reorganize and handle data labels for the lower values
+ i = length;
+ while (i--) {
+ point = data[i];
+ if (point) {
+ up = inside ? point.plotHigh < point.plotLow : point.plotHigh > point.plotLow;
+
+ // Move the generated labels from step 1, and reassign the original data labels
+ point.dataLabelUpper = point.dataLabel;
+ point.dataLabel = originalDataLabels[i];
+
+ // Reset values
+ point.y = point.low;
+ point.plotY = point._plotY;
+
+ // Set the default offset
+ point.below = !up;
+ if (inverted) {
+ if (!align) {
+ dataLabelOptions.align = up ? 'left' : 'right';
+ }
+ dataLabelOptions.x = dataLabelOptions.xLow;
+ } else {
+ dataLabelOptions.y = dataLabelOptions.yLow;
+ }
+ }
+ }
+ if (seriesProto.drawDataLabels) {
+ seriesProto.drawDataLabels.apply(this, arguments);
+ }
+ }
+
+ dataLabelOptions.align = align;
+
+ },
+
+ alignDataLabel: function () {
+ seriesTypes.column.prototype.alignDataLabel.apply(this, arguments);
+ },
+
+ setStackedPoints: noop,
+
+ getSymbol: noop,
+
+ drawPoints: noop
+});
+
+/**
+ * The AreaSplineRangeSeries class
+ */
+
+defaultPlotOptions.areasplinerange = merge(defaultPlotOptions.arearange);
+
+/**
+ * AreaSplineRangeSeries object
+ */
+seriesTypes.areasplinerange = extendClass(seriesTypes.arearange, {
+ type: 'areasplinerange',
+ getPointSpline: seriesTypes.spline.prototype.getPointSpline
+});
+
+
+
+(function () {
+
+ var colProto = seriesTypes.column.prototype;
+
+ /**
+ * The ColumnRangeSeries class
+ */
+ defaultPlotOptions.columnrange = merge(defaultPlotOptions.column, defaultPlotOptions.arearange, {
+ lineWidth: 1,
+ pointRange: null
+ });
+
+ /**
+ * ColumnRangeSeries object
+ */
+ seriesTypes.columnrange = extendClass(seriesTypes.arearange, {
+ type: 'columnrange',
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis,
+ plotHigh;
+
+ colProto.translate.apply(series);
+
+ // Set plotLow and plotHigh
+ each(series.points, function (point) {
+ var shapeArgs = point.shapeArgs,
+ minPointLength = series.options.minPointLength,
+ heightDifference,
+ height,
+ y;
+
+ point.tooltipPos = null; // don't inherit from column
+ point.plotHigh = plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
+ point.plotLow = point.plotY;
+
+ // adjust shape
+ y = plotHigh;
+ height = point.plotY - plotHigh;
+
+ // Adjust for minPointLength
+ if (Math.abs(height) < minPointLength) {
+ heightDifference = (minPointLength - height);
+ height += heightDifference;
+ y -= heightDifference / 2;
+
+ // Adjust for negative ranges or reversed Y axis (#1457)
+ } else if (height < 0) {
+ height *= -1;
+ y -= height;
+ }
+
+ shapeArgs.height = height;
+ shapeArgs.y = y;
+ });
+ },
+ directTouch: true,
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ drawGraph: noop,
+ crispCol: colProto.crispCol,
+ pointAttrToOptions: colProto.pointAttrToOptions,
+ drawPoints: colProto.drawPoints,
+ drawTracker: colProto.drawTracker,
+ animate: colProto.animate,
+ getColumnMetrics: colProto.getColumnMetrics
+ });
+}());
+
+
+
+/*
+ * The GaugeSeries class
+ */
+
+
+
+/**
+ * Extend the default options
+ */
+defaultPlotOptions.gauge = merge(defaultPlotOptions.line, {
+ dataLabels: {
+ enabled: true,
+ defer: false,
+ y: 15,
+ borderWidth: 1,
+ borderColor: 'silver',
+ borderRadius: 3,
+ crop: false,
+ verticalAlign: 'top',
+ zIndex: 2
+ },
+ dial: {
+ // radius: '80%',
+ // backgroundColor: 'black',
+ // borderColor: 'silver',
+ // borderWidth: 0,
+ // baseWidth: 3,
+ // topWidth: 1,
+ // baseLength: '70%' // of radius
+ // rearLength: '10%'
+ },
+ pivot: {
+ //radius: 5,
+ //borderWidth: 0
+ //borderColor: 'silver',
+ //backgroundColor: 'black'
+ },
+ tooltip: {
+ headerFormat: ''
+ },
+ showInLegend: false
+});
+
+/**
+ * Extend the point object
+ */
+var GaugePoint = extendClass(Point, {
+ /**
+ * Don't do any hover colors or anything
+ */
+ setState: function (state) {
+ this.state = state;
+ }
+});
+
+
+/**
+ * Add the series type
+ */
+var GaugeSeries = {
+ type: 'gauge',
+ pointClass: GaugePoint,
+
+ // chart.angular will be set to true when a gauge series is present, and this will
+ // be used on the axes
+ angular: true,
+ drawGraph: noop,
+ fixedBox: true,
+ forceDL: true,
+ trackerGroups: ['group', 'dataLabelsGroup'],
+
+ /**
+ * Calculate paths etc
+ */
+ translate: function () {
+
+ var series = this,
+ yAxis = series.yAxis,
+ options = series.options,
+ center = yAxis.center;
+
+ series.generatePoints();
+
+ each(series.points, function (point) {
+
+ var dialOptions = merge(options.dial, point.dial),
+ radius = (pInt(pick(dialOptions.radius, 80)) * center[2]) / 200,
+ baseLength = (pInt(pick(dialOptions.baseLength, 70)) * radius) / 100,
+ rearLength = (pInt(pick(dialOptions.rearLength, 10)) * radius) / 100,
+ baseWidth = dialOptions.baseWidth || 3,
+ topWidth = dialOptions.topWidth || 1,
+ overshoot = options.overshoot,
+ rotation = yAxis.startAngleRad + yAxis.translate(point.y, null, null, null, true);
+
+ // Handle the wrap and overshoot options
+ if (overshoot && typeof overshoot === 'number') {
+ overshoot = overshoot / 180 * Math.PI;
+ rotation = Math.max(yAxis.startAngleRad - overshoot, Math.min(yAxis.endAngleRad + overshoot, rotation));
+
+ } else if (options.wrap === false) {
+ rotation = Math.max(yAxis.startAngleRad, Math.min(yAxis.endAngleRad, rotation));
+ }
+
+ rotation = rotation * 180 / Math.PI;
+
+ point.shapeType = 'path';
+ point.shapeArgs = {
+ d: dialOptions.path || [
+ 'M',
+ -rearLength, -baseWidth / 2,
+ 'L',
+ baseLength, -baseWidth / 2,
+ radius, -topWidth / 2,
+ radius, topWidth / 2,
+ baseLength, baseWidth / 2,
+ -rearLength, baseWidth / 2,
+ 'z'
+ ],
+ translateX: center[0],
+ translateY: center[1],
+ rotation: rotation
+ };
+
+ // Positions for data label
+ point.plotX = center[0];
+ point.plotY = center[1];
+ });
+ },
+
+ /**
+ * Draw the points where each point is one needle
+ */
+ drawPoints: function () {
+
+ var series = this,
+ center = series.yAxis.center,
+ pivot = series.pivot,
+ options = series.options,
+ pivotOptions = options.pivot,
+ renderer = series.chart.renderer;
+
+ each(series.points, function (point) {
+
+ var graphic = point.graphic,
+ shapeArgs = point.shapeArgs,
+ d = shapeArgs.d,
+ dialOptions = merge(options.dial, point.dial); // #1233
+
+ if (graphic) {
+ graphic.animate(shapeArgs);
+ shapeArgs.d = d; // animate alters it
+ } else {
+ point.graphic = renderer[point.shapeType](shapeArgs)
+ .attr({
+ stroke: dialOptions.borderColor || 'none',
+ 'stroke-width': dialOptions.borderWidth || 0,
+ fill: dialOptions.backgroundColor || 'black',
+ rotation: shapeArgs.rotation // required by VML when animation is false
+ })
+ .add(series.group);
+ }
+ });
+
+ // Add or move the pivot
+ if (pivot) {
+ pivot.animate({ // #1235
+ translateX: center[0],
+ translateY: center[1]
+ });
+ } else {
+ series.pivot = renderer.circle(0, 0, pick(pivotOptions.radius, 5))
+ .attr({
+ 'stroke-width': pivotOptions.borderWidth || 0,
+ stroke: pivotOptions.borderColor || 'silver',
+ fill: pivotOptions.backgroundColor || 'black'
+ })
+ .translate(center[0], center[1])
+ .add(series.group);
+ }
+ },
+
+ /**
+ * Animate the arrow up from startAngle
+ */
+ animate: function (init) {
+ var series = this;
+
+ if (!init) {
+ each(series.points, function (point) {
+ var graphic = point.graphic;
+
+ if (graphic) {
+ // start value
+ graphic.attr({
+ rotation: series.yAxis.startAngleRad * 180 / Math.PI
+ });
+
+ // animate
+ graphic.animate({
+ rotation: point.shapeArgs.rotation
+ }, series.options.animation);
+ }
+ });
+
+ // delete this function to allow it only once
+ series.animate = null;
+ }
+ },
+
+ render: function () {
+ this.group = this.plotGroup(
+ 'group',
+ 'series',
+ this.visible ? 'visible' : 'hidden',
+ this.options.zIndex,
+ this.chart.seriesGroup
+ );
+ Series.prototype.render.call(this);
+ this.group.clip(this.chart.clipRect);
+ },
+
+ /**
+ * Extend the basic setData method by running processData and generatePoints immediately,
+ * in order to access the points from the legend.
+ */
+ setData: function (data, redraw) {
+ Series.prototype.setData.call(this, data, false);
+ this.processData();
+ this.generatePoints();
+ if (pick(redraw, true)) {
+ this.chart.redraw();
+ }
+ },
+
+ /**
+ * If the tracking module is loaded, add the point tracker
+ */
+ drawTracker: TrackerMixin && TrackerMixin.drawTrackerPoint
+};
+seriesTypes.gauge = extendClass(seriesTypes.line, GaugeSeries);
+
+
+
+/* ****************************************************************************
+ * Start Box plot series code *
+ *****************************************************************************/
+
+// Set default options
+defaultPlotOptions.boxplot = merge(defaultPlotOptions.column, {
+ fillColor: '#FFFFFF',
+ lineWidth: 1,
+ //medianColor: null,
+ medianWidth: 2,
+ states: {
+ hover: {
+ brightness: -0.3
+ }
+ },
+ //stemColor: null,
+ //stemDashStyle: 'solid'
+ //stemWidth: null,
+ threshold: null,
+ tooltip: {
+ pointFormat: '\u25CF {series.name}
' + // docs
+ 'Maximum: {point.high}
' +
+ 'Upper quartile: {point.q3}
' +
+ 'Median: {point.median}
' +
+ 'Lower quartile: {point.q1}
' +
+ 'Minimum: {point.low}
'
+
+ },
+ //whiskerColor: null,
+ whiskerLength: '50%',
+ whiskerWidth: 2
+});
+
+// Create the series object
+seriesTypes.boxplot = extendClass(seriesTypes.column, {
+ type: 'boxplot',
+ pointArrayMap: ['low', 'q1', 'median', 'q3', 'high'], // array point configs are mapped to this
+ toYData: function (point) { // return a plain array for speedy calculation
+ return [point.low, point.q1, point.median, point.q3, point.high];
+ },
+ pointValKey: 'high', // defines the top of the tracker
+
+ /**
+ * One-to-one mapping from options to SVG attributes
+ */
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ fill: 'fillColor',
+ stroke: 'color',
+ 'stroke-width': 'lineWidth'
+ },
+
+ /**
+ * Disable data labels for box plot
+ */
+ drawDataLabels: noop,
+
+ /**
+ * Translate data points from raw values x and y to plotX and plotY
+ */
+ translate: function () {
+ var series = this,
+ yAxis = series.yAxis,
+ pointArrayMap = series.pointArrayMap;
+
+ seriesTypes.column.prototype.translate.apply(series);
+
+ // do the translation on each point dimension
+ each(series.points, function (point) {
+ each(pointArrayMap, function (key) {
+ if (point[key] !== null) {
+ point[key + 'Plot'] = yAxis.translate(point[key], 0, 1, 0, 1);
+ }
+ });
+ });
+ },
+
+ /**
+ * Draw the data points
+ */
+ drawPoints: function () {
+ var series = this, //state = series.state,
+ points = series.points,
+ options = series.options,
+ chart = series.chart,
+ renderer = chart.renderer,
+ pointAttr,
+ q1Plot,
+ q3Plot,
+ highPlot,
+ lowPlot,
+ medianPlot,
+ crispCorr,
+ crispX,
+ graphic,
+ stemPath,
+ stemAttr,
+ boxPath,
+ whiskersPath,
+ whiskersAttr,
+ medianPath,
+ medianAttr,
+ width,
+ left,
+ right,
+ halfWidth,
+ shapeArgs,
+ color,
+ doQuartiles = series.doQuartiles !== false, // error bar inherits this series type but doesn't do quartiles
+ pointWiskerLength,
+ whiskerLength = series.options.whiskerLength;
+
+
+ each(points, function (point) {
+
+ graphic = point.graphic;
+ shapeArgs = point.shapeArgs; // the box
+ stemAttr = {};
+ whiskersAttr = {};
+ medianAttr = {};
+ color = point.color || series.color;
+
+ if (point.plotY !== UNDEFINED) {
+
+ pointAttr = point.pointAttr[point.selected ? 'selected' : ''];
+
+ // crisp vector coordinates
+ width = shapeArgs.width;
+ left = mathFloor(shapeArgs.x);
+ right = left + width;
+ halfWidth = mathRound(width / 2);
+ //crispX = mathRound(left + halfWidth) + crispCorr;
+ q1Plot = mathFloor(doQuartiles ? point.q1Plot : point.lowPlot);// + crispCorr;
+ q3Plot = mathFloor(doQuartiles ? point.q3Plot : point.lowPlot);// + crispCorr;
+ highPlot = mathFloor(point.highPlot);// + crispCorr;
+ lowPlot = mathFloor(point.lowPlot);// + crispCorr;
+
+ // Stem attributes
+ stemAttr.stroke = point.stemColor || options.stemColor || color;
+ stemAttr['stroke-width'] = pick(point.stemWidth, options.stemWidth, options.lineWidth);
+ stemAttr.dashstyle = point.stemDashStyle || options.stemDashStyle;
+
+ // Whiskers attributes
+ whiskersAttr.stroke = point.whiskerColor || options.whiskerColor || color;
+ whiskersAttr['stroke-width'] = pick(point.whiskerWidth, options.whiskerWidth, options.lineWidth);
+
+ // Median attributes
+ medianAttr.stroke = point.medianColor || options.medianColor || color;
+ medianAttr['stroke-width'] = pick(point.medianWidth, options.medianWidth, options.lineWidth);
+
+ // The stem
+ crispCorr = (stemAttr['stroke-width'] % 2) / 2;
+ crispX = left + halfWidth + crispCorr;
+ stemPath = [
+ // stem up
+ 'M',
+ crispX, q3Plot,
+ 'L',
+ crispX, highPlot,
+
+ // stem down
+ 'M',
+ crispX, q1Plot,
+ 'L',
+ crispX, lowPlot
+ ];
+
+ // The box
+ if (doQuartiles) {
+ crispCorr = (pointAttr['stroke-width'] % 2) / 2;
+ crispX = mathFloor(crispX) + crispCorr;
+ q1Plot = mathFloor(q1Plot) + crispCorr;
+ q3Plot = mathFloor(q3Plot) + crispCorr;
+ left += crispCorr;
+ right += crispCorr;
+ boxPath = [
+ 'M',
+ left, q3Plot,
+ 'L',
+ left, q1Plot,
+ 'L',
+ right, q1Plot,
+ 'L',
+ right, q3Plot,
+ 'L',
+ left, q3Plot,
+ 'z'
+ ];
+ }
+
+ // The whiskers
+ if (whiskerLength) {
+ crispCorr = (whiskersAttr['stroke-width'] % 2) / 2;
+ highPlot = highPlot + crispCorr;
+ lowPlot = lowPlot + crispCorr;
+ pointWiskerLength = (/%$/).test(whiskerLength) ? halfWidth * parseFloat(whiskerLength) / 100 : whiskerLength / 2;
+ whiskersPath = [
+ // High whisker
+ 'M',
+ crispX - pointWiskerLength,
+ highPlot,
+ 'L',
+ crispX + pointWiskerLength,
+ highPlot,
+
+ // Low whisker
+ 'M',
+ crispX - pointWiskerLength,
+ lowPlot,
+ 'L',
+ crispX + pointWiskerLength,
+ lowPlot
+ ];
+ }
+
+ // The median
+ crispCorr = (medianAttr['stroke-width'] % 2) / 2;
+ medianPlot = mathRound(point.medianPlot) + crispCorr;
+ medianPath = [
+ 'M',
+ left,
+ medianPlot,
+ 'L',
+ right,
+ medianPlot
+ ];
+
+ // Create or update the graphics
+ if (graphic) { // update
+
+ point.stem.animate({ d: stemPath });
+ if (whiskerLength) {
+ point.whiskers.animate({ d: whiskersPath });
+ }
+ if (doQuartiles) {
+ point.box.animate({ d: boxPath });
+ }
+ point.medianShape.animate({ d: medianPath });
+
+ } else { // create new
+ point.graphic = graphic = renderer.g()
+ .add(series.group);
+
+ point.stem = renderer.path(stemPath)
+ .attr(stemAttr)
+ .add(graphic);
+
+ if (whiskerLength) {
+ point.whiskers = renderer.path(whiskersPath)
+ .attr(whiskersAttr)
+ .add(graphic);
+ }
+ if (doQuartiles) {
+ point.box = renderer.path(boxPath)
+ .attr(pointAttr)
+ .add(graphic);
+ }
+ point.medianShape = renderer.path(medianPath)
+ .attr(medianAttr)
+ .add(graphic);
+ }
+ }
+ });
+
+ },
+ setStackedPoints: noop // #3890
+
+
+});
+
+/* ****************************************************************************
+ * End Box plot series code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start error bar series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.errorbar = merge(defaultPlotOptions.boxplot, {
+ color: '#000000',
+ grouping: false,
+ linkedTo: ':previous',
+ tooltip: {
+ pointFormat: '\u25CF {series.name}: {point.low} - {point.high}
' // docs
+ },
+ whiskerWidth: null
+});
+
+// 2 - Create the series object
+seriesTypes.errorbar = extendClass(seriesTypes.boxplot, {
+ type: 'errorbar',
+ pointArrayMap: ['low', 'high'], // array point configs are mapped to this
+ toYData: function (point) { // return a plain array for speedy calculation
+ return [point.low, point.high];
+ },
+ pointValKey: 'high', // defines the top of the tracker
+ doQuartiles: false,
+ drawDataLabels: seriesTypes.arearange ? seriesTypes.arearange.prototype.drawDataLabels : noop,
+
+ /**
+ * Get the width and X offset, either on top of the linked series column
+ * or standalone
+ */
+ getColumnMetrics: function () {
+ return (this.linkedParent && this.linkedParent.columnMetrics) ||
+ seriesTypes.column.prototype.getColumnMetrics.call(this);
+ }
+});
+
+/* ****************************************************************************
+ * End error bar series code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start Waterfall series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.waterfall = merge(defaultPlotOptions.column, {
+ lineWidth: 1,
+ lineColor: '#333',
+ dashStyle: 'dot',
+ borderColor: '#333',
+ dataLabels: {
+ inside: true
+ },
+ states: {
+ hover: {
+ lineWidthPlus: 0 // #3126
+ }
+ }
+});
+
+
+// 2 - Create the series object
+seriesTypes.waterfall = extendClass(seriesTypes.column, {
+ type: 'waterfall',
+
+ upColorProp: 'fill',
+
+ pointValKey: 'y',
+
+ /**
+ * Translate data points from raw values
+ */
+ translate: function () {
+ var series = this,
+ options = series.options,
+ yAxis = series.yAxis,
+ len,
+ i,
+ points,
+ point,
+ shapeArgs,
+ stack,
+ y,
+ yValue,
+ previousY,
+ previousIntermediate,
+ range,
+ threshold = options.threshold,
+ stacking = options.stacking,
+ tooltipY;
+
+ // run column series translate
+ seriesTypes.column.prototype.translate.apply(this);
+
+ previousY = previousIntermediate = threshold;
+ points = series.points;
+
+ for (i = 0, len = points.length; i < len; i++) {
+ // cache current point object
+ point = points[i];
+ yValue = this.processedYData[i];
+ shapeArgs = point.shapeArgs;
+
+ // get current stack
+ stack = stacking && yAxis.stacks[(series.negStacks && yValue < threshold ? '-' : '') + series.stackKey];
+ range = stack ?
+ stack[point.x].points[series.index + ',' + i] :
+ [0, yValue];
+
+ // override point value for sums
+ // #3710 Update point does not propagate to sum
+ if (point.isSum) {
+ point.y = yValue;
+ } else if (point.isIntermediateSum) {
+ point.y = yValue - previousIntermediate; // #3840
+ }
+ // up points
+ y = mathMax(previousY, previousY + point.y) + range[0];
+ shapeArgs.y = yAxis.translate(y, 0, 1);
+
+
+ // sum points
+ if (point.isSum) {
+ shapeArgs.y = yAxis.translate(range[1], 0, 1);
+ shapeArgs.height = Math.min(yAxis.translate(range[0], 0, 1), yAxis.len) - shapeArgs.y; // #4256
+
+ } else if (point.isIntermediateSum) {
+ shapeArgs.y = yAxis.translate(range[1], 0, 1);
+ shapeArgs.height = Math.min(yAxis.translate(previousIntermediate, 0, 1), yAxis.len) - shapeArgs.y;
+ previousIntermediate = range[1];
+
+ // If it's not the sum point, update previous stack end position and get
+ // shape height (#3886)
+ } else {
+ if (previousY !== 0) { // Not the first point
+ shapeArgs.height = yValue > 0 ?
+ yAxis.translate(previousY, 0, 1) - shapeArgs.y :
+ yAxis.translate(previousY, 0, 1) - yAxis.translate(previousY - yValue, 0, 1);
+ }
+ previousY += yValue;
+ }
+ // #3952 Negative sum or intermediate sum not rendered correctly
+ if (shapeArgs.height < 0) {
+ shapeArgs.y += shapeArgs.height;
+ shapeArgs.height *= -1;
+ }
+
+ point.plotY = shapeArgs.y = mathRound(shapeArgs.y) - (series.borderWidth % 2) / 2;
+ shapeArgs.height = mathMax(mathRound(shapeArgs.height), 0.001); // #3151
+ point.yBottom = shapeArgs.y + shapeArgs.height;
+
+ // Correct tooltip placement (#3014)
+ tooltipY = point.plotY + (point.negative ? shapeArgs.height : 0);
+ if (series.chart.inverted) {
+ point.tooltipPos[0] = yAxis.len - tooltipY;
+ } else {
+ point.tooltipPos[1] = tooltipY;
+ }
+
+ }
+ },
+
+ /**
+ * Call default processData then override yData to reflect waterfall's extremes on yAxis
+ */
+ processData: function (force) {
+ var series = this,
+ options = series.options,
+ yData = series.yData,
+ points = series.options.data, // #3710 Update point does not propagate to sum
+ point,
+ dataLength = yData.length,
+ threshold = options.threshold || 0,
+ subSum,
+ sum,
+ dataMin,
+ dataMax,
+ y,
+ i;
+
+ sum = subSum = dataMin = dataMax = threshold;
+
+ for (i = 0; i < dataLength; i++) {
+ y = yData[i];
+ point = points && points[i] ? points[i] : {};
+
+ if (y === "sum" || point.isSum) {
+ yData[i] = sum;
+ } else if (y === "intermediateSum" || point.isIntermediateSum) {
+ yData[i] = subSum;
+ } else {
+ sum += y;
+ subSum += y;
+ }
+ dataMin = Math.min(sum, dataMin);
+ dataMax = Math.max(sum, dataMax);
+ }
+
+ Series.prototype.processData.call(this, force);
+
+ // Record extremes
+ series.dataMin = dataMin;
+ series.dataMax = dataMax;
+ },
+
+ /**
+ * Return y value or string if point is sum
+ */
+ toYData: function (pt) {
+ if (pt.isSum) {
+ return (pt.x === 0 ? null : "sum"); //#3245 Error when first element is Sum or Intermediate Sum
+ } else if (pt.isIntermediateSum) {
+ return (pt.x === 0 ? null : "intermediateSum"); //#3245
+ }
+ return pt.y;
+ },
+
+ /**
+ * Postprocess mapping between options and SVG attributes
+ */
+ getAttribs: function () {
+ seriesTypes.column.prototype.getAttribs.apply(this, arguments);
+
+ var series = this,
+ options = series.options,
+ stateOptions = options.states,
+ upColor = options.upColor || series.color,
+ hoverColor = Highcharts.Color(upColor).brighten(0.1).get(),
+ seriesDownPointAttr = merge(series.pointAttr),
+ upColorProp = series.upColorProp;
+
+ seriesDownPointAttr[''][upColorProp] = upColor;
+ seriesDownPointAttr.hover[upColorProp] = stateOptions.hover.upColor || hoverColor;
+ seriesDownPointAttr.select[upColorProp] = stateOptions.select.upColor || upColor;
+
+ each(series.points, function (point) {
+ if (!point.options.color) {
+ // Up color
+ if (point.y > 0) {
+ point.pointAttr = seriesDownPointAttr;
+ point.color = upColor;
+
+ // Down color (#3710, update to negative)
+ } else {
+ point.pointAttr = series.pointAttr;
+ }
+ }
+ });
+ },
+
+ /**
+ * Draw columns' connector lines
+ */
+ getGraphPath: function () {
+
+ var data = this.data,
+ length = data.length,
+ lineWidth = this.options.lineWidth + this.borderWidth,
+ normalizer = mathRound(lineWidth) % 2 / 2,
+ path = [],
+ M = 'M',
+ L = 'L',
+ prevArgs,
+ pointArgs,
+ i,
+ d;
+
+ for (i = 1; i < length; i++) {
+ pointArgs = data[i].shapeArgs;
+ prevArgs = data[i - 1].shapeArgs;
+
+ d = [
+ M,
+ prevArgs.x + prevArgs.width, prevArgs.y + normalizer,
+ L,
+ pointArgs.x, prevArgs.y + normalizer
+ ];
+
+ if (data[i - 1].y < 0) {
+ d[2] += prevArgs.height;
+ d[5] += prevArgs.height;
+ }
+
+ path = path.concat(d);
+ }
+
+ return path;
+ },
+
+ /**
+ * Extremes are recorded in processData
+ */
+ getExtremes: noop,
+
+ drawGraph: Series.prototype.drawGraph
+});
+
+/* ****************************************************************************
+ * End Waterfall series code *
+ *****************************************************************************/
+
+
+/* ****************************************************************************
+ * Start Bubble series code *
+ *****************************************************************************/
+
+// 1 - set default options
+defaultPlotOptions.bubble = merge(defaultPlotOptions.scatter, {
+ dataLabels: {
+ formatter: function () { // #2945
+ return this.point.z;
+ },
+ inside: true,
+ verticalAlign: 'middle'
+ },
+ // displayNegative: true,
+ marker: {
+ // fillOpacity: 0.5,
+ lineColor: null, // inherit from series.color
+ lineWidth: 1
+ },
+ minSize: 8,
+ maxSize: '20%',
+ // negativeColor: null,
+ // sizeBy: 'area'
+ softThreshold: false,
+ states: {
+ hover: {
+ halo: {
+ size: 5
+ }
+ }
+ },
+ tooltip: {
+ pointFormat: '({point.x}, {point.y}), Size: {point.z}'
+ },
+ turboThreshold: 0,
+ zThreshold: 0,
+ zoneAxis: 'z'
+});
+
+var BubblePoint = extendClass(Point, {
+ haloPath: function () {
+ return Point.prototype.haloPath.call(this, this.shapeArgs.r + this.series.options.states.hover.halo.size);
+ },
+ ttBelow: false
+});
+
+// 2 - Create the series object
+seriesTypes.bubble = extendClass(seriesTypes.scatter, {
+ type: 'bubble',
+ pointClass: BubblePoint,
+ pointArrayMap: ['y', 'z'],
+ parallelArrays: ['x', 'y', 'z'],
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ bubblePadding: true,
+ zoneAxis: 'z',
+
+ /**
+ * Mapping between SVG attributes and the corresponding options
+ */
+ pointAttrToOptions: {
+ stroke: 'lineColor',
+ 'stroke-width': 'lineWidth',
+ fill: 'fillColor'
+ },
+
+ /**
+ * Apply the fillOpacity to all fill positions
+ */
+ applyOpacity: function (fill) {
+ var markerOptions = this.options.marker,
+ fillOpacity = pick(markerOptions.fillOpacity, 0.5);
+
+ // When called from Legend.colorizeItem, the fill isn't predefined
+ fill = fill || markerOptions.fillColor || this.color;
+
+ if (fillOpacity !== 1) {
+ fill = Color(fill).setOpacity(fillOpacity).get('rgba');
+ }
+ return fill;
+ },
+
+ /**
+ * Extend the convertAttribs method by applying opacity to the fill
+ */
+ convertAttribs: function () {
+ var obj = Series.prototype.convertAttribs.apply(this, arguments);
+
+ obj.fill = this.applyOpacity(obj.fill);
+
+ return obj;
+ },
+
+ /**
+ * Get the radius for each point based on the minSize, maxSize and each point's Z value. This
+ * must be done prior to Series.translate because the axis needs to add padding in
+ * accordance with the point sizes.
+ */
+ getRadii: function (zMin, zMax, minSize, maxSize) {
+ var len,
+ i,
+ pos,
+ zData = this.zData,
+ radii = [],
+ options = this.options,
+ sizeByArea = options.sizeBy !== 'width',
+ zThreshold = options.zThreshold,
+ zRange = zMax - zMin,
+ value,
+ radius;
+
+ // Set the shape type and arguments to be picked up in drawPoints
+ for (i = 0, len = zData.length; i < len; i++) {
+
+ value = zData[i];
+
+ // When sizing by threshold, the absolute value of z determines the size
+ // of the bubble.
+ if (options.sizeByAbsoluteValue) {
+ value = Math.abs(value - zThreshold);
+ zMax = Math.max(zMax - zThreshold, Math.abs(zMin - zThreshold));
+ zMin = 0;
+ }
+
+ if (value === null) {
+ radius = null;
+ // Issue #4419 - if value is less than zMin, push a radius that's always smaller than the minimum size
+ } else if (value < zMin) {
+ radius = minSize / 2 - 1;
+ } else {
+ // Relative size, a number between 0 and 1
+ pos = zRange > 0 ? (value - zMin) / zRange : 0.5;
+
+ if (sizeByArea && pos >= 0) {
+ pos = Math.sqrt(pos);
+ }
+ radius = math.ceil(minSize + pos * (maxSize - minSize)) / 2;
+ }
+ radii.push(radius);
+ }
+ this.radii = radii;
+ },
+
+ /**
+ * Perform animation on the bubbles
+ */
+ animate: function (init) {
+ var animation = this.options.animation;
+
+ if (!init) { // run the animation
+ each(this.points, function (point) {
+ var graphic = point.graphic,
+ shapeArgs = point.shapeArgs;
+
+ if (graphic && shapeArgs) {
+ // start values
+ graphic.attr('r', 1);
+
+ // animate
+ graphic.animate({
+ r: shapeArgs.r
+ }, animation);
+ }
+ });
+
+ // delete this function to allow it only once
+ this.animate = null;
+ }
+ },
+
+ /**
+ * Extend the base translate method to handle bubble size
+ */
+ translate: function () {
+
+ var i,
+ data = this.data,
+ point,
+ radius,
+ radii = this.radii;
+
+ // Run the parent method
+ seriesTypes.scatter.prototype.translate.call(this);
+
+ // Set the shape type and arguments to be picked up in drawPoints
+ i = data.length;
+
+ while (i--) {
+ point = data[i];
+ radius = radii ? radii[i] : 0; // #1737
+
+ if (typeof radius === 'number' && radius >= this.minPxSize / 2) {
+ // Shape arguments
+ point.shapeType = 'circle';
+ point.shapeArgs = {
+ x: point.plotX,
+ y: point.plotY,
+ r: radius
+ };
+
+ // Alignment box for the data label
+ point.dlBox = {
+ x: point.plotX - radius,
+ y: point.plotY - radius,
+ width: 2 * radius,
+ height: 2 * radius
+ };
+ } else { // below zThreshold or z = null
+ point.shapeArgs = point.plotY = point.dlBox = UNDEFINED; // #1691
+ }
+ }
+ },
+
+ /**
+ * Get the series' symbol in the legend
+ *
+ * @param {Object} legend The legend object
+ * @param {Object} item The series (this) or point
+ */
+ drawLegendSymbol: function (legend, item) {
+ var radius = pInt(legend.itemStyle.fontSize) / 2;
+
+ item.legendSymbol = this.chart.renderer.circle(
+ radius,
+ legend.baseline - radius,
+ radius
+ ).attr({
+ zIndex: 3
+ }).add(item.legendGroup);
+ item.legendSymbol.isMarker = true;
+
+ },
+
+ drawPoints: seriesTypes.column.prototype.drawPoints,
+ alignDataLabel: seriesTypes.column.prototype.alignDataLabel,
+ buildKDTree: noop,
+ applyZones: noop
+});
+
+/**
+ * Add logic to pad each axis with the amount of pixels
+ * necessary to avoid the bubbles to overflow.
+ */
+Axis.prototype.beforePadding = function () {
+ var axis = this,
+ axisLength = this.len,
+ chart = this.chart,
+ pxMin = 0,
+ pxMax = axisLength,
+ isXAxis = this.isXAxis,
+ dataKey = isXAxis ? 'xData' : 'yData',
+ min = this.min,
+ extremes = {},
+ smallestSize = math.min(chart.plotWidth, chart.plotHeight),
+ zMin = Number.MAX_VALUE,
+ zMax = -Number.MAX_VALUE,
+ range = this.max - min,
+ transA = axisLength / range,
+ activeSeries = [];
+
+ // Handle padding on the second pass, or on redraw
+ each(this.series, function (series) {
+
+ var seriesOptions = series.options,
+ zData;
+
+ if (series.bubblePadding && (series.visible || !chart.options.chart.ignoreHiddenSeries)) {
+
+ // Correction for #1673
+ axis.allowZoomOutside = true;
+
+ // Cache it
+ activeSeries.push(series);
+
+ if (isXAxis) { // because X axis is evaluated first
+
+ // For each series, translate the size extremes to pixel values
+ each(['minSize', 'maxSize'], function (prop) {
+ var length = seriesOptions[prop],
+ isPercent = /%$/.test(length);
+
+ length = pInt(length);
+ extremes[prop] = isPercent ?
+ smallestSize * length / 100 :
+ length;
+
+ });
+ series.minPxSize = extremes.minSize;
+ series.maxPxSize = extremes.maxSize;
+
+ // Find the min and max Z
+ zData = series.zData;
+ if (zData.length) { // #1735
+ zMin = pick(seriesOptions.zMin, math.min(
+ zMin,
+ math.max(
+ arrayMin(zData),
+ seriesOptions.displayNegative === false ? seriesOptions.zThreshold : -Number.MAX_VALUE
+ )
+ ));
+ zMax = pick(seriesOptions.zMax, math.max(zMax, arrayMax(zData)));
+ }
+ }
+ }
+ });
+
+ each(activeSeries, function (series) {
+
+ var data = series[dataKey],
+ i = data.length,
+ radius;
+
+ if (isXAxis) {
+ series.getRadii(zMin, zMax, series.minPxSize, series.maxPxSize);
+ }
+
+ if (range > 0) {
+ while (i--) {
+ if (typeof data[i] === 'number') {
+ radius = series.radii[i];
+ pxMin = Math.min(((data[i] - min) * transA) - radius, pxMin);
+ pxMax = Math.max(((data[i] - min) * transA) + radius, pxMax);
+ }
+ }
+ }
+ });
+
+
+ if (activeSeries.length && range > 0 && !this.isLog) {
+ pxMax -= axisLength;
+ transA *= (axisLength + pxMin - pxMax) / axisLength;
+ each([['min', 'userMin', pxMin], ['max', 'userMax', pxMax]], function (keys) {
+ if (pick(axis.options[keys[0]], axis[keys[1]]) === UNDEFINED) {
+ axis[keys[0]] += keys[2] / transA;
+ }
+ });
+ }
+};
+
+/* ****************************************************************************
+ * End Bubble series code *
+ *****************************************************************************/
+
+
+
+(function () {
+
+ /**
+ * Extensions for polar charts. Additionally, much of the geometry required for polar charts is
+ * gathered in RadialAxes.js.
+ *
+ */
+
+ var seriesProto = Series.prototype,
+ pointerProto = Pointer.prototype,
+ colProto;
+
+ /**
+ * Search a k-d tree by the point angle, used for shared tooltips in polar charts
+ */
+ seriesProto.searchPointByAngle = function (e) {
+ var series = this,
+ chart = series.chart,
+ xAxis = series.xAxis,
+ center = xAxis.pane.center,
+ plotX = e.chartX - center[0] - chart.plotLeft,
+ plotY = e.chartY - center[1] - chart.plotTop;
+
+ return this.searchKDTree({
+ clientX: 180 + (Math.atan2(plotX, plotY) * (-180 / Math.PI))
+ });
+
+ };
+
+ /**
+ * Wrap the buildKDTree function so that it searches by angle (clientX) in case of shared tooltip,
+ * and by two dimensional distance in case of non-shared.
+ */
+ wrap(seriesProto, 'buildKDTree', function (proceed) {
+ if (this.chart.polar) {
+ if (this.kdByAngle) {
+ this.searchPoint = this.searchPointByAngle;
+ } else {
+ this.kdDimensions = 2;
+ }
+ }
+ proceed.apply(this);
+ });
+
+ /**
+ * Translate a point's plotX and plotY from the internal angle and radius measures to
+ * true plotX, plotY coordinates
+ */
+ seriesProto.toXY = function (point) {
+ var xy,
+ chart = this.chart,
+ plotX = point.plotX,
+ plotY = point.plotY,
+ clientX;
+
+ // Save rectangular plotX, plotY for later computation
+ point.rectPlotX = plotX;
+ point.rectPlotY = plotY;
+
+ // Find the polar plotX and plotY
+ xy = this.xAxis.postTranslate(point.plotX, this.yAxis.len - plotY);
+ point.plotX = point.polarPlotX = xy.x - chart.plotLeft;
+ point.plotY = point.polarPlotY = xy.y - chart.plotTop;
+
+ // If shared tooltip, record the angle in degrees in order to align X points. Otherwise,
+ // use a standard k-d tree to get the nearest point in two dimensions.
+ if (this.kdByAngle) {
+ clientX = ((plotX / Math.PI * 180) + this.xAxis.pane.options.startAngle) % 360;
+ if (clientX < 0) { // #2665
+ clientX += 360;
+ }
+ point.clientX = clientX;
+ } else {
+ point.clientX = point.plotX;
+ }
+ };
+
+ /**
+ * Add some special init logic to areas and areasplines
+ */
+ function initArea(proceed, chart, options) {
+ proceed.call(this, chart, options);
+ if (this.chart.polar) {
+
+ /**
+ * Overridden method to close a segment path. While in a cartesian plane the area
+ * goes down to the threshold, in the polar chart it goes to the center.
+ */
+ this.closeSegment = function (path) {
+ var center = this.xAxis.center;
+ path.push(
+ 'L',
+ center[0],
+ center[1]
+ );
+ };
+
+ // Instead of complicated logic to draw an area around the inner area in a stack,
+ // just draw it behind
+ this.closedStacks = true;
+ }
+ }
+
+
+ if (seriesTypes.area) {
+ wrap(seriesTypes.area.prototype, 'init', initArea);
+ }
+ if (seriesTypes.areaspline) {
+ wrap(seriesTypes.areaspline.prototype, 'init', initArea);
+ }
+
+ if (seriesTypes.spline) {
+ /**
+ * Overridden method for calculating a spline from one point to the next
+ */
+ wrap(seriesTypes.spline.prototype, 'getPointSpline', function (proceed, segment, point, i) {
+
+ var ret,
+ smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
+ denom = smoothing + 1,
+ plotX,
+ plotY,
+ lastPoint,
+ nextPoint,
+ lastX,
+ lastY,
+ nextX,
+ nextY,
+ leftContX,
+ leftContY,
+ rightContX,
+ rightContY,
+ distanceLeftControlPoint,
+ distanceRightControlPoint,
+ leftContAngle,
+ rightContAngle,
+ jointAngle;
+
+
+ if (this.chart.polar) {
+
+ plotX = point.plotX;
+ plotY = point.plotY;
+ lastPoint = segment[i - 1];
+ nextPoint = segment[i + 1];
+
+ // Connect ends
+ if (this.connectEnds) {
+ if (!lastPoint) {
+ lastPoint = segment[segment.length - 2]; // not the last but the second last, because the segment is already connected
+ }
+ if (!nextPoint) {
+ nextPoint = segment[1];
+ }
+ }
+
+ // find control points
+ if (lastPoint && nextPoint) {
+
+ lastX = lastPoint.plotX;
+ lastY = lastPoint.plotY;
+ nextX = nextPoint.plotX;
+ nextY = nextPoint.plotY;
+ leftContX = (smoothing * plotX + lastX) / denom;
+ leftContY = (smoothing * plotY + lastY) / denom;
+ rightContX = (smoothing * plotX + nextX) / denom;
+ rightContY = (smoothing * plotY + nextY) / denom;
+ distanceLeftControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
+ distanceRightControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
+ leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
+ rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
+ jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
+
+
+ // Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
+ if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
+ jointAngle -= Math.PI;
+ }
+
+ // Find the corrected control points for a spline straight through the point
+ leftContX = plotX + Math.cos(jointAngle) * distanceLeftControlPoint;
+ leftContY = plotY + Math.sin(jointAngle) * distanceLeftControlPoint;
+ rightContX = plotX + Math.cos(Math.PI + jointAngle) * distanceRightControlPoint;
+ rightContY = plotY + Math.sin(Math.PI + jointAngle) * distanceRightControlPoint;
+
+ // Record for drawing in next point
+ point.rightContX = rightContX;
+ point.rightContY = rightContY;
+
+ }
+
+
+ // moveTo or lineTo
+ if (!i) {
+ ret = ['M', plotX, plotY];
+ } else { // curve from last point to this
+ ret = [
+ 'C',
+ lastPoint.rightContX || lastPoint.plotX,
+ lastPoint.rightContY || lastPoint.plotY,
+ leftContX || plotX,
+ leftContY || plotY,
+ plotX,
+ plotY
+ ];
+ lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
+ }
+
+
+ } else {
+ ret = proceed.call(this, segment, point, i);
+ }
+ return ret;
+ });
+ }
+
+ /**
+ * Extend translate. The plotX and plotY values are computed as if the polar chart were a
+ * cartesian plane, where plotX denotes the angle in radians and (yAxis.len - plotY) is the pixel distance from
+ * center.
+ */
+ wrap(seriesProto, 'translate', function (proceed) {
+ var chart = this.chart,
+ points,
+ i;
+
+ // Run uber method
+ proceed.call(this);
+
+ // Postprocess plot coordinates
+ if (chart.polar) {
+ this.kdByAngle = chart.tooltip && chart.tooltip.shared;
+
+ if (!this.preventPostTranslate) {
+ points = this.points;
+ i = points.length;
+
+ while (i--) {
+ // Translate plotX, plotY from angle and radius to true plot coordinates
+ this.toXY(points[i]);
+ }
+ }
+ }
+ });
+
+ /**
+ * Extend getSegmentPath to allow connecting ends across 0 to provide a closed circle in
+ * line-like series.
+ */
+ wrap(seriesProto, 'getSegmentPath', function (proceed, segment) {
+
+ var points = this.points;
+
+ // Connect the path
+ if (this.chart.polar && this.options.connectEnds !== false &&
+ segment[segment.length - 1] === points[points.length - 1] && points[0].y !== null) {
+ this.connectEnds = true; // re-used in splines
+ segment = [].concat(segment, [points[0]]);
+ }
+
+ // Run uber method
+ return proceed.call(this, segment);
+
+ });
+
+
+ function polarAnimate(proceed, init) {
+ var chart = this.chart,
+ animation = this.options.animation,
+ group = this.group,
+ markerGroup = this.markerGroup,
+ center = this.xAxis.center,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop,
+ attribs;
+
+ // Specific animation for polar charts
+ if (chart.polar) {
+
+ // Enable animation on polar charts only in SVG. In VML, the scaling is different, plus animation
+ // would be so slow it would't matter.
+ if (chart.renderer.isSVG) {
+
+ if (animation === true) {
+ animation = {};
+ }
+
+ // Initialize the animation
+ if (init) {
+
+ // Scale down the group and place it in the center
+ attribs = {
+ translateX: center[0] + plotLeft,
+ translateY: center[1] + plotTop,
+ scaleX: 0.001, // #1499
+ scaleY: 0.001
+ };
+
+ group.attr(attribs);
+ if (markerGroup) {
+ //markerGroup.attrSetters = group.attrSetters;
+ markerGroup.attr(attribs);
+ }
+
+ // Run the animation
+ } else {
+ attribs = {
+ translateX: plotLeft,
+ translateY: plotTop,
+ scaleX: 1,
+ scaleY: 1
+ };
+ group.animate(attribs, animation);
+ if (markerGroup) {
+ markerGroup.animate(attribs, animation);
+ }
+
+ // Delete this function to allow it only once
+ this.animate = null;
+ }
+ }
+
+ // For non-polar charts, revert to the basic animation
+ } else {
+ proceed.call(this, init);
+ }
+ }
+
+ // Define the animate method for regular series
+ wrap(seriesProto, 'animate', polarAnimate);
+
+
+ if (seriesTypes.column) {
+
+ colProto = seriesTypes.column.prototype;
+ /**
+ * Define the animate method for columnseries
+ */
+ wrap(colProto, 'animate', polarAnimate);
+
+
+ /**
+ * Extend the column prototype's translate method
+ */
+ wrap(colProto, 'translate', function (proceed) {
+
+ var xAxis = this.xAxis,
+ len = this.yAxis.len,
+ center = xAxis.center,
+ startAngleRad = xAxis.startAngleRad,
+ renderer = this.chart.renderer,
+ start,
+ points,
+ point,
+ i;
+
+ this.preventPostTranslate = true;
+
+ // Run uber method
+ proceed.call(this);
+
+ // Postprocess plot coordinates
+ if (xAxis.isRadial) {
+ points = this.points;
+ i = points.length;
+ while (i--) {
+ point = points[i];
+ start = point.barX + startAngleRad;
+ point.shapeType = 'path';
+ point.shapeArgs = {
+ d: renderer.symbols.arc(
+ center[0],
+ center[1],
+ len - point.plotY,
+ null,
+ {
+ start: start,
+ end: start + point.pointWidth,
+ innerR: len - pick(point.yBottom, len)
+ }
+ )
+ };
+ // Provide correct plotX, plotY for tooltip
+ this.toXY(point);
+ point.tooltipPos = [point.plotX, point.plotY];
+ point.ttBelow = point.plotY > center[1];
+ }
+ }
+ });
+
+
+ /**
+ * Align column data labels outside the columns. #1199.
+ */
+ wrap(colProto, 'alignDataLabel', function (proceed, point, dataLabel, options, alignTo, isNew) {
+
+ if (this.chart.polar) {
+ var angle = point.rectPlotX / Math.PI * 180,
+ align,
+ verticalAlign;
+
+ // Align nicely outside the perimeter of the columns
+ if (options.align === null) {
+ if (angle > 20 && angle < 160) {
+ align = 'left'; // right hemisphere
+ } else if (angle > 200 && angle < 340) {
+ align = 'right'; // left hemisphere
+ } else {
+ align = 'center'; // top or bottom
+ }
+ options.align = align;
+ }
+ if (options.verticalAlign === null) {
+ if (angle < 45 || angle > 315) {
+ verticalAlign = 'bottom'; // top part
+ } else if (angle > 135 && angle < 225) {
+ verticalAlign = 'top'; // bottom part
+ } else {
+ verticalAlign = 'middle'; // left or right
+ }
+ options.verticalAlign = verticalAlign;
+ }
+
+ seriesProto.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
+ } else {
+ proceed.call(this, point, dataLabel, options, alignTo, isNew);
+ }
+
+ });
+ }
+
+ /**
+ * Extend getCoordinates to prepare for polar axis values
+ */
+ wrap(pointerProto, 'getCoordinates', function (proceed, e) {
+ var chart = this.chart,
+ ret = {
+ xAxis: [],
+ yAxis: []
+ };
+
+ if (chart.polar) {
+
+ each(chart.axes, function (axis) {
+ var isXAxis = axis.isXAxis,
+ center = axis.center,
+ x = e.chartX - center[0] - chart.plotLeft,
+ y = e.chartY - center[1] - chart.plotTop;
+
+ ret[isXAxis ? 'xAxis' : 'yAxis'].push({
+ axis: axis,
+ value: axis.translate(
+ isXAxis ?
+ Math.PI - Math.atan2(x, y) : // angle
+ Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)), // distance from center
+ true
+ )
+ });
+ });
+
+ } else {
+ ret = proceed.call(this, e);
+ }
+
+ return ret;
+ });
+
+}());
+
+
+
+// global variables
+extend(Highcharts, {
+
+ // Constructors
+ Color: Color,
+ Point: Point,
+ Tick: Tick,
+ Renderer: Renderer,
+ SVGElement: SVGElement,
+ SVGRenderer: SVGRenderer,
+
+ // Various
+ arrayMin: arrayMin,
+ arrayMax: arrayMax,
+ charts: charts,
+ dateFormat: dateFormat,
+ error: error,
+ format: format,
+ pathAnim: pathAnim,
+ getOptions: getOptions,
+ hasBidiBug: hasBidiBug,
+ isTouchDevice: isTouchDevice,
+ setOptions: setOptions,
+ addEvent: addEvent,
+ removeEvent: removeEvent,
+ createElement: createElement,
+ discardElement: discardElement,
+ css: css,
+ each: each,
+ map: map,
+ merge: merge,
+ splat: splat,
+ extendClass: extendClass,
+ pInt: pInt,
+ svg: hasSVG,
+ canvas: useCanVG,
+ vml: !hasSVG && !useCanVG,
+ product: PRODUCT,
+ version: VERSION
+});
+
+
+
+}());
+
+
+/**
+ * @license
+ * Highcharts funnel module
+ *
+ * (c) 2010-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+/*global 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 = 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) {
+ return y > height - neckHeight || height === neckHeight ?
+ neckWidth :
+ neckWidth + (width - neckWidth) * ((height - neckHeight - y) / (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'
+});
+
+}(Highcharts));
+
+
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ * Exporting module
+ *
+ * (c) 2010-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+// JSLint options:
+/*global Highcharts, HighchartsAdapter, document, window, Math, setTimeout */
+
+(function (Highcharts) { // encapsulate
+
+// create shortcuts
+var Chart = Highcharts.Chart,
+ addEvent = Highcharts.addEvent,
+ removeEvent = Highcharts.removeEvent,
+ fireEvent = HighchartsAdapter.fireEvent,
+ createElement = Highcharts.createElement,
+ discardElement = Highcharts.discardElement,
+ css = Highcharts.css,
+ merge = Highcharts.merge,
+ each = Highcharts.each,
+ extend = Highcharts.extend,
+ splat = Highcharts.splat,
+ math = Math,
+ mathMax = math.max,
+ doc = document,
+ win = window,
+ isTouchDevice = Highcharts.isTouchDevice,
+ M = 'M',
+ L = 'L',
+ DIV = 'div',
+ HIDDEN = 'hidden',
+ NONE = 'none',
+ PREFIX = 'highcharts-',
+ ABSOLUTE = 'absolute',
+ PX = 'px',
+ UNDEFINED,
+ symbols = Highcharts.Renderer.prototype.symbols,
+ defaultOptions = Highcharts.getOptions(),
+ buttonOffset;
+
+ // Add language
+ extend(defaultOptions.lang, {
+ printChart: 'Print chart',
+ downloadPNG: 'Download PNG image',
+ downloadJPEG: 'Download JPEG image',
+ downloadPDF: 'Download PDF document',
+ downloadSVG: 'Download SVG vector image',
+ contextButtonTitle: 'Chart context menu'
+ });
+
+// Buttons and menus are collected in a separate config option set called 'navigation'.
+// This can be extended later to add control buttons like zoom and pan right click menus.
+defaultOptions.navigation = {
+ menuStyle: {
+ border: '1px solid #A0A0A0',
+ background: '#FFFFFF',
+ padding: '5px 0'
+ },
+ menuItemStyle: {
+ padding: '0 10px',
+ background: NONE,
+ color: '#303030',
+ fontSize: isTouchDevice ? '14px' : '11px'
+ },
+ menuItemHoverStyle: {
+ background: '#4572A5',
+ color: '#FFFFFF'
+ },
+
+ buttonOptions: {
+ symbolFill: '#E0E0E0',
+ symbolSize: 14,
+ symbolStroke: '#666',
+ symbolStrokeWidth: 3,
+ symbolX: 12.5,
+ symbolY: 10.5,
+ align: 'right',
+ buttonSpacing: 3,
+ height: 22,
+ // text: null,
+ theme: {
+ fill: 'white', // capture hover
+ stroke: 'none'
+ },
+ verticalAlign: 'top',
+ width: 24
+ }
+};
+
+
+
+// Add the export related options
+defaultOptions.exporting = {
+ //enabled: true,
+ //filename: 'chart',
+ type: 'image/png',
+ url: 'http://export.highcharts.com/',
+ //width: undefined,
+ //scale: 2
+ buttons: {
+ contextButton: {
+ menuClassName: PREFIX + 'contextmenu',
+ //x: -10,
+ symbol: 'menu',
+ _titleKey: 'contextButtonTitle',
+ menuItems: [{
+ textKey: 'printChart',
+ onclick: function () {
+ this.print();
+ }
+ }, {
+ separator: true
+ }, {
+ textKey: 'downloadPNG',
+ onclick: function () {
+ this.exportChart();
+ }
+ }, {
+ textKey: 'downloadJPEG',
+ onclick: function () {
+ this.exportChart({
+ type: 'image/jpeg'
+ });
+ }
+ }, {
+ textKey: 'downloadPDF',
+ onclick: function () {
+ this.exportChart({
+ type: 'application/pdf'
+ });
+ }
+ }, {
+ textKey: 'downloadSVG',
+ onclick: function () {
+ this.exportChart({
+ type: 'image/svg+xml'
+ });
+ }
+ }
+ // Enable this block to add "View SVG" to the dropdown menu
+ /*
+ ,{
+
+ text: 'View SVG',
+ onclick: function () {
+ var svg = this.getSVG()
+ .replace(//g, '>');
+
+ doc.body.innerHTML = '' + svg + '
';
+ }
+ } // */
+ ]
+ }
+ }
+};
+
+// Add the Highcharts.post utility
+Highcharts.post = function (url, data, formAttributes) {
+ var name,
+ form;
+
+ // create the form
+ form = createElement('form', merge({
+ method: 'post',
+ action: url,
+ enctype: 'multipart/form-data'
+ }, formAttributes), {
+ display: NONE
+ }, doc.body);
+
+ // add the data
+ for (name in data) {
+ createElement('input', {
+ type: HIDDEN,
+ name: name,
+ value: data[name]
+ }, null, form);
+ }
+
+ // submit
+ form.submit();
+
+ // clean up
+ discardElement(form);
+};
+
+extend(Chart.prototype, {
+
+ /**
+ * A collection of regex fixes on the produces SVG to account for expando properties,
+ * browser bugs, VML problems and other. Returns a cleaned SVG.
+ */
+ sanitizeSVG: function (svg) {
+ return svg
+ .replace(/zIndex="[^"]+"/g, '')
+ .replace(/isShadow="[^"]+"/g, '')
+ .replace(/symbolName="[^"]+"/g, '')
+ .replace(/jQuery[0-9]+="[^"]+"/g, '')
+ .replace(/url\([^#]+#/g, 'url(#')
+ .replace(/')
+ // Batik doesn't support rgba fills and strokes (#3095)
+ .replace(/(fill|stroke)="rgba\(([ 0-9]+,[ 0-9]+,[ 0-9]+),([ 0-9\.]+)\)"/g, '$1="rgb($2)" $1-opacity="$3"')
+ /* This fails in IE < 8
+ .replace(/([0-9]+)\.([0-9]+)/g, function(s1, s2, s3) { // round off to save weight
+ return s2 +'.'+ s3[0];
+ })*/
+
+ // Replace HTML entities, issue #347
+ .replace(/ /g, '\u00A0') // no-break space
+ .replace(//g, '\u00AD') // soft hyphen
+
+ // IE specific
+ .replace(/![]()
/g, '<$1title>')
+ .replace(/height=([^" ]+)/g, 'height="$1"')
+ .replace(/width=([^" ]+)/g, 'width="$1"')
+ .replace(/hc-svg-href="([^"]+)">/g, 'xlink:href="$1"/>')
+ .replace(/ id=([^" >]+)/g, ' id="$1"') // #4003
+ .replace(/class=([^" >]+)/g, 'class="$1"')
+ .replace(/ transform /g, ' ')
+ .replace(/:(path|rect)/g, '$1')
+ .replace(/style="([^"]+)"/g, function (s) {
+ return s.toLowerCase();
+ });
+ },
+
+ /**
+ * Return innerHTML of chart. Used as hook for plugins.
+ */
+ getChartHTML: function () {
+ return this.container.innerHTML;
+ },
+
+ /**
+ * Return an SVG representation of the chart
+ *
+ * @param additionalOptions {Object} Additional chart options for the generated SVG representation
+ */
+ getSVG: function (additionalOptions) {
+ var chart = this,
+ chartCopy,
+ sandbox,
+ svg,
+ seriesOptions,
+ sourceWidth,
+ sourceHeight,
+ cssWidth,
+ cssHeight,
+ html,
+ options = merge(chart.options, additionalOptions), // copy the options and add extra options
+ allowHTML = options.exporting.allowHTML; // docs: experimental, see #2473
+
+
+ // IE compatibility hack for generating SVG content that it doesn't really understand
+ if (!doc.createElementNS) {
+ /*jslint unparam: true*//* allow unused parameter ns in function below */
+ doc.createElementNS = function (ns, tagName) {
+ return doc.createElement(tagName);
+ };
+ /*jslint unparam: false*/
+ }
+
+ // create a sandbox where a new chart will be generated
+ sandbox = createElement(DIV, null, {
+ position: ABSOLUTE,
+ top: '-9999em',
+ width: chart.chartWidth + PX,
+ height: chart.chartHeight + PX
+ }, doc.body);
+
+ // get the source size
+ cssWidth = chart.renderTo.style.width;
+ cssHeight = chart.renderTo.style.height;
+ sourceWidth = options.exporting.sourceWidth ||
+ options.chart.width ||
+ (/px$/.test(cssWidth) && parseInt(cssWidth, 10)) ||
+ 600;
+ sourceHeight = options.exporting.sourceHeight ||
+ options.chart.height ||
+ (/px$/.test(cssHeight) && parseInt(cssHeight, 10)) ||
+ 400;
+
+ // override some options
+ extend(options.chart, {
+ animation: false,
+ renderTo: sandbox,
+ forExport: true,
+ renderer: 'SVGRenderer',
+ width: sourceWidth,
+ height: sourceHeight
+ });
+ options.exporting.enabled = false; // hide buttons in print
+ delete options.data; // #3004
+
+ // prepare for replicating the chart
+ options.series = [];
+ each(chart.series, function (serie) {
+ seriesOptions = merge(serie.options, {
+ animation: false, // turn off animation
+ enableMouseTracking: false,
+ showCheckbox: false,
+ visible: serie.visible
+ });
+
+ if (!seriesOptions.isInternal) { // used for the navigator series that has its own option set
+ options.series.push(seriesOptions);
+ }
+ });
+
+ // Axis options must be merged in one by one, since it may be an array or an object (#2022, #3900)
+ if (additionalOptions) {
+ each(['xAxis', 'yAxis'], function (axisType) {
+ each(splat(additionalOptions[axisType]), function (axisOptions, i) {
+ options[axisType][i] = merge(options[axisType][i], axisOptions);
+ });
+ });
+ }
+
+ // generate the chart copy
+ chartCopy = new Highcharts.Chart(options, chart.callback);
+
+ // reflect axis extremes in the export
+ each(['xAxis', 'yAxis'], function (axisType) {
+ each(chart[axisType], function (axis, i) {
+ var axisCopy = chartCopy[axisType][i],
+ extremes = axis.getExtremes(),
+ userMin = extremes.userMin,
+ userMax = extremes.userMax;
+
+ if (axisCopy && (userMin !== UNDEFINED || userMax !== UNDEFINED)) {
+ axisCopy.setExtremes(userMin, userMax, true, false);
+ }
+ });
+ });
+
+ // get the SVG from the container's innerHTML
+ svg = chartCopy.getChartHTML();
+
+ // free up memory
+ options = null;
+ chartCopy.destroy();
+ discardElement(sandbox);
+
+ // Move HTML into a foreignObject
+ if (allowHTML) {
+ html = svg.match(/<\/svg>(.*?$)/);
+ if (html) {
+ html = '' +
+ '' +
+ html[1] +
+ '' +
+ '';
+ svg = svg.replace('', html + '');
+ }
+ }
+
+ // sanitize
+ svg = this.sanitizeSVG(svg);
+
+ // IE9 beta bugs with innerHTML. Test again with final IE9.
+ svg = svg.replace(/(url\(#highcharts-[0-9]+)"/g, '$1')
+ .replace(/"/g, "'");
+
+ return svg;
+ },
+
+ getSVGForExport: function (options, chartOptions) {
+ var chartExportingOptions = this.options.exporting;
+
+ return this.getSVG(merge(
+ { chart: { borderRadius: 0 } },
+ chartExportingOptions.chartOptions,
+ chartOptions,
+ {
+ exporting: {
+ sourceWidth: (options && options.sourceWidth) || chartExportingOptions.sourceWidth,
+ sourceHeight: (options && options.sourceHeight) || chartExportingOptions.sourceHeight
+ }
+ }
+ ));
+ },
+
+ /**
+ * Submit the SVG representation of the chart to the server
+ * @param {Object} options Exporting options. Possible members are url, type, width and formAttributes.
+ * @param {Object} chartOptions Additional chart options for the SVG representation of the chart
+ */
+ exportChart: function (options, chartOptions) {
+
+ var svg = this.getSVGForExport(options, chartOptions);
+
+ // merge the options
+ options = merge(this.options.exporting, options);
+
+ // do the post
+ Highcharts.post(options.url, {
+ filename: options.filename || 'chart',
+ type: options.type,
+ width: options.width || 0, // IE8 fails to post undefined correctly, so use 0
+ scale: options.scale || 2,
+ svg: svg
+ }, options.formAttributes);
+
+ },
+
+ /**
+ * Print the chart
+ */
+ print: function () {
+
+ var chart = this,
+ container = chart.container,
+ origDisplay = [],
+ origParent = container.parentNode,
+ body = doc.body,
+ childNodes = body.childNodes;
+
+ if (chart.isPrinting) { // block the button while in printing mode
+ return;
+ }
+
+ chart.isPrinting = true;
+
+ fireEvent(chart, 'beforePrint');
+
+ // hide all body content
+ each(childNodes, function (node, i) {
+ if (node.nodeType === 1) {
+ origDisplay[i] = node.style.display;
+ node.style.display = NONE;
+ }
+ });
+
+ // pull out the chart
+ body.appendChild(container);
+
+ // print
+ win.focus(); // #1510
+ win.print();
+
+ // allow the browser to prepare before reverting
+ setTimeout(function () {
+
+ // put the chart back in
+ origParent.appendChild(container);
+
+ // restore all body content
+ each(childNodes, function (node, i) {
+ if (node.nodeType === 1) {
+ node.style.display = origDisplay[i];
+ }
+ });
+
+ chart.isPrinting = false;
+
+ fireEvent(chart, 'afterPrint');
+
+ }, 1000);
+
+ },
+
+ /**
+ * Display a popup menu for choosing the export type
+ *
+ * @param {String} className An identifier for the menu
+ * @param {Array} items A collection with text and onclicks for the items
+ * @param {Number} x The x position of the opener button
+ * @param {Number} y The y position of the opener button
+ * @param {Number} width The width of the opener button
+ * @param {Number} height The height of the opener button
+ */
+ contextMenu: function (className, items, x, y, width, height, button) {
+ var chart = this,
+ navOptions = chart.options.navigation,
+ menuItemStyle = navOptions.menuItemStyle,
+ chartWidth = chart.chartWidth,
+ chartHeight = chart.chartHeight,
+ cacheName = 'cache-' + className,
+ menu = chart[cacheName],
+ menuPadding = mathMax(width, height), // for mouse leave detection
+ boxShadow = '3px 3px 10px #888',
+ innerMenu,
+ hide,
+ hideTimer,
+ menuStyle,
+ docMouseUpHandler = function (e) {
+ if (!chart.pointer.inClass(e.target, className)) {
+ hide();
+ }
+ };
+
+ // create the menu only the first time
+ if (!menu) {
+
+ // create a HTML element above the SVG
+ chart[cacheName] = menu = createElement(DIV, {
+ className: className
+ }, {
+ position: ABSOLUTE,
+ zIndex: 1000,
+ padding: menuPadding + PX
+ }, chart.container);
+
+ innerMenu = createElement(DIV, null,
+ extend({
+ MozBoxShadow: boxShadow,
+ WebkitBoxShadow: boxShadow,
+ boxShadow: boxShadow
+ }, navOptions.menuStyle), menu);
+
+ // hide on mouse out
+ hide = function () {
+ css(menu, { display: NONE });
+ if (button) {
+ button.setState(0);
+ }
+ chart.openMenu = false;
+ };
+
+ // Hide the menu some time after mouse leave (#1357)
+ addEvent(menu, 'mouseleave', function () {
+ hideTimer = setTimeout(hide, 500);
+ });
+ addEvent(menu, 'mouseenter', function () {
+ clearTimeout(hideTimer);
+ });
+
+
+ // Hide it on clicking or touching outside the menu (#2258, #2335, #2407)
+ addEvent(document, 'mouseup', docMouseUpHandler);
+ addEvent(chart, 'destroy', function () {
+ removeEvent(document, 'mouseup', docMouseUpHandler);
+ });
+
+
+ // create the items
+ each(items, function (item) {
+ if (item) {
+ var element = item.separator ?
+ createElement('hr', null, null, innerMenu) :
+ createElement(DIV, {
+ onmouseover: function () {
+ css(this, navOptions.menuItemHoverStyle);
+ },
+ onmouseout: function () {
+ css(this, menuItemStyle);
+ },
+ onclick: function (e) {
+ e.stopPropagation();
+ hide();
+ if (item.onclick) {
+ item.onclick.apply(chart, arguments);
+ }
+ },
+ innerHTML: item.text || chart.options.lang[item.textKey]
+ }, extend({
+ cursor: 'pointer'
+ }, menuItemStyle), innerMenu);
+
+
+ // Keep references to menu divs to be able to destroy them
+ chart.exportDivElements.push(element);
+ }
+ });
+
+ // Keep references to menu and innerMenu div to be able to destroy them
+ chart.exportDivElements.push(innerMenu, menu);
+
+ chart.exportMenuWidth = menu.offsetWidth;
+ chart.exportMenuHeight = menu.offsetHeight;
+ }
+
+ menuStyle = { display: 'block' };
+
+ // if outside right, right align it
+ if (x + chart.exportMenuWidth > chartWidth) {
+ menuStyle.right = (chartWidth - x - width - menuPadding) + PX;
+ } else {
+ menuStyle.left = (x - menuPadding) + PX;
+ }
+ // if outside bottom, bottom align it
+ if (y + height + chart.exportMenuHeight > chartHeight && button.alignOptions.verticalAlign !== 'top') {
+ menuStyle.bottom = (chartHeight - y - menuPadding) + PX;
+ } else {
+ menuStyle.top = (y + height - menuPadding) + PX;
+ }
+
+ css(menu, menuStyle);
+ chart.openMenu = true;
+ },
+
+ /**
+ * Add the export button to the chart
+ */
+ addButton: function (options) {
+ var chart = this,
+ renderer = chart.renderer,
+ btnOptions = merge(chart.options.navigation.buttonOptions, options),
+ onclick = btnOptions.onclick,
+ menuItems = btnOptions.menuItems,
+ symbol,
+ button,
+ symbolAttr = {
+ stroke: btnOptions.symbolStroke,
+ fill: btnOptions.symbolFill
+ },
+ symbolSize = btnOptions.symbolSize || 12;
+ if (!chart.btnCount) {
+ chart.btnCount = 0;
+ }
+
+ // Keeps references to the button elements
+ if (!chart.exportDivElements) {
+ chart.exportDivElements = [];
+ chart.exportSVGElements = [];
+ }
+
+ if (btnOptions.enabled === false) {
+ return;
+ }
+
+
+ var attr = btnOptions.theme,
+ states = attr.states,
+ hover = states && states.hover,
+ select = states && states.select,
+ callback;
+
+ delete attr.states;
+
+ if (onclick) {
+ callback = function (e) {
+ e.stopPropagation();
+ onclick.call(chart, e);
+ };
+
+ } else if (menuItems) {
+ callback = function () {
+ chart.contextMenu(
+ button.menuClassName,
+ menuItems,
+ button.translateX,
+ button.translateY,
+ button.width,
+ button.height,
+ button
+ );
+ button.setState(2);
+ };
+ }
+
+
+ if (btnOptions.text && btnOptions.symbol) {
+ attr.paddingLeft = Highcharts.pick(attr.paddingLeft, 25);
+
+ } else if (!btnOptions.text) {
+ extend(attr, {
+ width: btnOptions.width,
+ height: btnOptions.height,
+ padding: 0
+ });
+ }
+
+ button = renderer.button(btnOptions.text, 0, 0, callback, attr, hover, select)
+ .attr({
+ title: chart.options.lang[btnOptions._titleKey],
+ 'stroke-linecap': 'round'
+ });
+ button.menuClassName = options.menuClassName || PREFIX + 'menu-' + chart.btnCount++;
+
+ if (btnOptions.symbol) {
+ symbol = renderer.symbol(
+ btnOptions.symbol,
+ btnOptions.symbolX - (symbolSize / 2),
+ btnOptions.symbolY - (symbolSize / 2),
+ symbolSize,
+ symbolSize
+ )
+ .attr(extend(symbolAttr, {
+ 'stroke-width': btnOptions.symbolStrokeWidth || 1,
+ zIndex: 1
+ })).add(button);
+ }
+
+ button.add()
+ .align(extend(btnOptions, {
+ width: button.width,
+ x: Highcharts.pick(btnOptions.x, buttonOffset) // #1654
+ }), true, 'spacingBox');
+
+ buttonOffset += (button.width + btnOptions.buttonSpacing) * (btnOptions.align === 'right' ? -1 : 1);
+
+ chart.exportSVGElements.push(button, symbol);
+
+ },
+
+ /**
+ * Destroy the buttons.
+ */
+ destroyExport: function (e) {
+ var chart = e.target,
+ i,
+ elem;
+
+ // Destroy the extra buttons added
+ for (i = 0; i < chart.exportSVGElements.length; i++) {
+ elem = chart.exportSVGElements[i];
+
+ // Destroy and null the svg/vml elements
+ if (elem) { // #1822
+ elem.onclick = elem.ontouchstart = null;
+ chart.exportSVGElements[i] = elem.destroy();
+ }
+ }
+
+ // Destroy the divs for the menu
+ for (i = 0; i < chart.exportDivElements.length; i++) {
+ elem = chart.exportDivElements[i];
+
+ // Remove the event handler
+ removeEvent(elem, 'mouseleave');
+
+ // Remove inline events
+ chart.exportDivElements[i] = elem.onmouseout = elem.onmouseover = elem.ontouchstart = elem.onclick = null;
+
+ // Destroy the div by moving to garbage bin
+ discardElement(elem);
+ }
+ }
+});
+
+
+symbols.menu = function (x, y, width, height) {
+ var arr = [
+ M, x, y + 2.5,
+ L, x + width, y + 2.5,
+ M, x, y + height / 2 + 0.5,
+ L, x + width, y + height / 2 + 0.5,
+ M, x, y + height - 1.5,
+ L, x + width, y + height - 1.5
+ ];
+ return arr;
+};
+
+// Add the buttons on chart load
+Chart.prototype.callbacks.push(function (chart) {
+ var n,
+ exportingOptions = chart.options.exporting,
+ buttons = exportingOptions.buttons;
+
+ buttonOffset = 0;
+
+ if (exportingOptions.enabled !== false) {
+
+ for (n in buttons) {
+ chart.addButton(buttons[n]);
+ }
+
+ // Destroy the export elements at chart destroy
+ addEvent(chart, 'destroy', chart.destroyExport);
+ }
+
+});
+
+
+}(Highcharts));
+
+
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ * Data module
+ *
+ * (c) 2012-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+// JSLint options:
+/*global jQuery, HighchartsAdapter */
+
+(function (Highcharts) {
+
+ // Utilities
+ var each = Highcharts.each,
+ pick = Highcharts.pick,
+ inArray = HighchartsAdapter.inArray,
+ splat = Highcharts.splat,
+ SeriesBuilder;
+
+
+ // The Data constructor
+ var Data = function (dataOptions, chartOptions) {
+ this.init(dataOptions, chartOptions);
+ };
+
+ // Set the prototype properties
+ Highcharts.extend(Data.prototype, {
+
+ /**
+ * Initialize the Data object with the given options
+ */
+ init: function (options, chartOptions) {
+ this.options = options;
+ this.chartOptions = chartOptions;
+ this.columns = options.columns || this.rowsToColumns(options.rows) || [];
+ this.firstRowAsNames = pick(options.firstRowAsNames, true);
+ this.decimalRegex = options.decimalPoint && new RegExp('^([0-9]+)' + options.decimalPoint + '([0-9]+)$');
+
+ // This is a two-dimensional array holding the raw, trimmed string values
+ // with the same organisation as the columns array. It makes it possible
+ // for example to revert from interpreted timestamps to string-based
+ // categories.
+ this.rawColumns = [];
+
+ // No need to parse or interpret anything
+ if (this.columns.length) {
+ this.dataFound();
+
+ // Parse and interpret
+ } else {
+
+ // Parse a CSV string if options.csv is given
+ this.parseCSV();
+
+ // Parse a HTML table if options.table is given
+ this.parseTable();
+
+ // Parse a Google Spreadsheet
+ this.parseGoogleSpreadsheet();
+ }
+
+ },
+
+ /**
+ * Get the column distribution. For example, a line series takes a single column for
+ * Y values. A range series takes two columns for low and high values respectively,
+ * and an OHLC series takes four columns.
+ */
+ getColumnDistribution: function () {
+ var chartOptions = this.chartOptions,
+ options = this.options,
+ xColumns = [],
+ getValueCount = function (type) {
+ return (Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap || [0]).length;
+ },
+ getPointArrayMap = function (type) {
+ return Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap;
+ },
+ globalType = chartOptions && chartOptions.chart && chartOptions.chart.type,
+ individualCounts = [],
+ seriesBuilders = [],
+ seriesIndex = 0,
+ i;
+
+ each((chartOptions && chartOptions.series) || [], function (series) {
+ individualCounts.push(getValueCount(series.type || globalType));
+ });
+
+ // Collect the x-column indexes from seriesMapping
+ each((options && options.seriesMapping) || [], function (mapping) {
+ xColumns.push(mapping.x || 0);
+ });
+
+ // If there are no defined series with x-columns, use the first column as x column
+ if (xColumns.length === 0) {
+ xColumns.push(0);
+ }
+
+ // Loop all seriesMappings and constructs SeriesBuilders from
+ // the mapping options.
+ each((options && options.seriesMapping) || [], function (mapping) {
+ var builder = new SeriesBuilder(),
+ name,
+ numberOfValueColumnsNeeded = individualCounts[seriesIndex] || getValueCount(globalType),
+ seriesArr = (chartOptions && chartOptions.series) || [],
+ series = seriesArr[seriesIndex] || {},
+ pointArrayMap = getPointArrayMap(series.type || globalType) || ['y'];
+
+ // Add an x reader from the x property or from an undefined column
+ // if the property is not set. It will then be auto populated later.
+ builder.addColumnReader(mapping.x, 'x');
+
+ // Add all column mappings
+ for (name in mapping) {
+ if (mapping.hasOwnProperty(name) && name !== 'x') {
+ builder.addColumnReader(mapping[name], name);
+ }
+ }
+
+ // Add missing columns
+ for (i = 0; i < numberOfValueColumnsNeeded; i++) {
+ if (!builder.hasReader(pointArrayMap[i])) {
+ //builder.addNextColumnReader(pointArrayMap[i]);
+ // Create and add a column reader for the next free column index
+ builder.addColumnReader(undefined, pointArrayMap[i]);
+ }
+ }
+
+ seriesBuilders.push(builder);
+ seriesIndex++;
+ });
+
+ var globalPointArrayMap = getPointArrayMap(globalType);
+ if (globalPointArrayMap === undefined) {
+ globalPointArrayMap = ['y'];
+ }
+
+ this.valueCount = {
+ global: getValueCount(globalType),
+ xColumns: xColumns,
+ individual: individualCounts,
+ seriesBuilders: seriesBuilders,
+ globalPointArrayMap: globalPointArrayMap
+ };
+ },
+
+ /**
+ * When the data is parsed into columns, either by CSV, table, GS or direct input,
+ * continue with other operations.
+ */
+ dataFound: function () {
+
+ if (this.options.switchRowsAndColumns) {
+ this.columns = this.rowsToColumns(this.columns);
+ }
+
+ // Interpret the info about series and columns
+ this.getColumnDistribution();
+
+ // Interpret the values into right types
+ this.parseTypes();
+
+ // Handle columns if a handleColumns callback is given
+ if (this.parsed() !== false) {
+
+ // Complete if a complete callback is given
+ this.complete();
+ }
+
+ },
+
+ /**
+ * Parse a CSV input string
+ */
+ parseCSV: function () {
+ var self = this,
+ options = this.options,
+ csv = options.csv,
+ columns = this.columns,
+ startRow = options.startRow || 0,
+ endRow = options.endRow || Number.MAX_VALUE,
+ startColumn = options.startColumn || 0,
+ endColumn = options.endColumn || Number.MAX_VALUE,
+ itemDelimiter,
+ lines,
+ activeRowNo = 0;
+
+ if (csv) {
+
+ lines = csv
+ .replace(/\r\n/g, "\n") // Unix
+ .replace(/\r/g, "\n") // Mac
+ .split(options.lineDelimiter || "\n");
+
+ itemDelimiter = options.itemDelimiter || (csv.indexOf('\t') !== -1 ? '\t' : ',');
+
+ each(lines, function (line, rowNo) {
+ var trimmed = self.trim(line),
+ isComment = trimmed.indexOf('#') === 0,
+ isBlank = trimmed === '',
+ items;
+
+ if (rowNo >= startRow && rowNo <= endRow && !isComment && !isBlank) {
+ items = line.split(itemDelimiter);
+ each(items, function (item, colNo) {
+ if (colNo >= startColumn && colNo <= endColumn) {
+ if (!columns[colNo - startColumn]) {
+ columns[colNo - startColumn] = [];
+ }
+
+ columns[colNo - startColumn][activeRowNo] = item;
+ }
+ });
+ activeRowNo += 1;
+ }
+ });
+
+ this.dataFound();
+ }
+ },
+
+ /**
+ * Parse a HTML table
+ */
+ parseTable: function () {
+ var options = this.options,
+ table = options.table,
+ columns = this.columns,
+ startRow = options.startRow || 0,
+ endRow = options.endRow || Number.MAX_VALUE,
+ startColumn = options.startColumn || 0,
+ endColumn = options.endColumn || Number.MAX_VALUE;
+
+ if (table) {
+
+ if (typeof table === 'string') {
+ table = document.getElementById(table);
+ }
+
+ each(table.getElementsByTagName('tr'), function (tr, rowNo) {
+ if (rowNo >= startRow && rowNo <= endRow) {
+ each(tr.children, function (item, colNo) {
+ if ((item.tagName === 'TD' || item.tagName === 'TH') && colNo >= startColumn && colNo <= endColumn) {
+ if (!columns[colNo - startColumn]) {
+ columns[colNo - startColumn] = [];
+ }
+
+ columns[colNo - startColumn][rowNo - startRow] = item.innerHTML;
+ }
+ });
+ }
+ });
+
+ this.dataFound(); // continue
+ }
+ },
+
+ /**
+ */
+ parseGoogleSpreadsheet: function () {
+ var self = this,
+ options = this.options,
+ googleSpreadsheetKey = options.googleSpreadsheetKey,
+ columns = this.columns,
+ startRow = options.startRow || 0,
+ endRow = options.endRow || Number.MAX_VALUE,
+ startColumn = options.startColumn || 0,
+ endColumn = options.endColumn || Number.MAX_VALUE,
+ gr, // google row
+ gc; // google column
+
+ if (googleSpreadsheetKey) {
+ jQuery.ajax({
+ dataType: 'json',
+ url: 'https://spreadsheets.google.com/feeds/cells/' +
+ googleSpreadsheetKey + '/' + (options.googleSpreadsheetWorksheet || 'od6') +
+ '/public/values?alt=json-in-script&callback=?',
+ error: options.error,
+ success: function (json) {
+ // Prepare the data from the spreadsheat
+ var cells = json.feed.entry,
+ cell,
+ cellCount = cells.length,
+ colCount = 0,
+ rowCount = 0,
+ i;
+
+ // First, find the total number of columns and rows that
+ // are actually filled with data
+ for (i = 0; i < cellCount; i++) {
+ cell = cells[i];
+ colCount = Math.max(colCount, cell.gs$cell.col);
+ rowCount = Math.max(rowCount, cell.gs$cell.row);
+ }
+
+ // Set up arrays containing the column data
+ for (i = 0; i < colCount; i++) {
+ if (i >= startColumn && i <= endColumn) {
+ // Create new columns with the length of either end-start or rowCount
+ columns[i - startColumn] = [];
+
+ // Setting the length to avoid jslint warning
+ columns[i - startColumn].length = Math.min(rowCount, endRow - startRow);
+ }
+ }
+
+ // Loop over the cells and assign the value to the right
+ // place in the column arrays
+ for (i = 0; i < cellCount; i++) {
+ cell = cells[i];
+ gr = cell.gs$cell.row - 1; // rows start at 1
+ gc = cell.gs$cell.col - 1; // columns start at 1
+
+ // If both row and col falls inside start and end
+ // set the transposed cell value in the newly created columns
+ if (gc >= startColumn && gc <= endColumn &&
+ gr >= startRow && gr <= endRow) {
+ columns[gc - startColumn][gr - startRow] = cell.content.$t;
+ }
+ }
+ self.dataFound();
+ }
+ });
+ }
+ },
+
+ /**
+ * Trim a string from whitespace
+ */
+ trim: function (str, inside) {
+ if (typeof str === 'string') {
+ str = str.replace(/^\s+|\s+$/g, '');
+
+ // Clear white space insdie the string, like thousands separators
+ if (inside && /^[0-9\s]+$/.test(str)) {
+ str = str.replace(/\s/g, '');
+ }
+
+ if (this.decimalRegex) {
+ str = str.replace(this.decimalRegex, '$1.$2');
+ }
+ }
+ return str;
+ },
+
+ /**
+ * Parse numeric cells in to number types and date types in to true dates.
+ */
+ parseTypes: function () {
+ var columns = this.columns,
+ col = columns.length;
+
+ while (col--) {
+ this.parseColumn(columns[col], col);
+ }
+
+ },
+
+ /**
+ * Parse a single column. Set properties like .isDatetime and .isNumeric.
+ */
+ parseColumn: function (column, col) {
+ var rawColumns = this.rawColumns,
+ columns = this.columns,
+ row = column.length,
+ val,
+ floatVal,
+ trimVal,
+ trimInsideVal,
+ firstRowAsNames = this.firstRowAsNames,
+ isXColumn = inArray(col, this.valueCount.xColumns) !== -1,
+ dateVal,
+ backup = [],
+ diff,
+ chartOptions = this.chartOptions,
+ descending,
+ columnTypes = this.options.columnTypes || [],
+ columnType = columnTypes[col],
+ forceCategory = isXColumn && ((chartOptions && chartOptions.xAxis && splat(chartOptions.xAxis)[0].type === 'category') || columnType === 'string');
+
+ if (!rawColumns[col]) {
+ rawColumns[col] = [];
+ }
+ while (row--) {
+ val = backup[row] || column[row];
+
+ trimVal = this.trim(val);
+ trimInsideVal = this.trim(val, true);
+ floatVal = parseFloat(trimInsideVal);
+
+ // Set it the first time
+ if (rawColumns[col][row] === undefined) {
+ rawColumns[col][row] = trimVal;
+ }
+
+ // Disable number or date parsing by setting the X axis type to category
+ if (forceCategory || (row === 0 && firstRowAsNames)) {
+ column[row] = trimVal;
+
+ } else if (+trimInsideVal === floatVal) { // is numeric
+
+ column[row] = floatVal;
+
+ // If the number is greater than milliseconds in a year, assume datetime
+ if (floatVal > 365 * 24 * 3600 * 1000 && columnType !== 'float') {
+ column.isDatetime = true;
+ } else {
+ column.isNumeric = true;
+ }
+
+ if (column[row + 1] !== undefined) {
+ descending = floatVal > column[row + 1];
+ }
+
+ // String, continue to determine if it is a date string or really a string
+ } else {
+ dateVal = this.parseDate(val);
+ // Only allow parsing of dates if this column is an x-column
+ if (isXColumn && typeof dateVal === 'number' && !isNaN(dateVal) && columnType !== 'float') { // is date
+ backup[row] = val;
+ column[row] = dateVal;
+ column.isDatetime = true;
+
+ // Check if the dates are uniformly descending or ascending. If they
+ // are not, chances are that they are a different time format, so check
+ // for alternative.
+ if (column[row + 1] !== undefined) {
+ diff = dateVal > column[row + 1];
+ if (diff !== descending && descending !== undefined) {
+ if (this.alternativeFormat) {
+ this.dateFormat = this.alternativeFormat;
+ row = column.length;
+ this.alternativeFormat = this.dateFormats[this.dateFormat].alternative;
+ } else {
+ column.unsorted = true;
+ }
+ }
+ descending = diff;
+ }
+
+ } else { // string
+ column[row] = trimVal === '' ? null : trimVal;
+ if (row !== 0 && (column.isDatetime || column.isNumeric)) {
+ column.mixed = true;
+ }
+ }
+ }
+ }
+
+ // If strings are intermixed with numbers or dates in a parsed column, it is an indication
+ // that parsing went wrong or the data was not intended to display as numbers or dates and
+ // parsing is too aggressive. Fall back to categories. Demonstrated in the
+ // highcharts/demo/column-drilldown sample.
+ if (isXColumn && column.mixed) {
+ columns[col] = rawColumns[col];
+ }
+
+ // If the 0 column is date or number and descending, reverse all columns.
+ if (isXColumn && descending && this.options.sort) {
+ for (col = 0; col < columns.length; col++) {
+ columns[col].reverse();
+ if (firstRowAsNames) {
+ columns[col].unshift(columns[col].pop());
+ }
+ }
+ }
+ },
+
+ /**
+ * A collection of available date formats, extendable from the outside to support
+ * custom date formats.
+ */
+ dateFormats: {
+ 'YYYY-mm-dd': {
+ regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
+ parser: function (match) {
+ return Date.UTC(+match[1], match[2] - 1, +match[3]);
+ }
+ },
+ 'dd/mm/YYYY': {
+ regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
+ parser: function (match) {
+ return Date.UTC(+match[3], match[2] - 1, +match[1]);
+ },
+ alternative: 'mm/dd/YYYY' // different format with the same regex
+ },
+ 'mm/dd/YYYY': {
+ regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
+ parser: function (match) {
+ return Date.UTC(+match[3], match[1] - 1, +match[2]);
+ }
+ },
+ 'dd/mm/YY': {
+ regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
+ parser: function (match) {
+ return Date.UTC(+match[3] + 2000, match[2] - 1, +match[1]);
+ },
+ alternative: 'mm/dd/YY' // different format with the same regex
+ },
+ 'mm/dd/YY': {
+ regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
+ parser: function (match) {
+ return Date.UTC(+match[3] + 2000, match[1] - 1, +match[2]);
+ }
+ }
+ },
+
+ /**
+ * Parse a date and return it as a number. Overridable through options.parseDate.
+ */
+ parseDate: function (val) {
+ var parseDate = this.options.parseDate,
+ ret,
+ key,
+ format,
+ dateFormat = this.options.dateFormat || this.dateFormat,
+ match;
+
+ if (parseDate) {
+ ret = parseDate(val);
+
+ } else if (typeof val === 'string') {
+ // Auto-detect the date format the first time
+ if (!dateFormat) {
+ for (key in this.dateFormats) {
+ format = this.dateFormats[key];
+ match = val.match(format.regex);
+ if (match) {
+ this.dateFormat = dateFormat = key;
+ this.alternativeFormat = format.alternative;
+ ret = format.parser(match);
+ break;
+ }
+ }
+ // Next time, use the one previously found
+ } else {
+ format = this.dateFormats[dateFormat];
+ match = val.match(format.regex);
+ if (match) {
+ ret = format.parser(match);
+ }
+ }
+ // Fall back to Date.parse
+ if (!match) {
+ match = Date.parse(val);
+ // External tools like Date.js and MooTools extend Date object and
+ // returns a date.
+ if (typeof match === 'object' && match !== null && match.getTime) {
+ ret = match.getTime() - match.getTimezoneOffset() * 60000;
+
+ // Timestamp
+ } else if (typeof match === 'number' && !isNaN(match)) {
+ ret = match - (new Date(match)).getTimezoneOffset() * 60000;
+ }
+ }
+ }
+ return ret;
+ },
+
+ /**
+ * Reorganize rows into columns
+ */
+ rowsToColumns: function (rows) {
+ var row,
+ rowsLength,
+ col,
+ colsLength,
+ columns;
+
+ if (rows) {
+ columns = [];
+ rowsLength = rows.length;
+ for (row = 0; row < rowsLength; row++) {
+ colsLength = rows[row].length;
+ for (col = 0; col < colsLength; col++) {
+ if (!columns[col]) {
+ columns[col] = [];
+ }
+ columns[col][row] = rows[row][col];
+ }
+ }
+ }
+ return columns;
+ },
+
+ /**
+ * A hook for working directly on the parsed columns
+ */
+ parsed: function () {
+ if (this.options.parsed) {
+ return this.options.parsed.call(this, this.columns);
+ }
+ },
+
+ getFreeIndexes: function (numberOfColumns, seriesBuilders) {
+ var s,
+ i,
+ freeIndexes = [],
+ freeIndexValues = [],
+ referencedIndexes;
+
+ // Add all columns as free
+ for (i = 0; i < numberOfColumns; i = i + 1) {
+ freeIndexes.push(true);
+ }
+
+ // Loop all defined builders and remove their referenced columns
+ for (s = 0; s < seriesBuilders.length; s = s + 1) {
+ referencedIndexes = seriesBuilders[s].getReferencedColumnIndexes();
+
+ for (i = 0; i < referencedIndexes.length; i = i + 1) {
+ freeIndexes[referencedIndexes[i]] = false;
+ }
+ }
+
+ // Collect the values for the free indexes
+ for (i = 0; i < freeIndexes.length; i = i + 1) {
+ if (freeIndexes[i]) {
+ freeIndexValues.push(i);
+ }
+ }
+
+ return freeIndexValues;
+ },
+
+ /**
+ * If a complete callback function is provided in the options, interpret the
+ * columns into a Highcharts options object.
+ */
+ complete: function () {
+
+ var columns = this.columns,
+ xColumns = [],
+ type,
+ options = this.options,
+ series,
+ data,
+ i,
+ j,
+ r,
+ seriesIndex,
+ chartOptions,
+ allSeriesBuilders = [],
+ builder,
+ freeIndexes,
+ typeCol,
+ index;
+
+ xColumns.length = columns.length;
+ if (options.complete || options.afterComplete) {
+
+ // Get the names and shift the top row
+ for (i = 0; i < columns.length; i++) {
+ if (this.firstRowAsNames) {
+ columns[i].name = columns[i].shift();
+ }
+ }
+
+ // Use the next columns for series
+ series = [];
+ freeIndexes = this.getFreeIndexes(columns.length, this.valueCount.seriesBuilders);
+
+ // Populate defined series
+ for (seriesIndex = 0; seriesIndex < this.valueCount.seriesBuilders.length; seriesIndex++) {
+ builder = this.valueCount.seriesBuilders[seriesIndex];
+
+ // If the builder can be populated with remaining columns, then add it to allBuilders
+ if (builder.populateColumns(freeIndexes)) {
+ allSeriesBuilders.push(builder);
+ }
+ }
+
+ // Populate dynamic series
+ while (freeIndexes.length > 0) {
+ builder = new SeriesBuilder();
+ builder.addColumnReader(0, 'x');
+
+ // Mark index as used (not free)
+ index = inArray(0, freeIndexes);
+ if (index !== -1) {
+ freeIndexes.splice(index, 1);
+ }
+
+ for (i = 0; i < this.valueCount.global; i++) {
+ // Create and add a column reader for the next free column index
+ builder.addColumnReader(undefined, this.valueCount.globalPointArrayMap[i]);
+ }
+
+ // If the builder can be populated with remaining columns, then add it to allBuilders
+ if (builder.populateColumns(freeIndexes)) {
+ allSeriesBuilders.push(builder);
+ }
+ }
+
+ // Get the data-type from the first series x column
+ if (allSeriesBuilders.length > 0 && allSeriesBuilders[0].readers.length > 0) {
+ typeCol = columns[allSeriesBuilders[0].readers[0].columnIndex];
+ if (typeCol !== undefined) {
+ if (typeCol.isDatetime) {
+ type = 'datetime';
+ } else if (!typeCol.isNumeric) {
+ type = 'category';
+ }
+ }
+ }
+ // Axis type is category, then the "x" column should be called "name"
+ if (type === 'category') {
+ for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
+ builder = allSeriesBuilders[seriesIndex];
+ for (r = 0; r < builder.readers.length; r++) {
+ if (builder.readers[r].configName === 'x') {
+ builder.readers[r].configName = 'name';
+ }
+ }
+ }
+ }
+
+ // Read data for all builders
+ for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
+ builder = allSeriesBuilders[seriesIndex];
+
+ // Iterate down the cells of each column and add data to the series
+ data = [];
+ for (j = 0; j < columns[0].length; j++) { // TODO: which column's length should we use here
+ data[j] = builder.read(columns, j);
+ }
+
+ // Add the series
+ series[seriesIndex] = {
+ data: data
+ };
+ if (builder.name) {
+ series[seriesIndex].name = builder.name;
+ }
+ if (type === 'category') {
+ series[seriesIndex].turboThreshold = 0;
+ }
+ }
+
+
+
+ // Do the callback
+ chartOptions = {
+ series: series
+ };
+ if (type) {
+ chartOptions.xAxis = {
+ type: type
+ };
+ }
+
+ if (options.complete) {
+ options.complete(chartOptions);
+ }
+
+ // The afterComplete hook is used internally to avoid conflict with the externally
+ // available complete option.
+ if (options.afterComplete) {
+ options.afterComplete(chartOptions);
+ }
+ }
+ }
+ });
+
+ // Register the Data prototype and data function on Highcharts
+ Highcharts.Data = Data;
+ Highcharts.data = function (options, chartOptions) {
+ return new Data(options, chartOptions);
+ };
+
+ // Extend Chart.init so that the Chart constructor accepts a new configuration
+ // option group, data.
+ Highcharts.wrap(Highcharts.Chart.prototype, 'init', function (proceed, userOptions, callback) {
+ var chart = this;
+
+ if (userOptions && userOptions.data) {
+ Highcharts.data(Highcharts.extend(userOptions.data, {
+
+ afterComplete: function (dataOptions) {
+ var i, series;
+
+ // Merge series configs
+ if (userOptions.hasOwnProperty('series')) {
+ if (typeof userOptions.series === 'object') {
+ i = Math.max(userOptions.series.length, dataOptions.series.length);
+ while (i--) {
+ series = userOptions.series[i] || {};
+ userOptions.series[i] = Highcharts.merge(series, dataOptions.series[i]);
+ }
+ } else { // Allow merging in dataOptions.series (#2856)
+ delete userOptions.series;
+ }
+ }
+
+ // Do the merge
+ userOptions = Highcharts.merge(dataOptions, userOptions);
+
+ proceed.call(chart, userOptions, callback);
+ }
+ }), userOptions);
+ } else {
+ proceed.call(chart, userOptions, callback);
+ }
+ });
+
+ /**
+ * Creates a new SeriesBuilder. A SeriesBuilder consists of a number
+ * of ColumnReaders that reads columns and give them a name.
+ * Ex: A series builder can be constructed to read column 3 as 'x' and
+ * column 7 and 8 as 'y1' and 'y2'.
+ * The output would then be points/rows of the form {x: 11, y1: 22, y2: 33}
+ *
+ * The name of the builder is taken from the second column. In the above
+ * example it would be the column with index 7.
+ * @constructor
+ */
+ SeriesBuilder = function () {
+ this.readers = [];
+ this.pointIsArray = true;
+ };
+
+ /**
+ * Populates readers with column indexes. A reader can be added without
+ * a specific index and for those readers the index is taken sequentially
+ * from the free columns (this is handled by the ColumnCursor instance).
+ * @returns {boolean}
+ */
+ SeriesBuilder.prototype.populateColumns = function (freeIndexes) {
+ var builder = this,
+ enoughColumns = true;
+
+ // Loop each reader and give it an index if its missing.
+ // The freeIndexes.shift() will return undefined if there
+ // are no more columns.
+ each(builder.readers, function (reader) {
+ if (reader.columnIndex === undefined) {
+ reader.columnIndex = freeIndexes.shift();
+ }
+ });
+
+ // Now, all readers should have columns mapped. If not
+ // then return false to signal that this series should
+ // not be added.
+ each(builder.readers, function (reader) {
+ if (reader.columnIndex === undefined) {
+ enoughColumns = false;
+ }
+ });
+
+ return enoughColumns;
+ };
+
+ /**
+ * Reads a row from the dataset and returns a point or array depending
+ * on the names of the readers.
+ * @param columns
+ * @param rowIndex
+ * @returns {Array | Object}
+ */
+ SeriesBuilder.prototype.read = function (columns, rowIndex) {
+ var builder = this,
+ pointIsArray = builder.pointIsArray,
+ point = pointIsArray ? [] : {},
+ columnIndexes;
+
+ // Loop each reader and ask it to read its value.
+ // Then, build an array or point based on the readers names.
+ each(builder.readers, function (reader) {
+ var value = columns[reader.columnIndex][rowIndex];
+ if (pointIsArray) {
+ point.push(value);
+ } else {
+ point[reader.configName] = value;
+ }
+ });
+
+ // The name comes from the first column (excluding the x column)
+ if (this.name === undefined && builder.readers.length >= 2) {
+ columnIndexes = builder.getReferencedColumnIndexes();
+ if (columnIndexes.length >= 2) {
+ // remove the first one (x col)
+ columnIndexes.shift();
+
+ // Sort the remaining
+ columnIndexes.sort();
+
+ // Now use the lowest index as name column
+ this.name = columns[columnIndexes.shift()].name;
+ }
+ }
+
+ return point;
+ };
+
+ /**
+ * Creates and adds ColumnReader from the given columnIndex and configName.
+ * ColumnIndex can be undefined and in that case the reader will be given
+ * an index when columns are populated.
+ * @param columnIndex {Number | undefined}
+ * @param configName
+ */
+ SeriesBuilder.prototype.addColumnReader = function (columnIndex, configName) {
+ this.readers.push({
+ columnIndex: columnIndex,
+ configName: configName
+ });
+
+ if (!(configName === 'x' || configName === 'y' || configName === undefined)) {
+ this.pointIsArray = false;
+ }
+ };
+
+ /**
+ * Returns an array of column indexes that the builder will use when
+ * reading data.
+ * @returns {Array}
+ */
+ SeriesBuilder.prototype.getReferencedColumnIndexes = function () {
+ var i,
+ referencedColumnIndexes = [],
+ columnReader;
+
+ for (i = 0; i < this.readers.length; i = i + 1) {
+ columnReader = this.readers[i];
+ if (columnReader.columnIndex !== undefined) {
+ referencedColumnIndexes.push(columnReader.columnIndex);
+ }
+ }
+
+ return referencedColumnIndexes;
+ };
+
+ /**
+ * Returns true if the builder has a reader for the given configName.
+ * @param configName
+ * @returns {boolean}
+ */
+ SeriesBuilder.prototype.hasReader = function (configName) {
+ var i, columnReader;
+ for (i = 0; i < this.readers.length; i = i + 1) {
+ columnReader = this.readers[i];
+ if (columnReader.configName === configName) {
+ return true;
+ }
+ }
+ // Else return undefined
+ };
+
+
+
+}(Highcharts));
+
+
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ * Plugin for displaying a message when there is no data visible in chart.
+ *
+ * (c) 2010-2014 Highsoft AS
+ * Author: Oystein Moseng
+ *
+ * License: www.highcharts.com/license
+ */
+
+(function (H) {
+
+ var seriesTypes = H.seriesTypes,
+ chartPrototype = H.Chart.prototype,
+ defaultOptions = H.getOptions(),
+ extend = H.extend,
+ each = H.each;
+
+ // Add language option
+ extend(defaultOptions.lang, {
+ noData: 'No data to display'
+ });
+
+ // Add default display options for message
+ defaultOptions.noData = {
+ position: {
+ x: 0,
+ y: 0,
+ align: 'center',
+ verticalAlign: 'middle'
+ },
+ attr: {
+ },
+ style: {
+ fontWeight: 'bold',
+ fontSize: '12px',
+ color: '#60606a'
+ }
+ // useHTML: false // docs
+ };
+
+ /**
+ * Define hasData functions for series. These return true if there are data points on this series within the plot area
+ */
+ function hasDataPie() {
+ return !!this.points.length; /* != 0 */
+ }
+
+ each(['pie', 'gauge', 'waterfall', 'bubble'], function (type) {
+ if (seriesTypes[type]) {
+ seriesTypes[type].prototype.hasData = hasDataPie;
+ }
+ });
+
+ H.Series.prototype.hasData = function () {
+ return this.visible && this.dataMax !== undefined && this.dataMin !== undefined; // #3703
+ };
+
+ /**
+ * Display a no-data message.
+ *
+ * @param {String} str An optional message to show in place of the default one
+ */
+ chartPrototype.showNoData = function (str) {
+ var chart = this,
+ options = chart.options,
+ text = str || options.lang.noData,
+ noDataOptions = options.noData;
+
+ if (!chart.noDataLabel) {
+ chart.noDataLabel = chart.renderer
+ .label(
+ text,
+ 0,
+ 0,
+ null,
+ null,
+ null,
+ noDataOptions.useHTML,
+ null,
+ 'no-data'
+ )
+ .attr(noDataOptions.attr)
+ .css(noDataOptions.style)
+ .add();
+ chart.noDataLabel.align(extend(chart.noDataLabel.getBBox(), noDataOptions.position), false, 'plotBox');
+ }
+ };
+
+ /**
+ * Hide no-data message
+ */
+ chartPrototype.hideNoData = function () {
+ var chart = this;
+ if (chart.noDataLabel) {
+ chart.noDataLabel = chart.noDataLabel.destroy();
+ }
+ };
+
+ /**
+ * Returns true if there are data points within the plot area now
+ */
+ chartPrototype.hasData = function () {
+ var chart = this,
+ series = chart.series,
+ i = series.length;
+
+ while (i--) {
+ if (series[i].hasData() && !series[i].options.isInternal) {
+ return true;
+ }
+ }
+
+ return false;
+ };
+
+ /**
+ * Show no-data message if there is no data in sight. Otherwise, hide it.
+ */
+ function handleNoData() {
+ var chart = this;
+ if (chart.hasData()) {
+ chart.hideNoData();
+ } else {
+ chart.showNoData();
+ }
+ }
+
+ /**
+ * Add event listener to handle automatic display of no-data message
+ */
+ chartPrototype.callbacks.push(function (chart) {
+ H.addEvent(chart, 'load', handleNoData);
+ H.addEvent(chart, 'redraw', handleNoData);
+ });
+
+}(Highcharts));
+
+
+/**
+ * Highcharts Drilldown plugin
+ *
+ * Author: Torstein Honsi
+ * License: MIT License
+ *
+ * Demo: http://jsfiddle.net/highcharts/Vf3yT/
+ */
+
+/*global Highcharts,HighchartsAdapter*/
+(function (H) {
+
+ "use strict";
+
+ var noop = function () {},
+ defaultOptions = H.getOptions(),
+ each = H.each,
+ extend = H.extend,
+ format = H.format,
+ pick = H.pick,
+ wrap = H.wrap,
+ Chart = H.Chart,
+ seriesTypes = H.seriesTypes,
+ PieSeries = seriesTypes.pie,
+ ColumnSeries = seriesTypes.column,
+ Tick = H.Tick,
+ fireEvent = HighchartsAdapter.fireEvent,
+ inArray = HighchartsAdapter.inArray,
+ ddSeriesId = 1;
+
+ // Utilities
+ /*
+ * Return an intermediate color between two colors, according to pos where 0
+ * is the from color and 1 is the to color. This method is copied from ColorAxis.js
+ * and should always be kept updated, until we get AMD support.
+ */
+ function tweenColors(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.raw || '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) {
+ HighchartsAdapter.addAnimSetter(prop, function (fx) {
+ fx.elem.attr(prop, tweenColors(H.Color(fx.start), H.Color(fx.end), fx.pos));
+ });
+ });
+
+ // Add language
+ extend(defaultOptions.lang, {
+ drillUpText: '◁ Back to {series.name}'
+ });
+ defaultOptions.drilldown = {
+ activeAxisLabelStyle: {
+ cursor: 'pointer',
+ color: '#0d233a',
+ fontWeight: 'bold',
+ textDecoration: 'underline'
+ },
+ activeDataLabelStyle: {
+ cursor: 'pointer',
+ color: '#0d233a',
+ fontWeight: 'bold',
+ textDecoration: 'underline'
+ },
+ animation: {
+ duration: 500
+ },
+ drillUpButton: {
+ position: {
+ align: 'right',
+ x: -10,
+ y: 10
+ }
+ // relativeTo: 'plotBox'
+ // theme
+ }
+ };
+
+ /**
+ * A general fadeIn method
+ */
+ H.SVGRenderer.prototype.Element.prototype.fadeIn = function (animation) {
+ this
+ .attr({
+ opacity: 0.1,
+ visibility: 'inherit'
+ })
+ .animate({
+ opacity: pick(this.newOpacity, 1) // newOpacity used in maps
+ }, animation || {
+ duration: 250
+ });
+ };
+
+ Chart.prototype.addSeriesAsDrilldown = function (point, ddOptions) {
+ this.addSingleSeriesAsDrilldown(point, ddOptions);
+ this.applyDrilldown();
+ };
+ Chart.prototype.addSingleSeriesAsDrilldown = function (point, ddOptions) {
+ var oldSeries = point.series,
+ xAxis = oldSeries.xAxis,
+ yAxis = oldSeries.yAxis,
+ newSeries,
+ color = point.color || oldSeries.color,
+ pointIndex,
+ levelSeries = [],
+ levelSeriesOptions = [],
+ level,
+ levelNumber,
+ last;
+
+ if (!this.drilldownLevels) {
+ this.drilldownLevels = [];
+ }
+
+ levelNumber = oldSeries.options._levelNumber || 0;
+
+ // See if we can reuse the registered series from last run
+ last = this.drilldownLevels[this.drilldownLevels.length - 1];
+ if (last && last.levelNumber !== levelNumber) {
+ last = undefined;
+ }
+
+
+ ddOptions = extend({
+ color: color,
+ _ddSeriesId: ddSeriesId++
+ }, ddOptions);
+ pointIndex = inArray(point, oldSeries.points);
+
+ // Record options for all current series
+ each(oldSeries.chart.series, function (series) {
+ if (series.xAxis === xAxis && !series.isDrilling) {
+ series.options._ddSeriesId = series.options._ddSeriesId || ddSeriesId++;
+ series.options._colorIndex = series.userOptions._colorIndex;
+ series.options._levelNumber = series.options._levelNumber || levelNumber; // #3182
+
+ if (last) {
+ levelSeries = last.levelSeries;
+ levelSeriesOptions = last.levelSeriesOptions;
+ } else {
+ levelSeries.push(series);
+ levelSeriesOptions.push(series.options);
+ }
+ }
+ });
+
+ // Add a record of properties for each drilldown level
+ level = {
+ levelNumber: levelNumber,
+ seriesOptions: oldSeries.options,
+ levelSeriesOptions: levelSeriesOptions,
+ levelSeries: levelSeries,
+ shapeArgs: point.shapeArgs,
+ bBox: point.graphic ? point.graphic.getBBox() : {}, // no graphic in line series with markers disabled
+ color: color,
+ lowerSeriesOptions: ddOptions,
+ pointOptions: oldSeries.options.data[pointIndex],
+ pointIndex: pointIndex,
+ oldExtremes: {
+ xMin: xAxis && xAxis.userMin,
+ xMax: xAxis && xAxis.userMax,
+ yMin: yAxis && yAxis.userMin,
+ yMax: yAxis && yAxis.userMax
+ }
+ };
+
+ // Push it to the lookup array
+ this.drilldownLevels.push(level);
+
+ newSeries = level.lowerSeries = this.addSeries(ddOptions, false);
+ newSeries.options._levelNumber = levelNumber + 1;
+ if (xAxis) {
+ xAxis.oldPos = xAxis.pos;
+ xAxis.userMin = xAxis.userMax = null;
+ yAxis.userMin = yAxis.userMax = null;
+ }
+
+ // Run fancy cross-animation on supported and equal types
+ if (oldSeries.type === newSeries.type) {
+ newSeries.animate = newSeries.animateDrilldown || noop;
+ newSeries.options.animation = true;
+ }
+ };
+
+ Chart.prototype.applyDrilldown = function () {
+ var drilldownLevels = this.drilldownLevels,
+ levelToRemove;
+
+ if (drilldownLevels && drilldownLevels.length > 0) { // #3352, async loading
+ levelToRemove = drilldownLevels[drilldownLevels.length - 1].levelNumber;
+ each(this.drilldownLevels, function (level) {
+ if (level.levelNumber === levelToRemove) {
+ each(level.levelSeries, function (series) {
+ if (series.options && series.options._levelNumber === levelToRemove) { // Not removed, not added as part of a multi-series drilldown
+ series.remove(false);
+ }
+ });
+ }
+ });
+ }
+
+ this.redraw();
+ this.showDrillUpButton();
+ };
+
+ Chart.prototype.getDrilldownBackText = function () {
+ var drilldownLevels = this.drilldownLevels,
+ lastLevel;
+ if (drilldownLevels && drilldownLevels.length > 0) { // #3352, async loading
+ lastLevel = drilldownLevels[drilldownLevels.length - 1];
+ lastLevel.series = lastLevel.seriesOptions;
+ return format(this.options.lang.drillUpText, lastLevel);
+ }
+
+ };
+
+ Chart.prototype.showDrillUpButton = function () {
+ var chart = this,
+ backText = this.getDrilldownBackText(),
+ buttonOptions = chart.options.drilldown.drillUpButton,
+ attr,
+ states;
+
+
+ if (!this.drillUpButton) {
+ attr = buttonOptions.theme;
+ states = attr && attr.states;
+
+ this.drillUpButton = this.renderer.button(
+ backText,
+ null,
+ null,
+ function () {
+ chart.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();
+ }
+ };
+
+ Chart.prototype.drillUp = function () {
+ var chart = this,
+ drilldownLevels = chart.drilldownLevels,
+ levelNumber = drilldownLevels[drilldownLevels.length - 1].levelNumber,
+ i = drilldownLevels.length,
+ chartSeries = chart.series,
+ seriesI,
+ level,
+ oldSeries,
+ newSeries,
+ oldExtremes,
+ addSeries = function (seriesOptions) {
+ var addedSeries;
+ each(chartSeries, function (series) {
+ if (series.options._ddSeriesId === seriesOptions._ddSeriesId) {
+ addedSeries = series;
+ }
+ });
+
+ addedSeries = addedSeries || chart.addSeries(seriesOptions, false);
+ if (addedSeries.type === oldSeries.type && addedSeries.animateDrillupTo) {
+ addedSeries.animate = addedSeries.animateDrillupTo;
+ }
+ if (seriesOptions === level.seriesOptions) {
+ newSeries = addedSeries;
+ }
+ };
+
+ while (i--) {
+
+ level = drilldownLevels[i];
+ if (level.levelNumber === levelNumber) {
+ drilldownLevels.pop();
+
+ // Get the lower series by reference or id
+ oldSeries = level.lowerSeries;
+ if (!oldSeries.chart) { // #2786
+ seriesI = chartSeries.length; // #2919
+ while (seriesI--) {
+ if (chartSeries[seriesI].options.id === level.lowerSeriesOptions.id &&
+ chartSeries[seriesI].options._levelNumber === levelNumber + 1) { // #3867
+ oldSeries = chartSeries[seriesI];
+ break;
+ }
+ }
+ }
+ oldSeries.xData = []; // Overcome problems with minRange (#2898)
+
+ each(level.levelSeriesOptions, addSeries);
+
+ fireEvent(chart, 'drillup', { seriesOptions: level.seriesOptions });
+
+ if (newSeries.type === oldSeries.type) {
+ newSeries.drilldownLevel = level;
+ newSeries.options.animation = chart.options.drilldown.animation;
+
+ if (oldSeries.animateDrillupFrom && oldSeries.chart) { // #2919
+ oldSeries.animateDrillupFrom(level);
+ }
+ }
+ newSeries.options._levelNumber = levelNumber;
+
+ oldSeries.remove(false);
+
+ // Reset the zoom level of the upper series
+ if (newSeries.xAxis) {
+ oldExtremes = level.oldExtremes;
+ newSeries.xAxis.setExtremes(oldExtremes.xMin, oldExtremes.xMax, false);
+ newSeries.yAxis.setExtremes(oldExtremes.yMin, oldExtremes.yMax, false);
+ }
+ }
+ }
+
+ this.redraw();
+
+ if (this.drilldownLevels.length === 0) {
+ this.drillUpButton = this.drillUpButton.destroy();
+ } else {
+ this.drillUpButton.attr({
+ text: this.getDrilldownBackText()
+ })
+ .align();
+ }
+
+ this.ddDupes.length = []; // #3315
+ };
+
+
+ ColumnSeries.prototype.supportsDrilldown = true;
+
+ /**
+ * When drilling up, keep the upper series invisible until the lower series has
+ * moved into place
+ */
+ ColumnSeries.prototype.animateDrillupTo = function (init) {
+ if (!init) {
+ var newSeries = this,
+ level = newSeries.drilldownLevel;
+
+ each(this.points, function (point) {
+ if (point.graphic) { // #3407
+ point.graphic.hide();
+ }
+ if (point.dataLabel) {
+ point.dataLabel.hide();
+ }
+ if (point.connector) {
+ point.connector.hide();
+ }
+ });
+
+
+ // Do dummy animation on first point to get to complete
+ setTimeout(function () {
+ if (newSeries.points) { // May be destroyed in the meantime, #3389
+ each(newSeries.points, function (point, i) {
+ // Fade in other points
+ var verb = i === (level && level.pointIndex) ? 'show' : 'fadeIn',
+ inherit = verb === 'show' ? true : undefined;
+ if (point.graphic) { // #3407
+ point.graphic[verb](inherit);
+ }
+ if (point.dataLabel) {
+ point.dataLabel[verb](inherit);
+ }
+ if (point.connector) {
+ point.connector[verb](inherit);
+ }
+ });
+ }
+ }, Math.max(this.chart.options.drilldown.animation.duration - 50, 0));
+
+ // Reset
+ this.animate = noop;
+ }
+
+ };
+
+ ColumnSeries.prototype.animateDrilldown = function (init) {
+ var series = this,
+ drilldownLevels = this.chart.drilldownLevels,
+ animateFrom,
+ animationOptions = this.chart.options.drilldown.animation,
+ xAxis = this.xAxis;
+
+ if (!init) {
+ each(drilldownLevels, function (level) {
+ if (series.options._ddSeriesId === level.lowerSeriesOptions._ddSeriesId) {
+ animateFrom = level.shapeArgs;
+ animateFrom.fill = level.color;
+ }
+ });
+
+ animateFrom.x += (pick(xAxis.oldPos, xAxis.pos) - xAxis.pos);
+
+ each(this.points, function (point) {
+ if (point.graphic) {
+ point.graphic
+ .attr(animateFrom)
+ .animate(
+ extend(point.shapeArgs, { fill: point.color }),
+ animationOptions
+ );
+ }
+ if (point.dataLabel) {
+ point.dataLabel.fadeIn(animationOptions);
+ }
+ });
+ this.animate = null;
+ }
+
+ };
+
+ /**
+ * When drilling up, pull out the individual point graphics from the lower series
+ * and animate them into the origin point in the upper series.
+ */
+ ColumnSeries.prototype.animateDrillupFrom = function (level) {
+ var animationOptions = this.chart.options.drilldown.animation,
+ group = this.group,
+ series = this;
+
+ // Cancel mouse events on the series group (#2787)
+ each(series.trackerGroups, function (key) {
+ if (series[key]) { // we don't always have dataLabelsGroup
+ series[key].on('mouseover');
+ }
+ });
+
+
+ delete this.group;
+ each(this.points, function (point) {
+ var graphic = point.graphic,
+ complete = function () {
+ graphic.destroy();
+ if (group) {
+ group = group.destroy();
+ }
+ };
+
+ if (graphic) {
+
+ delete point.graphic;
+
+ if (animationOptions) {
+ graphic.animate(
+ extend(level.shapeArgs, { fill: level.color }),
+ H.merge(animationOptions, { complete: complete })
+ );
+ } else {
+ graphic.attr(level.shapeArgs);
+ complete();
+ }
+ }
+ });
+ };
+
+ if (PieSeries) {
+ extend(PieSeries.prototype, {
+ supportsDrilldown: true,
+ animateDrillupTo: ColumnSeries.prototype.animateDrillupTo,
+ animateDrillupFrom: ColumnSeries.prototype.animateDrillupFrom,
+
+ animateDrilldown: function (init) {
+ var level = this.chart.drilldownLevels[this.chart.drilldownLevels.length - 1],
+ animationOptions = this.chart.options.drilldown.animation,
+ animateFrom = level.shapeArgs,
+ start = animateFrom.start,
+ angle = animateFrom.end - start,
+ startAngle = angle / this.points.length;
+
+ if (!init) {
+ each(this.points, function (point, i) {
+ point.graphic
+ .attr(H.merge(animateFrom, {
+ start: start + i * startAngle,
+ end: start + (i + 1) * startAngle,
+ fill: level.color
+ }))[animationOptions ? 'animate' : 'attr'](
+ extend(point.shapeArgs, { fill: point.color }),
+ animationOptions
+ );
+ });
+ this.animate = null;
+ }
+ }
+ });
+ }
+
+ H.Point.prototype.doDrilldown = function (_holdRedraw, category) {
+ var series = this.series,
+ chart = series.chart,
+ drilldown = chart.options.drilldown,
+ i = (drilldown.series || []).length,
+ seriesOptions;
+
+ if (!chart.ddDupes) {
+ chart.ddDupes = [];
+ }
+
+ while (i-- && !seriesOptions) {
+ if (drilldown.series[i].id === this.drilldown && inArray(this.drilldown, chart.ddDupes) === -1) {
+ seriesOptions = drilldown.series[i];
+ chart.ddDupes.push(this.drilldown);
+ }
+ }
+
+ // Fire the event. If seriesOptions is undefined, the implementer can check for
+ // seriesOptions, and call addSeriesAsDrilldown async if necessary.
+ fireEvent(chart, 'drilldown', {
+ point: this,
+ seriesOptions: seriesOptions,
+ category: category,
+ points: category !== undefined && this.series.xAxis.ddPoints[category].slice(0)
+ });
+
+ if (seriesOptions) {
+ if (_holdRedraw) {
+ chart.addSingleSeriesAsDrilldown(this, seriesOptions);
+ } else {
+ chart.addSeriesAsDrilldown(this, seriesOptions);
+ }
+ }
+ };
+
+ /**
+ * Drill down to a given category. This is the same as clicking on an axis label.
+ */
+ H.Axis.prototype.drilldownCategory = function (x) {
+ var key,
+ point,
+ ddPointsX = this.ddPoints[x];
+ for (key in ddPointsX) {
+ point = ddPointsX[key];
+ if (point && point.series && point.series.visible && point.doDrilldown) { // #3197
+ point.doDrilldown(true, x);
+ }
+ }
+ this.chart.applyDrilldown();
+ };
+
+ /**
+ * Create and return a collection of points associated with the X position. Reset it for each level.
+ */
+ H.Axis.prototype.getDDPoints = function (x, levelNumber) {
+ var ddPoints = this.ddPoints;
+ if (!ddPoints) {
+ this.ddPoints = ddPoints = {};
+ }
+ if (!ddPoints[x]) {
+ ddPoints[x] = [];
+ }
+ if (ddPoints[x].levelNumber !== levelNumber) {
+ ddPoints[x].length = 0; // reset
+ }
+ return ddPoints[x];
+ };
+
+
+ /**
+ * Make a tick label drillable, or remove drilling on update
+ */
+ Tick.prototype.drillable = function () {
+ var pos = this.pos,
+ label = this.label,
+ axis = this.axis,
+ ddPointsX = axis.ddPoints && axis.ddPoints[pos];
+
+ if (label && ddPointsX && ddPointsX.length) {
+ if (!label.basicStyles) {
+ label.basicStyles = H.merge(label.styles);
+ }
+ label
+ .addClass('highcharts-drilldown-axis-label')
+ .css(axis.chart.options.drilldown.activeAxisLabelStyle)
+ .on('click', function () {
+ axis.drilldownCategory(pos);
+ });
+
+ } else if (label && label.basicStyles) {
+ label.styles = {}; // reset for full overwrite of styles
+ label.css(label.basicStyles);
+ label.on('click', null); // #3806
+ }
+ };
+
+ /**
+ * Always keep the drillability updated (#3951)
+ */
+ wrap(Tick.prototype, 'addLabel', function (proceed) {
+ proceed.call(this);
+ this.drillable();
+ });
+
+
+ /**
+ * On initialization of each point, identify its label and make it clickable. Also, provide a
+ * list of points associated to that label.
+ */
+ wrap(H.Point.prototype, 'init', function (proceed, series, options, x) {
+ var point = proceed.call(this, series, options, x),
+ xAxis = series.xAxis,
+ tick = xAxis && xAxis.ticks[x],
+ ddPointsX = xAxis && xAxis.getDDPoints(x, series.options._levelNumber);
+
+ if (point.drilldown) {
+
+ // Add the click event to the point
+ H.addEvent(point, 'click', function () {
+ if (series.xAxis && series.chart.options.drilldown.allowPointDrilldown === false) {
+ series.xAxis.drilldownCategory(x);
+ } else {
+ point.doDrilldown();
+ }
+ });
+ /*wrap(point, 'importEvents', function (proceed) { // wrapping importEvents makes point.click event work
+ if (!this.hasImportedEvents) {
+ proceed.call(this);
+ H.addEvent(this, 'click', function () {
+ this.doDrilldown();
+ });
+ }
+ });*/
+
+
+ // Register drilldown points on this X value
+ if (ddPointsX) {
+ ddPointsX.push(point);
+ ddPointsX.levelNumber = series.options._levelNumber;
+ }
+
+ }
+
+ // Add or remove click handler and style on the tick label
+ if (tick) {
+ tick.drillable();
+ }
+
+ return point;
+ });
+
+ wrap(H.Series.prototype, 'drawDataLabels', function (proceed) {
+ var css = this.chart.options.drilldown.activeDataLabelStyle;
+
+ proceed.call(this);
+
+ each(this.points, function (point) {
+ if (point.drilldown && point.dataLabel) {
+ point.dataLabel
+ .attr({
+ 'class': 'highcharts-drilldown-data-label'
+ })
+ .css(css);
+ }
+ });
+ });
+
+ // Mark the trackers with a pointer
+ var type,
+ drawTrackerWrapper = function (proceed) {
+ proceed.call(this);
+ each(this.points, function (point) {
+ if (point.drilldown && point.graphic) {
+ point.graphic
+ .attr({
+ 'class': 'highcharts-drilldown-point'
+ })
+ .css({ cursor: 'pointer' });
+ }
+ });
+ };
+ for (type in seriesTypes) {
+ if (seriesTypes[type].prototype.supportsDrilldown) {
+ wrap(seriesTypes[type].prototype, 'drawTracker', drawTrackerWrapper);
+ }
+ }
+
+}(Highcharts));
+
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ * Solid angular gauge module
+ *
+ * (c) 2010-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+/*global Highcharts, HighchartsAdapter*/
+(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.raw || '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) {
+ HighchartsAdapter.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),
+ fromColor,
+ 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') {
+ fromColor = point.color;
+ 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);
+ }
+ }
+ });
+
+}(Highcharts));
+
+/**
+ * @license Highcharts 4.1.9 JS v/Highstock 2.1.9 (2015-10-07)
+ *
+ * (c) 2011-2014 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+/*global HighchartsAdapter*/
+(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.raw || '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;
+
+ grad = horiz ? [+reversed, 0, +!reversed, 0] : [0, +!reversed, 0, +reversed]; // #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,
+ box,
+ 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);
+ box = item.legendSymbol.getBBox();
+
+ // 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) {
+ if (typeof pos === 'number') { // crosshairs only // #3969 pos can be 0 !!
+ return 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'];
+ } else {
+ return 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) {
+ HighchartsAdapter.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) {
+ proceed = new ColorAxis(this, colorAxisOptions); // Fake assignment for jsLint
+ }
+});
+
+
+/**
+ * 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}
'
+ },
+ 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;
+ this.pointRange = 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);
+ }
+
+}));
+
+
+
+
+}(Highcharts));
+
diff --git a/assets/js/main_stats.js b/assets/js/main_stats.js
new file mode 100644
index 0000000..c25e3cb
--- /dev/null
+++ b/assets/js/main_stats.js
@@ -0,0 +1,113 @@
+document.addEventListener("DOMContentLoaded", function(event) {
+ var main_channel_names = ['general','random'],
+ main_member_numbers = [],
+ main_message_numbers = [],
+ other_channel_names = [],
+ other_member_numbers = [],
+ other_message_numbers = [];
+ for(var i = 0; i < stats.channels.length; i++){
+ if(stats.channels[i].name == "general") {
+ main_member_numbers[0] = stats.channels[i].member_count;
+ main_message_numbers[0] = stats.channels[i].message_count;
+ } else if(stats.channels[i].name == "random") {
+ main_member_numbers[1] = stats.channels[i].member_count;
+ main_message_numbers[1] = stats.channels[i].message_count;
+ } else {
+ other_channel_names.push(stats.channels[i].name);
+ other_member_numbers.push(stats.channels[i].member_count);
+ other_message_numbers.push(stats.channels[i].message_count);
+ }
+ }
+
+ var mainChart = new Highcharts.Chart({
+ chart: {
+ renderTo: 'mainStatsBarChart',
+ type: 'column'
+ },
+
+ title: {
+ text: 'Main Channels'
+ },
+
+ yAxis: [{
+ min: 0,
+ title: { text: 'Messages' }
+ },{
+ min: 0,
+ title: { text: 'Members' },
+ opposite: true
+ }],
+
+ plotOptions: {
+ column: {
+ grouping: false,
+ shadow: false,
+ borderWidth: 0
+ }
+ },
+
+ xAxis: {
+ categories: main_channel_names
+ },
+
+ series: [{
+ name: 'Messages',
+ color: 'rgba(126,86,134,0.9)',
+ data: main_message_numbers,
+ pointPadding: 0.3
+ },{
+ name: 'Members',
+ color: 'rgba(165,170,217,1)',
+ data: main_member_numbers,
+ pointPadding: 0.4,
+ yAxis: 1
+ }]
+ });
+
+ var otherChart = new Highcharts.Chart({
+ chart: {
+ renderTo: 'statsBarChart',
+ type: 'column'
+ },
+
+ title: {
+ text: 'Other Channels'
+ },
+
+ yAxis: [{
+ min: 0,
+ title: { text: 'Members' }
+ },{
+ min: 0,
+ title: { text: 'Messages' },
+ opposite: true
+ }],
+
+ tooltip: { shared: true },
+
+ plotOptions: {
+ column: {
+ grouping: false,
+ shadow: false,
+ borderWidth: 0
+ }
+ },
+
+ xAxis: {
+ categories: other_channel_names
+ },
+
+ series: [{
+ name: 'Messages',
+ color: 'rgba(126,86,134,0.9)',
+ data: other_message_numbers,
+ pointPadding: 0.3
+ },{
+ name: 'Members',
+ color: 'rgba(165,170,217,1)',
+ data: other_member_numbers,
+ pointPadding: 0.4,
+ yAxis: 1
+ }]
+ });
+});
diff --git a/processor_general.go b/processor_general.go
index 9a7dad4..84696e2 100644
--- a/processor_general.go
+++ b/processor_general.go
@@ -2,6 +2,7 @@ package main
import (
"fmt"
+ "net/http"
"strings"
)
@@ -97,7 +98,7 @@ func (p *generalStatProcessor) GetStatKeys() []string {
func (p *generalStatProcessor) ProcessMessage(m *Message) {
incrementUserStat(m.User, "message-hour-"+m.Time.Format("15"))
incrementUserStat(m.User, "message-dow-"+m.Time.Format("Mon"))
- incrementUserStat(m.User, "message-dom-"+m.Time.Format("_2"))
+ incrementUserStat(m.User, "message-dom-"+m.Time.Format("02"))
}
func (p *generalStatProcessor) ProcessBotMessage(m *Message) {}
@@ -111,6 +112,99 @@ func (p *generalStatProcessor) ProcessChannelMessage(m *Message) {
incrementChannelStat(m.Channel, "message-hour-"+m.Time.Format("15"))
incrementChannelStat(m.Channel, "message-dow-"+m.Time.Format("Mon"))
- incrementChannelStat(m.Channel, "message-dom-"+m.Time.Format("_2"))
+ incrementChannelStat(m.Channel, "message-dom-"+m.Time.Format("02"))
}
func (p *generalStatProcessor) ProcessBotChannelMessage(m *Message) {}
+
+/*
+ * Web Site Module
+ */
+type generalWebModule struct{}
+
+func (wm *generalWebModule) GetName() string {
+ return "General Web Module"
+}
+func (wm *generalWebModule) GetRoutes() map[string]func(http.ResponseWriter, *http.Request) {
+ ret := make(map[string]func(http.ResponseWriter, *http.Request))
+ ret["/"] = wm.handleStats
+ return ret
+}
+func (wm *generalWebModule) Register() {
+ for k, v := range wm.GetRoutes() {
+ r.HandleFunc(k, v)
+ }
+}
+
+func (wm *generalWebModule) GetMenuEntries() []menuItem {
+ var ret []menuItem
+ ret = append(ret, menuItem{Text: "Stats", Link: "/"})
+ return ret
+}
+
+func (wm *generalWebModule) GetBottomMenuEntries() []menuItem {
+ var ret []menuItem
+ return ret
+}
+
+func (wm *generalWebModule) handleStats(w http.ResponseWriter, req *http.Request) {
+ initRequest(w, req)
+
+ type ChannelStat struct {
+ Name string
+ MemberCount int
+ MessageCount int
+ }
+ type StatData struct {
+ TotalChannelMessages int
+ TotalChannels int
+ ChannelStats []ChannelStat
+ Error string
+ }
+
+ // Get the global stats
+ var s StatData
+ var err error
+
+ openDatabase()
+ chanlst := getChannelList()
+ var chanstats []ChannelStat
+ for _, k := range chanlst {
+ chanstats = append(chanstats, ChannelStat{
+ Name: getChannelName(k),
+ MemberCount: getChannelMemberCount(k),
+ MessageCount: getChannelMessageCount(k),
+ })
+ }
+ s.ChannelStats = chanstats
+ s.TotalChannelMessages = getTotalChannelMsgCount()
+ s.TotalChannels = len(chanlst)
+ closeDatabase()
+
+ sc := "var stats = {totalchannelmessages:"
+ sc = fmt.Sprintf("%s%d,", sc, s.TotalChannelMessages)
+ sc = sc + "\"channels\":["
+ for _, k := range s.ChannelStats {
+ sc = fmt.Sprintf("%s{name:\"%s\",member_count:%d,message_count:%d},",
+ sc,
+ k.Name,
+ k.MemberCount,
+ k.MessageCount,
+ )
+ }
+ // Trim the last ,
+ sc = sc[:len(sc)-1]
+ sc = sc + "]"
+ sc = sc + "};"
+
+ addToInlineScript(sc)
+
+ site.Scripts = append(site.Scripts, "/assets/js/main_stats.js")
+
+ if err != nil {
+ setFlashMessage("Error Counting Channel Messages", "error")
+ }
+ site.TemplateData = s
+
+ setMenuItemActive("Stats")
+ showPage("stats.html", site, w)
+}
diff --git a/processor_levelup.go b/processor_levelup.go
index 356eada..69f2f63 100644
--- a/processor_levelup.go
+++ b/processor_levelup.go
@@ -1,5 +1,7 @@
package main
+import "net/http"
+
type levelUpStatProcessor struct{}
func (p *levelUpStatProcessor) GetName() string {
@@ -39,3 +41,36 @@ func (p *levelUpStatProcessor) ProcessChannelMessage(m *Message) {
}
func (p *levelUpStatProcessor) ProcessAdminChannelMessage(m *Message) {}
func (p *levelUpStatProcessor) ProcessBotChannelMessage(m *Message) {}
+
+/*
+ * Web Site Module
+ */
+type levelUpWebModule struct{}
+
+func (wm *levelUpWebModule) GetName() string {
+ return "LevelUp Web Module"
+}
+func (wm *levelUpWebModule) GetRoutes() map[string]func(http.ResponseWriter, *http.Request) {
+ ret := make(map[string]func(http.ResponseWriter, *http.Request))
+ //ret["/levelup/"] = wm.
+ return ret
+}
+func (wm *levelUpWebModule) Register() {
+ for k, v := range wm.GetRoutes() {
+ r.HandleFunc(k, v)
+ }
+}
+func (wm *levelUpWebModule) GetMenuEntries() []menuItem {
+ var ret []menuItem
+ ret = append(ret, menuItem{Text: "LevelUp!", Link: "/levelup/"})
+ return ret
+}
+func (wm *levelUpWebModule) GetBottomMenuEntries() []menuItem {
+ var ret []menuItem
+ return ret
+}
+
+func (wm *levelUpWebModule) handleLevelUpGeneral(w http.ResponseWriter, req *http.Request) {
+ initRequest(w, req)
+
+}
diff --git a/statbot.go b/statbot.go
index de8648d..9c7a62f 100644
--- a/statbot.go
+++ b/statbot.go
@@ -55,7 +55,6 @@ func main() {
panic(err)
}
- // For now, we're not running the web server
statWebMain(slack)
statBotMain(slack)
}
diff --git a/statbot_model.go b/statbot_model.go
index 1fca673..82bd9ca 100644
--- a/statbot_model.go
+++ b/statbot_model.go
@@ -398,6 +398,7 @@ func addChannelStat(channel string, key string, addVal int) error {
openDatabase()
v, err := getChannelStat(channel, key)
err = saveChannelStat(channel, key, v+addVal)
+ v, err = getChannelStat(channel, key)
closeDatabase()
return err
}
@@ -410,6 +411,55 @@ func decrementChannelStat(channel string, key string) error {
return addChannelStat(channel, key, -1)
}
+func getChannelName(chnl string) string {
+ var ret string
+ openDatabase()
+ db.View(func(tx *bolt.Tx) error {
+ var b, chB, chIB *bolt.Bucket
+ var err error
+
+ b = tx.Bucket([]byte("channels"))
+ if b == nil {
+ return fmt.Errorf("Error opening 'channels' bucket")
+ }
+ if chB = b.Bucket([]byte(chnl)); chB == nil {
+ return fmt.Errorf("Error opening channel bucket (%s)", chnl)
+ }
+ if chIB = chB.Bucket([]byte("info")); chIB == nil {
+ return fmt.Errorf("Error opening channel info bucket (%s/info)", chnl)
+ }
+ ret, err = bktGetString(chIB, "name")
+ return err
+ })
+ closeDatabase()
+ return ret
+}
+
+func getChannelMemberCount(chnl string) int {
+ var ret int
+ openDatabase()
+ db.View(func(tx *bolt.Tx) error {
+ var b, chB, chIB *bolt.Bucket
+
+ b = tx.Bucket([]byte("channels"))
+ if b == nil {
+ return fmt.Errorf("Error opening 'channels' bucket")
+ }
+ if chB = b.Bucket([]byte(chnl)); chB == nil {
+ return fmt.Errorf("Error opening channel bucket (%s)", chnl)
+ }
+ if chIB = chB.Bucket([]byte("info")); chIB == nil {
+ return fmt.Errorf("Error opening channel info bucket (%s/info)", chnl)
+ }
+ // Get all of the members into a []string
+ chMembersB := chIB.Bucket([]byte("members"))
+ ret = chMembersB.Stats().KeyN
+ return nil
+ })
+ closeDatabase()
+ return ret
+}
+
func getChannelStat(channel string, key string) (int, error) {
openDatabase()
var ret int
@@ -421,8 +471,8 @@ func getChannelStat(channel string, key string) (int, error) {
if b == nil {
return fmt.Errorf("Unable to open 'channels' bucket")
}
- if chB, err = b.CreateBucketIfNotExists([]byte(channel)); err == nil {
- if chSB, err = chB.CreateBucketIfNotExists([]byte("stats")); err == nil {
+ if chB = b.Bucket([]byte(channel)); chB != nil {
+ if chSB = chB.Bucket([]byte("stats")); chSB != nil {
ret, err = bktGetInt(chSB, key)
return err
}
@@ -671,8 +721,8 @@ func getUserStat(user string, key string) (int, error) {
if b == nil {
return fmt.Errorf("Unable to open 'users' bucket")
}
- if uB, err = b.CreateBucketIfNotExists([]byte(user)); err == nil {
- if uSB, err = uB.CreateBucketIfNotExists([]byte("stats")); err == nil {
+ if uB = b.Bucket([]byte(user)); uB != nil {
+ if uSB = uB.Bucket([]byte("stats")); uSB != nil {
ret, err = bktGetInt(uSB, key)
return err
}
@@ -705,6 +755,7 @@ func addUserStat(user string, key string, addVal int) error {
openDatabase()
v, err := getUserStat(user, key)
err = saveUserStat(user, key, v+addVal)
+ v, err = getUserStat(user, key)
closeDatabase()
return err
}
@@ -777,6 +828,52 @@ func getAllUsersStats() (map[string]int, error) {
return ret, err
}
+func getChannelMessageCount(channel string) int {
+ var ret int
+ openDatabase()
+ db.View(func(tx *bolt.Tx) error {
+ var b, chB, chMB *bolt.Bucket
+ var err error
+
+ b = tx.Bucket([]byte("channels"))
+ if chB = b.Bucket([]byte(channel)); chB != nil {
+ if chMB = chB.Bucket([]byte("messages")); chMB != nil {
+ ret = chMB.Stats().BucketN
+ }
+ }
+ return err
+ })
+ closeDatabase()
+ return ret
+}
+
+func getChannelList() []string {
+ openDatabase()
+ // First build channel list
+ var chans []string
+ db.Update(func(tx *bolt.Tx) error {
+ b := tx.Bucket([]byte("channels"))
+ return b.ForEach(func(k, v []byte) error {
+ chans = append(chans, string(k))
+ return nil
+ })
+ })
+ closeDatabase()
+ return chans
+}
+
+func getTotalChannelMsgCount() int {
+ var ret int
+ openDatabase()
+ // First build channel list
+ chans := getChannelList()
+ for _, k := range chans {
+ ret = ret + getChannelMessageCount(k)
+ }
+ closeDatabase()
+ return ret
+}
+
func bktGetBucket(b *bolt.Bucket, key string) (*bolt.Bucket, error) {
bkt := b.Bucket([]byte(key))
if bkt != nil {
diff --git a/statbotweb.go b/statbotweb.go
index e7991e9..d285886 100644
--- a/statbotweb.go
+++ b/statbotweb.go
@@ -19,8 +19,9 @@ type SiteData struct {
Port int
SessionName string
- Stylesheets []string
- Scripts []string
+ Stylesheets []string
+ Scripts []string
+ InlineScript string
Flash flashMessage // Quick message at top of page
Menu []menuItem // Top-aligned menu items
@@ -46,6 +47,16 @@ var site SiteData
var sessionStore = sessions.NewCookieStore([]byte("gostatbot secret cookie nobody will guess"))
var r *mux.Router
+type webModule interface {
+ GetName() string
+ GetRoutes() map[string]func(http.ResponseWriter, *http.Request)
+ Register()
+ GetMenuEntries() []menuItem
+ GetBottomMenuEntries() []menuItem
+}
+
+var webModules []webModule
+
// This is the main function for the web server
func statWebMain(slack *Slack) {
site.Title = "stat_bot"
@@ -58,7 +69,9 @@ func statWebMain(slack *Slack) {
assetHandler := http.FileServer(http.Dir("./assets/"))
http.Handle("/assets/", http.StripPrefix("/assets/", assetHandler))
- r.HandleFunc("/", handleStats)
+
+ registerWebModule(new(generalWebModule))
+
http.Handle("/", r)
go func() {
log.Fatal(http.ListenAndServe(fmt.Sprintf(":%d", site.Port), context.ClearHandler(http.DefaultServeMux)))
@@ -73,33 +86,39 @@ func initRequest(w http.ResponseWriter, req *http.Request) {
site.Stylesheets = append(site.Stylesheets, "https://maxcdn.bootstrapcdn.com/font-awesome/4.4.0/css/font-awesome.min.css")
site.Scripts = make([]string, 0, 0)
+ site.Scripts = append(site.Scripts, "/assets/js/highcharts.js")
site.Menu = make([]menuItem, 0, 0)
- site.Menu = append(site.Menu, menuItem{Text: "Stats", Link: "/stats/"})
-
site.BottomMenu = make([]menuItem, 0, 0)
site.BottomMenu = append(site.BottomMenu, menuItem{Text: "Admin", Link: "/admin/"})
+ for _, mod := range webModules {
+ for _, m := range mod.GetMenuEntries() {
+ site.Menu = append(site.Menu, m)
+ }
+ for _, m := range mod.GetBottomMenuEntries() {
+ site.BottomMenu = append(site.BottomMenu, m)
+ }
+ }
}
-func handleStats(w http.ResponseWriter, req *http.Request) {
- initRequest(w, req)
-
- type StatData struct {
- TotalChannelMessages int
- Error string
+func registerWebModule(b webModule) {
+ // Register a web module
+ // Make sure that we haven't already registered it (or another that has the same route)
+ for _, mod := range webModules {
+ if mod.GetName() == b.GetName() {
+ panic(fmt.Errorf("Attempted to Re-register Web Module %s", b.GetName()))
+ } else {
+ for k := range mod.GetRoutes() {
+ for nk := range b.GetRoutes() {
+ if k == nk {
+ panic(fmt.Errorf("Attempted to Re-register Web Route %s", k))
+ }
+ }
+ }
+ }
}
-
- // Get the global stats
- var s StatData
- if stats, err := getAllUsersStats(); err == nil {
- s = StatData{TotalChannelMessages: stats["channel-message"], Error: ""}
- } else {
- s = StatData{TotalChannelMessages: -1, Error: fmt.Sprintf("%s", err)}
- }
- site.TemplateData = s
-
- setMenuItemActive("Stats")
- showPage("stats.html", site, w)
+ b.Register()
+ webModules = append(webModules, b)
}
// showPage
@@ -159,6 +178,14 @@ func getSessionStringValue(key string, w http.ResponseWriter, req *http.Request)
return retVal, nil
}
+func setFlashMessage(msg string, stat string) {
+ site.Flash = flashMessage{Message: msg, Status: stat}
+}
+
+func addToInlineScript(s string) {
+ site.InlineScript = fmt.Sprintf("%s%s", site.InlineScript, s)
+}
+
func assertError(err error, w http.ResponseWriter) bool {
if err != nil {
http.Error(w, err.Error(), 500)
diff --git a/templates/htmlfooter.html b/templates/htmlfooter.html
index bb84825..d3e2c5d 100644
--- a/templates/htmlfooter.html
+++ b/templates/htmlfooter.html
@@ -3,5 +3,6 @@
{{ range $i, $v := .Scripts }}
{{ end }}
+