From 59bfbce44674e52aefbe883233ffaea93d750a8f Mon Sep 17 00:00:00 2001
From: yujian <yujian@163.com>
Date: 星期一, 25 十一月 2019 09:56:17 +0800
Subject: [PATCH] Merge branch 'div' of ssh://193.112.35.168:29418/fanli-server into div
---
fanli/src/main/webapp/admin/new/js/third-party/highcharts/highcharts.src.js | 33948 +++++++++++++++++++++++++++++-----------------------------
1 files changed, 16,974 insertions(+), 16,974 deletions(-)
diff --git a/fanli/src/main/webapp/admin/new/js/third-party/highcharts/highcharts.src.js b/fanli/src/main/webapp/admin/new/js/third-party/highcharts/highcharts.src.js
index a29b0fa..1a9893a 100644
--- a/fanli/src/main/webapp/admin/new/js/third-party/highcharts/highcharts.src.js
+++ b/fanli/src/main/webapp/admin/new/js/third-party/highcharts/highcharts.src.js
@@ -1,16974 +1,16974 @@
-// ==ClosureCompiler==
-// @compilation_level SIMPLE_OPTIMIZATIONS
-
-/**
- * @license Highcharts JS v3.0.6 (2013-10-04)
- *
- * (c) 2009-2013 Torstein H酶nsi
- *
- * License: www.highcharts.com/license
- */
-
-// JSLint options:
-/*global Highcharts, document, window, navigator, setInterval, clearInterval, clearTimeout, setTimeout, location, jQuery, $, console, each, grep */
-
-(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,
- isIE = /msie/i.test(userAgent) && !isOpera,
- docMode8 = doc.documentMode === 8,
- isWebKit = /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 && !isIE && !!doc.createElement('canvas').getContext,
- Renderer,
- hasTouch = doc.documentElement.ontouchstart !== UNDEFINED,
- symbolSizes = {},
- idCounter = 0,
- garbageBin,
- defaultOptions,
- dateFormat, // function
- globalAnimation,
- pathAnim,
- timeUnits,
- noop = function () {},
- charts = [],
- PRODUCT = 'Highcharts',
- VERSION = '3.0.6',
-
- // 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',
- /*
- * Empirical lowest possible opacities for TRACKER_FILL
- * 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) + ')', // invisible but clickable
- //TRACKER_FILL = 'rgba(192,192,192,0.5)',
- NORMAL_STATE = '',
- HOVER_STATE = 'hover',
- SELECT_STATE = 'select',
- MILLISECOND = 'millisecond',
- SECOND = 'second',
- MINUTE = 'minute',
- HOUR = 'hour',
- DAY = 'day',
- WEEK = 'week',
- MONTH = 'month',
- YEAR = 'year',
-
- // constants for attributes
- LINEAR_GRADIENT = 'linearGradient',
- STOPS = 'stops',
- STROKE_WIDTH = 'stroke-width',
-
- // time methods, changed based on whether or not UTC is used
- makeTime,
- getMinutes,
- getHours,
- getDay,
- getDate,
- getMonth,
- getFullYear,
- setMinutes,
- setHours,
- setDate,
- setMonth,
- setFullYear,
-
-
- // lookup over the types and the associated classes
- seriesTypes = {};
-
-// The Highcharts namespace
-win.Highcharts = win.Highcharts ? error(16, true) : {};
-
-/**
- * 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
- */
-function extend(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.
- * 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,
- len = arguments.length,
- 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]'
- && typeof value.nodeType !== 'number') {
- copy[key] = doCopy(copy[key] || {}, value);
-
- // Primitives and arrays are copied over directly
- } else {
- copy[key] = original[key];
- }
- }
- }
- return copy;
- };
-
- // For each argument, extend the return
- for (i = 0; i < len; i++) {
- ret = doCopy(ret, arguments[i]);
- }
-
- return ret;
-}
-
-/**
- * Take an array and turn into a hash with even number arguments as keys and odd numbers as
- * values. Allows creating constants for commonly used style properties, attributes etc.
- * Avoid it in performance critical situations like looping
- */
-function hash() {
- var i = 0,
- args = arguments,
- length = args.length,
- obj = {};
- for (; i < length; i++) {
- obj[args[i++]] = args[i];
- }
- return obj;
-}
-
-/**
- * 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 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,
- setAttribute = 'setAttribute',
- 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.
- */
-function pick() {
- var args = arguments,
- i,
- arg,
- length = args.length;
- for (i = 0; i < length; i++) {
- arg = args[i];
- if (typeof 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 (isIE) {
- 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 () {};
- object.prototype = new parent();
- extend(object.prototype, members);
- return object;
-}
-
-/**
- * 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
- */
-function numberFormat(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 ?
- (n.toString().split('.')[1] || '').length : // preserve decimals
- (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) : "");
-}
-
-/**
- * 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;
-}
-
-/**
- * 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.
- */
-function wrap(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);
- };
-}
-
-/**
- * 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 'Invalid date';
- }
- format = pick(format, '%Y-%m-%d %H:%M:%S');
-
- var date = new Date(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
-
- // 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
- '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;
- val = 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, options) {
- var normalized, i;
-
- // 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 (options && options.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++) {
- interval = multiples[i];
- if (normalized <= (multiples[i] + (multiples[i + 1] || multiples[i])) / 2) {
- break;
- }
- }
-
- // multiply back to the correct magnitude
- interval *= magnitude;
-
- return interval;
-}
-
-/**
- * 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.
- */
-function normalizeTimeTickInterval(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 ? getMagnitude(tickInterval / interval) : 1 // #1913
- );
-
- return {
- unitRange: interval,
- count: count,
- unitName: unit[0]
- };
-}
-
-/**
- * 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
- */
-function getTimeTicks(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),
- interval = normalizedInterval.unitRange,
- count = normalizedInterval.count;
-
- if (defined(min)) { // #1300
- if (interval >= timeUnits[SECOND]) { // second
- minDate.setMilliseconds(0);
- minDate.setSeconds(interval >= timeUnits[MINUTE] ? 0 :
- 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;
- minYear = minDate[getFullYear]();
- var time = minDate.getTime(),
- minMonth = minDate[getMonth](),
- minDateDate = minDate[getDate](),
- timezoneOffset = useUTC ?
- 0 :
- (24 * 3600 * 1000 + minDate.getTimezoneOffset() * 60 * 1000) % (24 * 3600 * 1000); // #950
-
- // 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] === timezoneOffset;
- }), 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;
-}
-
-/**
- * Helper class that contains variuos counters that are local to the chart.
- */
-function ChartCounters() {
- this.color = 0;
- this.symbol = 0;
-}
-
-ChartCounters.prototype = {
- /**
- * Wraps the color counter if it reaches the specified length.
- */
- wrapColor: function (length) {
- if (this.color >= length) {
- this.color = 0;
- }
- },
-
- /**
- * Wraps the symbol counter if it reaches the specified length.
- */
- wrapSymbol: function (length) {
- if (this.symbol >= length) {
- this.symbol = 0;
- }
- }
-};
-
-
-/**
- * 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) {
- return parseFloat(
- num.toPrecision(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) {
- globalAnimation = pick(animation, chart.animation);
-}
-
-/**
- * The time unit lookup
- */
-/*jslint white: true*/
-timeUnits = hash(
- MILLISECOND, 1,
- SECOND, 1000,
- MINUTE, 60000,
- HOUR, 3600000,
- DAY, 24 * 3600000,
- WEEK, 7 * 24 * 3600000,
- MONTH, 31 * 24 * 3600000,
- YEAR, 31556952000
-);
-/*jslint white: false*/
-/**
- * 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;
- }
-};
-
-(function ($) {
- /**
- * The default HighchartsAdapter for jQuery
- */
- win.HighchartsAdapter = win.HighchartsAdapter || ($ && {
-
- /**
- * Initialize the adapter by applying some extensions to jQuery
- */
- init: function (pathAnim) {
-
- // extend the animate function to allow SVG animations
- var Fx = $.fx,
- Step = Fx.step,
- dSetter,
- Tween = $.Tween,
- propHooks = Tween && Tween.propHooks,
- opacityHook = $.cssHooks.opacity;
-
- /*jslint unparam: true*//* allow unused param x in this function */
- $.extend($.easing, {
- easeOutQuad: function (x, t, b, c, d) {
- return -c * (t /= d) * (t - 2) + b;
- }
- });
- /*jslint unparam: false*/
-
- // extend some methods to check for elem.attr, which means it is a Highcharts SVG object
- $.each(['cur', '_default', 'width', 'height', 'opacity'], function (i, fn) {
- var obj = Step,
- base,
- elem;
-
- // Handle different parent objects
- if (fn === 'cur') {
- obj = Fx.prototype; // 'cur', the getter, relates to Fx.prototype
-
- } else if (fn === '_default' && Tween) { // jQuery 1.8 model
- obj = propHooks[fn];
- fn = 'set';
- }
-
- // Overwrite the method
- base = obj[fn];
- if (base) { // step.width and step.height don't exist in jQuery < 1.7
-
- // create the extended function replacement
- obj[fn] = function (fx) {
-
- // Fx.prototype.cur does not use fx argument
- fx = i ? fx : this;
-
- // Don't run animations on textual properties like align (#1821)
- if (fx.prop === 'align') {
- return;
- }
-
- // shortcut
- elem = fx.elem;
-
- // Fx.prototype.cur returns the current value. The other ones are setters
- // and returning a value has no effect.
- return elem.attr ? // is SVG element wrapper
- elem.attr(fx.prop, fn === 'cur' ? UNDEFINED : fx.now) : // apply the SVG wrapper's method
- base.apply(this, arguments); // use jQuery's built-in method
- };
- }
- });
-
- // Extend the opacity getter, needed for fading opacity with IE9 and jQuery 1.10+
- wrap(opacityHook, 'get', function (proceed, elem, computed) {
- return elem.attr ? (elem.opacity || 0) : proceed.call(this, elem, computed);
- });
-
-
- // Define the setter function for d (path definitions)
- dSetter = function (fx) {
- var elem = fx.elem,
- ends;
-
- // Normally start and end should be set in state == 0, but sometimes,
- // for reasons unknown, this doesn't happen. Perhaps state == 0 is skipped
- // in these cases
- if (!fx.started) {
- ends = pathAnim.init(elem, elem.d, elem.toD);
- fx.start = ends[0];
- fx.end = ends[1];
- fx.started = true;
- }
-
-
- // interpolate each value of the path
- elem.attr('d', pathAnim.step(fx.start, fx.end, fx.pos, elem.toD));
- };
-
- // jQuery 1.8 style
- if (Tween) {
- propHooks.d = {
- set: dSetter
- };
- // pre 1.8
- } else {
- // animate paths
- Step.d = dSetter;
- }
-
- /**
- * Utility for iterating over an array. Parameters are reversed compared to jQuery.
- * @param {Array} arr
- * @param {Function} fn
- */
- this.each = Array.prototype.forEach ?
- function (arr, fn) { // modern browsers
- return Array.prototype.forEach.call(arr, fn);
-
- } :
- 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;
- }
- }
- };
-
- /**
- * Register Highcharts as a plugin in the respective framework
- */
- $.fn.highcharts = function () {
- var constr = 'Chart', // default constructor
- args = arguments,
- options,
- ret,
- chart;
-
- if (isString(args[0])) {
- constr = args[0];
- args = Array.prototype.slice.call(args, 1);
- }
- options = args[0];
-
- // Create the chart
- if (options !== UNDEFINED) {
- /*jslint unused:false*/
- options.chart = options.chart || {};
- options.chart.renderTo = this[0];
- chart = new Highcharts[constr](options, args[1]);
- ret = this;
- /*jslint unused:true*/
- }
-
- // When called without parameters or with the return argument, get a predefined chart
- if (options === UNDEFINED) {
- ret = charts[attr(this[0], 'data-highcharts-chart')];
- }
-
- return ret;
- };
-
- },
-
-
- /**
- * Downloads a script and executes a callback when done.
- * @param {String} scriptLocation
- * @param {Function} callback
- */
- getScript: $.getScript,
-
- /**
- * Return the index of an item in an array, or -1 if not found
- */
- inArray: $.inArray,
-
- /**
- * A direct link to jQuery methods. MooTools and Prototype adapters must be implemented for each case of method.
- * @param {Object} elem The HTML element
- * @param {String} method Which method to run on the wrapped element
- */
- adapterRun: function (elem, method) {
- return $(elem)[method]();
- },
-
- /**
- * Filter an array
- */
- grep: $.grep,
-
- /**
- * Map an array
- * @param {Array} arr
- * @param {Function} fn
- */
- map: function (arr, fn) {
- //return jQuery.map(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 position of an element relative to the top left of the page
- */
- offset: function (el) {
- return $(el).offset();
- },
-
- /**
- * Add an event listener
- * @param {Object} el A HTML element or custom object
- * @param {String} event The event type
- * @param {Function} fn The event handler
- */
- addEvent: function (el, event, fn) {
- $(el).bind(event, fn);
- },
-
- /**
- * Remove event added with addEvent
- * @param {Object} el The object
- * @param {String} eventType The event type. Leave blank to remove all events.
- * @param {Function} handler The function to remove
- */
- removeEvent: function (el, eventType, handler) {
- // workaround for jQuery issue with unbinding custom events:
- // http://forum.jQuery.com/topic/javascript-error-when-unbinding-a-custom-event-using-jQuery-1-4-2
- var func = doc.removeEventListener ? 'removeEventListener' : 'detachEvent';
- if (doc[func] && el && !el[func]) {
- el[func] = function () {};
- }
-
- $(el).unbind(eventType, handler);
- },
-
- /**
- * Fire an event on a custom object
- * @param {Object} el
- * @param {String} type
- * @param {Object} eventArguments
- * @param {Function} defaultFunction
- */
- fireEvent: function (el, type, eventArguments, defaultFunction) {
- var event = $.Event(type),
- detachedType = 'detached' + type,
- defaultPrevented;
-
- // Remove warnings in Chrome when accessing layerX and layerY. Although Highcharts
- // never uses these properties, Chrome includes them in the default click event and
- // raises the warning when they are copied over in the extend statement below.
- //
- // To avoid problems in IE (see #1010) where we cannot delete the properties and avoid
- // testing if they are there (warning in chrome) the only option is to test if running IE.
- if (!isIE && eventArguments) {
- delete eventArguments.layerX;
- delete eventArguments.layerY;
- }
-
- extend(event, eventArguments);
-
- // Prevent jQuery from triggering the object method that is named the
- // same as the event. For example, if the event is 'select', jQuery
- // attempts calling el.select and it goes into a loop.
- if (el[type]) {
- el[detachedType] = el[type];
- el[type] = null;
- }
-
- // Wrap preventDefault and stopPropagation in try/catch blocks in
- // order to prevent JS errors when cancelling events on non-DOM
- // objects. #615.
- /*jslint unparam: true*/
- $.each(['preventDefault', 'stopPropagation'], function (i, fn) {
- var base = event[fn];
- event[fn] = function () {
- try {
- base.call(event);
- } catch (e) {
- if (fn === 'preventDefault') {
- defaultPrevented = true;
- }
- }
- };
- });
- /*jslint unparam: false*/
-
- // trigger it
- $(el).trigger(event);
-
- // attach the method
- if (el[detachedType]) {
- el[type] = el[detachedType];
- el[detachedType] = null;
- }
-
- if (defaultFunction && !event.isDefaultPrevented() && !defaultPrevented) {
- defaultFunction(event);
- }
- },
-
- /**
- * Extension method needed for MooTools
- */
- washMouseEvent: function (e) {
- var ret = e.originalEvent || e;
-
- // computed by jQuery, needed by IE8
- if (ret.pageX === UNDEFINED) { // #1236
- ret.pageX = e.pageX;
- ret.pageY = e.pageY;
- }
-
- return ret;
- },
-
- /**
- * Animate a HTML element or SVG element wrapper
- * @param {Object} el
- * @param {Object} params
- * @param {Object} options jQuery-like animation options: duration, easing, callback
- */
- animate: function (el, params, options) {
- var $el = $(el);
- if (!el.style) {
- el.style = {}; // #1881
- }
- if (params.d) {
- el.toD = params.d; // keep the array form for paths, used in $.fx.step.d
- params.d = 1; // because in jQuery, animating to an array has a different meaning
- }
-
- $el.stop();
- if (params.opacity !== UNDEFINED && el.attr) {
- params.opacity += 'px'; // force jQuery to use same logic as width and height (#2161)
- }
- $el.animate(params, options);
-
- },
- /**
- * Stop running animation
- */
- stop: function (el) {
- $(el).stop();
- }
- });
-}(win.jQuery));
-
-
-// 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 = 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 *
- *****************************************************************************/
-var
-
-defaultLabelOptions = {
- enabled: true,
- // rotation: 0,
- // align: 'center',
- x: 0,
- y: 15,
- /*formatter: function () {
- return this.value;
- },*/
- style: {
- color: '#666',
- cursor: 'default',
- fontSize: '11px',
- lineHeight: '14px'
- }
-};
-
-defaultOptions = {
- colors: ['#2f7ed8', '#0d233a', '#8bbc21', '#910000', '#1aadce', '#492970',
- '#f28f43', '#77a1e5', '#c42525', '#a6c96a'],
- 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'],
- 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,
- canvasToolsURL: 'http://code.highcharts.com/3.0.6/modules/canvas-tools.js',
- VMLRadialGradientURL: 'http://code.highcharts.com/3.0.6/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: 5,
- 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: '#274b6d',//#3E576F',
- fontSize: '16px'
- }
-
- },
- subtitle: {
- text: '',
- align: 'center',
- // floating: false
- // x: 0,
- // verticalAlign: 'top',
- // y: null,
- style: {
- color: '#4d759e'
- }
- },
-
- 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,
- 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
- //radius: base + 2
- },
- select: {
- fillColor: '#FFFFFF',
- lineColor: '#000000',
- lineWidth: 2
- }
- }
- },
- point: {
- events: {}
- },
- dataLabels: merge(defaultLabelOptions, {
- align: 'center',
- enabled: false,
- formatter: function () {
- return this.y === null ? '' : numberFormat(this.y, -1);
- },
- verticalAlign: 'bottom', // above singular point
- y: 0
- // backgroundColor: undefined,
- // borderColor: undefined,
- // borderRadius: undefined,
- // borderWidth: undefined,
- // padding: 3,
- // 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: true,
- states: { // states for the entire series
- hover: {
- //enabled: false,
- //lineWidth: base + 1,
- marker: {
- // lineWidth: base + 1,
- // radius: base + 1
- }
- },
- select: {
- marker: {}
- }
- },
- stickyTracking: true
- //tooltip: {
- //pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.y}</b>'
- //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: 1,
- borderColor: '#909090',
- borderRadius: 5,
- navigation: {
- // animation: true,
- activeColor: '#274b6d',
- // arrowSize: 12
- inactiveColor: '#CCC'
- // style: {} // text styles
- },
- // margin: 10,
- // reversed: false,
- shadow: false,
- // backgroundColor: null,
- /*style: {
- padding: '5px'
- },*/
- itemStyle: {
- cursor: 'pointer',
- color: '#274b6d',
- fontSize: '12px'
- },
- itemHoverStyle: {
- //cursor: 'pointer', removed as of #601
- color: '#000'
- },
- itemHiddenStyle: {
- color: '#CCC'
- },
- itemCheckboxStyle: {
- position: ABSOLUTE,
- width: '13px', // for IE precision
- height: '13px'
- },
- // itemWidth: undefined,
- 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: '1em'
- },
- // showDuration: 0,
- style: {
- position: ABSOLUTE,
- backgroundColor: 'white',
- opacity: 0.5,
- textAlign: 'center'
- }
- },
-
- tooltip: {
- enabled: true,
- animation: hasSVG,
- //crosshairs: null,
- backgroundColor: 'rgba(255, 255, 255, .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'
- },
- //formatter: defaultFormatter,
- headerFormat: '<span style="font-size: 10px">{point.key}</span><br/>',
- pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.y}</b><br/>',
- shadow: true,
- //shared: false,
- snap: isTouchDevice ? 25 : 10,
- style: {
- color: '#333333',
- cursor: 'default',
- fontSize: '12px',
- padding: '8px',
- 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 useUTC = defaultOptions.global.useUTC,
- GET = useUTC ? 'getUTC' : 'get',
- SET = useUTC ? 'setUTC' : 'set';
-
- makeTime = useUTC ? Date.UTC : function (year, month, date, hours, minutes, seconds) {
- return new Date(
- year,
- month,
- pick(date, 1),
- pick(hours, 0),
- pick(minutes, 0),
- pick(seconds, 0)
- ).getTime();
- };
- getMinutes = GET + 'Minutes';
- getHours = GET + 'Hours';
- getDay = GET + 'Day';
- getDate = GET + 'Date';
- getMonth = GET + 'Month';
- getFullYear = GET + 'FullYear';
- 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) {
-
- // Pull out axis options and apply them to the respective default axis options
- /*defaultXAxisOptions = merge(defaultXAxisOptions, options.xAxis);
- defaultYAxisOptions = merge(defaultYAxisOptions, options.yAxis);
- options.xAxis = options.yAxis = UNDEFINED;*/
-
- // Merge in the default options
- defaultOptions = merge(defaultOptions, options);
-
- // Apply UTC
- setTimeMethods();
-
- return defaultOptions;
-}
-
-/**
- * Get the updated default options. Merely exposing defaultOptions for outside modules
- * isn't enough because the setOptions method creates 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 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 = /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*\)/.exec(input);
- if (result) {
- rgba = [pInt(result[1]), pInt(result[2]), pInt(result[3]), parseFloat(result[4], 10)];
- } else {
- // hex
- result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(input);
- if (result) {
- rgba = [pInt(result[1], 16), pInt(result[2], 16), pInt(result[3], 16), 1];
- } else {
- // rgb
- result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.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
- };
-};
-
-
-/**
- * A wrapper object for SVG elements
- */
-function SVGElement() {}
-
-SVGElement.prototype = {
- /**
- * 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;
- /**
- * A collection of attribute setters. These methods, if defined, are called right before a certain
- * attribute is set on an element wrapper. Returning false prevents the default attribute
- * setter to run. Returning a value causes the default setter to set that value. Used in
- * Renderer.label.
- */
- wrapper.attrSetters = {};
- },
- /**
- * Default base for animation
- */
- opacity: 1,
- /**
- * 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, globalAnimation, true);
- stop(this); // stop regardless of animation actually running, or reverting to .attr (#607)
- if (animOptions) {
- animOptions = merge(animOptions);
- if (complete) { // allows using a callback with the global animation without overwriting it
- animOptions.complete = complete;
- }
- animate(this, params, animOptions);
- } else {
- this.attr(params);
- if (complete) {
- complete();
- }
- }
- },
- /**
- * Set or get a given attribute
- * @param {Object|String} hash
- * @param {Mixed|Undefined} val
- */
- attr: function (hash, val) {
- var wrapper = this,
- key,
- value,
- result,
- i,
- child,
- element = wrapper.element,
- nodeName = element.nodeName.toLowerCase(), // Android2 requires lower for "text"
- renderer = wrapper.renderer,
- skipAttr,
- titleNode,
- attrSetters = wrapper.attrSetters,
- shadows = wrapper.shadows,
- hasSetSymbolSize,
- doTransform,
- ret = wrapper;
-
- // single key-value pair
- if (isString(hash) && defined(val)) {
- key = hash;
- hash = {};
- hash[key] = val;
- }
-
- // used as a getter: first argument is a string, second is undefined
- if (isString(hash)) {
- key = hash;
- if (nodeName === 'circle') {
- key = { x: 'cx', y: 'cy' }[key] || key;
- } else if (key === 'strokeWidth') {
- key = 'stroke-width';
- }
- ret = attr(element, key) || wrapper[key] || 0;
- if (key !== 'd' && key !== 'visibility' && key !== 'fill') { // 'd' is string in animation step
- ret = parseFloat(ret);
- }
-
- // setter
- } else {
-
- for (key in hash) {
- skipAttr = false; // reset
- value = hash[key];
-
- // check for a specific attribute setter
- result = attrSetters[key] && attrSetters[key].call(wrapper, value, key);
-
- if (result !== false) {
- if (result !== UNDEFINED) {
- value = result; // the attribute setter has returned a new value to set
- }
-
-
- // paths
- if (key === 'd') {
- if (value && value.join) { // join path
- value = value.join(' ');
- }
- if (/(NaN| {2}|^$)/.test(value)) {
- value = 'M 0 0';
- }
- //wrapper.d = value; // shortcut for animations
-
- // update child tspans x values
- } else if (key === 'x' && nodeName === 'text') {
- for (i = 0; i < element.childNodes.length; i++) {
- child = element.childNodes[i];
- // if the x values are equal, the tspan represents a linebreak
- if (attr(child, 'x') === attr(element, 'x')) {
- //child.setAttribute('x', value);
- attr(child, 'x', value);
- }
- }
-
- } else if (wrapper.rotation && (key === 'x' || key === 'y')) {
- doTransform = true;
-
- // apply gradients
- } else if (key === 'fill') {
- value = renderer.color(value, element, key);
-
- // circle x and y
- } else if (nodeName === 'circle' && (key === 'x' || key === 'y')) {
- key = { x: 'cx', y: 'cy' }[key] || key;
-
- // rectangle border radius
- } else if (nodeName === 'rect' && key === 'r') {
- attr(element, {
- rx: value,
- ry: value
- });
- skipAttr = true;
-
- // translation and text rotation
- } else if (key === 'translateX' || key === 'translateY' || key === 'rotation' ||
- key === 'verticalAlign' || key === 'scaleX' || key === 'scaleY') {
- doTransform = true;
- skipAttr = true;
-
- // apply opacity as subnode (required by legacy WebKit and Batik)
- } else if (key === 'stroke') {
- value = renderer.color(value, element, key);
-
- // emulate VML's dashstyle implementation
- } else if (key === 'dashstyle') {
- key = 'stroke-dasharray';
- value = value && value.toLowerCase();
- if (value === 'solid') {
- value = NONE;
- } else 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]) * pick(hash['stroke-width'], wrapper['stroke-width']);
- }
- value = value.join(',');
- }
-
- // IE9/MooTools combo: MooTools returns objects instead of numbers and IE9 Beta 2
- // is unable to cast them. Test again with final IE9.
- } else if (key === 'width') {
- value = pInt(value);
-
- // Text alignment
- } else if (key === 'align') {
- key = 'text-anchor';
- value = { left: 'start', center: 'middle', right: 'end' }[value];
-
- // Title requires a subnode, #431
- } else if (key === 'title') {
- titleNode = element.getElementsByTagName('title')[0];
- if (!titleNode) {
- titleNode = doc.createElementNS(SVG_NS, 'title');
- element.appendChild(titleNode);
- }
- titleNode.textContent = value;
- }
-
- // jQuery animate changes case
- if (key === 'strokeWidth') {
- key = 'stroke-width';
- }
-
- // In Chrome/Win < 6 as well as Batik, the stroke attribute can't be set when the stroke-
- // width is 0. #1369
- if (key === 'stroke-width' || key === 'stroke') {
- wrapper[key] = value;
- // Only apply the stroke attribute if the stroke width is defined and larger than 0
- if (wrapper.stroke && wrapper['stroke-width']) {
- attr(element, 'stroke', wrapper.stroke);
- attr(element, 'stroke-width', wrapper['stroke-width']);
- wrapper.hasStroke = true;
- } else if (key === 'stroke-width' && value === 0 && wrapper.hasStroke) {
- element.removeAttribute('stroke');
- wrapper.hasStroke = false;
- }
- skipAttr = true;
- }
-
- // symbols
- if (wrapper.symbolName && /^(x|y|width|height|r|start|end|innerR|anchorX|anchorY)/.test(key)) {
-
-
- if (!hasSetSymbolSize) {
- wrapper.symbolAttr(hash);
- hasSetSymbolSize = true;
- }
- skipAttr = true;
- }
-
- // let the shadow follow the main element
- if (shadows && /^(width|height|visibility|x|y|d|transform|cx|cy|r)$/.test(key)) {
- i = shadows.length;
- while (i--) {
- attr(
- shadows[i],
- key,
- key === 'height' ?
- mathMax(value - (shadows[i].cutHeight || 0), 0) :
- value
- );
- }
- }
-
- // validate heights
- if ((key === 'width' || key === 'height') && nodeName === 'rect' && value < 0) {
- value = 0;
- }
-
- // Record for animation and quick access without polling the DOM
- wrapper[key] = value;
-
-
- if (key === 'text') {
- // Delete bBox memo when the text changes
- if (value !== wrapper.textStr) {
- delete wrapper.bBox;
- }
- wrapper.textStr = value;
- if (wrapper.added) {
- renderer.buildText(wrapper);
- }
- } else if (!skipAttr) {
- attr(element, key, value);
- }
-
- }
-
- }
-
- // Update transform. Do this outside the loop to prevent redundant updating for batch setting
- // of attributes.
- if (doTransform) {
- wrapper.updateTransform();
- }
-
- }
-
- return ret;
- },
-
-
- /**
- * 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 (strokeWidth, x, y, width, height) {
-
- var wrapper = this,
- key,
- attribs = {},
- values = {},
- normalizer;
-
- strokeWidth = strokeWidth || wrapper.strokeWidth || (wrapper.attr && wrapper.attr('stroke-width')) || 0;
- normalizer = mathRound(strokeWidth) % 2 / 2; // mathRound because strokeWidth can sometimes have roundoff errors
-
- // normalize for crisp edges
- values.x = mathFloor(x || wrapper.x || 0) + normalizer;
- values.y = mathFloor(y || wrapper.y || 0) + normalizer;
- values.width = mathFloor((width || wrapper.width || 0) - 2 * normalizer);
- values.height = mathFloor((height || wrapper.height || 0) - 2 * normalizer);
- values.strokeWidth = strokeWidth;
-
- for (key in values) {
- if (wrapper[key] !== values[key]) { // only set attribute if changed
- wrapper[key] = attribs[key] = values[key];
- }
- }
-
- return attribs;
- },
-
- /**
- * Set styles for the element
- * @param {Object} styles
- */
- css: function (styles) {
- /*jslint unparam: true*//* allow unused param a in the regexp function below */
- var elemWrapper = this,
- elem = elemWrapper.element,
- textWidth = styles && styles.width && elem.nodeName.toLowerCase() === 'text',
- n,
- serializedCss = '',
- hyphenate = function (a, b) { return '-' + b.toLowerCase(); };
- /*jslint unparam: false*/
-
- // convert legacy
- if (styles && styles.color) {
- styles.fill = styles.color;
- }
-
- // Merge the new styles with the old ones
- styles = extend(
- elemWrapper.styles,
- styles
- );
-
- // store object
- elemWrapper.styles = styles;
-
-
- // Don't handle line wrap on canvas
- if (useCanVG && textWidth) {
- delete styles.width;
- }
-
- // serialize and set style attribute
- if (isIE && !hasSVG) { // legacy IE doesn't support setting style attribute
- if (textWidth) {
- delete styles.width;
- }
- css(elemWrapper.element, styles);
- } else {
- 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) {
- this.element.radialReference = coordinates;
- 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;
- },
-
- /**
- * 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();
- }
-
- 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,
- bBox = wrapper.bBox;
-
- // faking getBBox in exported SVG in legacy IE
- if (!bBox) {
- // 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;
- }
-
- bBox = wrapper.bBox = {
- x: element.offsetLeft,
- y: element.offsetTop,
- width: element.offsetWidth,
- height: element.offsetHeight
- };
- }
-
- return bBox;
- },
-
- /**
- * 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],
- nonLeft = align && align !== 'left',
- shadows = wrapper.shadows;
-
- // 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, height,
- rotation = wrapper.rotation,
- baseline,
- radians = 0,
- costheta = 1,
- sintheta = 0,
- quad,
- textWidth = pInt(wrapper.textWidth),
- xCorr = wrapper.xCorr || 0,
- yCorr = wrapper.yCorr || 0,
- currentTextTransform = [rotation, align, elem.innerHTML, wrapper.textWidth].join(',');
-
- if (currentTextTransform !== wrapper.cTT) { // do the calculations and DOM access only if properties changed
-
- if (defined(rotation)) {
-
- radians = rotation * deg2rad; // deg to rad
- costheta = mathCos(radians);
- sintheta = mathSin(radians);
-
- wrapper.setSpanRotation(rotation, sintheta, costheta);
-
- }
-
- width = pick(wrapper.elemWidth, elem.offsetWidth);
- height = pick(wrapper.elemHeight, elem.offsetHeight);
-
- // update textWidth
- if (width > textWidth && /[ \-]/.test(elem.textContent || elem.innerText)) { // #983, #1254
- css(elem, {
- width: textWidth + PX,
- display: 'block',
- whiteSpace: 'normal'
- });
- width = textWidth;
- }
-
- // correct x and y
- baseline = renderer.fontMetrics(elem.style.fontSize).b;
- xCorr = costheta < 0 && -width;
- yCorr = sintheta < 0 && -height;
-
- // correct for baseline and corners spilling out after rotation
- quad = costheta * sintheta < 0;
- xCorr += sintheta * baseline * (quad ? 1 - alignCorrection : alignCorrection);
- yCorr -= costheta * baseline * (rotation ? (quad ? alignCorrection : 1 - alignCorrection) : 1);
-
- // correct for the length/height of the text
- if (nonLeft) {
- xCorr -= width * alignCorrection * (costheta < 0 ? -1 : 1);
- if (rotation) {
- yCorr -= height * alignCorrection * (sintheta < 0 ? -1 : 1);
- }
- css(elem, {
- textAlign: align
- });
- }
-
- // record correction
- wrapper.xCorr = xCorr;
- wrapper.yCorr = yCorr;
- }
-
- // apply position with correction
- css(elem, {
- left: (x + xCorr) + PX,
- top: (y + yCorr) + PX
- });
-
- // force reflow in webkit to apply the left and top on useHTML element (#1249)
- if (isWebKit) {
- height = elem.offsetHeight; // assigned to height for JSLint purpose
- }
-
- // record current text transform
- wrapper.cTT = currentTextTransform;
- }
- },
-
- /**
- * Set the rotation of an individual HTML span
- */
- setSpanRotation: function (rotation) {
- var rotationStyle = {},
- cssTransformKey = isIE ? '-ms-transform' : isWebKit ? '-webkit-transform' : isFirefox ? 'MozTransform' : isOpera ? '-o-transform' : '';
-
- rotationStyle[cssTransformKey] = rotationStyle.transform = 'rotate(' + rotation + 'deg)';
- css(this.element, rotationStyle);
- },
-
- /**
- * 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,
- 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 + ' ' + (wrapper.x || 0) + ' ' + (wrapper.y || 0) + ')');
- }
-
- // apply scale
- if (defined(scaleX) || defined(scaleY)) {
- transform.push('scale(' + pick(scaleX, 1) + ' ' + pick(scaleY, 1) + ')');
- }
-
- if (transform.length) {
- attr(wrapper.element, '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 () {
- var wrapper = this,
- bBox = wrapper.bBox,
- renderer = wrapper.renderer,
- width,
- height,
- rotation = wrapper.rotation,
- element = wrapper.element,
- styles = wrapper.styles,
- rad = rotation * deg2rad;
-
- if (!bBox) {
- // SVG elements
- if (element.namespaceURI === SVG_NS || renderer.forExport) {
- try { // Fails in Firefox if the container has display: 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
- };
- } 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)
- if (isIE && styles && styles.fontSize === '11px' && height.toPrecision(3) === '22.7') {
- 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));
- }
- }
-
- wrapper.bBox = bBox;
- }
- return bBox;
- },
-
- /**
- * Show the element
- */
- show: function () {
- return this.attr({ visibility: 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.hide();
- }
- });
- },
-
- /**
- * 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,
- parentWrapper = parent || renderer,
- parentNode = parentWrapper.element || renderer.box,
- childNodes = parentNode.childNodes,
- element = this.element,
- zIndex = attr(element, 'zIndex'),
- otherElement,
- otherZIndex,
- i,
- 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 the container as having z indexed children
- if (zIndex) {
- parentWrapper.handleZ = true;
- zIndex = pInt(zIndex);
- }
-
- // insert according to this and other elements' zIndex
- if (parentWrapper.handleZ) { // this element or any of its siblings has a z index
- for (i = 0; i < childNodes.length; i++) {
- otherElement = childNodes[i];
- otherZIndex = attr(otherElement, 'zIndex');
- if (otherElement !== element && (
- // insert before the first element with a higher zIndex
- pInt(otherZIndex) > zIndex ||
- // if no zIndex given, insert before the first element with a zIndex
- (!defined(zIndex) && defined(otherZIndex))
-
- )) {
- parentNode.insertBefore(element, otherElement);
- inserted = true;
- break;
- }
- }
- }
-
- // default: append at the end
- if (!inserted) {
- parentNode.appendChild(element);
- }
-
- // mark as added
- this.added = true;
-
- // fire an event for internal hooks
- fireEvent(this, 'add');
-
- 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' && element.parentNode,
- 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).
- while (parentToClean && parentToClean.childNodes.length === 0) {
- grandParent = parentToClean.parentNode;
- wrapper.safeRemoveChild(parentToClean);
- 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;
-
- }
-};
-
-
-/**
- * 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, forExport) {
- var renderer = this,
- loc = location,
- boxWrapper,
- element,
- desc;
-
- boxWrapper = renderer.createElement('svg')
- .attr({
- version: '1.1'
- });
- 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.forExport = forExport;
- renderer.gradients = {}; // Object where gradient SvgElements are stored
-
- 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);
- }
- },
-
- /**
- * 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 () {},
-
- /**
- * 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,
- lines = pick(wrapper.textStr, '').toString()
- .replace(/<(b|strong)>/g, '<span style="font-weight:bold">')
- .replace(/<(i|em)>/g, '<span style="font-style:italic">')
- .replace(/<a/g, '<span')
- .replace(/<\/(b|strong|i|em|a)>/g, '</span>')
- .split(/<br.*?>/g),
- childNodes = textNode.childNodes,
- styleRegex = /style="([^"]+)"/,
- hrefRegex = /href="(http[^"]+)"/,
- parentX = attr(textNode, 'x'),
- textStyles = wrapper.styles,
- width = textStyles && textStyles.width && pInt(textStyles.width),
- textLineHeight = textStyles && textStyles.lineHeight,
- i = childNodes.length;
-
- /// remove old text
- while (i--) {
- textNode.removeChild(childNodes[i]);
- }
-
- if (width && !wrapper.added) {
- this.box.appendChild(textNode); // attach it to the DOM to read offset width
- }
-
- // 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(/<span/g, '|||<span').replace(/<\/span>/g, '</span>|||');
- 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 = (span.replace(/<(.|\n)*?>/g, '') || ' ')
- .replace(/</g, '<')
- .replace(/>/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
- attributes.x = parentX;
- } else {
- attributes.dx = 0; // #16
- }
-
- // add attributes
- attr(tspan, attributes);
-
- // 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',
- textLineHeight || renderer.fontMetrics(
- /px$/.test(tspan.style.fontSize) ?
- tspan.style.fontSize :
- textStyles.fontSize
- ).h,
- // Safari 6.0.2 - too optimized for its own good (#1539)
- // TODO: revisit this with future versions of Safari
- isWebKit && tspan.offsetHeight
- );
- }
-
- // Append it
- textNode.appendChild(tspan);
-
- spanNo++;
-
- // check width and apply soft breaks
- if (width) {
- var words = span.replace(/([^\^])-/g, '$1- ').split(' '), // #1273
- tooLong,
- actualWidth,
- clipHeight = wrapper._clipHeight,
- rest = [],
- dy = pInt(textLineHeight || 16),
- softLineNo = 1,
- bBox;
-
- while (words.length || rest.length) {
- delete wrapper.bBox; // delete cache
- bBox = wrapper.getBBox();
- actualWidth = bBox.width;
- tooLong = actualWidth > width;
- if (!tooLong || words.length === 1) { // new line needed
- words = rest;
- rest = [];
- if (words.length) {
- softLineNo++;
-
- if (clipHeight && softLineNo * dy > clipHeight) {
- words = ['...'];
- wrapper.attr('title', wrapper.textStr);
- } else {
-
- 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, '-')));
- }
- }
- }
- }
- }
- });
- });
- },
-
- /**
- * 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) {
- var label = this.label(text, x, y, null, null, null, null, null, 'button'),
- curState = 0,
- stateOptions,
- stateStyle,
- normalStyle,
- hoverStyle,
- pressedStyle,
- disabledStyle,
- STYLE = 'style',
- 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, isIE ? 'mouseover' : 'mouseenter', function () {
- if (curState !== 3) {
- label.attr(hoverState)
- .css(hoverStyle);
- }
- });
- addEvent(label.element, isIE ? '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 () {
- if (curState !== 3) {
- callback.call(label);
- }
- })
- .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
- };
-
- return this.createElement('circle').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').attr({
- rx: r,
- ry: r,
- fill: NONE
- });
- return wrapper.attr(
- isObject(x) ?
- x :
- // do not crispify when an object is passed in (as in column charts)
- wrapper.crisp(strokeWidth, x, y, mathMax(width, 0), mathMax(height, 0))
- );
- },
-
- /**
- * 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];
-
- // 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 () {
- centerImage(obj, symbolSizes[imageSrc] = [this.width, this.height]);
- },
- 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
- ];
- }
- },
-
- /**
- * 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;
-
- return wrapper;
- },
-
-
- /**
- * Take a color and return it if it's a string, make it a gradient if it's a
- * gradient configuration object. Prior to Highstock, an array was used to define
- * a linear gradient with pixel positions relative to the SVG. In newer versions
- * we change the coordinates to apply relative to the shape, using coordinates
- * 0-1 within the shape. To preserve backwards compatibility, linearGradient
- * in this definition is an object of x1, y1, x2 and y2.
- *
- * @param {Object} color The color or config object
- */
- color: function (color, elem, prop) {
- var renderer = this,
- colorObject,
- regexRgba = /^rgba/,
- gradName,
- gradAttr,
- gradients,
- gradientObject,
- stops,
- stopColor,
- stopOpacity,
- radialReference,
- n,
- id,
- key = [];
-
- // Apply linear or radial gradients
- if (color && color.linearGradient) {
- gradName = 'linearGradient';
- } else if (color && 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)) {
- gradAttr = merge(gradAttr, {
- 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],
- 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].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);
-
-
- // The gradient needs to keep a list of stops to be able to destroy them
- gradientObject.stops = [];
- each(stops, function (stop) {
- var stopObject;
- if (regexRgba.test(stop[1])) {
- 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);
- });
- }
-
- // Return the reference to the gradient object
- return 'url(' + renderer.url + '#' + id + ')';
-
- // Webkit and Batik can't show rgba.
- } else if (regexRgba.test(color)) {
- colorObject = Color(color);
- attr(elem, prop + '-opacity', colorObject.get('a'));
-
- return colorObject.get('rgb');
-
-
- } else {
- // Remove the opacity attribute added above. Does not throw if the attribute is not there.
- elem.removeAttribute(prop + '-opacity');
-
- return color;
- }
-
- },
-
-
- /**
- * 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,
- defaultChartStyle = defaultOptions.chart.style,
- fakeSVG = useCanVG || (!hasSVG && renderer.forExport),
- wrapper;
-
- if (useHTML && !renderer.forExport) {
- return renderer.html(str, x, y);
- }
-
- x = mathRound(pick(x, 0));
- y = mathRound(pick(y, 0));
-
- wrapper = renderer.createElement('text')
- .attr({
- x: x,
- y: y,
- text: str
- })
- .css({
- fontFamily: defaultChartStyle.fontFamily,
- fontSize: defaultChartStyle.fontSize
- });
-
- // Prevent wrapping from creating false offsetWidths in export in legacy IE (#1079, #1063)
- if (fakeSVG) {
- wrapper.css({
- position: ABSOLUTE
- });
- }
-
- wrapper.x = x;
- wrapper.y = y;
- return wrapper;
- },
-
-
- /**
- * 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 defaultChartStyle = defaultOptions.chart.style,
- wrapper = this.createElement('span'),
- attrSetters = wrapper.attrSetters,
- element = wrapper.element,
- renderer = wrapper.renderer;
-
- // Text setter
- attrSetters.text = function (value) {
- if (value !== element.innerHTML) {
- delete this.bBox;
- }
- element.innerHTML = value;
- return false;
- };
-
- // Various setters which rely on update transform
- attrSetters.x = attrSetters.y = attrSetters.align = function (value, key) {
- if (key === 'align') {
- key = 'textAlign'; // Do not overwrite the SVGElement.align method. Same as VML.
- }
- wrapper[key] = value;
- wrapper.htmlUpdateTransform();
- return false;
- };
-
- // Set the default attributes
- wrapper.attr({
- text: str,
- x: mathRound(x),
- y: mathRound(y)
- })
- .css({
- position: ABSOLUTE,
- whiteSpace: 'nowrap',
- fontFamily: defaultChartStyle.fontFamily,
- fontSize: defaultChartStyle.fontSize
- });
-
- // 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 = [];
-
- // 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;
-
- // Create a HTML div and append it to the parent div to emulate
- // the SVG group structure
- htmlGroup = parentGroup.div = parentGroup.div || createElement(DIV, {
- className: attr(parentGroup.element, 'class')
- }, {
- 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.attrSetters, {
- translateX: function (value) {
- htmlGroupStyle.left = value + PX;
- },
- translateY: function (value) {
- htmlGroupStyle.top = value + PX;
- },
- visibility: function (value, key) {
- htmlGroupStyle[key] = value;
- }
- });
- });
-
- }
- } else {
- htmlGroup = container;
- }
-
- htmlGroup.appendChild(element);
-
- // Shared with VML:
- wrapper.added = true;
- if (wrapper.alignOnAdd) {
- wrapper.htmlUpdateTransform();
- }
-
- return wrapper;
- };
- }
- return wrapper;
- },
-
- /**
- * Utility to return the baseline offset and total line height from the font size
- */
- fontMetrics: function (fontSize) {
- fontSize = pInt(fontSize || 11);
-
- // Empirical values found by comparing font size and bounding box height.
- // Applies to the default font family. http://jsfiddle.net/highcharts/7xvn7/
- var lineHeight = fontSize < 24 ? fontSize + 4 : mathRound(fontSize * 1.2),
- baseline = mathRound(lineHeight * 0.8);
-
- return {
- h: lineHeight,
- b: baseline
- };
- },
-
- /**
- * 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,
- attrSetters = wrapper.attrSetters,
- 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) &&
- text.getBBox();
- 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).b;
-
- if (needsBox) {
-
- // create the border box if it is not already present
- if (!box) {
- boxX = mathRound(-alignFactor * padding);
- boxY = baseline ? -baselineOffset : 0;
-
- wrapper.box = box = shape ?
- renderer.symbol(shape, boxX, boxY, wrapper.width, wrapper.height) :
- renderer.rect(boxX, boxY, wrapper.width, wrapper.height, 0, deferredAttr[STROKE_WIDTH]);
- box.add(wrapper);
- }
-
- // apply the box attributes
- if (!box.isImg) { // #1630
- box.attr(merge({
- width: wrapper.width,
- height: 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) && (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,
- 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;
- }
- }
-
- function getSizeAfterAdd() {
- text.add(wrapper);
- wrapper.attr({
- text: str, // alignment is available now
- x: x,
- y: y
- });
-
- if (box && defined(anchorX)) {
- wrapper.attr({
- anchorX: anchorX,
- anchorY: anchorY
- });
- }
- }
-
- /**
- * After the text element is added, get the desired size of the border box
- * and add it before the text in the DOM.
- */
- addEvent(wrapper, 'add', getSizeAfterAdd);
-
- /*
- * Add specific attribute setters.
- */
-
- // only change local variables
- attrSetters.width = function (value) {
- width = value;
- return false;
- };
- attrSetters.height = function (value) {
- height = value;
- return false;
- };
- attrSetters.padding = function (value) {
- if (defined(value) && value !== padding) {
- padding = value;
- updateTextPadding();
- }
- return false;
- };
- attrSetters.paddingLeft = function (value) {
- if (defined(value) && value !== paddingLeft) {
- paddingLeft = value;
- updateTextPadding();
- }
- return false;
- };
-
-
- // change local variable and set attribue as well
- attrSetters.align = function (value) {
- alignFactor = { left: 0, center: 0.5, right: 1 }[value];
- return false; // prevent setting text-anchor on the group
- };
-
- // apply these to the box and the text alike
- attrSetters.text = function (value, key) {
- text.attr(key, value);
- updateBoxSize();
- updateTextPadding();
- return false;
- };
-
- // apply these to the box but not to the text
- attrSetters[STROKE_WIDTH] = function (value, key) {
- needsBox = true;
- crispAdjust = value % 2 / 2;
- boxAttr(key, value);
- return false;
- };
- attrSetters.stroke = attrSetters.fill = attrSetters.r = function (value, key) {
- if (key === 'fill') {
- needsBox = true;
- }
- boxAttr(key, value);
- return false;
- };
- attrSetters.anchorX = function (value, key) {
- anchorX = value;
- boxAttr(key, value + crispAdjust - wrapperX);
- return false;
- };
- attrSetters.anchorY = function (value, key) {
- anchorY = value;
- boxAttr(key, value - wrapperY);
- return false;
- };
-
- // rename attributes
- attrSetters.x = function (value) {
- wrapper.x = value; // for animation getter
- value -= alignFactor * ((width || bBox.width) + padding);
- wrapperX = mathRound(value);
-
- wrapper.attr('translateX', wrapperX);
- return false;
- };
- attrSetters.y = function (value) {
- wrapperY = wrapper.y = mathRound(value);
- wrapper.attr('translateY', wrapperY);
- return false;
- };
-
- // 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(['fontSize', 'fontWeight', 'fontFamily', 'color', 'lineHeight', 'width', 'textDecoration', 'textShadow'], 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 () {
- removeEvent(wrapper, 'add', getSizeAfterAdd);
-
- // 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 = getSizeAfterAdd = null;
- }
- });
- }
-}; // end SVGRenderer
-
-
-// general renderer
-Renderer = SVGRenderer;
-
-
-/* ****************************************************************************
- * *
- * START OF INTERNET EXPLORER <= 8 SPECIFIC CODE *
- * *
- * For applications and websites that don't need IE support, like platform *
- * targeted mobile apps and web apps, this code can be removed. *
- * *
- *****************************************************************************/
-
-/**
- * @constructor
- */
-var VMLRenderer, VMLElement;
-if (!hasSVG && !useCanVG) {
-
-/**
- * The VML element wrapper.
- */
-Highcharts.VMLElement = VMLElement = {
-
- /**
- * Initialize a new VML element wrapper. It builds the markup as a string
- * to minimize DOM traffic.
- * @param {Object} renderer
- * @param {Object} nodeName
- */
- init: function (renderer, nodeName) {
- var wrapper = this,
- markup = ['<', nodeName, ' filled="f" stroked="f"'],
- style = ['position: ', ABSOLUTE, ';'],
- isDiv = nodeName === DIV;
-
- // divs and shapes need size
- if (nodeName === 'shape' || isDiv) {
- style.push('left:0;top:0;width:1px;height:1px;');
- }
- style.push('visibility: ', isDiv ? HIDDEN : VISIBLE);
-
- markup.push(' style="', style.join(''), '"/>');
-
- // create element with default attributes and style
- if (nodeName) {
- markup = isDiv || nodeName === 'span' || nodeName === 'img' ?
- markup.join('')
- : renderer.prepVML(markup);
- wrapper.element = createElement(markup);
- }
-
- wrapper.renderer = renderer;
- wrapper.attrSetters = {};
- },
-
- /**
- * Add the node to the given parent
- * @param {Object} parent
- */
- add: function (parent) {
- var wrapper = this,
- renderer = wrapper.renderer,
- element = wrapper.element,
- box = renderer.box,
- inverted = parent && parent.inverted,
-
- // get the parent node
- parentNode = parent ?
- parent.element || parent :
- box;
-
-
- // if the parent group is inverted, apply inversion on all children
- if (inverted) { // only on groups
- renderer.invertChild(element, parentNode);
- }
-
- // append it
- parentNode.appendChild(element);
-
- // align text after adding to be able to read offset
- wrapper.added = true;
- if (wrapper.alignOnAdd && !wrapper.deferUpdateTransform) {
- wrapper.updateTransform();
- }
-
- // fire an event for internal hooks
- fireEvent(wrapper, 'add');
-
- return wrapper;
- },
-
- /**
- * VML always uses htmlUpdateTransform
- */
- updateTransform: SVGElement.prototype.htmlUpdateTransform,
-
- /**
- * Set the rotation of a span with oldIE's filter
- */
- setSpanRotation: function (rotation, sintheta, costheta) {
- // Adjust for alignment and rotation. Rotation of useHTML content is not yet implemented
- // but it can probably be implemented for Firefox 3.5+ on user request. FF3.5+
- // has support for CSS3 transform. The getBBox method also needs to be updated
- // to compensate for the rotation, like it currently does for SVG.
- // Test case: http://highcharts.com/tests/?file=text-rotation
- css(this.element, {
- filter: rotation ? ['progid:DXImageTransform.Microsoft.Matrix(M11=', costheta,
- ', M12=', -sintheta, ', M21=', sintheta, ', M22=', costheta,
- ', sizingMethod=\'auto expand\')'].join('') : NONE
- });
- },
-
- /**
- * Converts a subset of an SVG path definition to its VML counterpart. Takes an array
- * as the parameter and returns a string.
- */
- pathToVML: function (value) {
- // convert paths
- var i = value.length,
- path = [],
- clockwise;
-
- while (i--) {
-
- // Multiply by 10 to allow subpixel precision.
- // Substracting half a pixel seems to make the coordinates
- // align with SVG, but this hasn't been tested thoroughly
- if (isNumber(value[i])) {
- path[i] = mathRound(value[i] * 10) - 5;
- } else if (value[i] === 'Z') { // close the path
- path[i] = 'x';
- } else {
- path[i] = value[i];
-
- // When the start X and end X coordinates of an arc are too close,
- // they are rounded to the same value above. In this case, substract 1 from the end X
- // position. #760, #1371.
- if (value.isArc && (value[i] === 'wa' || value[i] === 'at')) {
- clockwise = value[i] === 'wa' ? 1 : -1; // #1642
- if (path[i + 5] === path[i + 7]) {
- path[i + 7] -= clockwise;
- }
- // Start and end Y (#1410)
- if (path[i + 6] === path[i + 8]) {
- path[i + 8] -= clockwise;
- }
- }
- }
- }
- // Loop up again to handle path shortcuts (#2132)
- /*while (i++ < path.length) {
- if (path[i] === 'H') { // horizontal line to
- path[i] = 'L';
- path.splice(i + 2, 0, path[i - 1]);
- } else if (path[i] === 'V') { // vertical line to
- path[i] = 'L';
- path.splice(i + 1, 0, path[i - 2]);
- }
- }*/
- return path.join(' ') || 'x';
- },
-
- /**
- * Get or set attributes
- */
- attr: function (hash, val) {
- var wrapper = this,
- key,
- value,
- i,
- result,
- element = wrapper.element || {},
- elemStyle = element.style,
- nodeName = element.nodeName,
- renderer = wrapper.renderer,
- symbolName = wrapper.symbolName,
- hasSetSymbolSize,
- shadows = wrapper.shadows,
- skipAttr,
- attrSetters = wrapper.attrSetters,
- ret = wrapper;
-
- // single key-value pair
- if (isString(hash) && defined(val)) {
- key = hash;
- hash = {};
- hash[key] = val;
- }
-
- // used as a getter, val is undefined
- if (isString(hash)) {
- key = hash;
- if (key === 'strokeWidth' || key === 'stroke-width') {
- ret = wrapper.strokeweight;
- } else {
- ret = wrapper[key];
- }
-
- // setter
- } else {
- for (key in hash) {
- value = hash[key];
- skipAttr = false;
-
- // check for a specific attribute setter
- result = attrSetters[key] && attrSetters[key].call(wrapper, value, key);
-
- if (result !== false && value !== null) { // #620
-
- if (result !== UNDEFINED) {
- value = result; // the attribute setter has returned a new value to set
- }
-
-
- // prepare paths
- // symbols
- if (symbolName && /^(x|y|r|start|end|width|height|innerR|anchorX|anchorY)/.test(key)) {
- // 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
- if (!hasSetSymbolSize) {
- wrapper.symbolAttr(hash);
-
- hasSetSymbolSize = true;
- }
- skipAttr = true;
-
- } else if (key === 'd') {
- value = value || [];
- wrapper.d = value.join(' '); // used in getter for animation
-
- element.path = value = wrapper.pathToVML(value);
-
- // update shadows
- if (shadows) {
- i = shadows.length;
- while (i--) {
- shadows[i].path = shadows[i].cutOff ? this.cutOffPath(value, shadows[i].cutOff) : value;
- }
- }
- skipAttr = true;
-
- // handle visibility
- } else if (key === 'visibility') {
-
- // let the shadow follow the main element
- if (shadows) {
- i = shadows.length;
- while (i--) {
- shadows[i].style[key] = value;
- }
- }
-
- // Instead of toggling the visibility CSS property, move the div out of the viewport.
- // This works around #61 and #586
- if (nodeName === 'DIV') {
- value = value === HIDDEN ? '-999em' : 0;
-
- // In order to redraw, IE7 needs the div to be visible when tucked away
- // outside the viewport. So the visibility is actually opposite of
- // the expected value. This applies to the tooltip only.
- if (!docMode8) {
- elemStyle[key] = value ? VISIBLE : HIDDEN;
- }
- key = 'top';
- }
- elemStyle[key] = value;
- skipAttr = true;
-
- // directly mapped to css
- } else if (key === 'zIndex') {
-
- if (value) {
- elemStyle[key] = value;
- }
- skipAttr = true;
-
- // x, y, width, height
- } else if (inArray(key, ['x', 'y', 'width', 'height']) !== -1) {
-
- wrapper[key] = value; // used in getter
-
- if (key === 'x' || key === 'y') {
- key = { x: 'left', y: 'top' }[key];
- } else {
- value = mathMax(0, value); // don't set width or height below zero (#311)
- }
-
- // clipping rectangle special
- if (wrapper.updateClipping) {
- wrapper[key] = value; // the key is now 'left' or 'top' for 'x' and 'y'
- wrapper.updateClipping();
- } else {
- // normal
- elemStyle[key] = value;
- }
-
- skipAttr = true;
-
- // class name
- } else if (key === 'class' && nodeName === 'DIV') {
- // IE8 Standards mode has problems retrieving the className
- element.className = value;
-
- // stroke
- } else if (key === 'stroke') {
-
- value = renderer.color(value, element, key);
-
- key = 'strokecolor';
-
- // stroke width
- } else if (key === 'stroke-width' || key === 'strokeWidth') {
- element.stroked = value ? true : false;
- key = 'strokeweight';
- wrapper[key] = value; // used in getter, issue #113
- if (isNumber(value)) {
- value += PX;
- }
-
- // dashStyle
- } else if (key === 'dashstyle') {
- var strokeElem = element.getElementsByTagName('stroke')[0] ||
- createElement(renderer.prepVML(['<stroke/>']), null, null, element);
- strokeElem[key] = value || 'solid';
- wrapper.dashstyle = value; /* because changing stroke-width will change the dash length
- and cause an epileptic effect */
- skipAttr = true;
-
- // fill
- } else if (key === 'fill') {
-
- if (nodeName === 'SPAN') { // text color
- elemStyle.color = value;
- } else if (nodeName !== 'IMG') { // #1336
- element.filled = value !== NONE ? true : false;
-
- value = renderer.color(value, element, key, wrapper);
-
- key = 'fillcolor';
- }
-
- // opacity: don't bother - animation is too slow and filters introduce artifacts
- } else if (key === 'opacity') {
- /*css(element, {
- opacity: value
- });*/
- skipAttr = true;
-
- // rotation on VML elements
- } else if (nodeName === 'shape' && key === 'rotation') {
-
- wrapper[key] = element.style[key] = value; // style is for #1873
-
- // Correction for the 1x1 size of the shape container. Used in gauge needles.
- element.style.left = -mathRound(mathSin(value * deg2rad) + 1) + PX;
- element.style.top = mathRound(mathCos(value * deg2rad)) + PX;
-
- // translation for animation
- } else if (key === 'translateX' || key === 'translateY' || key === 'rotation') {
- wrapper[key] = value;
- wrapper.updateTransform();
-
- skipAttr = true;
-
- // text for rotated and non-rotated elements
- } else if (key === 'text') {
- this.bBox = null;
- element.innerHTML = value;
- skipAttr = true;
- }
-
-
- if (!skipAttr) {
- if (docMode8) { // IE8 setAttribute bug
- element[key] = value;
- } else {
- attr(element, key, value);
- }
- }
-
- }
- }
- }
- return ret;
- },
-
- /**
- * Set the element's clipping to a predefined rectangle
- *
- * @param {String} id The id of the clip rectangle
- */
- clip: function (clipRect) {
- var wrapper = this,
- clipMembers,
- cssRet;
-
- if (clipRect) {
- clipMembers = clipRect.members;
- erase(clipMembers, wrapper); // Ensure unique list of elements (#1258)
- clipMembers.push(wrapper);
- wrapper.destroyClip = function () {
- erase(clipMembers, wrapper);
- };
- cssRet = clipRect.getCSS(wrapper);
-
- } else {
- if (wrapper.destroyClip) {
- wrapper.destroyClip();
- }
- cssRet = { clip: docMode8 ? 'inherit' : 'rect(auto)' }; // #1214
- }
-
- return wrapper.css(cssRet);
-
- },
-
- /**
- * Set styles for the element
- * @param {Object} styles
- */
- css: SVGElement.prototype.htmlCss,
-
- /**
- * 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) {
- // discardElement will detach the node from its parent before attaching it
- // to the garbage bin. Therefore it is important that the node is attached and have parent.
- if (element.parentNode) {
- discardElement(element);
- }
- },
-
- /**
- * Extend element.destroy by removing it from the clip members array
- */
- destroy: function () {
- if (this.destroyClip) {
- this.destroyClip();
- }
-
- return SVGElement.prototype.destroy.apply(this);
- },
-
- /**
- * Add an event listener. VML override for normalizing event parameters.
- * @param {String} eventType
- * @param {Function} handler
- */
- on: function (eventType, handler) {
- // simplest possible event model for internal use
- this.element['on' + eventType] = function () {
- var evt = win.event;
- evt.target = evt.srcElement;
- handler(evt);
- };
- return this;
- },
-
- /**
- * In stacked columns, cut off the shadows so that they don't overlap
- */
- cutOffPath: function (path, length) {
-
- var len;
-
- path = path.split(/[ ,]/);
- len = path.length;
-
- if (len === 9 || len === 11) {
- path[len - 4] = path[len - 2] = pInt(path[len - 2]) - 10 * length;
- }
- return path.join(' ');
- },
-
- /**
- * Apply a drop shadow by copying elements and giving them different strokes
- * @param {Boolean|Object} shadowOptions
- */
- shadow: function (shadowOptions, group, cutOff) {
- var shadows = [],
- i,
- element = this.element,
- renderer = this.renderer,
- shadow,
- elemStyle = element.style,
- markup,
- path = element.path,
- strokeWidth,
- modifiedPath,
- shadowWidth,
- shadowElementOpacity;
-
- // some times empty paths are not strings
- if (path && typeof path.value !== 'string') {
- path = 'x';
- }
- modifiedPath = path;
-
- if (shadowOptions) {
- shadowWidth = pick(shadowOptions.width, 3);
- shadowElementOpacity = (shadowOptions.opacity || 0.15) / shadowWidth;
- for (i = 1; i <= 3; i++) {
-
- strokeWidth = (shadowWidth * 2) + 1 - (2 * i);
-
- // Cut off shadows for stacked column items
- if (cutOff) {
- modifiedPath = this.cutOffPath(path.value, strokeWidth + 0.5);
- }
-
- markup = ['<shape isShadow="true" strokeweight="', strokeWidth,
- '" filled="false" path="', modifiedPath,
- '" coordsize="10 10" style="', element.style.cssText, '" />'];
-
- shadow = createElement(renderer.prepVML(markup),
- null, {
- left: pInt(elemStyle.left) + pick(shadowOptions.offsetX, 1),
- top: pInt(elemStyle.top) + pick(shadowOptions.offsetY, 1)
- }
- );
- if (cutOff) {
- shadow.cutOff = strokeWidth + 1;
- }
-
- // apply the opacity
- markup = ['<stroke color="', shadowOptions.color || 'black', '" opacity="', shadowElementOpacity * i, '"/>'];
- createElement(renderer.prepVML(markup), null, null, shadow);
-
-
- // insert it
- if (group) {
- group.element.appendChild(shadow);
- } else {
- element.parentNode.insertBefore(shadow, element);
- }
-
- // record it
- shadows.push(shadow);
-
- }
-
- this.shadows = shadows;
- }
- return this;
-
- }
-};
-VMLElement = extendClass(SVGElement, VMLElement);
-
-/**
- * The VML renderer
- */
-var VMLRendererExtension = { // inherit SVGRenderer
-
- Element: VMLElement,
- isIE8: userAgent.indexOf('MSIE 8.0') > -1,
-
-
- /**
- * Initialize the VMLRenderer
- * @param {Object} container
- * @param {Number} width
- * @param {Number} height
- */
- init: function (container, width, height) {
- var renderer = this,
- boxWrapper,
- box;
-
- renderer.alignedObjects = [];
-
- boxWrapper = renderer.createElement(DIV);
- box = boxWrapper.element;
- box.style.position = RELATIVE; // for freeform drawing using renderer directly
- container.appendChild(boxWrapper.element);
-
-
- // generate the containing box
- renderer.isVML = true;
- renderer.box = box;
- renderer.boxWrapper = boxWrapper;
-
-
- renderer.setSize(width, height, false);
-
- // The only way to make IE6 and IE7 print is to use a global namespace. However,
- // with IE8 the only way to make the dynamic shapes visible in screen and print mode
- // seems to be to add the xmlns attribute and the behaviour style inline.
- if (!doc.namespaces.hcv) {
-
- doc.namespaces.add('hcv', 'urn:schemas-microsoft-com:vml');
-
- // Setup default CSS (#2153)
- (doc.styleSheets.length ? doc.styleSheets[0] : doc.createStyleSheet()).cssText +=
- 'hcv\\:fill, hcv\\:path, hcv\\:shape, hcv\\:stroke' +
- '{ behavior:url(#default#VML); display: inline-block; } ';
-
- }
- },
-
-
- /**
- * Detect whether the renderer is hidden. This happens when one of the parent elements
- * has display: none
- */
- isHidden: function () {
- return !this.box.offsetWidth;
- },
-
- /**
- * Define a clipping rectangle. In VML it is accomplished by storing the values
- * for setting the CSS style to all associated members.
- *
- * @param {Number} x
- * @param {Number} y
- * @param {Number} width
- * @param {Number} height
- */
- clipRect: function (x, y, width, height) {
-
- // create a dummy element
- var clipRect = this.createElement(),
- isObj = isObject(x);
-
- // mimic a rectangle with its style object for automatic updating in attr
- return extend(clipRect, {
- members: [],
- left: (isObj ? x.x : x) + 1,
- top: (isObj ? x.y : y) + 1,
- width: (isObj ? x.width : width) - 1,
- height: (isObj ? x.height : height) - 1,
- getCSS: function (wrapper) {
- var element = wrapper.element,
- nodeName = element.nodeName,
- isShape = nodeName === 'shape',
- inverted = wrapper.inverted,
- rect = this,
- top = rect.top - (isShape ? element.offsetTop : 0),
- left = rect.left,
- right = left + rect.width,
- bottom = top + rect.height,
- ret = {
- clip: 'rect(' +
- mathRound(inverted ? left : top) + 'px,' +
- mathRound(inverted ? bottom : right) + 'px,' +
- mathRound(inverted ? right : bottom) + 'px,' +
- mathRound(inverted ? top : left) + 'px)'
- };
-
- // issue 74 workaround
- if (!inverted && docMode8 && nodeName === 'DIV') {
- extend(ret, {
- width: right + PX,
- height: bottom + PX
- });
- }
- return ret;
- },
-
- // used in attr and animation to update the clipping of all members
- updateClipping: function () {
- each(clipRect.members, function (member) {
- member.css(clipRect.getCSS(member));
- });
- }
- });
-
- },
-
-
- /**
- * Take a color and return it if it's a string, make it a gradient if it's a
- * gradient configuration object, and apply opacity.
- *
- * @param {Object} color The color or config object
- */
- color: function (color, elem, prop, wrapper) {
- var renderer = this,
- colorObject,
- regexRgba = /^rgba/,
- markup,
- fillType,
- ret = NONE;
-
- // Check for linear or radial gradient
- if (color && color.linearGradient) {
- fillType = 'gradient';
- } else if (color && color.radialGradient) {
- fillType = 'pattern';
- }
-
-
- if (fillType) {
-
- var stopColor,
- stopOpacity,
- gradient = color.linearGradient || color.radialGradient,
- x1,
- y1,
- x2,
- y2,
- opacity1,
- opacity2,
- color1,
- color2,
- fillAttr = '',
- stops = color.stops,
- firstStop,
- lastStop,
- colors = [],
- addFillNode = function () {
- // Add the fill subnode. When colors attribute is used, the meanings of opacity and o:opacity2
- // are reversed.
- markup = ['<fill colors="' + colors.join(',') + '" opacity="', opacity2, '" o:opacity2="', opacity1,
- '" type="', fillType, '" ', fillAttr, 'focus="100%" method="any" />'];
- createElement(renderer.prepVML(markup), null, null, elem);
- };
-
- // Extend from 0 to 1
- firstStop = stops[0];
- lastStop = stops[stops.length - 1];
- if (firstStop[0] > 0) {
- stops.unshift([
- 0,
- firstStop[1]
- ]);
- }
- if (lastStop[0] < 1) {
- stops.push([
- 1,
- lastStop[1]
- ]);
- }
-
- // Compute the stops
- each(stops, function (stop, i) {
- if (regexRgba.test(stop[1])) {
- colorObject = Color(stop[1]);
- stopColor = colorObject.get('rgb');
- stopOpacity = colorObject.get('a');
- } else {
- stopColor = stop[1];
- stopOpacity = 1;
- }
-
- // Build the color attribute
- colors.push((stop[0] * 100) + '% ' + stopColor);
-
- // Only start and end opacities are allowed, so we use the first and the last
- if (!i) {
- opacity1 = stopOpacity;
- color2 = stopColor;
- } else {
- opacity2 = stopOpacity;
- color1 = stopColor;
- }
- });
-
- // Apply the gradient to fills only.
- if (prop === 'fill') {
-
- // Handle linear gradient angle
- if (fillType === 'gradient') {
- x1 = gradient.x1 || gradient[0] || 0;
- y1 = gradient.y1 || gradient[1] || 0;
- x2 = gradient.x2 || gradient[2] || 0;
- y2 = gradient.y2 || gradient[3] || 0;
- fillAttr = 'angle="' + (90 - math.atan(
- (y2 - y1) / // y vector
- (x2 - x1) // x vector
- ) * 180 / mathPI) + '"';
-
- addFillNode();
-
- // Radial (circular) gradient
- } else {
-
- var r = gradient.r,
- sizex = r * 2,
- sizey = r * 2,
- cx = gradient.cx,
- cy = gradient.cy,
- radialReference = elem.radialReference,
- bBox,
- applyRadialGradient = function () {
- if (radialReference) {
- bBox = wrapper.getBBox();
- cx += (radialReference[0] - bBox.x) / bBox.width - 0.5;
- cy += (radialReference[1] - bBox.y) / bBox.height - 0.5;
- sizex *= radialReference[2] / bBox.width;
- sizey *= radialReference[2] / bBox.height;
- }
- fillAttr = 'src="' + defaultOptions.global.VMLRadialGradientURL + '" ' +
- 'size="' + sizex + ',' + sizey + '" ' +
- 'origin="0.5,0.5" ' +
- 'position="' + cx + ',' + cy + '" ' +
- 'color2="' + color2 + '" ';
-
- addFillNode();
- };
-
- // Apply radial gradient
- if (wrapper.added) {
- applyRadialGradient();
- } else {
- // We need to know the bounding box to get the size and position right
- addEvent(wrapper, 'add', applyRadialGradient);
- }
-
- // The fill element's color attribute is broken in IE8 standards mode, so we
- // need to set the parent shape's fillcolor attribute instead.
- ret = color1;
- }
-
- // Gradients are not supported for VML stroke, return the first color. #722.
- } else {
- ret = stopColor;
- }
-
- // if the color is an rgba color, split it and add a fill node
- // to hold the opacity component
- } else if (regexRgba.test(color) && elem.tagName !== 'IMG') {
-
- colorObject = Color(color);
-
- markup = ['<', prop, ' opacity="', colorObject.get('a'), '"/>'];
- createElement(this.prepVML(markup), null, null, elem);
-
- ret = colorObject.get('rgb');
-
-
- } else {
- var propNodes = elem.getElementsByTagName(prop); // 'stroke' or 'fill' node
- if (propNodes.length) {
- propNodes[0].opacity = 1;
- propNodes[0].type = 'solid';
- }
- ret = color;
- }
-
- return ret;
- },
-
- /**
- * Take a VML string and prepare it for either IE8 or IE6/IE7.
- * @param {Array} markup A string array of the VML markup to prepare
- */
- prepVML: function (markup) {
- var vmlStyle = 'display:inline-block;behavior:url(#default#VML);',
- isIE8 = this.isIE8;
-
- markup = markup.join('');
-
- if (isIE8) { // add xmlns and style inline
- markup = markup.replace('/>', ' xmlns="urn:schemas-microsoft-com:vml" />');
- if (markup.indexOf('style="') === -1) {
- markup = markup.replace('/>', ' style="' + vmlStyle + '" />');
- } else {
- markup = markup.replace('style="', 'style="' + vmlStyle);
- }
-
- } else { // add namespace
- markup = markup.replace('<', '<hcv:');
- }
-
- return markup;
- },
-
- /**
- * Create rotated and aligned text
- * @param {String} str
- * @param {Number} x
- * @param {Number} y
- */
- text: SVGRenderer.prototype.html,
-
- /**
- * Create and return a path element
- * @param {Array} path
- */
- path: function (path) {
- var attr = {
- // subpixel precision down to 0.1 (width and height = 1px)
- coordsize: '10 10'
- };
- if (isArray(path)) {
- attr.d = path;
- } else if (isObject(path)) { // attributes
- extend(attr, path);
- }
- // create the shape
- return this.createElement('shape').attr(attr);
- },
-
- /**
- * Create and return a circle element. In VML circles are implemented as
- * shapes, which is faster than v:oval
- * @param {Number} x
- * @param {Number} y
- * @param {Number} r
- */
- circle: function (x, y, r) {
- var circle = this.symbol('circle');
- if (isObject(x)) {
- r = x.r;
- y = x.y;
- x = x.x;
- }
- circle.isCircle = true; // Causes x and y to mean center (#1682)
- circle.r = r;
- return circle.attr({ x: x, y: y });
- },
-
- /**
- * Create a group using an outer div and an inner v:group to allow rotating
- * and flipping. A simple v:group would have problems with positioning
- * child HTML elements and CSS clip.
- *
- * @param {String} name The name of the group
- */
- g: function (name) {
- var wrapper,
- attribs;
-
- // set the class name
- if (name) {
- attribs = { 'className': PREFIX + name, 'class': PREFIX + name };
- }
-
- // the div to hold HTML and clipping
- wrapper = this.createElement(DIV).attr(attribs);
-
- return wrapper;
- },
-
- /**
- * VML override to create a regular HTML image
- * @param {String} src
- * @param {Number} x
- * @param {Number} y
- * @param {Number} width
- * @param {Number} height
- */
- image: function (src, x, y, width, height) {
- var obj = this.createElement('img')
- .attr({ src: src });
-
- if (arguments.length > 1) {
- obj.attr({
- x: x,
- y: y,
- width: width,
- height: height
- });
- }
- return obj;
- },
-
- /**
- * VML uses a shape for rect to overcome bugs and rotation problems
- */
- rect: function (x, y, width, height, r, strokeWidth) {
-
- var wrapper = this.symbol('rect');
- wrapper.r = isObject(x) ? x.r : r;
-
- //return wrapper.attr(wrapper.crisp(strokeWidth, x, y, mathMax(width, 0), mathMax(height, 0)));
- return wrapper.attr(
- isObject(x) ?
- x :
- // do not crispify when an object is passed in (as in column charts)
- wrapper.crisp(strokeWidth, x, y, mathMax(width, 0), mathMax(height, 0))
- );
- },
-
- /**
- * In the VML renderer, each child of an inverted div (group) is inverted
- * @param {Object} element
- * @param {Object} parentNode
- */
- invertChild: function (element, parentNode) {
- var parentStyle = parentNode.style;
- css(element, {
- flip: 'x',
- left: pInt(parentStyle.width) - 1,
- top: pInt(parentStyle.height) - 1,
- rotation: -90
- });
- },
-
- /**
- * Symbol definitions that override the parent SVG renderer's symbols
- *
- */
- symbols: {
- // VML specific arc function
- arc: function (x, y, w, h, options) {
- var start = options.start,
- end = options.end,
- radius = options.r || w || h,
- innerRadius = options.innerR,
- cosStart = mathCos(start),
- sinStart = mathSin(start),
- cosEnd = mathCos(end),
- sinEnd = mathSin(end),
- ret;
-
- if (end - start === 0) { // no angle, don't show it.
- return ['x'];
- }
-
- ret = [
- 'wa', // clockwise arc to
- x - radius, // left
- y - radius, // top
- x + radius, // right
- y + radius, // bottom
- x + radius * cosStart, // start x
- y + radius * sinStart, // start y
- x + radius * cosEnd, // end x
- y + radius * sinEnd // end y
- ];
-
- if (options.open && !innerRadius) {
- ret.push(
- 'e',
- M,
- x,// - innerRadius,
- y// - innerRadius
- );
- }
-
- ret.push(
- 'at', // anti clockwise arc to
- x - innerRadius, // left
- y - innerRadius, // top
- x + innerRadius, // right
- y + innerRadius, // bottom
- x + innerRadius * cosEnd, // start x
- y + innerRadius * sinEnd, // start y
- x + innerRadius * cosStart, // end x
- y + innerRadius * sinStart, // end y
- 'x', // finish path
- 'e' // close
- );
-
- ret.isArc = true;
- return ret;
-
- },
- // Add circle symbol path. This performs significantly faster than v:oval.
- circle: function (x, y, w, h, wrapper) {
-
- if (wrapper) {
- w = h = 2 * wrapper.r;
- }
-
- // Center correction, #1682
- if (wrapper && wrapper.isCircle) {
- x -= w / 2;
- y -= h / 2;
- }
-
- // Return the path
- return [
- 'wa', // clockwisearcto
- x, // left
- y, // top
- x + w, // right
- y + h, // bottom
- x + w, // start x
- y + h / 2, // start y
- x + w, // end x
- y + h / 2, // end y
- //'x', // finish path
- 'e' // close
- ];
- },
- /**
- * Add rectangle symbol path which eases rotation and omits arcsize problems
- * compared to the built-in VML roundrect shape
- *
- * @param {Number} left Left position
- * @param {Number} top Top position
- * @param {Number} r Border radius
- * @param {Object} options Width and height
- */
-
- rect: function (left, top, width, height, options) {
-
- var right = left + width,
- bottom = top + height,
- ret,
- r;
-
- // No radius, return the more lightweight square
- if (!defined(options) || !options.r) {
- ret = SVGRenderer.prototype.symbols.square.apply(0, arguments);
-
- // Has radius add arcs for the corners
- } else {
-
- r = mathMin(options.r, width, height);
- ret = [
- M,
- left + r, top,
-
- L,
- right - r, top,
- 'wa',
- right - 2 * r, top,
- right, top + 2 * r,
- right - r, top,
- right, top + r,
-
- L,
- right, bottom - r,
- 'wa',
- right - 2 * r, bottom - 2 * r,
- right, bottom,
- right, bottom - r,
- right - r, bottom,
-
- L,
- left + r, bottom,
- 'wa',
- left, bottom - 2 * r,
- left + 2 * r, bottom,
- left + r, bottom,
- left, bottom - r,
-
- L,
- left, top + r,
- 'wa',
- left, top,
- left + 2 * r, top + 2 * r,
- left, top + r,
- left + r, top,
-
-
- 'x',
- 'e'
- ];
- }
- return ret;
- }
- }
-};
-Highcharts.VMLRenderer = VMLRenderer = function () {
- this.init.apply(this, arguments);
-};
-VMLRenderer.prototype = merge(SVGRenderer.prototype, VMLRendererExtension);
-
- // general renderer
- Renderer = VMLRenderer;
-}
-
-/* ****************************************************************************
- * *
- * END OF INTERNET EXPLORER <= 8 SPECIFIC CODE *
- * *
- *****************************************************************************/
-/* ****************************************************************************
- * *
- * START OF ANDROID < 3 SPECIFIC CODE. THIS CAN BE REMOVED IF YOU'RE NOT *
- * TARGETING THAT SYSTEM. *
- * *
- *****************************************************************************/
-var CanVGRenderer,
- CanVGController;
-
-if (useCanVG) {
- /**
- * The CanVGRenderer is empty from start to keep the source footprint small.
- * When requested, the CanVGController downloads the rest of the source packaged
- * together with the canvg library.
- */
- Highcharts.CanVGRenderer = CanVGRenderer = function () {
- // Override the global SVG namespace to fake SVG/HTML that accepts CSS
- SVG_NS = 'http://www.w3.org/1999/xhtml';
- };
-
- /**
- * Start with an empty symbols object. This is needed when exporting is used (exporting.src.js will add a few symbols), but
- * the implementation from SvgRenderer will not be merged in until first render.
- */
- CanVGRenderer.prototype.symbols = {};
-
- /**
- * Handles on demand download of canvg rendering support.
- */
- CanVGController = (function () {
- // List of renderering calls
- var deferredRenderCalls = [];
-
- /**
- * When downloaded, we are ready to draw deferred charts.
- */
- function drawDeferred() {
- var callLength = deferredRenderCalls.length,
- callIndex;
-
- // Draw all pending render calls
- for (callIndex = 0; callIndex < callLength; callIndex++) {
- deferredRenderCalls[callIndex]();
- }
- // Clear the list
- deferredRenderCalls = [];
- }
-
- return {
- push: function (func, scriptLocation) {
- // Only get the script once
- if (deferredRenderCalls.length === 0) {
- getScript(scriptLocation, drawDeferred);
- }
- // Register render call
- deferredRenderCalls.push(func);
- }
- };
- }());
-
- Renderer = CanVGRenderer;
-} // end CanVGRenderer
-
-/* ****************************************************************************
- * *
- * END OF ANDROID < 3 SPECIFIC CODE *
- * *
- *****************************************************************************/
-
-/**
- * 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,
- horiz = axis.horiz,
- categories = axis.categories,
- names = axis.series[0] && axis.series[0].names,
- pos = tick.pos,
- labelOptions = options.labels,
- str,
- tickPositions = axis.tickPositions,
- width = (horiz && categories &&
- !labelOptions.step && !labelOptions.staggerLines &&
- !labelOptions.rotation &&
- chart.plotWidth / tickPositions.length) ||
- (!horiz && (chart.margin[3] || chart.chartWidth * 0.33)), // #1580, #1931
- isFirst = pos === tickPositions[0],
- isLast = pos === tickPositions[tickPositions.length - 1],
- css,
- attr,
- value = categories ?
- pick(categories[pos], names && 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 };
- css = extend(css, labelOptions.style);
-
- // first call
- if (!defined(label)) {
- attr = {
- align: axis.labelAlign
- };
- if (isNumber(labelOptions.rotation)) {
- attr.rotation = labelOptions.rotation;
- }
- if (width && labelOptions.ellipsis) {
- attr._clipHeight = axis.len / tickPositions.length;
- }
-
- tick.label =
- defined(str) && labelOptions.enabled ?
- chart.renderer.text(
- str,
- 0,
- 0,
- labelOptions.useHTML
- )
- .attr(attr)
- // without position absolute, IE export sometimes is wrong
- .css(css)
- .add(axis.labelGroup) :
- null;
-
- // update
- } else if (label) {
- label.attr({
- text: str
- })
- .css(css);
- }
- },
-
- /**
- * Get the offset height or width of the label
- */
- getLabelSize: function () {
- var label = this.label,
- axis = this.axis;
- return label ?
- ((this.labelBBox = label.getBBox()))[axis.horiz ? 'height' : 'width'] :
- 0;
- },
-
- /**
- * Find how far the labels extend to the right and left of the tick's x position. Used for anti-collision
- * detection with overflow logic.
- */
- getLabelSides: function () {
- var bBox = this.labelBBox, // assume getLabelSize has run at this point
- axis = this.axis,
- options = axis.options,
- labelOptions = options.labels,
- width = bBox.width,
- leftSide = width * { left: 0, center: 0.5, right: 1 }[axis.labelAlign] - labelOptions.x;
-
- return [-leftSide, width - leftSide];
- },
-
- /**
- * 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 (index, xy) {
- var show = true,
- axis = this.axis,
- chart = axis.chart,
- isFirst = this.isFirst,
- isLast = this.isLast,
- x = xy.x,
- reversed = axis.reversed,
- tickPositions = axis.tickPositions;
-
- if (isFirst || isLast) {
-
- var sides = this.getLabelSides(),
- leftSide = sides[0],
- rightSide = sides[1],
- plotLeft = chart.plotLeft,
- plotRight = plotLeft + axis.len,
- neighbour = axis.ticks[tickPositions[index + (isFirst ? 1 : -1)]],
- neighbourEdge = neighbour && neighbour.label.xy && neighbour.label.xy.x + neighbour.getLabelSides()[isFirst ? 0 : 1];
-
- if ((isFirst && !reversed) || (isLast && reversed)) {
- // Is the label spilling out to the left of the plot area?
- if (x + leftSide < plotLeft) {
-
- // Align it to plot left
- x = plotLeft - leftSide;
-
- // Hide it if it now overlaps the neighbour label
- if (neighbour && x + rightSide > neighbourEdge) {
- show = false;
- }
- }
-
- } else {
- // Is the label spilling out to the right of the plot area?
- if (x + rightSide > plotRight) {
-
- // Align it to plot right
- x = plotRight - rightSide;
-
- // Hide it if it now overlaps the neighbour label
- if (neighbour && x + leftSide < neighbourEdge) {
- show = false;
- }
-
- }
- }
-
- // Set the modified x position of the label
- xy.x = x;
- }
- return show;
- },
-
- /**
- * 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,
- baseline = axis.chart.renderer.fontMetrics(labelOptions.style.fontSize).b,
- rotation = labelOptions.rotation;
-
- x = x + labelOptions.x - (tickmarkOffset && horiz ?
- tickmarkOffset * transA * (reversed ? -1 : 1) : 0);
- y = y + labelOptions.y - (tickmarkOffset && !horiz ?
- tickmarkOffset * transA * (reversed ? 1 : -1) : 0);
-
- // Correct for rotation (#1764)
- if (rotation && axis.side === 2) {
- y -= baseline - baseline * mathCos(rotation * deg2rad);
- }
-
- // Vertically centered
- if (!defined(labelOptions.y) && !rotation) { // #1951
- y += baseline - label.getBBox().height / 2;
- }
-
- // Correct for staggered labels
- if (staggerLines) {
- y += (index / (step || 1) % staggerLines) * (axis.labelOffset / staggerLines);
- }
-
- return {
- x: x,
- y: 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 = options[tickPrefix + 'Width'] || 0,
- tickColor = options[tickPrefix + 'Color'],
- tickPosition = options[tickPrefix + 'Position'],
- gridLinePath,
- mark = tick.mark,
- markPath,
- step = 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
- staggerLines = axis.staggerLines;
-
- 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 (!staggerLines && horiz && labelOptions.overflow === 'justify' && !tick.handleOverflow(index, xy)) {
- show = false;
- }
-
- // 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
- */
-function PlotLineOrBand(axis, options) {
- this.axis = axis;
-
- if (options) {
- this.options = options;
- this.id = options.id;
- }
-}
-
-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,
- halfPointRange = (axis.pointRange || 0) / 2,
- 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
-
- // keep within plot area
- from = mathMax(from, axis.min - halfPointRange);
- to = mathMin(to, axis.max + halfPointRange);
-
- path = axis.getPlotBandPath(from, to, options);
- 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();
- };
- }
- } 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) {
- plotLine.label = label = renderer.text(
- optionsLabel.text,
- 0,
- 0,
- optionsLabel.useHTML
- )
- .attr({
- align: optionsLabel.textAlign || optionsLabel.align,
- rotation: optionsLabel.rotation,
- zIndex: zIndex
- })
- .css(optionsLabel.style)
- .add();
- }
-
- // get the bounding box and align the label
- xs = [path[1], path[4], pick(path[6], path[1])];
- ys = [path[2], path[5], pick(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);
- }
-};
-/**
- * The class for stack items
- */
-function StackItem(axis, options, isNegative, x, stackOption, stacking) {
-
- 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
- this.points = {};
-
- // Save the stack option on the series configuration object, and whether to treat it as percent
- this.stack = stackOption;
- this.percent = stacking === 'percent';
-
- // 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, 0, 0, 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,
- neg = this.isNegative, // special treatment is needed for negative stacks
- y = axis.translate(this.percent ? 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.attr({
- visibility: this.options.crop === false || chart.isInsidePlot(alignAttr.x, alignAttr.y) ?
- (hasSVG ? 'inherit' : VISIBLE) :
- HIDDEN
- });
- }
- }
-};
-/**
- * Create a new axis object
- * @param {Object} chart
- * @param {Object} options
- */
-function Axis() {
- 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: '#C0C0C0',
- // gridLineDashStyle: 'solid',
- // gridLineWidth: 0,
- // reversed: false,
-
- labels: defaultLabelOptions,
- // { step: null },
- 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: 5,
- 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: '#4d759e',
- //font: defaultFont.replace('normal', 'bold')
- fontWeight: 'bold'
- }
- //x: 0,
- //y: 0
- },
- type: 'linear' // linear, logarithmic or datetime
- },
-
- /**
- * 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 numberFormat(this.total, -1);
- },
- style: defaultLabelOptions.style
- }
- },
-
- /**
- * These options extend the defaultOptions for left axes
- */
- defaultLeftAxisOptions: {
- labels: {
- x: -8,
- y: null
- },
- title: {
- rotation: 270
- }
- },
-
- /**
- * These options extend the defaultOptions for right axes
- */
- defaultRightAxisOptions: {
- labels: {
- x: 8,
- y: null
- },
- title: {
- rotation: 90
- }
- },
-
- /**
- * These options extend the defaultOptions for bottom axes
- */
- defaultBottomAxisOptions: {
- labels: {
- x: 0,
- y: 14
- // overflow: undefined,
- // staggerLines: null
- },
- title: {
- rotation: 0
- }
- },
- /**
- * These options extend the defaultOptions for left axes
- */
- defaultTopAxisOptions: {
- labels: {
- x: 0,
- y: -5
- // overflow: undefined
- // staggerLines: null
- },
- title: {
- rotation: 0
- }
- },
-
- /**
- * Initialize the axis
- */
- init: function (chart, userOptions) {
-
-
- var isXAxis = userOptions.isX,
- axis = this;
-
- // Flag, is the axis horizontal
- axis.horiz = chart.inverted ? !isXAxis : isXAxis;
-
- // Flag, isXAxis
- axis.isXAxis = isXAxis;
- axis.xOrY = isXAxis ? 'x' : 'y';
-
-
- axis.opposite = userOptions.opposite; // needed in setOptions
- axis.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.ignoreMinPadding = UNDEFINED; // can be set to true by a column or bar series
- //axis.ignoreMaxPadding = UNDEFINED;
-
- axis.chart = chart;
- axis.reversed = options.reversed;
- axis.zoomEnabled = options.zoomEnabled !== false;
-
- // Initial categories
- axis.categories = options.categories || type === 'category';
-
- // 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;
-
- axis.tickmarkOffset = (axis.categories && options.tickmarkPlacement === 'between') ? 0.5 : 0;
-
- // Major ticks
- axis.ticks = {};
- // Minor ticks
- axis.minorTicks = {};
- //axis.tickAmount = UNDEFINED;
-
- // 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 = {};
-
- // Dictionary for stacks max values
- axis.stackExtremes = {};
-
- // 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,
-
- // Run Axis
-
- var eventType,
- events = axis.options.events;
-
- // Register
- if (inArray(axis, chart.axes) === -1) { // don't add it again on Axis.update()
- chart.axes.push(axis);
- chart[isXAxis ? 'xAxis' : 'yAxis'].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.isXAxis ? 'xAxis' : 'yAxis'], // if set in setOptions (#1053)
- userOptions
- )
- );
- },
-
- /**
- * Update the axis with a new options structure
- */
- update: function (newOptions, redraw) {
- var chart = this.chart;
-
- newOptions = chart.options[this.xOrY + 'Axis'][this.options.index] = merge(this.userOptions, newOptions);
-
- this.destroy(true);
- this._addedPlotLB = this.userMin = this.userMax = UNDEFINED; // #1611, #2306
-
- 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.xOrY + 'Axis'; // xAxis or yAxis
-
- // Remove associated series
- each(this.series, function (series) {
- series.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();
- }
- },
-
- /**
- * 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 && numericSymbols[i] !== null) {
- ret = numberFormat(value / multi, -1) + numericSymbols[i];
- }
- }
- }
-
- if (ret === UNDEFINED) {
- if (value >= 1000) { // add thousands separators
- ret = numberFormat(value, 0);
-
- } else { // small numbers
- ret = numberFormat(value, -1);
- }
- }
-
- 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 dataMin and dataMax in case we're redrawing
- axis.dataMin = axis.dataMax = null;
-
- // reset cached stacking extremes
- axis.stackExtremes = {};
-
- 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)) {
- if (axis.dataMin >= threshold) {
- axis.dataMin = threshold;
- axis.ignoreMinPadding = true;
- } else if (axis.dataMax < threshold) {
- axis.dataMax = threshold;
- axis.ignoreMaxPadding = true;
- }
- }
- }
- }
- });
- },
-
- /**
- * Translate from axis value to pixel position on the chart, or back
- *
- */
- translate: function (val, backwards, cvsCoord, old, handleLog, pointPlacement) {
- var axis = this,
- axisLength = axis.len,
- sign = 1,
- cvsOffset = 0,
- localA = old ? axis.oldTransA : axis.transA,
- localMin = old ? axis.oldMin : axis.min,
- returnValue,
- minPixelPadding = axis.minPixelPadding,
- postTranslate = (axis.options.ordinal || (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 = axisLength;
- }
-
- // Handle reversed axis
- if (axis.reversed) {
- sign *= -1;
- cvsOffset -= sign * axisLength;
- }
-
- // From pixels to value
- if (backwards) { // reverse translation
-
- val = val * sign + cvsOffset;
- val -= minPixelPadding;
- returnValue = val / localA + localMin; // from chart pixel to value
- if (postTranslate) { // log and ordinal axes
- returnValue = axis.lin2val(returnValue);
- }
-
- // From value to pixels
- } else {
- if (postTranslate) { // 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) {
- var axis = this,
- chart = axis.chart,
- axisLeft = axis.left,
- axisTop = axis.top,
- x1,
- y1,
- x2,
- y2,
- translatedValue = axis.translate(value, null, null, old),
- cHeight = (old && chart.oldChartHeight) || chart.chartHeight,
- cWidth = (old && chart.oldChartWidth) || chart.chartWidth,
- skip,
- transB = axis.transB;
-
- 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;
- if (x1 < axisLeft || x1 > axisLeft + axis.width) {
- skip = true;
- }
- } else {
- x1 = axisLeft;
- x2 = cWidth - axis.right;
-
- if (y1 < axisTop || y1 > axisTop + axis.height) {
- skip = true;
- }
- }
- return skip && !force ?
- null :
- chart.renderer.crispLine([M, x1, y1, L, x2, y2], lineWidth || 0);
- },
-
- /**
- * Create the path for a plot band
- */
- getPlotBandPath: function (from, to) {
-
- var toPath = this.getPlotLinePath(to),
- path = this.getPlotLinePath(from);
-
- if (path && toPath) {
- path.push(
- toPath[4],
- toPath[5],
- toPath[1],
- toPath[2]
- );
- } else { // outside the axis area
- path = null;
- }
-
- return path;
- },
-
- /**
- * 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 = [];
-
- // 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;
- },
-
- /**
- * Set the tick positions of a logarithmic axis
- */
- 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)) { // #1670
- 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;
- },
-
- /**
- * 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,
- len;
-
- 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(
- getTimeTicks(
- normalizeTimeTickInterval(minorTickInterval),
- axis.min,
- axis.max,
- options.startOfWeek
- )
- );
- if (minorTickPositions[0] < axis.min) {
- minorTickPositions.shift();
- }
- } else {
- for (pos = axis.min + (tickPositions[0] - axis.min) % minorTickInterval; pos <= axis.max; pos += minorTickInterval) {
- minorTickPositions.push(pos);
- }
- }
- 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;
-
- // 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) {
- var 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 = 0,
- closestPointRange,
- minPointOffset = 0,
- pointRangePadding = 0,
- linkedParent = axis.linkedParent,
- ordinalCorrection,
- transA = axis.transA;
-
- // adjust translation for padding
- if (axis.isXAxis) {
- if (linkedParent) {
- minPointOffset = linkedParent.minPointOffset;
- pointRangePadding = linkedParent.pointRangePadding;
-
- } else {
- each(axis.series, function (series) {
- var seriesPointRange = series.pointRange,
- pointPlacement = series.options.pointPlacement,
- seriesClosestPointRange = series.closestPointRange;
-
- if (seriesPointRange > range) { // #1446
- seriesPointRange = 0;
- }
- pointRange = mathMax(pointRange, seriesPointRange);
-
- // 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
- 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;
- },
-
- /**
- * Set the tick positions to round values and optionally extend the extremes
- * to the nearest tick
- */
- setTickPositions: function (secondPass) {
- var axis = this,
- chart = axis.chart,
- options = axis.options,
- isLog = axis.isLog,
- isDatetimeAxis = axis.isDatetimeAxis,
- isXAxis = axis.isXAxis,
- isLinked = axis.isLinked,
- tickPositioner = axis.options.tickPositioner,
- maxPadding = options.maxPadding,
- minPadding = options.minPadding,
- length,
- linkedParentExtremes,
- tickIntervalOption = options.tickInterval,
- minTickIntervalOption = options.minTickInterval,
- tickPixelIntervalOption = options.tickPixelInterval,
- tickPositions,
- keepTwoTicksOnly,
- categories = axis.categories;
-
- // linked axis gets the extremes from the parent axis
- if (isLinked) {
- axis.linkedParent = chart[isXAxis ? 'xAxis' : 'yAxis'][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
- }
- } else { // initial min and max from the extreme data values
- axis.min = pick(axis.userMin, options.min, axis.dataMin);
- axis.max = pick(axis.userMax, options.max, 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
- }
- axis.min = correctFloat(log2lin(axis.min)); // correctFloat cures #934
- axis.max = correctFloat(log2lin(axis.max));
- }
-
- // handle zoomed range
- if (axis.range) {
- axis.userMin = axis.min = mathMax(axis.min, axis.max - axis.range); // #618
- axis.userMax = axis.max;
- if (secondPass) {
- 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.usePercentage && !isLinked && defined(axis.min) && defined(axis.max)) {
- length = axis.max - axis.min;
- if (length) {
- if (!defined(options.min) && !defined(axis.userMin) && minPadding && (axis.dataMin < 0 || !axis.ignoreMinPadding)) {
- axis.min -= length * minPadding;
- }
- if (!defined(options.max) && !defined(axis.userMax) && maxPadding && (axis.dataMax > 0 || !axis.ignoreMaxPadding)) {
- axis.max += length * maxPadding;
- }
- }
- }
-
- // 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 = axis.linkedParent.tickInterval;
- } else {
- axis.tickInterval = pick(
- tickIntervalOption,
- 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)
- );
- // For squished axes, set only two ticks
- if (!defined(tickIntervalOption) && axis.len < tickPixelIntervalOption && !this.isRadial) {
- keepTwoTicksOnly = true;
- axis.tickInterval /= 4; // tick extremes closer to the real values
- }
- }
-
- // 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.
- if (!tickIntervalOption && axis.tickInterval < minTickIntervalOption) {
- axis.tickInterval = minTickIntervalOption;
- }
-
- // for linear axes, get magnitude and normalize the interval
- if (!isDatetimeAxis && !isLog) { // linear
- if (!tickIntervalOption) {
- axis.tickInterval = normalizeTickInterval(axis.tickInterval, null, getMagnitude(axis.tickInterval), options);
- }
- }
-
- // get minorTickInterval
- axis.minorTickInterval = options.minorTickInterval === 'auto' && axis.tickInterval ?
- axis.tickInterval / 5 : options.minorTickInterval;
-
- // find the tick positions
- axis.tickPositions = tickPositions = options.tickPositions ?
- [].concat(options.tickPositions) : // Work on a copy (#1565)
- (tickPositioner && tickPositioner.apply(axis, [axis.min, axis.max]));
- if (!tickPositions) {
-
- // Too many ticks
- if (!axis.ordinalPositions && (axis.max - axis.min) / axis.tickInterval > mathMax(2 * axis.len, 200)) {
- error(19, true);
- }
-
- if (isDatetimeAxis) {
- tickPositions = (axis.getNonLinearTimeTicks || getTimeTicks)(
- normalizeTimeTickInterval(axis.tickInterval, options.units),
- axis.min,
- axis.max,
- options.startOfWeek,
- axis.ordinalPositions,
- axis.closestPointRange,
- true
- );
- } else if (isLog) {
- tickPositions = axis.getLogTickPositions(axis.tickInterval, axis.min, axis.max);
- } else {
- tickPositions = axis.getLinearTickPositions(axis.tickInterval, axis.min, axis.max);
- }
- if (keepTwoTicksOnly) {
- tickPositions.splice(1, tickPositions.length - 2);
- }
-
- axis.tickPositions = tickPositions;
- }
-
- if (!isLinked) {
-
- // reset min/max or remove extremes based on start/end on tick
- var roundedMin = tickPositions[0],
- roundedMax = tickPositions[tickPositions.length - 1],
- minPointOffset = axis.minPointOffset || 0,
- singlePad;
-
- if (options.startOnTick) {
- axis.min = roundedMin;
- } else if (axis.min - minPointOffset > roundedMin) {
- tickPositions.shift();
- }
-
- if (options.endOnTick) {
- axis.max = roundedMax;
- } else if (axis.max + minPointOffset < roundedMax) {
- tickPositions.pop();
- }
-
- // 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 1. In this case, add some padding
- // in order to center the point, but leave it with one tick. #1337.
- if (tickPositions.length === 1) {
- singlePad = 0.001; // The lowest possible number to avoid extra padding on columns
- axis.min -= singlePad;
- axis.max += singlePad;
- }
- }
- },
-
- /**
- * Set the max ticks of either the x and y axis collection
- */
- setMaxTicks: function () {
-
- var chart = this.chart,
- maxTicks = chart.maxTicks || {},
- tickPositions = this.tickPositions,
- key = this._maxTicksKey = [this.xOrY, this.pos, this.len].join('-');
-
- if (!this.isLinked && !this.isDatetimeAxis && tickPositions && tickPositions.length > (maxTicks[key] || 0) && this.options.alignTicks !== false) {
- maxTicks[key] = tickPositions.length;
- }
- chart.maxTicks = maxTicks;
- },
-
- /**
- * When using multiple axes, adjust the number of ticks to match the highest
- * number of ticks in that group
- */
- adjustTickAmount: function () {
- var axis = this,
- chart = axis.chart,
- key = axis._maxTicksKey,
- tickPositions = axis.tickPositions,
- maxTicks = chart.maxTicks;
-
- if (maxTicks && maxTicks[key] && !axis.isDatetimeAxis && !axis.categories && !axis.isLinked && axis.options.alignTicks !== false) { // only apply to linear scale
- var oldTickAmount = axis.tickAmount,
- calculatedTickAmount = tickPositions.length,
- tickAmount;
-
- // set the axis-level tickAmount to use below
- axis.tickAmount = tickAmount = maxTicks[key];
-
- if (calculatedTickAmount < tickAmount) {
- while (tickPositions.length < tickAmount) {
- tickPositions.push(correctFloat(
- tickPositions[tickPositions.length - 1] + axis.tickInterval
- ));
- }
- axis.transA *= (calculatedTickAmount - 1) / (tickAmount - 1);
- axis.max = tickPositions[tickPositions.length - 1];
-
- }
- if (defined(oldTickAmount) && tickAmount !== oldTickAmount) {
- axis.isDirty = true;
- }
- }
- },
-
- /**
- * Set the scale based on data min and max, user set min and max or options
- *
- */
- setScale: function () {
- var axis = this,
- stacks = axis.stacks,
- type,
- i,
- 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) {
-
- // reset stacks
- if (!axis.isXAxis) {
- for (type in stacks) {
- delete stacks[type];
- }
- }
-
- axis.forceRedraw = false;
-
- // get data extremes if needed
- axis.getSeriesExtremes();
-
- // get fixed positions based on tickInterval
- axis.setTickPositions();
-
- // 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.isXAxis) {
- if (axis.oldStacks) {
- stacks = axis.stacks = axis.oldStacks;
- }
-
- // reset stacks
- for (type in stacks) {
- for (i in stacks[type]) {
- stacks[type][i].cum = stacks[type][i].total;
- }
- }
- }
-
- // Set the maximum tick amount
- axis.setMaxTicks();
- },
-
- /**
- * 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
-
- // 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;
-
- // Mark for running afterSetExtremes
- axis.isDirtyExtremes = true;
-
- // redraw
- 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) {
-
- // Prevent pinch zooming out of range. Check for defined is for #1946.
- if (!this.allowZoomOutside) {
- if (defined(this.dataMin) && newMin <= this.dataMin) {
- newMin = UNDEFINED;
- }
- if (defined(this.dataMax) && newMax >= this.dataMax) {
- newMax = UNDEFINED;
- }
- }
-
- // 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,
- height,
- top,
- left;
-
- // Expose basic values to use in Series object and navigator
- this.left = left = pick(options.left, chart.plotLeft + offsetLeft);
- this.top = top = pick(options.top, chart.plotTop);
- this.width = width = pick(options.width, chart.plotWidth - offsetLeft + offsetRight);
- this.height = height = pick(options.height, chart.plotHeight);
- 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;
-
- var realMin = isLog ? lin2log(axis.min) : axis.min,
- realMax = isLog ? lin2log(axis.max) : axis.max;
-
- if (realMin > threshold || threshold === null) {
- threshold = realMin;
- } else if (realMax < threshold) {
- threshold = realMax;
- }
-
- return axis.translate(threshold, 0, 1, 0, 1);
- },
-
- addPlotBand: function (options) {
- this.addPlotBandOrLine(options, 'plotBands');
- },
-
- addPlotLine: function (options) {
- 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 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;
- },
-
- /**
- * 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;
- },
-
- /**
- * 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
- axisOffset = chart.axisOffset,
- clipOffset = chart.clipOffset,
- directionFactor = [-1, 1, 1, -1][side],
- n,
- i,
- autoStaggerLines = 1,
- maxStaggerLines = pick(labelOptions.maxStaggerLines, 5),
- sortedPositions,
- lastRight,
- overlap,
- pos,
- bBox,
- x,
- w,
- lineNo;
-
- // For reuse in Axis.render
- axis.hasData = hasData = (axis.hasVisibleSeries || (defined(axis.min) && defined(axis.max) && !!tickPositions));
- 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();
- axis.axisGroup = renderer.g('axis')
- .attr({ zIndex: options.zIndex || 2 })
- .add();
- axis.labelGroup = renderer.g('axis-labels')
- .attr({ zIndex: labelOptions.zIndex || 7 })
- .add();
- }
-
- if (hasData || axis.isLinked) {
-
- // Set the explicit or automatic label alignment
- axis.labelAlign = pick(labelOptions.align || axis.autoLabelAlign(labelOptions.rotation));
-
- each(tickPositions, function (pos) {
- if (!ticks[pos]) {
- ticks[pos] = new Tick(axis, pos);
- } else {
- ticks[pos].addLabel(); // update labels depending on tick interval
- }
- });
-
- // Handle automatic stagger lines
- if (axis.horiz && !axis.staggerLines && maxStaggerLines && !labelOptions.rotation) {
- sortedPositions = axis.reversed ? [].concat(tickPositions).reverse() : tickPositions;
- while (autoStaggerLines < maxStaggerLines) {
- lastRight = [];
- overlap = false;
-
- for (i = 0; i < sortedPositions.length; i++) {
- pos = sortedPositions[i];
- bBox = ticks[pos].label && ticks[pos].label.getBBox();
- w = bBox ? bBox.width : 0;
- lineNo = i % autoStaggerLines;
-
- if (w) {
- x = axis.translate(pos); // don't handle log
- if (lastRight[lineNo] !== UNDEFINED && x < lastRight[lineNo]) {
- overlap = true;
- }
- lastRight[lineNo] = x + w;
- }
- }
- if (overlap) {
- autoStaggerLines++;
- } else {
- break;
- }
- }
-
- if (autoStaggerLines > 1) {
- axis.staggerLines = autoStaggerLines;
- }
- }
-
-
- 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]
- })
- .css(axisTitleOptions.style)
- .add(axis.axisGroup);
- axis.axisTitle.isNew = true;
- }
-
- if (showAxis) {
- titleOffset = axis.axisTitle.getBBox()[horiz ? 'height' : 'width'];
- titleMargin = pick(axisTitleOptions.margin, horiz ? 5 : 10);
- titleOffsetOption = axisTitleOptions.offset;
- }
-
- // 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.axisTitleMargin =
- pick(titleOffsetOption,
- labelOffset + titleMargin +
- (side !== 2 && labelOffset && directionFactor * options.labels[horiz ? 'y' : 'x'])
- );
-
- axisOffset[side] = mathMax(
- axisOffset[side],
- axis.axisTitleMargin + titleOffset + directionFactor * axis.offset
- );
- clipOffset[invertedSide] = mathMax(clipOffset[invertedSide], mathFloor(options.lineWidth / 2) * 2);
- },
-
- /**
- * 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,
- 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 :
- offAxis + (opposite ? this.width : 0) + offset +
- (axisTitleOptions.x || 0), // x
- y: horiz ?
- offAxis - (opposite ? this.height : 0) + offset :
- alongAxis + (axisTitleOptions.y || 0) // y
- };
- },
-
- /**
- * 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,
- stacks = axis.stacks,
- 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),
- hasData = axis.hasData,
- showAxis = axis.showAxis,
- from,
- to;
-
- // 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 (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.slice(1).concat([tickPositions[0]]), function (pos, i) {
-
- // Reorganize the indices
- i = (i === tickPositions.length - 1) ? 0 : i + 1;
-
- // 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);
- }
-
- ticks[pos].render(i, false, 1);
- }
-
- });
- // 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) {
- 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) {
- if (i % 2 === 0 && pos < axis.max) {
- if (!alternateBands[pos]) {
- alternateBands[pos] = new PlotLineOrBand(axis);
- }
- from = pos + tickmarkOffset; // #949
- to = tickPositions[i + 1] !== UNDEFINED ? tickPositions[i + 1] + tickmarkOffset : axis.max;
- 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) {
- var 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);
- }
- }
- }
- // End stacked totals
-
- axis.isDirty = false;
- },
-
- /**
- * 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]);
- }
- }
- });
-
- },
-
- /**
- * Update the axis title by options
- */
- setTitle: function (newTitleOptions, redraw) {
- this.update({ title: newTitleOptions }, redraw);
- },
-
- /**
- * Redraw the axis to reflect changes in the data or axis extremes
- */
- redraw: function () {
- var axis = this,
- chart = axis.chart,
- pointer = chart.pointer;
-
- // hide tooltip and hover states
- if (pointer.reset) {
- pointer.reset(true);
- }
-
- // render the axis
- axis.render();
-
- // move plot lines and bands
- each(axis.plotLinesAndBands, function (plotLine) {
- plotLine.render();
- });
-
- // mark associated series as dirty and ready for redraw
- each(axis.series, function (series) {
- series.isDirty = true;
- });
-
- },
-
- /**
- * Build the stacks from top down
- */
- buildStacks: function () {
- var series = this.series,
- i = series.length;
- if (!this.isXAxis) {
- while (i--) {
- series[i].setStackedPoints();
- }
- // Loop up again to compute percent stack
- if (this.usePercentage) {
- for (i = 0; i < series.length; i++) {
- series[i].setPercentStacks();
- }
- }
- }
- },
-
- /**
- * Set new axis categories and optionally redraw
- * @param {Array} categories
- * @param {Boolean} redraw
- */
- setCategories: function (categories, redraw) {
- this.update({ categories: categories }, redraw);
- },
-
- /**
- * 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', 'axisGroup', 'gridGroup', 'labelGroup', 'axisTitle'], function (prop) {
- if (axis[prop]) {
- axis[prop] = axis[prop].destroy();
- }
- });
- }
-
-
-}; // end Axis
-
-/**
- * The tooltip object
- * @param {Object} chart The chart instance
- * @param {Object} options Tooltip options
- */
-function Tooltip() {
- 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, 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: -999 }); // #2301
-
- // 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 () {
- each(this.crosshairs, function (crosshair) {
- if (crosshair) {
- crosshair.destroy();
- }
- });
-
- // 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;
-
- // get intermediate values for animation
- extend(now, {
- x: animate ? (2 * now.x + x) / 3 : x,
- y: animate ? (now.y + y) / 2 : y,
- anchorX: animate ? (2 * now.anchorX + anchorX) / 3 : anchorX,
- anchorY: 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 && (mathAbs(x - now.x) > 1 || mathAbs(y - now.y) > 1)) {
-
- // 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 () {
- 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(this.options.hideDelay, 500));
-
- // hide previous hoverPoints and set new
- if (hoverPoints) {
- each(hoverPoints, function (point) {
- point.setState();
- });
- }
-
- this.chart.hoverPoints = null;
- }
- },
-
- /**
- * Hide the crosshairs
- */
- hideCrosshairs: function () {
- each(this.crosshairs, function (crosshair) {
- if (crosshair) {
- crosshair.hide();
- }
- });
- },
-
- /**
- * 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,
- plotX = 0,
- plotY = 0,
- yAxis;
-
- 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;
- plotX += point.plotX;
- 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) {
-
- // Set up the variables
- var chart = this.chart,
- plotLeft = chart.plotLeft,
- plotTop = chart.plotTop,
- plotWidth = chart.plotWidth,
- plotHeight = chart.plotHeight,
- distance = pick(this.options.distance, 12),
- pointX = point.plotX,
- pointY = point.plotY,
- x = pointX + plotLeft + (chart.inverted ? distance : -boxWidth - distance),
- y = pointY - boxHeight + plotTop + 15, // 15 means the point is 15 pixels up from the bottom of the tooltip
- alignedRight;
-
- // It is too far to the left, adjust it
- if (x < 7) {
- x = plotLeft + mathMax(pointX, 0) + distance;
- }
-
- // Test to see if the tooltip is too far to the right,
- // if it is, move it back to be inside and then up to not cover the point.
- if ((x + boxWidth) > (plotLeft + plotWidth)) {
- x -= (x + boxWidth) - (plotLeft + plotWidth);
- y = pointY - boxHeight + plotTop - distance;
- alignedRight = true;
- }
-
- // If it is now above the plot area, align it to the top of the plot area
- if (y < plotTop + 5) {
- y = plotTop + 5;
-
- // If the tooltip is still covering the point, move it below instead
- if (alignedRight && pointY >= y && pointY <= (y + boxHeight)) {
- y = pointY + plotTop + distance; // below
- }
- }
-
- // Now if the tooltip is below the chart, move it up. It's better to cover the
- // point than to disappear outside the chart. #834.
- if (y + boxHeight > plotTop + plotHeight) {
- y = mathMax(plotTop, plotTop + plotHeight - boxHeight - distance); // below
- }
-
- return {x: x, y: y};
- },
-
- /**
- * 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),
- series = items[0].series,
- s;
-
- // build the header
- s = [series.tooltipHeaderFormatter(items[0])];
-
- // build the values
- each(items, function (item) {
- series = item.series;
- s.push((series.tooltipFormatter && series.tooltipFormatter(item)) ||
- item.point.tooltipFormatter(series.tooltipOptions.pointFormat));
- });
-
- // footer
- s.push(tooltip.options.footerFormat || '');
-
- 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,
- crosshairsOptions = options.crosshairs,
- 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;
- point = point[0];
-
- // single point tooltip
- } else {
- textConfig = point.getLabelConfig();
- }
- text = formatter.call(textConfig, tooltip);
-
- // register the current series
- currentSeries = point.series;
-
- // 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 });
-
- this.isHidden = false;
- }
-
- // crosshairs
- if (crosshairsOptions) {
- crosshairsOptions = splat(crosshairsOptions); // [x, y]
-
- var path,
- i = crosshairsOptions.length,
- attribs,
- axis,
- val,
- series;
-
- while (i--) {
- series = point.series;
- axis = series[i ? 'yAxis' : 'xAxis'];
- if (crosshairsOptions[i] && axis) {
- val = i ? pick(point.stackY, point.y) : point.x; // #814
- if (axis.isLog) { // #1671
- val = log2lin(val);
- }
- if (i === 1 && series.modifyValue) { // #1205, #2316
- val = series.modifyValue(val);
- }
-
- path = axis.getPlotLinePath(
- val,
- 1
- );
-
- if (tooltip.crosshairs[i]) {
- tooltip.crosshairs[i].attr({ d: path, visibility: VISIBLE });
- } else {
- attribs = {
- 'stroke-width': crosshairsOptions[i].width || 1,
- stroke: crosshairsOptions[i].color || '#C0C0C0',
- zIndex: crosshairsOptions[i].zIndex || 2
- };
- if (crosshairsOptions[i].dashStyle) {
- attribs.dashstyle = crosshairsOptions[i].dashStyle;
- }
- tooltip.crosshairs[i] = chart.renderer.path(path)
- .attr(attribs)
- .add();
- }
- }
- }
- }
- 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),
- point.plotX + chart.plotLeft,
- point.plotY + chart.plotTop
- );
- }
-};
-/**
- * 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
- */
-function Pointer(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);
-
- // Do we need to handle click on a touch device?
- this.runChartClick = chartEvents && !!chartEvents.click;
-
- this.pinchDown = [];
- this.lastValidTouch = {};
-
- if (options.tooltip.enabled) {
- chart.tooltip = new Tooltip(chart, options.tooltip);
- }
-
- 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 || win.event;
- if (!e.target) {
- e.target = e.srcElement;
- }
-
- // Framework specific normalizing (#1165)
- e = washMouseEvent(e);
-
- // iOS
- ePos = e.touches ? e.touches.item(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;
- },
-
- /**
- * Return the index in the tooltipPoints array, corresponding to pixel position in
- * the plot area.
- */
- getIndex: function (e) {
- var chart = this.chart;
- return chart.inverted ?
- chart.plotHeight + chart.plotTop - e.chartY :
- e.chartX - chart.plotLeft;
- },
-
- /**
- * 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,
- point,
- points,
- hoverPoint = chart.hoverPoint,
- hoverSeries = chart.hoverSeries,
- i,
- j,
- distance = chart.chartWidth,
- index = pointer.getIndex(e),
- anchor;
-
- // shared tooltip
- if (tooltip && pointer.options.tooltip.shared && !(hoverSeries && hoverSeries.noSharedTooltip)) {
- points = [];
-
- // loop over all series and find the ones with points closest to the mouse
- i = series.length;
- for (j = 0; j < i; j++) {
- if (series[j].visible &&
- series[j].options.enableMouseTracking !== false &&
- !series[j].noSharedTooltip && series[j].tooltipPoints.length) {
- point = series[j].tooltipPoints[index];
- if (point && point.series) { // not a dummy point, #1544
- point._dist = mathAbs(index - point.clientX);
- distance = mathMin(distance, point._dist);
- points.push(point);
- }
- }
- }
- // remove furthest points
- i = points.length;
- while (i--) {
- if (points[i]._dist > distance) {
- points.splice(i, 1);
- }
- }
- // refresh the tooltip if necessary
- if (points.length && (points[0].clientX !== pointer.hoverX)) {
- tooltip.refresh(points, e);
- pointer.hoverX = points[0].clientX;
- }
- }
-
- // separate tooltip and general mouse events
- if (hoverSeries && hoverSeries.tracker) { // only use for line-type series with common tracker
-
- // get the point
- point = hoverSeries.tooltipPoints[index];
-
- // a new point is hovered, refresh the tooltip
- if (point && point !== hoverPoint) {
-
- // trigger the events
- point.onMouseOver(e);
-
- }
-
- } else if (tooltip && tooltip.followPointer && !tooltip.isHidden) {
- anchor = tooltip.getAnchor([{}], e);
- tooltip.updatePosition({ plotX: anchor[0], plotY: anchor[1] });
- }
- },
-
-
-
- /**
- * 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) {
- var pointer = this,
- chart = pointer.chart,
- hoverSeries = chart.hoverSeries,
- hoverPoint = chart.hoverPoint,
- tooltip = chart.tooltip,
- tooltipPoints = tooltip && tooltip.shared ? chart.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);
-
- // Full reset
- } else {
-
- if (hoverPoint) {
- hoverPoint.onMouseOut();
- }
-
- if (hoverSeries) {
- hoverSeries.onMouseOut();
- }
-
- if (tooltip) {
- tooltip.hide();
- tooltip.hideCrosshairs();
- }
-
- pointer.hoverX = 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);
- },
-
- /**
- * Run translation operations for each direction (horizontal and vertical) independently
- */
- pinchTranslateDirection: function (horiz, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch) {
- 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 = 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 = 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,
- followTouchMove = chart.tooltip && chart.tooltip.options.followTouchMove,
- touches = e.touches,
- touchesLength = touches.length,
- lastValidTouch = self.lastValidTouch,
- zoomHor = self.zoomHor || self.pinchHor,
- zoomVert = self.zoomVert || self.pinchVert,
- hasZoom = zoomHor || zoomVert,
- selectionMarker = self.selectionMarker,
- transform = {},
- fireClickEvent = touchesLength === 1 && ((self.inClass(e.target, PREFIX + 'tracker') &&
- chart.runTrackerClick) || chart.runChartClick),
- clip = {};
-
- // On touch devices, only proceed to trigger click if a handler is defined
- if ((hasZoom || followTouchMove) && !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(axis.dataMin),
- max = axis.toPixels(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);
- }
- });
-
- // 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
- }, chart.plotBox);
- }
-
-
-
- if (zoomHor) {
- self.pinchTranslateDirection(true, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch);
- }
- if (zoomVert) {
- self.pinchTranslateDirection(false, 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 && followTouchMove && touchesLength === 1) {
- this.runPointActions(self.normalize(e));
- }
- }
- },
-
- /**
- * 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,
- mouseDownX = this.mouseDownX,
- mouseDownY = this.mouseDownY;
-
- // 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) {
- if (!this.selectionMarker) {
- this.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 (this.selectionMarker && zoomHor) {
- size = chartX - mouseDownX;
- this.selectionMarker.attr({
- width: mathAbs(size),
- x: (size > 0 ? 0 : size) + mouseDownX
- });
- }
- // adjust the height of the selection marker
- if (this.selectionMarker && zoomVert) {
- size = chartY - mouseDownY;
- this.selectionMarker.attr({
- height: mathAbs(size),
- y: (size > 0 ? 0 : size) + mouseDownY
- });
- }
-
- // panning
- if (clickedInside && !this.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 chart = this.chart,
- hasPinched = this.hasPinched;
-
- if (this.selectionMarker) {
- var selectionData = {
- xAxis: [],
- yAxis: [],
- originalEvent: e.originalEvent || e
- },
- selectionBox = this.selectionMarker,
- selectionLeft = selectionBox.x,
- selectionTop = selectionBox.y,
- runZoom;
- // a selection has been made
- if (this.hasDragged || hasPinched) {
-
- // record each axis' min and max
- each(chart.axes, function (axis) {
- if (axis.zoomEnabled) {
- var horiz = axis.horiz,
- selectionMin = axis.toValue((horiz ? selectionLeft : selectionTop)),
- selectionMax = axis.toValue((horiz ? selectionLeft + selectionBox.width : selectionTop + selectionBox.height));
-
- if (!isNaN(selectionMin) && !isNaN(selectionMax)) { // #859
- selectionData[axis.xOrY + 'Axis'].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) {
- this.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,
- hoverSeries = chart.hoverSeries;
-
- e = this.normalize(e, chartPosition);
-
- // If we're outside, hide the tooltip
- if (chartPosition && hoverSeries && !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 () {
- this.reset();
- this.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;
-
- // normalize
- e = this.normalize(e);
-
- // #295
- e.returnValue = false;
-
-
- 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;
- if (series && !series.options.stickyTracking && !this.inClass(e.toElement || e.relatedTarget, PREFIX + 'tooltip')) {
- series.onMouseOut();
- }
- },
-
- onContainerClick: function (e) {
- var chart = this.chart,
- hoverPoint = chart.hoverPoint,
- plotLeft = chart.plotLeft,
- plotTop = chart.plotTop,
- inverted = chart.inverted,
- chartPosition,
- plotX,
- plotY;
-
- e = this.normalize(e);
- e.cancelBubble = true; // IE specific
-
- if (!chart.cancelClick) {
-
- // On tracker click, fire the series and point events. #783, #1583
- if (hoverPoint && this.inClass(e.target, PREFIX + 'tracker')) {
- chartPosition = this.chartPosition;
- plotX = hoverPoint.plotX;
- plotY = hoverPoint.plotY;
-
- // add page position info
- extend(hoverPoint, {
- pageX: chartPosition.left + plotLeft +
- (inverted ? chart.plotWidth - plotY : plotX),
- pageY: chartPosition.top + plotTop +
- (inverted ? chart.plotHeight - plotX : plotY)
- });
-
- // 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);
- }
- }
-
-
- }
- },
-
- onContainerTouchStart: function (e) {
- var chart = this.chart;
-
- if (e.touches.length === 1) {
-
- e = this.normalize(e);
-
- if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
-
- // Prevent the click pseudo event from firing unless it is set in the options
- /*if (!chart.runChartClick) {
- e.preventDefault();
- }*/
-
- // Run mouse events and display tooltip etc
- this.runPointActions(e);
-
- this.pinch(e);
-
- } else {
- // Hide the tooltip on touching outside the plot area (#1203)
- this.reset();
- }
-
- } else if (e.touches.length === 2) {
- this.pinch(e);
- }
- },
-
- onContainerTouchMove: function (e) {
- if (e.touches.length === 1 || e.touches.length === 2) {
- this.pinch(e);
- }
- },
-
- onDocumentTouchEnd: function (e) {
- this.drop(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,
- events;
-
- this._events = events = [
- [container, 'onmousedown', 'onContainerMouseDown'],
- [container, 'onmousemove', 'onContainerMouseMove'],
- [container, 'onclick', 'onContainerClick'],
- [container, 'mouseleave', 'onContainerMouseLeave'],
- [doc, 'mousemove', 'onDocumentMouseMove'],
- [doc, 'mouseup', 'onDocumentMouseUp']
- ];
-
- if (hasTouch) {
- events.push(
- [container, 'ontouchstart', 'onContainerTouchStart'],
- [container, 'ontouchmove', 'onContainerTouchMove'],
- [doc, 'touchend', 'onDocumentTouchEnd']
- );
- }
-
- each(events, function (eventConfig) {
-
- // First, create the callback function that in turn calls the method on Pointer
- pointer['_' + eventConfig[2]] = function (e) {
- pointer[eventConfig[2]](e);
- };
-
- // Now attach the function, either as a direct property or through addEvent
- if (eventConfig[1].indexOf('on') === 0) {
- eventConfig[0][eventConfig[1]] = pointer['_' + eventConfig[2]];
- } else {
- addEvent(eventConfig[0], eventConfig[1], pointer['_' + eventConfig[2]]);
- }
- });
-
-
- },
-
- /**
- * Destroys the Pointer object and disconnects DOM events.
- */
- destroy: function () {
- var pointer = this;
-
- // Release all DOM events
- each(pointer._events, function (eventConfig) {
- if (eventConfig[1].indexOf('on') === 0) {
- eventConfig[0][eventConfig[1]] = null; // delete breaks oldIE
- } else {
- removeEvent(eventConfig[0], eventConfig[1], pointer['_' + eventConfig[2]]);
- }
- });
- delete pointer._events;
-
- // memory and CPU leak
- clearInterval(pointer.tooltipTimeout);
- }
-};
-/**
- * The overview of the chart's series
- */
-function Legend(chart, options) {
- this.init(chart, options);
-}
-
-Legend.prototype = {
-
- /**
- * Initialize the legend
- */
- init: function (chart, options) {
-
- var legend = this,
- itemStyle = options.itemStyle,
- padding = pick(options.padding, 8),
- itemMarginTop = options.itemMarginTop || 0;
-
- this.options = options;
-
- if (!options.enabled) {
- return;
- }
-
- legend.baseline = pInt(itemStyle.fontSize) + 3 + itemMarginTop; // used in Series prototype
- legend.itemStyle = itemStyle;
- legend.itemHiddenStyle = merge(itemStyle, options.itemHiddenStyle);
- legend.itemMarginTop = itemMarginTop;
- legend.padding = padding;
- 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.lastLineHeight = 0;
-
- // 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.color : hiddenColor,
- markerOptions = item.options && item.options.marker,
- symbolAttr = {
- stroke: symbolColor,
- 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
- 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;
-
- if (item.legendGroup) {
- item.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.legendItemWidth + 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;
- },
-
- /**
- * 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 = options.symbolWidth,
- symbolPadding = options.symbolPadding,
- itemStyle = legend.itemStyle,
- itemHiddenStyle = legend.itemHiddenStyle,
- padding = legend.padding,
- itemDistance = horizontal ? pick(options.itemDistance, 8) : 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,
- itemOptions = series.options,
- showCheckbox = itemOptions.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);
-
- // Draw the legend symbol inside the group box
- series.drawLegendSymbol(legend, item);
-
- // Generate the list item text and add it to the group
- item.legendItem = li = renderer.text(
- options.labelFormat ? format(options.labelFormat, item) : options.labelFormatter.call(item),
- ltr ? symbolWidth + symbolPadding : -symbolPadding,
- legend.baseline,
- useHTML
- )
- .css(merge(item.visible ? itemStyle : itemHiddenStyle)) // merge to prevent modifying original (#1021)
- .attr({
- align: ltr ? 'left' : 'right',
- zIndex: 2
- })
- .add(item.legendGroup);
-
- // Set the events on the item group, or in case of useHTML, the item itself (#1249)
- (useHTML ? li : item.legendGroup).on('mouseover', function () {
- item.setState(HOVER_STATE);
- li.css(legend.options.itemHoverStyle);
- })
- .on('mouseout', function () {
- li.css(item.visible ? itemStyle : itemHiddenStyle);
- item.setState();
- })
- .on('click', function (event) {
- var strLegendItemClick = 'legendItemClick',
- fnLegendItemClick = function () {
- 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);
- }
- });
-
- // Colorize the items
- legend.colorizeItem(item, item.visible);
-
- // add the HTML checkbox on top
- if (itemOptions && showCheckbox) {
- item.checkbox = createElement('input', {
- type: 'checkbox',
- checked: item.selected,
- defaultChecked: item.selected // required by IE7
- }, options.itemCheckboxStyle, chart.container);
-
- addEvent(item.checkbox, 'click', function (event) {
- var target = event.target;
- fireEvent(item, 'checkboxClick', {
- checked: target.checked
- },
- function () {
- item.select();
- }
- );
- });
- }
- }
-
- // calculate the positions for the next line
- bBox = li.getBBox();
-
- itemWidth = item.legendItemWidth =
- options.itemWidth || symbolWidth + symbolPadding + bBox.width + itemDistance +
- (showCheckbox ? 20 : 0);
- legend.itemHeight = itemHeight = bBox.height;
-
- // if the item exceeds the width, start a new line
- if (horizontal && legend.itemX - initialItemX + itemWidth >
- (widthOption || (chart.chartWidth - 2 * padding - initialItemX))) {
- legend.itemX = initialItemX;
- legend.itemY += itemMarginTop + legend.lastLineHeight + itemMarginBottom;
- legend.lastLineHeight = 0; // reset for next line
- }
-
- // 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
- );
- },
-
- /**
- * 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 = [];
- each(chart.series, function (serie) {
- var seriesOptions = serie.options;
-
- if (!seriesOptions.showInLegend || defined(seriesOptions.linkedTo)) {
- return;
- }
-
- // use points or series for the legend item depending on legendType
- allItems = allItems.concat(
- serie.legendItems ||
- (seriesOptions.legendType === 'point' ?
- serie.data :
- serie)
- );
- });
-
- // 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
- each(allItems, function (item) {
- legend.renderItem(item);
- });
-
- // Draw the border
- legendWidth = options.width || legend.offsetWidth;
- legendHeight = legend.lastItemY + legend.lastLineHeight + legend.titleHeight;
-
-
- legendHeight = legend.handleOverflow(legendHeight);
-
- if (legendBorderWidth || legendBackgroundColor) {
- legendWidth += padding;
- legendHeight += padding;
-
- 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(null, null, null, legendWidth, 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,
- pageCount,
- 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;
-
- // Adjust the height
- if (options.layout === 'horizontal') {
- spaceHeight /= 2;
- }
- if (maxHeight) {
- spaceHeight = mathMin(spaceHeight, maxHeight);
- }
-
- // Reset the legend height and adjust the clipping rectangle
- if (legendHeight > spaceHeight && !options.useHTML) {
-
- this.clipHeight = clipHeight = spaceHeight - 20 - this.titleHeight;
- this.pageCount = pageCount = mathCeil(legendHeight / clipHeight);
- this.currentPage = pick(this.currentPage, 1);
- this.fullHeight = legendHeight;
-
- // Only apply clipping if needed. Clipping causes blurred legend in PDF export (#1787)
- if (!clipRect) {
- clipRect = legend.clipRect = renderer.clipRect(0, 0, 9999, 0);
- legend.contentGroup.clip(clipRect);
- }
- clipRect.attr({
- height: 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) {
- clipRect.attr({
- height: 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 pageCount = this.pageCount,
- 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 + 7 + this.titleHeight,
- visibility: VISIBLE
- });
- this.up.attr({
- fill: currentPage === 1 ? inactiveColor : activeColor
- })
- .css({
- cursor: currentPage === 1 ? 'default' : 'pointer'
- });
- pager.attr({
- text: currentPage + '/' + this.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 = -mathMin(clipHeight * (currentPage - 1), this.fullHeight - clipHeight + padding) + 1;
- this.scrollGroup.animate({
- translateY: scrollOffset
- });
- pager.attr({
- text: currentPage + '/' + pageCount
- });
-
-
- this.currentPage = currentPage;
- this.positionCheckboxes(scrollOffset);
- }
-
- }
-
-};
-
-// Workaround for #2030, horizontal legend items not displaying in IE11 Preview.
-// TODO: When IE11 is released, check again for this bug, and remove the fix
-// or make a better one.
-if (/Trident.*?11\.0/.test(userAgent)) {
- wrap(Legend.prototype, 'positionItem', function (proceed, item) {
- var legend = this;
- setTimeout(function () {
- proceed.call(legend, item);
- });
- });
-}
-
-/**
- * The chart class
- * @param {Object} options
- * @param {Function} callback Function to run when the chart has loaded
- */
-function Chart() {
- this.init.apply(this, arguments);
-}
-
-Chart.prototype = {
-
- /**
- * 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
-
- 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);
-
- // 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 = 0;
- chart.counters = new ChartCounters();
-
- 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;
- },
-
- /**
- * 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);
- }
- },
-
- /**
- * 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;
- },
-
- /**
- * Adjust all axes tick amounts
- */
- adjustTickAmounts: function () {
- if (this.options.chart.alignTicks !== false) {
- each(this.axes, function (axis) {
- axis.adjustTickAmount();
- });
- }
- this.maxTicks = null;
- },
-
- /**
- * 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,
- 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) { // prepare the data so axis can read it
- if (serie.options.legendType === 'point') {
- 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 (chart.hasCartesianSeries) {
- if (!chart.isResizing) {
-
- // reset maxTicks
- chart.maxTicks = null;
-
- // set axes scales
- each(axes, function (axis) {
- axis.setScale();
- });
- }
-
- chart.adjustTickAmounts();
- chart.getMargins();
-
- // 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
- if (axis.isDirtyExtremes) { // #821
- axis.isDirtyExtremes = false;
- 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) {
- 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();
- });
- },
-
-
-
- /**
- * 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;
-
- var loadingOptions = options.loading;
-
- // 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
- );
-
- }
-
- // update text
- chart.loadingSpan.innerHTML = str || options.lang.loading;
-
- // show it
- if (!chart.loadingShown) {
- css(loadingDiv, {
- opacity: 0,
- display: '',
- left: chart.plotLeft + PX,
- top: chart.plotTop + PX,
- width: chart.plotWidth + PX,
- height: chart.plotHeight + PX
- });
- animate(loadingDiv, {
- opacity: loadingOptions.style.opacity
- }, {
- duration: loadingOptions.showDuration || 0
- });
- chart.loadingShown = true;
- }
- },
-
- /**
- * 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;
- },
-
- /**
- * 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);
- });
-
- chart.adjustTickAmounts();
- },
-
-
- /**
- * 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;
- });
- },
-
- /**
- * Generate stacks for each series and calculate stacks total values
- */
- 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, '');
- }
- });
- },
-
- /**
- * 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;
-
- if (axis.series.length && newMin > mathMin(extremes.dataMin, extremes.min) && 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' });
- },
-
- /**
- * Show the title and subtitle of the chart
- *
- * @param titleOptions {Object} New title options
- * @param subtitleOptions {Object} New subtitle options
- *
- */
- setTitle: function (titleOptions, subtitleOptions) {
- 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();
- },
-
- /**
- * Lay out the chart titles and cache the full offset height for use in getMargins
- */
- layOutTitles: function () {
- var titleOffset = 0,
- title = this.title,
- subtitle = this.subtitle,
- options = this.options,
- titleOptions = options.title,
- subtitleOptions = options.subtitle,
- autoWidth = this.spacingBox.width - 44; // 44 makes room for default context button
-
- if (title) {
- title
- .css({ width: (titleOptions.width || autoWidth) + PX })
- .align(extend({ y: 15 }, titleOptions), false, 'spacingBox');
-
- if (!titleOptions.floating && !titleOptions.verticalAlign) {
- titleOffset = title.getBBox().height;
-
- // Adjust for browser consistency + backwards compat after #776 fix
- if (titleOffset >= 18 && titleOffset <= 25) {
- titleOffset = 15;
- }
- }
- }
- if (subtitle) {
- subtitle
- .css({ width: (subtitleOptions.width || autoWidth) + PX })
- .align(extend({ y: titleOffset + titleOptions.margin }, subtitleOptions), false, 'spacingBox');
-
- if (!subtitleOptions.floating && !subtitleOptions.verticalAlign) {
- titleOffset = mathCeil(titleOffset + subtitle.getBBox().height);
- }
- }
-
- this.titleOffset = titleOffset; // used in getMargins
- },
-
- /**
- * Get chart width and height according to options and container size
- */
- getChartSize: function () {
- var chart = this,
- optionsChart = chart.options.chart,
- renderTo = chart.renderToClone || chart.renderTo;
-
- // get inner width and height from jQuery (#824)
- chart.containerWidth = adapterRun(renderTo, 'width');
- chart.containerHeight = adapterRun(renderTo, 'height');
-
- chart.chartWidth = mathMax(0, optionsChart.width || chart.containerWidth || 600); // #1393, 1460
- chart.chartHeight = mathMax(0, pick(optionsChart.height,
- // 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
- });
- 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,
- optionsChart = chart.options.chart,
- chartWidth,
- chartHeight,
- renderTo,
- indexAttrName = 'data-highcharts-chart',
- oldChartIndex,
- 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
- oldChartIndex = pInt(attr(renderTo, indexAttrName));
- if (!isNaN(oldChartIndex) && charts[oldChartIndex]) {
- 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
- if (!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;
-
- chart.renderer =
- optionsChart.forExport ? // force SVG, used for SVG export
- new SVGRenderer(container, chartWidth, chartHeight, true) :
- new Renderer(container, chartWidth, chartHeight);
-
- 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);
- }
- },
-
- /**
- * 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 () {
- var chart = this,
- spacing = chart.spacing,
- axisOffset,
- legend = chart.legend,
- margin = chart.margin,
- legendOptions = chart.options.legend,
- legendMargin = pick(legendOptions.margin, 10),
- legendX = legendOptions.x,
- legendY = legendOptions.y,
- align = legendOptions.align,
- verticalAlign = legendOptions.verticalAlign,
- titleOffset = chart.titleOffset;
-
- chart.resetMargins();
- axisOffset = chart.axisOffset;
-
- // 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
- if (legend.display && !legendOptions.floating) {
- if (align === 'right') { // horizontal alignment handled first
- if (!defined(margin[1])) {
- chart.marginRight = mathMax(
- chart.marginRight,
- legend.legendWidth - legendX + legendMargin + spacing[1]
- );
- }
- } else if (align === 'left') {
- if (!defined(margin[3])) {
- chart.plotLeft = mathMax(
- chart.plotLeft,
- legend.legendWidth + legendX + legendMargin + spacing[3]
- );
- }
-
- } else if (verticalAlign === 'top') {
- if (!defined(margin[0])) {
- chart.plotTop = mathMax(
- chart.plotTop,
- legend.legendHeight + legendY + legendMargin + spacing[0]
- );
- }
-
- } else if (verticalAlign === 'bottom') {
- if (!defined(margin[2])) {
- chart.marginBottom = mathMax(
- chart.marginBottom,
- legend.legendHeight - legendY + legendMargin + spacing[2]
- );
- }
- }
- }
-
- // adjust for scroller
- if (chart.extraBottomMargin) {
- chart.marginBottom += chart.extraBottomMargin;
- }
- if (chart.extraTopMargin) {
- chart.plotTop += chart.extraTopMargin;
- }
-
- // pre-render axes to get labels offset width
- if (chart.hasCartesianSeries) {
- each(chart.axes, function (axis) {
- axis.getOffset();
- });
- }
-
- if (!defined(margin[3])) {
- chart.plotLeft += axisOffset[3];
- }
- if (!defined(margin[0])) {
- chart.plotTop += axisOffset[0];
- }
- if (!defined(margin[2])) {
- chart.marginBottom += axisOffset[2];
- }
- if (!defined(margin[1])) {
- chart.marginRight += axisOffset[1];
- }
-
- chart.setChartSize();
-
- },
-
- /**
- * Add the event handlers necessary for auto resizing
- *
- */
- initReflow: function () {
- var chart = this,
- optionsChart = chart.options.chart,
- renderTo = chart.renderTo,
- reflowTimeout;
-
- function reflow(e) {
- var width = optionsChart.width || adapterRun(renderTo, 'width'),
- height = optionsChart.height || adapterRun(renderTo, 'height'),
- target = e ? e.target : win; // #805 - MooTools doesn't supply e
-
- // Width and height checks for display:none. Target is doc in IE8 and Opera,
- // win in Firefox, Chrome and IE9.
- if (!chart.hasUserSize && width && height && (target === win || target === doc)) {
-
- if (width !== chart.containerWidth || height !== chart.containerHeight) {
- clearTimeout(reflowTimeout);
- chart.reflowTimeout = reflowTimeout = setTimeout(function () {
- if (chart.container) { // It may have been destroyed in the meantime (#1257)
- chart.setSize(width, height, false);
- chart.hasUserSize = null;
- }
- }, 100);
- }
- chart.containerWidth = width;
- chart.containerHeight = height;
- }
- }
- chart.reflow = reflow;
- 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;
-
- // 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));
- }
-
- css(chart.container, {
- width: chartWidth + PX,
- height: chartHeight + PX
- });
- chart.setChartSize(true);
- chart.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.getMargins();
-
- chart.redraw(animation);
-
-
- chart.oldChartHeight = null;
- fireEvent(chart, 'resize');
-
- // fire endResize and set isResizing back
- // If animation is disabled, fire without delay
- 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: 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,
- spacing = chart.spacing,
- margin = chart.margin;
-
- chart.plotTop = pick(margin[0], spacing[0]);
- chart.marginRight = pick(margin[1], spacing[1]);
- chart.marginBottom = pick(margin[2], spacing[2]);
- chart.plotLeft = pick(margin[3], spacing[3]);
- 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)
- .add()
- .shadow(optionsChart.shadow);
-
- } else { // resize
- chartBackground.animate(
- chartBackground.crisp(null, null, null, chartWidth - mgn, 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,
- zIndex: 1
- })
- .add();
- } else {
- plotBorder.animate(
- plotBorder.crisp(null, plotLeft, plotTop, plotWidth, plotHeight)
- );
- }
- }
-
- // 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;
- }
- }
- });
- },
-
- /**
- * Render all graphics for the chart
- */
- render: function () {
- var chart = this,
- axes = chart.axes,
- renderer = chart.renderer,
- options = chart.options;
-
- var labels = options.labels,
- credits = options.credits,
- creditsHref;
-
- // Title
- chart.setTitle();
-
-
- // Legend
- chart.legend = new Legend(chart, options.legend);
-
- chart.getStacks(); // render stacks
-
- // Get margins by pre-rendering axes
- // set axes scales
- each(axes, function (axis) {
- axis.setScale();
- });
-
- chart.getMargins();
-
- chart.maxTicks = null; // reset for second pass
- each(axes, function (axis) {
- axis.setTickPositions(true); // update to reflect the new margins
- axis.setMaxTicks();
- });
- chart.adjustTickAmounts();
- chart.getMargins(); // second pass to check for new labels
-
-
- // Draw the borders and backgrounds
- chart.drawChartBox();
-
-
- // Axes
- if (chart.hasCartesianSeries) {
- each(axes, function (axis) {
- axis.render();
- });
- }
-
- // The series
- if (!chart.seriesGroup) {
- chart.seriesGroup = renderer.g('series-group')
- .attr({ zIndex: 3 })
- .add();
- }
- each(chart.series, function (serie) {
- serie.translate();
- serie.setTooltipPoints();
- serie.render();
- });
-
- // 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;
-
- renderer.text(
- label.html,
- x,
- y
- )
- .attr({ zIndex: 2 })
- .css(style)
- .add();
-
- });
- }
-
- // Credits
- if (credits.enabled && !chart.credits) {
- creditsHref = credits.href;
- chart.credits = renderer.text(
- credits.text,
- 0,
- 0
- )
- .on('click', function () {
- if (creditsHref) {
- location.href = creditsHref;
- }
- })
- .attr({
- align: credits.position.align,
- zIndex: 8
- })
- .css(credits.style)
- .add()
- .align(credits.position);
- }
-
- // Set flag
- chart.hasRendered = true;
-
- },
-
- /**
- * 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;
- 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
- 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) {
- fn.apply(chart, [chart]);
- });
-
-
- // If the chart was rendered outside the top container, put it back in
- chart.cloneRenderTo(true);
-
- fireEvent(chart, 'load');
-
- },
-
- /**
- * 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
-
-// Hook for exporting module
-Chart.prototype.callbacks = [];
-/**
- * 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.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.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,
- pointArrayMap = series.pointArrayMap || ['y'],
- valueCount = pointArrayMap.length,
- firstItemType,
- i = 0,
- j = 0;
-
- if (typeof options === 'number' || options === null) {
- ret = { y: options };
-
- } else if (isArray(options)) {
- ret = {};
- // with leading x value
- if (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) {
- ret[pointArrayMap[j++]] = options[i++];
- }
- } 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', 'group', '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 () {
- var point = this;
- return {
- x: point.category,
- y: point.y,
- key: point.name || point.category,
- series: point.series,
- point: point,
- percentage: point.percentage,
- total: point.total || point.stackTotal
- };
- },
-
- /**
- * 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
- */
- onMouseOver: function (e) {
- var point = this,
- series = point.series,
- chart = series.chart,
- tooltip = chart.tooltip,
- hoverPoint = chart.hoverPoint;
-
- // set normal state to previous series
- if (hoverPoint && hoverPoint !== point) {
- hoverPoint.onMouseOut();
- }
-
- // 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);
- chart.hoverPoint = point;
- },
-
- /**
- * Runs on mouse out from the point
- */
- onMouseOut: function () {
- var chart = this.series.chart,
- hoverPoints = chart.hoverPoints;
-
- if (!hoverPoints || inArray(this, hoverPoints) === -1) { // #887
- this.firePointEvent('mouseOut');
-
- this.setState();
- chart.hoverPoint = null;
- }
- },
-
- /**
- * 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
- });
- },
-
- /**
- * 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) {
- var point = this,
- series = point.series,
- graphic = point.graphic,
- i,
- data = series.data,
- chart = series.chart,
- seriesOptions = series.options;
-
- redraw = pick(redraw, true);
-
- // fire the event with a default handler of doing the update
- point.firePointEvent('update', { options: options }, function () {
-
- point.applyOptions(options);
-
- // update visuals
- if (isObject(options)) {
- series.getAttribs();
- if (graphic) {
- if (options.marker && options.marker.symbol) {
- point.graphic = graphic.destroy();
- } else {
- graphic.attr(point.pointAttr[point.state || '']);
- }
- }
- }
-
- // record changes in the parallel arrays
- i = inArray(point, data);
- series.xData[i] = point.x;
- series.yData[i] = series.toYData ? series.toYData(point) : point.y;
- series.zData[i] = point.z;
- 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.legend.destroyItem(point);
- }
- if (redraw) {
- chart.redraw(animation);
- }
- });
- },
-
- /**
- * 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) {
- var point = this,
- series = point.series,
- points = series.points,
- chart = series.chart,
- i,
- data = series.data;
-
- setAnimation(animation, chart);
- redraw = pick(redraw, true);
-
- // fire the event with a default handler of removing the point
- point.firePointEvent('remove', null, function () {
-
- // splice all the parallel arrays
- i = inArray(point, data);
- if (data.length === points.length) {
- points.splice(i, 1);
- }
- data.splice(i, 1);
- series.options.data.splice(i, 1);
- series.xData.splice(i, 1);
- series.yData.splice(i, 1);
- series.zData.splice(i, 1);
-
- point.destroy();
-
-
- // redraw
- series.isDirty = true;
- series.isDirtyData = true;
- if (redraw) {
- chart.redraw();
- }
- });
-
-
- },
-
- /**
- * 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
- point.select(null, event.ctrlKey || event.metaKey || event.shiftKey);
- };
- }
-
- fireEvent(this, eventType, eventArgs, defaultFunction);
- },
- /**
- * 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) {
- var point = this,
- plotX = point.plotX,
- 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,
- newSymbol,
- pointAttr = point.pointAttr;
-
- state = state || NORMAL_STATE; // empty string
-
- if (
- // already has this state
- state === point.state ||
- // selected points don't respond to hover
- (point.selected && state !== SELECT_STATE) ||
- // series' state options is disabled
- (stateOptions[state] && stateOptions[state].enabled === false) ||
- // point marker's state options is disabled
- (state && (stateDisabled || (normalDisabled && !markerStateOptions.enabled)))
-
- ) {
- return;
- }
-
- // apply hover styles to the existing point
- if (point.graphic) {
- radius = markerOptions && point.graphic.symbolName && pointAttr[state].r;
- point.graphic.attr(merge(
- pointAttr[state],
- radius ? { // new symbol attributes (#507, #612)
- x: plotX - radius,
- y: plotY - radius,
- width: 2 * radius,
- height: 2 * radius
- } : {}
- ));
- } 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) {
- series.stateMarkerGraphic = stateMarkerGraphic = chart.renderer.symbol(
- newSymbol,
- plotX - radius,
- plotY - radius,
- 2 * radius,
- 2 * radius
- )
- .attr(pointAttr[state])
- .add(series.markerGroup);
- stateMarkerGraphic.currentSymbol = newSymbol;
-
- // Move the existing graphic
- } else {
- stateMarkerGraphic.attr({ // #1054
- x: plotX - radius,
- y: plotY - radius
- });
- }
- }
-
- if (stateMarkerGraphic) {
- stateMarkerGraphic[state && chart.isInsidePlot(plotX, plotY) ? 'show' : 'hide']();
- }
- }
-
- point.state = state;
- }
-};
-
-/**
- * @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 = 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'
- },
- colorCounter: 0,
- init: function (chart, options) {
- var series = this,
- eventType,
- events,
- chartSeries = chart.series;
-
- 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
- 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)
- stableSort(chartSeries, function (a, b) {
- return pick(a.options.index, a._i) - pick(b.options.index, a._i);
- });
- 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;
-
- if (series.isCartesian) {
-
- each(['xAxis', 'yAxis'], 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]) {
- error(18, true);
- }
-
- });
- }
- },
-
-
- /**
- * 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 series = this,
- options = series.options,
- xIncrement = series.xIncrement;
-
- xIncrement = pick(xIncrement, options.pointStart, 0);
-
- series.pointInterval = pick(series.pointInterval, options.pointInterval, 1);
-
- series.xIncrement = xIncrement + series.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,
- typeOptions = plotOptions[this.type],
- options;
-
- this.userOptions = itemOptions;
-
- options = merge(
- typeOptions,
- plotOptions.series,
- itemOptions
- );
-
- // the tooltip options are merged between global and series specific options
- this.tooltipOptions = merge(chartOptions.tooltip, options.tooltip);
-
- // Delte marker object if not allowed (#1125)
- if (typeOptions.marker === null) {
- delete options.marker;
- }
-
- return options;
-
- },
- /**
- * Get the series' color
- */
- getColor: function () {
- var options = this.options,
- userOptions = this.userOptions,
- defaultColors = this.chart.options.colors,
- counters = this.chart.counters,
- color,
- colorIndex;
-
- color = options.color || defaultPlotOptions[this.type].color;
-
- if (!color && !options.colorByPoint) {
- if (defined(userOptions._colorIndex)) { // after Series.update()
- colorIndex = userOptions._colorIndex;
- } else {
- userOptions._colorIndex = counters.color;
- colorIndex = counters.color++;
- }
- color = defaultColors[colorIndex];
- }
-
- this.color = color;
- counters.wrapColor(defaultColors.length);
- },
- /**
- * Get the series' symbol
- */
- getSymbol: function () {
- var series = this,
- userOptions = series.userOptions,
- seriesMarkerOption = series.options.marker,
- chart = series.chart,
- defaultSymbols = chart.options.symbols,
- counters = chart.counters,
- symbolIndex;
-
- series.symbol = seriesMarkerOption.symbol;
- if (!series.symbol) {
- if (defined(userOptions._symbolIndex)) { // after Series.update()
- symbolIndex = userOptions._symbolIndex;
- } else {
- userOptions._symbolIndex = counters.symbol;
- symbolIndex = counters.symbol++;
- }
- series.symbol = defaultSymbols[symbolIndex];
- }
-
- // don't substract radius in image symbols (#604)
- if (/^url/.test(series.symbol)) {
- seriesMarkerOption.radius = 0;
- }
- counters.wrapSymbol(defaultSymbols.length);
- },
-
- /**
- * 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
- */
- drawLegendSymbol: function (legend) {
-
- var options = this.options,
- markerOptions = options.marker,
- radius,
- legendOptions = legend.options,
- legendSymbol,
- symbolWidth = legendOptions.symbolWidth,
- renderer = this.chart.renderer,
- legendItemGroup = this.legendGroup,
- verticalCenter = legend.baseline - mathRound(renderer.fontMetrics(legendOptions.itemStyle.fontSize).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) {
- radius = markerOptions.radius;
- this.legendSymbol = legendSymbol = renderer.symbol(
- this.symbol,
- (symbolWidth / 2) - radius,
- verticalCenter - radius,
- 2 * radius,
- 2 * radius
- )
- .add(legendItemGroup);
- legendSymbol.isMarker = true;
- }
- },
-
- /**
- * 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,
- xData = series.xData,
- yData = series.yData,
- zData = series.zData,
- names = series.names,
- currentShift = (graph && graph.shift) || 0,
- dataOptions = seriesOptions.data,
- point,
- isInTheMiddle,
- x,
- i;
-
- setAnimation(animation, chart);
-
- // Make graph animate sideways
- if (shift) {
- each([graph, area, series.graphNeg, series.areaNeg], function (shape) {
- if (shape) {
- shape.shift = currentShift + 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--;
- }
- }
-
- xData.splice(i, 0, x);
- yData.splice(i, 0, series.toYData ? series.toYData(point) : point.y);
- zData.splice(i, 0, point.z);
- if (names) {
- 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();
- xData.shift();
- yData.shift();
- zData.shift();
- dataOptions.shift();
- }
- }
-
- // redraw
- series.isDirty = true;
- series.isDirtyData = true;
- if (redraw) {
- series.getAttribs(); // #1937
- chart.redraw();
- }
- },
-
- /**
- * Replace the series data with a new set of data
- * @param {Object} data
- * @param {Object} redraw
- */
- setData: function (data, redraw) {
- var series = this,
- oldData = series.points,
- options = series.options,
- chart = series.chart,
- firstPoint = null,
- xAxis = series.xAxis,
- names = xAxis && xAxis.categories && !xAxis.categories.length ? [] : null,
- i;
-
- // reset properties
- series.xIncrement = null;
- series.pointRange = xAxis && xAxis.categories ? 1 : options.pointRange;
-
- series.colorCounter = 0; // for series with colorByPoint (#1547)
-
- // parallel arrays
- var xData = [],
- yData = [],
- zData = [],
- dataLength = data ? data.length : [],
- turboThreshold = pick(options.turboThreshold, 1000),
- pt,
- pointArrayMap = series.pointArrayMap,
- valueCount = pointArrayMap && pointArrayMap.length,
- hasToYData = !!series.toYData;
-
- // 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]]);
- xData[i] = pt.x;
- yData[i] = hasToYData ? series.toYData(pt) : pt.y;
- zData[i] = pt.z;
- if (names && pt.name) {
- 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.xData = xData;
- series.yData = yData;
- series.zData = zData;
- series.names = names;
-
- // destroy old points
- i = (oldData && oldData.length) || 0;
- 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;
- if (pick(redraw, true)) {
- chart.redraw(false);
- }
- },
-
- /**
- * 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;
- },
-
- /**
- * 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,
- isCartesian = series.isCartesian;
-
- // 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;
- }
-
-
- // optionally filter out points outside the plot area
- if (isCartesian && series.sorted && (!cropThreshold || dataLength > cropThreshold || series.forceCrop)) {
- var min = xAxis.min,
- max = xAxis.max;
-
- // 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])));
- }
- }
-
- // 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;
- },
-
- /**
- * Adds series' points value to corresponding stack
- */
- 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,
- stackOption = seriesOptions.stack,
- stacking = seriesOptions.stacking,
- stackKey = series.stackKey,
- negKey = '-' + stackKey,
- negStacks = series.negStacks,
- yAxis = series.yAxis,
- stacks = yAxis.stacks,
- oldStacks = yAxis.oldStacks,
- isNegative,
- stack,
- other,
- key,
- i,
- x,
- y;
-
- // 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];
-
- // 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 < 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, stacking);
- }
- }
-
- // If the StackItem doesn't exist, create it first
- stack = stacks[key][x];
- stack.points[series.index] = [stack.cum || 0];
-
- // 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 += mathAbs(y) || 0;
- }
- } else {
- stack.total += y || 0;
- }
-
- stack.cum = (stack.cum || 0) + (y || 0);
-
- stack.points[series.index].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
- */
- setPercentStacks: function () {
- var series = this,
- stackKey = series.stackKey,
- stacks = series.yAxis.stacks;
-
- each([stackKey, '-' + stackKey], function (key) {
- var i = series.xData.length,
- x,
- stack,
- pointExtremes,
- totalFactor;
-
- while (i--) {
- x = series.xData[i];
- stack = stacks[key] && stacks[key][x];
- pointExtremes = stack && stack.points[series.index];
- 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];
- }
- }
- });
- },
-
- /**
- * Calculate Y extremes for visible data
- */
- getExtremes: function () {
- var xAxis = this.xAxis,
- yAxis = this.yAxis,
- xData = this.processedXData,
- yData = this.stackedYData || this.processedYData,
- yDataLength = yData.length,
- activeYData = [],
- activeCounter = 0,
- xExtremes = xAxis.getExtremes(), // #2117, need to compensate for log X axis
- xMin = xExtremes.min,
- xMax = xExtremes.max,
- validValue,
- withinRange,
- dataMin,
- dataMax,
- x,
- y,
- i,
- j;
-
- 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.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 = pick(dataMin, arrayMin(activeYData));
- this.dataMax = pick(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;
-
-
- // Translate each point
- for (i = 0; i < dataLength; i++) {
- var point = points[i],
- xValue = point.x,
- yValue = point.y,
- yBottom = point.low,
- stack = yAxis.stacks[(series.negStacks && yValue < threshold ? '-' : '') + series.stackKey],
- pointStack,
- stackValues;
-
- // Discard disallowed y values for log axes
- if (yAxis.isLog && yValue <= 0) {
- point.y = yValue = null;
- }
-
- // Get the plotX translation
- point.plotX = xAxis.translate(xValue, 0, 0, 0, 1, pointPlacement, this.type === 'flags'); // Math.round fixes #591
-
-
- // Calculate the bottom y value for stacked series
- if (stacking && series.visible && stack && stack[xValue]) {
-
- pointStack = stack[xValue];
- stackValues = pointStack.points[series.index];
- yBottom = stackValues[0];
- yValue = stackValues[1];
-
- if (yBottom === 0) {
- yBottom = pick(threshold, yAxis.min);
- }
- if (yAxis.isLog && yBottom <= 0) { // #1200, #1232
- yBottom = null;
- }
-
- point.percentage = stacking === 'percent' && yValue;
- point.total = point.stackTotal = pointStack.total;
- 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 = (typeof yValue === 'number' && yValue !== Infinity) ?
- //mathRound(yAxis.translate(yValue, 0, 1, 0, 1) * 10) / 10 : // Math.round fixes #591
- yAxis.translate(yValue, 0, 1, 0, 1) :
- UNDEFINED;
-
- // Set client related positions for mouse tracking
- point.clientX = dynamicallyPlaced ? xAxis.translate(xValue, 0, 0, 0, 1) : point.plotX; // #1514
-
- point.negative = point.y < (threshold || 0);
-
- // some API data
- point.category = categories && categories[point.x] !== UNDEFINED ?
- categories[point.x] : point.x;
-
-
- }
-
- // now that we have the cropped data, build the segments
- series.getSegments();
- },
- /**
- * Memoize tooltip texts and positions
- */
- setTooltipPoints: function (renew) {
- var series = this,
- points = [],
- pointsLength,
- low,
- high,
- xAxis = series.xAxis,
- xExtremes = xAxis && xAxis.getExtremes(),
- axisLength = xAxis ? (xAxis.tooltipLen || xAxis.len) : series.chart.plotSizeX, // tooltipLen and tooltipPosName used in polar
- point,
- pointX,
- nextPoint,
- i,
- tooltipPoints = []; // a lookup array for each pixel in the x dimension
-
- // don't waste resources if tracker is disabled
- if (series.options.enableMouseTracking === false) {
- return;
- }
-
- // renew
- if (renew) {
- series.tooltipPoints = null;
- }
-
- // concat segments to overcome null values
- each(series.segments || series.points, function (segment) {
- points = points.concat(segment);
- });
-
- // Reverse the points in case the X axis is reversed
- if (xAxis && xAxis.reversed) {
- points = points.reverse();
- }
-
- // Polar needs additional shaping
- if (series.orderTooltipPoints) {
- series.orderTooltipPoints(points);
- }
-
- // Assign each pixel position to the nearest point
- pointsLength = points.length;
- for (i = 0; i < pointsLength; i++) {
- point = points[i];
- pointX = point.x;
- if (pointX >= xExtremes.min && pointX <= xExtremes.max) { // #1149
- nextPoint = points[i + 1];
-
- // Set this range's low to the last range's high plus one
- low = high === UNDEFINED ? 0 : high + 1;
- // Now find the new high
- high = points[i + 1] ?
- mathMin(mathMax(0, mathFloor( // #2070
- (point.clientX + (nextPoint ? (nextPoint.wrappedClientX || nextPoint.clientX) : axisLength)) / 2
- )), axisLength) :
- axisLength;
-
- while (low >= 0 && low <= high) {
- tooltipPoints[low++] = point;
- }
- }
- }
- series.tooltipPoints = tooltipPoints;
- },
-
- /**
- * Format the header of the tooltip
- */
- tooltipHeaderFormatter: function (point) {
- var series = this,
- tooltipOptions = series.tooltipOptions,
- xDateFormat = tooltipOptions.xDateFormat,
- dateTimeLabelFormats = tooltipOptions.dateTimeLabelFormats,
- xAxis = series.xAxis,
- isDateTime = xAxis && xAxis.options.type === 'datetime',
- headerFormat = tooltipOptions.headerFormat,
- closestPointRange = xAxis && xAxis.closestPointRange,
- n;
-
- // Guess the best date format based on the closest point distance (#568)
- if (isDateTime && !xDateFormat) {
- if (closestPointRange) {
- for (n in timeUnits) {
- if (timeUnits[n] >= closestPointRange) {
- xDateFormat = dateTimeLabelFormats[n];
- break;
- }
- }
- } else {
- xDateFormat = dateTimeLabelFormats.day;
- }
- }
-
- // Insert the header date format if any
- if (isDateTime && xDateFormat && isNumber(point.key)) {
- headerFormat = headerFormat.replace('{point.key}', '{point.key:' + xDateFormat + '}');
- }
-
- return format(headerFormat, {
- point: point,
- series: series
- });
- },
-
- /**
- * 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;
-
- // 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();
- chart.hoverSeries = null;
- },
-
- /**
- * Animate in the series
- */
- animate: function (init) {
- var series = this,
- chart = series.chart,
- renderer = chart.renderer,
- clipRect,
- markerClipRect,
- animation = series.options.animation,
- clipBox = chart.clipBox,
- inverted = chart.inverted,
- sharedClipKey;
-
- // Animation option is set to true
- if (animation && !isObject(animation)) {
- animation = defaultPlotOptions[series.type].animation;
- }
- sharedClipKey = '_sharedClip' + animation.duration + animation.easing;
-
- // Initialize the animation. Set up the clipping rectangle.
- if (init) {
-
- // If a clipping rectangle with the same properties is currently present in the chart, use that.
- clipRect = chart[sharedClipKey];
- markerClipRect = chart[sharedClipKey + 'm'];
- if (!clipRect) {
- chart[sharedClipKey] = clipRect = renderer.clipRect(
- extend(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
- );
- }
- series.group.clip(clipRect);
- series.markerGroup.clip(markerClipRect);
- series.sharedClipKey = sharedClipKey;
-
- // Run the animation
- } else {
- clipRect = chart[sharedClipKey];
- if (clipRect) {
- clipRect.animate({
- width: chart.plotSizeX
- }, animation);
- chart[sharedClipKey + 'm'].animate({
- width: chart.plotSizeX + 99
- }, animation);
- }
-
- // Delete this function to allow it only once
- series.animate = null;
-
- // Call the afterAnimate function on animation complete (but don't overwrite the animation.complete option
- // which should be available to the user).
- series.animationTimeout = setTimeout(function () {
- series.afterAnimate();
- }, animation.duration);
- }
- },
-
- /**
- * This runs after animation to land on the final plot clipping
- */
- afterAnimate: function () {
- var chart = this.chart,
- sharedClipKey = this.sharedClipKey,
- group = this.group;
-
- if (group && this.options.clip !== false) {
- group.clip(chart.clipRect);
- this.markerGroup.clip(); // no clip
- }
-
- // Remove the shared clipping rectancgle when all series are shown
- setTimeout(function () {
- if (sharedClipKey && chart[sharedClipKey]) {
- chart[sharedClipKey] = chart[sharedClipKey].destroy();
- chart[sharedClipKey + 'm'] = chart[sharedClipKey + 'm'].destroy();
- }
- }, 100);
- },
-
- /**
- * 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,
- pointMarkerOptions,
- enabled,
- isInside,
- markerGroup = series.markerGroup;
-
- if (seriesMarkerOptions.enabled || series._hasPointMarkers) {
-
- i = points.length;
- while (i--) {
- point = points[i];
- plotX = mathFloor(point.plotX); // #1843
- plotY = point.plotY;
- graphic = point.graphic;
- pointMarkerOptions = point.marker || {};
- enabled = (seriesMarkerOptions.enabled && pointMarkerOptions.enabled === UNDEFINED) || pointMarkerOptions.enabled;
- isInside = chart.isInsidePlot(mathRound(plotX), plotY, chart.inverted); // #1858
-
- // 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];
- radius = pointAttr.r;
- symbol = pick(pointMarkerOptions.symbol, series.symbol);
- isImage = symbol.indexOf('url') === 0;
-
- if (graphic) { // update
- graphic
- .attr({ // Since the marker group isn't clipped, each individual marker must be toggled
- visibility: isInside ? (hasSVG ? 'inherit' : VISIBLE) : HIDDEN
- })
- .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
- )
- .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,
- normalDefaults = {
- stroke: seriesColor,
- fill: seriesColor
- },
- points = series.points || [], // #927
- i,
- point,
- seriesPointAttr = [],
- pointAttr,
- pointAttrToOptions = series.pointAttrToOptions,
- hasPointSpecificOptions,
- negativeColor = seriesOptions.negativeColor,
- defaultLineColor = normalOptions.lineColor,
- 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 + 2;
- stateOptionsHover.lineWidth = stateOptionsHover.lineWidth || normalOptions.lineWidth + 1;
-
- } 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();
- }
-
- // 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;
- while (i--) {
- point = points[i];
- normalOptions = (point.options && point.options.marker) || point.options;
- if (normalOptions && normalOptions.enabled === false) {
- normalOptions.radius = 0;
- }
-
- if (point.negative && negativeColor) {
- point.color = point.fillColor = negativeColor;
- }
-
- 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) { // column, bar, point
- // if no hover color is given, brighten the normal color
- pointStateOptionsHover.color =
- Color(pointStateOptionsHover.color || point.color)
- .brighten(pointStateOptionsHover.brightness ||
- stateOptionsHover.brightness).get();
-
- }
-
- // normal point state inherits series wide normal state
- pointAttr[NORMAL_STATE] = series.convertAttribs(extend({
- color: point.color, // #868
- fillColor: point.color, // Individual point color or negative color markers (#2219)
- lineColor: defaultLineColor === null ? point.color : UNDEFINED // Bubbles take point color, line markers use white
- }, 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;
-
- }
-
- },
- /**
- * Update the series with a new set of options
- */
- update: function (newOptions, redraw) {
- var 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,
- n;
-
- // 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 reinsert methods from the type prototype
- this.remove(false);
- for (n in proto) { // Overwrite series-type specific methods (#2270)
- if (proto.hasOwnProperty(n)) {
- this[n] = UNDEFINED;
- }
- }
- extend(this, seriesTypes[newOptions.type || oldType].prototype);
-
-
- this.init(chart, newOptions);
- if (pick(redraw, true)) {
- chart.redraw(false);
- }
- },
-
- /**
- * 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(['xAxis', 'yAxis'], function (AXIS) {
- axis = series[AXIS];
- if (axis) {
- erase(axis.series, series);
- axis.isDirty = axis.forceRedraw = true;
- axis.stacks = {}; // Rebuild stacks when updating (#2229)
- }
- });
-
- // 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
- each(['area', 'graph', 'dataLabelsGroup', 'group', 'markerGroup', 'tracker',
- 'graphNeg', 'areaNeg', 'posClip', 'negClip'], function (prop) {
- if (series[prop]) {
-
- // 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];
- }
- },
-
- /**
- * Draw the data labels
- */
- drawDataLabels: function () {
-
- var series = this,
- seriesOptions = series.options,
- options = seriesOptions.dataLabels,
- points = series.points,
- pointOptions,
- generalOptions,
- str,
- dataLabelsGroup;
-
- 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',
- series.visible ? VISIBLE : HIDDEN,
- options.zIndex || 6
- );
-
- // 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;
-
- // Determine if each data label is enabled
- pointOptions = point.options && point.options.dataLabels;
- 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);
-
- rotation = options.rotation;
-
- // Get the string
- labelConfig = point.getLabelConfig();
- str = options.format ?
- format(options.format, labelConfig) :
- options.formatter.call(labelConfig, options);
-
- // Determine the color
- options.style.color = pick(options.color, options.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
- };
- // Remove unused attributes (#947)
- for (name in attr) {
- if (attr[name] === UNDEFINED) {
- delete attr[name];
- }
- }
-
- dataLabel = point.dataLabel = series.chart.renderer[rotation ? 'text' : 'label']( // labels don't support rotation
- str,
- 0,
- -999,
- null,
- null,
- null,
- options.useHTML
- )
- .attr(attr)
- .css(options.style)
- .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
- */
- 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(),
- visible = this.visible && chart.isInsidePlot(point.plotX, point.plotY, 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
- alignAttr = {
- align: options.align,
- x: alignTo.x + options.x + alignTo.width / 2,
- y: alignTo.y + options.y + alignTo.height / 2
- };
- dataLabel[isNew ? 'attr' : 'animate'](alignAttr);
- } else {
- dataLabel.align(options, null, alignTo);
- alignAttr = dataLabel.alignAttr;
-
- // Handle justify or crop
- if (pick(options.overflow, 'justify') === 'justify') { // docs: overflow: justify, also crop only applies when not 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);
-
- }
- }
- }
-
- // Show or hide based on the final aligned position
- if (!visible) {
- dataLabel.attr({ y: -999 });
- }
-
- },
-
- /**
- * If data labels fall partly outside the plot area, align them back in, in a way that
- * doesn't hide the point.
- */
- justifyDataLabel: function (dataLabel, options, alignAttr, bBox, alignTo, isNew) {
- var chart = this.chart,
- align = options.align,
- verticalAlign = options.verticalAlign,
- off,
- justified;
-
- // Off left
- off = alignAttr.x;
- if (off < 0) {
- if (align === 'right') {
- options.align = 'left';
- } else {
- options.x = -off;
- }
- justified = true;
- }
-
- // Off right
- off = alignAttr.x + bBox.width;
- if (off > chart.plotWidth) {
- if (align === 'left') {
- options.align = 'right';
- } else {
- options.x = chart.plotWidth - off;
- }
- justified = true;
- }
-
- // Off top
- off = alignAttr.y;
- if (off < 0) {
- if (verticalAlign === 'bottom') {
- options.verticalAlign = 'top';
- } else {
- options.y = -off;
- }
- justified = true;
- }
-
- // Off bottom
- off = alignAttr.y + bBox.height;
- 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);
- }
- },
-
- /**
- * 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
- );
-
- } else if (step === 'center') {
- segmentPath.push(
- (lastPoint.plotX + plotX) / 2,
- lastPoint.plotY,
- (lastPoint.plotX + plotX) / 2,
- plotY
- );
-
- } else {
- segmentPath.push(
- plotX,
- lastPoint.plotY
- );
- }
- }
-
- // 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]],
- lineWidth = options.lineWidth,
- dashStyle = options.dashStyle,
- graphPath = this.getGraphPath(),
- negativeColor = options.negativeColor;
-
- if (negativeColor) {
- props.push(['graphNeg', negativeColor]);
- }
-
- // draw the graph
- each(props, function (prop, i) {
- var graphKey = prop[0],
- graph = series[graphKey],
- attribs;
-
- if (graph) {
- stop(graph); // cancel running animations, #459
- graph.animate({ d: graphPath });
-
- } else if (lineWidth && graphPath.length) { // #1487
- attribs = {
- stroke: prop[1],
- 'stroke-width': lineWidth,
- zIndex: 1 // #1069
- };
- if (dashStyle) {
- attribs.dashstyle = dashStyle;
- } else {
- attribs['stroke-linecap'] = attribs['stroke-linejoin'] = 'round';
- }
-
- series[graphKey] = series.chart.renderer.path(graphPath)
- .attr(attribs)
- .add(series.group)
- .shadow(!i && options.shadow);
- }
- });
- },
-
- /**
- * Clip the graphs into the positive and negative coloured graphs
- */
- clipNeg: function () {
- var options = this.options,
- chart = this.chart,
- renderer = chart.renderer,
- negativeColor = options.negativeColor || options.negativeFillColor,
- translatedThreshold,
- posAttr,
- negAttr,
- graph = this.graph,
- area = this.area,
- posClip = this.posClip,
- negClip = this.negClip,
- chartWidth = chart.chartWidth,
- chartHeight = chart.chartHeight,
- chartSizeMax = mathMax(chartWidth, chartHeight),
- yAxis = this.yAxis,
- above,
- below;
-
- if (negativeColor && (graph || area)) {
- translatedThreshold = mathRound(yAxis.toPixels(options.threshold || 0, true));
- above = {
- x: 0,
- y: 0,
- width: chartSizeMax,
- height: translatedThreshold
- };
- below = {
- x: 0,
- y: translatedThreshold,
- width: chartSizeMax,
- height: chartSizeMax
- };
-
- if (chart.inverted) {
-
- above.height = below.y = chart.plotWidth - translatedThreshold;
- if (renderer.isVML) {
- above = {
- x: chart.plotWidth - translatedThreshold - chart.plotLeft,
- y: 0,
- width: chartWidth,
- height: chartHeight
- };
- below = {
- x: translatedThreshold + chart.plotLeft - chartWidth,
- y: 0,
- width: chart.plotLeft + translatedThreshold,
- height: chartWidth
- };
- }
- }
-
- if (yAxis.reversed) {
- posAttr = below;
- negAttr = above;
- } else {
- posAttr = above;
- negAttr = below;
- }
-
- if (posClip) { // update
- posClip.animate(posAttr);
- negClip.animate(negAttr);
- } else {
-
- this.posClip = posClip = renderer.clipRect(posAttr);
- this.negClip = negClip = renderer.clipRect(negAttr);
-
- if (graph && this.graphNeg) {
- graph.clip(posClip);
- this.graphNeg.clip(negClip);
- }
-
- if (area) {
- area.clip(posClip);
- this.areaNeg.clip(negClip);
- }
- }
- }
- },
-
- /**
- * 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);
- }
- // 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 () {
- return {
- translateX: this.xAxis ? this.xAxis.left : this.chart.plotLeft,
- translateY: this.yAxis ? this.yAxis.top : this.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,
- doAnimation = animation && !!series.animate &&
- chart.renderer.isSVG, // this animation doesn't work in IE8 quirks when the group div is hidden,
- // and looks bad in other oldIE
- 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 (doAnimation) {
- 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.clipNeg();
- }
-
- // draw the data labels (inn pies they go before the points)
- series.drawDataLabels();
-
- // draw the points
- series.drawPoints();
-
-
- // draw the mouse tracking area
- if (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
- if (options.clip !== false && !series.sharedClipKey && !hasRendered) {
- group.clip(chart.clipRect);
- }
-
- // Run the animation
- if (doAnimation) {
- series.animate();
- } else if (!hasRendered) {
- 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
- 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.setTooltipPoints(true);
-
- series.render();
- if (wasDirtyData) {
- fireEvent(series, 'updatedData');
- }
- },
-
- /**
- * Set the state of the graph
- */
- setState: function (state) {
- var series = this,
- options = series.options,
- graph = series.graph,
- graphNeg = series.graphNeg,
- stateOptions = options.states,
- lineWidth = options.lineWidth,
- attribs;
-
- 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 + 1;
- }
-
- 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);
- if (graphNeg) {
- graphNeg.attr(attribs);
- }
- }
- }
- },
-
- /**
- * 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) {
- 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');
- },
-
- /**
- * 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.
- */
- drawTracker: 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();
- }
- };
-
- // 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 Series prototype
-
-
-/**
- * LineSeries object
- */
-var LineSeries = extendClass(Series);
-seriesTypes.line = LineSeries;
-
-/**
- * Set the default options for area
- */
-defaultPlotOptions.area = merge(defaultSeriesOptions, {
- 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 segments = [],
- segment = [],
- keys = [],
- xAxis = this.xAxis,
- yAxis = this.yAxis,
- stack = yAxis.stacks[this.stackKey],
- pointMap = {},
- plotX,
- plotY,
- points = this.points,
- connectNulls = this.options.connectNulls,
- val,
- 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) {
- keys.push(+x);
- }
- keys.sort(function (a, b) {
- return a - b;
- });
-
- each(keys, function (x) {
- 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 {
- plotX = xAxis.translate(x);
- val = stack[x].percent ? (stack[x].total ? stack[x].cum * 100 / stack[x].total : 0) : stack[x].cum; // #1991
- plotY = yAxis.toPixels(val, true);
- 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,
- negativeColor = options.negativeColor,
- negativeFillColor = options.negativeFillColor,
- props = [['area', this.color, options.fillColor]]; // area name, main color, fill color
-
- if (negativeColor || negativeFillColor) {
- props.push(['areaNeg', negativeColor, negativeFillColor]);
- }
-
- 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);
- }
- });
- },
-
- /**
- * 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) {
-
- item.legendSymbol = this.chart.renderer.rect(
- 0,
- legend.baseline - 11,
- legend.options.symbolWidth,
- 12,
- 2
- ).attr({
- zIndex: 3
- }).add(item.legendGroup);
-
- }
-});
-
-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: areaProto.drawLegendSymbol
- });
-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
- },
- select: {
- color: '#C0C0C0',
- borderColor: '#000000',
- shadow: false
- }
- },
- dataLabels: {
- align: null, // auto
- verticalAlign: null, // auto
- y: null
- },
- stickyTracking: false,
- threshold: 0
-});
-
-/**
- * ColumnSeries object
- */
-var ColumnSeries = extendClass(Series, {
- type: 'column',
- pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
- stroke: 'borderColor',
- 'stroke-width': 'borderWidth',
- fill: 'color',
- r: 'borderRadius'
- },
- cropShoulder: 0,
- 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 || 1),
- xAxis.len // #1535
- ),
- groupPadding = categoryWidth * options.groupPadding,
- groupWidth = categoryWidth - 2 * groupPadding,
- pointOffsetWidth = groupWidth / columnCount,
- optionPointWidth = options.pointWidth,
- pointPadding = defined(optionPointWidth) ? (pointOffsetWidth - optionPointWidth) / 2 :
- pointOffsetWidth * options.pointPadding,
- pointWidth = pick(optionPointWidth, pointOffsetWidth - 2 * pointPadding), // exact point width, used in polar charts
- 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
- });
-
- },
-
- /**
- * 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 = options.borderWidth,
- 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 = mathCeil(mathMax(pointWidth, 1 + 2 * borderWidth)), // rounded and postprocessed for border width
- pointXOffset = series.pointXOffset = metrics.offset,
- xCrisp = -(borderWidth % 2 ? 0.5 : 0),
- yCrisp = borderWidth % 2 ? 0.5 : 1;
-
- if (chart.renderer.isVML && chart.inverted) {
- yCrisp += 1;
- }
-
- Series.prototype.translate.apply(series);
-
- // record the new values
- each(series.points, function (point) {
- var yBottom = pick(point.yBottom, translatedThreshold),
- plotY = mathMin(mathMax(-999 - yBottom, point.plotY), yAxis.len + 999 + yBottom), // Don't draw too far outside plot area (#1303, #2241)
- barX = point.plotX + pointXOffset,
- barW = seriesBarW,
- barY = mathMin(plotY, yBottom),
- right,
- bottom,
- fromTop,
- fromLeft,
- barH = mathMax(plotY, yBottom) - barY;
-
- // Handle options.minPointLength
- if (mathAbs(barH) < minPointLength) {
- if (minPointLength) {
- barH = minPointLength;
- barY =
- mathRound(mathAbs(barY - translatedThreshold) > minPointLength ? // stacked
- yBottom - minPointLength : // keep position
- translatedThreshold - (yAxis.translate(point.y, 0, 1, 0, 1) <= translatedThreshold ? minPointLength : 0)); // use exact yAxis.translation (#1485)
- }
- }
-
- // Cache for access in polar
- point.barX = barX;
- point.pointWidth = pointWidth;
-
-
- // Round off to obtain crisp edges
- fromLeft = mathAbs(barX) < 0.5;
- right = mathRound(barX + barW) + xCrisp;
- barX = mathRound(barX) + xCrisp;
- barW = right - barX;
-
- fromTop = mathAbs(barY) < 0.5;
- bottom = mathRound(barY + barH) + yCrisp;
- barY = mathRound(barY) + yCrisp;
- barH = bottom - barY;
-
- // Top and left edges are exceptions
- if (fromLeft) {
- barX += 1;
- barW -= 1;
- }
- if (fromTop) {
- barY -= 1;
- barH += 1;
- }
-
- // Register shape type and arguments to be used in drawPoints
- point.shapeType = 'rect';
- point.shapeArgs = {
- x: barX,
- y: barY,
- width: barW,
- height: barH
- };
- });
-
- },
-
- getSymbol: noop,
-
- /**
- * Use a solid rectangle like the area series types
- */
- drawLegendSymbol: AreaSeries.prototype.drawLegendSymbol,
-
-
- /**
- * 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,
- options = series.options,
- renderer = series.chart.renderer,
- shapeArgs;
-
-
- // draw the columns
- each(series.points, function (point) {
- var plotY = point.plotY,
- graphic = point.graphic;
-
- if (plotY !== UNDEFINED && !isNaN(plotY) && point.y !== null) {
- shapeArgs = point.shapeArgs;
-
- if (graphic) { // update
- stop(graphic);
- graphic.animate(merge(shapeArgs));
-
- } else {
- point.graphic = graphic = renderer[point.shapeType](shapeArgs)
- .attr(point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE])
- .add(series.group)
- .shadow(options.shadow, null, options.stacking && !options.borderRadius);
- }
-
- } else if (graphic) {
- point.graphic = graphic.destroy(); // #1269
- }
- });
- },
-
- /**
- * Add tracking event listener to the series group, so the point graphics
- * themselves act as trackers
- */
- drawTracker: 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;
-
- if (chart.hoverSeries !== series) {
- series.onMouseOver();
- }
- 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;
- }
- },
-
- /**
- * Override the basic data label alignment by adjusting for the position of the column
- */
- alignDataLabel: function (point, dataLabel, options, alignTo, isNew) {
- var chart = this.chart,
- inverted = chart.inverted,
- dlBox = point.dlBox || point.shapeArgs, // data label box for alignment
- below = point.below || (point.plotY > pick(this.translatedThreshold, chart.plotSizeY)),
- 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: chart.plotWidth - alignTo.y - alignTo.height,
- y: chart.plotHeight - 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);
- },
-
-
- /**
- * 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,
- tooltip: {
- headerFormat: '<span style="font-size: 10px; color:{series.color}">{series.name}</span><br/>',
- pointFormat: 'x: <b>{point.x}</b><br/>y: <b>{point.y}</b><br/>',
- followPointer: true
- },
- stickyTracking: false
-});
-
-/**
- * The scatter series class
- */
-var ScatterSeries = extendClass(Series, {
- type: 'scatter',
- sorted: false,
- requireSorting: false,
- noSharedTooltip: true,
- trackerGroups: ['markerGroup'],
-
- drawTracker: ColumnSeries.prototype.drawTracker,
-
- setTooltipPoints: noop
-});
-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 () {
- return this.point.name;
- }
- // softConnector: true,
- //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;
-
- // Disallow negative values (#1530)
- if (point.y < 0) {
- point.y = null;
- }
-
- //visible: options.visible !== false,
- extend(point, {
- visible: point.visible !== false,
- 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) {
- var point = this,
- series = point.series,
- chart = series.chart,
- method;
-
- // 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
-
- method = vis ? 'show' : 'hide';
-
- // Show and hide associated elements
- each(['graphic', 'dataLabel', 'connector', 'shadowGroup'], function (key) {
- if (point[key]) {
- point[key][method]();
- }
- });
-
- if (point.legendItem) {
- chart.legend.colorizeItem(point, vis);
- }
-
- // Handle ignore hidden slices
- if (!series.isDirty && series.options.ignoreHiddenPoint) {
- series.isDirty = true;
- 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);
- }
-
- }
-});
-
-/**
- * The Pie series class
- */
-var PieSeries = {
- type: 'pie',
- isCartesian: false,
- pointClass: PiePoint,
- requireSorting: false,
- noSharedTooltip: true,
- trackerGroups: ['group', 'dataLabelsGroup'],
- pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
- stroke: 'borderColor',
- 'stroke-width': 'borderWidth',
- fill: 'color'
- },
-
- /**
- * Pies have one color each point
- */
- getColor: noop,
-
- /**
- * 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: 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;
- }
- },
-
- /**
- * 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();
- }
- },
-
- /**
- * Extend the generatePoints method by adding total and percentage properties to each point
- */
- generatePoints: function () {
- var i,
- total = 0,
- points,
- len,
- point,
- ignoreHiddenPoint = this.options.ignoreHiddenPoint;
-
- Series.prototype.generatePoints.call(this);
-
- // Populate local vars
- points = this.points;
- len = points.length;
-
- // 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.y / total) * 100 : 0;
- point.total = total;
- }
-
- },
-
- /**
- * 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),
- isPercent;
-
- return map(positions, function (length, i) {
- isPercent = /%$/.test(length);
- handleSlicingRoom = i < 2 || (i === 2 && isPercent);
- return (isPercent ?
- // i == 0: centerX, relative to width
- // i == 1: centerY, relative to height
- // i == 2: size, relative to smallestSize
- // i == 4: innerSize, relative to smallestSize
- [plotWidth, plotHeight, smallestSize, smallestSize][i] *
- pInt(length) / 100 :
- length) + (handleSlicingRoom ? slicingRoom : 0);
- });
- },
-
- /**
- * 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 * ((options.endAngle || (startAngle + 360)) - 90), // docs
- 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((y - positions[1]) / (positions[2] / 2 + labelDistance));
-
- 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
- };
-
- // center for the sliced out slice
- angle = (end + start) / 2;
- if (angle > 0.75 * circ) {
- angle -= 2 * mathPI;
- }
- 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
- ];
-
- }
- },
-
- setTooltipPoints: noop,
- 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;
-
- if (shadow && !series.shadowGroup) {
- series.shadowGroup = renderer.g('shadow')
- .add(series.group);
- }
-
- // draw the slices
- each(series.points, function (point) {
- 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.animate(extend(shapeArgs, groupTranslation));
- } else {
- point.graphic = graphic = renderer.arc(shapeArgs)
- .setRadialReference(series.center)
- .attr(
- point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE]
- )
- .attr({ 'stroke-linejoin': 'round' })
- .attr(groupTranslation)
- .add(series.group)
- .shadow(shadow, shadowGroup);
- }
-
- // detect point specific visibility
- if (point.visible === false) {
- point.setVisible(false);
- }
-
- });
-
- },
-
- /**
- * Utility for sorting data labels
- */
- sortByAngle: function (points, sign) {
- points.sort(function (a, b) {
- return a.angle !== undefined && (b.angle - a.angle) * sign;
- });
- },
-
- /**
- * Override the base drawDataLabels method by pie specific functionality
- */
- 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) { // it may have been cancelled in the base method (#407)
- halves[point.half].push(point);
- }
- });
-
- // assume equal label heights
- i = 0;
- while (!labelHeight && data[i]) { // #1569
- labelHeight = data[i] && data[i].dataLabel && (data[i].dataLabel.getBBox().height || 21); // 21 is for #968
- i++;
- }
-
- /* 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,
- length = points.length,
- slotIndex;
-
- // Sort by angle
- series.sortByAngle(points, i - 0.5);
-
- // Only do anti-collision when we are outside the pie and have connectors (#856)
- if (distanceOption > 0) {
-
- // build the slots
- for (pos = centerY - radius - distanceOption; pos <= centerY + radius + distanceOption; pos += labelHeight) {
- slots.push(pos);
-
- // visualize the slot
- /*
- var slotX = series.getX(pos, i) + chart.plotLeft - (i ? 100 : 0),
- slotY = pos + chart.plotTop;
- if (!isNaN(slotX)) {
- chart.renderer.rect(slotX, slotY - 7, 100, labelHeight, 1)
- .attr({
- 'stroke-width': 1,
- stroke: 'silver'
- })
- .add();
- chart.renderer.text('Slot '+ (slots.length - 1), slotX, slotY + 4)
- .attr({
- fill: 'silver'
- }).add();
- }
- */
- }
- slotsLength = slots.length;
-
- // 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 : VISIBLE;
- 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 = naturalY;
- }
-
- } 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(slotIndex === 0 || slotIndex === slots.length - 1 ? 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) {
- 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
- })
- .add(series.group);
- }
- } else if (connector) {
- point.connector = connector.destroy();
- }
- });
- }
- }
- },
-
- /**
- * 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.
- */
- 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;
- this.translate(center);
- each(this.points, function (point) {
- if (point.dataLabel) {
- point.dataLabel._pos = null; // reset
- }
- });
- this.drawDataLabels();
-
- // Else, return true to indicate that the pie and its labels is within the plot area
- } else {
- ret = true;
- }
- return ret;
- },
-
- /**
- * Perform the final placement of the data labels after we have verified that they
- * fall within the plot area.
- */
- placeDataLabels: function () {
- each(this.points, function (point) {
- var dataLabel = point.dataLabel,
- _pos;
-
- if (dataLabel) {
- _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 });
- }
- }
- });
- },
-
- alignDataLabel: noop,
-
- /**
- * Draw point specific tracker objects. Inherit directly from column series.
- */
- drawTracker: ColumnSeries.prototype.drawTracker,
-
- /**
- * Use a simple symbol from column prototype
- */
- drawLegendSymbol: AreaSeries.prototype.drawLegendSymbol,
-
- /**
- * Pies don't have point marker symbols
- */
- getSymbol: noop
-
-};
-PieSeries = extendClass(Series, PieSeries);
-seriesTypes.pie = PieSeries;
-
-
-// global variables
-extend(Highcharts, {
-
- // Constructors
- Axis: Axis,
- Chart: Chart,
- Color: Color,
- Legend: Legend,
- Pointer: Pointer,
- Point: Point,
- Tick: Tick,
- Tooltip: Tooltip,
- Renderer: Renderer,
- Series: Series,
- SVGElement: SVGElement,
- SVGRenderer: SVGRenderer,
-
- // Various
- arrayMin: arrayMin,
- arrayMax: arrayMax,
- charts: charts,
- dateFormat: dateFormat,
- format: format,
- pathAnim: pathAnim,
- getOptions: getOptions,
- hasBidiBug: hasBidiBug,
- isTouchDevice: isTouchDevice,
- numberFormat: numberFormat,
- seriesTypes: seriesTypes,
- setOptions: setOptions,
- addEvent: addEvent,
- removeEvent: removeEvent,
- createElement: createElement,
- discardElement: discardElement,
- css: css,
- each: each,
- extend: extend,
- map: map,
- merge: merge,
- pick: pick,
- splat: splat,
- extendClass: extendClass,
- pInt: pInt,
- wrap: wrap,
- svg: hasSVG,
- canvas: useCanVG,
- vml: !hasSVG && !useCanVG,
- product: PRODUCT,
- version: VERSION
-});
-}());
+// ==ClosureCompiler==
+// @compilation_level SIMPLE_OPTIMIZATIONS
+
+/**
+ * @license Highcharts JS v3.0.6 (2013-10-04)
+ *
+ * (c) 2009-2013 Torstein H酶nsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+// JSLint options:
+/*global Highcharts, document, window, navigator, setInterval, clearInterval, clearTimeout, setTimeout, location, jQuery, $, console, each, grep */
+
+(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,
+ isIE = /msie/i.test(userAgent) && !isOpera,
+ docMode8 = doc.documentMode === 8,
+ isWebKit = /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 && !isIE && !!doc.createElement('canvas').getContext,
+ Renderer,
+ hasTouch = doc.documentElement.ontouchstart !== UNDEFINED,
+ symbolSizes = {},
+ idCounter = 0,
+ garbageBin,
+ defaultOptions,
+ dateFormat, // function
+ globalAnimation,
+ pathAnim,
+ timeUnits,
+ noop = function () {},
+ charts = [],
+ PRODUCT = 'Highcharts',
+ VERSION = '3.0.6',
+
+ // 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',
+ /*
+ * Empirical lowest possible opacities for TRACKER_FILL
+ * 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) + ')', // invisible but clickable
+ //TRACKER_FILL = 'rgba(192,192,192,0.5)',
+ NORMAL_STATE = '',
+ HOVER_STATE = 'hover',
+ SELECT_STATE = 'select',
+ MILLISECOND = 'millisecond',
+ SECOND = 'second',
+ MINUTE = 'minute',
+ HOUR = 'hour',
+ DAY = 'day',
+ WEEK = 'week',
+ MONTH = 'month',
+ YEAR = 'year',
+
+ // constants for attributes
+ LINEAR_GRADIENT = 'linearGradient',
+ STOPS = 'stops',
+ STROKE_WIDTH = 'stroke-width',
+
+ // time methods, changed based on whether or not UTC is used
+ makeTime,
+ getMinutes,
+ getHours,
+ getDay,
+ getDate,
+ getMonth,
+ getFullYear,
+ setMinutes,
+ setHours,
+ setDate,
+ setMonth,
+ setFullYear,
+
+
+ // lookup over the types and the associated classes
+ seriesTypes = {};
+
+// The Highcharts namespace
+win.Highcharts = win.Highcharts ? error(16, true) : {};
+
+/**
+ * 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
+ */
+function extend(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.
+ * 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,
+ len = arguments.length,
+ 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]'
+ && typeof value.nodeType !== 'number') {
+ copy[key] = doCopy(copy[key] || {}, value);
+
+ // Primitives and arrays are copied over directly
+ } else {
+ copy[key] = original[key];
+ }
+ }
+ }
+ return copy;
+ };
+
+ // For each argument, extend the return
+ for (i = 0; i < len; i++) {
+ ret = doCopy(ret, arguments[i]);
+ }
+
+ return ret;
+}
+
+/**
+ * Take an array and turn into a hash with even number arguments as keys and odd numbers as
+ * values. Allows creating constants for commonly used style properties, attributes etc.
+ * Avoid it in performance critical situations like looping
+ */
+function hash() {
+ var i = 0,
+ args = arguments,
+ length = args.length,
+ obj = {};
+ for (; i < length; i++) {
+ obj[args[i++]] = args[i];
+ }
+ return obj;
+}
+
+/**
+ * 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 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,
+ setAttribute = 'setAttribute',
+ 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.
+ */
+function pick() {
+ var args = arguments,
+ i,
+ arg,
+ length = args.length;
+ for (i = 0; i < length; i++) {
+ arg = args[i];
+ if (typeof 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 (isIE) {
+ 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 () {};
+ object.prototype = new parent();
+ extend(object.prototype, members);
+ return object;
+}
+
+/**
+ * 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
+ */
+function numberFormat(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 ?
+ (n.toString().split('.')[1] || '').length : // preserve decimals
+ (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) : "");
+}
+
+/**
+ * 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;
+}
+
+/**
+ * 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.
+ */
+function wrap(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);
+ };
+}
+
+/**
+ * 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 'Invalid date';
+ }
+ format = pick(format, '%Y-%m-%d %H:%M:%S');
+
+ var date = new Date(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
+
+ // 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
+ '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;
+ val = 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, options) {
+ var normalized, i;
+
+ // 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 (options && options.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++) {
+ interval = multiples[i];
+ if (normalized <= (multiples[i] + (multiples[i + 1] || multiples[i])) / 2) {
+ break;
+ }
+ }
+
+ // multiply back to the correct magnitude
+ interval *= magnitude;
+
+ return interval;
+}
+
+/**
+ * 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.
+ */
+function normalizeTimeTickInterval(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 ? getMagnitude(tickInterval / interval) : 1 // #1913
+ );
+
+ return {
+ unitRange: interval,
+ count: count,
+ unitName: unit[0]
+ };
+}
+
+/**
+ * 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
+ */
+function getTimeTicks(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),
+ interval = normalizedInterval.unitRange,
+ count = normalizedInterval.count;
+
+ if (defined(min)) { // #1300
+ if (interval >= timeUnits[SECOND]) { // second
+ minDate.setMilliseconds(0);
+ minDate.setSeconds(interval >= timeUnits[MINUTE] ? 0 :
+ 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;
+ minYear = minDate[getFullYear]();
+ var time = minDate.getTime(),
+ minMonth = minDate[getMonth](),
+ minDateDate = minDate[getDate](),
+ timezoneOffset = useUTC ?
+ 0 :
+ (24 * 3600 * 1000 + minDate.getTimezoneOffset() * 60 * 1000) % (24 * 3600 * 1000); // #950
+
+ // 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] === timezoneOffset;
+ }), 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;
+}
+
+/**
+ * Helper class that contains variuos counters that are local to the chart.
+ */
+function ChartCounters() {
+ this.color = 0;
+ this.symbol = 0;
+}
+
+ChartCounters.prototype = {
+ /**
+ * Wraps the color counter if it reaches the specified length.
+ */
+ wrapColor: function (length) {
+ if (this.color >= length) {
+ this.color = 0;
+ }
+ },
+
+ /**
+ * Wraps the symbol counter if it reaches the specified length.
+ */
+ wrapSymbol: function (length) {
+ if (this.symbol >= length) {
+ this.symbol = 0;
+ }
+ }
+};
+
+
+/**
+ * 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) {
+ return parseFloat(
+ num.toPrecision(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) {
+ globalAnimation = pick(animation, chart.animation);
+}
+
+/**
+ * The time unit lookup
+ */
+/*jslint white: true*/
+timeUnits = hash(
+ MILLISECOND, 1,
+ SECOND, 1000,
+ MINUTE, 60000,
+ HOUR, 3600000,
+ DAY, 24 * 3600000,
+ WEEK, 7 * 24 * 3600000,
+ MONTH, 31 * 24 * 3600000,
+ YEAR, 31556952000
+);
+/*jslint white: false*/
+/**
+ * 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;
+ }
+};
+
+(function ($) {
+ /**
+ * The default HighchartsAdapter for jQuery
+ */
+ win.HighchartsAdapter = win.HighchartsAdapter || ($ && {
+
+ /**
+ * Initialize the adapter by applying some extensions to jQuery
+ */
+ init: function (pathAnim) {
+
+ // extend the animate function to allow SVG animations
+ var Fx = $.fx,
+ Step = Fx.step,
+ dSetter,
+ Tween = $.Tween,
+ propHooks = Tween && Tween.propHooks,
+ opacityHook = $.cssHooks.opacity;
+
+ /*jslint unparam: true*//* allow unused param x in this function */
+ $.extend($.easing, {
+ easeOutQuad: function (x, t, b, c, d) {
+ return -c * (t /= d) * (t - 2) + b;
+ }
+ });
+ /*jslint unparam: false*/
+
+ // extend some methods to check for elem.attr, which means it is a Highcharts SVG object
+ $.each(['cur', '_default', 'width', 'height', 'opacity'], function (i, fn) {
+ var obj = Step,
+ base,
+ elem;
+
+ // Handle different parent objects
+ if (fn === 'cur') {
+ obj = Fx.prototype; // 'cur', the getter, relates to Fx.prototype
+
+ } else if (fn === '_default' && Tween) { // jQuery 1.8 model
+ obj = propHooks[fn];
+ fn = 'set';
+ }
+
+ // Overwrite the method
+ base = obj[fn];
+ if (base) { // step.width and step.height don't exist in jQuery < 1.7
+
+ // create the extended function replacement
+ obj[fn] = function (fx) {
+
+ // Fx.prototype.cur does not use fx argument
+ fx = i ? fx : this;
+
+ // Don't run animations on textual properties like align (#1821)
+ if (fx.prop === 'align') {
+ return;
+ }
+
+ // shortcut
+ elem = fx.elem;
+
+ // Fx.prototype.cur returns the current value. The other ones are setters
+ // and returning a value has no effect.
+ return elem.attr ? // is SVG element wrapper
+ elem.attr(fx.prop, fn === 'cur' ? UNDEFINED : fx.now) : // apply the SVG wrapper's method
+ base.apply(this, arguments); // use jQuery's built-in method
+ };
+ }
+ });
+
+ // Extend the opacity getter, needed for fading opacity with IE9 and jQuery 1.10+
+ wrap(opacityHook, 'get', function (proceed, elem, computed) {
+ return elem.attr ? (elem.opacity || 0) : proceed.call(this, elem, computed);
+ });
+
+
+ // Define the setter function for d (path definitions)
+ dSetter = function (fx) {
+ var elem = fx.elem,
+ ends;
+
+ // Normally start and end should be set in state == 0, but sometimes,
+ // for reasons unknown, this doesn't happen. Perhaps state == 0 is skipped
+ // in these cases
+ if (!fx.started) {
+ ends = pathAnim.init(elem, elem.d, elem.toD);
+ fx.start = ends[0];
+ fx.end = ends[1];
+ fx.started = true;
+ }
+
+
+ // interpolate each value of the path
+ elem.attr('d', pathAnim.step(fx.start, fx.end, fx.pos, elem.toD));
+ };
+
+ // jQuery 1.8 style
+ if (Tween) {
+ propHooks.d = {
+ set: dSetter
+ };
+ // pre 1.8
+ } else {
+ // animate paths
+ Step.d = dSetter;
+ }
+
+ /**
+ * Utility for iterating over an array. Parameters are reversed compared to jQuery.
+ * @param {Array} arr
+ * @param {Function} fn
+ */
+ this.each = Array.prototype.forEach ?
+ function (arr, fn) { // modern browsers
+ return Array.prototype.forEach.call(arr, fn);
+
+ } :
+ 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;
+ }
+ }
+ };
+
+ /**
+ * Register Highcharts as a plugin in the respective framework
+ */
+ $.fn.highcharts = function () {
+ var constr = 'Chart', // default constructor
+ args = arguments,
+ options,
+ ret,
+ chart;
+
+ if (isString(args[0])) {
+ constr = args[0];
+ args = Array.prototype.slice.call(args, 1);
+ }
+ options = args[0];
+
+ // Create the chart
+ if (options !== UNDEFINED) {
+ /*jslint unused:false*/
+ options.chart = options.chart || {};
+ options.chart.renderTo = this[0];
+ chart = new Highcharts[constr](options, args[1]);
+ ret = this;
+ /*jslint unused:true*/
+ }
+
+ // When called without parameters or with the return argument, get a predefined chart
+ if (options === UNDEFINED) {
+ ret = charts[attr(this[0], 'data-highcharts-chart')];
+ }
+
+ return ret;
+ };
+
+ },
+
+
+ /**
+ * Downloads a script and executes a callback when done.
+ * @param {String} scriptLocation
+ * @param {Function} callback
+ */
+ getScript: $.getScript,
+
+ /**
+ * Return the index of an item in an array, or -1 if not found
+ */
+ inArray: $.inArray,
+
+ /**
+ * A direct link to jQuery methods. MooTools and Prototype adapters must be implemented for each case of method.
+ * @param {Object} elem The HTML element
+ * @param {String} method Which method to run on the wrapped element
+ */
+ adapterRun: function (elem, method) {
+ return $(elem)[method]();
+ },
+
+ /**
+ * Filter an array
+ */
+ grep: $.grep,
+
+ /**
+ * Map an array
+ * @param {Array} arr
+ * @param {Function} fn
+ */
+ map: function (arr, fn) {
+ //return jQuery.map(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 position of an element relative to the top left of the page
+ */
+ offset: function (el) {
+ return $(el).offset();
+ },
+
+ /**
+ * Add an event listener
+ * @param {Object} el A HTML element or custom object
+ * @param {String} event The event type
+ * @param {Function} fn The event handler
+ */
+ addEvent: function (el, event, fn) {
+ $(el).bind(event, fn);
+ },
+
+ /**
+ * Remove event added with addEvent
+ * @param {Object} el The object
+ * @param {String} eventType The event type. Leave blank to remove all events.
+ * @param {Function} handler The function to remove
+ */
+ removeEvent: function (el, eventType, handler) {
+ // workaround for jQuery issue with unbinding custom events:
+ // http://forum.jQuery.com/topic/javascript-error-when-unbinding-a-custom-event-using-jQuery-1-4-2
+ var func = doc.removeEventListener ? 'removeEventListener' : 'detachEvent';
+ if (doc[func] && el && !el[func]) {
+ el[func] = function () {};
+ }
+
+ $(el).unbind(eventType, handler);
+ },
+
+ /**
+ * Fire an event on a custom object
+ * @param {Object} el
+ * @param {String} type
+ * @param {Object} eventArguments
+ * @param {Function} defaultFunction
+ */
+ fireEvent: function (el, type, eventArguments, defaultFunction) {
+ var event = $.Event(type),
+ detachedType = 'detached' + type,
+ defaultPrevented;
+
+ // Remove warnings in Chrome when accessing layerX and layerY. Although Highcharts
+ // never uses these properties, Chrome includes them in the default click event and
+ // raises the warning when they are copied over in the extend statement below.
+ //
+ // To avoid problems in IE (see #1010) where we cannot delete the properties and avoid
+ // testing if they are there (warning in chrome) the only option is to test if running IE.
+ if (!isIE && eventArguments) {
+ delete eventArguments.layerX;
+ delete eventArguments.layerY;
+ }
+
+ extend(event, eventArguments);
+
+ // Prevent jQuery from triggering the object method that is named the
+ // same as the event. For example, if the event is 'select', jQuery
+ // attempts calling el.select and it goes into a loop.
+ if (el[type]) {
+ el[detachedType] = el[type];
+ el[type] = null;
+ }
+
+ // Wrap preventDefault and stopPropagation in try/catch blocks in
+ // order to prevent JS errors when cancelling events on non-DOM
+ // objects. #615.
+ /*jslint unparam: true*/
+ $.each(['preventDefault', 'stopPropagation'], function (i, fn) {
+ var base = event[fn];
+ event[fn] = function () {
+ try {
+ base.call(event);
+ } catch (e) {
+ if (fn === 'preventDefault') {
+ defaultPrevented = true;
+ }
+ }
+ };
+ });
+ /*jslint unparam: false*/
+
+ // trigger it
+ $(el).trigger(event);
+
+ // attach the method
+ if (el[detachedType]) {
+ el[type] = el[detachedType];
+ el[detachedType] = null;
+ }
+
+ if (defaultFunction && !event.isDefaultPrevented() && !defaultPrevented) {
+ defaultFunction(event);
+ }
+ },
+
+ /**
+ * Extension method needed for MooTools
+ */
+ washMouseEvent: function (e) {
+ var ret = e.originalEvent || e;
+
+ // computed by jQuery, needed by IE8
+ if (ret.pageX === UNDEFINED) { // #1236
+ ret.pageX = e.pageX;
+ ret.pageY = e.pageY;
+ }
+
+ return ret;
+ },
+
+ /**
+ * Animate a HTML element or SVG element wrapper
+ * @param {Object} el
+ * @param {Object} params
+ * @param {Object} options jQuery-like animation options: duration, easing, callback
+ */
+ animate: function (el, params, options) {
+ var $el = $(el);
+ if (!el.style) {
+ el.style = {}; // #1881
+ }
+ if (params.d) {
+ el.toD = params.d; // keep the array form for paths, used in $.fx.step.d
+ params.d = 1; // because in jQuery, animating to an array has a different meaning
+ }
+
+ $el.stop();
+ if (params.opacity !== UNDEFINED && el.attr) {
+ params.opacity += 'px'; // force jQuery to use same logic as width and height (#2161)
+ }
+ $el.animate(params, options);
+
+ },
+ /**
+ * Stop running animation
+ */
+ stop: function (el) {
+ $(el).stop();
+ }
+ });
+}(win.jQuery));
+
+
+// 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 = 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 *
+ *****************************************************************************/
+var
+
+defaultLabelOptions = {
+ enabled: true,
+ // rotation: 0,
+ // align: 'center',
+ x: 0,
+ y: 15,
+ /*formatter: function () {
+ return this.value;
+ },*/
+ style: {
+ color: '#666',
+ cursor: 'default',
+ fontSize: '11px',
+ lineHeight: '14px'
+ }
+};
+
+defaultOptions = {
+ colors: ['#2f7ed8', '#0d233a', '#8bbc21', '#910000', '#1aadce', '#492970',
+ '#f28f43', '#77a1e5', '#c42525', '#a6c96a'],
+ 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'],
+ 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,
+ canvasToolsURL: 'http://code.highcharts.com/3.0.6/modules/canvas-tools.js',
+ VMLRadialGradientURL: 'http://code.highcharts.com/3.0.6/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: 5,
+ 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: '#274b6d',//#3E576F',
+ fontSize: '16px'
+ }
+
+ },
+ subtitle: {
+ text: '',
+ align: 'center',
+ // floating: false
+ // x: 0,
+ // verticalAlign: 'top',
+ // y: null,
+ style: {
+ color: '#4d759e'
+ }
+ },
+
+ 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,
+ 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
+ //radius: base + 2
+ },
+ select: {
+ fillColor: '#FFFFFF',
+ lineColor: '#000000',
+ lineWidth: 2
+ }
+ }
+ },
+ point: {
+ events: {}
+ },
+ dataLabels: merge(defaultLabelOptions, {
+ align: 'center',
+ enabled: false,
+ formatter: function () {
+ return this.y === null ? '' : numberFormat(this.y, -1);
+ },
+ verticalAlign: 'bottom', // above singular point
+ y: 0
+ // backgroundColor: undefined,
+ // borderColor: undefined,
+ // borderRadius: undefined,
+ // borderWidth: undefined,
+ // padding: 3,
+ // 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: true,
+ states: { // states for the entire series
+ hover: {
+ //enabled: false,
+ //lineWidth: base + 1,
+ marker: {
+ // lineWidth: base + 1,
+ // radius: base + 1
+ }
+ },
+ select: {
+ marker: {}
+ }
+ },
+ stickyTracking: true
+ //tooltip: {
+ //pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.y}</b>'
+ //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: 1,
+ borderColor: '#909090',
+ borderRadius: 5,
+ navigation: {
+ // animation: true,
+ activeColor: '#274b6d',
+ // arrowSize: 12
+ inactiveColor: '#CCC'
+ // style: {} // text styles
+ },
+ // margin: 10,
+ // reversed: false,
+ shadow: false,
+ // backgroundColor: null,
+ /*style: {
+ padding: '5px'
+ },*/
+ itemStyle: {
+ cursor: 'pointer',
+ color: '#274b6d',
+ fontSize: '12px'
+ },
+ itemHoverStyle: {
+ //cursor: 'pointer', removed as of #601
+ color: '#000'
+ },
+ itemHiddenStyle: {
+ color: '#CCC'
+ },
+ itemCheckboxStyle: {
+ position: ABSOLUTE,
+ width: '13px', // for IE precision
+ height: '13px'
+ },
+ // itemWidth: undefined,
+ 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: '1em'
+ },
+ // showDuration: 0,
+ style: {
+ position: ABSOLUTE,
+ backgroundColor: 'white',
+ opacity: 0.5,
+ textAlign: 'center'
+ }
+ },
+
+ tooltip: {
+ enabled: true,
+ animation: hasSVG,
+ //crosshairs: null,
+ backgroundColor: 'rgba(255, 255, 255, .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'
+ },
+ //formatter: defaultFormatter,
+ headerFormat: '<span style="font-size: 10px">{point.key}</span><br/>',
+ pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.y}</b><br/>',
+ shadow: true,
+ //shared: false,
+ snap: isTouchDevice ? 25 : 10,
+ style: {
+ color: '#333333',
+ cursor: 'default',
+ fontSize: '12px',
+ padding: '8px',
+ 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 useUTC = defaultOptions.global.useUTC,
+ GET = useUTC ? 'getUTC' : 'get',
+ SET = useUTC ? 'setUTC' : 'set';
+
+ makeTime = useUTC ? Date.UTC : function (year, month, date, hours, minutes, seconds) {
+ return new Date(
+ year,
+ month,
+ pick(date, 1),
+ pick(hours, 0),
+ pick(minutes, 0),
+ pick(seconds, 0)
+ ).getTime();
+ };
+ getMinutes = GET + 'Minutes';
+ getHours = GET + 'Hours';
+ getDay = GET + 'Day';
+ getDate = GET + 'Date';
+ getMonth = GET + 'Month';
+ getFullYear = GET + 'FullYear';
+ 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) {
+
+ // Pull out axis options and apply them to the respective default axis options
+ /*defaultXAxisOptions = merge(defaultXAxisOptions, options.xAxis);
+ defaultYAxisOptions = merge(defaultYAxisOptions, options.yAxis);
+ options.xAxis = options.yAxis = UNDEFINED;*/
+
+ // Merge in the default options
+ defaultOptions = merge(defaultOptions, options);
+
+ // Apply UTC
+ setTimeMethods();
+
+ return defaultOptions;
+}
+
+/**
+ * Get the updated default options. Merely exposing defaultOptions for outside modules
+ * isn't enough because the setOptions method creates 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 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 = /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*\)/.exec(input);
+ if (result) {
+ rgba = [pInt(result[1]), pInt(result[2]), pInt(result[3]), parseFloat(result[4], 10)];
+ } else {
+ // hex
+ result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(input);
+ if (result) {
+ rgba = [pInt(result[1], 16), pInt(result[2], 16), pInt(result[3], 16), 1];
+ } else {
+ // rgb
+ result = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.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
+ };
+};
+
+
+/**
+ * A wrapper object for SVG elements
+ */
+function SVGElement() {}
+
+SVGElement.prototype = {
+ /**
+ * 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;
+ /**
+ * A collection of attribute setters. These methods, if defined, are called right before a certain
+ * attribute is set on an element wrapper. Returning false prevents the default attribute
+ * setter to run. Returning a value causes the default setter to set that value. Used in
+ * Renderer.label.
+ */
+ wrapper.attrSetters = {};
+ },
+ /**
+ * Default base for animation
+ */
+ opacity: 1,
+ /**
+ * 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, globalAnimation, true);
+ stop(this); // stop regardless of animation actually running, or reverting to .attr (#607)
+ if (animOptions) {
+ animOptions = merge(animOptions);
+ if (complete) { // allows using a callback with the global animation without overwriting it
+ animOptions.complete = complete;
+ }
+ animate(this, params, animOptions);
+ } else {
+ this.attr(params);
+ if (complete) {
+ complete();
+ }
+ }
+ },
+ /**
+ * Set or get a given attribute
+ * @param {Object|String} hash
+ * @param {Mixed|Undefined} val
+ */
+ attr: function (hash, val) {
+ var wrapper = this,
+ key,
+ value,
+ result,
+ i,
+ child,
+ element = wrapper.element,
+ nodeName = element.nodeName.toLowerCase(), // Android2 requires lower for "text"
+ renderer = wrapper.renderer,
+ skipAttr,
+ titleNode,
+ attrSetters = wrapper.attrSetters,
+ shadows = wrapper.shadows,
+ hasSetSymbolSize,
+ doTransform,
+ ret = wrapper;
+
+ // single key-value pair
+ if (isString(hash) && defined(val)) {
+ key = hash;
+ hash = {};
+ hash[key] = val;
+ }
+
+ // used as a getter: first argument is a string, second is undefined
+ if (isString(hash)) {
+ key = hash;
+ if (nodeName === 'circle') {
+ key = { x: 'cx', y: 'cy' }[key] || key;
+ } else if (key === 'strokeWidth') {
+ key = 'stroke-width';
+ }
+ ret = attr(element, key) || wrapper[key] || 0;
+ if (key !== 'd' && key !== 'visibility' && key !== 'fill') { // 'd' is string in animation step
+ ret = parseFloat(ret);
+ }
+
+ // setter
+ } else {
+
+ for (key in hash) {
+ skipAttr = false; // reset
+ value = hash[key];
+
+ // check for a specific attribute setter
+ result = attrSetters[key] && attrSetters[key].call(wrapper, value, key);
+
+ if (result !== false) {
+ if (result !== UNDEFINED) {
+ value = result; // the attribute setter has returned a new value to set
+ }
+
+
+ // paths
+ if (key === 'd') {
+ if (value && value.join) { // join path
+ value = value.join(' ');
+ }
+ if (/(NaN| {2}|^$)/.test(value)) {
+ value = 'M 0 0';
+ }
+ //wrapper.d = value; // shortcut for animations
+
+ // update child tspans x values
+ } else if (key === 'x' && nodeName === 'text') {
+ for (i = 0; i < element.childNodes.length; i++) {
+ child = element.childNodes[i];
+ // if the x values are equal, the tspan represents a linebreak
+ if (attr(child, 'x') === attr(element, 'x')) {
+ //child.setAttribute('x', value);
+ attr(child, 'x', value);
+ }
+ }
+
+ } else if (wrapper.rotation && (key === 'x' || key === 'y')) {
+ doTransform = true;
+
+ // apply gradients
+ } else if (key === 'fill') {
+ value = renderer.color(value, element, key);
+
+ // circle x and y
+ } else if (nodeName === 'circle' && (key === 'x' || key === 'y')) {
+ key = { x: 'cx', y: 'cy' }[key] || key;
+
+ // rectangle border radius
+ } else if (nodeName === 'rect' && key === 'r') {
+ attr(element, {
+ rx: value,
+ ry: value
+ });
+ skipAttr = true;
+
+ // translation and text rotation
+ } else if (key === 'translateX' || key === 'translateY' || key === 'rotation' ||
+ key === 'verticalAlign' || key === 'scaleX' || key === 'scaleY') {
+ doTransform = true;
+ skipAttr = true;
+
+ // apply opacity as subnode (required by legacy WebKit and Batik)
+ } else if (key === 'stroke') {
+ value = renderer.color(value, element, key);
+
+ // emulate VML's dashstyle implementation
+ } else if (key === 'dashstyle') {
+ key = 'stroke-dasharray';
+ value = value && value.toLowerCase();
+ if (value === 'solid') {
+ value = NONE;
+ } else 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]) * pick(hash['stroke-width'], wrapper['stroke-width']);
+ }
+ value = value.join(',');
+ }
+
+ // IE9/MooTools combo: MooTools returns objects instead of numbers and IE9 Beta 2
+ // is unable to cast them. Test again with final IE9.
+ } else if (key === 'width') {
+ value = pInt(value);
+
+ // Text alignment
+ } else if (key === 'align') {
+ key = 'text-anchor';
+ value = { left: 'start', center: 'middle', right: 'end' }[value];
+
+ // Title requires a subnode, #431
+ } else if (key === 'title') {
+ titleNode = element.getElementsByTagName('title')[0];
+ if (!titleNode) {
+ titleNode = doc.createElementNS(SVG_NS, 'title');
+ element.appendChild(titleNode);
+ }
+ titleNode.textContent = value;
+ }
+
+ // jQuery animate changes case
+ if (key === 'strokeWidth') {
+ key = 'stroke-width';
+ }
+
+ // In Chrome/Win < 6 as well as Batik, the stroke attribute can't be set when the stroke-
+ // width is 0. #1369
+ if (key === 'stroke-width' || key === 'stroke') {
+ wrapper[key] = value;
+ // Only apply the stroke attribute if the stroke width is defined and larger than 0
+ if (wrapper.stroke && wrapper['stroke-width']) {
+ attr(element, 'stroke', wrapper.stroke);
+ attr(element, 'stroke-width', wrapper['stroke-width']);
+ wrapper.hasStroke = true;
+ } else if (key === 'stroke-width' && value === 0 && wrapper.hasStroke) {
+ element.removeAttribute('stroke');
+ wrapper.hasStroke = false;
+ }
+ skipAttr = true;
+ }
+
+ // symbols
+ if (wrapper.symbolName && /^(x|y|width|height|r|start|end|innerR|anchorX|anchorY)/.test(key)) {
+
+
+ if (!hasSetSymbolSize) {
+ wrapper.symbolAttr(hash);
+ hasSetSymbolSize = true;
+ }
+ skipAttr = true;
+ }
+
+ // let the shadow follow the main element
+ if (shadows && /^(width|height|visibility|x|y|d|transform|cx|cy|r)$/.test(key)) {
+ i = shadows.length;
+ while (i--) {
+ attr(
+ shadows[i],
+ key,
+ key === 'height' ?
+ mathMax(value - (shadows[i].cutHeight || 0), 0) :
+ value
+ );
+ }
+ }
+
+ // validate heights
+ if ((key === 'width' || key === 'height') && nodeName === 'rect' && value < 0) {
+ value = 0;
+ }
+
+ // Record for animation and quick access without polling the DOM
+ wrapper[key] = value;
+
+
+ if (key === 'text') {
+ // Delete bBox memo when the text changes
+ if (value !== wrapper.textStr) {
+ delete wrapper.bBox;
+ }
+ wrapper.textStr = value;
+ if (wrapper.added) {
+ renderer.buildText(wrapper);
+ }
+ } else if (!skipAttr) {
+ attr(element, key, value);
+ }
+
+ }
+
+ }
+
+ // Update transform. Do this outside the loop to prevent redundant updating for batch setting
+ // of attributes.
+ if (doTransform) {
+ wrapper.updateTransform();
+ }
+
+ }
+
+ return ret;
+ },
+
+
+ /**
+ * 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 (strokeWidth, x, y, width, height) {
+
+ var wrapper = this,
+ key,
+ attribs = {},
+ values = {},
+ normalizer;
+
+ strokeWidth = strokeWidth || wrapper.strokeWidth || (wrapper.attr && wrapper.attr('stroke-width')) || 0;
+ normalizer = mathRound(strokeWidth) % 2 / 2; // mathRound because strokeWidth can sometimes have roundoff errors
+
+ // normalize for crisp edges
+ values.x = mathFloor(x || wrapper.x || 0) + normalizer;
+ values.y = mathFloor(y || wrapper.y || 0) + normalizer;
+ values.width = mathFloor((width || wrapper.width || 0) - 2 * normalizer);
+ values.height = mathFloor((height || wrapper.height || 0) - 2 * normalizer);
+ values.strokeWidth = strokeWidth;
+
+ for (key in values) {
+ if (wrapper[key] !== values[key]) { // only set attribute if changed
+ wrapper[key] = attribs[key] = values[key];
+ }
+ }
+
+ return attribs;
+ },
+
+ /**
+ * Set styles for the element
+ * @param {Object} styles
+ */
+ css: function (styles) {
+ /*jslint unparam: true*//* allow unused param a in the regexp function below */
+ var elemWrapper = this,
+ elem = elemWrapper.element,
+ textWidth = styles && styles.width && elem.nodeName.toLowerCase() === 'text',
+ n,
+ serializedCss = '',
+ hyphenate = function (a, b) { return '-' + b.toLowerCase(); };
+ /*jslint unparam: false*/
+
+ // convert legacy
+ if (styles && styles.color) {
+ styles.fill = styles.color;
+ }
+
+ // Merge the new styles with the old ones
+ styles = extend(
+ elemWrapper.styles,
+ styles
+ );
+
+ // store object
+ elemWrapper.styles = styles;
+
+
+ // Don't handle line wrap on canvas
+ if (useCanVG && textWidth) {
+ delete styles.width;
+ }
+
+ // serialize and set style attribute
+ if (isIE && !hasSVG) { // legacy IE doesn't support setting style attribute
+ if (textWidth) {
+ delete styles.width;
+ }
+ css(elemWrapper.element, styles);
+ } else {
+ 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) {
+ this.element.radialReference = coordinates;
+ 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;
+ },
+
+ /**
+ * 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();
+ }
+
+ 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,
+ bBox = wrapper.bBox;
+
+ // faking getBBox in exported SVG in legacy IE
+ if (!bBox) {
+ // 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;
+ }
+
+ bBox = wrapper.bBox = {
+ x: element.offsetLeft,
+ y: element.offsetTop,
+ width: element.offsetWidth,
+ height: element.offsetHeight
+ };
+ }
+
+ return bBox;
+ },
+
+ /**
+ * 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],
+ nonLeft = align && align !== 'left',
+ shadows = wrapper.shadows;
+
+ // 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, height,
+ rotation = wrapper.rotation,
+ baseline,
+ radians = 0,
+ costheta = 1,
+ sintheta = 0,
+ quad,
+ textWidth = pInt(wrapper.textWidth),
+ xCorr = wrapper.xCorr || 0,
+ yCorr = wrapper.yCorr || 0,
+ currentTextTransform = [rotation, align, elem.innerHTML, wrapper.textWidth].join(',');
+
+ if (currentTextTransform !== wrapper.cTT) { // do the calculations and DOM access only if properties changed
+
+ if (defined(rotation)) {
+
+ radians = rotation * deg2rad; // deg to rad
+ costheta = mathCos(radians);
+ sintheta = mathSin(radians);
+
+ wrapper.setSpanRotation(rotation, sintheta, costheta);
+
+ }
+
+ width = pick(wrapper.elemWidth, elem.offsetWidth);
+ height = pick(wrapper.elemHeight, elem.offsetHeight);
+
+ // update textWidth
+ if (width > textWidth && /[ \-]/.test(elem.textContent || elem.innerText)) { // #983, #1254
+ css(elem, {
+ width: textWidth + PX,
+ display: 'block',
+ whiteSpace: 'normal'
+ });
+ width = textWidth;
+ }
+
+ // correct x and y
+ baseline = renderer.fontMetrics(elem.style.fontSize).b;
+ xCorr = costheta < 0 && -width;
+ yCorr = sintheta < 0 && -height;
+
+ // correct for baseline and corners spilling out after rotation
+ quad = costheta * sintheta < 0;
+ xCorr += sintheta * baseline * (quad ? 1 - alignCorrection : alignCorrection);
+ yCorr -= costheta * baseline * (rotation ? (quad ? alignCorrection : 1 - alignCorrection) : 1);
+
+ // correct for the length/height of the text
+ if (nonLeft) {
+ xCorr -= width * alignCorrection * (costheta < 0 ? -1 : 1);
+ if (rotation) {
+ yCorr -= height * alignCorrection * (sintheta < 0 ? -1 : 1);
+ }
+ css(elem, {
+ textAlign: align
+ });
+ }
+
+ // record correction
+ wrapper.xCorr = xCorr;
+ wrapper.yCorr = yCorr;
+ }
+
+ // apply position with correction
+ css(elem, {
+ left: (x + xCorr) + PX,
+ top: (y + yCorr) + PX
+ });
+
+ // force reflow in webkit to apply the left and top on useHTML element (#1249)
+ if (isWebKit) {
+ height = elem.offsetHeight; // assigned to height for JSLint purpose
+ }
+
+ // record current text transform
+ wrapper.cTT = currentTextTransform;
+ }
+ },
+
+ /**
+ * Set the rotation of an individual HTML span
+ */
+ setSpanRotation: function (rotation) {
+ var rotationStyle = {},
+ cssTransformKey = isIE ? '-ms-transform' : isWebKit ? '-webkit-transform' : isFirefox ? 'MozTransform' : isOpera ? '-o-transform' : '';
+
+ rotationStyle[cssTransformKey] = rotationStyle.transform = 'rotate(' + rotation + 'deg)';
+ css(this.element, rotationStyle);
+ },
+
+ /**
+ * 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,
+ 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 + ' ' + (wrapper.x || 0) + ' ' + (wrapper.y || 0) + ')');
+ }
+
+ // apply scale
+ if (defined(scaleX) || defined(scaleY)) {
+ transform.push('scale(' + pick(scaleX, 1) + ' ' + pick(scaleY, 1) + ')');
+ }
+
+ if (transform.length) {
+ attr(wrapper.element, '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 () {
+ var wrapper = this,
+ bBox = wrapper.bBox,
+ renderer = wrapper.renderer,
+ width,
+ height,
+ rotation = wrapper.rotation,
+ element = wrapper.element,
+ styles = wrapper.styles,
+ rad = rotation * deg2rad;
+
+ if (!bBox) {
+ // SVG elements
+ if (element.namespaceURI === SVG_NS || renderer.forExport) {
+ try { // Fails in Firefox if the container has display: 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
+ };
+ } 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)
+ if (isIE && styles && styles.fontSize === '11px' && height.toPrecision(3) === '22.7') {
+ 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));
+ }
+ }
+
+ wrapper.bBox = bBox;
+ }
+ return bBox;
+ },
+
+ /**
+ * Show the element
+ */
+ show: function () {
+ return this.attr({ visibility: 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.hide();
+ }
+ });
+ },
+
+ /**
+ * 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,
+ parentWrapper = parent || renderer,
+ parentNode = parentWrapper.element || renderer.box,
+ childNodes = parentNode.childNodes,
+ element = this.element,
+ zIndex = attr(element, 'zIndex'),
+ otherElement,
+ otherZIndex,
+ i,
+ 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 the container as having z indexed children
+ if (zIndex) {
+ parentWrapper.handleZ = true;
+ zIndex = pInt(zIndex);
+ }
+
+ // insert according to this and other elements' zIndex
+ if (parentWrapper.handleZ) { // this element or any of its siblings has a z index
+ for (i = 0; i < childNodes.length; i++) {
+ otherElement = childNodes[i];
+ otherZIndex = attr(otherElement, 'zIndex');
+ if (otherElement !== element && (
+ // insert before the first element with a higher zIndex
+ pInt(otherZIndex) > zIndex ||
+ // if no zIndex given, insert before the first element with a zIndex
+ (!defined(zIndex) && defined(otherZIndex))
+
+ )) {
+ parentNode.insertBefore(element, otherElement);
+ inserted = true;
+ break;
+ }
+ }
+ }
+
+ // default: append at the end
+ if (!inserted) {
+ parentNode.appendChild(element);
+ }
+
+ // mark as added
+ this.added = true;
+
+ // fire an event for internal hooks
+ fireEvent(this, 'add');
+
+ 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' && element.parentNode,
+ 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).
+ while (parentToClean && parentToClean.childNodes.length === 0) {
+ grandParent = parentToClean.parentNode;
+ wrapper.safeRemoveChild(parentToClean);
+ 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;
+
+ }
+};
+
+
+/**
+ * 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, forExport) {
+ var renderer = this,
+ loc = location,
+ boxWrapper,
+ element,
+ desc;
+
+ boxWrapper = renderer.createElement('svg')
+ .attr({
+ version: '1.1'
+ });
+ 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.forExport = forExport;
+ renderer.gradients = {}; // Object where gradient SvgElements are stored
+
+ 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);
+ }
+ },
+
+ /**
+ * 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 () {},
+
+ /**
+ * 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,
+ lines = pick(wrapper.textStr, '').toString()
+ .replace(/<(b|strong)>/g, '<span style="font-weight:bold">')
+ .replace(/<(i|em)>/g, '<span style="font-style:italic">')
+ .replace(/<a/g, '<span')
+ .replace(/<\/(b|strong|i|em|a)>/g, '</span>')
+ .split(/<br.*?>/g),
+ childNodes = textNode.childNodes,
+ styleRegex = /style="([^"]+)"/,
+ hrefRegex = /href="(http[^"]+)"/,
+ parentX = attr(textNode, 'x'),
+ textStyles = wrapper.styles,
+ width = textStyles && textStyles.width && pInt(textStyles.width),
+ textLineHeight = textStyles && textStyles.lineHeight,
+ i = childNodes.length;
+
+ /// remove old text
+ while (i--) {
+ textNode.removeChild(childNodes[i]);
+ }
+
+ if (width && !wrapper.added) {
+ this.box.appendChild(textNode); // attach it to the DOM to read offset width
+ }
+
+ // 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(/<span/g, '|||<span').replace(/<\/span>/g, '</span>|||');
+ 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 = (span.replace(/<(.|\n)*?>/g, '') || ' ')
+ .replace(/</g, '<')
+ .replace(/>/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
+ attributes.x = parentX;
+ } else {
+ attributes.dx = 0; // #16
+ }
+
+ // add attributes
+ attr(tspan, attributes);
+
+ // 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',
+ textLineHeight || renderer.fontMetrics(
+ /px$/.test(tspan.style.fontSize) ?
+ tspan.style.fontSize :
+ textStyles.fontSize
+ ).h,
+ // Safari 6.0.2 - too optimized for its own good (#1539)
+ // TODO: revisit this with future versions of Safari
+ isWebKit && tspan.offsetHeight
+ );
+ }
+
+ // Append it
+ textNode.appendChild(tspan);
+
+ spanNo++;
+
+ // check width and apply soft breaks
+ if (width) {
+ var words = span.replace(/([^\^])-/g, '$1- ').split(' '), // #1273
+ tooLong,
+ actualWidth,
+ clipHeight = wrapper._clipHeight,
+ rest = [],
+ dy = pInt(textLineHeight || 16),
+ softLineNo = 1,
+ bBox;
+
+ while (words.length || rest.length) {
+ delete wrapper.bBox; // delete cache
+ bBox = wrapper.getBBox();
+ actualWidth = bBox.width;
+ tooLong = actualWidth > width;
+ if (!tooLong || words.length === 1) { // new line needed
+ words = rest;
+ rest = [];
+ if (words.length) {
+ softLineNo++;
+
+ if (clipHeight && softLineNo * dy > clipHeight) {
+ words = ['...'];
+ wrapper.attr('title', wrapper.textStr);
+ } else {
+
+ 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, '-')));
+ }
+ }
+ }
+ }
+ }
+ });
+ });
+ },
+
+ /**
+ * 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) {
+ var label = this.label(text, x, y, null, null, null, null, null, 'button'),
+ curState = 0,
+ stateOptions,
+ stateStyle,
+ normalStyle,
+ hoverStyle,
+ pressedStyle,
+ disabledStyle,
+ STYLE = 'style',
+ 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, isIE ? 'mouseover' : 'mouseenter', function () {
+ if (curState !== 3) {
+ label.attr(hoverState)
+ .css(hoverStyle);
+ }
+ });
+ addEvent(label.element, isIE ? '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 () {
+ if (curState !== 3) {
+ callback.call(label);
+ }
+ })
+ .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
+ };
+
+ return this.createElement('circle').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').attr({
+ rx: r,
+ ry: r,
+ fill: NONE
+ });
+ return wrapper.attr(
+ isObject(x) ?
+ x :
+ // do not crispify when an object is passed in (as in column charts)
+ wrapper.crisp(strokeWidth, x, y, mathMax(width, 0), mathMax(height, 0))
+ );
+ },
+
+ /**
+ * 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];
+
+ // 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 () {
+ centerImage(obj, symbolSizes[imageSrc] = [this.width, this.height]);
+ },
+ 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
+ ];
+ }
+ },
+
+ /**
+ * 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;
+
+ return wrapper;
+ },
+
+
+ /**
+ * Take a color and return it if it's a string, make it a gradient if it's a
+ * gradient configuration object. Prior to Highstock, an array was used to define
+ * a linear gradient with pixel positions relative to the SVG. In newer versions
+ * we change the coordinates to apply relative to the shape, using coordinates
+ * 0-1 within the shape. To preserve backwards compatibility, linearGradient
+ * in this definition is an object of x1, y1, x2 and y2.
+ *
+ * @param {Object} color The color or config object
+ */
+ color: function (color, elem, prop) {
+ var renderer = this,
+ colorObject,
+ regexRgba = /^rgba/,
+ gradName,
+ gradAttr,
+ gradients,
+ gradientObject,
+ stops,
+ stopColor,
+ stopOpacity,
+ radialReference,
+ n,
+ id,
+ key = [];
+
+ // Apply linear or radial gradients
+ if (color && color.linearGradient) {
+ gradName = 'linearGradient';
+ } else if (color && 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)) {
+ gradAttr = merge(gradAttr, {
+ 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],
+ 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].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);
+
+
+ // The gradient needs to keep a list of stops to be able to destroy them
+ gradientObject.stops = [];
+ each(stops, function (stop) {
+ var stopObject;
+ if (regexRgba.test(stop[1])) {
+ 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);
+ });
+ }
+
+ // Return the reference to the gradient object
+ return 'url(' + renderer.url + '#' + id + ')';
+
+ // Webkit and Batik can't show rgba.
+ } else if (regexRgba.test(color)) {
+ colorObject = Color(color);
+ attr(elem, prop + '-opacity', colorObject.get('a'));
+
+ return colorObject.get('rgb');
+
+
+ } else {
+ // Remove the opacity attribute added above. Does not throw if the attribute is not there.
+ elem.removeAttribute(prop + '-opacity');
+
+ return color;
+ }
+
+ },
+
+
+ /**
+ * 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,
+ defaultChartStyle = defaultOptions.chart.style,
+ fakeSVG = useCanVG || (!hasSVG && renderer.forExport),
+ wrapper;
+
+ if (useHTML && !renderer.forExport) {
+ return renderer.html(str, x, y);
+ }
+
+ x = mathRound(pick(x, 0));
+ y = mathRound(pick(y, 0));
+
+ wrapper = renderer.createElement('text')
+ .attr({
+ x: x,
+ y: y,
+ text: str
+ })
+ .css({
+ fontFamily: defaultChartStyle.fontFamily,
+ fontSize: defaultChartStyle.fontSize
+ });
+
+ // Prevent wrapping from creating false offsetWidths in export in legacy IE (#1079, #1063)
+ if (fakeSVG) {
+ wrapper.css({
+ position: ABSOLUTE
+ });
+ }
+
+ wrapper.x = x;
+ wrapper.y = y;
+ return wrapper;
+ },
+
+
+ /**
+ * 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 defaultChartStyle = defaultOptions.chart.style,
+ wrapper = this.createElement('span'),
+ attrSetters = wrapper.attrSetters,
+ element = wrapper.element,
+ renderer = wrapper.renderer;
+
+ // Text setter
+ attrSetters.text = function (value) {
+ if (value !== element.innerHTML) {
+ delete this.bBox;
+ }
+ element.innerHTML = value;
+ return false;
+ };
+
+ // Various setters which rely on update transform
+ attrSetters.x = attrSetters.y = attrSetters.align = function (value, key) {
+ if (key === 'align') {
+ key = 'textAlign'; // Do not overwrite the SVGElement.align method. Same as VML.
+ }
+ wrapper[key] = value;
+ wrapper.htmlUpdateTransform();
+ return false;
+ };
+
+ // Set the default attributes
+ wrapper.attr({
+ text: str,
+ x: mathRound(x),
+ y: mathRound(y)
+ })
+ .css({
+ position: ABSOLUTE,
+ whiteSpace: 'nowrap',
+ fontFamily: defaultChartStyle.fontFamily,
+ fontSize: defaultChartStyle.fontSize
+ });
+
+ // 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 = [];
+
+ // 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;
+
+ // Create a HTML div and append it to the parent div to emulate
+ // the SVG group structure
+ htmlGroup = parentGroup.div = parentGroup.div || createElement(DIV, {
+ className: attr(parentGroup.element, 'class')
+ }, {
+ 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.attrSetters, {
+ translateX: function (value) {
+ htmlGroupStyle.left = value + PX;
+ },
+ translateY: function (value) {
+ htmlGroupStyle.top = value + PX;
+ },
+ visibility: function (value, key) {
+ htmlGroupStyle[key] = value;
+ }
+ });
+ });
+
+ }
+ } else {
+ htmlGroup = container;
+ }
+
+ htmlGroup.appendChild(element);
+
+ // Shared with VML:
+ wrapper.added = true;
+ if (wrapper.alignOnAdd) {
+ wrapper.htmlUpdateTransform();
+ }
+
+ return wrapper;
+ };
+ }
+ return wrapper;
+ },
+
+ /**
+ * Utility to return the baseline offset and total line height from the font size
+ */
+ fontMetrics: function (fontSize) {
+ fontSize = pInt(fontSize || 11);
+
+ // Empirical values found by comparing font size and bounding box height.
+ // Applies to the default font family. http://jsfiddle.net/highcharts/7xvn7/
+ var lineHeight = fontSize < 24 ? fontSize + 4 : mathRound(fontSize * 1.2),
+ baseline = mathRound(lineHeight * 0.8);
+
+ return {
+ h: lineHeight,
+ b: baseline
+ };
+ },
+
+ /**
+ * 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,
+ attrSetters = wrapper.attrSetters,
+ 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) &&
+ text.getBBox();
+ 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).b;
+
+ if (needsBox) {
+
+ // create the border box if it is not already present
+ if (!box) {
+ boxX = mathRound(-alignFactor * padding);
+ boxY = baseline ? -baselineOffset : 0;
+
+ wrapper.box = box = shape ?
+ renderer.symbol(shape, boxX, boxY, wrapper.width, wrapper.height) :
+ renderer.rect(boxX, boxY, wrapper.width, wrapper.height, 0, deferredAttr[STROKE_WIDTH]);
+ box.add(wrapper);
+ }
+
+ // apply the box attributes
+ if (!box.isImg) { // #1630
+ box.attr(merge({
+ width: wrapper.width,
+ height: 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) && (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,
+ 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;
+ }
+ }
+
+ function getSizeAfterAdd() {
+ text.add(wrapper);
+ wrapper.attr({
+ text: str, // alignment is available now
+ x: x,
+ y: y
+ });
+
+ if (box && defined(anchorX)) {
+ wrapper.attr({
+ anchorX: anchorX,
+ anchorY: anchorY
+ });
+ }
+ }
+
+ /**
+ * After the text element is added, get the desired size of the border box
+ * and add it before the text in the DOM.
+ */
+ addEvent(wrapper, 'add', getSizeAfterAdd);
+
+ /*
+ * Add specific attribute setters.
+ */
+
+ // only change local variables
+ attrSetters.width = function (value) {
+ width = value;
+ return false;
+ };
+ attrSetters.height = function (value) {
+ height = value;
+ return false;
+ };
+ attrSetters.padding = function (value) {
+ if (defined(value) && value !== padding) {
+ padding = value;
+ updateTextPadding();
+ }
+ return false;
+ };
+ attrSetters.paddingLeft = function (value) {
+ if (defined(value) && value !== paddingLeft) {
+ paddingLeft = value;
+ updateTextPadding();
+ }
+ return false;
+ };
+
+
+ // change local variable and set attribue as well
+ attrSetters.align = function (value) {
+ alignFactor = { left: 0, center: 0.5, right: 1 }[value];
+ return false; // prevent setting text-anchor on the group
+ };
+
+ // apply these to the box and the text alike
+ attrSetters.text = function (value, key) {
+ text.attr(key, value);
+ updateBoxSize();
+ updateTextPadding();
+ return false;
+ };
+
+ // apply these to the box but not to the text
+ attrSetters[STROKE_WIDTH] = function (value, key) {
+ needsBox = true;
+ crispAdjust = value % 2 / 2;
+ boxAttr(key, value);
+ return false;
+ };
+ attrSetters.stroke = attrSetters.fill = attrSetters.r = function (value, key) {
+ if (key === 'fill') {
+ needsBox = true;
+ }
+ boxAttr(key, value);
+ return false;
+ };
+ attrSetters.anchorX = function (value, key) {
+ anchorX = value;
+ boxAttr(key, value + crispAdjust - wrapperX);
+ return false;
+ };
+ attrSetters.anchorY = function (value, key) {
+ anchorY = value;
+ boxAttr(key, value - wrapperY);
+ return false;
+ };
+
+ // rename attributes
+ attrSetters.x = function (value) {
+ wrapper.x = value; // for animation getter
+ value -= alignFactor * ((width || bBox.width) + padding);
+ wrapperX = mathRound(value);
+
+ wrapper.attr('translateX', wrapperX);
+ return false;
+ };
+ attrSetters.y = function (value) {
+ wrapperY = wrapper.y = mathRound(value);
+ wrapper.attr('translateY', wrapperY);
+ return false;
+ };
+
+ // 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(['fontSize', 'fontWeight', 'fontFamily', 'color', 'lineHeight', 'width', 'textDecoration', 'textShadow'], 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 () {
+ removeEvent(wrapper, 'add', getSizeAfterAdd);
+
+ // 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 = getSizeAfterAdd = null;
+ }
+ });
+ }
+}; // end SVGRenderer
+
+
+// general renderer
+Renderer = SVGRenderer;
+
+
+/* ****************************************************************************
+ * *
+ * START OF INTERNET EXPLORER <= 8 SPECIFIC CODE *
+ * *
+ * For applications and websites that don't need IE support, like platform *
+ * targeted mobile apps and web apps, this code can be removed. *
+ * *
+ *****************************************************************************/
+
+/**
+ * @constructor
+ */
+var VMLRenderer, VMLElement;
+if (!hasSVG && !useCanVG) {
+
+/**
+ * The VML element wrapper.
+ */
+Highcharts.VMLElement = VMLElement = {
+
+ /**
+ * Initialize a new VML element wrapper. It builds the markup as a string
+ * to minimize DOM traffic.
+ * @param {Object} renderer
+ * @param {Object} nodeName
+ */
+ init: function (renderer, nodeName) {
+ var wrapper = this,
+ markup = ['<', nodeName, ' filled="f" stroked="f"'],
+ style = ['position: ', ABSOLUTE, ';'],
+ isDiv = nodeName === DIV;
+
+ // divs and shapes need size
+ if (nodeName === 'shape' || isDiv) {
+ style.push('left:0;top:0;width:1px;height:1px;');
+ }
+ style.push('visibility: ', isDiv ? HIDDEN : VISIBLE);
+
+ markup.push(' style="', style.join(''), '"/>');
+
+ // create element with default attributes and style
+ if (nodeName) {
+ markup = isDiv || nodeName === 'span' || nodeName === 'img' ?
+ markup.join('')
+ : renderer.prepVML(markup);
+ wrapper.element = createElement(markup);
+ }
+
+ wrapper.renderer = renderer;
+ wrapper.attrSetters = {};
+ },
+
+ /**
+ * Add the node to the given parent
+ * @param {Object} parent
+ */
+ add: function (parent) {
+ var wrapper = this,
+ renderer = wrapper.renderer,
+ element = wrapper.element,
+ box = renderer.box,
+ inverted = parent && parent.inverted,
+
+ // get the parent node
+ parentNode = parent ?
+ parent.element || parent :
+ box;
+
+
+ // if the parent group is inverted, apply inversion on all children
+ if (inverted) { // only on groups
+ renderer.invertChild(element, parentNode);
+ }
+
+ // append it
+ parentNode.appendChild(element);
+
+ // align text after adding to be able to read offset
+ wrapper.added = true;
+ if (wrapper.alignOnAdd && !wrapper.deferUpdateTransform) {
+ wrapper.updateTransform();
+ }
+
+ // fire an event for internal hooks
+ fireEvent(wrapper, 'add');
+
+ return wrapper;
+ },
+
+ /**
+ * VML always uses htmlUpdateTransform
+ */
+ updateTransform: SVGElement.prototype.htmlUpdateTransform,
+
+ /**
+ * Set the rotation of a span with oldIE's filter
+ */
+ setSpanRotation: function (rotation, sintheta, costheta) {
+ // Adjust for alignment and rotation. Rotation of useHTML content is not yet implemented
+ // but it can probably be implemented for Firefox 3.5+ on user request. FF3.5+
+ // has support for CSS3 transform. The getBBox method also needs to be updated
+ // to compensate for the rotation, like it currently does for SVG.
+ // Test case: http://highcharts.com/tests/?file=text-rotation
+ css(this.element, {
+ filter: rotation ? ['progid:DXImageTransform.Microsoft.Matrix(M11=', costheta,
+ ', M12=', -sintheta, ', M21=', sintheta, ', M22=', costheta,
+ ', sizingMethod=\'auto expand\')'].join('') : NONE
+ });
+ },
+
+ /**
+ * Converts a subset of an SVG path definition to its VML counterpart. Takes an array
+ * as the parameter and returns a string.
+ */
+ pathToVML: function (value) {
+ // convert paths
+ var i = value.length,
+ path = [],
+ clockwise;
+
+ while (i--) {
+
+ // Multiply by 10 to allow subpixel precision.
+ // Substracting half a pixel seems to make the coordinates
+ // align with SVG, but this hasn't been tested thoroughly
+ if (isNumber(value[i])) {
+ path[i] = mathRound(value[i] * 10) - 5;
+ } else if (value[i] === 'Z') { // close the path
+ path[i] = 'x';
+ } else {
+ path[i] = value[i];
+
+ // When the start X and end X coordinates of an arc are too close,
+ // they are rounded to the same value above. In this case, substract 1 from the end X
+ // position. #760, #1371.
+ if (value.isArc && (value[i] === 'wa' || value[i] === 'at')) {
+ clockwise = value[i] === 'wa' ? 1 : -1; // #1642
+ if (path[i + 5] === path[i + 7]) {
+ path[i + 7] -= clockwise;
+ }
+ // Start and end Y (#1410)
+ if (path[i + 6] === path[i + 8]) {
+ path[i + 8] -= clockwise;
+ }
+ }
+ }
+ }
+ // Loop up again to handle path shortcuts (#2132)
+ /*while (i++ < path.length) {
+ if (path[i] === 'H') { // horizontal line to
+ path[i] = 'L';
+ path.splice(i + 2, 0, path[i - 1]);
+ } else if (path[i] === 'V') { // vertical line to
+ path[i] = 'L';
+ path.splice(i + 1, 0, path[i - 2]);
+ }
+ }*/
+ return path.join(' ') || 'x';
+ },
+
+ /**
+ * Get or set attributes
+ */
+ attr: function (hash, val) {
+ var wrapper = this,
+ key,
+ value,
+ i,
+ result,
+ element = wrapper.element || {},
+ elemStyle = element.style,
+ nodeName = element.nodeName,
+ renderer = wrapper.renderer,
+ symbolName = wrapper.symbolName,
+ hasSetSymbolSize,
+ shadows = wrapper.shadows,
+ skipAttr,
+ attrSetters = wrapper.attrSetters,
+ ret = wrapper;
+
+ // single key-value pair
+ if (isString(hash) && defined(val)) {
+ key = hash;
+ hash = {};
+ hash[key] = val;
+ }
+
+ // used as a getter, val is undefined
+ if (isString(hash)) {
+ key = hash;
+ if (key === 'strokeWidth' || key === 'stroke-width') {
+ ret = wrapper.strokeweight;
+ } else {
+ ret = wrapper[key];
+ }
+
+ // setter
+ } else {
+ for (key in hash) {
+ value = hash[key];
+ skipAttr = false;
+
+ // check for a specific attribute setter
+ result = attrSetters[key] && attrSetters[key].call(wrapper, value, key);
+
+ if (result !== false && value !== null) { // #620
+
+ if (result !== UNDEFINED) {
+ value = result; // the attribute setter has returned a new value to set
+ }
+
+
+ // prepare paths
+ // symbols
+ if (symbolName && /^(x|y|r|start|end|width|height|innerR|anchorX|anchorY)/.test(key)) {
+ // 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
+ if (!hasSetSymbolSize) {
+ wrapper.symbolAttr(hash);
+
+ hasSetSymbolSize = true;
+ }
+ skipAttr = true;
+
+ } else if (key === 'd') {
+ value = value || [];
+ wrapper.d = value.join(' '); // used in getter for animation
+
+ element.path = value = wrapper.pathToVML(value);
+
+ // update shadows
+ if (shadows) {
+ i = shadows.length;
+ while (i--) {
+ shadows[i].path = shadows[i].cutOff ? this.cutOffPath(value, shadows[i].cutOff) : value;
+ }
+ }
+ skipAttr = true;
+
+ // handle visibility
+ } else if (key === 'visibility') {
+
+ // let the shadow follow the main element
+ if (shadows) {
+ i = shadows.length;
+ while (i--) {
+ shadows[i].style[key] = value;
+ }
+ }
+
+ // Instead of toggling the visibility CSS property, move the div out of the viewport.
+ // This works around #61 and #586
+ if (nodeName === 'DIV') {
+ value = value === HIDDEN ? '-999em' : 0;
+
+ // In order to redraw, IE7 needs the div to be visible when tucked away
+ // outside the viewport. So the visibility is actually opposite of
+ // the expected value. This applies to the tooltip only.
+ if (!docMode8) {
+ elemStyle[key] = value ? VISIBLE : HIDDEN;
+ }
+ key = 'top';
+ }
+ elemStyle[key] = value;
+ skipAttr = true;
+
+ // directly mapped to css
+ } else if (key === 'zIndex') {
+
+ if (value) {
+ elemStyle[key] = value;
+ }
+ skipAttr = true;
+
+ // x, y, width, height
+ } else if (inArray(key, ['x', 'y', 'width', 'height']) !== -1) {
+
+ wrapper[key] = value; // used in getter
+
+ if (key === 'x' || key === 'y') {
+ key = { x: 'left', y: 'top' }[key];
+ } else {
+ value = mathMax(0, value); // don't set width or height below zero (#311)
+ }
+
+ // clipping rectangle special
+ if (wrapper.updateClipping) {
+ wrapper[key] = value; // the key is now 'left' or 'top' for 'x' and 'y'
+ wrapper.updateClipping();
+ } else {
+ // normal
+ elemStyle[key] = value;
+ }
+
+ skipAttr = true;
+
+ // class name
+ } else if (key === 'class' && nodeName === 'DIV') {
+ // IE8 Standards mode has problems retrieving the className
+ element.className = value;
+
+ // stroke
+ } else if (key === 'stroke') {
+
+ value = renderer.color(value, element, key);
+
+ key = 'strokecolor';
+
+ // stroke width
+ } else if (key === 'stroke-width' || key === 'strokeWidth') {
+ element.stroked = value ? true : false;
+ key = 'strokeweight';
+ wrapper[key] = value; // used in getter, issue #113
+ if (isNumber(value)) {
+ value += PX;
+ }
+
+ // dashStyle
+ } else if (key === 'dashstyle') {
+ var strokeElem = element.getElementsByTagName('stroke')[0] ||
+ createElement(renderer.prepVML(['<stroke/>']), null, null, element);
+ strokeElem[key] = value || 'solid';
+ wrapper.dashstyle = value; /* because changing stroke-width will change the dash length
+ and cause an epileptic effect */
+ skipAttr = true;
+
+ // fill
+ } else if (key === 'fill') {
+
+ if (nodeName === 'SPAN') { // text color
+ elemStyle.color = value;
+ } else if (nodeName !== 'IMG') { // #1336
+ element.filled = value !== NONE ? true : false;
+
+ value = renderer.color(value, element, key, wrapper);
+
+ key = 'fillcolor';
+ }
+
+ // opacity: don't bother - animation is too slow and filters introduce artifacts
+ } else if (key === 'opacity') {
+ /*css(element, {
+ opacity: value
+ });*/
+ skipAttr = true;
+
+ // rotation on VML elements
+ } else if (nodeName === 'shape' && key === 'rotation') {
+
+ wrapper[key] = element.style[key] = value; // style is for #1873
+
+ // Correction for the 1x1 size of the shape container. Used in gauge needles.
+ element.style.left = -mathRound(mathSin(value * deg2rad) + 1) + PX;
+ element.style.top = mathRound(mathCos(value * deg2rad)) + PX;
+
+ // translation for animation
+ } else if (key === 'translateX' || key === 'translateY' || key === 'rotation') {
+ wrapper[key] = value;
+ wrapper.updateTransform();
+
+ skipAttr = true;
+
+ // text for rotated and non-rotated elements
+ } else if (key === 'text') {
+ this.bBox = null;
+ element.innerHTML = value;
+ skipAttr = true;
+ }
+
+
+ if (!skipAttr) {
+ if (docMode8) { // IE8 setAttribute bug
+ element[key] = value;
+ } else {
+ attr(element, key, value);
+ }
+ }
+
+ }
+ }
+ }
+ return ret;
+ },
+
+ /**
+ * Set the element's clipping to a predefined rectangle
+ *
+ * @param {String} id The id of the clip rectangle
+ */
+ clip: function (clipRect) {
+ var wrapper = this,
+ clipMembers,
+ cssRet;
+
+ if (clipRect) {
+ clipMembers = clipRect.members;
+ erase(clipMembers, wrapper); // Ensure unique list of elements (#1258)
+ clipMembers.push(wrapper);
+ wrapper.destroyClip = function () {
+ erase(clipMembers, wrapper);
+ };
+ cssRet = clipRect.getCSS(wrapper);
+
+ } else {
+ if (wrapper.destroyClip) {
+ wrapper.destroyClip();
+ }
+ cssRet = { clip: docMode8 ? 'inherit' : 'rect(auto)' }; // #1214
+ }
+
+ return wrapper.css(cssRet);
+
+ },
+
+ /**
+ * Set styles for the element
+ * @param {Object} styles
+ */
+ css: SVGElement.prototype.htmlCss,
+
+ /**
+ * 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) {
+ // discardElement will detach the node from its parent before attaching it
+ // to the garbage bin. Therefore it is important that the node is attached and have parent.
+ if (element.parentNode) {
+ discardElement(element);
+ }
+ },
+
+ /**
+ * Extend element.destroy by removing it from the clip members array
+ */
+ destroy: function () {
+ if (this.destroyClip) {
+ this.destroyClip();
+ }
+
+ return SVGElement.prototype.destroy.apply(this);
+ },
+
+ /**
+ * Add an event listener. VML override for normalizing event parameters.
+ * @param {String} eventType
+ * @param {Function} handler
+ */
+ on: function (eventType, handler) {
+ // simplest possible event model for internal use
+ this.element['on' + eventType] = function () {
+ var evt = win.event;
+ evt.target = evt.srcElement;
+ handler(evt);
+ };
+ return this;
+ },
+
+ /**
+ * In stacked columns, cut off the shadows so that they don't overlap
+ */
+ cutOffPath: function (path, length) {
+
+ var len;
+
+ path = path.split(/[ ,]/);
+ len = path.length;
+
+ if (len === 9 || len === 11) {
+ path[len - 4] = path[len - 2] = pInt(path[len - 2]) - 10 * length;
+ }
+ return path.join(' ');
+ },
+
+ /**
+ * Apply a drop shadow by copying elements and giving them different strokes
+ * @param {Boolean|Object} shadowOptions
+ */
+ shadow: function (shadowOptions, group, cutOff) {
+ var shadows = [],
+ i,
+ element = this.element,
+ renderer = this.renderer,
+ shadow,
+ elemStyle = element.style,
+ markup,
+ path = element.path,
+ strokeWidth,
+ modifiedPath,
+ shadowWidth,
+ shadowElementOpacity;
+
+ // some times empty paths are not strings
+ if (path && typeof path.value !== 'string') {
+ path = 'x';
+ }
+ modifiedPath = path;
+
+ if (shadowOptions) {
+ shadowWidth = pick(shadowOptions.width, 3);
+ shadowElementOpacity = (shadowOptions.opacity || 0.15) / shadowWidth;
+ for (i = 1; i <= 3; i++) {
+
+ strokeWidth = (shadowWidth * 2) + 1 - (2 * i);
+
+ // Cut off shadows for stacked column items
+ if (cutOff) {
+ modifiedPath = this.cutOffPath(path.value, strokeWidth + 0.5);
+ }
+
+ markup = ['<shape isShadow="true" strokeweight="', strokeWidth,
+ '" filled="false" path="', modifiedPath,
+ '" coordsize="10 10" style="', element.style.cssText, '" />'];
+
+ shadow = createElement(renderer.prepVML(markup),
+ null, {
+ left: pInt(elemStyle.left) + pick(shadowOptions.offsetX, 1),
+ top: pInt(elemStyle.top) + pick(shadowOptions.offsetY, 1)
+ }
+ );
+ if (cutOff) {
+ shadow.cutOff = strokeWidth + 1;
+ }
+
+ // apply the opacity
+ markup = ['<stroke color="', shadowOptions.color || 'black', '" opacity="', shadowElementOpacity * i, '"/>'];
+ createElement(renderer.prepVML(markup), null, null, shadow);
+
+
+ // insert it
+ if (group) {
+ group.element.appendChild(shadow);
+ } else {
+ element.parentNode.insertBefore(shadow, element);
+ }
+
+ // record it
+ shadows.push(shadow);
+
+ }
+
+ this.shadows = shadows;
+ }
+ return this;
+
+ }
+};
+VMLElement = extendClass(SVGElement, VMLElement);
+
+/**
+ * The VML renderer
+ */
+var VMLRendererExtension = { // inherit SVGRenderer
+
+ Element: VMLElement,
+ isIE8: userAgent.indexOf('MSIE 8.0') > -1,
+
+
+ /**
+ * Initialize the VMLRenderer
+ * @param {Object} container
+ * @param {Number} width
+ * @param {Number} height
+ */
+ init: function (container, width, height) {
+ var renderer = this,
+ boxWrapper,
+ box;
+
+ renderer.alignedObjects = [];
+
+ boxWrapper = renderer.createElement(DIV);
+ box = boxWrapper.element;
+ box.style.position = RELATIVE; // for freeform drawing using renderer directly
+ container.appendChild(boxWrapper.element);
+
+
+ // generate the containing box
+ renderer.isVML = true;
+ renderer.box = box;
+ renderer.boxWrapper = boxWrapper;
+
+
+ renderer.setSize(width, height, false);
+
+ // The only way to make IE6 and IE7 print is to use a global namespace. However,
+ // with IE8 the only way to make the dynamic shapes visible in screen and print mode
+ // seems to be to add the xmlns attribute and the behaviour style inline.
+ if (!doc.namespaces.hcv) {
+
+ doc.namespaces.add('hcv', 'urn:schemas-microsoft-com:vml');
+
+ // Setup default CSS (#2153)
+ (doc.styleSheets.length ? doc.styleSheets[0] : doc.createStyleSheet()).cssText +=
+ 'hcv\\:fill, hcv\\:path, hcv\\:shape, hcv\\:stroke' +
+ '{ behavior:url(#default#VML); display: inline-block; } ';
+
+ }
+ },
+
+
+ /**
+ * Detect whether the renderer is hidden. This happens when one of the parent elements
+ * has display: none
+ */
+ isHidden: function () {
+ return !this.box.offsetWidth;
+ },
+
+ /**
+ * Define a clipping rectangle. In VML it is accomplished by storing the values
+ * for setting the CSS style to all associated members.
+ *
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} width
+ * @param {Number} height
+ */
+ clipRect: function (x, y, width, height) {
+
+ // create a dummy element
+ var clipRect = this.createElement(),
+ isObj = isObject(x);
+
+ // mimic a rectangle with its style object for automatic updating in attr
+ return extend(clipRect, {
+ members: [],
+ left: (isObj ? x.x : x) + 1,
+ top: (isObj ? x.y : y) + 1,
+ width: (isObj ? x.width : width) - 1,
+ height: (isObj ? x.height : height) - 1,
+ getCSS: function (wrapper) {
+ var element = wrapper.element,
+ nodeName = element.nodeName,
+ isShape = nodeName === 'shape',
+ inverted = wrapper.inverted,
+ rect = this,
+ top = rect.top - (isShape ? element.offsetTop : 0),
+ left = rect.left,
+ right = left + rect.width,
+ bottom = top + rect.height,
+ ret = {
+ clip: 'rect(' +
+ mathRound(inverted ? left : top) + 'px,' +
+ mathRound(inverted ? bottom : right) + 'px,' +
+ mathRound(inverted ? right : bottom) + 'px,' +
+ mathRound(inverted ? top : left) + 'px)'
+ };
+
+ // issue 74 workaround
+ if (!inverted && docMode8 && nodeName === 'DIV') {
+ extend(ret, {
+ width: right + PX,
+ height: bottom + PX
+ });
+ }
+ return ret;
+ },
+
+ // used in attr and animation to update the clipping of all members
+ updateClipping: function () {
+ each(clipRect.members, function (member) {
+ member.css(clipRect.getCSS(member));
+ });
+ }
+ });
+
+ },
+
+
+ /**
+ * Take a color and return it if it's a string, make it a gradient if it's a
+ * gradient configuration object, and apply opacity.
+ *
+ * @param {Object} color The color or config object
+ */
+ color: function (color, elem, prop, wrapper) {
+ var renderer = this,
+ colorObject,
+ regexRgba = /^rgba/,
+ markup,
+ fillType,
+ ret = NONE;
+
+ // Check for linear or radial gradient
+ if (color && color.linearGradient) {
+ fillType = 'gradient';
+ } else if (color && color.radialGradient) {
+ fillType = 'pattern';
+ }
+
+
+ if (fillType) {
+
+ var stopColor,
+ stopOpacity,
+ gradient = color.linearGradient || color.radialGradient,
+ x1,
+ y1,
+ x2,
+ y2,
+ opacity1,
+ opacity2,
+ color1,
+ color2,
+ fillAttr = '',
+ stops = color.stops,
+ firstStop,
+ lastStop,
+ colors = [],
+ addFillNode = function () {
+ // Add the fill subnode. When colors attribute is used, the meanings of opacity and o:opacity2
+ // are reversed.
+ markup = ['<fill colors="' + colors.join(',') + '" opacity="', opacity2, '" o:opacity2="', opacity1,
+ '" type="', fillType, '" ', fillAttr, 'focus="100%" method="any" />'];
+ createElement(renderer.prepVML(markup), null, null, elem);
+ };
+
+ // Extend from 0 to 1
+ firstStop = stops[0];
+ lastStop = stops[stops.length - 1];
+ if (firstStop[0] > 0) {
+ stops.unshift([
+ 0,
+ firstStop[1]
+ ]);
+ }
+ if (lastStop[0] < 1) {
+ stops.push([
+ 1,
+ lastStop[1]
+ ]);
+ }
+
+ // Compute the stops
+ each(stops, function (stop, i) {
+ if (regexRgba.test(stop[1])) {
+ colorObject = Color(stop[1]);
+ stopColor = colorObject.get('rgb');
+ stopOpacity = colorObject.get('a');
+ } else {
+ stopColor = stop[1];
+ stopOpacity = 1;
+ }
+
+ // Build the color attribute
+ colors.push((stop[0] * 100) + '% ' + stopColor);
+
+ // Only start and end opacities are allowed, so we use the first and the last
+ if (!i) {
+ opacity1 = stopOpacity;
+ color2 = stopColor;
+ } else {
+ opacity2 = stopOpacity;
+ color1 = stopColor;
+ }
+ });
+
+ // Apply the gradient to fills only.
+ if (prop === 'fill') {
+
+ // Handle linear gradient angle
+ if (fillType === 'gradient') {
+ x1 = gradient.x1 || gradient[0] || 0;
+ y1 = gradient.y1 || gradient[1] || 0;
+ x2 = gradient.x2 || gradient[2] || 0;
+ y2 = gradient.y2 || gradient[3] || 0;
+ fillAttr = 'angle="' + (90 - math.atan(
+ (y2 - y1) / // y vector
+ (x2 - x1) // x vector
+ ) * 180 / mathPI) + '"';
+
+ addFillNode();
+
+ // Radial (circular) gradient
+ } else {
+
+ var r = gradient.r,
+ sizex = r * 2,
+ sizey = r * 2,
+ cx = gradient.cx,
+ cy = gradient.cy,
+ radialReference = elem.radialReference,
+ bBox,
+ applyRadialGradient = function () {
+ if (radialReference) {
+ bBox = wrapper.getBBox();
+ cx += (radialReference[0] - bBox.x) / bBox.width - 0.5;
+ cy += (radialReference[1] - bBox.y) / bBox.height - 0.5;
+ sizex *= radialReference[2] / bBox.width;
+ sizey *= radialReference[2] / bBox.height;
+ }
+ fillAttr = 'src="' + defaultOptions.global.VMLRadialGradientURL + '" ' +
+ 'size="' + sizex + ',' + sizey + '" ' +
+ 'origin="0.5,0.5" ' +
+ 'position="' + cx + ',' + cy + '" ' +
+ 'color2="' + color2 + '" ';
+
+ addFillNode();
+ };
+
+ // Apply radial gradient
+ if (wrapper.added) {
+ applyRadialGradient();
+ } else {
+ // We need to know the bounding box to get the size and position right
+ addEvent(wrapper, 'add', applyRadialGradient);
+ }
+
+ // The fill element's color attribute is broken in IE8 standards mode, so we
+ // need to set the parent shape's fillcolor attribute instead.
+ ret = color1;
+ }
+
+ // Gradients are not supported for VML stroke, return the first color. #722.
+ } else {
+ ret = stopColor;
+ }
+
+ // if the color is an rgba color, split it and add a fill node
+ // to hold the opacity component
+ } else if (regexRgba.test(color) && elem.tagName !== 'IMG') {
+
+ colorObject = Color(color);
+
+ markup = ['<', prop, ' opacity="', colorObject.get('a'), '"/>'];
+ createElement(this.prepVML(markup), null, null, elem);
+
+ ret = colorObject.get('rgb');
+
+
+ } else {
+ var propNodes = elem.getElementsByTagName(prop); // 'stroke' or 'fill' node
+ if (propNodes.length) {
+ propNodes[0].opacity = 1;
+ propNodes[0].type = 'solid';
+ }
+ ret = color;
+ }
+
+ return ret;
+ },
+
+ /**
+ * Take a VML string and prepare it for either IE8 or IE6/IE7.
+ * @param {Array} markup A string array of the VML markup to prepare
+ */
+ prepVML: function (markup) {
+ var vmlStyle = 'display:inline-block;behavior:url(#default#VML);',
+ isIE8 = this.isIE8;
+
+ markup = markup.join('');
+
+ if (isIE8) { // add xmlns and style inline
+ markup = markup.replace('/>', ' xmlns="urn:schemas-microsoft-com:vml" />');
+ if (markup.indexOf('style="') === -1) {
+ markup = markup.replace('/>', ' style="' + vmlStyle + '" />');
+ } else {
+ markup = markup.replace('style="', 'style="' + vmlStyle);
+ }
+
+ } else { // add namespace
+ markup = markup.replace('<', '<hcv:');
+ }
+
+ return markup;
+ },
+
+ /**
+ * Create rotated and aligned text
+ * @param {String} str
+ * @param {Number} x
+ * @param {Number} y
+ */
+ text: SVGRenderer.prototype.html,
+
+ /**
+ * Create and return a path element
+ * @param {Array} path
+ */
+ path: function (path) {
+ var attr = {
+ // subpixel precision down to 0.1 (width and height = 1px)
+ coordsize: '10 10'
+ };
+ if (isArray(path)) {
+ attr.d = path;
+ } else if (isObject(path)) { // attributes
+ extend(attr, path);
+ }
+ // create the shape
+ return this.createElement('shape').attr(attr);
+ },
+
+ /**
+ * Create and return a circle element. In VML circles are implemented as
+ * shapes, which is faster than v:oval
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} r
+ */
+ circle: function (x, y, r) {
+ var circle = this.symbol('circle');
+ if (isObject(x)) {
+ r = x.r;
+ y = x.y;
+ x = x.x;
+ }
+ circle.isCircle = true; // Causes x and y to mean center (#1682)
+ circle.r = r;
+ return circle.attr({ x: x, y: y });
+ },
+
+ /**
+ * Create a group using an outer div and an inner v:group to allow rotating
+ * and flipping. A simple v:group would have problems with positioning
+ * child HTML elements and CSS clip.
+ *
+ * @param {String} name The name of the group
+ */
+ g: function (name) {
+ var wrapper,
+ attribs;
+
+ // set the class name
+ if (name) {
+ attribs = { 'className': PREFIX + name, 'class': PREFIX + name };
+ }
+
+ // the div to hold HTML and clipping
+ wrapper = this.createElement(DIV).attr(attribs);
+
+ return wrapper;
+ },
+
+ /**
+ * VML override to create a regular HTML image
+ * @param {String} src
+ * @param {Number} x
+ * @param {Number} y
+ * @param {Number} width
+ * @param {Number} height
+ */
+ image: function (src, x, y, width, height) {
+ var obj = this.createElement('img')
+ .attr({ src: src });
+
+ if (arguments.length > 1) {
+ obj.attr({
+ x: x,
+ y: y,
+ width: width,
+ height: height
+ });
+ }
+ return obj;
+ },
+
+ /**
+ * VML uses a shape for rect to overcome bugs and rotation problems
+ */
+ rect: function (x, y, width, height, r, strokeWidth) {
+
+ var wrapper = this.symbol('rect');
+ wrapper.r = isObject(x) ? x.r : r;
+
+ //return wrapper.attr(wrapper.crisp(strokeWidth, x, y, mathMax(width, 0), mathMax(height, 0)));
+ return wrapper.attr(
+ isObject(x) ?
+ x :
+ // do not crispify when an object is passed in (as in column charts)
+ wrapper.crisp(strokeWidth, x, y, mathMax(width, 0), mathMax(height, 0))
+ );
+ },
+
+ /**
+ * In the VML renderer, each child of an inverted div (group) is inverted
+ * @param {Object} element
+ * @param {Object} parentNode
+ */
+ invertChild: function (element, parentNode) {
+ var parentStyle = parentNode.style;
+ css(element, {
+ flip: 'x',
+ left: pInt(parentStyle.width) - 1,
+ top: pInt(parentStyle.height) - 1,
+ rotation: -90
+ });
+ },
+
+ /**
+ * Symbol definitions that override the parent SVG renderer's symbols
+ *
+ */
+ symbols: {
+ // VML specific arc function
+ arc: function (x, y, w, h, options) {
+ var start = options.start,
+ end = options.end,
+ radius = options.r || w || h,
+ innerRadius = options.innerR,
+ cosStart = mathCos(start),
+ sinStart = mathSin(start),
+ cosEnd = mathCos(end),
+ sinEnd = mathSin(end),
+ ret;
+
+ if (end - start === 0) { // no angle, don't show it.
+ return ['x'];
+ }
+
+ ret = [
+ 'wa', // clockwise arc to
+ x - radius, // left
+ y - radius, // top
+ x + radius, // right
+ y + radius, // bottom
+ x + radius * cosStart, // start x
+ y + radius * sinStart, // start y
+ x + radius * cosEnd, // end x
+ y + radius * sinEnd // end y
+ ];
+
+ if (options.open && !innerRadius) {
+ ret.push(
+ 'e',
+ M,
+ x,// - innerRadius,
+ y// - innerRadius
+ );
+ }
+
+ ret.push(
+ 'at', // anti clockwise arc to
+ x - innerRadius, // left
+ y - innerRadius, // top
+ x + innerRadius, // right
+ y + innerRadius, // bottom
+ x + innerRadius * cosEnd, // start x
+ y + innerRadius * sinEnd, // start y
+ x + innerRadius * cosStart, // end x
+ y + innerRadius * sinStart, // end y
+ 'x', // finish path
+ 'e' // close
+ );
+
+ ret.isArc = true;
+ return ret;
+
+ },
+ // Add circle symbol path. This performs significantly faster than v:oval.
+ circle: function (x, y, w, h, wrapper) {
+
+ if (wrapper) {
+ w = h = 2 * wrapper.r;
+ }
+
+ // Center correction, #1682
+ if (wrapper && wrapper.isCircle) {
+ x -= w / 2;
+ y -= h / 2;
+ }
+
+ // Return the path
+ return [
+ 'wa', // clockwisearcto
+ x, // left
+ y, // top
+ x + w, // right
+ y + h, // bottom
+ x + w, // start x
+ y + h / 2, // start y
+ x + w, // end x
+ y + h / 2, // end y
+ //'x', // finish path
+ 'e' // close
+ ];
+ },
+ /**
+ * Add rectangle symbol path which eases rotation and omits arcsize problems
+ * compared to the built-in VML roundrect shape
+ *
+ * @param {Number} left Left position
+ * @param {Number} top Top position
+ * @param {Number} r Border radius
+ * @param {Object} options Width and height
+ */
+
+ rect: function (left, top, width, height, options) {
+
+ var right = left + width,
+ bottom = top + height,
+ ret,
+ r;
+
+ // No radius, return the more lightweight square
+ if (!defined(options) || !options.r) {
+ ret = SVGRenderer.prototype.symbols.square.apply(0, arguments);
+
+ // Has radius add arcs for the corners
+ } else {
+
+ r = mathMin(options.r, width, height);
+ ret = [
+ M,
+ left + r, top,
+
+ L,
+ right - r, top,
+ 'wa',
+ right - 2 * r, top,
+ right, top + 2 * r,
+ right - r, top,
+ right, top + r,
+
+ L,
+ right, bottom - r,
+ 'wa',
+ right - 2 * r, bottom - 2 * r,
+ right, bottom,
+ right, bottom - r,
+ right - r, bottom,
+
+ L,
+ left + r, bottom,
+ 'wa',
+ left, bottom - 2 * r,
+ left + 2 * r, bottom,
+ left + r, bottom,
+ left, bottom - r,
+
+ L,
+ left, top + r,
+ 'wa',
+ left, top,
+ left + 2 * r, top + 2 * r,
+ left, top + r,
+ left + r, top,
+
+
+ 'x',
+ 'e'
+ ];
+ }
+ return ret;
+ }
+ }
+};
+Highcharts.VMLRenderer = VMLRenderer = function () {
+ this.init.apply(this, arguments);
+};
+VMLRenderer.prototype = merge(SVGRenderer.prototype, VMLRendererExtension);
+
+ // general renderer
+ Renderer = VMLRenderer;
+}
+
+/* ****************************************************************************
+ * *
+ * END OF INTERNET EXPLORER <= 8 SPECIFIC CODE *
+ * *
+ *****************************************************************************/
+/* ****************************************************************************
+ * *
+ * START OF ANDROID < 3 SPECIFIC CODE. THIS CAN BE REMOVED IF YOU'RE NOT *
+ * TARGETING THAT SYSTEM. *
+ * *
+ *****************************************************************************/
+var CanVGRenderer,
+ CanVGController;
+
+if (useCanVG) {
+ /**
+ * The CanVGRenderer is empty from start to keep the source footprint small.
+ * When requested, the CanVGController downloads the rest of the source packaged
+ * together with the canvg library.
+ */
+ Highcharts.CanVGRenderer = CanVGRenderer = function () {
+ // Override the global SVG namespace to fake SVG/HTML that accepts CSS
+ SVG_NS = 'http://www.w3.org/1999/xhtml';
+ };
+
+ /**
+ * Start with an empty symbols object. This is needed when exporting is used (exporting.src.js will add a few symbols), but
+ * the implementation from SvgRenderer will not be merged in until first render.
+ */
+ CanVGRenderer.prototype.symbols = {};
+
+ /**
+ * Handles on demand download of canvg rendering support.
+ */
+ CanVGController = (function () {
+ // List of renderering calls
+ var deferredRenderCalls = [];
+
+ /**
+ * When downloaded, we are ready to draw deferred charts.
+ */
+ function drawDeferred() {
+ var callLength = deferredRenderCalls.length,
+ callIndex;
+
+ // Draw all pending render calls
+ for (callIndex = 0; callIndex < callLength; callIndex++) {
+ deferredRenderCalls[callIndex]();
+ }
+ // Clear the list
+ deferredRenderCalls = [];
+ }
+
+ return {
+ push: function (func, scriptLocation) {
+ // Only get the script once
+ if (deferredRenderCalls.length === 0) {
+ getScript(scriptLocation, drawDeferred);
+ }
+ // Register render call
+ deferredRenderCalls.push(func);
+ }
+ };
+ }());
+
+ Renderer = CanVGRenderer;
+} // end CanVGRenderer
+
+/* ****************************************************************************
+ * *
+ * END OF ANDROID < 3 SPECIFIC CODE *
+ * *
+ *****************************************************************************/
+
+/**
+ * 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,
+ horiz = axis.horiz,
+ categories = axis.categories,
+ names = axis.series[0] && axis.series[0].names,
+ pos = tick.pos,
+ labelOptions = options.labels,
+ str,
+ tickPositions = axis.tickPositions,
+ width = (horiz && categories &&
+ !labelOptions.step && !labelOptions.staggerLines &&
+ !labelOptions.rotation &&
+ chart.plotWidth / tickPositions.length) ||
+ (!horiz && (chart.margin[3] || chart.chartWidth * 0.33)), // #1580, #1931
+ isFirst = pos === tickPositions[0],
+ isLast = pos === tickPositions[tickPositions.length - 1],
+ css,
+ attr,
+ value = categories ?
+ pick(categories[pos], names && 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 };
+ css = extend(css, labelOptions.style);
+
+ // first call
+ if (!defined(label)) {
+ attr = {
+ align: axis.labelAlign
+ };
+ if (isNumber(labelOptions.rotation)) {
+ attr.rotation = labelOptions.rotation;
+ }
+ if (width && labelOptions.ellipsis) {
+ attr._clipHeight = axis.len / tickPositions.length;
+ }
+
+ tick.label =
+ defined(str) && labelOptions.enabled ?
+ chart.renderer.text(
+ str,
+ 0,
+ 0,
+ labelOptions.useHTML
+ )
+ .attr(attr)
+ // without position absolute, IE export sometimes is wrong
+ .css(css)
+ .add(axis.labelGroup) :
+ null;
+
+ // update
+ } else if (label) {
+ label.attr({
+ text: str
+ })
+ .css(css);
+ }
+ },
+
+ /**
+ * Get the offset height or width of the label
+ */
+ getLabelSize: function () {
+ var label = this.label,
+ axis = this.axis;
+ return label ?
+ ((this.labelBBox = label.getBBox()))[axis.horiz ? 'height' : 'width'] :
+ 0;
+ },
+
+ /**
+ * Find how far the labels extend to the right and left of the tick's x position. Used for anti-collision
+ * detection with overflow logic.
+ */
+ getLabelSides: function () {
+ var bBox = this.labelBBox, // assume getLabelSize has run at this point
+ axis = this.axis,
+ options = axis.options,
+ labelOptions = options.labels,
+ width = bBox.width,
+ leftSide = width * { left: 0, center: 0.5, right: 1 }[axis.labelAlign] - labelOptions.x;
+
+ return [-leftSide, width - leftSide];
+ },
+
+ /**
+ * 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 (index, xy) {
+ var show = true,
+ axis = this.axis,
+ chart = axis.chart,
+ isFirst = this.isFirst,
+ isLast = this.isLast,
+ x = xy.x,
+ reversed = axis.reversed,
+ tickPositions = axis.tickPositions;
+
+ if (isFirst || isLast) {
+
+ var sides = this.getLabelSides(),
+ leftSide = sides[0],
+ rightSide = sides[1],
+ plotLeft = chart.plotLeft,
+ plotRight = plotLeft + axis.len,
+ neighbour = axis.ticks[tickPositions[index + (isFirst ? 1 : -1)]],
+ neighbourEdge = neighbour && neighbour.label.xy && neighbour.label.xy.x + neighbour.getLabelSides()[isFirst ? 0 : 1];
+
+ if ((isFirst && !reversed) || (isLast && reversed)) {
+ // Is the label spilling out to the left of the plot area?
+ if (x + leftSide < plotLeft) {
+
+ // Align it to plot left
+ x = plotLeft - leftSide;
+
+ // Hide it if it now overlaps the neighbour label
+ if (neighbour && x + rightSide > neighbourEdge) {
+ show = false;
+ }
+ }
+
+ } else {
+ // Is the label spilling out to the right of the plot area?
+ if (x + rightSide > plotRight) {
+
+ // Align it to plot right
+ x = plotRight - rightSide;
+
+ // Hide it if it now overlaps the neighbour label
+ if (neighbour && x + leftSide < neighbourEdge) {
+ show = false;
+ }
+
+ }
+ }
+
+ // Set the modified x position of the label
+ xy.x = x;
+ }
+ return show;
+ },
+
+ /**
+ * 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,
+ baseline = axis.chart.renderer.fontMetrics(labelOptions.style.fontSize).b,
+ rotation = labelOptions.rotation;
+
+ x = x + labelOptions.x - (tickmarkOffset && horiz ?
+ tickmarkOffset * transA * (reversed ? -1 : 1) : 0);
+ y = y + labelOptions.y - (tickmarkOffset && !horiz ?
+ tickmarkOffset * transA * (reversed ? 1 : -1) : 0);
+
+ // Correct for rotation (#1764)
+ if (rotation && axis.side === 2) {
+ y -= baseline - baseline * mathCos(rotation * deg2rad);
+ }
+
+ // Vertically centered
+ if (!defined(labelOptions.y) && !rotation) { // #1951
+ y += baseline - label.getBBox().height / 2;
+ }
+
+ // Correct for staggered labels
+ if (staggerLines) {
+ y += (index / (step || 1) % staggerLines) * (axis.labelOffset / staggerLines);
+ }
+
+ return {
+ x: x,
+ y: 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 = options[tickPrefix + 'Width'] || 0,
+ tickColor = options[tickPrefix + 'Color'],
+ tickPosition = options[tickPrefix + 'Position'],
+ gridLinePath,
+ mark = tick.mark,
+ markPath,
+ step = 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
+ staggerLines = axis.staggerLines;
+
+ 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 (!staggerLines && horiz && labelOptions.overflow === 'justify' && !tick.handleOverflow(index, xy)) {
+ show = false;
+ }
+
+ // 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
+ */
+function PlotLineOrBand(axis, options) {
+ this.axis = axis;
+
+ if (options) {
+ this.options = options;
+ this.id = options.id;
+ }
+}
+
+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,
+ halfPointRange = (axis.pointRange || 0) / 2,
+ 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
+
+ // keep within plot area
+ from = mathMax(from, axis.min - halfPointRange);
+ to = mathMin(to, axis.max + halfPointRange);
+
+ path = axis.getPlotBandPath(from, to, options);
+ 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();
+ };
+ }
+ } 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) {
+ plotLine.label = label = renderer.text(
+ optionsLabel.text,
+ 0,
+ 0,
+ optionsLabel.useHTML
+ )
+ .attr({
+ align: optionsLabel.textAlign || optionsLabel.align,
+ rotation: optionsLabel.rotation,
+ zIndex: zIndex
+ })
+ .css(optionsLabel.style)
+ .add();
+ }
+
+ // get the bounding box and align the label
+ xs = [path[1], path[4], pick(path[6], path[1])];
+ ys = [path[2], path[5], pick(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);
+ }
+};
+/**
+ * The class for stack items
+ */
+function StackItem(axis, options, isNegative, x, stackOption, stacking) {
+
+ 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
+ this.points = {};
+
+ // Save the stack option on the series configuration object, and whether to treat it as percent
+ this.stack = stackOption;
+ this.percent = stacking === 'percent';
+
+ // 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, 0, 0, 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,
+ neg = this.isNegative, // special treatment is needed for negative stacks
+ y = axis.translate(this.percent ? 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.attr({
+ visibility: this.options.crop === false || chart.isInsidePlot(alignAttr.x, alignAttr.y) ?
+ (hasSVG ? 'inherit' : VISIBLE) :
+ HIDDEN
+ });
+ }
+ }
+};
+/**
+ * Create a new axis object
+ * @param {Object} chart
+ * @param {Object} options
+ */
+function Axis() {
+ 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: '#C0C0C0',
+ // gridLineDashStyle: 'solid',
+ // gridLineWidth: 0,
+ // reversed: false,
+
+ labels: defaultLabelOptions,
+ // { step: null },
+ 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: 5,
+ 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: '#4d759e',
+ //font: defaultFont.replace('normal', 'bold')
+ fontWeight: 'bold'
+ }
+ //x: 0,
+ //y: 0
+ },
+ type: 'linear' // linear, logarithmic or datetime
+ },
+
+ /**
+ * 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 numberFormat(this.total, -1);
+ },
+ style: defaultLabelOptions.style
+ }
+ },
+
+ /**
+ * These options extend the defaultOptions for left axes
+ */
+ defaultLeftAxisOptions: {
+ labels: {
+ x: -8,
+ y: null
+ },
+ title: {
+ rotation: 270
+ }
+ },
+
+ /**
+ * These options extend the defaultOptions for right axes
+ */
+ defaultRightAxisOptions: {
+ labels: {
+ x: 8,
+ y: null
+ },
+ title: {
+ rotation: 90
+ }
+ },
+
+ /**
+ * These options extend the defaultOptions for bottom axes
+ */
+ defaultBottomAxisOptions: {
+ labels: {
+ x: 0,
+ y: 14
+ // overflow: undefined,
+ // staggerLines: null
+ },
+ title: {
+ rotation: 0
+ }
+ },
+ /**
+ * These options extend the defaultOptions for left axes
+ */
+ defaultTopAxisOptions: {
+ labels: {
+ x: 0,
+ y: -5
+ // overflow: undefined
+ // staggerLines: null
+ },
+ title: {
+ rotation: 0
+ }
+ },
+
+ /**
+ * Initialize the axis
+ */
+ init: function (chart, userOptions) {
+
+
+ var isXAxis = userOptions.isX,
+ axis = this;
+
+ // Flag, is the axis horizontal
+ axis.horiz = chart.inverted ? !isXAxis : isXAxis;
+
+ // Flag, isXAxis
+ axis.isXAxis = isXAxis;
+ axis.xOrY = isXAxis ? 'x' : 'y';
+
+
+ axis.opposite = userOptions.opposite; // needed in setOptions
+ axis.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.ignoreMinPadding = UNDEFINED; // can be set to true by a column or bar series
+ //axis.ignoreMaxPadding = UNDEFINED;
+
+ axis.chart = chart;
+ axis.reversed = options.reversed;
+ axis.zoomEnabled = options.zoomEnabled !== false;
+
+ // Initial categories
+ axis.categories = options.categories || type === 'category';
+
+ // 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;
+
+ axis.tickmarkOffset = (axis.categories && options.tickmarkPlacement === 'between') ? 0.5 : 0;
+
+ // Major ticks
+ axis.ticks = {};
+ // Minor ticks
+ axis.minorTicks = {};
+ //axis.tickAmount = UNDEFINED;
+
+ // 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 = {};
+
+ // Dictionary for stacks max values
+ axis.stackExtremes = {};
+
+ // 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,
+
+ // Run Axis
+
+ var eventType,
+ events = axis.options.events;
+
+ // Register
+ if (inArray(axis, chart.axes) === -1) { // don't add it again on Axis.update()
+ chart.axes.push(axis);
+ chart[isXAxis ? 'xAxis' : 'yAxis'].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.isXAxis ? 'xAxis' : 'yAxis'], // if set in setOptions (#1053)
+ userOptions
+ )
+ );
+ },
+
+ /**
+ * Update the axis with a new options structure
+ */
+ update: function (newOptions, redraw) {
+ var chart = this.chart;
+
+ newOptions = chart.options[this.xOrY + 'Axis'][this.options.index] = merge(this.userOptions, newOptions);
+
+ this.destroy(true);
+ this._addedPlotLB = this.userMin = this.userMax = UNDEFINED; // #1611, #2306
+
+ 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.xOrY + 'Axis'; // xAxis or yAxis
+
+ // Remove associated series
+ each(this.series, function (series) {
+ series.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();
+ }
+ },
+
+ /**
+ * 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 && numericSymbols[i] !== null) {
+ ret = numberFormat(value / multi, -1) + numericSymbols[i];
+ }
+ }
+ }
+
+ if (ret === UNDEFINED) {
+ if (value >= 1000) { // add thousands separators
+ ret = numberFormat(value, 0);
+
+ } else { // small numbers
+ ret = numberFormat(value, -1);
+ }
+ }
+
+ 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 dataMin and dataMax in case we're redrawing
+ axis.dataMin = axis.dataMax = null;
+
+ // reset cached stacking extremes
+ axis.stackExtremes = {};
+
+ 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)) {
+ if (axis.dataMin >= threshold) {
+ axis.dataMin = threshold;
+ axis.ignoreMinPadding = true;
+ } else if (axis.dataMax < threshold) {
+ axis.dataMax = threshold;
+ axis.ignoreMaxPadding = true;
+ }
+ }
+ }
+ }
+ });
+ },
+
+ /**
+ * Translate from axis value to pixel position on the chart, or back
+ *
+ */
+ translate: function (val, backwards, cvsCoord, old, handleLog, pointPlacement) {
+ var axis = this,
+ axisLength = axis.len,
+ sign = 1,
+ cvsOffset = 0,
+ localA = old ? axis.oldTransA : axis.transA,
+ localMin = old ? axis.oldMin : axis.min,
+ returnValue,
+ minPixelPadding = axis.minPixelPadding,
+ postTranslate = (axis.options.ordinal || (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 = axisLength;
+ }
+
+ // Handle reversed axis
+ if (axis.reversed) {
+ sign *= -1;
+ cvsOffset -= sign * axisLength;
+ }
+
+ // From pixels to value
+ if (backwards) { // reverse translation
+
+ val = val * sign + cvsOffset;
+ val -= minPixelPadding;
+ returnValue = val / localA + localMin; // from chart pixel to value
+ if (postTranslate) { // log and ordinal axes
+ returnValue = axis.lin2val(returnValue);
+ }
+
+ // From value to pixels
+ } else {
+ if (postTranslate) { // 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) {
+ var axis = this,
+ chart = axis.chart,
+ axisLeft = axis.left,
+ axisTop = axis.top,
+ x1,
+ y1,
+ x2,
+ y2,
+ translatedValue = axis.translate(value, null, null, old),
+ cHeight = (old && chart.oldChartHeight) || chart.chartHeight,
+ cWidth = (old && chart.oldChartWidth) || chart.chartWidth,
+ skip,
+ transB = axis.transB;
+
+ 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;
+ if (x1 < axisLeft || x1 > axisLeft + axis.width) {
+ skip = true;
+ }
+ } else {
+ x1 = axisLeft;
+ x2 = cWidth - axis.right;
+
+ if (y1 < axisTop || y1 > axisTop + axis.height) {
+ skip = true;
+ }
+ }
+ return skip && !force ?
+ null :
+ chart.renderer.crispLine([M, x1, y1, L, x2, y2], lineWidth || 0);
+ },
+
+ /**
+ * Create the path for a plot band
+ */
+ getPlotBandPath: function (from, to) {
+
+ var toPath = this.getPlotLinePath(to),
+ path = this.getPlotLinePath(from);
+
+ if (path && toPath) {
+ path.push(
+ toPath[4],
+ toPath[5],
+ toPath[1],
+ toPath[2]
+ );
+ } else { // outside the axis area
+ path = null;
+ }
+
+ return path;
+ },
+
+ /**
+ * 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 = [];
+
+ // 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;
+ },
+
+ /**
+ * Set the tick positions of a logarithmic axis
+ */
+ 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)) { // #1670
+ 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;
+ },
+
+ /**
+ * 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,
+ len;
+
+ 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(
+ getTimeTicks(
+ normalizeTimeTickInterval(minorTickInterval),
+ axis.min,
+ axis.max,
+ options.startOfWeek
+ )
+ );
+ if (minorTickPositions[0] < axis.min) {
+ minorTickPositions.shift();
+ }
+ } else {
+ for (pos = axis.min + (tickPositions[0] - axis.min) % minorTickInterval; pos <= axis.max; pos += minorTickInterval) {
+ minorTickPositions.push(pos);
+ }
+ }
+ 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;
+
+ // 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) {
+ var 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 = 0,
+ closestPointRange,
+ minPointOffset = 0,
+ pointRangePadding = 0,
+ linkedParent = axis.linkedParent,
+ ordinalCorrection,
+ transA = axis.transA;
+
+ // adjust translation for padding
+ if (axis.isXAxis) {
+ if (linkedParent) {
+ minPointOffset = linkedParent.minPointOffset;
+ pointRangePadding = linkedParent.pointRangePadding;
+
+ } else {
+ each(axis.series, function (series) {
+ var seriesPointRange = series.pointRange,
+ pointPlacement = series.options.pointPlacement,
+ seriesClosestPointRange = series.closestPointRange;
+
+ if (seriesPointRange > range) { // #1446
+ seriesPointRange = 0;
+ }
+ pointRange = mathMax(pointRange, seriesPointRange);
+
+ // 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
+ 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;
+ },
+
+ /**
+ * Set the tick positions to round values and optionally extend the extremes
+ * to the nearest tick
+ */
+ setTickPositions: function (secondPass) {
+ var axis = this,
+ chart = axis.chart,
+ options = axis.options,
+ isLog = axis.isLog,
+ isDatetimeAxis = axis.isDatetimeAxis,
+ isXAxis = axis.isXAxis,
+ isLinked = axis.isLinked,
+ tickPositioner = axis.options.tickPositioner,
+ maxPadding = options.maxPadding,
+ minPadding = options.minPadding,
+ length,
+ linkedParentExtremes,
+ tickIntervalOption = options.tickInterval,
+ minTickIntervalOption = options.minTickInterval,
+ tickPixelIntervalOption = options.tickPixelInterval,
+ tickPositions,
+ keepTwoTicksOnly,
+ categories = axis.categories;
+
+ // linked axis gets the extremes from the parent axis
+ if (isLinked) {
+ axis.linkedParent = chart[isXAxis ? 'xAxis' : 'yAxis'][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
+ }
+ } else { // initial min and max from the extreme data values
+ axis.min = pick(axis.userMin, options.min, axis.dataMin);
+ axis.max = pick(axis.userMax, options.max, 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
+ }
+ axis.min = correctFloat(log2lin(axis.min)); // correctFloat cures #934
+ axis.max = correctFloat(log2lin(axis.max));
+ }
+
+ // handle zoomed range
+ if (axis.range) {
+ axis.userMin = axis.min = mathMax(axis.min, axis.max - axis.range); // #618
+ axis.userMax = axis.max;
+ if (secondPass) {
+ 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.usePercentage && !isLinked && defined(axis.min) && defined(axis.max)) {
+ length = axis.max - axis.min;
+ if (length) {
+ if (!defined(options.min) && !defined(axis.userMin) && minPadding && (axis.dataMin < 0 || !axis.ignoreMinPadding)) {
+ axis.min -= length * minPadding;
+ }
+ if (!defined(options.max) && !defined(axis.userMax) && maxPadding && (axis.dataMax > 0 || !axis.ignoreMaxPadding)) {
+ axis.max += length * maxPadding;
+ }
+ }
+ }
+
+ // 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 = axis.linkedParent.tickInterval;
+ } else {
+ axis.tickInterval = pick(
+ tickIntervalOption,
+ 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)
+ );
+ // For squished axes, set only two ticks
+ if (!defined(tickIntervalOption) && axis.len < tickPixelIntervalOption && !this.isRadial) {
+ keepTwoTicksOnly = true;
+ axis.tickInterval /= 4; // tick extremes closer to the real values
+ }
+ }
+
+ // 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.
+ if (!tickIntervalOption && axis.tickInterval < minTickIntervalOption) {
+ axis.tickInterval = minTickIntervalOption;
+ }
+
+ // for linear axes, get magnitude and normalize the interval
+ if (!isDatetimeAxis && !isLog) { // linear
+ if (!tickIntervalOption) {
+ axis.tickInterval = normalizeTickInterval(axis.tickInterval, null, getMagnitude(axis.tickInterval), options);
+ }
+ }
+
+ // get minorTickInterval
+ axis.minorTickInterval = options.minorTickInterval === 'auto' && axis.tickInterval ?
+ axis.tickInterval / 5 : options.minorTickInterval;
+
+ // find the tick positions
+ axis.tickPositions = tickPositions = options.tickPositions ?
+ [].concat(options.tickPositions) : // Work on a copy (#1565)
+ (tickPositioner && tickPositioner.apply(axis, [axis.min, axis.max]));
+ if (!tickPositions) {
+
+ // Too many ticks
+ if (!axis.ordinalPositions && (axis.max - axis.min) / axis.tickInterval > mathMax(2 * axis.len, 200)) {
+ error(19, true);
+ }
+
+ if (isDatetimeAxis) {
+ tickPositions = (axis.getNonLinearTimeTicks || getTimeTicks)(
+ normalizeTimeTickInterval(axis.tickInterval, options.units),
+ axis.min,
+ axis.max,
+ options.startOfWeek,
+ axis.ordinalPositions,
+ axis.closestPointRange,
+ true
+ );
+ } else if (isLog) {
+ tickPositions = axis.getLogTickPositions(axis.tickInterval, axis.min, axis.max);
+ } else {
+ tickPositions = axis.getLinearTickPositions(axis.tickInterval, axis.min, axis.max);
+ }
+ if (keepTwoTicksOnly) {
+ tickPositions.splice(1, tickPositions.length - 2);
+ }
+
+ axis.tickPositions = tickPositions;
+ }
+
+ if (!isLinked) {
+
+ // reset min/max or remove extremes based on start/end on tick
+ var roundedMin = tickPositions[0],
+ roundedMax = tickPositions[tickPositions.length - 1],
+ minPointOffset = axis.minPointOffset || 0,
+ singlePad;
+
+ if (options.startOnTick) {
+ axis.min = roundedMin;
+ } else if (axis.min - minPointOffset > roundedMin) {
+ tickPositions.shift();
+ }
+
+ if (options.endOnTick) {
+ axis.max = roundedMax;
+ } else if (axis.max + minPointOffset < roundedMax) {
+ tickPositions.pop();
+ }
+
+ // 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 1. In this case, add some padding
+ // in order to center the point, but leave it with one tick. #1337.
+ if (tickPositions.length === 1) {
+ singlePad = 0.001; // The lowest possible number to avoid extra padding on columns
+ axis.min -= singlePad;
+ axis.max += singlePad;
+ }
+ }
+ },
+
+ /**
+ * Set the max ticks of either the x and y axis collection
+ */
+ setMaxTicks: function () {
+
+ var chart = this.chart,
+ maxTicks = chart.maxTicks || {},
+ tickPositions = this.tickPositions,
+ key = this._maxTicksKey = [this.xOrY, this.pos, this.len].join('-');
+
+ if (!this.isLinked && !this.isDatetimeAxis && tickPositions && tickPositions.length > (maxTicks[key] || 0) && this.options.alignTicks !== false) {
+ maxTicks[key] = tickPositions.length;
+ }
+ chart.maxTicks = maxTicks;
+ },
+
+ /**
+ * When using multiple axes, adjust the number of ticks to match the highest
+ * number of ticks in that group
+ */
+ adjustTickAmount: function () {
+ var axis = this,
+ chart = axis.chart,
+ key = axis._maxTicksKey,
+ tickPositions = axis.tickPositions,
+ maxTicks = chart.maxTicks;
+
+ if (maxTicks && maxTicks[key] && !axis.isDatetimeAxis && !axis.categories && !axis.isLinked && axis.options.alignTicks !== false) { // only apply to linear scale
+ var oldTickAmount = axis.tickAmount,
+ calculatedTickAmount = tickPositions.length,
+ tickAmount;
+
+ // set the axis-level tickAmount to use below
+ axis.tickAmount = tickAmount = maxTicks[key];
+
+ if (calculatedTickAmount < tickAmount) {
+ while (tickPositions.length < tickAmount) {
+ tickPositions.push(correctFloat(
+ tickPositions[tickPositions.length - 1] + axis.tickInterval
+ ));
+ }
+ axis.transA *= (calculatedTickAmount - 1) / (tickAmount - 1);
+ axis.max = tickPositions[tickPositions.length - 1];
+
+ }
+ if (defined(oldTickAmount) && tickAmount !== oldTickAmount) {
+ axis.isDirty = true;
+ }
+ }
+ },
+
+ /**
+ * Set the scale based on data min and max, user set min and max or options
+ *
+ */
+ setScale: function () {
+ var axis = this,
+ stacks = axis.stacks,
+ type,
+ i,
+ 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) {
+
+ // reset stacks
+ if (!axis.isXAxis) {
+ for (type in stacks) {
+ delete stacks[type];
+ }
+ }
+
+ axis.forceRedraw = false;
+
+ // get data extremes if needed
+ axis.getSeriesExtremes();
+
+ // get fixed positions based on tickInterval
+ axis.setTickPositions();
+
+ // 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.isXAxis) {
+ if (axis.oldStacks) {
+ stacks = axis.stacks = axis.oldStacks;
+ }
+
+ // reset stacks
+ for (type in stacks) {
+ for (i in stacks[type]) {
+ stacks[type][i].cum = stacks[type][i].total;
+ }
+ }
+ }
+
+ // Set the maximum tick amount
+ axis.setMaxTicks();
+ },
+
+ /**
+ * 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
+
+ // 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;
+
+ // Mark for running afterSetExtremes
+ axis.isDirtyExtremes = true;
+
+ // redraw
+ 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) {
+
+ // Prevent pinch zooming out of range. Check for defined is for #1946.
+ if (!this.allowZoomOutside) {
+ if (defined(this.dataMin) && newMin <= this.dataMin) {
+ newMin = UNDEFINED;
+ }
+ if (defined(this.dataMax) && newMax >= this.dataMax) {
+ newMax = UNDEFINED;
+ }
+ }
+
+ // 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,
+ height,
+ top,
+ left;
+
+ // Expose basic values to use in Series object and navigator
+ this.left = left = pick(options.left, chart.plotLeft + offsetLeft);
+ this.top = top = pick(options.top, chart.plotTop);
+ this.width = width = pick(options.width, chart.plotWidth - offsetLeft + offsetRight);
+ this.height = height = pick(options.height, chart.plotHeight);
+ 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;
+
+ var realMin = isLog ? lin2log(axis.min) : axis.min,
+ realMax = isLog ? lin2log(axis.max) : axis.max;
+
+ if (realMin > threshold || threshold === null) {
+ threshold = realMin;
+ } else if (realMax < threshold) {
+ threshold = realMax;
+ }
+
+ return axis.translate(threshold, 0, 1, 0, 1);
+ },
+
+ addPlotBand: function (options) {
+ this.addPlotBandOrLine(options, 'plotBands');
+ },
+
+ addPlotLine: function (options) {
+ 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 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;
+ },
+
+ /**
+ * 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;
+ },
+
+ /**
+ * 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
+ axisOffset = chart.axisOffset,
+ clipOffset = chart.clipOffset,
+ directionFactor = [-1, 1, 1, -1][side],
+ n,
+ i,
+ autoStaggerLines = 1,
+ maxStaggerLines = pick(labelOptions.maxStaggerLines, 5),
+ sortedPositions,
+ lastRight,
+ overlap,
+ pos,
+ bBox,
+ x,
+ w,
+ lineNo;
+
+ // For reuse in Axis.render
+ axis.hasData = hasData = (axis.hasVisibleSeries || (defined(axis.min) && defined(axis.max) && !!tickPositions));
+ 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();
+ axis.axisGroup = renderer.g('axis')
+ .attr({ zIndex: options.zIndex || 2 })
+ .add();
+ axis.labelGroup = renderer.g('axis-labels')
+ .attr({ zIndex: labelOptions.zIndex || 7 })
+ .add();
+ }
+
+ if (hasData || axis.isLinked) {
+
+ // Set the explicit or automatic label alignment
+ axis.labelAlign = pick(labelOptions.align || axis.autoLabelAlign(labelOptions.rotation));
+
+ each(tickPositions, function (pos) {
+ if (!ticks[pos]) {
+ ticks[pos] = new Tick(axis, pos);
+ } else {
+ ticks[pos].addLabel(); // update labels depending on tick interval
+ }
+ });
+
+ // Handle automatic stagger lines
+ if (axis.horiz && !axis.staggerLines && maxStaggerLines && !labelOptions.rotation) {
+ sortedPositions = axis.reversed ? [].concat(tickPositions).reverse() : tickPositions;
+ while (autoStaggerLines < maxStaggerLines) {
+ lastRight = [];
+ overlap = false;
+
+ for (i = 0; i < sortedPositions.length; i++) {
+ pos = sortedPositions[i];
+ bBox = ticks[pos].label && ticks[pos].label.getBBox();
+ w = bBox ? bBox.width : 0;
+ lineNo = i % autoStaggerLines;
+
+ if (w) {
+ x = axis.translate(pos); // don't handle log
+ if (lastRight[lineNo] !== UNDEFINED && x < lastRight[lineNo]) {
+ overlap = true;
+ }
+ lastRight[lineNo] = x + w;
+ }
+ }
+ if (overlap) {
+ autoStaggerLines++;
+ } else {
+ break;
+ }
+ }
+
+ if (autoStaggerLines > 1) {
+ axis.staggerLines = autoStaggerLines;
+ }
+ }
+
+
+ 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]
+ })
+ .css(axisTitleOptions.style)
+ .add(axis.axisGroup);
+ axis.axisTitle.isNew = true;
+ }
+
+ if (showAxis) {
+ titleOffset = axis.axisTitle.getBBox()[horiz ? 'height' : 'width'];
+ titleMargin = pick(axisTitleOptions.margin, horiz ? 5 : 10);
+ titleOffsetOption = axisTitleOptions.offset;
+ }
+
+ // 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.axisTitleMargin =
+ pick(titleOffsetOption,
+ labelOffset + titleMargin +
+ (side !== 2 && labelOffset && directionFactor * options.labels[horiz ? 'y' : 'x'])
+ );
+
+ axisOffset[side] = mathMax(
+ axisOffset[side],
+ axis.axisTitleMargin + titleOffset + directionFactor * axis.offset
+ );
+ clipOffset[invertedSide] = mathMax(clipOffset[invertedSide], mathFloor(options.lineWidth / 2) * 2);
+ },
+
+ /**
+ * 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,
+ 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 :
+ offAxis + (opposite ? this.width : 0) + offset +
+ (axisTitleOptions.x || 0), // x
+ y: horiz ?
+ offAxis - (opposite ? this.height : 0) + offset :
+ alongAxis + (axisTitleOptions.y || 0) // y
+ };
+ },
+
+ /**
+ * 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,
+ stacks = axis.stacks,
+ 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),
+ hasData = axis.hasData,
+ showAxis = axis.showAxis,
+ from,
+ to;
+
+ // 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 (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.slice(1).concat([tickPositions[0]]), function (pos, i) {
+
+ // Reorganize the indices
+ i = (i === tickPositions.length - 1) ? 0 : i + 1;
+
+ // 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);
+ }
+
+ ticks[pos].render(i, false, 1);
+ }
+
+ });
+ // 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) {
+ 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) {
+ if (i % 2 === 0 && pos < axis.max) {
+ if (!alternateBands[pos]) {
+ alternateBands[pos] = new PlotLineOrBand(axis);
+ }
+ from = pos + tickmarkOffset; // #949
+ to = tickPositions[i + 1] !== UNDEFINED ? tickPositions[i + 1] + tickmarkOffset : axis.max;
+ 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) {
+ var 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);
+ }
+ }
+ }
+ // End stacked totals
+
+ axis.isDirty = false;
+ },
+
+ /**
+ * 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]);
+ }
+ }
+ });
+
+ },
+
+ /**
+ * Update the axis title by options
+ */
+ setTitle: function (newTitleOptions, redraw) {
+ this.update({ title: newTitleOptions }, redraw);
+ },
+
+ /**
+ * Redraw the axis to reflect changes in the data or axis extremes
+ */
+ redraw: function () {
+ var axis = this,
+ chart = axis.chart,
+ pointer = chart.pointer;
+
+ // hide tooltip and hover states
+ if (pointer.reset) {
+ pointer.reset(true);
+ }
+
+ // render the axis
+ axis.render();
+
+ // move plot lines and bands
+ each(axis.plotLinesAndBands, function (plotLine) {
+ plotLine.render();
+ });
+
+ // mark associated series as dirty and ready for redraw
+ each(axis.series, function (series) {
+ series.isDirty = true;
+ });
+
+ },
+
+ /**
+ * Build the stacks from top down
+ */
+ buildStacks: function () {
+ var series = this.series,
+ i = series.length;
+ if (!this.isXAxis) {
+ while (i--) {
+ series[i].setStackedPoints();
+ }
+ // Loop up again to compute percent stack
+ if (this.usePercentage) {
+ for (i = 0; i < series.length; i++) {
+ series[i].setPercentStacks();
+ }
+ }
+ }
+ },
+
+ /**
+ * Set new axis categories and optionally redraw
+ * @param {Array} categories
+ * @param {Boolean} redraw
+ */
+ setCategories: function (categories, redraw) {
+ this.update({ categories: categories }, redraw);
+ },
+
+ /**
+ * 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', 'axisGroup', 'gridGroup', 'labelGroup', 'axisTitle'], function (prop) {
+ if (axis[prop]) {
+ axis[prop] = axis[prop].destroy();
+ }
+ });
+ }
+
+
+}; // end Axis
+
+/**
+ * The tooltip object
+ * @param {Object} chart The chart instance
+ * @param {Object} options Tooltip options
+ */
+function Tooltip() {
+ 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, 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: -999 }); // #2301
+
+ // 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 () {
+ each(this.crosshairs, function (crosshair) {
+ if (crosshair) {
+ crosshair.destroy();
+ }
+ });
+
+ // 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;
+
+ // get intermediate values for animation
+ extend(now, {
+ x: animate ? (2 * now.x + x) / 3 : x,
+ y: animate ? (now.y + y) / 2 : y,
+ anchorX: animate ? (2 * now.anchorX + anchorX) / 3 : anchorX,
+ anchorY: 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 && (mathAbs(x - now.x) > 1 || mathAbs(y - now.y) > 1)) {
+
+ // 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 () {
+ 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(this.options.hideDelay, 500));
+
+ // hide previous hoverPoints and set new
+ if (hoverPoints) {
+ each(hoverPoints, function (point) {
+ point.setState();
+ });
+ }
+
+ this.chart.hoverPoints = null;
+ }
+ },
+
+ /**
+ * Hide the crosshairs
+ */
+ hideCrosshairs: function () {
+ each(this.crosshairs, function (crosshair) {
+ if (crosshair) {
+ crosshair.hide();
+ }
+ });
+ },
+
+ /**
+ * 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,
+ plotX = 0,
+ plotY = 0,
+ yAxis;
+
+ 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;
+ plotX += point.plotX;
+ 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) {
+
+ // Set up the variables
+ var chart = this.chart,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop,
+ plotWidth = chart.plotWidth,
+ plotHeight = chart.plotHeight,
+ distance = pick(this.options.distance, 12),
+ pointX = point.plotX,
+ pointY = point.plotY,
+ x = pointX + plotLeft + (chart.inverted ? distance : -boxWidth - distance),
+ y = pointY - boxHeight + plotTop + 15, // 15 means the point is 15 pixels up from the bottom of the tooltip
+ alignedRight;
+
+ // It is too far to the left, adjust it
+ if (x < 7) {
+ x = plotLeft + mathMax(pointX, 0) + distance;
+ }
+
+ // Test to see if the tooltip is too far to the right,
+ // if it is, move it back to be inside and then up to not cover the point.
+ if ((x + boxWidth) > (plotLeft + plotWidth)) {
+ x -= (x + boxWidth) - (plotLeft + plotWidth);
+ y = pointY - boxHeight + plotTop - distance;
+ alignedRight = true;
+ }
+
+ // If it is now above the plot area, align it to the top of the plot area
+ if (y < plotTop + 5) {
+ y = plotTop + 5;
+
+ // If the tooltip is still covering the point, move it below instead
+ if (alignedRight && pointY >= y && pointY <= (y + boxHeight)) {
+ y = pointY + plotTop + distance; // below
+ }
+ }
+
+ // Now if the tooltip is below the chart, move it up. It's better to cover the
+ // point than to disappear outside the chart. #834.
+ if (y + boxHeight > plotTop + plotHeight) {
+ y = mathMax(plotTop, plotTop + plotHeight - boxHeight - distance); // below
+ }
+
+ return {x: x, y: y};
+ },
+
+ /**
+ * 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),
+ series = items[0].series,
+ s;
+
+ // build the header
+ s = [series.tooltipHeaderFormatter(items[0])];
+
+ // build the values
+ each(items, function (item) {
+ series = item.series;
+ s.push((series.tooltipFormatter && series.tooltipFormatter(item)) ||
+ item.point.tooltipFormatter(series.tooltipOptions.pointFormat));
+ });
+
+ // footer
+ s.push(tooltip.options.footerFormat || '');
+
+ 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,
+ crosshairsOptions = options.crosshairs,
+ 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;
+ point = point[0];
+
+ // single point tooltip
+ } else {
+ textConfig = point.getLabelConfig();
+ }
+ text = formatter.call(textConfig, tooltip);
+
+ // register the current series
+ currentSeries = point.series;
+
+ // 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 });
+
+ this.isHidden = false;
+ }
+
+ // crosshairs
+ if (crosshairsOptions) {
+ crosshairsOptions = splat(crosshairsOptions); // [x, y]
+
+ var path,
+ i = crosshairsOptions.length,
+ attribs,
+ axis,
+ val,
+ series;
+
+ while (i--) {
+ series = point.series;
+ axis = series[i ? 'yAxis' : 'xAxis'];
+ if (crosshairsOptions[i] && axis) {
+ val = i ? pick(point.stackY, point.y) : point.x; // #814
+ if (axis.isLog) { // #1671
+ val = log2lin(val);
+ }
+ if (i === 1 && series.modifyValue) { // #1205, #2316
+ val = series.modifyValue(val);
+ }
+
+ path = axis.getPlotLinePath(
+ val,
+ 1
+ );
+
+ if (tooltip.crosshairs[i]) {
+ tooltip.crosshairs[i].attr({ d: path, visibility: VISIBLE });
+ } else {
+ attribs = {
+ 'stroke-width': crosshairsOptions[i].width || 1,
+ stroke: crosshairsOptions[i].color || '#C0C0C0',
+ zIndex: crosshairsOptions[i].zIndex || 2
+ };
+ if (crosshairsOptions[i].dashStyle) {
+ attribs.dashstyle = crosshairsOptions[i].dashStyle;
+ }
+ tooltip.crosshairs[i] = chart.renderer.path(path)
+ .attr(attribs)
+ .add();
+ }
+ }
+ }
+ }
+ 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),
+ point.plotX + chart.plotLeft,
+ point.plotY + chart.plotTop
+ );
+ }
+};
+/**
+ * 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
+ */
+function Pointer(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);
+
+ // Do we need to handle click on a touch device?
+ this.runChartClick = chartEvents && !!chartEvents.click;
+
+ this.pinchDown = [];
+ this.lastValidTouch = {};
+
+ if (options.tooltip.enabled) {
+ chart.tooltip = new Tooltip(chart, options.tooltip);
+ }
+
+ 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 || win.event;
+ if (!e.target) {
+ e.target = e.srcElement;
+ }
+
+ // Framework specific normalizing (#1165)
+ e = washMouseEvent(e);
+
+ // iOS
+ ePos = e.touches ? e.touches.item(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;
+ },
+
+ /**
+ * Return the index in the tooltipPoints array, corresponding to pixel position in
+ * the plot area.
+ */
+ getIndex: function (e) {
+ var chart = this.chart;
+ return chart.inverted ?
+ chart.plotHeight + chart.plotTop - e.chartY :
+ e.chartX - chart.plotLeft;
+ },
+
+ /**
+ * 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,
+ point,
+ points,
+ hoverPoint = chart.hoverPoint,
+ hoverSeries = chart.hoverSeries,
+ i,
+ j,
+ distance = chart.chartWidth,
+ index = pointer.getIndex(e),
+ anchor;
+
+ // shared tooltip
+ if (tooltip && pointer.options.tooltip.shared && !(hoverSeries && hoverSeries.noSharedTooltip)) {
+ points = [];
+
+ // loop over all series and find the ones with points closest to the mouse
+ i = series.length;
+ for (j = 0; j < i; j++) {
+ if (series[j].visible &&
+ series[j].options.enableMouseTracking !== false &&
+ !series[j].noSharedTooltip && series[j].tooltipPoints.length) {
+ point = series[j].tooltipPoints[index];
+ if (point && point.series) { // not a dummy point, #1544
+ point._dist = mathAbs(index - point.clientX);
+ distance = mathMin(distance, point._dist);
+ points.push(point);
+ }
+ }
+ }
+ // remove furthest points
+ i = points.length;
+ while (i--) {
+ if (points[i]._dist > distance) {
+ points.splice(i, 1);
+ }
+ }
+ // refresh the tooltip if necessary
+ if (points.length && (points[0].clientX !== pointer.hoverX)) {
+ tooltip.refresh(points, e);
+ pointer.hoverX = points[0].clientX;
+ }
+ }
+
+ // separate tooltip and general mouse events
+ if (hoverSeries && hoverSeries.tracker) { // only use for line-type series with common tracker
+
+ // get the point
+ point = hoverSeries.tooltipPoints[index];
+
+ // a new point is hovered, refresh the tooltip
+ if (point && point !== hoverPoint) {
+
+ // trigger the events
+ point.onMouseOver(e);
+
+ }
+
+ } else if (tooltip && tooltip.followPointer && !tooltip.isHidden) {
+ anchor = tooltip.getAnchor([{}], e);
+ tooltip.updatePosition({ plotX: anchor[0], plotY: anchor[1] });
+ }
+ },
+
+
+
+ /**
+ * 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) {
+ var pointer = this,
+ chart = pointer.chart,
+ hoverSeries = chart.hoverSeries,
+ hoverPoint = chart.hoverPoint,
+ tooltip = chart.tooltip,
+ tooltipPoints = tooltip && tooltip.shared ? chart.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);
+
+ // Full reset
+ } else {
+
+ if (hoverPoint) {
+ hoverPoint.onMouseOut();
+ }
+
+ if (hoverSeries) {
+ hoverSeries.onMouseOut();
+ }
+
+ if (tooltip) {
+ tooltip.hide();
+ tooltip.hideCrosshairs();
+ }
+
+ pointer.hoverX = 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);
+ },
+
+ /**
+ * Run translation operations for each direction (horizontal and vertical) independently
+ */
+ pinchTranslateDirection: function (horiz, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch) {
+ 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 = 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 = 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,
+ followTouchMove = chart.tooltip && chart.tooltip.options.followTouchMove,
+ touches = e.touches,
+ touchesLength = touches.length,
+ lastValidTouch = self.lastValidTouch,
+ zoomHor = self.zoomHor || self.pinchHor,
+ zoomVert = self.zoomVert || self.pinchVert,
+ hasZoom = zoomHor || zoomVert,
+ selectionMarker = self.selectionMarker,
+ transform = {},
+ fireClickEvent = touchesLength === 1 && ((self.inClass(e.target, PREFIX + 'tracker') &&
+ chart.runTrackerClick) || chart.runChartClick),
+ clip = {};
+
+ // On touch devices, only proceed to trigger click if a handler is defined
+ if ((hasZoom || followTouchMove) && !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(axis.dataMin),
+ max = axis.toPixels(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);
+ }
+ });
+
+ // 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
+ }, chart.plotBox);
+ }
+
+
+
+ if (zoomHor) {
+ self.pinchTranslateDirection(true, pinchDown, touches, transform, selectionMarker, clip, lastValidTouch);
+ }
+ if (zoomVert) {
+ self.pinchTranslateDirection(false, 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 && followTouchMove && touchesLength === 1) {
+ this.runPointActions(self.normalize(e));
+ }
+ }
+ },
+
+ /**
+ * 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,
+ mouseDownX = this.mouseDownX,
+ mouseDownY = this.mouseDownY;
+
+ // 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) {
+ if (!this.selectionMarker) {
+ this.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 (this.selectionMarker && zoomHor) {
+ size = chartX - mouseDownX;
+ this.selectionMarker.attr({
+ width: mathAbs(size),
+ x: (size > 0 ? 0 : size) + mouseDownX
+ });
+ }
+ // adjust the height of the selection marker
+ if (this.selectionMarker && zoomVert) {
+ size = chartY - mouseDownY;
+ this.selectionMarker.attr({
+ height: mathAbs(size),
+ y: (size > 0 ? 0 : size) + mouseDownY
+ });
+ }
+
+ // panning
+ if (clickedInside && !this.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 chart = this.chart,
+ hasPinched = this.hasPinched;
+
+ if (this.selectionMarker) {
+ var selectionData = {
+ xAxis: [],
+ yAxis: [],
+ originalEvent: e.originalEvent || e
+ },
+ selectionBox = this.selectionMarker,
+ selectionLeft = selectionBox.x,
+ selectionTop = selectionBox.y,
+ runZoom;
+ // a selection has been made
+ if (this.hasDragged || hasPinched) {
+
+ // record each axis' min and max
+ each(chart.axes, function (axis) {
+ if (axis.zoomEnabled) {
+ var horiz = axis.horiz,
+ selectionMin = axis.toValue((horiz ? selectionLeft : selectionTop)),
+ selectionMax = axis.toValue((horiz ? selectionLeft + selectionBox.width : selectionTop + selectionBox.height));
+
+ if (!isNaN(selectionMin) && !isNaN(selectionMax)) { // #859
+ selectionData[axis.xOrY + 'Axis'].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) {
+ this.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,
+ hoverSeries = chart.hoverSeries;
+
+ e = this.normalize(e, chartPosition);
+
+ // If we're outside, hide the tooltip
+ if (chartPosition && hoverSeries && !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 () {
+ this.reset();
+ this.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;
+
+ // normalize
+ e = this.normalize(e);
+
+ // #295
+ e.returnValue = false;
+
+
+ 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;
+ if (series && !series.options.stickyTracking && !this.inClass(e.toElement || e.relatedTarget, PREFIX + 'tooltip')) {
+ series.onMouseOut();
+ }
+ },
+
+ onContainerClick: function (e) {
+ var chart = this.chart,
+ hoverPoint = chart.hoverPoint,
+ plotLeft = chart.plotLeft,
+ plotTop = chart.plotTop,
+ inverted = chart.inverted,
+ chartPosition,
+ plotX,
+ plotY;
+
+ e = this.normalize(e);
+ e.cancelBubble = true; // IE specific
+
+ if (!chart.cancelClick) {
+
+ // On tracker click, fire the series and point events. #783, #1583
+ if (hoverPoint && this.inClass(e.target, PREFIX + 'tracker')) {
+ chartPosition = this.chartPosition;
+ plotX = hoverPoint.plotX;
+ plotY = hoverPoint.plotY;
+
+ // add page position info
+ extend(hoverPoint, {
+ pageX: chartPosition.left + plotLeft +
+ (inverted ? chart.plotWidth - plotY : plotX),
+ pageY: chartPosition.top + plotTop +
+ (inverted ? chart.plotHeight - plotX : plotY)
+ });
+
+ // 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);
+ }
+ }
+
+
+ }
+ },
+
+ onContainerTouchStart: function (e) {
+ var chart = this.chart;
+
+ if (e.touches.length === 1) {
+
+ e = this.normalize(e);
+
+ if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
+
+ // Prevent the click pseudo event from firing unless it is set in the options
+ /*if (!chart.runChartClick) {
+ e.preventDefault();
+ }*/
+
+ // Run mouse events and display tooltip etc
+ this.runPointActions(e);
+
+ this.pinch(e);
+
+ } else {
+ // Hide the tooltip on touching outside the plot area (#1203)
+ this.reset();
+ }
+
+ } else if (e.touches.length === 2) {
+ this.pinch(e);
+ }
+ },
+
+ onContainerTouchMove: function (e) {
+ if (e.touches.length === 1 || e.touches.length === 2) {
+ this.pinch(e);
+ }
+ },
+
+ onDocumentTouchEnd: function (e) {
+ this.drop(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,
+ events;
+
+ this._events = events = [
+ [container, 'onmousedown', 'onContainerMouseDown'],
+ [container, 'onmousemove', 'onContainerMouseMove'],
+ [container, 'onclick', 'onContainerClick'],
+ [container, 'mouseleave', 'onContainerMouseLeave'],
+ [doc, 'mousemove', 'onDocumentMouseMove'],
+ [doc, 'mouseup', 'onDocumentMouseUp']
+ ];
+
+ if (hasTouch) {
+ events.push(
+ [container, 'ontouchstart', 'onContainerTouchStart'],
+ [container, 'ontouchmove', 'onContainerTouchMove'],
+ [doc, 'touchend', 'onDocumentTouchEnd']
+ );
+ }
+
+ each(events, function (eventConfig) {
+
+ // First, create the callback function that in turn calls the method on Pointer
+ pointer['_' + eventConfig[2]] = function (e) {
+ pointer[eventConfig[2]](e);
+ };
+
+ // Now attach the function, either as a direct property or through addEvent
+ if (eventConfig[1].indexOf('on') === 0) {
+ eventConfig[0][eventConfig[1]] = pointer['_' + eventConfig[2]];
+ } else {
+ addEvent(eventConfig[0], eventConfig[1], pointer['_' + eventConfig[2]]);
+ }
+ });
+
+
+ },
+
+ /**
+ * Destroys the Pointer object and disconnects DOM events.
+ */
+ destroy: function () {
+ var pointer = this;
+
+ // Release all DOM events
+ each(pointer._events, function (eventConfig) {
+ if (eventConfig[1].indexOf('on') === 0) {
+ eventConfig[0][eventConfig[1]] = null; // delete breaks oldIE
+ } else {
+ removeEvent(eventConfig[0], eventConfig[1], pointer['_' + eventConfig[2]]);
+ }
+ });
+ delete pointer._events;
+
+ // memory and CPU leak
+ clearInterval(pointer.tooltipTimeout);
+ }
+};
+/**
+ * The overview of the chart's series
+ */
+function Legend(chart, options) {
+ this.init(chart, options);
+}
+
+Legend.prototype = {
+
+ /**
+ * Initialize the legend
+ */
+ init: function (chart, options) {
+
+ var legend = this,
+ itemStyle = options.itemStyle,
+ padding = pick(options.padding, 8),
+ itemMarginTop = options.itemMarginTop || 0;
+
+ this.options = options;
+
+ if (!options.enabled) {
+ return;
+ }
+
+ legend.baseline = pInt(itemStyle.fontSize) + 3 + itemMarginTop; // used in Series prototype
+ legend.itemStyle = itemStyle;
+ legend.itemHiddenStyle = merge(itemStyle, options.itemHiddenStyle);
+ legend.itemMarginTop = itemMarginTop;
+ legend.padding = padding;
+ 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.lastLineHeight = 0;
+
+ // 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.color : hiddenColor,
+ markerOptions = item.options && item.options.marker,
+ symbolAttr = {
+ stroke: symbolColor,
+ 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
+ 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;
+
+ if (item.legendGroup) {
+ item.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.legendItemWidth + 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;
+ },
+
+ /**
+ * 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 = options.symbolWidth,
+ symbolPadding = options.symbolPadding,
+ itemStyle = legend.itemStyle,
+ itemHiddenStyle = legend.itemHiddenStyle,
+ padding = legend.padding,
+ itemDistance = horizontal ? pick(options.itemDistance, 8) : 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,
+ itemOptions = series.options,
+ showCheckbox = itemOptions.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);
+
+ // Draw the legend symbol inside the group box
+ series.drawLegendSymbol(legend, item);
+
+ // Generate the list item text and add it to the group
+ item.legendItem = li = renderer.text(
+ options.labelFormat ? format(options.labelFormat, item) : options.labelFormatter.call(item),
+ ltr ? symbolWidth + symbolPadding : -symbolPadding,
+ legend.baseline,
+ useHTML
+ )
+ .css(merge(item.visible ? itemStyle : itemHiddenStyle)) // merge to prevent modifying original (#1021)
+ .attr({
+ align: ltr ? 'left' : 'right',
+ zIndex: 2
+ })
+ .add(item.legendGroup);
+
+ // Set the events on the item group, or in case of useHTML, the item itself (#1249)
+ (useHTML ? li : item.legendGroup).on('mouseover', function () {
+ item.setState(HOVER_STATE);
+ li.css(legend.options.itemHoverStyle);
+ })
+ .on('mouseout', function () {
+ li.css(item.visible ? itemStyle : itemHiddenStyle);
+ item.setState();
+ })
+ .on('click', function (event) {
+ var strLegendItemClick = 'legendItemClick',
+ fnLegendItemClick = function () {
+ 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);
+ }
+ });
+
+ // Colorize the items
+ legend.colorizeItem(item, item.visible);
+
+ // add the HTML checkbox on top
+ if (itemOptions && showCheckbox) {
+ item.checkbox = createElement('input', {
+ type: 'checkbox',
+ checked: item.selected,
+ defaultChecked: item.selected // required by IE7
+ }, options.itemCheckboxStyle, chart.container);
+
+ addEvent(item.checkbox, 'click', function (event) {
+ var target = event.target;
+ fireEvent(item, 'checkboxClick', {
+ checked: target.checked
+ },
+ function () {
+ item.select();
+ }
+ );
+ });
+ }
+ }
+
+ // calculate the positions for the next line
+ bBox = li.getBBox();
+
+ itemWidth = item.legendItemWidth =
+ options.itemWidth || symbolWidth + symbolPadding + bBox.width + itemDistance +
+ (showCheckbox ? 20 : 0);
+ legend.itemHeight = itemHeight = bBox.height;
+
+ // if the item exceeds the width, start a new line
+ if (horizontal && legend.itemX - initialItemX + itemWidth >
+ (widthOption || (chart.chartWidth - 2 * padding - initialItemX))) {
+ legend.itemX = initialItemX;
+ legend.itemY += itemMarginTop + legend.lastLineHeight + itemMarginBottom;
+ legend.lastLineHeight = 0; // reset for next line
+ }
+
+ // 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
+ );
+ },
+
+ /**
+ * 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 = [];
+ each(chart.series, function (serie) {
+ var seriesOptions = serie.options;
+
+ if (!seriesOptions.showInLegend || defined(seriesOptions.linkedTo)) {
+ return;
+ }
+
+ // use points or series for the legend item depending on legendType
+ allItems = allItems.concat(
+ serie.legendItems ||
+ (seriesOptions.legendType === 'point' ?
+ serie.data :
+ serie)
+ );
+ });
+
+ // 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
+ each(allItems, function (item) {
+ legend.renderItem(item);
+ });
+
+ // Draw the border
+ legendWidth = options.width || legend.offsetWidth;
+ legendHeight = legend.lastItemY + legend.lastLineHeight + legend.titleHeight;
+
+
+ legendHeight = legend.handleOverflow(legendHeight);
+
+ if (legendBorderWidth || legendBackgroundColor) {
+ legendWidth += padding;
+ legendHeight += padding;
+
+ 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(null, null, null, legendWidth, 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,
+ pageCount,
+ 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;
+
+ // Adjust the height
+ if (options.layout === 'horizontal') {
+ spaceHeight /= 2;
+ }
+ if (maxHeight) {
+ spaceHeight = mathMin(spaceHeight, maxHeight);
+ }
+
+ // Reset the legend height and adjust the clipping rectangle
+ if (legendHeight > spaceHeight && !options.useHTML) {
+
+ this.clipHeight = clipHeight = spaceHeight - 20 - this.titleHeight;
+ this.pageCount = pageCount = mathCeil(legendHeight / clipHeight);
+ this.currentPage = pick(this.currentPage, 1);
+ this.fullHeight = legendHeight;
+
+ // Only apply clipping if needed. Clipping causes blurred legend in PDF export (#1787)
+ if (!clipRect) {
+ clipRect = legend.clipRect = renderer.clipRect(0, 0, 9999, 0);
+ legend.contentGroup.clip(clipRect);
+ }
+ clipRect.attr({
+ height: 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) {
+ clipRect.attr({
+ height: 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 pageCount = this.pageCount,
+ 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 + 7 + this.titleHeight,
+ visibility: VISIBLE
+ });
+ this.up.attr({
+ fill: currentPage === 1 ? inactiveColor : activeColor
+ })
+ .css({
+ cursor: currentPage === 1 ? 'default' : 'pointer'
+ });
+ pager.attr({
+ text: currentPage + '/' + this.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 = -mathMin(clipHeight * (currentPage - 1), this.fullHeight - clipHeight + padding) + 1;
+ this.scrollGroup.animate({
+ translateY: scrollOffset
+ });
+ pager.attr({
+ text: currentPage + '/' + pageCount
+ });
+
+
+ this.currentPage = currentPage;
+ this.positionCheckboxes(scrollOffset);
+ }
+
+ }
+
+};
+
+// Workaround for #2030, horizontal legend items not displaying in IE11 Preview.
+// TODO: When IE11 is released, check again for this bug, and remove the fix
+// or make a better one.
+if (/Trident.*?11\.0/.test(userAgent)) {
+ wrap(Legend.prototype, 'positionItem', function (proceed, item) {
+ var legend = this;
+ setTimeout(function () {
+ proceed.call(legend, item);
+ });
+ });
+}
+
+/**
+ * The chart class
+ * @param {Object} options
+ * @param {Function} callback Function to run when the chart has loaded
+ */
+function Chart() {
+ this.init.apply(this, arguments);
+}
+
+Chart.prototype = {
+
+ /**
+ * 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
+
+ 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);
+
+ // 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 = 0;
+ chart.counters = new ChartCounters();
+
+ 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;
+ },
+
+ /**
+ * 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);
+ }
+ },
+
+ /**
+ * 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;
+ },
+
+ /**
+ * Adjust all axes tick amounts
+ */
+ adjustTickAmounts: function () {
+ if (this.options.chart.alignTicks !== false) {
+ each(this.axes, function (axis) {
+ axis.adjustTickAmount();
+ });
+ }
+ this.maxTicks = null;
+ },
+
+ /**
+ * 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,
+ 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) { // prepare the data so axis can read it
+ if (serie.options.legendType === 'point') {
+ 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 (chart.hasCartesianSeries) {
+ if (!chart.isResizing) {
+
+ // reset maxTicks
+ chart.maxTicks = null;
+
+ // set axes scales
+ each(axes, function (axis) {
+ axis.setScale();
+ });
+ }
+
+ chart.adjustTickAmounts();
+ chart.getMargins();
+
+ // 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
+ if (axis.isDirtyExtremes) { // #821
+ axis.isDirtyExtremes = false;
+ 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) {
+ 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();
+ });
+ },
+
+
+
+ /**
+ * 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;
+
+ var loadingOptions = options.loading;
+
+ // 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
+ );
+
+ }
+
+ // update text
+ chart.loadingSpan.innerHTML = str || options.lang.loading;
+
+ // show it
+ if (!chart.loadingShown) {
+ css(loadingDiv, {
+ opacity: 0,
+ display: '',
+ left: chart.plotLeft + PX,
+ top: chart.plotTop + PX,
+ width: chart.plotWidth + PX,
+ height: chart.plotHeight + PX
+ });
+ animate(loadingDiv, {
+ opacity: loadingOptions.style.opacity
+ }, {
+ duration: loadingOptions.showDuration || 0
+ });
+ chart.loadingShown = true;
+ }
+ },
+
+ /**
+ * 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;
+ },
+
+ /**
+ * 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);
+ });
+
+ chart.adjustTickAmounts();
+ },
+
+
+ /**
+ * 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;
+ });
+ },
+
+ /**
+ * Generate stacks for each series and calculate stacks total values
+ */
+ 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, '');
+ }
+ });
+ },
+
+ /**
+ * 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;
+
+ if (axis.series.length && newMin > mathMin(extremes.dataMin, extremes.min) && 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' });
+ },
+
+ /**
+ * Show the title and subtitle of the chart
+ *
+ * @param titleOptions {Object} New title options
+ * @param subtitleOptions {Object} New subtitle options
+ *
+ */
+ setTitle: function (titleOptions, subtitleOptions) {
+ 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();
+ },
+
+ /**
+ * Lay out the chart titles and cache the full offset height for use in getMargins
+ */
+ layOutTitles: function () {
+ var titleOffset = 0,
+ title = this.title,
+ subtitle = this.subtitle,
+ options = this.options,
+ titleOptions = options.title,
+ subtitleOptions = options.subtitle,
+ autoWidth = this.spacingBox.width - 44; // 44 makes room for default context button
+
+ if (title) {
+ title
+ .css({ width: (titleOptions.width || autoWidth) + PX })
+ .align(extend({ y: 15 }, titleOptions), false, 'spacingBox');
+
+ if (!titleOptions.floating && !titleOptions.verticalAlign) {
+ titleOffset = title.getBBox().height;
+
+ // Adjust for browser consistency + backwards compat after #776 fix
+ if (titleOffset >= 18 && titleOffset <= 25) {
+ titleOffset = 15;
+ }
+ }
+ }
+ if (subtitle) {
+ subtitle
+ .css({ width: (subtitleOptions.width || autoWidth) + PX })
+ .align(extend({ y: titleOffset + titleOptions.margin }, subtitleOptions), false, 'spacingBox');
+
+ if (!subtitleOptions.floating && !subtitleOptions.verticalAlign) {
+ titleOffset = mathCeil(titleOffset + subtitle.getBBox().height);
+ }
+ }
+
+ this.titleOffset = titleOffset; // used in getMargins
+ },
+
+ /**
+ * Get chart width and height according to options and container size
+ */
+ getChartSize: function () {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ renderTo = chart.renderToClone || chart.renderTo;
+
+ // get inner width and height from jQuery (#824)
+ chart.containerWidth = adapterRun(renderTo, 'width');
+ chart.containerHeight = adapterRun(renderTo, 'height');
+
+ chart.chartWidth = mathMax(0, optionsChart.width || chart.containerWidth || 600); // #1393, 1460
+ chart.chartHeight = mathMax(0, pick(optionsChart.height,
+ // 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
+ });
+ 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,
+ optionsChart = chart.options.chart,
+ chartWidth,
+ chartHeight,
+ renderTo,
+ indexAttrName = 'data-highcharts-chart',
+ oldChartIndex,
+ 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
+ oldChartIndex = pInt(attr(renderTo, indexAttrName));
+ if (!isNaN(oldChartIndex) && charts[oldChartIndex]) {
+ 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
+ if (!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;
+
+ chart.renderer =
+ optionsChart.forExport ? // force SVG, used for SVG export
+ new SVGRenderer(container, chartWidth, chartHeight, true) :
+ new Renderer(container, chartWidth, chartHeight);
+
+ 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);
+ }
+ },
+
+ /**
+ * 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 () {
+ var chart = this,
+ spacing = chart.spacing,
+ axisOffset,
+ legend = chart.legend,
+ margin = chart.margin,
+ legendOptions = chart.options.legend,
+ legendMargin = pick(legendOptions.margin, 10),
+ legendX = legendOptions.x,
+ legendY = legendOptions.y,
+ align = legendOptions.align,
+ verticalAlign = legendOptions.verticalAlign,
+ titleOffset = chart.titleOffset;
+
+ chart.resetMargins();
+ axisOffset = chart.axisOffset;
+
+ // 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
+ if (legend.display && !legendOptions.floating) {
+ if (align === 'right') { // horizontal alignment handled first
+ if (!defined(margin[1])) {
+ chart.marginRight = mathMax(
+ chart.marginRight,
+ legend.legendWidth - legendX + legendMargin + spacing[1]
+ );
+ }
+ } else if (align === 'left') {
+ if (!defined(margin[3])) {
+ chart.plotLeft = mathMax(
+ chart.plotLeft,
+ legend.legendWidth + legendX + legendMargin + spacing[3]
+ );
+ }
+
+ } else if (verticalAlign === 'top') {
+ if (!defined(margin[0])) {
+ chart.plotTop = mathMax(
+ chart.plotTop,
+ legend.legendHeight + legendY + legendMargin + spacing[0]
+ );
+ }
+
+ } else if (verticalAlign === 'bottom') {
+ if (!defined(margin[2])) {
+ chart.marginBottom = mathMax(
+ chart.marginBottom,
+ legend.legendHeight - legendY + legendMargin + spacing[2]
+ );
+ }
+ }
+ }
+
+ // adjust for scroller
+ if (chart.extraBottomMargin) {
+ chart.marginBottom += chart.extraBottomMargin;
+ }
+ if (chart.extraTopMargin) {
+ chart.plotTop += chart.extraTopMargin;
+ }
+
+ // pre-render axes to get labels offset width
+ if (chart.hasCartesianSeries) {
+ each(chart.axes, function (axis) {
+ axis.getOffset();
+ });
+ }
+
+ if (!defined(margin[3])) {
+ chart.plotLeft += axisOffset[3];
+ }
+ if (!defined(margin[0])) {
+ chart.plotTop += axisOffset[0];
+ }
+ if (!defined(margin[2])) {
+ chart.marginBottom += axisOffset[2];
+ }
+ if (!defined(margin[1])) {
+ chart.marginRight += axisOffset[1];
+ }
+
+ chart.setChartSize();
+
+ },
+
+ /**
+ * Add the event handlers necessary for auto resizing
+ *
+ */
+ initReflow: function () {
+ var chart = this,
+ optionsChart = chart.options.chart,
+ renderTo = chart.renderTo,
+ reflowTimeout;
+
+ function reflow(e) {
+ var width = optionsChart.width || adapterRun(renderTo, 'width'),
+ height = optionsChart.height || adapterRun(renderTo, 'height'),
+ target = e ? e.target : win; // #805 - MooTools doesn't supply e
+
+ // Width and height checks for display:none. Target is doc in IE8 and Opera,
+ // win in Firefox, Chrome and IE9.
+ if (!chart.hasUserSize && width && height && (target === win || target === doc)) {
+
+ if (width !== chart.containerWidth || height !== chart.containerHeight) {
+ clearTimeout(reflowTimeout);
+ chart.reflowTimeout = reflowTimeout = setTimeout(function () {
+ if (chart.container) { // It may have been destroyed in the meantime (#1257)
+ chart.setSize(width, height, false);
+ chart.hasUserSize = null;
+ }
+ }, 100);
+ }
+ chart.containerWidth = width;
+ chart.containerHeight = height;
+ }
+ }
+ chart.reflow = reflow;
+ 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;
+
+ // 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));
+ }
+
+ css(chart.container, {
+ width: chartWidth + PX,
+ height: chartHeight + PX
+ });
+ chart.setChartSize(true);
+ chart.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.getMargins();
+
+ chart.redraw(animation);
+
+
+ chart.oldChartHeight = null;
+ fireEvent(chart, 'resize');
+
+ // fire endResize and set isResizing back
+ // If animation is disabled, fire without delay
+ 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: 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,
+ spacing = chart.spacing,
+ margin = chart.margin;
+
+ chart.plotTop = pick(margin[0], spacing[0]);
+ chart.marginRight = pick(margin[1], spacing[1]);
+ chart.marginBottom = pick(margin[2], spacing[2]);
+ chart.plotLeft = pick(margin[3], spacing[3]);
+ 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)
+ .add()
+ .shadow(optionsChart.shadow);
+
+ } else { // resize
+ chartBackground.animate(
+ chartBackground.crisp(null, null, null, chartWidth - mgn, 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,
+ zIndex: 1
+ })
+ .add();
+ } else {
+ plotBorder.animate(
+ plotBorder.crisp(null, plotLeft, plotTop, plotWidth, plotHeight)
+ );
+ }
+ }
+
+ // 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;
+ }
+ }
+ });
+ },
+
+ /**
+ * Render all graphics for the chart
+ */
+ render: function () {
+ var chart = this,
+ axes = chart.axes,
+ renderer = chart.renderer,
+ options = chart.options;
+
+ var labels = options.labels,
+ credits = options.credits,
+ creditsHref;
+
+ // Title
+ chart.setTitle();
+
+
+ // Legend
+ chart.legend = new Legend(chart, options.legend);
+
+ chart.getStacks(); // render stacks
+
+ // Get margins by pre-rendering axes
+ // set axes scales
+ each(axes, function (axis) {
+ axis.setScale();
+ });
+
+ chart.getMargins();
+
+ chart.maxTicks = null; // reset for second pass
+ each(axes, function (axis) {
+ axis.setTickPositions(true); // update to reflect the new margins
+ axis.setMaxTicks();
+ });
+ chart.adjustTickAmounts();
+ chart.getMargins(); // second pass to check for new labels
+
+
+ // Draw the borders and backgrounds
+ chart.drawChartBox();
+
+
+ // Axes
+ if (chart.hasCartesianSeries) {
+ each(axes, function (axis) {
+ axis.render();
+ });
+ }
+
+ // The series
+ if (!chart.seriesGroup) {
+ chart.seriesGroup = renderer.g('series-group')
+ .attr({ zIndex: 3 })
+ .add();
+ }
+ each(chart.series, function (serie) {
+ serie.translate();
+ serie.setTooltipPoints();
+ serie.render();
+ });
+
+ // 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;
+
+ renderer.text(
+ label.html,
+ x,
+ y
+ )
+ .attr({ zIndex: 2 })
+ .css(style)
+ .add();
+
+ });
+ }
+
+ // Credits
+ if (credits.enabled && !chart.credits) {
+ creditsHref = credits.href;
+ chart.credits = renderer.text(
+ credits.text,
+ 0,
+ 0
+ )
+ .on('click', function () {
+ if (creditsHref) {
+ location.href = creditsHref;
+ }
+ })
+ .attr({
+ align: credits.position.align,
+ zIndex: 8
+ })
+ .css(credits.style)
+ .add()
+ .align(credits.position);
+ }
+
+ // Set flag
+ chart.hasRendered = true;
+
+ },
+
+ /**
+ * 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;
+ 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
+ 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) {
+ fn.apply(chart, [chart]);
+ });
+
+
+ // If the chart was rendered outside the top container, put it back in
+ chart.cloneRenderTo(true);
+
+ fireEvent(chart, 'load');
+
+ },
+
+ /**
+ * 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
+
+// Hook for exporting module
+Chart.prototype.callbacks = [];
+/**
+ * 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.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.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,
+ pointArrayMap = series.pointArrayMap || ['y'],
+ valueCount = pointArrayMap.length,
+ firstItemType,
+ i = 0,
+ j = 0;
+
+ if (typeof options === 'number' || options === null) {
+ ret = { y: options };
+
+ } else if (isArray(options)) {
+ ret = {};
+ // with leading x value
+ if (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) {
+ ret[pointArrayMap[j++]] = options[i++];
+ }
+ } 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', 'group', '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 () {
+ var point = this;
+ return {
+ x: point.category,
+ y: point.y,
+ key: point.name || point.category,
+ series: point.series,
+ point: point,
+ percentage: point.percentage,
+ total: point.total || point.stackTotal
+ };
+ },
+
+ /**
+ * 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
+ */
+ onMouseOver: function (e) {
+ var point = this,
+ series = point.series,
+ chart = series.chart,
+ tooltip = chart.tooltip,
+ hoverPoint = chart.hoverPoint;
+
+ // set normal state to previous series
+ if (hoverPoint && hoverPoint !== point) {
+ hoverPoint.onMouseOut();
+ }
+
+ // 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);
+ chart.hoverPoint = point;
+ },
+
+ /**
+ * Runs on mouse out from the point
+ */
+ onMouseOut: function () {
+ var chart = this.series.chart,
+ hoverPoints = chart.hoverPoints;
+
+ if (!hoverPoints || inArray(this, hoverPoints) === -1) { // #887
+ this.firePointEvent('mouseOut');
+
+ this.setState();
+ chart.hoverPoint = null;
+ }
+ },
+
+ /**
+ * 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
+ });
+ },
+
+ /**
+ * 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) {
+ var point = this,
+ series = point.series,
+ graphic = point.graphic,
+ i,
+ data = series.data,
+ chart = series.chart,
+ seriesOptions = series.options;
+
+ redraw = pick(redraw, true);
+
+ // fire the event with a default handler of doing the update
+ point.firePointEvent('update', { options: options }, function () {
+
+ point.applyOptions(options);
+
+ // update visuals
+ if (isObject(options)) {
+ series.getAttribs();
+ if (graphic) {
+ if (options.marker && options.marker.symbol) {
+ point.graphic = graphic.destroy();
+ } else {
+ graphic.attr(point.pointAttr[point.state || '']);
+ }
+ }
+ }
+
+ // record changes in the parallel arrays
+ i = inArray(point, data);
+ series.xData[i] = point.x;
+ series.yData[i] = series.toYData ? series.toYData(point) : point.y;
+ series.zData[i] = point.z;
+ 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.legend.destroyItem(point);
+ }
+ if (redraw) {
+ chart.redraw(animation);
+ }
+ });
+ },
+
+ /**
+ * 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) {
+ var point = this,
+ series = point.series,
+ points = series.points,
+ chart = series.chart,
+ i,
+ data = series.data;
+
+ setAnimation(animation, chart);
+ redraw = pick(redraw, true);
+
+ // fire the event with a default handler of removing the point
+ point.firePointEvent('remove', null, function () {
+
+ // splice all the parallel arrays
+ i = inArray(point, data);
+ if (data.length === points.length) {
+ points.splice(i, 1);
+ }
+ data.splice(i, 1);
+ series.options.data.splice(i, 1);
+ series.xData.splice(i, 1);
+ series.yData.splice(i, 1);
+ series.zData.splice(i, 1);
+
+ point.destroy();
+
+
+ // redraw
+ series.isDirty = true;
+ series.isDirtyData = true;
+ if (redraw) {
+ chart.redraw();
+ }
+ });
+
+
+ },
+
+ /**
+ * 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
+ point.select(null, event.ctrlKey || event.metaKey || event.shiftKey);
+ };
+ }
+
+ fireEvent(this, eventType, eventArgs, defaultFunction);
+ },
+ /**
+ * 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) {
+ var point = this,
+ plotX = point.plotX,
+ 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,
+ newSymbol,
+ pointAttr = point.pointAttr;
+
+ state = state || NORMAL_STATE; // empty string
+
+ if (
+ // already has this state
+ state === point.state ||
+ // selected points don't respond to hover
+ (point.selected && state !== SELECT_STATE) ||
+ // series' state options is disabled
+ (stateOptions[state] && stateOptions[state].enabled === false) ||
+ // point marker's state options is disabled
+ (state && (stateDisabled || (normalDisabled && !markerStateOptions.enabled)))
+
+ ) {
+ return;
+ }
+
+ // apply hover styles to the existing point
+ if (point.graphic) {
+ radius = markerOptions && point.graphic.symbolName && pointAttr[state].r;
+ point.graphic.attr(merge(
+ pointAttr[state],
+ radius ? { // new symbol attributes (#507, #612)
+ x: plotX - radius,
+ y: plotY - radius,
+ width: 2 * radius,
+ height: 2 * radius
+ } : {}
+ ));
+ } 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) {
+ series.stateMarkerGraphic = stateMarkerGraphic = chart.renderer.symbol(
+ newSymbol,
+ plotX - radius,
+ plotY - radius,
+ 2 * radius,
+ 2 * radius
+ )
+ .attr(pointAttr[state])
+ .add(series.markerGroup);
+ stateMarkerGraphic.currentSymbol = newSymbol;
+
+ // Move the existing graphic
+ } else {
+ stateMarkerGraphic.attr({ // #1054
+ x: plotX - radius,
+ y: plotY - radius
+ });
+ }
+ }
+
+ if (stateMarkerGraphic) {
+ stateMarkerGraphic[state && chart.isInsidePlot(plotX, plotY) ? 'show' : 'hide']();
+ }
+ }
+
+ point.state = state;
+ }
+};
+
+/**
+ * @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 = 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'
+ },
+ colorCounter: 0,
+ init: function (chart, options) {
+ var series = this,
+ eventType,
+ events,
+ chartSeries = chart.series;
+
+ 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
+ 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)
+ stableSort(chartSeries, function (a, b) {
+ return pick(a.options.index, a._i) - pick(b.options.index, a._i);
+ });
+ 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;
+
+ if (series.isCartesian) {
+
+ each(['xAxis', 'yAxis'], 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]) {
+ error(18, true);
+ }
+
+ });
+ }
+ },
+
+
+ /**
+ * 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 series = this,
+ options = series.options,
+ xIncrement = series.xIncrement;
+
+ xIncrement = pick(xIncrement, options.pointStart, 0);
+
+ series.pointInterval = pick(series.pointInterval, options.pointInterval, 1);
+
+ series.xIncrement = xIncrement + series.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,
+ typeOptions = plotOptions[this.type],
+ options;
+
+ this.userOptions = itemOptions;
+
+ options = merge(
+ typeOptions,
+ plotOptions.series,
+ itemOptions
+ );
+
+ // the tooltip options are merged between global and series specific options
+ this.tooltipOptions = merge(chartOptions.tooltip, options.tooltip);
+
+ // Delte marker object if not allowed (#1125)
+ if (typeOptions.marker === null) {
+ delete options.marker;
+ }
+
+ return options;
+
+ },
+ /**
+ * Get the series' color
+ */
+ getColor: function () {
+ var options = this.options,
+ userOptions = this.userOptions,
+ defaultColors = this.chart.options.colors,
+ counters = this.chart.counters,
+ color,
+ colorIndex;
+
+ color = options.color || defaultPlotOptions[this.type].color;
+
+ if (!color && !options.colorByPoint) {
+ if (defined(userOptions._colorIndex)) { // after Series.update()
+ colorIndex = userOptions._colorIndex;
+ } else {
+ userOptions._colorIndex = counters.color;
+ colorIndex = counters.color++;
+ }
+ color = defaultColors[colorIndex];
+ }
+
+ this.color = color;
+ counters.wrapColor(defaultColors.length);
+ },
+ /**
+ * Get the series' symbol
+ */
+ getSymbol: function () {
+ var series = this,
+ userOptions = series.userOptions,
+ seriesMarkerOption = series.options.marker,
+ chart = series.chart,
+ defaultSymbols = chart.options.symbols,
+ counters = chart.counters,
+ symbolIndex;
+
+ series.symbol = seriesMarkerOption.symbol;
+ if (!series.symbol) {
+ if (defined(userOptions._symbolIndex)) { // after Series.update()
+ symbolIndex = userOptions._symbolIndex;
+ } else {
+ userOptions._symbolIndex = counters.symbol;
+ symbolIndex = counters.symbol++;
+ }
+ series.symbol = defaultSymbols[symbolIndex];
+ }
+
+ // don't substract radius in image symbols (#604)
+ if (/^url/.test(series.symbol)) {
+ seriesMarkerOption.radius = 0;
+ }
+ counters.wrapSymbol(defaultSymbols.length);
+ },
+
+ /**
+ * 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
+ */
+ drawLegendSymbol: function (legend) {
+
+ var options = this.options,
+ markerOptions = options.marker,
+ radius,
+ legendOptions = legend.options,
+ legendSymbol,
+ symbolWidth = legendOptions.symbolWidth,
+ renderer = this.chart.renderer,
+ legendItemGroup = this.legendGroup,
+ verticalCenter = legend.baseline - mathRound(renderer.fontMetrics(legendOptions.itemStyle.fontSize).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) {
+ radius = markerOptions.radius;
+ this.legendSymbol = legendSymbol = renderer.symbol(
+ this.symbol,
+ (symbolWidth / 2) - radius,
+ verticalCenter - radius,
+ 2 * radius,
+ 2 * radius
+ )
+ .add(legendItemGroup);
+ legendSymbol.isMarker = true;
+ }
+ },
+
+ /**
+ * 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,
+ xData = series.xData,
+ yData = series.yData,
+ zData = series.zData,
+ names = series.names,
+ currentShift = (graph && graph.shift) || 0,
+ dataOptions = seriesOptions.data,
+ point,
+ isInTheMiddle,
+ x,
+ i;
+
+ setAnimation(animation, chart);
+
+ // Make graph animate sideways
+ if (shift) {
+ each([graph, area, series.graphNeg, series.areaNeg], function (shape) {
+ if (shape) {
+ shape.shift = currentShift + 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--;
+ }
+ }
+
+ xData.splice(i, 0, x);
+ yData.splice(i, 0, series.toYData ? series.toYData(point) : point.y);
+ zData.splice(i, 0, point.z);
+ if (names) {
+ 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();
+ xData.shift();
+ yData.shift();
+ zData.shift();
+ dataOptions.shift();
+ }
+ }
+
+ // redraw
+ series.isDirty = true;
+ series.isDirtyData = true;
+ if (redraw) {
+ series.getAttribs(); // #1937
+ chart.redraw();
+ }
+ },
+
+ /**
+ * Replace the series data with a new set of data
+ * @param {Object} data
+ * @param {Object} redraw
+ */
+ setData: function (data, redraw) {
+ var series = this,
+ oldData = series.points,
+ options = series.options,
+ chart = series.chart,
+ firstPoint = null,
+ xAxis = series.xAxis,
+ names = xAxis && xAxis.categories && !xAxis.categories.length ? [] : null,
+ i;
+
+ // reset properties
+ series.xIncrement = null;
+ series.pointRange = xAxis && xAxis.categories ? 1 : options.pointRange;
+
+ series.colorCounter = 0; // for series with colorByPoint (#1547)
+
+ // parallel arrays
+ var xData = [],
+ yData = [],
+ zData = [],
+ dataLength = data ? data.length : [],
+ turboThreshold = pick(options.turboThreshold, 1000),
+ pt,
+ pointArrayMap = series.pointArrayMap,
+ valueCount = pointArrayMap && pointArrayMap.length,
+ hasToYData = !!series.toYData;
+
+ // 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]]);
+ xData[i] = pt.x;
+ yData[i] = hasToYData ? series.toYData(pt) : pt.y;
+ zData[i] = pt.z;
+ if (names && pt.name) {
+ 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.xData = xData;
+ series.yData = yData;
+ series.zData = zData;
+ series.names = names;
+
+ // destroy old points
+ i = (oldData && oldData.length) || 0;
+ 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;
+ if (pick(redraw, true)) {
+ chart.redraw(false);
+ }
+ },
+
+ /**
+ * 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;
+ },
+
+ /**
+ * 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,
+ isCartesian = series.isCartesian;
+
+ // 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;
+ }
+
+
+ // optionally filter out points outside the plot area
+ if (isCartesian && series.sorted && (!cropThreshold || dataLength > cropThreshold || series.forceCrop)) {
+ var min = xAxis.min,
+ max = xAxis.max;
+
+ // 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])));
+ }
+ }
+
+ // 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;
+ },
+
+ /**
+ * Adds series' points value to corresponding stack
+ */
+ 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,
+ stackOption = seriesOptions.stack,
+ stacking = seriesOptions.stacking,
+ stackKey = series.stackKey,
+ negKey = '-' + stackKey,
+ negStacks = series.negStacks,
+ yAxis = series.yAxis,
+ stacks = yAxis.stacks,
+ oldStacks = yAxis.oldStacks,
+ isNegative,
+ stack,
+ other,
+ key,
+ i,
+ x,
+ y;
+
+ // 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];
+
+ // 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 < 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, stacking);
+ }
+ }
+
+ // If the StackItem doesn't exist, create it first
+ stack = stacks[key][x];
+ stack.points[series.index] = [stack.cum || 0];
+
+ // 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 += mathAbs(y) || 0;
+ }
+ } else {
+ stack.total += y || 0;
+ }
+
+ stack.cum = (stack.cum || 0) + (y || 0);
+
+ stack.points[series.index].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
+ */
+ setPercentStacks: function () {
+ var series = this,
+ stackKey = series.stackKey,
+ stacks = series.yAxis.stacks;
+
+ each([stackKey, '-' + stackKey], function (key) {
+ var i = series.xData.length,
+ x,
+ stack,
+ pointExtremes,
+ totalFactor;
+
+ while (i--) {
+ x = series.xData[i];
+ stack = stacks[key] && stacks[key][x];
+ pointExtremes = stack && stack.points[series.index];
+ 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];
+ }
+ }
+ });
+ },
+
+ /**
+ * Calculate Y extremes for visible data
+ */
+ getExtremes: function () {
+ var xAxis = this.xAxis,
+ yAxis = this.yAxis,
+ xData = this.processedXData,
+ yData = this.stackedYData || this.processedYData,
+ yDataLength = yData.length,
+ activeYData = [],
+ activeCounter = 0,
+ xExtremes = xAxis.getExtremes(), // #2117, need to compensate for log X axis
+ xMin = xExtremes.min,
+ xMax = xExtremes.max,
+ validValue,
+ withinRange,
+ dataMin,
+ dataMax,
+ x,
+ y,
+ i,
+ j;
+
+ 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.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 = pick(dataMin, arrayMin(activeYData));
+ this.dataMax = pick(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;
+
+
+ // Translate each point
+ for (i = 0; i < dataLength; i++) {
+ var point = points[i],
+ xValue = point.x,
+ yValue = point.y,
+ yBottom = point.low,
+ stack = yAxis.stacks[(series.negStacks && yValue < threshold ? '-' : '') + series.stackKey],
+ pointStack,
+ stackValues;
+
+ // Discard disallowed y values for log axes
+ if (yAxis.isLog && yValue <= 0) {
+ point.y = yValue = null;
+ }
+
+ // Get the plotX translation
+ point.plotX = xAxis.translate(xValue, 0, 0, 0, 1, pointPlacement, this.type === 'flags'); // Math.round fixes #591
+
+
+ // Calculate the bottom y value for stacked series
+ if (stacking && series.visible && stack && stack[xValue]) {
+
+ pointStack = stack[xValue];
+ stackValues = pointStack.points[series.index];
+ yBottom = stackValues[0];
+ yValue = stackValues[1];
+
+ if (yBottom === 0) {
+ yBottom = pick(threshold, yAxis.min);
+ }
+ if (yAxis.isLog && yBottom <= 0) { // #1200, #1232
+ yBottom = null;
+ }
+
+ point.percentage = stacking === 'percent' && yValue;
+ point.total = point.stackTotal = pointStack.total;
+ 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 = (typeof yValue === 'number' && yValue !== Infinity) ?
+ //mathRound(yAxis.translate(yValue, 0, 1, 0, 1) * 10) / 10 : // Math.round fixes #591
+ yAxis.translate(yValue, 0, 1, 0, 1) :
+ UNDEFINED;
+
+ // Set client related positions for mouse tracking
+ point.clientX = dynamicallyPlaced ? xAxis.translate(xValue, 0, 0, 0, 1) : point.plotX; // #1514
+
+ point.negative = point.y < (threshold || 0);
+
+ // some API data
+ point.category = categories && categories[point.x] !== UNDEFINED ?
+ categories[point.x] : point.x;
+
+
+ }
+
+ // now that we have the cropped data, build the segments
+ series.getSegments();
+ },
+ /**
+ * Memoize tooltip texts and positions
+ */
+ setTooltipPoints: function (renew) {
+ var series = this,
+ points = [],
+ pointsLength,
+ low,
+ high,
+ xAxis = series.xAxis,
+ xExtremes = xAxis && xAxis.getExtremes(),
+ axisLength = xAxis ? (xAxis.tooltipLen || xAxis.len) : series.chart.plotSizeX, // tooltipLen and tooltipPosName used in polar
+ point,
+ pointX,
+ nextPoint,
+ i,
+ tooltipPoints = []; // a lookup array for each pixel in the x dimension
+
+ // don't waste resources if tracker is disabled
+ if (series.options.enableMouseTracking === false) {
+ return;
+ }
+
+ // renew
+ if (renew) {
+ series.tooltipPoints = null;
+ }
+
+ // concat segments to overcome null values
+ each(series.segments || series.points, function (segment) {
+ points = points.concat(segment);
+ });
+
+ // Reverse the points in case the X axis is reversed
+ if (xAxis && xAxis.reversed) {
+ points = points.reverse();
+ }
+
+ // Polar needs additional shaping
+ if (series.orderTooltipPoints) {
+ series.orderTooltipPoints(points);
+ }
+
+ // Assign each pixel position to the nearest point
+ pointsLength = points.length;
+ for (i = 0; i < pointsLength; i++) {
+ point = points[i];
+ pointX = point.x;
+ if (pointX >= xExtremes.min && pointX <= xExtremes.max) { // #1149
+ nextPoint = points[i + 1];
+
+ // Set this range's low to the last range's high plus one
+ low = high === UNDEFINED ? 0 : high + 1;
+ // Now find the new high
+ high = points[i + 1] ?
+ mathMin(mathMax(0, mathFloor( // #2070
+ (point.clientX + (nextPoint ? (nextPoint.wrappedClientX || nextPoint.clientX) : axisLength)) / 2
+ )), axisLength) :
+ axisLength;
+
+ while (low >= 0 && low <= high) {
+ tooltipPoints[low++] = point;
+ }
+ }
+ }
+ series.tooltipPoints = tooltipPoints;
+ },
+
+ /**
+ * Format the header of the tooltip
+ */
+ tooltipHeaderFormatter: function (point) {
+ var series = this,
+ tooltipOptions = series.tooltipOptions,
+ xDateFormat = tooltipOptions.xDateFormat,
+ dateTimeLabelFormats = tooltipOptions.dateTimeLabelFormats,
+ xAxis = series.xAxis,
+ isDateTime = xAxis && xAxis.options.type === 'datetime',
+ headerFormat = tooltipOptions.headerFormat,
+ closestPointRange = xAxis && xAxis.closestPointRange,
+ n;
+
+ // Guess the best date format based on the closest point distance (#568)
+ if (isDateTime && !xDateFormat) {
+ if (closestPointRange) {
+ for (n in timeUnits) {
+ if (timeUnits[n] >= closestPointRange) {
+ xDateFormat = dateTimeLabelFormats[n];
+ break;
+ }
+ }
+ } else {
+ xDateFormat = dateTimeLabelFormats.day;
+ }
+ }
+
+ // Insert the header date format if any
+ if (isDateTime && xDateFormat && isNumber(point.key)) {
+ headerFormat = headerFormat.replace('{point.key}', '{point.key:' + xDateFormat + '}');
+ }
+
+ return format(headerFormat, {
+ point: point,
+ series: series
+ });
+ },
+
+ /**
+ * 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;
+
+ // 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();
+ chart.hoverSeries = null;
+ },
+
+ /**
+ * Animate in the series
+ */
+ animate: function (init) {
+ var series = this,
+ chart = series.chart,
+ renderer = chart.renderer,
+ clipRect,
+ markerClipRect,
+ animation = series.options.animation,
+ clipBox = chart.clipBox,
+ inverted = chart.inverted,
+ sharedClipKey;
+
+ // Animation option is set to true
+ if (animation && !isObject(animation)) {
+ animation = defaultPlotOptions[series.type].animation;
+ }
+ sharedClipKey = '_sharedClip' + animation.duration + animation.easing;
+
+ // Initialize the animation. Set up the clipping rectangle.
+ if (init) {
+
+ // If a clipping rectangle with the same properties is currently present in the chart, use that.
+ clipRect = chart[sharedClipKey];
+ markerClipRect = chart[sharedClipKey + 'm'];
+ if (!clipRect) {
+ chart[sharedClipKey] = clipRect = renderer.clipRect(
+ extend(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
+ );
+ }
+ series.group.clip(clipRect);
+ series.markerGroup.clip(markerClipRect);
+ series.sharedClipKey = sharedClipKey;
+
+ // Run the animation
+ } else {
+ clipRect = chart[sharedClipKey];
+ if (clipRect) {
+ clipRect.animate({
+ width: chart.plotSizeX
+ }, animation);
+ chart[sharedClipKey + 'm'].animate({
+ width: chart.plotSizeX + 99
+ }, animation);
+ }
+
+ // Delete this function to allow it only once
+ series.animate = null;
+
+ // Call the afterAnimate function on animation complete (but don't overwrite the animation.complete option
+ // which should be available to the user).
+ series.animationTimeout = setTimeout(function () {
+ series.afterAnimate();
+ }, animation.duration);
+ }
+ },
+
+ /**
+ * This runs after animation to land on the final plot clipping
+ */
+ afterAnimate: function () {
+ var chart = this.chart,
+ sharedClipKey = this.sharedClipKey,
+ group = this.group;
+
+ if (group && this.options.clip !== false) {
+ group.clip(chart.clipRect);
+ this.markerGroup.clip(); // no clip
+ }
+
+ // Remove the shared clipping rectancgle when all series are shown
+ setTimeout(function () {
+ if (sharedClipKey && chart[sharedClipKey]) {
+ chart[sharedClipKey] = chart[sharedClipKey].destroy();
+ chart[sharedClipKey + 'm'] = chart[sharedClipKey + 'm'].destroy();
+ }
+ }, 100);
+ },
+
+ /**
+ * 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,
+ pointMarkerOptions,
+ enabled,
+ isInside,
+ markerGroup = series.markerGroup;
+
+ if (seriesMarkerOptions.enabled || series._hasPointMarkers) {
+
+ i = points.length;
+ while (i--) {
+ point = points[i];
+ plotX = mathFloor(point.plotX); // #1843
+ plotY = point.plotY;
+ graphic = point.graphic;
+ pointMarkerOptions = point.marker || {};
+ enabled = (seriesMarkerOptions.enabled && pointMarkerOptions.enabled === UNDEFINED) || pointMarkerOptions.enabled;
+ isInside = chart.isInsidePlot(mathRound(plotX), plotY, chart.inverted); // #1858
+
+ // 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];
+ radius = pointAttr.r;
+ symbol = pick(pointMarkerOptions.symbol, series.symbol);
+ isImage = symbol.indexOf('url') === 0;
+
+ if (graphic) { // update
+ graphic
+ .attr({ // Since the marker group isn't clipped, each individual marker must be toggled
+ visibility: isInside ? (hasSVG ? 'inherit' : VISIBLE) : HIDDEN
+ })
+ .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
+ )
+ .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,
+ normalDefaults = {
+ stroke: seriesColor,
+ fill: seriesColor
+ },
+ points = series.points || [], // #927
+ i,
+ point,
+ seriesPointAttr = [],
+ pointAttr,
+ pointAttrToOptions = series.pointAttrToOptions,
+ hasPointSpecificOptions,
+ negativeColor = seriesOptions.negativeColor,
+ defaultLineColor = normalOptions.lineColor,
+ 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 + 2;
+ stateOptionsHover.lineWidth = stateOptionsHover.lineWidth || normalOptions.lineWidth + 1;
+
+ } 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();
+ }
+
+ // 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;
+ while (i--) {
+ point = points[i];
+ normalOptions = (point.options && point.options.marker) || point.options;
+ if (normalOptions && normalOptions.enabled === false) {
+ normalOptions.radius = 0;
+ }
+
+ if (point.negative && negativeColor) {
+ point.color = point.fillColor = negativeColor;
+ }
+
+ 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) { // column, bar, point
+ // if no hover color is given, brighten the normal color
+ pointStateOptionsHover.color =
+ Color(pointStateOptionsHover.color || point.color)
+ .brighten(pointStateOptionsHover.brightness ||
+ stateOptionsHover.brightness).get();
+
+ }
+
+ // normal point state inherits series wide normal state
+ pointAttr[NORMAL_STATE] = series.convertAttribs(extend({
+ color: point.color, // #868
+ fillColor: point.color, // Individual point color or negative color markers (#2219)
+ lineColor: defaultLineColor === null ? point.color : UNDEFINED // Bubbles take point color, line markers use white
+ }, 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;
+
+ }
+
+ },
+ /**
+ * Update the series with a new set of options
+ */
+ update: function (newOptions, redraw) {
+ var 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,
+ n;
+
+ // 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 reinsert methods from the type prototype
+ this.remove(false);
+ for (n in proto) { // Overwrite series-type specific methods (#2270)
+ if (proto.hasOwnProperty(n)) {
+ this[n] = UNDEFINED;
+ }
+ }
+ extend(this, seriesTypes[newOptions.type || oldType].prototype);
+
+
+ this.init(chart, newOptions);
+ if (pick(redraw, true)) {
+ chart.redraw(false);
+ }
+ },
+
+ /**
+ * 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(['xAxis', 'yAxis'], function (AXIS) {
+ axis = series[AXIS];
+ if (axis) {
+ erase(axis.series, series);
+ axis.isDirty = axis.forceRedraw = true;
+ axis.stacks = {}; // Rebuild stacks when updating (#2229)
+ }
+ });
+
+ // 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
+ each(['area', 'graph', 'dataLabelsGroup', 'group', 'markerGroup', 'tracker',
+ 'graphNeg', 'areaNeg', 'posClip', 'negClip'], function (prop) {
+ if (series[prop]) {
+
+ // 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];
+ }
+ },
+
+ /**
+ * Draw the data labels
+ */
+ drawDataLabels: function () {
+
+ var series = this,
+ seriesOptions = series.options,
+ options = seriesOptions.dataLabels,
+ points = series.points,
+ pointOptions,
+ generalOptions,
+ str,
+ dataLabelsGroup;
+
+ 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',
+ series.visible ? VISIBLE : HIDDEN,
+ options.zIndex || 6
+ );
+
+ // 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;
+
+ // Determine if each data label is enabled
+ pointOptions = point.options && point.options.dataLabels;
+ 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);
+
+ rotation = options.rotation;
+
+ // Get the string
+ labelConfig = point.getLabelConfig();
+ str = options.format ?
+ format(options.format, labelConfig) :
+ options.formatter.call(labelConfig, options);
+
+ // Determine the color
+ options.style.color = pick(options.color, options.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
+ };
+ // Remove unused attributes (#947)
+ for (name in attr) {
+ if (attr[name] === UNDEFINED) {
+ delete attr[name];
+ }
+ }
+
+ dataLabel = point.dataLabel = series.chart.renderer[rotation ? 'text' : 'label']( // labels don't support rotation
+ str,
+ 0,
+ -999,
+ null,
+ null,
+ null,
+ options.useHTML
+ )
+ .attr(attr)
+ .css(options.style)
+ .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
+ */
+ 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(),
+ visible = this.visible && chart.isInsidePlot(point.plotX, point.plotY, 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
+ alignAttr = {
+ align: options.align,
+ x: alignTo.x + options.x + alignTo.width / 2,
+ y: alignTo.y + options.y + alignTo.height / 2
+ };
+ dataLabel[isNew ? 'attr' : 'animate'](alignAttr);
+ } else {
+ dataLabel.align(options, null, alignTo);
+ alignAttr = dataLabel.alignAttr;
+
+ // Handle justify or crop
+ if (pick(options.overflow, 'justify') === 'justify') { // docs: overflow: justify, also crop only applies when not 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);
+
+ }
+ }
+ }
+
+ // Show or hide based on the final aligned position
+ if (!visible) {
+ dataLabel.attr({ y: -999 });
+ }
+
+ },
+
+ /**
+ * If data labels fall partly outside the plot area, align them back in, in a way that
+ * doesn't hide the point.
+ */
+ justifyDataLabel: function (dataLabel, options, alignAttr, bBox, alignTo, isNew) {
+ var chart = this.chart,
+ align = options.align,
+ verticalAlign = options.verticalAlign,
+ off,
+ justified;
+
+ // Off left
+ off = alignAttr.x;
+ if (off < 0) {
+ if (align === 'right') {
+ options.align = 'left';
+ } else {
+ options.x = -off;
+ }
+ justified = true;
+ }
+
+ // Off right
+ off = alignAttr.x + bBox.width;
+ if (off > chart.plotWidth) {
+ if (align === 'left') {
+ options.align = 'right';
+ } else {
+ options.x = chart.plotWidth - off;
+ }
+ justified = true;
+ }
+
+ // Off top
+ off = alignAttr.y;
+ if (off < 0) {
+ if (verticalAlign === 'bottom') {
+ options.verticalAlign = 'top';
+ } else {
+ options.y = -off;
+ }
+ justified = true;
+ }
+
+ // Off bottom
+ off = alignAttr.y + bBox.height;
+ 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);
+ }
+ },
+
+ /**
+ * 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
+ );
+
+ } else if (step === 'center') {
+ segmentPath.push(
+ (lastPoint.plotX + plotX) / 2,
+ lastPoint.plotY,
+ (lastPoint.plotX + plotX) / 2,
+ plotY
+ );
+
+ } else {
+ segmentPath.push(
+ plotX,
+ lastPoint.plotY
+ );
+ }
+ }
+
+ // 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]],
+ lineWidth = options.lineWidth,
+ dashStyle = options.dashStyle,
+ graphPath = this.getGraphPath(),
+ negativeColor = options.negativeColor;
+
+ if (negativeColor) {
+ props.push(['graphNeg', negativeColor]);
+ }
+
+ // draw the graph
+ each(props, function (prop, i) {
+ var graphKey = prop[0],
+ graph = series[graphKey],
+ attribs;
+
+ if (graph) {
+ stop(graph); // cancel running animations, #459
+ graph.animate({ d: graphPath });
+
+ } else if (lineWidth && graphPath.length) { // #1487
+ attribs = {
+ stroke: prop[1],
+ 'stroke-width': lineWidth,
+ zIndex: 1 // #1069
+ };
+ if (dashStyle) {
+ attribs.dashstyle = dashStyle;
+ } else {
+ attribs['stroke-linecap'] = attribs['stroke-linejoin'] = 'round';
+ }
+
+ series[graphKey] = series.chart.renderer.path(graphPath)
+ .attr(attribs)
+ .add(series.group)
+ .shadow(!i && options.shadow);
+ }
+ });
+ },
+
+ /**
+ * Clip the graphs into the positive and negative coloured graphs
+ */
+ clipNeg: function () {
+ var options = this.options,
+ chart = this.chart,
+ renderer = chart.renderer,
+ negativeColor = options.negativeColor || options.negativeFillColor,
+ translatedThreshold,
+ posAttr,
+ negAttr,
+ graph = this.graph,
+ area = this.area,
+ posClip = this.posClip,
+ negClip = this.negClip,
+ chartWidth = chart.chartWidth,
+ chartHeight = chart.chartHeight,
+ chartSizeMax = mathMax(chartWidth, chartHeight),
+ yAxis = this.yAxis,
+ above,
+ below;
+
+ if (negativeColor && (graph || area)) {
+ translatedThreshold = mathRound(yAxis.toPixels(options.threshold || 0, true));
+ above = {
+ x: 0,
+ y: 0,
+ width: chartSizeMax,
+ height: translatedThreshold
+ };
+ below = {
+ x: 0,
+ y: translatedThreshold,
+ width: chartSizeMax,
+ height: chartSizeMax
+ };
+
+ if (chart.inverted) {
+
+ above.height = below.y = chart.plotWidth - translatedThreshold;
+ if (renderer.isVML) {
+ above = {
+ x: chart.plotWidth - translatedThreshold - chart.plotLeft,
+ y: 0,
+ width: chartWidth,
+ height: chartHeight
+ };
+ below = {
+ x: translatedThreshold + chart.plotLeft - chartWidth,
+ y: 0,
+ width: chart.plotLeft + translatedThreshold,
+ height: chartWidth
+ };
+ }
+ }
+
+ if (yAxis.reversed) {
+ posAttr = below;
+ negAttr = above;
+ } else {
+ posAttr = above;
+ negAttr = below;
+ }
+
+ if (posClip) { // update
+ posClip.animate(posAttr);
+ negClip.animate(negAttr);
+ } else {
+
+ this.posClip = posClip = renderer.clipRect(posAttr);
+ this.negClip = negClip = renderer.clipRect(negAttr);
+
+ if (graph && this.graphNeg) {
+ graph.clip(posClip);
+ this.graphNeg.clip(negClip);
+ }
+
+ if (area) {
+ area.clip(posClip);
+ this.areaNeg.clip(negClip);
+ }
+ }
+ }
+ },
+
+ /**
+ * 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);
+ }
+ // 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 () {
+ return {
+ translateX: this.xAxis ? this.xAxis.left : this.chart.plotLeft,
+ translateY: this.yAxis ? this.yAxis.top : this.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,
+ doAnimation = animation && !!series.animate &&
+ chart.renderer.isSVG, // this animation doesn't work in IE8 quirks when the group div is hidden,
+ // and looks bad in other oldIE
+ 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 (doAnimation) {
+ 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.clipNeg();
+ }
+
+ // draw the data labels (inn pies they go before the points)
+ series.drawDataLabels();
+
+ // draw the points
+ series.drawPoints();
+
+
+ // draw the mouse tracking area
+ if (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
+ if (options.clip !== false && !series.sharedClipKey && !hasRendered) {
+ group.clip(chart.clipRect);
+ }
+
+ // Run the animation
+ if (doAnimation) {
+ series.animate();
+ } else if (!hasRendered) {
+ 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
+ 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.setTooltipPoints(true);
+
+ series.render();
+ if (wasDirtyData) {
+ fireEvent(series, 'updatedData');
+ }
+ },
+
+ /**
+ * Set the state of the graph
+ */
+ setState: function (state) {
+ var series = this,
+ options = series.options,
+ graph = series.graph,
+ graphNeg = series.graphNeg,
+ stateOptions = options.states,
+ lineWidth = options.lineWidth,
+ attribs;
+
+ 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 + 1;
+ }
+
+ 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);
+ if (graphNeg) {
+ graphNeg.attr(attribs);
+ }
+ }
+ }
+ },
+
+ /**
+ * 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) {
+ 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');
+ },
+
+ /**
+ * 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.
+ */
+ drawTracker: 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();
+ }
+ };
+
+ // 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 Series prototype
+
+
+/**
+ * LineSeries object
+ */
+var LineSeries = extendClass(Series);
+seriesTypes.line = LineSeries;
+
+/**
+ * Set the default options for area
+ */
+defaultPlotOptions.area = merge(defaultSeriesOptions, {
+ 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 segments = [],
+ segment = [],
+ keys = [],
+ xAxis = this.xAxis,
+ yAxis = this.yAxis,
+ stack = yAxis.stacks[this.stackKey],
+ pointMap = {},
+ plotX,
+ plotY,
+ points = this.points,
+ connectNulls = this.options.connectNulls,
+ val,
+ 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) {
+ keys.push(+x);
+ }
+ keys.sort(function (a, b) {
+ return a - b;
+ });
+
+ each(keys, function (x) {
+ 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 {
+ plotX = xAxis.translate(x);
+ val = stack[x].percent ? (stack[x].total ? stack[x].cum * 100 / stack[x].total : 0) : stack[x].cum; // #1991
+ plotY = yAxis.toPixels(val, true);
+ 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,
+ negativeColor = options.negativeColor,
+ negativeFillColor = options.negativeFillColor,
+ props = [['area', this.color, options.fillColor]]; // area name, main color, fill color
+
+ if (negativeColor || negativeFillColor) {
+ props.push(['areaNeg', negativeColor, negativeFillColor]);
+ }
+
+ 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);
+ }
+ });
+ },
+
+ /**
+ * 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) {
+
+ item.legendSymbol = this.chart.renderer.rect(
+ 0,
+ legend.baseline - 11,
+ legend.options.symbolWidth,
+ 12,
+ 2
+ ).attr({
+ zIndex: 3
+ }).add(item.legendGroup);
+
+ }
+});
+
+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: areaProto.drawLegendSymbol
+ });
+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
+ },
+ select: {
+ color: '#C0C0C0',
+ borderColor: '#000000',
+ shadow: false
+ }
+ },
+ dataLabels: {
+ align: null, // auto
+ verticalAlign: null, // auto
+ y: null
+ },
+ stickyTracking: false,
+ threshold: 0
+});
+
+/**
+ * ColumnSeries object
+ */
+var ColumnSeries = extendClass(Series, {
+ type: 'column',
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ stroke: 'borderColor',
+ 'stroke-width': 'borderWidth',
+ fill: 'color',
+ r: 'borderRadius'
+ },
+ cropShoulder: 0,
+ 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 || 1),
+ xAxis.len // #1535
+ ),
+ groupPadding = categoryWidth * options.groupPadding,
+ groupWidth = categoryWidth - 2 * groupPadding,
+ pointOffsetWidth = groupWidth / columnCount,
+ optionPointWidth = options.pointWidth,
+ pointPadding = defined(optionPointWidth) ? (pointOffsetWidth - optionPointWidth) / 2 :
+ pointOffsetWidth * options.pointPadding,
+ pointWidth = pick(optionPointWidth, pointOffsetWidth - 2 * pointPadding), // exact point width, used in polar charts
+ 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
+ });
+
+ },
+
+ /**
+ * 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 = options.borderWidth,
+ 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 = mathCeil(mathMax(pointWidth, 1 + 2 * borderWidth)), // rounded and postprocessed for border width
+ pointXOffset = series.pointXOffset = metrics.offset,
+ xCrisp = -(borderWidth % 2 ? 0.5 : 0),
+ yCrisp = borderWidth % 2 ? 0.5 : 1;
+
+ if (chart.renderer.isVML && chart.inverted) {
+ yCrisp += 1;
+ }
+
+ Series.prototype.translate.apply(series);
+
+ // record the new values
+ each(series.points, function (point) {
+ var yBottom = pick(point.yBottom, translatedThreshold),
+ plotY = mathMin(mathMax(-999 - yBottom, point.plotY), yAxis.len + 999 + yBottom), // Don't draw too far outside plot area (#1303, #2241)
+ barX = point.plotX + pointXOffset,
+ barW = seriesBarW,
+ barY = mathMin(plotY, yBottom),
+ right,
+ bottom,
+ fromTop,
+ fromLeft,
+ barH = mathMax(plotY, yBottom) - barY;
+
+ // Handle options.minPointLength
+ if (mathAbs(barH) < minPointLength) {
+ if (minPointLength) {
+ barH = minPointLength;
+ barY =
+ mathRound(mathAbs(barY - translatedThreshold) > minPointLength ? // stacked
+ yBottom - minPointLength : // keep position
+ translatedThreshold - (yAxis.translate(point.y, 0, 1, 0, 1) <= translatedThreshold ? minPointLength : 0)); // use exact yAxis.translation (#1485)
+ }
+ }
+
+ // Cache for access in polar
+ point.barX = barX;
+ point.pointWidth = pointWidth;
+
+
+ // Round off to obtain crisp edges
+ fromLeft = mathAbs(barX) < 0.5;
+ right = mathRound(barX + barW) + xCrisp;
+ barX = mathRound(barX) + xCrisp;
+ barW = right - barX;
+
+ fromTop = mathAbs(barY) < 0.5;
+ bottom = mathRound(barY + barH) + yCrisp;
+ barY = mathRound(barY) + yCrisp;
+ barH = bottom - barY;
+
+ // Top and left edges are exceptions
+ if (fromLeft) {
+ barX += 1;
+ barW -= 1;
+ }
+ if (fromTop) {
+ barY -= 1;
+ barH += 1;
+ }
+
+ // Register shape type and arguments to be used in drawPoints
+ point.shapeType = 'rect';
+ point.shapeArgs = {
+ x: barX,
+ y: barY,
+ width: barW,
+ height: barH
+ };
+ });
+
+ },
+
+ getSymbol: noop,
+
+ /**
+ * Use a solid rectangle like the area series types
+ */
+ drawLegendSymbol: AreaSeries.prototype.drawLegendSymbol,
+
+
+ /**
+ * 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,
+ options = series.options,
+ renderer = series.chart.renderer,
+ shapeArgs;
+
+
+ // draw the columns
+ each(series.points, function (point) {
+ var plotY = point.plotY,
+ graphic = point.graphic;
+
+ if (plotY !== UNDEFINED && !isNaN(plotY) && point.y !== null) {
+ shapeArgs = point.shapeArgs;
+
+ if (graphic) { // update
+ stop(graphic);
+ graphic.animate(merge(shapeArgs));
+
+ } else {
+ point.graphic = graphic = renderer[point.shapeType](shapeArgs)
+ .attr(point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE])
+ .add(series.group)
+ .shadow(options.shadow, null, options.stacking && !options.borderRadius);
+ }
+
+ } else if (graphic) {
+ point.graphic = graphic.destroy(); // #1269
+ }
+ });
+ },
+
+ /**
+ * Add tracking event listener to the series group, so the point graphics
+ * themselves act as trackers
+ */
+ drawTracker: 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;
+
+ if (chart.hoverSeries !== series) {
+ series.onMouseOver();
+ }
+ 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;
+ }
+ },
+
+ /**
+ * Override the basic data label alignment by adjusting for the position of the column
+ */
+ alignDataLabel: function (point, dataLabel, options, alignTo, isNew) {
+ var chart = this.chart,
+ inverted = chart.inverted,
+ dlBox = point.dlBox || point.shapeArgs, // data label box for alignment
+ below = point.below || (point.plotY > pick(this.translatedThreshold, chart.plotSizeY)),
+ 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: chart.plotWidth - alignTo.y - alignTo.height,
+ y: chart.plotHeight - 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);
+ },
+
+
+ /**
+ * 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,
+ tooltip: {
+ headerFormat: '<span style="font-size: 10px; color:{series.color}">{series.name}</span><br/>',
+ pointFormat: 'x: <b>{point.x}</b><br/>y: <b>{point.y}</b><br/>',
+ followPointer: true
+ },
+ stickyTracking: false
+});
+
+/**
+ * The scatter series class
+ */
+var ScatterSeries = extendClass(Series, {
+ type: 'scatter',
+ sorted: false,
+ requireSorting: false,
+ noSharedTooltip: true,
+ trackerGroups: ['markerGroup'],
+
+ drawTracker: ColumnSeries.prototype.drawTracker,
+
+ setTooltipPoints: noop
+});
+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 () {
+ return this.point.name;
+ }
+ // softConnector: true,
+ //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;
+
+ // Disallow negative values (#1530)
+ if (point.y < 0) {
+ point.y = null;
+ }
+
+ //visible: options.visible !== false,
+ extend(point, {
+ visible: point.visible !== false,
+ 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) {
+ var point = this,
+ series = point.series,
+ chart = series.chart,
+ method;
+
+ // 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
+
+ method = vis ? 'show' : 'hide';
+
+ // Show and hide associated elements
+ each(['graphic', 'dataLabel', 'connector', 'shadowGroup'], function (key) {
+ if (point[key]) {
+ point[key][method]();
+ }
+ });
+
+ if (point.legendItem) {
+ chart.legend.colorizeItem(point, vis);
+ }
+
+ // Handle ignore hidden slices
+ if (!series.isDirty && series.options.ignoreHiddenPoint) {
+ series.isDirty = true;
+ 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);
+ }
+
+ }
+});
+
+/**
+ * The Pie series class
+ */
+var PieSeries = {
+ type: 'pie',
+ isCartesian: false,
+ pointClass: PiePoint,
+ requireSorting: false,
+ noSharedTooltip: true,
+ trackerGroups: ['group', 'dataLabelsGroup'],
+ pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
+ stroke: 'borderColor',
+ 'stroke-width': 'borderWidth',
+ fill: 'color'
+ },
+
+ /**
+ * Pies have one color each point
+ */
+ getColor: noop,
+
+ /**
+ * 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: 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;
+ }
+ },
+
+ /**
+ * 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();
+ }
+ },
+
+ /**
+ * Extend the generatePoints method by adding total and percentage properties to each point
+ */
+ generatePoints: function () {
+ var i,
+ total = 0,
+ points,
+ len,
+ point,
+ ignoreHiddenPoint = this.options.ignoreHiddenPoint;
+
+ Series.prototype.generatePoints.call(this);
+
+ // Populate local vars
+ points = this.points;
+ len = points.length;
+
+ // 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.y / total) * 100 : 0;
+ point.total = total;
+ }
+
+ },
+
+ /**
+ * 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),
+ isPercent;
+
+ return map(positions, function (length, i) {
+ isPercent = /%$/.test(length);
+ handleSlicingRoom = i < 2 || (i === 2 && isPercent);
+ return (isPercent ?
+ // i == 0: centerX, relative to width
+ // i == 1: centerY, relative to height
+ // i == 2: size, relative to smallestSize
+ // i == 4: innerSize, relative to smallestSize
+ [plotWidth, plotHeight, smallestSize, smallestSize][i] *
+ pInt(length) / 100 :
+ length) + (handleSlicingRoom ? slicingRoom : 0);
+ });
+ },
+
+ /**
+ * 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 * ((options.endAngle || (startAngle + 360)) - 90), // docs
+ 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((y - positions[1]) / (positions[2] / 2 + labelDistance));
+
+ 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
+ };
+
+ // center for the sliced out slice
+ angle = (end + start) / 2;
+ if (angle > 0.75 * circ) {
+ angle -= 2 * mathPI;
+ }
+ 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
+ ];
+
+ }
+ },
+
+ setTooltipPoints: noop,
+ 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;
+
+ if (shadow && !series.shadowGroup) {
+ series.shadowGroup = renderer.g('shadow')
+ .add(series.group);
+ }
+
+ // draw the slices
+ each(series.points, function (point) {
+ 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.animate(extend(shapeArgs, groupTranslation));
+ } else {
+ point.graphic = graphic = renderer.arc(shapeArgs)
+ .setRadialReference(series.center)
+ .attr(
+ point.pointAttr[point.selected ? SELECT_STATE : NORMAL_STATE]
+ )
+ .attr({ 'stroke-linejoin': 'round' })
+ .attr(groupTranslation)
+ .add(series.group)
+ .shadow(shadow, shadowGroup);
+ }
+
+ // detect point specific visibility
+ if (point.visible === false) {
+ point.setVisible(false);
+ }
+
+ });
+
+ },
+
+ /**
+ * Utility for sorting data labels
+ */
+ sortByAngle: function (points, sign) {
+ points.sort(function (a, b) {
+ return a.angle !== undefined && (b.angle - a.angle) * sign;
+ });
+ },
+
+ /**
+ * Override the base drawDataLabels method by pie specific functionality
+ */
+ 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) { // it may have been cancelled in the base method (#407)
+ halves[point.half].push(point);
+ }
+ });
+
+ // assume equal label heights
+ i = 0;
+ while (!labelHeight && data[i]) { // #1569
+ labelHeight = data[i] && data[i].dataLabel && (data[i].dataLabel.getBBox().height || 21); // 21 is for #968
+ i++;
+ }
+
+ /* 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,
+ length = points.length,
+ slotIndex;
+
+ // Sort by angle
+ series.sortByAngle(points, i - 0.5);
+
+ // Only do anti-collision when we are outside the pie and have connectors (#856)
+ if (distanceOption > 0) {
+
+ // build the slots
+ for (pos = centerY - radius - distanceOption; pos <= centerY + radius + distanceOption; pos += labelHeight) {
+ slots.push(pos);
+
+ // visualize the slot
+ /*
+ var slotX = series.getX(pos, i) + chart.plotLeft - (i ? 100 : 0),
+ slotY = pos + chart.plotTop;
+ if (!isNaN(slotX)) {
+ chart.renderer.rect(slotX, slotY - 7, 100, labelHeight, 1)
+ .attr({
+ 'stroke-width': 1,
+ stroke: 'silver'
+ })
+ .add();
+ chart.renderer.text('Slot '+ (slots.length - 1), slotX, slotY + 4)
+ .attr({
+ fill: 'silver'
+ }).add();
+ }
+ */
+ }
+ slotsLength = slots.length;
+
+ // 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 : VISIBLE;
+ 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 = naturalY;
+ }
+
+ } 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(slotIndex === 0 || slotIndex === slots.length - 1 ? 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) {
+ 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
+ })
+ .add(series.group);
+ }
+ } else if (connector) {
+ point.connector = connector.destroy();
+ }
+ });
+ }
+ }
+ },
+
+ /**
+ * 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.
+ */
+ 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;
+ this.translate(center);
+ each(this.points, function (point) {
+ if (point.dataLabel) {
+ point.dataLabel._pos = null; // reset
+ }
+ });
+ this.drawDataLabels();
+
+ // Else, return true to indicate that the pie and its labels is within the plot area
+ } else {
+ ret = true;
+ }
+ return ret;
+ },
+
+ /**
+ * Perform the final placement of the data labels after we have verified that they
+ * fall within the plot area.
+ */
+ placeDataLabels: function () {
+ each(this.points, function (point) {
+ var dataLabel = point.dataLabel,
+ _pos;
+
+ if (dataLabel) {
+ _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 });
+ }
+ }
+ });
+ },
+
+ alignDataLabel: noop,
+
+ /**
+ * Draw point specific tracker objects. Inherit directly from column series.
+ */
+ drawTracker: ColumnSeries.prototype.drawTracker,
+
+ /**
+ * Use a simple symbol from column prototype
+ */
+ drawLegendSymbol: AreaSeries.prototype.drawLegendSymbol,
+
+ /**
+ * Pies don't have point marker symbols
+ */
+ getSymbol: noop
+
+};
+PieSeries = extendClass(Series, PieSeries);
+seriesTypes.pie = PieSeries;
+
+
+// global variables
+extend(Highcharts, {
+
+ // Constructors
+ Axis: Axis,
+ Chart: Chart,
+ Color: Color,
+ Legend: Legend,
+ Pointer: Pointer,
+ Point: Point,
+ Tick: Tick,
+ Tooltip: Tooltip,
+ Renderer: Renderer,
+ Series: Series,
+ SVGElement: SVGElement,
+ SVGRenderer: SVGRenderer,
+
+ // Various
+ arrayMin: arrayMin,
+ arrayMax: arrayMax,
+ charts: charts,
+ dateFormat: dateFormat,
+ format: format,
+ pathAnim: pathAnim,
+ getOptions: getOptions,
+ hasBidiBug: hasBidiBug,
+ isTouchDevice: isTouchDevice,
+ numberFormat: numberFormat,
+ seriesTypes: seriesTypes,
+ setOptions: setOptions,
+ addEvent: addEvent,
+ removeEvent: removeEvent,
+ createElement: createElement,
+ discardElement: discardElement,
+ css: css,
+ each: each,
+ extend: extend,
+ map: map,
+ merge: merge,
+ pick: pick,
+ splat: splat,
+ extendClass: extendClass,
+ pInt: pInt,
+ wrap: wrap,
+ svg: hasSVG,
+ canvas: useCanVG,
+ vml: !hasSVG && !useCanVG,
+ product: PRODUCT,
+ version: VERSION
+});
+}());
--
Gitblit v1.8.0