corrade-nucleus-nucleons – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /**
2 * @license Highcharts JS v5.0.10 (2017-03-31)
3 * Highcharts Drilldown module
4 *
5 * Author: Torstein Honsi
6 * License: www.highcharts.com/license
7 *
8 */
9 'use strict';
10 (function(factory) {
11 if (typeof module === 'object' && module.exports) {
12 module.exports = factory;
13 } else {
14 factory(Highcharts);
15 }
16 }(function(Highcharts) {
17 (function(H) {
18 /**
19 * Highcharts Drilldown module
20 *
21 * Author: Torstein Honsi
22 * License: www.highcharts.com/license
23 *
24 */
25  
26  
27 var noop = H.noop,
28 color = H.color,
29 defaultOptions = H.defaultOptions,
30 each = H.each,
31 extend = H.extend,
32 format = H.format,
33 pick = H.pick,
34 wrap = H.wrap,
35 Chart = H.Chart,
36 seriesTypes = H.seriesTypes,
37 PieSeries = seriesTypes.pie,
38 ColumnSeries = seriesTypes.column,
39 Tick = H.Tick,
40 fireEvent = H.fireEvent,
41 inArray = H.inArray,
42 ddSeriesId = 1;
43  
44 // Utilities
45 /*
46 * Return an intermediate color between two colors, according to pos where 0
47 * is the from color and 1 is the to color. This method is copied from ColorAxis.js
48 * and should always be kept updated, until we get AMD support.
49 */
50 function tweenColors(from, to, pos) {
51 // Check for has alpha, because rgba colors perform worse due to lack of
52 // support in WebKit.
53 var hasAlpha,
54 ret;
55  
56 // Unsupported color, return to-color (#3920)
57 if (!to.rgba.length || !from.rgba.length) {
58 ret = to.input || 'none';
59  
60 // Interpolate
61 } else {
62 from = from.rgba;
63 to = to.rgba;
64 hasAlpha = (to[3] !== 1 || from[3] !== 1);
65 ret = (hasAlpha ? 'rgba(' : 'rgb(') +
66 Math.round(to[0] + (from[0] - to[0]) * (1 - pos)) + ',' +
67 Math.round(to[1] + (from[1] - to[1]) * (1 - pos)) + ',' +
68 Math.round(to[2] + (from[2] - to[2]) * (1 - pos)) +
69 (hasAlpha ? (',' + (to[3] + (from[3] - to[3]) * (1 - pos))) : '') + ')';
70 }
71 return ret;
72 }
73 /**
74 * Handle animation of the color attributes directly
75 */
76 each(['fill', 'stroke'], function(prop) {
77 H.Fx.prototype[prop + 'Setter'] = function() {
78 this.elem.attr(
79 prop,
80 tweenColors(color(this.start), color(this.end), this.pos),
81 null,
82 true
83 );
84 };
85 });
86  
87 // Add language
88 extend(defaultOptions.lang, {
89 drillUpText: '◁ Back to {series.name}'
90 });
91 defaultOptions.drilldown = {
92  
93 animation: {
94 duration: 500
95 },
96 drillUpButton: {
97 position: {
98 align: 'right',
99 x: -10,
100 y: 10
101 }
102 // relativeTo: 'plotBox'
103 // theme
104 }
105 };
106  
107 /**
108 * A general fadeIn method
109 */
110 H.SVGRenderer.prototype.Element.prototype.fadeIn = function(animation) {
111 this
112 .attr({
113 opacity: 0.1,
114 visibility: 'inherit'
115 })
116 .animate({
117 opacity: pick(this.newOpacity, 1) // newOpacity used in maps
118 }, animation || {
119 duration: 250
120 });
121 };
122  
123 Chart.prototype.addSeriesAsDrilldown = function(point, ddOptions) {
124 this.addSingleSeriesAsDrilldown(point, ddOptions);
125 this.applyDrilldown();
126 };
127 Chart.prototype.addSingleSeriesAsDrilldown = function(point, ddOptions) {
128 var oldSeries = point.series,
129 xAxis = oldSeries.xAxis,
130 yAxis = oldSeries.yAxis,
131 newSeries,
132 pointIndex,
133 levelSeries = [],
134 levelSeriesOptions = [],
135 level,
136 levelNumber,
137 last,
138 colorProp;
139  
140  
141  
142 colorProp = {
143 colorIndex: pick(point.colorIndex, oldSeries.colorIndex)
144 };
145  
146  
147 if (!this.drilldownLevels) {
148 this.drilldownLevels = [];
149 }
150  
151 levelNumber = oldSeries.options._levelNumber || 0;
152  
153 // See if we can reuse the registered series from last run
154 last = this.drilldownLevels[this.drilldownLevels.length - 1];
155 if (last && last.levelNumber !== levelNumber) {
156 last = undefined;
157 }
158  
159 ddOptions = extend(extend({
160 _ddSeriesId: ddSeriesId++
161 }, colorProp), ddOptions);
162 pointIndex = inArray(point, oldSeries.points);
163  
164 // Record options for all current series
165 each(oldSeries.chart.series, function(series) {
166 if (series.xAxis === xAxis && !series.isDrilling) {
167 series.options._ddSeriesId = series.options._ddSeriesId || ddSeriesId++;
168 series.options._colorIndex = series.userOptions._colorIndex;
169 series.options._levelNumber = series.options._levelNumber || levelNumber; // #3182
170  
171 if (last) {
172 levelSeries = last.levelSeries;
173 levelSeriesOptions = last.levelSeriesOptions;
174 } else {
175 levelSeries.push(series);
176 levelSeriesOptions.push(series.options);
177 }
178 }
179 });
180  
181 // Add a record of properties for each drilldown level
182 level = extend({
183 levelNumber: levelNumber,
184 seriesOptions: oldSeries.options,
185 levelSeriesOptions: levelSeriesOptions,
186 levelSeries: levelSeries,
187 shapeArgs: point.shapeArgs,
188 bBox: point.graphic ? point.graphic.getBBox() : {}, // no graphic in line series with markers disabled
189 color: point.isNull ? new H.Color(color).setOpacity(0).get() : color,
190 lowerSeriesOptions: ddOptions,
191 pointOptions: oldSeries.options.data[pointIndex],
192 pointIndex: pointIndex,
193 oldExtremes: {
194 xMin: xAxis && xAxis.userMin,
195 xMax: xAxis && xAxis.userMax,
196 yMin: yAxis && yAxis.userMin,
197 yMax: yAxis && yAxis.userMax
198 }
199 }, colorProp);
200  
201 // Push it to the lookup array
202 this.drilldownLevels.push(level);
203  
204 newSeries = level.lowerSeries = this.addSeries(ddOptions, false);
205 newSeries.options._levelNumber = levelNumber + 1;
206 if (xAxis) {
207 xAxis.oldPos = xAxis.pos;
208 xAxis.userMin = xAxis.userMax = null;
209 yAxis.userMin = yAxis.userMax = null;
210 }
211  
212 // Run fancy cross-animation on supported and equal types
213 if (oldSeries.type === newSeries.type) {
214 newSeries.animate = newSeries.animateDrilldown || noop;
215 newSeries.options.animation = true;
216 }
217 };
218  
219 Chart.prototype.applyDrilldown = function() {
220 var drilldownLevels = this.drilldownLevels,
221 levelToRemove;
222  
223 if (drilldownLevels && drilldownLevels.length > 0) { // #3352, async loading
224 levelToRemove = drilldownLevels[drilldownLevels.length - 1].levelNumber;
225 each(this.drilldownLevels, function(level) {
226 if (level.levelNumber === levelToRemove) {
227 each(level.levelSeries, function(series) {
228 if (series.options && series.options._levelNumber === levelToRemove) { // Not removed, not added as part of a multi-series drilldown
229 series.remove(false);
230 }
231 });
232 }
233 });
234 }
235  
236 this.redraw();
237 this.showDrillUpButton();
238 };
239  
240 Chart.prototype.getDrilldownBackText = function() {
241 var drilldownLevels = this.drilldownLevels,
242 lastLevel;
243 if (drilldownLevels && drilldownLevels.length > 0) { // #3352, async loading
244 lastLevel = drilldownLevels[drilldownLevels.length - 1];
245 lastLevel.series = lastLevel.seriesOptions;
246 return format(this.options.lang.drillUpText, lastLevel);
247 }
248  
249 };
250  
251 Chart.prototype.showDrillUpButton = function() {
252 var chart = this,
253 backText = this.getDrilldownBackText(),
254 buttonOptions = chart.options.drilldown.drillUpButton,
255 attr,
256 states;
257  
258  
259 if (!this.drillUpButton) {
260 attr = buttonOptions.theme;
261 states = attr && attr.states;
262  
263 this.drillUpButton = this.renderer.button(
264 backText,
265 null,
266 null,
267 function() {
268 chart.drillUp();
269 },
270 attr,
271 states && states.hover,
272 states && states.select
273 )
274 .addClass('highcharts-drillup-button')
275 .attr({
276 align: buttonOptions.position.align,
277 zIndex: 7
278 })
279 .add()
280 .align(buttonOptions.position, false, buttonOptions.relativeTo || 'plotBox');
281 } else {
282 this.drillUpButton.attr({
283 text: backText
284 })
285 .align();
286 }
287 };
288  
289 Chart.prototype.drillUp = function() {
290 var chart = this,
291 drilldownLevels = chart.drilldownLevels,
292 levelNumber = drilldownLevels[drilldownLevels.length - 1].levelNumber,
293 i = drilldownLevels.length,
294 chartSeries = chart.series,
295 seriesI,
296 level,
297 oldSeries,
298 newSeries,
299 oldExtremes,
300 addSeries = function(seriesOptions) {
301 var addedSeries;
302 each(chartSeries, function(series) {
303 if (series.options._ddSeriesId === seriesOptions._ddSeriesId) {
304 addedSeries = series;
305 }
306 });
307  
308 addedSeries = addedSeries || chart.addSeries(seriesOptions, false);
309 if (addedSeries.type === oldSeries.type && addedSeries.animateDrillupTo) {
310 addedSeries.animate = addedSeries.animateDrillupTo;
311 }
312 if (seriesOptions === level.seriesOptions) {
313 newSeries = addedSeries;
314 }
315 };
316  
317 while (i--) {
318  
319 level = drilldownLevels[i];
320 if (level.levelNumber === levelNumber) {
321 drilldownLevels.pop();
322  
323 // Get the lower series by reference or id
324 oldSeries = level.lowerSeries;
325 if (!oldSeries.chart) { // #2786
326 seriesI = chartSeries.length; // #2919
327 while (seriesI--) {
328 if (chartSeries[seriesI].options.id === level.lowerSeriesOptions.id &&
329 chartSeries[seriesI].options._levelNumber === levelNumber + 1) { // #3867
330 oldSeries = chartSeries[seriesI];
331 break;
332 }
333 }
334 }
335 oldSeries.xData = []; // Overcome problems with minRange (#2898)
336  
337 each(level.levelSeriesOptions, addSeries);
338  
339 fireEvent(chart, 'drillup', {
340 seriesOptions: level.seriesOptions
341 });
342  
343 if (newSeries.type === oldSeries.type) {
344 newSeries.drilldownLevel = level;
345 newSeries.options.animation = chart.options.drilldown.animation;
346  
347 if (oldSeries.animateDrillupFrom && oldSeries.chart) { // #2919
348 oldSeries.animateDrillupFrom(level);
349 }
350 }
351 newSeries.options._levelNumber = levelNumber;
352  
353 oldSeries.remove(false);
354  
355 // Reset the zoom level of the upper series
356 if (newSeries.xAxis) {
357 oldExtremes = level.oldExtremes;
358 newSeries.xAxis.setExtremes(oldExtremes.xMin, oldExtremes.xMax, false);
359 newSeries.yAxis.setExtremes(oldExtremes.yMin, oldExtremes.yMax, false);
360 }
361 }
362 }
363  
364 // Fire a once-off event after all series have been drilled up (#5158)
365 fireEvent(chart, 'drillupall');
366  
367 this.redraw();
368  
369 if (this.drilldownLevels.length === 0) {
370 this.drillUpButton = this.drillUpButton.destroy();
371 } else {
372 this.drillUpButton.attr({
373 text: this.getDrilldownBackText()
374 })
375 .align();
376 }
377  
378 this.ddDupes.length = []; // #3315
379 };
380  
381  
382 ColumnSeries.prototype.supportsDrilldown = true;
383  
384 /**
385 * When drilling up, keep the upper series invisible until the lower series has
386 * moved into place
387 */
388 ColumnSeries.prototype.animateDrillupTo = function(init) {
389 if (!init) {
390 var newSeries = this,
391 level = newSeries.drilldownLevel;
392  
393 // First hide all items before animating in again
394 each(this.points, function(point) {
395 var dataLabel = point.dataLabel;
396  
397 if (point.graphic) { // #3407
398 point.graphic.hide();
399 }
400  
401 if (dataLabel) {
402 // The data label is initially hidden, make sure it is not faded
403 // in (#6127)
404 dataLabel.hidden = dataLabel.attr('visibility') === 'hidden';
405  
406 if (!dataLabel.hidden) {
407 dataLabel.hide();
408 if (point.connector) {
409 point.connector.hide();
410 }
411 }
412 }
413 });
414  
415  
416 // Do dummy animation on first point to get to complete
417 setTimeout(function() {
418 if (newSeries.points) { // May be destroyed in the meantime, #3389
419 each(newSeries.points, function(point, i) {
420 // Fade in other points
421 var verb =
422 i === (level && level.pointIndex) ? 'show' : 'fadeIn',
423 inherit = verb === 'show' ? true : undefined,
424 dataLabel = point.dataLabel;
425  
426  
427 if (point.graphic) { // #3407
428 point.graphic[verb](inherit);
429 }
430  
431 if (dataLabel && !dataLabel.hidden) { // #6127
432 dataLabel[verb](inherit);
433 if (point.connector) {
434 point.connector[verb](inherit);
435 }
436 }
437 });
438 }
439 }, Math.max(this.chart.options.drilldown.animation.duration - 50, 0));
440  
441 // Reset
442 this.animate = noop;
443 }
444  
445 };
446  
447 ColumnSeries.prototype.animateDrilldown = function(init) {
448 var series = this,
449 drilldownLevels = this.chart.drilldownLevels,
450 animateFrom,
451 animationOptions = this.chart.options.drilldown.animation,
452 xAxis = this.xAxis;
453  
454 if (!init) {
455 each(drilldownLevels, function(level) {
456 if (series.options._ddSeriesId === level.lowerSeriesOptions._ddSeriesId) {
457 animateFrom = level.shapeArgs;
458  
459 }
460 });
461  
462 animateFrom.x += (pick(xAxis.oldPos, xAxis.pos) - xAxis.pos);
463  
464 each(this.points, function(point) {
465 var animateTo = point.shapeArgs;
466  
467  
468  
469 if (point.graphic) {
470 point.graphic
471 .attr(animateFrom)
472 .animate(
473 extend(point.shapeArgs, {
474 fill: point.color || series.color
475 }),
476 animationOptions
477 );
478 }
479 if (point.dataLabel) {
480 point.dataLabel.fadeIn(animationOptions);
481 }
482 });
483 this.animate = null;
484 }
485  
486 };
487  
488 /**
489 * When drilling up, pull out the individual point graphics from the lower series
490 * and animate them into the origin point in the upper series.
491 */
492 ColumnSeries.prototype.animateDrillupFrom = function(level) {
493 var animationOptions = this.chart.options.drilldown.animation,
494 group = this.group,
495 series = this;
496  
497 // Cancel mouse events on the series group (#2787)
498 each(series.trackerGroups, function(key) {
499 if (series[key]) { // we don't always have dataLabelsGroup
500 series[key].on('mouseover');
501 }
502 });
503  
504  
505 delete this.group;
506 each(this.points, function(point) {
507 var graphic = point.graphic,
508 animateTo = level.shapeArgs,
509 complete = function() {
510 graphic.destroy();
511 if (group) {
512 group = group.destroy();
513 }
514 };
515  
516 if (graphic) {
517  
518 delete point.graphic;
519  
520  
521  
522 if (animationOptions) {
523 graphic.animate(
524 animateTo,
525 H.merge(animationOptions, {
526 complete: complete
527 })
528 );
529 } else {
530 graphic.attr(animateTo);
531 complete();
532 }
533 }
534 });
535 };
536  
537 if (PieSeries) {
538 extend(PieSeries.prototype, {
539 supportsDrilldown: true,
540 animateDrillupTo: ColumnSeries.prototype.animateDrillupTo,
541 animateDrillupFrom: ColumnSeries.prototype.animateDrillupFrom,
542  
543 animateDrilldown: function(init) {
544 var level = this.chart.drilldownLevels[this.chart.drilldownLevels.length - 1],
545 animationOptions = this.chart.options.drilldown.animation,
546 animateFrom = level.shapeArgs,
547 start = animateFrom.start,
548 angle = animateFrom.end - start,
549 startAngle = angle / this.points.length;
550  
551 if (!init) {
552 each(this.points, function(point, i) {
553 var animateTo = point.shapeArgs;
554  
555  
556  
557 if (point.graphic) {
558 point.graphic
559 .attr(H.merge(animateFrom, {
560 start: start + i * startAngle,
561 end: start + (i + 1) * startAngle
562 }))[animationOptions ? 'animate' : 'attr'](
563 animateTo,
564 animationOptions
565 );
566 }
567 });
568 this.animate = null;
569 }
570 }
571 });
572 }
573  
574 H.Point.prototype.doDrilldown = function(_holdRedraw, category, originalEvent) {
575 var series = this.series,
576 chart = series.chart,
577 drilldown = chart.options.drilldown,
578 i = (drilldown.series || []).length,
579 seriesOptions;
580  
581 if (!chart.ddDupes) {
582 chart.ddDupes = [];
583 }
584  
585 while (i-- && !seriesOptions) {
586 if (drilldown.series[i].id === this.drilldown && inArray(this.drilldown, chart.ddDupes) === -1) {
587 seriesOptions = drilldown.series[i];
588 chart.ddDupes.push(this.drilldown);
589 }
590 }
591  
592 // Fire the event. If seriesOptions is undefined, the implementer can check for
593 // seriesOptions, and call addSeriesAsDrilldown async if necessary.
594 fireEvent(chart, 'drilldown', {
595 point: this,
596 seriesOptions: seriesOptions,
597 category: category,
598 originalEvent: originalEvent,
599 points: category !== undefined && this.series.xAxis.getDDPoints(category).slice(0)
600 }, function(e) {
601 var chart = e.point.series && e.point.series.chart,
602 seriesOptions = e.seriesOptions;
603 if (chart && seriesOptions) {
604 if (_holdRedraw) {
605 chart.addSingleSeriesAsDrilldown(e.point, seriesOptions);
606 } else {
607 chart.addSeriesAsDrilldown(e.point, seriesOptions);
608 }
609 }
610 });
611  
612  
613 };
614  
615 /**
616 * Drill down to a given category. This is the same as clicking on an axis label.
617 */
618 H.Axis.prototype.drilldownCategory = function(x, e) {
619 var key,
620 point,
621 ddPointsX = this.getDDPoints(x);
622 for (key in ddPointsX) {
623 point = ddPointsX[key];
624 if (point && point.series && point.series.visible && point.doDrilldown) { // #3197
625 point.doDrilldown(true, x, e);
626 }
627 }
628 this.chart.applyDrilldown();
629 };
630  
631 /**
632 * Return drillable points for this specific X value
633 */
634 H.Axis.prototype.getDDPoints = function(x) {
635 var ret = [];
636 each(this.series, function(series) {
637 var i,
638 xData = series.xData,
639 points = series.points;
640  
641 for (i = 0; i < xData.length; i++) {
642 < xData.length; i++) { if (xData[i] === x && series.options.data[i] && series.options.data[i].drilldown) {
643 < xData.length; i++) { ret.push(points ? points[i] : true);
644 < xData.length; i++) { break;
645 < xData.length; i++) { }
646 < xData.length; i++) { }
647 < xData.length; i++) { });
648 < xData.length; i++) { return ret;
649 < xData.length; i++) { };
650  
651  
652 < xData.length; i++) { /**
653 < xData.length; i++) { * Make a tick label drillable, or remove drilling on update
654 < xData.length; i++) { */
655 < xData.length; i++) { Tick.prototype.drillable = function() {
656 < xData.length; i++) { var pos = this.pos,
657 < xData.length; i++) { label = this.label,
658 < xData.length; i++) { axis = this.axis,
659 < xData.length; i++) { isDrillable = axis.coll === 'xAxis' && axis.getDDPoints,
660 < xData.length; i++) { ddPointsX = isDrillable && axis.getDDPoints(pos);
661  
662 < xData.length; i++) { if (isDrillable) {
663 < xData.length; i++) { if (label && ddPointsX.length) {
664 < xData.length; i++) { label.drillable = true;
665  
666  
667  
668 < xData.length; i++) { label
669 < xData.length; i++) { .addClass('highcharts-drilldown-axis-label')
670  
671 < xData.length; i++) { .on('click', function(e) {
672 < xData.length; i++) { axis.drilldownCategory(pos, e);
673 < xData.length; i++) { });
674  
675 < xData.length; i++) { } else if (label && label.drillable) {
676  
677  
678  
679 < xData.length; i++) { label.on('click', null); // #3806
680 < xData.length; i++) { label.removeClass('highcharts-drilldown-axis-label');
681 < xData.length; i++) { }
682 < xData.length; i++) { }
683 < xData.length; i++) { };
684  
685 < xData.length; i++) { /**
686 < xData.length; i++) { * Always keep the drillability updated (#3951)
687 < xData.length; i++) { */
688 < xData.length; i++) { wrap(Tick.prototype, 'addLabel', function(proceed) {
689 < xData.length; i++) { proceed.call(this);
690 < xData.length; i++) { this.drillable();
691 < xData.length; i++) { });
692  
693  
694 < xData.length; i++) { /**
695 < xData.length; i++) { * On initialization of each point, identify its label and make it clickable. Also, provide a
696 < xData.length; i++) { * list of points associated to that label.
697 < xData.length; i++) { */
698 < xData.length; i++) { wrap(H.Point.prototype, 'init', function(proceed, series, options, x) {
699 < xData.length; i++) { var point = proceed.call(this, series, options, x),
700 < xData.length; i++) { xAxis = series.xAxis,
701 < xData.length; i++) { tick = xAxis && xAxis.ticks[x];
702  
703 < xData.length; i++) { if (point.drilldown) {
704  
705 < xData.length; i++) { // Add the click event to the point
706 < xData.length; i++) { H.addEvent(point, 'click', function(e) {
707 < xData.length; i++) { if (series.xAxis && series.chart.options.drilldown.allowPointDrilldown === false) {
708 < xData.length; i++) { series.xAxis.drilldownCategory(point.x, e); // #5822, x changed
709 < xData.length; i++) { } else {
710 < xData.length; i++) { point.doDrilldown(undefined, undefined, e);
711 < xData.length; i++) { }
712 < xData.length; i++) { });
713 < xData.length; i++) { /*wrap(point, 'importEvents', function (proceed) { // wrapping importEvents makes point.click event work
714 < xData.length; i++) { if (!this.hasImportedEvents) {
715 < xData.length; i++) { proceed.call(this);
716 < xData.length; i++) { H.addEvent(this, 'click', function () {
717 < xData.length; i++) { this.doDrilldown();
718 < xData.length; i++) { });
719 < xData.length; i++) { }
720 < xData.length; i++) { });*/
721  
722 < xData.length; i++) { }
723  
724 < xData.length; i++) { // Add or remove click handler and style on the tick label
725 < xData.length; i++) { if (tick) {
726 < xData.length; i++) { tick.drillable();
727 < xData.length; i++) { }
728  
729 < xData.length; i++) { return point;
730 < xData.length; i++) { });
731  
732 < xData.length; i++) { wrap(H.Series.prototype, 'drawDataLabels', function(proceed) {
733 < xData.length; i++) { var css = this.chart.options.drilldown.activeDataLabelStyle,
734 < xData.length; i++) { renderer = this.chart.renderer;
735  
736 < xData.length; i++) { proceed.call(this);
737  
738 < xData.length; i++) { each(this.points, function(point) {
739 < xData.length; i++) { var pointCSS = {};
740 < xData.length; i++) { if (point.drilldown && point.dataLabel) {
741 < xData.length; i++) { if (css.color === 'contrast') {
742 < xData.length; i++) { pointCSS.color = renderer.getContrast(point.color || this.color);
743 < xData.length; i++) { }
744 < xData.length; i++) { point.dataLabel
745 < xData.length; i++) { .addClass('highcharts-drilldown-data-label');
746  
747  
748 < xData.length; i++) { }
749 < xData.length; i++) { }, this);
750 < xData.length; i++) { });
751  
752 < xData.length; i++) { // Mark the trackers with a pointer
753 < xData.length; i++) { var type,
754 < xData.length; i++) { drawTrackerWrapper = function(proceed) {
755 < xData.length; i++) { proceed.call(this);
756 < xData.length; i++) { each(this.points, function(point) {
757 < xData.length; i++) { if (point.drilldown && point.graphic) {
758 < xData.length; i++) { point.graphic.addClass('highcharts-drilldown-point');
759  
760  
761 < xData.length; i++) { }
762 < xData.length; i++) { });
763 < xData.length; i++) { };
764 < xData.length; i++) { for (type in seriesTypes) {
765 < xData.length; i++) { if (seriesTypes[type].prototype.supportsDrilldown) {
766 < xData.length; i++) { wrap(seriesTypes[type].prototype, 'drawTracker', drawTrackerWrapper);
767 < xData.length; i++) { }
768 < xData.length; i++) { }
769  
770 < xData.length; i++) { }(Highcharts));
771 < xData.length; i++) {}));