1 /* Javascript plotting library for jQuery, version 3.0.0.

     2 

     3 Copyright (c) 2007-2014 IOLA and Ole Laursen.

     4 Licensed under the MIT license.

     5 

     6 */

     7 

     8 // the actual Flot code

     9 (function($) {

    10     "use strict";

    11 

    12     var Canvas = window.Flot.Canvas;

    13 

    14     function defaultTickGenerator(axis) {

    15         var ticks = [],

    16             start = $.plot.saturated.saturate($.plot.saturated.floorInBase(axis.min, axis.tickSize)),

    17             i = 0,

    18             v = Number.NaN,

    19             prev;

    20 

    21         if (start === -Number.MAX_VALUE) {

    22             ticks.push(start);

    23             start = $.plot.saturated.floorInBase(axis.min + axis.tickSize, axis.tickSize);

    24         }

    25 

    26         do {

    27             prev = v;

    28             //v = start + i * axis.tickSize;

    29             v = $.plot.saturated.multiplyAdd(axis.tickSize, i, start);

    30             ticks.push(v);

    31             ++i;

    32         } while (v < axis.max && v !== prev);

    33 

    34         return ticks;

    35     }

    36 

    37     function defaultTickFormatter(value, axis, precision) {

    38         var oldTickDecimals = axis.tickDecimals,

    39             expPosition = ("" + value).indexOf("e");

    40 

    41         if (expPosition !== -1) {

    42             return expRepTickFormatter(value, axis, precision);

    43         }

    44 

    45         if (precision > 0) {

    46             axis.tickDecimals = precision;

    47         }

    48 

    49         var factor = axis.tickDecimals ? parseFloat('1e' + axis.tickDecimals) : 1,

    50             formatted = "" + Math.round(value * factor) / factor;

    51 

    52         // If tickDecimals was specified, ensure that we have exactly that

    53         // much precision; otherwise default to the value's own precision.

    54         if (axis.tickDecimals != null) {

    55             var decimal = formatted.indexOf("."),

    56                 decimalPrecision = decimal === -1 ? 0 : formatted.length - decimal - 1;

    57             if (decimalPrecision < axis.tickDecimals) {

    58                 var decimals = ("" + factor).substr(1, axis.tickDecimals - decimalPrecision);

    59                 formatted = (decimalPrecision ? formatted : formatted + ".") + decimals;

    60             }

    61         }

    62 

    63         axis.tickDecimals = oldTickDecimals;

    64         return formatted;

    65     };

    66 

    67     function expRepTickFormatter(value, axis, precision) {

    68         var expPosition = ("" + value).indexOf("e"),

    69             exponentValue = parseInt(("" + value).substr(expPosition + 1)),

    70             tenExponent = expPosition !== -1 ? exponentValue : (value > 0 ? Math.floor(Math.log(value) / Math.LN10) : 0),

    71             roundWith = parseFloat('1e' + tenExponent),

    72             x = value / roundWith;

    73 

    74         if (precision) {

    75             var updatedPrecision = recomputePrecision(value, precision);

    76             return (value / roundWith).toFixed(updatedPrecision) + 'e' + tenExponent;

    77         }

    78 

    79         if (axis.tickDecimals > 0) {

    80             return x.toFixed(recomputePrecision(value, axis.tickDecimals)) + 'e' + tenExponent;

    81         }

    82         return x.toFixed() + 'e' + tenExponent;

    83     }

    84 

    85     function recomputePrecision(num, precision) {

    86         //for numbers close to zero, the precision from flot will be a big number

    87         //while for big numbers, the precision will be negative

    88         var log10Value = Math.log(Math.abs(num)) * Math.LOG10E,

    89             newPrecision = Math.abs(log10Value + precision);

    90 

    91         return newPrecision <= 20 ? Math.floor(newPrecision) : 20;

    92     }

    93 

    94     ///////////////////////////////////////////////////////////////////////////

    95     // The top-level container for the entire plot.

    96     function Plot(placeholder, data_, options_, plugins) {

    97         // data is on the form:

    98         //   [ series1, series2 ... ]

    99         // where series is either just the data as [ [x1, y1], [x2, y2], ... ]

   100         // or { data: [ [x1, y1], [x2, y2], ... ], label: "some label", ... }

   101 

   102         var series = [],

   103             options = {

   104                 // the color theme used for graphs

   105                 colors: ["#edc240", "#afd8f8", "#cb4b4b", "#4da74d", "#9440ed"],

   106                 xaxis: {

   107                     show: null, // null = auto-detect, true = always, false = never

   108                     position: "bottom", // or "top"

   109                     mode: null, // null or "time"

   110                     font: null, // null (derived from CSS in placeholder) or object like { size: 11, lineHeight: 13, style: "italic", weight: "bold", family: "sans-serif", variant: "small-caps" }

   111                     color: null, // base color, labels, ticks

   112                     tickColor: null, // possibly different color of ticks, e.g. "rgba(0,0,0,0.15)"

   113                     transform: null, // null or f: number -> number to transform axis

   114                     inverseTransform: null, // if transform is set, this should be the inverse function

   115                     min: null, // min. value to show, null means set automatically

   116                     max: null, // max. value to show, null means set automatically

   117                     autoScaleMargin: null, // margin in % to add if autoScale option is on "loose" mode,

   118                     autoScale: "exact", // Available modes: "none", "loose", "exact", "sliding-window"

   119                     windowSize: null, // null or number. This is the size of sliding-window.

   120                     growOnly: null, // grow only, useful for smoother auto-scale, the scales will grow to accomodate data but won't shrink back.

   121                     ticks: null, // either [1, 3] or [[1, "a"], 3] or (fn: axis info -> ticks) or app. number of ticks for auto-ticks

   122                     tickFormatter: null, // fn: number -> string

   123                     showTickLabels: "major", // "none", "endpoints", "major", "all"

   124                     labelWidth: null, // size of tick labels in pixels

   125                     labelHeight: null,

   126                     reserveSpace: null, // whether to reserve space even if axis isn't shown

   127                     tickLength: null, // size in pixels of major tick marks

   128                     showMinorTicks: null, // true = show minor tick marks, false = hide minor tick marks

   129                     showTicks: null, // true = show tick marks, false = hide all tick marks

   130                     gridLines: null, // true = show grid lines, false = hide grid lines

   131                     alignTicksWithAxis: null, // axis number or null for no sync

   132                     tickDecimals: null, // no. of decimals, null means auto

   133                     tickSize: null, // number or [number, "unit"]

   134                     minTickSize: null, // number or [number, "unit"]

   135                     offset: { below: 0, above: 0 }, // the plot drawing offset. this is calculated by the flot.navigate for each axis

   136                     boxPosition: { centerX: 0, centerY: 0 } //position of the axis on the corresponding axis box

   137                 },

   138                 yaxis: {

   139                     autoScaleMargin: 0.02, // margin in % to add if autoScale option is on "loose" mode

   140                     autoScale: "loose", // Available modes: "none", "loose", "exact"

   141                     growOnly: null, // grow only, useful for smoother auto-scale, the scales will grow to accomodate data but won't shrink back.

   142                     position: "left", // or "right"

   143                     showTickLabels: "major", // "none", "endpoints", "major", "all"

   144                     offset: { below: 0, above: 0 }, // the plot drawing offset. this is calculated by the flot.navigate for each axis

   145                     boxPosition: { centerX: 0, centerY: 0 } //position of the axis on the corresponding axis box

   146                 },

   147                 xaxes: [],

   148                 yaxes: [],

   149                 series: {

   150                     points: {

   151                         show: false,

   152                         radius: 3,

   153                         lineWidth: 2, // in pixels

   154                         fill: true,

   155                         fillColor: "#ffffff",

   156                         symbol: 'circle' // or callback

   157                     },

   158                     lines: {

   159                         // we don't put in show: false so we can see

   160                         // whether lines were actively disabled

   161                         lineWidth: 1, // in pixels

   162                         fill: false,

   163                         fillColor: null,

   164                         steps: false

   165                         // Omit 'zero', so we can later default its value to

   166                         // match that of the 'fill' option.

   167                     },

   168                     bars: {

   169                         show: false,

   170                         lineWidth: 2, // in pixels

   171                         // barWidth: number or [number, absolute]

   172                         // when 'absolute' is false, 'number' is relative to the minimum distance between points for the series

   173                         // when 'absolute' is true, 'number' is considered to be in units of the x-axis

   174                         horizontal: false,

   175                         barWidth: 0.8,

   176                         fill: true,

   177                         fillColor: null,

   178                         align: "left", // "left", "right", or "center"

   179                         zero: true

   180                     },

   181                     shadowSize: 3,

   182                     highlightColor: null

   183                 },

   184                 grid: {

   185                     show: true,

   186                     aboveData: false,

   187                     color: "#545454", // primary color used for outline and labels

   188                     backgroundColor: null, // null for transparent, else color

   189                     borderColor: null, // set if different from the grid color

   190                     tickColor: null, // color for the ticks, e.g. "rgba(0,0,0,0.15)"

   191                     margin: 0, // distance from the canvas edge to the grid

   192                     labelMargin: 5, // in pixels

   193                     axisMargin: 8, // in pixels

   194                     borderWidth: 1, // in pixels

   195                     minBorderMargin: null, // in pixels, null means taken from points radius

   196                     markings: null, // array of ranges or fn: axes -> array of ranges

   197                     markingsColor: "#f4f4f4",

   198                     markingsLineWidth: 2,

   199                     // interactive stuff

   200                     clickable: false,

   201                     hoverable: false,

   202                     autoHighlight: true, // highlight in case mouse is near

   203                     mouseActiveRadius: 15 // how far the mouse can be away to activate an item

   204                 },

   205                 interaction: {

   206                     redrawOverlayInterval: 1000 / 60 // time between updates, -1 means in same flow

   207                 },

   208                 hooks: {}

   209             },

   210             surface = null, // the canvas for the plot itself

   211             overlay = null, // canvas for interactive stuff on top of plot

   212             eventHolder = null, // jQuery object that events should be bound to

   213             ctx = null,

   214             octx = null,

   215             xaxes = [],

   216             yaxes = [],

   217             plotOffset = {

   218                 left: 0,

   219                 right: 0,

   220                 top: 0,

   221                 bottom: 0

   222             },

   223             plotWidth = 0,

   224             plotHeight = 0,

   225             hooks = {

   226                 processOptions: [],

   227                 processRawData: [],

   228                 processDatapoints: [],

   229                 processOffset: [],

   230                 setupGrid: [],

   231                 adjustSeriesDataRange: [],

   232                 setRange: [],

   233                 drawBackground: [],

   234                 drawSeries: [],

   235                 drawAxis: [],

   236                 draw: [],

   237                 axisReserveSpace: [],

   238                 bindEvents: [],

   239                 drawOverlay: [],

   240                 resize: [],

   241                 shutdown: []

   242             },

   243             plot = this;

   244 

   245         var eventManager = {};

   246 

   247         // interactive features

   248 

   249         var redrawTimeout = null;

   250 

   251         // public functions

   252         plot.setData = setData;

   253         plot.setupGrid = setupGrid;

   254         plot.draw = draw;

   255         plot.getPlaceholder = function() {

   256             return placeholder;

   257         };

   258         plot.getCanvas = function() {

   259             return surface.element;

   260         };

   261         plot.getSurface = function() {

   262             return surface;

   263         };

   264         plot.getEventHolder = function() {

   265             return eventHolder[0];

   266         };

   267         plot.getPlotOffset = function() {

   268             return plotOffset;

   269         };

   270         plot.width = function() {

   271             return plotWidth;

   272         };

   273         plot.height = function() {

   274             return plotHeight;

   275         };

   276         plot.offset = function() {

   277             var o = eventHolder.offset();

   278             o.left += plotOffset.left;

   279             o.top += plotOffset.top;

   280             return o;

   281         };

   282         plot.getData = function() {

   283             return series;

   284         };

   285         plot.getAxes = function() {

   286             var res = {};

   287             $.each(xaxes.concat(yaxes), function(_, axis) {

   288                 if (axis) {

   289                     res[axis.direction + (axis.n !== 1 ? axis.n : "") + "axis"] = axis;

   290                 }

   291             });

   292             return res;

   293         };

   294         plot.getXAxes = function() {

   295             return xaxes;

   296         };

   297         plot.getYAxes = function() {

   298             return yaxes;

   299         };

   300         plot.c2p = canvasToCartesianAxisCoords;

   301         plot.p2c = cartesianAxisToCanvasCoords;

   302         plot.getOptions = function() {

   303             return options;

   304         };

   305         plot.triggerRedrawOverlay = triggerRedrawOverlay;

   306         plot.pointOffset = function(point) {

   307             return {

   308                 left: parseInt(xaxes[axisNumber(point, "x") - 1].p2c(+point.x) + plotOffset.left, 10),

   309                 top: parseInt(yaxes[axisNumber(point, "y") - 1].p2c(+point.y) + plotOffset.top, 10)

   310             };

   311         };

   312         plot.shutdown = shutdown;

   313         plot.destroy = function() {

   314             shutdown();

   315             placeholder.removeData("plot").empty();

   316 

   317             series = [];

   318             options = null;

   319             surface = null;

   320             overlay = null;

   321             eventHolder = null;

   322             ctx = null;

   323             octx = null;

   324             xaxes = [];

   325             yaxes = [];

   326             hooks = null;

   327             plot = null;

   328         };

   329 

   330         plot.resize = function() {

   331             var width = placeholder.width(),

   332                 height = placeholder.height();

   333             surface.resize(width, height);

   334             overlay.resize(width, height);

   335 

   336             executeHooks(hooks.resize, [width, height]);

   337         };

   338 

   339         plot.clearTextCache = function () {

   340             surface.clearCache();

   341             overlay.clearCache();

   342         };

   343 

   344         plot.autoScaleAxis = autoScaleAxis;

   345         plot.computeRangeForDataSeries = computeRangeForDataSeries;

   346         plot.adjustSeriesDataRange = adjustSeriesDataRange;

   347         plot.findNearbyItem = findNearbyItem;

   348         plot.findNearbyInterpolationPoint = findNearbyInterpolationPoint;

   349         plot.computeValuePrecision = computeValuePrecision;

   350         plot.computeTickSize = computeTickSize;

   351         plot.addEventHandler = addEventHandler;

   352 

   353         // public attributes

   354         plot.hooks = hooks;

   355 

   356         // initialize

   357         var MINOR_TICKS_COUNT_CONSTANT = $.plot.uiConstants.MINOR_TICKS_COUNT_CONSTANT;

   358         var TICK_LENGTH_CONSTANT = $.plot.uiConstants.TICK_LENGTH_CONSTANT;

   359         initPlugins(plot);

   360         setupCanvases();

   361         parseOptions(options_);

   362         setData(data_);

   363         setupGrid(true);

   364         draw();

   365         bindEvents();

   366 

   367         function executeHooks(hook, args) {

   368             args = [plot].concat(args);

   369             for (var i = 0; i < hook.length; ++i) {

   370                 hook[i].apply(this, args);

   371             }

   372         }

   373 

   374         function initPlugins() {

   375             // References to key classes, allowing plugins to modify them

   376 

   377             var classes = {

   378                 Canvas: Canvas

   379             };

   380 

   381             for (var i = 0; i < plugins.length; ++i) {

   382                 var p = plugins[i];

   383                 p.init(plot, classes);

   384                 if (p.options) {

   385                     $.extend(true, options, p.options);

   386                 }

   387             }

   388         }

   389 

   390         function parseOptions(opts) {

   391             $.extend(true, options, opts);

   392 

   393             // $.extend merges arrays, rather than replacing them.  When less

   394             // colors are provided than the size of the default palette, we

   395             // end up with those colors plus the remaining defaults, which is

   396             // not expected behavior; avoid it by replacing them here.

   397 

   398             if (opts && opts.colors) {

   399                 options.colors = opts.colors;

   400             }

   401 

   402             if (options.xaxis.color == null) {

   403                 options.xaxis.color = $.color.parse(options.grid.color).scale('a', 0.22).toString();

   404             }

   405 

   406             if (options.yaxis.color == null) {

   407                 options.yaxis.color = $.color.parse(options.grid.color).scale('a', 0.22).toString();

   408             }

   409 

   410             if (options.xaxis.tickColor == null) {

   411                 // grid.tickColor for back-compatibility

   412                 options.xaxis.tickColor = options.grid.tickColor || options.xaxis.color;

   413             }

   414 

   415             if (options.yaxis.tickColor == null) {

   416                 // grid.tickColor for back-compatibility

   417                 options.yaxis.tickColor = options.grid.tickColor || options.yaxis.color;

   418             }

   419 

   420             if (options.grid.borderColor == null) {

   421                 options.grid.borderColor = options.grid.color;

   422             }

   423 

   424             if (options.grid.tickColor == null) {

   425                 options.grid.tickColor = $.color.parse(options.grid.color).scale('a', 0.22).toString();

   426             }

   427 

   428             // Fill in defaults for axis options, including any unspecified

   429             // font-spec fields, if a font-spec was provided.

   430 

   431             // If no x/y axis options were provided, create one of each anyway,

   432             // since the rest of the code assumes that they exist.

   433 

   434             var i, axisOptions, axisCount,

   435                 fontSize = placeholder.css("font-size"),

   436                 fontSizeDefault = fontSize ? +fontSize.replace("px", "") : 13,

   437                 fontDefaults = {

   438                     style: placeholder.css("font-style"),

   439                     size: Math.round(0.8 * fontSizeDefault),

   440                     variant: placeholder.css("font-variant"),

   441                     weight: placeholder.css("font-weight"),

   442                     family: placeholder.css("font-family")

   443                 };

   444 

   445             axisCount = options.xaxes.length || 1;

   446             for (i = 0; i < axisCount; ++i) {

   447                 axisOptions = options.xaxes[i];

   448                 if (axisOptions && !axisOptions.tickColor) {

   449                     axisOptions.tickColor = axisOptions.color;

   450                 }

   451 

   452                 axisOptions = $.extend(true, {}, options.xaxis, axisOptions);

   453                 options.xaxes[i] = axisOptions;

   454 

   455                 if (axisOptions.font) {

   456                     axisOptions.font = $.extend({}, fontDefaults, axisOptions.font);

   457                     if (!axisOptions.font.color) {

   458                         axisOptions.font.color = axisOptions.color;

   459                     }

   460                     if (!axisOptions.font.lineHeight) {

   461                         axisOptions.font.lineHeight = Math.round(axisOptions.font.size * 1.15);

   462                     }

   463                 }

   464             }

   465 

   466             axisCount = options.yaxes.length || 1;

   467             for (i = 0; i < axisCount; ++i) {

   468                 axisOptions = options.yaxes[i];

   469                 if (axisOptions && !axisOptions.tickColor) {

   470                     axisOptions.tickColor = axisOptions.color;

   471                 }

   472 

   473                 axisOptions = $.extend(true, {}, options.yaxis, axisOptions);

   474                 options.yaxes[i] = axisOptions;

   475 

   476                 if (axisOptions.font) {

   477                     axisOptions.font = $.extend({}, fontDefaults, axisOptions.font);

   478                     if (!axisOptions.font.color) {

   479                         axisOptions.font.color = axisOptions.color;

   480                     }

   481                     if (!axisOptions.font.lineHeight) {

   482                         axisOptions.font.lineHeight = Math.round(axisOptions.font.size * 1.15);

   483                     }

   484                 }

   485             }

   486 

   487             // save options on axes for future reference

   488             for (i = 0; i < options.xaxes.length; ++i) {

   489                 getOrCreateAxis(xaxes, i + 1).options = options.xaxes[i];

   490             }

   491 

   492             for (i = 0; i < options.yaxes.length; ++i) {

   493                 getOrCreateAxis(yaxes, i + 1).options = options.yaxes[i];

   494             }

   495 

   496             //process boxPosition options used for axis.box size

   497             $.each(allAxes(), function(_, axis) {

   498                 axis.boxPosition = axis.options.boxPosition || {centerX: 0, centerY: 0};

   499             });

   500 

   501             // add hooks from options

   502             for (var n in hooks) {

   503                 if (options.hooks[n] && options.hooks[n].length) {

   504                     hooks[n] = hooks[n].concat(options.hooks[n]);

   505                 }

   506             }

   507 

   508             executeHooks(hooks.processOptions, [options]);

   509         }

   510 

   511         function setData(d) {

   512             var oldseries = series;

   513             series = parseData(d);

   514             fillInSeriesOptions();

   515             processData(oldseries);

   516         }

   517 

   518         function parseData(d) {

   519             var res = [];

   520             for (var i = 0; i < d.length; ++i) {

   521                 var s = $.extend(true, {}, options.series);

   522 

   523                 if (d[i].data != null) {

   524                     s.data = d[i].data; // move the data instead of deep-copy

   525                     delete d[i].data;

   526 

   527                     $.extend(true, s, d[i]);

   528 

   529                     d[i].data = s.data;

   530                 } else {

   531                     s.data = d[i];

   532                 }

   533 

   534                 res.push(s);

   535             }

   536 

   537             return res;

   538         }

   539 

   540         function axisNumber(obj, coord) {

   541             var a = obj[coord + "axis"];

   542             if (typeof a === "object") {

   543                 // if we got a real axis, extract number

   544                 a = a.n;

   545             }

   546 

   547             if (typeof a !== "number") {

   548                 a = 1; // default to first axis

   549             }

   550 

   551             return a;

   552         }

   553 

   554         function allAxes() {

   555             // return flat array without annoying null entries

   556             return xaxes.concat(yaxes).filter(function(a) {

   557                 return a;

   558             });

   559         }

   560 

   561         // canvas to axis for cartesian axes

   562         function canvasToCartesianAxisCoords(pos) {

   563             // return an object with x/y corresponding to all used axes

   564             var res = {},

   565                 i, axis;

   566             for (i = 0; i < xaxes.length; ++i) {

   567                 axis = xaxes[i];

   568                 if (axis && axis.used) {

   569                     res["x" + axis.n] = axis.c2p(pos.left);

   570                 }

   571             }

   572 

   573             for (i = 0; i < yaxes.length; ++i) {

   574                 axis = yaxes[i];

   575                 if (axis && axis.used) {

   576                     res["y" + axis.n] = axis.c2p(pos.top);

   577                 }

   578             }

   579 

   580             if (res.x1 !== undefined) {

   581                 res.x = res.x1;

   582             }

   583 

   584             if (res.y1 !== undefined) {

   585                 res.y = res.y1;

   586             }

   587 

   588             return res;

   589         }

   590 

   591         // axis to canvas for cartesian axes

   592         function cartesianAxisToCanvasCoords(pos) {

   593             // get canvas coords from the first pair of x/y found in pos

   594             var res = {},

   595                 i, axis, key;

   596 

   597             for (i = 0; i < xaxes.length; ++i) {

   598                 axis = xaxes[i];

   599                 if (axis && axis.used) {

   600                     key = "x" + axis.n;

   601                     if (pos[key] == null && axis.n === 1) {

   602                         key = "x";

   603                     }

   604 

   605                     if (pos[key] != null) {

   606                         res.left = axis.p2c(pos[key]);

   607                         break;

   608                     }

   609                 }

   610             }

   611 

   612             for (i = 0; i < yaxes.length; ++i) {

   613                 axis = yaxes[i];

   614                 if (axis && axis.used) {

   615                     key = "y" + axis.n;

   616                     if (pos[key] == null && axis.n === 1) {

   617                         key = "y";

   618                     }

   619 

   620                     if (pos[key] != null) {

   621                         res.top = axis.p2c(pos[key]);

   622                         break;

   623                     }

   624                 }

   625             }

   626 

   627             return res;

   628         }

   629 

   630         function getOrCreateAxis(axes, number) {

   631             if (!axes[number - 1]) {

   632                 axes[number - 1] = {

   633                     n: number, // save the number for future reference

   634                     direction: axes === xaxes ? "x" : "y",

   635                     options: $.extend(true, {}, axes === xaxes ? options.xaxis : options.yaxis)

   636                 };

   637             }

   638 

   639             return axes[number - 1];

   640         }

   641 

   642         function fillInSeriesOptions() {

   643             var neededColors = series.length,

   644                 maxIndex = -1,

   645                 i;

   646 

   647             // Subtract the number of series that already have fixed colors or

   648             // color indexes from the number that we still need to generate.

   649 

   650             for (i = 0; i < series.length; ++i) {

   651                 var sc = series[i].color;

   652                 if (sc != null) {

   653                     neededColors--;

   654                     if (typeof sc === "number" && sc > maxIndex) {

   655                         maxIndex = sc;

   656                     }

   657                 }

   658             }

   659 

   660             // If any of the series have fixed color indexes, then we need to

   661             // generate at least as many colors as the highest index.

   662 

   663             if (neededColors <= maxIndex) {

   664                 neededColors = maxIndex + 1;

   665             }

   666 

   667             // Generate all the colors, using first the option colors and then

   668             // variations on those colors once they're exhausted.

   669 

   670             var c, colors = [],

   671                 colorPool = options.colors,

   672                 colorPoolSize = colorPool.length,

   673                 variation = 0,

   674                 definedColors = Math.max(0, series.length - neededColors);

   675 

   676             for (i = 0; i < neededColors; i++) {

   677                 c = $.color.parse(colorPool[(definedColors + i) % colorPoolSize] || "#666");

   678 

   679                 // Each time we exhaust the colors in the pool we adjust

   680                 // a scaling factor used to produce more variations on

   681                 // those colors. The factor alternates negative/positive

   682                 // to produce lighter/darker colors.

   683 

   684                 // Reset the variation after every few cycles, or else

   685                 // it will end up producing only white or black colors.

   686 

   687                 if (i % colorPoolSize === 0 && i) {

   688                     if (variation >= 0) {

   689                         if (variation < 0.5) {

   690                             variation = -variation - 0.2;

   691                         } else variation = 0;

   692                     } else variation = -variation;

   693                 }

   694 

   695                 colors[i] = c.scale('rgb', 1 + variation);

   696             }

   697 

   698             // Finalize the series options, filling in their colors

   699 

   700             var colori = 0,

   701                 s;

   702             for (i = 0; i < series.length; ++i) {

   703                 s = series[i];

   704 

   705                 // assign colors

   706                 if (s.color == null) {

   707                     s.color = colors[colori].toString();

   708                     ++colori;

   709                 } else if (typeof s.color === "number") {

   710                     s.color = colors[s.color].toString();

   711                 }

   712 

   713                 // turn on lines automatically in case nothing is set

   714                 if (s.lines.show == null) {

   715                     var v, show = true;

   716                     for (v in s) {

   717                         if (s[v] && s[v].show) {

   718                             show = false;

   719                             break;

   720                         }

   721                     }

   722 

   723                     if (show) {

   724                         s.lines.show = true;

   725                     }

   726                 }

   727 

   728                 // If nothing was provided for lines.zero, default it to match

   729                 // lines.fill, since areas by default should extend to zero.

   730 

   731                 if (s.lines.zero == null) {

   732                     s.lines.zero = !!s.lines.fill;

   733                 }

   734 

   735                 // setup axes

   736                 s.xaxis = getOrCreateAxis(xaxes, axisNumber(s, "x"));

   737                 s.yaxis = getOrCreateAxis(yaxes, axisNumber(s, "y"));

   738             }

   739         }

   740 

   741         function processData(prevSeries) {

   742             var topSentry = Number.POSITIVE_INFINITY,

   743                 bottomSentry = Number.NEGATIVE_INFINITY,

   744                 i, j, k, m,

   745                 s, points, ps, val, f, p,

   746                 data, format;

   747 

   748             function updateAxis(axis, min, max) {

   749                 if (min < axis.datamin && min !== -Infinity) {

   750                     axis.datamin = min;

   751                 }

   752 

   753                 if (max > axis.datamax && max !== Infinity) {

   754                     axis.datamax = max;

   755                 }

   756             }

   757 

   758             function reusePoints(prevSeries, i) {

   759                 if (prevSeries && prevSeries[i] && prevSeries[i].datapoints && prevSeries[i].datapoints.points) {

   760                     return prevSeries[i].datapoints.points;

   761                 }

   762 

   763                 return [];

   764             }

   765 

   766             $.each(allAxes(), function(_, axis) {

   767                 // init axis

   768                 if (axis.options.growOnly !== true) {

   769                     axis.datamin = topSentry;

   770                     axis.datamax = bottomSentry;

   771                 } else {

   772                     if (axis.datamin === undefined) {

   773                         axis.datamin = topSentry;

   774                     }

   775                     if (axis.datamax === undefined) {

   776                         axis.datamax = bottomSentry;

   777                     }

   778                 }

   779                 axis.used = false;

   780             });

   781 

   782             for (i = 0; i < series.length; ++i) {

   783                 s = series[i];

   784                 s.datapoints = {

   785                     points: []

   786                 };

   787 

   788                 if (s.datapoints.points.length === 0) {

   789                     s.datapoints.points = reusePoints(prevSeries, i);

   790                 }

   791 

   792                 executeHooks(hooks.processRawData, [s, s.data, s.datapoints]);

   793             }

   794 

   795             // first pass: clean and copy data

   796             for (i = 0; i < series.length; ++i) {

   797                 s = series[i];

   798 

   799                 data = s.data;

   800                 format = s.datapoints.format;

   801 

   802                 if (!format) {

   803                     format = [];

   804                     // find out how to copy

   805                     format.push({

   806                         x: true,

   807                         y: false,

   808                         number: true,

   809                         required: true,

   810                         computeRange: s.xaxis.options.autoScale !== 'none',

   811                         defaultValue: null

   812                     });

   813 

   814                     format.push({

   815                         x: false,

   816                         y: true,

   817                         number: true,

   818                         required: true,

   819                         computeRange: s.yaxis.options.autoScale !== 'none',

   820                         defaultValue: null

   821                     });

   822 

   823                     if (s.stack || s.bars.show || (s.lines.show && s.lines.fill)) {

   824                         var expectedPs = s.datapoints.pointsize != null ? s.datapoints.pointsize : (s.data && s.data[0] && s.data[0].length ? s.data[0].length : 3);

   825                         if (expectedPs > 2) {

   826                             format.push({

   827                                 x: false,

   828                                 y: true,

   829                                 number: true,

   830                                 required: false,

   831                                 computeRange: s.yaxis.options.autoScale !== 'none',

   832                                 defaultValue: 0

   833                             });

   834                         }

   835                     }

   836 

   837                     s.datapoints.format = format;

   838                 }

   839 

   840                 s.xaxis.used = s.yaxis.used = true;

   841 

   842                 if (s.datapoints.pointsize != null) continue; // already filled in

   843 

   844                 s.datapoints.pointsize = format.length;

   845                 ps = s.datapoints.pointsize;

   846                 points = s.datapoints.points;

   847 

   848                 var insertSteps = s.lines.show && s.lines.steps;

   849 

   850                 for (j = k = 0; j < data.length; ++j, k += ps) {

   851                     p = data[j];

   852 

   853                     var nullify = p == null;

   854                     if (!nullify) {

   855                         for (m = 0; m < ps; ++m) {

   856                             val = p[m];

   857                             f = format[m];

   858 

   859                             if (f) {

   860                                 if (f.number && val != null) {

   861                                     val = +val; // convert to number

   862                                     if (isNaN(val)) {

   863                                         val = null;

   864                                     }

   865                                 }

   866 

   867                                 if (val == null) {

   868                                     if (f.required) nullify = true;

   869 

   870                                     if (f.defaultValue != null) val = f.defaultValue;

   871                                 }

   872                             }

   873 

   874                             points[k + m] = val;

   875                         }

   876                     }

   877 

   878                     if (nullify) {

   879                         for (m = 0; m < ps; ++m) {

   880                             val = points[k + m];

   881                             if (val != null) {

   882                                 f = format[m];

   883                                 // extract min/max info

   884                                 if (f.computeRange) {

   885                                     if (f.x) {

   886                                         updateAxis(s.xaxis, val, val);

   887                                     }

   888                                     if (f.y) {

   889                                         updateAxis(s.yaxis, val, val);

   890                                     }

   891                                 }

   892                             }

   893                             points[k + m] = null;

   894                         }

   895                     }

   896                 }

   897 

   898                 points.length = k; //trims the internal buffer to the correct length

   899             }

   900 

   901             // give the hooks a chance to run

   902             for (i = 0; i < series.length; ++i) {

   903                 s = series[i];

   904 

   905                 executeHooks(hooks.processDatapoints, [s, s.datapoints]);

   906             }

   907 

   908             // second pass: find datamax/datamin for auto-scaling

   909             for (i = 0; i < series.length; ++i) {

   910                 s = series[i];

   911                 format = s.datapoints.format;

   912 

   913                 if (format.every(function (f) { return !f.computeRange; })) {

   914                     continue;

   915                 }

   916 

   917                 var range = plot.adjustSeriesDataRange(s,

   918                     plot.computeRangeForDataSeries(s));

   919 

   920                 executeHooks(hooks.adjustSeriesDataRange, [s, range]);

   921 

   922                 updateAxis(s.xaxis, range.xmin, range.xmax);

   923                 updateAxis(s.yaxis, range.ymin, range.ymax);

   924             }

   925 

   926             $.each(allAxes(), function(_, axis) {

   927                 if (axis.datamin === topSentry) {

   928                     axis.datamin = null;

   929                 }

   930 

   931                 if (axis.datamax === bottomSentry) {

   932                     axis.datamax = null;

   933                 }

   934             });

   935         }

   936 

   937         function setupCanvases() {

   938             // Make sure the placeholder is clear of everything except canvases

   939             // from a previous plot in this container that we'll try to re-use.

   940 

   941             placeholder.css("padding", 0) // padding messes up the positioning

   942                 .children().filter(function() {

   943                     return !$(this).hasClass("flot-overlay") && !$(this).hasClass('flot-base');

   944                 }).remove();

   945 

   946             if (placeholder.css("position") === 'static') {

   947                 placeholder.css("position", "relative"); // for positioning labels and overlay

   948             }

   949 

   950             surface = new Canvas("flot-base", placeholder[0]);

   951             overlay = new Canvas("flot-overlay", placeholder[0]); // overlay canvas for interactive features

   952 

   953             ctx = surface.context;

   954             octx = overlay.context;

   955 

   956             // define which element we're listening for events on

   957             eventHolder = $(overlay.element).unbind();

   958 

   959             // If we're re-using a plot object, shut down the old one

   960 

   961             var existing = placeholder.data("plot");

   962 

   963             if (existing) {

   964                 existing.shutdown();

   965                 overlay.clear();

   966             }

   967 

   968             // save in case we get replotted

   969             placeholder.data("plot", plot);

   970         }

   971 

   972         function bindEvents() {

   973             executeHooks(hooks.bindEvents, [eventHolder]);

   974         }

   975 

   976         function addEventHandler(event, handler, eventHolder, priority) {

   977             var key = eventHolder + event;

   978             var eventList = eventManager[key] || [];

   979 

   980             eventList.push({"event": event, "handler": handler, "eventHolder": eventHolder, "priority": priority});

   981             eventList.sort((a, b) => b.priority - a.priority );

   982             eventList.forEach( eventData => {

   983                 eventData.eventHolder.unbind(eventData.event, eventData.handler);

   984                 eventData.eventHolder.bind(eventData.event, eventData.handler);

   985             });

   986 

   987             eventManager[key] = eventList;

   988         }

   989 

   990         function shutdown() {

   991             if (redrawTimeout) {

   992                 clearTimeout(redrawTimeout);

   993             }

   994 

   995             executeHooks(hooks.shutdown, [eventHolder]);

   996         }

   997 

   998         function setTransformationHelpers(axis) {

   999             // set helper functions on the axis, assumes plot area

  1000             // has been computed already

  1001 

  1002             function identity(x) {

  1003                 return x;

  1004             }

  1005 

  1006             var s, m, t = axis.options.transform || identity,

  1007                 it = axis.options.inverseTransform;

  1008 

  1009             // precompute how much the axis is scaling a point

  1010             // in canvas space

  1011             if (axis.direction === "x") {

  1012                 if (isFinite(t(axis.max) - t(axis.min))) {

  1013                     s = axis.scale = plotWidth / Math.abs(t(axis.max) - t(axis.min));

  1014                 } else {

  1015                     s = axis.scale = 1 / Math.abs($.plot.saturated.delta(t(axis.min), t(axis.max), plotWidth));

  1016                 }

  1017                 m = Math.min(t(axis.max), t(axis.min));

  1018             } else {

  1019                 if (isFinite(t(axis.max) - t(axis.min))) {

  1020                     s = axis.scale = plotHeight / Math.abs(t(axis.max) - t(axis.min));

  1021                 } else {

  1022                     s = axis.scale = 1 / Math.abs($.plot.saturated.delta(t(axis.min), t(axis.max), plotHeight));

  1023                 }

  1024                 s = -s;

  1025                 m = Math.max(t(axis.max), t(axis.min));

  1026             }

  1027 

  1028             // data point to canvas coordinate

  1029             if (t === identity) {

  1030                 // slight optimization

  1031                 axis.p2c = function(p) {

  1032                     if (isFinite(p - m)) {

  1033                         return (p - m) * s;

  1034                     } else {

  1035                         return (p / 4 - m / 4) * s * 4;

  1036                     }

  1037                 };

  1038             } else {

  1039                 axis.p2c = function(p) {

  1040                     var tp = t(p);

  1041 

  1042                     if (isFinite(tp - m)) {

  1043                         return (tp - m) * s;

  1044                     } else {

  1045                         return (tp / 4 - m / 4) * s * 4;

  1046                     }

  1047                 };

  1048             }

  1049 

  1050             // canvas coordinate to data point

  1051             if (!it) {

  1052                 axis.c2p = function(c) {

  1053                     return m + c / s;

  1054                 };

  1055             } else {

  1056                 axis.c2p = function(c) {

  1057                     return it(m + c / s);

  1058                 };

  1059             }

  1060         }

  1061 

  1062         function measureTickLabels(axis) {

  1063             var opts = axis.options,

  1064                 ticks = opts.showTickLabels !== 'none' && axis.ticks ? axis.ticks : [],

  1065                 showMajorTickLabels = opts.showTickLabels === 'major' || opts.showTickLabels === 'all',

  1066                 showEndpointsTickLabels = opts.showTickLabels === 'endpoints' || opts.showTickLabels === 'all',

  1067                 labelWidth = opts.labelWidth || 0,

  1068                 labelHeight = opts.labelHeight || 0,

  1069                 legacyStyles = axis.direction + "Axis " + axis.direction + axis.n + "Axis",

  1070                 layer = "flot-" + axis.direction + "-axis flot-" + axis.direction + axis.n + "-axis " + legacyStyles,

  1071                 font = opts.font || "flot-tick-label tickLabel";

  1072 

  1073             for (var i = 0; i < ticks.length; ++i) {

  1074                 var t = ticks[i];

  1075                 var label = t.label;

  1076 

  1077                 if (!t.label ||

  1078                     (showMajorTickLabels === false && i > 0 && i < ticks.length - 1) ||

  1079                     (showEndpointsTickLabels === false && (i === 0 || i === ticks.length - 1))) {

  1080                     continue;

  1081                 }

  1082 

  1083                 if (typeof t.label === 'object') {

  1084                     label = t.label.name;

  1085                 }

  1086 

  1087                 var info = surface.getTextInfo(layer, label, font);

  1088 

  1089                 labelWidth = Math.max(labelWidth, info.width);

  1090                 labelHeight = Math.max(labelHeight, info.height);

  1091             }

  1092 

  1093             axis.labelWidth = opts.labelWidth || labelWidth;

  1094             axis.labelHeight = opts.labelHeight || labelHeight;

  1095         }

  1096 

  1097         function allocateAxisBoxFirstPhase(axis) {

  1098             // find the bounding box of the axis by looking at label

  1099             // widths/heights and ticks, make room by diminishing the

  1100             // plotOffset; this first phase only looks at one

  1101             // dimension per axis, the other dimension depends on the

  1102             // other axes so will have to wait

  1103 

  1104             // here reserve additional space

  1105             executeHooks(hooks.axisReserveSpace, [axis]);

  1106 

  1107             var lw = axis.labelWidth,

  1108                 lh = axis.labelHeight,

  1109                 pos = axis.options.position,

  1110                 isXAxis = axis.direction === "x",

  1111                 tickLength = axis.options.tickLength,

  1112                 showTicks = axis.options.showTicks,

  1113                 showMinorTicks = axis.options.showMinorTicks,

  1114                 gridLines = axis.options.gridLines,

  1115                 axisMargin = options.grid.axisMargin,

  1116                 padding = options.grid.labelMargin,

  1117                 innermost = true,

  1118                 outermost = true,

  1119                 found = false;

  1120 

  1121             // Determine the axis's position in its direction and on its side

  1122 

  1123             $.each(isXAxis ? xaxes : yaxes, function(i, a) {

  1124                 if (a && (a.show || a.reserveSpace)) {

  1125                     if (a === axis) {

  1126                         found = true;

  1127                     } else if (a.options.position === pos) {

  1128                         if (found) {

  1129                             outermost = false;

  1130                         } else {

  1131                             innermost = false;

  1132                         }

  1133                     }

  1134                 }

  1135             });