diff --git a/COPYRIGHT b/COPYRIGHT
index c1f400aff4e..d32bb9b45ea 100644
--- a/COPYRIGHT
+++ b/COPYRIGHT
@@ -38,13 +38,12 @@ TCPDI 1.0.0 LGPL-3+ / Apache 2.0 Yes
JS libraries:
Ace 1.4.8 BSD Yes JS library to get code syntaxique coloration in a textarea.
-Chart 2.9.3 MIT License Yes JS library for graph
+ChartJS 2.9.3 MIT License Yes JS library for graph
jQuery 3.4.1 MIT License Yes JS library
jQuery UI 1.12.1 GPL and MIT License Yes JS library plugin UI
jQuery select2 4.0.13 GPL and Apache License Yes JS library plugin for sexier multiselect
jQuery blockUI 2.70.0 GPL and MIT License Yes JS library plugin blockUI (to use ajax popups)
jQuery Colorpicker 1.1 MIT License Yes JS library for color picker for a defined list of colors
-jQuery Flot 0.8.3 MIT License Yes JS library to build graph
jQuery JCrop 0.9.8 GPL and MIT License Yes JS library plugin Crop (to crop images)
jQuery Jeditable 1.7.1 GPL and MIT License Yes JS library plugin jeditable (to edit in place)
jQuery jNotify 1.1.00 Apache Software License 2.0 Yes JS library plugin jNotify (to use ajax popups)
diff --git a/htdocs/includes/jquery/plugins/flot/API.md b/htdocs/includes/jquery/plugins/flot/API.md
deleted file mode 100644
index e08b44cf1d2..00000000000
--- a/htdocs/includes/jquery/plugins/flot/API.md
+++ /dev/null
@@ -1,1498 +0,0 @@
-# Flot Reference #
-
-**Table of Contents**
-
-[Introduction](#introduction)
-| [Data Format](#data-format)
-| [Plot Options](#plot-options)
-| [Customizing the legend](#customizing-the-legend)
-| [Customizing the axes](#customizing-the-axes)
-| [Multiple axes](#multiple-axes)
-| [Time series data](#time-series-data)
-| [Customizing the data series](#customizing-the-data-series)
-| [Customizing the grid](#customizing-the-grid)
-| [Specifying gradients](#specifying-gradients)
-| [Plot Methods](#plot-methods)
-| [Hooks](#hooks)
-| [Plugins](#plugins)
-| [Version number](#version-number)
-
----
-
-## Introduction ##
-
-Consider a call to the plot function:
-
-```js
-var plot = $.plot(placeholder, data, options)
-```
-
-The placeholder is a jQuery object or DOM element or jQuery expression
-that the plot will be put into. This placeholder needs to have its
-width and height set as explained in the [README](README.md) (go read that now if
-you haven't, it's short). The plot will modify some properties of the
-placeholder so it's recommended you simply pass in a div that you
-don't use for anything else. Make sure you check any fancy styling
-you apply to the div, e.g. background images have been reported to be a
-problem on IE 7.
-
-The plot function can also be used as a jQuery chainable property. This form
-naturally can't return the plot object directly, but you can still access it
-via the 'plot' data key, like this:
-
-```js
-var plot = $("#placeholder").plot(data, options).data("plot");
-```
-
-The format of the data is documented below, as is the available
-options. The plot object returned from the call has some methods you
-can call. These are documented separately below.
-
-Note that in general Flot gives no guarantees if you change any of the
-objects you pass in to the plot function or get out of it since
-they're not necessarily deep-copied.
-
-
-## Data Format ##
-
-The data is an array of data series:
-
-```js
-[ series1, series2, ... ]
-```
-
-A series can either be raw data or an object with properties. The raw
-data format is an array of points:
-
-```js
-[ [x1, y1], [x2, y2], ... ]
-```
-
-E.g.
-
-```js
-[ [1, 3], [2, 14.01], [3.5, 3.14] ]
-```
-
-Note that to simplify the internal logic in Flot both the x and y
-values must be numbers (even if specifying time series, see below for
-how to do this). This is a common problem because you might retrieve
-data from the database and serialize them directly to JSON without
-noticing the wrong type. If you're getting mysterious errors, double
-check that you're inputting numbers and not strings.
-
-If a null is specified as a point or if one of the coordinates is null
-or couldn't be converted to a number, the point is ignored when
-drawing. As a special case, a null value for lines is interpreted as a
-line segment end, i.e. the points before and after the null value are
-not connected.
-
-Lines and points take two coordinates. For filled lines and bars, you
-can specify a third coordinate which is the bottom of the filled
-area/bar (defaults to 0).
-
-The format of a single series object is as follows:
-
-```js
-{
- color: color or number
- data: rawdata
- label: string
- lines: specific lines options
- bars: specific bars options
- points: specific points options
- xaxis: number
- yaxis: number
- clickable: boolean
- hoverable: boolean
- shadowSize: number
- highlightColor: color or number
-}
-```
-
-You don't have to specify any of them except the data, the rest are
-options that will get default values. Typically you'd only specify
-label and data, like this:
-
-```js
-{
- label: "y = 3",
- data: [[0, 3], [10, 3]]
-}
-```
-
-The label is used for the legend, if you don't specify one, the series
-will not show up in the legend.
-
-If you don't specify color, the series will get a color from the
-auto-generated colors. The color is either a CSS color specification
-(like "rgb(255, 100, 123)") or an integer that specifies which of
-auto-generated colors to select, e.g. 0 will get color no. 0, etc.
-
-The latter is mostly useful if you let the user add and remove series,
-in which case you can hard-code the color index to prevent the colors
-from jumping around between the series.
-
-The "xaxis" and "yaxis" options specify which axis to use. The axes
-are numbered from 1 (default), so { yaxis: 2} means that the series
-should be plotted against the second y axis.
-
-"clickable" and "hoverable" can be set to false to disable
-interactivity for specific series if interactivity is turned on in
-the plot, see below.
-
-The rest of the options are all documented below as they are the same
-as the default options passed in via the options parameter in the plot
-commmand. When you specify them for a specific data series, they will
-override the default options for the plot for that data series.
-
-Here's a complete example of a simple data specification:
-
-```js
-[ { label: "Foo", data: [ [10, 1], [17, -14], [30, 5] ] },
- { label: "Bar", data: [ [11, 13], [19, 11], [30, -7] ] }
-]
-```
-
-
-## Plot Options ##
-
-All options are completely optional. They are documented individually
-below, to change them you just specify them in an object, e.g.
-
-```js
-var options = {
- series: {
- lines: { show: true },
- points: { show: true }
- }
-};
-
-$.plot(placeholder, data, options);
-```
-
-
-## Customizing the legend ##
-
-```js
-legend: {
- show: boolean
- labelFormatter: null or (fn: string, series object -> string)
- labelBoxBorderColor: color
- noColumns: number
- position: "ne" or "nw" or "se" or "sw"
- margin: number of pixels or [x margin, y margin]
- backgroundColor: null or color
- backgroundOpacity: number between 0 and 1
- container: null or jQuery object/DOM element/jQuery expression
- sorted: null/false, true, "ascending", "descending", "reverse", or a comparator
-}
-```
-
-The legend is generated as a table with the data series labels and
-small label boxes with the color of the series. If you want to format
-the labels in some way, e.g. make them to links, you can pass in a
-function for "labelFormatter". Here's an example that makes them
-clickable:
-
-```js
-labelFormatter: function(label, series) {
- // series is the series object for the label
- return '' + label + '';
-}
-```
-
-To prevent a series from showing up in the legend, simply have the function
-return null.
-
-"noColumns" is the number of columns to divide the legend table into.
-"position" specifies the overall placement of the legend within the
-plot (top-right, top-left, etc.) and margin the distance to the plot
-edge (this can be either a number or an array of two numbers like [x,
-y]). "backgroundColor" and "backgroundOpacity" specifies the
-background. The default is a partly transparent auto-detected
-background.
-
-If you want the legend to appear somewhere else in the DOM, you can
-specify "container" as a jQuery object/expression to put the legend
-table into. The "position" and "margin" etc. options will then be
-ignored. Note that Flot will overwrite the contents of the container.
-
-Legend entries appear in the same order as their series by default. If "sorted"
-is "reverse" then they appear in the opposite order from their series. To sort
-them alphabetically, you can specify true, "ascending" or "descending", where
-true and "ascending" are equivalent.
-
-You can also provide your own comparator function that accepts two
-objects with "label" and "color" properties, and returns zero if they
-are equal, a positive value if the first is greater than the second,
-and a negative value if the first is less than the second.
-
-```js
-sorted: function(a, b) {
- // sort alphabetically in ascending order
- return a.label == b.label ? 0 : (
- a.label > b.label ? 1 : -1
- )
-}
-```
-
-
-## Customizing the axes ##
-
-```js
-xaxis, yaxis: {
- show: null or true/false
- position: "bottom" or "top" or "left" or "right"
- mode: null or "time" ("time" requires jquery.flot.time.js plugin)
- timezone: null, "browser" or timezone (only makes sense for mode: "time")
-
- color: null or color spec
- tickColor: null or color spec
- font: null or font spec object
-
- min: null or number
- max: null or number
- autoscaleMargin: null or number
-
- transform: null or fn: number -> number
- inverseTransform: null or fn: number -> number
-
- ticks: null or number or ticks array or (fn: axis -> ticks array)
- tickSize: number or array
- minTickSize: number or array
- tickFormatter: (fn: number, object -> string) or string
- tickDecimals: null or number
-
- labelWidth: null or number
- labelHeight: null or number
- reserveSpace: null or true
-
- tickLength: null or number
-
- alignTicksWithAxis: null or number
-}
-```
-
-All axes have the same kind of options. The following describes how to
-configure one axis, see below for what to do if you've got more than
-one x axis or y axis.
-
-If you don't set the "show" option (i.e. it is null), visibility is
-auto-detected, i.e. the axis will show up if there's data associated
-with it. You can override this by setting the "show" option to true or
-false.
-
-The "position" option specifies where the axis is placed, bottom or
-top for x axes, left or right for y axes. The "mode" option determines
-how the data is interpreted, the default of null means as decimal
-numbers. Use "time" for time series data; see the time series data
-section. The time plugin (jquery.flot.time.js) is required for time
-series support.
-
-The "color" option determines the color of the line and ticks for the axis, and
-defaults to the grid color with transparency. For more fine-grained control you
-can also set the color of the ticks separately with "tickColor".
-
-You can customize the font and color used to draw the axis tick labels with CSS
-or directly via the "font" option. When "font" is null - the default - each
-tick label is given the 'flot-tick-label' class. For compatibility with Flot
-0.7 and earlier the labels are also given the 'tickLabel' class, but this is
-deprecated and scheduled to be removed with the release of version 1.0.0.
-
-To enable more granular control over styles, labels are divided between a set
-of text containers, with each holding the labels for one axis. These containers
-are given the classes 'flot-[x|y]-axis', and 'flot-[x|y]#-axis', where '#' is
-the number of the axis when there are multiple axes. For example, the x-axis
-labels for a simple plot with only a single x-axis might look like this:
-
-```html
-
-```
-
-For direct control over label styles you can also provide "font" as an object
-with this format:
-
-```js
-{
- size: 11,
- lineHeight: 13,
- style: "italic",
- weight: "bold",
- family: "sans-serif",
- variant: "small-caps",
- color: "#545454"
-}
-```
-
-The size and lineHeight must be expressed in pixels; CSS units such as 'em'
-or 'smaller' are not allowed.
-
-The options "min"/"max" are the precise minimum/maximum value on the
-scale. If you don't specify either of them, a value will automatically
-be chosen based on the minimum/maximum data values. Note that Flot
-always examines all the data values you feed to it, even if a
-restriction on another axis may make some of them invisible (this
-makes interactive use more stable).
-
-The "autoscaleMargin" is a bit esoteric: it's the fraction of margin
-that the scaling algorithm will add to avoid that the outermost points
-ends up on the grid border. Note that this margin is only applied when
-a min or max value is not explicitly set. If a margin is specified,
-the plot will furthermore extend the axis end-point to the nearest
-whole tick. The default value is "null" for the x axes and 0.02 for y
-axes which seems appropriate for most cases.
-
-"transform" and "inverseTransform" are callbacks you can put in to
-change the way the data is drawn. You can design a function to
-compress or expand certain parts of the axis non-linearly, e.g.
-suppress weekends or compress far away points with a logarithm or some
-other means. When Flot draws the plot, each value is first put through
-the transform function. Here's an example, the x axis can be turned
-into a natural logarithm axis with the following code:
-
-```js
-xaxis: {
- transform: function (v) { return Math.log(v); },
- inverseTransform: function (v) { return Math.exp(v); }
-}
-```
-
-Similarly, for reversing the y axis so the values appear in inverse
-order:
-
-```js
-yaxis: {
- transform: function (v) { return -v; },
- inverseTransform: function (v) { return -v; }
-}
-```
-
-Note that for finding extrema, Flot assumes that the transform
-function does not reorder values (it should be monotone).
-
-The inverseTransform is simply the inverse of the transform function
-(so v == inverseTransform(transform(v)) for all relevant v). It is
-required for converting from canvas coordinates to data coordinates,
-e.g. for a mouse interaction where a certain pixel is clicked. If you
-don't use any interactive features of Flot, you may not need it.
-
-
-The rest of the options deal with the ticks.
-
-If you don't specify any ticks, a tick generator algorithm will make
-some for you. The algorithm has two passes. It first estimates how
-many ticks would be reasonable and uses this number to compute a nice
-round tick interval size. Then it generates the ticks.
-
-You can specify how many ticks the algorithm aims for by setting
-"ticks" to a number. The algorithm always tries to generate reasonably
-round tick values so even if you ask for three ticks, you might get
-five if that fits better with the rounding. If you don't want any
-ticks at all, set "ticks" to 0 or an empty array.
-
-Another option is to skip the rounding part and directly set the tick
-interval size with "tickSize". If you set it to 2, you'll get ticks at
-2, 4, 6, etc. Alternatively, you can specify that you just don't want
-ticks at a size less than a specific tick size with "minTickSize".
-Note that for time series, the format is an array like [2, "month"],
-see the next section.
-
-If you want to completely override the tick algorithm, you can specify
-an array for "ticks", either like this:
-
-```js
-ticks: [0, 1.2, 2.4]
-```
-
-Or like this where the labels are also customized:
-
-```js
-ticks: [[0, "zero"], [1.2, "one mark"], [2.4, "two marks"]]
-```
-
-You can mix the two if you like.
-
-For extra flexibility you can specify a function as the "ticks"
-parameter. The function will be called with an object with the axis
-min and max and should return a ticks array. Here's a simplistic tick
-generator that spits out intervals of pi, suitable for use on the x
-axis for trigonometric functions:
-
-```js
-function piTickGenerator(axis) {
- var res = [], i = Math.floor(axis.min / Math.PI);
- do {
- var v = i * Math.PI;
- res.push([v, i + "\u03c0"]);
- ++i;
- } while (v < axis.max);
- return res;
-}
-```
-
-You can control how the ticks look like with "tickDecimals", the
-number of decimals to display (default is auto-detected).
-
-Alternatively, for ultimate control over how ticks are formatted you can
-provide a function to "tickFormatter". The function is passed two
-parameters, the tick value and an axis object with information, and
-should return a string. The default formatter looks like this:
-
-```js
-function formatter(val, axis) {
- return val.toFixed(axis.tickDecimals);
-}
-```
-
-The axis object has "min" and "max" with the range of the axis,
-"tickDecimals" with the number of decimals to round the value to and
-"tickSize" with the size of the interval between ticks as calculated
-by the automatic axis scaling algorithm (or specified by you). Here's
-an example of a custom formatter:
-
-```js
-function suffixFormatter(val, axis) {
- if (val > 1000000)
- return (val / 1000000).toFixed(axis.tickDecimals) + " MB";
- else if (val > 1000)
- return (val / 1000).toFixed(axis.tickDecimals) + " kB";
- else
- return val.toFixed(axis.tickDecimals) + " B";
-}
-```
-
-"labelWidth" and "labelHeight" specifies a fixed size of the tick
-labels in pixels. They're useful in case you need to align several
-plots. "reserveSpace" means that even if an axis isn't shown, Flot
-should reserve space for it - it is useful in combination with
-labelWidth and labelHeight for aligning multi-axis charts.
-
-"tickLength" is the length of the tick lines in pixels. By default, the
-innermost axes will have ticks that extend all across the plot, while
-any extra axes use small ticks. A value of null means use the default,
-while a number means small ticks of that length - set it to 0 to hide
-the lines completely.
-
-If you set "alignTicksWithAxis" to the number of another axis, e.g.
-alignTicksWithAxis: 1, Flot will ensure that the autogenerated ticks
-of this axis are aligned with the ticks of the other axis. This may
-improve the looks, e.g. if you have one y axis to the left and one to
-the right, because the grid lines will then match the ticks in both
-ends. The trade-off is that the forced ticks won't necessarily be at
-natural places.
-
-
-## Multiple axes ##
-
-If you need more than one x axis or y axis, you need to specify for
-each data series which axis they are to use, as described under the
-format of the data series, e.g. { data: [...], yaxis: 2 } specifies
-that a series should be plotted against the second y axis.
-
-To actually configure that axis, you can't use the xaxis/yaxis options
-directly - instead there are two arrays in the options:
-
-```js
-xaxes: []
-yaxes: []
-```
-
-Here's an example of configuring a single x axis and two y axes (we
-can leave options of the first y axis empty as the defaults are fine):
-
-```js
-{
- xaxes: [ { position: "top" } ],
- yaxes: [ { }, { position: "right", min: 20 } ]
-}
-```
-
-The arrays get their default values from the xaxis/yaxis settings, so
-say you want to have all y axes start at zero, you can simply specify
-yaxis: { min: 0 } instead of adding a min parameter to all the axes.
-
-Generally, the various interfaces in Flot dealing with data points
-either accept an xaxis/yaxis parameter to specify which axis number to
-use (starting from 1), or lets you specify the coordinate directly as
-x2/x3/... or x2axis/x3axis/... instead of "x" or "xaxis".
-
-
-## Time series data ##
-
-Please note that it is now required to include the time plugin,
-jquery.flot.time.js, for time series support.
-
-Time series are a bit more difficult than scalar data because
-calendars don't follow a simple base 10 system. For many cases, Flot
-abstracts most of this away, but it can still be a bit difficult to
-get the data into Flot. So we'll first discuss the data format.
-
-The time series support in Flot is based on Javascript timestamps,
-i.e. everywhere a time value is expected or handed over, a Javascript
-timestamp number is used. This is a number, not a Date object. A
-Javascript timestamp is the number of milliseconds since January 1,
-1970 00:00:00 UTC. This is almost the same as Unix timestamps, except it's
-in milliseconds, so remember to multiply by 1000!
-
-You can see a timestamp like this
-
-```js
-alert((new Date()).getTime())
-```
-
-There are different schools of thought when it comes to display of
-timestamps. Many will want the timestamps to be displayed according to
-a certain time zone, usually the time zone in which the data has been
-produced. Some want the localized experience, where the timestamps are
-displayed according to the local time of the visitor. Flot supports
-both. Optionally you can include a third-party library to get
-additional timezone support.
-
-Default behavior is that Flot always displays timestamps according to
-UTC. The reason being that the core Javascript Date object does not
-support other fixed time zones. Often your data is at another time
-zone, so it may take a little bit of tweaking to work around this
-limitation.
-
-The easiest way to think about it is to pretend that the data
-production time zone is UTC, even if it isn't. So if you have a
-datapoint at 2002-02-20 08:00, you can generate a timestamp for eight
-o'clock UTC even if it really happened eight o'clock UTC+0200.
-
-In PHP you can get an appropriate timestamp with:
-
-```php
-strtotime("2002-02-20 UTC") * 1000
-```
-
-In Python you can get it with something like:
-
-```python
-calendar.timegm(datetime_object.timetuple()) * 1000
-```
-In Ruby you can get it using the `#to_i` method on the
-[`Time`](http://apidock.com/ruby/Time/to_i) object. If you're using the
-`active_support` gem (default for Ruby on Rails applications) `#to_i` is also
-available on the `DateTime` and `ActiveSupport::TimeWithZone` objects. You
-simply need to multiply the result by 1000:
-
-```ruby
-Time.now.to_i * 1000 # => 1383582043000
-# ActiveSupport examples:
-DateTime.now.to_i * 1000 # => 1383582043000
-ActiveSupport::TimeZone.new('Asia/Shanghai').now.to_i * 1000
-# => 1383582043000
-```
-
-In .NET you can get it with something like:
-
-```aspx
-public static int GetJavascriptTimestamp(System.DateTime input)
-{
- System.TimeSpan span = new System.TimeSpan(System.DateTime.Parse("1/1/1970").Ticks);
- System.DateTime time = input.Subtract(span);
- return (long)(time.Ticks / 10000);
-}
-```
-
-Javascript also has some support for parsing date strings, so it is
-possible to generate the timestamps manually client-side.
-
-If you've already got the real UTC timestamp, it's too late to use the
-pretend trick described above. But you can fix up the timestamps by
-adding the time zone offset, e.g. for UTC+0200 you would add 2 hours
-to the UTC timestamp you got. Then it'll look right on the plot. Most
-programming environments have some means of getting the timezone
-offset for a specific date (note that you need to get the offset for
-each individual timestamp to account for daylight savings).
-
-The alternative with core Javascript is to interpret the timestamps
-according to the time zone that the visitor is in, which means that
-the ticks will shift with the time zone and daylight savings of each
-visitor. This behavior is enabled by setting the axis option
-"timezone" to the value "browser".
-
-If you need more time zone functionality than this, there is still
-another option. If you include the "timezone-js" library
- in the page and set axis.timezone
-to a value recognized by said library, Flot will use timezone-js to
-interpret the timestamps according to that time zone.
-
-Once you've gotten the timestamps into the data and specified "time"
-as the axis mode, Flot will automatically generate relevant ticks and
-format them. As always, you can tweak the ticks via the "ticks" option
-- just remember that the values should be timestamps (numbers), not
-Date objects.
-
-Tick generation and formatting can also be controlled separately
-through the following axis options:
-
-```js
-minTickSize: array
-timeformat: null or format string
-monthNames: null or array of size 12 of strings
-dayNames: null or array of size 7 of strings
-twelveHourClock: boolean
-```
-
-Here "timeformat" is a format string to use. You might use it like
-this:
-
-```js
-xaxis: {
- mode: "time",
- timeformat: "%Y/%m/%d"
-}
-```
-
-This will result in tick labels like "2000/12/24". A subset of the
-standard strftime specifiers are supported (plus the nonstandard %q):
-
-```js
-%a: weekday name (customizable)
-%b: month name (customizable)
-%d: day of month, zero-padded (01-31)
-%e: day of month, space-padded ( 1-31)
-%H: hours, 24-hour time, zero-padded (00-23)
-%I: hours, 12-hour time, zero-padded (01-12)
-%m: month, zero-padded (01-12)
-%M: minutes, zero-padded (00-59)
-%q: quarter (1-4)
-%S: seconds, zero-padded (00-59)
-%y: year (two digits)
-%Y: year (four digits)
-%p: am/pm
-%P: AM/PM (uppercase version of %p)
-%w: weekday as number (0-6, 0 being Sunday)
-```
-
-Flot 0.8 switched from %h to the standard %H hours specifier. The %h specifier
-is still available, for backwards-compatibility, but is deprecated and
-scheduled to be removed permanently with the release of version 1.0.
-
-You can customize the month names with the "monthNames" option. For
-instance, for Danish you might specify:
-
-```js
-monthNames: ["jan", "feb", "mar", "apr", "maj", "jun", "jul", "aug", "sep", "okt", "nov", "dec"]
-```
-
-Similarly you can customize the weekday names with the "dayNames"
-option. An example in French:
-
-```js
-dayNames: ["dim", "lun", "mar", "mer", "jeu", "ven", "sam"]
-```
-
-If you set "twelveHourClock" to true, the autogenerated timestamps
-will use 12 hour AM/PM timestamps instead of 24 hour. This only
-applies if you have not set "timeformat". Use the "%I" and "%p" or
-"%P" options if you want to build your own format string with 12-hour
-times.
-
-If the Date object has a strftime property (and it is a function), it
-will be used instead of the built-in formatter. Thus you can include
-a strftime library such as http://hacks.bluesmoon.info/strftime/ for
-more powerful date/time formatting.
-
-If everything else fails, you can control the formatting by specifying
-a custom tick formatter function as usual. Here's a simple example
-which will format December 24 as 24/12:
-
-```js
-tickFormatter: function (val, axis) {
- var d = new Date(val);
- return d.getUTCDate() + "/" + (d.getUTCMonth() + 1);
-}
-```
-
-Note that for the time mode "tickSize" and "minTickSize" are a bit
-special in that they are arrays on the form "[value, unit]" where unit
-is one of "second", "minute", "hour", "day", "month" and "year". So
-you can specify
-
-```js
-minTickSize: [1, "month"]
-```
-
-to get a tick interval size of at least 1 month and correspondingly,
-if axis.tickSize is [2, "day"] in the tick formatter, the ticks have
-been produced with two days in-between.
-
-
-## Customizing the data series ##
-
-```js
-series: {
- lines, points, bars: {
- show: boolean
- lineWidth: number
- fill: boolean or number
- fillColor: null or color/gradient
- }
-
- lines, bars: {
- zero: boolean
- }
-
- points: {
- radius: number
- symbol: "circle" or function
- }
-
- bars: {
- barWidth: number
- align: "left", "right" or "center"
- horizontal: boolean
- }
-
- lines: {
- steps: boolean
- }
-
- shadowSize: number
- highlightColor: color or number
-}
-
-colors: [ color1, color2, ... ]
-```
-
-The options inside "series: {}" are copied to each of the series. So
-you can specify that all series should have bars by putting it in the
-global options, or override it for individual series by specifying
-bars in a particular the series object in the array of data.
-
-The most important options are "lines", "points" and "bars" that
-specify whether and how lines, points and bars should be shown for
-each data series. In case you don't specify anything at all, Flot will
-default to showing lines (you can turn this off with
-lines: { show: false }). You can specify the various types
-independently of each other, and Flot will happily draw each of them
-in turn (this is probably only useful for lines and points), e.g.
-
-```js
-var options = {
- series: {
- lines: { show: true, fill: true, fillColor: "rgba(255, 255, 255, 0.8)" },
- points: { show: true, fill: false }
- }
-};
-```
-
-"lineWidth" is the thickness of the line or outline in pixels. You can
-set it to 0 to prevent a line or outline from being drawn; this will
-also hide the shadow.
-
-"fill" is whether the shape should be filled. For lines, this produces
-area graphs. You can use "fillColor" to specify the color of the fill.
-If "fillColor" evaluates to false (default for everything except
-points which are filled with white), the fill color is auto-set to the
-color of the data series. You can adjust the opacity of the fill by
-setting fill to a number between 0 (fully transparent) and 1 (fully
-opaque).
-
-For bars, fillColor can be a gradient, see the gradient documentation
-below. "barWidth" is the width of the bars in units of the x axis (or
-the y axis if "horizontal" is true), contrary to most other measures
-that are specified in pixels. For instance, for time series the unit
-is milliseconds so 24 * 60 * 60 * 1000 produces bars with the width of
-a day. "align" specifies whether a bar should be left-aligned
-(default), right-aligned or centered on top of the value it represents.
-When "horizontal" is on, the bars are drawn horizontally, i.e. from the
-y axis instead of the x axis; note that the bar end points are still
-defined in the same way so you'll probably want to swap the
-coordinates if you've been plotting vertical bars first.
-
-Area and bar charts normally start from zero, regardless of the data's range.
-This is because they convey information through size, and starting from a
-different value would distort their meaning. In cases where the fill is purely
-for decorative purposes, however, "zero" allows you to override this behavior.
-It defaults to true for filled lines and bars; setting it to false tells the
-series to use the same automatic scaling as an un-filled line.
-
-For lines, "steps" specifies whether two adjacent data points are
-connected with a straight (possibly diagonal) line or with first a
-horizontal and then a vertical line. Note that this transforms the
-data by adding extra points.
-
-For points, you can specify the radius and the symbol. The only
-built-in symbol type is circles, for other types you can use a plugin
-or define them yourself by specifying a callback:
-
-```js
-function cross(ctx, x, y, radius, shadow) {
- var size = radius * Math.sqrt(Math.PI) / 2;
- ctx.moveTo(x - size, y - size);
- ctx.lineTo(x + size, y + size);
- ctx.moveTo(x - size, y + size);
- ctx.lineTo(x + size, y - size);
-}
-```
-
-The parameters are the drawing context, x and y coordinates of the
-center of the point, a radius which corresponds to what the circle
-would have used and whether the call is to draw a shadow (due to
-limited canvas support, shadows are currently faked through extra
-draws). It's good practice to ensure that the area covered by the
-symbol is the same as for the circle with the given radius, this
-ensures that all symbols have approximately the same visual weight.
-
-"shadowSize" is the default size of shadows in pixels. Set it to 0 to
-remove shadows.
-
-"highlightColor" is the default color of the translucent overlay used
-to highlight the series when the mouse hovers over it.
-
-The "colors" array specifies a default color theme to get colors for
-the data series from. You can specify as many colors as you like, like
-this:
-
-```js
-colors: ["#d18b2c", "#dba255", "#919733"]
-```
-
-If there are more data series than colors, Flot will try to generate
-extra colors by lightening and darkening colors in the theme.
-
-
-## Customizing the grid ##
-
-```js
-grid: {
- show: boolean
- aboveData: boolean
- color: color
- backgroundColor: color/gradient or null
- margin: number or margin object
- labelMargin: number
- axisMargin: number
- markings: array of markings or (fn: axes -> array of markings)
- borderWidth: number or object with "top", "right", "bottom" and "left" properties with different widths
- borderColor: color or null or object with "top", "right", "bottom" and "left" properties with different colors
- minBorderMargin: number or null
- clickable: boolean
- hoverable: boolean
- autoHighlight: boolean
- mouseActiveRadius: number
-}
-
-interaction: {
- redrawOverlayInterval: number or -1
-}
-```
-
-The grid is the thing with the axes and a number of ticks. Many of the
-things in the grid are configured under the individual axes, but not
-all. "color" is the color of the grid itself whereas "backgroundColor"
-specifies the background color inside the grid area, here null means
-that the background is transparent. You can also set a gradient, see
-the gradient documentation below.
-
-You can turn off the whole grid including tick labels by setting
-"show" to false. "aboveData" determines whether the grid is drawn
-above the data or below (below is default).
-
-"margin" is the space in pixels between the canvas edge and the grid,
-which can be either a number or an object with individual margins for
-each side, in the form:
-
-```js
-margin: {
- top: top margin in pixels
- left: left margin in pixels
- bottom: bottom margin in pixels
- right: right margin in pixels
-}
-```
-
-"labelMargin" is the space in pixels between tick labels and axis
-line, and "axisMargin" is the space in pixels between axes when there
-are two next to each other.
-
-"borderWidth" is the width of the border around the plot. Set it to 0
-to disable the border. Set it to an object with "top", "right",
-"bottom" and "left" properties to use different widths. You can
-also set "borderColor" if you want the border to have a different color
-than the grid lines. Set it to an object with "top", "right", "bottom"
-and "left" properties to use different colors. "minBorderMargin" controls
-the default minimum margin around the border - it's used to make sure
-that points aren't accidentally clipped by the canvas edge so by default
-the value is computed from the point radius.
-
-"markings" is used to draw simple lines and rectangular areas in the
-background of the plot. You can either specify an array of ranges on
-the form { xaxis: { from, to }, yaxis: { from, to } } (with multiple
-axes, you can specify coordinates for other axes instead, e.g. as
-x2axis/x3axis/...) or with a function that returns such an array given
-the axes for the plot in an object as the first parameter.
-
-You can set the color of markings by specifying "color" in the ranges
-object. Here's an example array:
-
-```js
-markings: [ { xaxis: { from: 0, to: 2 }, yaxis: { from: 10, to: 10 }, color: "#bb0000" }, ... ]
-```
-
-If you leave out one of the values, that value is assumed to go to the
-border of the plot. So for example if you only specify { xaxis: {
-from: 0, to: 2 } } it means an area that extends from the top to the
-bottom of the plot in the x range 0-2.
-
-A line is drawn if from and to are the same, e.g.
-
-```js
-markings: [ { yaxis: { from: 1, to: 1 } }, ... ]
-```
-
-would draw a line parallel to the x axis at y = 1. You can control the
-line width with "lineWidth" in the range object.
-
-An example function that makes vertical stripes might look like this:
-
-```js
-markings: function (axes) {
- var markings = [];
- for (var x = Math.floor(axes.xaxis.min); x < axes.xaxis.max; x += 2)
- markings.push({ xaxis: { from: x, to: x + 1 } });
- return markings;
-}
-```
-
-If you set "clickable" to true, the plot will listen for click events
-on the plot area and fire a "plotclick" event on the placeholder with
-a position and a nearby data item object as parameters. The coordinates
-are available both in the unit of the axes (not in pixels) and in
-global screen coordinates.
-
-Likewise, if you set "hoverable" to true, the plot will listen for
-mouse move events on the plot area and fire a "plothover" event with
-the same parameters as the "plotclick" event. If "autoHighlight" is
-true (the default), nearby data items are highlighted automatically.
-If needed, you can disable highlighting and control it yourself with
-the highlight/unhighlight plot methods described elsewhere.
-
-You can use "plotclick" and "plothover" events like this:
-
-```js
-$.plot($("#placeholder"), [ d ], { grid: { clickable: true } });
-
-$("#placeholder").bind("plotclick", function (event, pos, item) {
- alert("You clicked at " + pos.x + ", " + pos.y);
- // axis coordinates for other axes, if present, are in pos.x2, pos.x3, ...
- // if you need global screen coordinates, they are pos.pageX, pos.pageY
-
- if (item) {
- highlight(item.series, item.datapoint);
- alert("You clicked a point!");
- }
-});
-```
-
-The item object in this example is either null or a nearby object on the form:
-
-```js
-item: {
- datapoint: the point, e.g. [0, 2]
- dataIndex: the index of the point in the data array
- series: the series object
- seriesIndex: the index of the series
- pageX, pageY: the global screen coordinates of the point
-}
-```
-
-For instance, if you have specified the data like this
-
-```js
-$.plot($("#placeholder"), [ { label: "Foo", data: [[0, 10], [7, 3]] } ], ...);
-```
-
-and the mouse is near the point (7, 3), "datapoint" is [7, 3],
-"dataIndex" will be 1, "series" is a normalized series object with
-among other things the "Foo" label in series.label and the color in
-series.color, and "seriesIndex" is 0. Note that plugins and options
-that transform the data can shift the indexes from what you specified
-in the original data array.
-
-If you use the above events to update some other information and want
-to clear out that info in case the mouse goes away, you'll probably
-also need to listen to "mouseout" events on the placeholder div.
-
-"mouseActiveRadius" specifies how far the mouse can be from an item
-and still activate it. If there are two or more points within this
-radius, Flot chooses the closest item. For bars, the top-most bar
-(from the latest specified data series) is chosen.
-
-If you want to disable interactivity for a specific data series, you
-can set "hoverable" and "clickable" to false in the options for that
-series, like this:
-
-```js
-{ data: [...], label: "Foo", clickable: false }
-```
-
-"redrawOverlayInterval" specifies the maximum time to delay a redraw
-of interactive things (this works as a rate limiting device). The
-default is capped to 60 frames per second. You can set it to -1 to
-disable the rate limiting.
-
-
-## Specifying gradients ##
-
-A gradient is specified like this:
-
-```js
-{ colors: [ color1, color2, ... ] }
-```
-
-For instance, you might specify a background on the grid going from
-black to gray like this:
-
-```js
-grid: {
- backgroundColor: { colors: ["#000", "#999"] }
-}
-```
-
-For the series you can specify the gradient as an object that
-specifies the scaling of the brightness and the opacity of the series
-color, e.g.
-
-```js
-{ colors: [{ opacity: 0.8 }, { brightness: 0.6, opacity: 0.8 } ] }
-```
-
-where the first color simply has its alpha scaled, whereas the second
-is also darkened. For instance, for bars the following makes the bars
-gradually disappear, without outline:
-
-```js
-bars: {
- show: true,
- lineWidth: 0,
- fill: true,
- fillColor: { colors: [ { opacity: 0.8 }, { opacity: 0.1 } ] }
-}
-```
-
-Flot currently only supports vertical gradients drawn from top to
-bottom because that's what works with IE.
-
-
-## Plot Methods ##
-
-The Plot object returned from the plot function has some methods you
-can call:
-
- - highlight(series, datapoint)
-
- Highlight a specific datapoint in the data series. You can either
- specify the actual objects, e.g. if you got them from a
- "plotclick" event, or you can specify the indices, e.g.
- highlight(1, 3) to highlight the fourth point in the second series
- (remember, zero-based indexing).
-
- - unhighlight(series, datapoint) or unhighlight()
-
- Remove the highlighting of the point, same parameters as
- highlight.
-
- If you call unhighlight with no parameters, e.g. as
- plot.unhighlight(), all current highlights are removed.
-
- - setData(data)
-
- You can use this to reset the data used. Note that axis scaling,
- ticks, legend etc. will not be recomputed (use setupGrid() to do
- that). You'll probably want to call draw() afterwards.
-
- You can use this function to speed up redrawing a small plot if
- you know that the axes won't change. Put in the new data with
- setData(newdata), call draw(), and you're good to go. Note that
- for large datasets, almost all the time is consumed in draw()
- plotting the data so in this case don't bother.
-
- - setupGrid()
-
- Recalculate and set axis scaling, ticks, legend etc.
-
- Note that because of the drawing model of the canvas, this
- function will immediately redraw (actually reinsert in the DOM)
- the labels and the legend, but not the actual tick lines because
- they're drawn on the canvas. You need to call draw() to get the
- canvas redrawn.
-
- - draw()
-
- Redraws the plot canvas.
-
- - triggerRedrawOverlay()
-
- Schedules an update of an overlay canvas used for drawing
- interactive things like a selection and point highlights. This
- is mostly useful for writing plugins. The redraw doesn't happen
- immediately, instead a timer is set to catch multiple successive
- redraws (e.g. from a mousemove). You can get to the overlay by
- setting up a drawOverlay hook.
-
- - width()/height()
-
- Gets the width and height of the plotting area inside the grid.
- This is smaller than the canvas or placeholder dimensions as some
- extra space is needed (e.g. for labels).
-
- - offset()
-
- Returns the offset of the plotting area inside the grid relative
- to the document, useful for instance for calculating mouse
- positions (event.pageX/Y minus this offset is the pixel position
- inside the plot).
-
- - pointOffset({ x: xpos, y: ypos })
-
- Returns the calculated offset of the data point at (x, y) in data
- space within the placeholder div. If you are working with multiple
- axes, you can specify the x and y axis references, e.g.
-
- ```js
- o = pointOffset({ x: xpos, y: ypos, xaxis: 2, yaxis: 3 })
- // o.left and o.top now contains the offset within the div
- ````
-
- - resize()
-
- Tells Flot to resize the drawing canvas to the size of the
- placeholder. You need to run setupGrid() and draw() afterwards as
- canvas resizing is a destructive operation. This is used
- internally by the resize plugin.
-
- - shutdown()
-
- Cleans up any event handlers Flot has currently registered. This
- is used internally.
-
-There are also some members that let you peek inside the internal
-workings of Flot which is useful in some cases. Note that if you change
-something in the objects returned, you're changing the objects used by
-Flot to keep track of its state, so be careful.
-
- - getData()
-
- Returns an array of the data series currently used in normalized
- form with missing settings filled in according to the global
- options. So for instance to find out what color Flot has assigned
- to the data series, you could do this:
-
- ```js
- var series = plot.getData();
- for (var i = 0; i < series.length; ++i)
- alert(series[i].color);
- ```
-
- A notable other interesting field besides color is datapoints
- which has a field "points" with the normalized data points in a
- flat array (the field "pointsize" is the increment in the flat
- array to get to the next point so for a dataset consisting only of
- (x,y) pairs it would be 2).
-
- - getAxes()
-
- Gets an object with the axes. The axes are returned as the
- attributes of the object, so for instance getAxes().xaxis is the
- x axis.
-
- Various things are stuffed inside an axis object, e.g. you could
- use getAxes().xaxis.ticks to find out what the ticks are for the
- xaxis. Two other useful attributes are p2c and c2p, functions for
- transforming from data point space to the canvas plot space and
- back. Both returns values that are offset with the plot offset.
- Check the Flot source code for the complete set of attributes (or
- output an axis with console.log() and inspect it).
-
- With multiple axes, the extra axes are returned as x2axis, x3axis,
- etc., e.g. getAxes().y2axis is the second y axis. You can check
- y2axis.used to see whether the axis is associated with any data
- points and y2axis.show to see if it is currently shown.
-
- - getPlaceholder()
-
- Returns placeholder that the plot was put into. This can be useful
- for plugins for adding DOM elements or firing events.
-
- - getCanvas()
-
- Returns the canvas used for drawing in case you need to hack on it
- yourself. You'll probably need to get the plot offset too.
-
- - getPlotOffset()
-
- Gets the offset that the grid has within the canvas as an object
- with distances from the canvas edges as "left", "right", "top",
- "bottom". I.e., if you draw a circle on the canvas with the center
- placed at (left, top), its center will be at the top-most, left
- corner of the grid.
-
- - getOptions()
-
- Gets the options for the plot, normalized, with default values
- filled in. You get a reference to actual values used by Flot, so
- if you modify the values in here, Flot will use the new values.
- If you change something, you probably have to call draw() or
- setupGrid() or triggerRedrawOverlay() to see the change.
-
-
-## Hooks ##
-
-In addition to the public methods, the Plot object also has some hooks
-that can be used to modify the plotting process. You can install a
-callback function at various points in the process, the function then
-gets access to the internal data structures in Flot.
-
-Here's an overview of the phases Flot goes through:
-
- 1. Plugin initialization, parsing options
-
- 2. Constructing the canvases used for drawing
-
- 3. Set data: parsing data specification, calculating colors,
- copying raw data points into internal format,
- normalizing them, finding max/min for axis auto-scaling
-
- 4. Grid setup: calculating axis spacing, ticks, inserting tick
- labels, the legend
-
- 5. Draw: drawing the grid, drawing each of the series in turn
-
- 6. Setting up event handling for interactive features
-
- 7. Responding to events, if any
-
- 8. Shutdown: this mostly happens in case a plot is overwritten
-
-Each hook is simply a function which is put in the appropriate array.
-You can add them through the "hooks" option, and they are also available
-after the plot is constructed as the "hooks" attribute on the returned
-plot object, e.g.
-
-```js
- // define a simple draw hook
- function hellohook(plot, canvascontext) { alert("hello!"); };
-
- // pass it in, in an array since we might want to specify several
- var plot = $.plot(placeholder, data, { hooks: { draw: [hellohook] } });
-
- // we can now find it again in plot.hooks.draw[0] unless a plugin
- // has added other hooks
-```
-
-The available hooks are described below. All hook callbacks get the
-plot object as first parameter. You can find some examples of defined
-hooks in the plugins bundled with Flot.
-
- - processOptions [phase 1]
-
- ```function(plot, options)```
-
- Called after Flot has parsed and merged options. Useful in the
- instance where customizations beyond simple merging of default
- values is needed. A plugin might use it to detect that it has been
- enabled and then turn on or off other options.
-
-
- - processRawData [phase 3]
-
- ```function(plot, series, data, datapoints)```
-
- Called before Flot copies and normalizes the raw data for the given
- series. If the function fills in datapoints.points with normalized
- points and sets datapoints.pointsize to the size of the points,
- Flot will skip the copying/normalization step for this series.
-
- In any case, you might be interested in setting datapoints.format,
- an array of objects for specifying how a point is normalized and
- how it interferes with axis scaling. It accepts the following options:
-
- ```js
- {
- x, y: boolean,
- number: boolean,
- required: boolean,
- defaultValue: value,
- autoscale: boolean
- }
- ```
-
- "x" and "y" specify whether the value is plotted against the x or y axis,
- and is currently used only to calculate axis min-max ranges. The default
- format array, for example, looks like this:
-
- ```js
- [
- { x: true, number: true, required: true },
- { y: true, number: true, required: true }
- ]
- ```
-
- This indicates that a point, i.e. [0, 25], consists of two values, with the
- first being plotted on the x axis and the second on the y axis.
-
- If "number" is true, then the value must be numeric, and is set to null if
- it cannot be converted to a number.
-
- "defaultValue" provides a fallback in case the original value is null. This
- is for instance handy for bars, where one can omit the third coordinate
- (the bottom of the bar), which then defaults to zero.
-
- If "required" is true, then the value must exist (be non-null) for the
- point as a whole to be valid. If no value is provided, then the entire
- point is cleared out with nulls, turning it into a gap in the series.
-
- "autoscale" determines whether the value is considered when calculating an
- automatic min-max range for the axes that the value is plotted against.
-
- - processDatapoints [phase 3]
-
- ```function(plot, series, datapoints)```
-
- Called after normalization of the given series but before finding
- min/max of the data points. This hook is useful for implementing data
- transformations. "datapoints" contains the normalized data points in
- a flat array as datapoints.points with the size of a single point
- given in datapoints.pointsize. Here's a simple transform that
- multiplies all y coordinates by 2:
-
- ```js
- function multiply(plot, series, datapoints) {
- var points = datapoints.points, ps = datapoints.pointsize;
- for (var i = 0; i < points.length; i += ps)
- points[i + 1] *= 2;
- }
- ```
-
- Note that you must leave datapoints in a good condition as Flot
- doesn't check it or do any normalization on it afterwards.
-
- - processOffset [phase 4]
-
- ```function(plot, offset)```
-
- Called after Flot has initialized the plot's offset, but before it
- draws any axes or plot elements. This hook is useful for customizing
- the margins between the grid and the edge of the canvas. "offset" is
- an object with attributes "top", "bottom", "left" and "right",
- corresponding to the margins on the four sides of the plot.
-
- - drawBackground [phase 5]
-
- ```function(plot, canvascontext)```
-
- Called before all other drawing operations. Used to draw backgrounds
- or other custom elements before the plot or axes have been drawn.
-
- - drawSeries [phase 5]
-
- ```function(plot, canvascontext, series)```
-
- Hook for custom drawing of a single series. Called just before the
- standard drawing routine has been called in the loop that draws
- each series.
-
- - draw [phase 5]
-
- ```function(plot, canvascontext)```
-
- Hook for drawing on the canvas. Called after the grid is drawn
- (unless it's disabled or grid.aboveData is set) and the series have
- been plotted (in case any points, lines or bars have been turned
- on). For examples of how to draw things, look at the source code.
-
- - bindEvents [phase 6]
-
- ```function(plot, eventHolder)```
-
- Called after Flot has setup its event handlers. Should set any
- necessary event handlers on eventHolder, a jQuery object with the
- canvas, e.g.
-
- ```js
- function (plot, eventHolder) {
- eventHolder.mousedown(function (e) {
- alert("You pressed the mouse at " + e.pageX + " " + e.pageY);
- });
- }
- ```
-
- Interesting events include click, mousemove, mouseup/down. You can
- use all jQuery events. Usually, the event handlers will update the
- state by drawing something (add a drawOverlay hook and call
- triggerRedrawOverlay) or firing an externally visible event for
- user code. See the crosshair plugin for an example.
-
- Currently, eventHolder actually contains both the static canvas
- used for the plot itself and the overlay canvas used for
- interactive features because some versions of IE get the stacking
- order wrong. The hook only gets one event, though (either for the
- overlay or for the static canvas).
-
- Note that custom plot events generated by Flot are not generated on
- eventHolder, but on the div placeholder supplied as the first
- argument to the plot call. You can get that with
- plot.getPlaceholder() - that's probably also the one you should use
- if you need to fire a custom event.
-
- - drawOverlay [phase 7]
-
- ```function (plot, canvascontext)```
-
- The drawOverlay hook is used for interactive things that need a
- canvas to draw on. The model currently used by Flot works the way
- that an extra overlay canvas is positioned on top of the static
- canvas. This overlay is cleared and then completely redrawn
- whenever something interesting happens. This hook is called when
- the overlay canvas is to be redrawn.
-
- "canvascontext" is the 2D context of the overlay canvas. You can
- use this to draw things. You'll most likely need some of the
- metrics computed by Flot, e.g. plot.width()/plot.height(). See the
- crosshair plugin for an example.
-
- - shutdown [phase 8]
-
- ```function (plot, eventHolder)```
-
- Run when plot.shutdown() is called, which usually only happens in
- case a plot is overwritten by a new plot. If you're writing a
- plugin that adds extra DOM elements or event handlers, you should
- add a callback to clean up after you. Take a look at the section in
- the [PLUGINS](PLUGINS.md) document for more info.
-
-
-## Plugins ##
-
-Plugins extend the functionality of Flot. To use a plugin, simply
-include its Javascript file after Flot in the HTML page.
-
-If you're worried about download size/latency, you can concatenate all
-the plugins you use, and Flot itself for that matter, into one big file
-(make sure you get the order right), then optionally run it through a
-Javascript minifier such as YUI Compressor.
-
-Here's a brief explanation of how the plugin plumbings work:
-
-Each plugin registers itself in the global array $.plot.plugins. When
-you make a new plot object with $.plot, Flot goes through this array
-calling the "init" function of each plugin and merging default options
-from the "option" attribute of the plugin. The init function gets a
-reference to the plot object created and uses this to register hooks
-and add new public methods if needed.
-
-See the [PLUGINS](PLUGINS.md) document for details on how to write a plugin. As the
-above description hints, it's actually pretty easy.
-
-
-## Version number ##
-
-The version number of Flot is available in ```$.plot.version```.
diff --git a/htdocs/includes/jquery/plugins/flot/CONTRIBUTING.md b/htdocs/includes/jquery/plugins/flot/CONTRIBUTING.md
deleted file mode 100644
index 3e6e43a0fd4..00000000000
--- a/htdocs/includes/jquery/plugins/flot/CONTRIBUTING.md
+++ /dev/null
@@ -1,98 +0,0 @@
-## Contributing to Flot ##
-
-We welcome all contributions, but following these guidelines results in less
-work for us, and a faster and better response.
-
-### Issues ###
-
-Issues are not a way to ask general questions about Flot. If you see unexpected
-behavior but are not 100% certain that it is a bug, please try posting to the
-[forum](http://groups.google.com/group/flot-graphs) first, and confirm that
-what you see is really a Flot problem before creating a new issue for it. When
-reporting a bug, please include a working demonstration of the problem, if
-possible, or at least a clear description of the options you're using and the
-environment (browser and version, jQuery version, other libraries) that you're
-running under.
-
-If you have suggestions for new features, or changes to existing ones, we'd
-love to hear them! Please submit each suggestion as a separate new issue.
-
-If you would like to work on an existing issue, please make sure it is not
-already assigned to someone else. If an issue is assigned to someone, that
-person has already started working on it. So, pick unassigned issues to prevent
-duplicated effort.
-
-### Pull Requests ###
-
-To make merging as easy as possible, please keep these rules in mind:
-
- 1. Submit new features or architectural changes to the *<version>-work*
- branch for the next major release. Submit bug fixes to the master branch.
-
- 2. Divide larger changes into a series of small, logical commits with
- descriptive messages.
-
- 3. Rebase, if necessary, before submitting your pull request, to reduce the
- work we need to do to merge it.
-
- 4. Format your code according to the style guidelines below.
-
-### Flot Style Guidelines ###
-
-Flot follows the [jQuery Core Style Guidelines](http://docs.jquery.com/JQuery_Core_Style_Guidelines),
-with the following updates and exceptions:
-
-#### Spacing ####
-
-Use four-space indents, no tabs. Do not add horizontal space around parameter
-lists, loop definitions, or array/object indices. For example:
-
-```js
- for ( var i = 0; i < data.length; i++ ) { // This block is wrong!
- if ( data[ i ] > 1 ) {
- data[ i ] = 2;
- }
- }
-
- for (var i = 0; i < data.length; i++) { // This block is correct!
- if (data[i] > 1) {
- data[i] = 2;
- }
- }
-```
-
-#### Comments ####
-
-Use [jsDoc](http://usejsdoc.org) comments for all file and function headers.
-Use // for all inline and block comments, regardless of length.
-
-All // comment blocks should have an empty line above *and* below them. For
-example:
-
-```js
- var a = 5;
-
- // We're going to loop here
- // TODO: Make this loop faster, better, stronger!
-
- for (var x = 0; x < 10; x++) {}
-```
-
-#### Wrapping ####
-
-Block comments should be wrapped at 80 characters.
-
-Code should attempt to wrap at 80 characters, but may run longer if wrapping
-would hurt readability more than having to scroll horizontally. This is a
-judgement call made on a situational basis.
-
-Statements containing complex logic should not be wrapped arbitrarily if they
-do not exceed 80 characters. For example:
-
-```js
- if (a == 1 && // This block is wrong!
- b == 2 &&
- c == 3) {}
-
- if (a == 1 && b == 2 && c == 3) {} // This block is correct!
-```
diff --git a/htdocs/includes/jquery/plugins/flot/FAQ.md b/htdocs/includes/jquery/plugins/flot/FAQ.md
deleted file mode 100644
index 9131e043985..00000000000
--- a/htdocs/includes/jquery/plugins/flot/FAQ.md
+++ /dev/null
@@ -1,75 +0,0 @@
-## Frequently asked questions ##
-
-#### How much data can Flot cope with? ####
-
-Flot will happily draw everything you send to it so the answer
-depends on the browser. The excanvas emulation used for IE (built with
-VML) makes IE by far the slowest browser so be sure to test with that
-if IE users are in your target group (for large plots in IE, you can
-also check out Flashcanvas which may be faster).
-
-1000 points is not a problem, but as soon as you start having more
-points than the pixel width, you should probably start thinking about
-downsampling/aggregation as this is near the resolution limit of the
-chart anyway. If you downsample server-side, you also save bandwidth.
-
-
-#### Flot isn't working when I'm using JSON data as source! ####
-
-Actually, Flot loves JSON data, you just got the format wrong.
-Double check that you're not inputting strings instead of numbers,
-like [["0", "-2.13"], ["5", "4.3"]]. This is most common mistake, and
-the error might not show up immediately because Javascript can do some
-conversion automatically.
-
-
-#### Can I export the graph? ####
-
-You can grab the image rendered by the canvas element used by Flot
-as a PNG or JPEG (remember to set a background). Note that it won't
-include anything not drawn in the canvas (such as the legend). And it
-doesn't work with excanvas which uses VML, but you could try
-Flashcanvas.
-
-
-#### The bars are all tiny in time mode? ####
-
-It's not really possible to determine the bar width automatically.
-So you have to set the width with the barWidth option which is NOT in
-pixels, but in the units of the x axis (or the y axis for horizontal
-bars). For time mode that's milliseconds so the default value of 1
-makes the bars 1 millisecond wide.
-
-
-#### Can I use Flot with libraries like Mootools or Prototype? ####
-
-Yes, Flot supports it out of the box and it's easy! Just use jQuery
-instead of $, e.g. call jQuery.plot instead of $.plot and use
-jQuery(something) instead of $(something). As a convenience, you can
-put in a DOM element for the graph placeholder where the examples and
-the API documentation are using jQuery objects.
-
-Depending on how you include jQuery, you may have to add one line of
-code to prevent jQuery from overwriting functions from the other
-libraries, see the documentation in jQuery ("Using jQuery with other
-libraries") for details.
-
-
-#### Flot doesn't work with [insert name of Javascript UI framework]! ####
-
-Flot is using standard HTML to make charts. If this is not working,
-it's probably because the framework you're using is doing something
-weird with the DOM or with the CSS that is interfering with Flot.
-
-A common problem is that there's display:none on a container until the
-user does something. Many tab widgets work this way, and there's
-nothing wrong with it - you just can't call Flot inside a display:none
-container as explained in the README so you need to hold off the Flot
-call until the container is actually displayed (or use
-visibility:hidden instead of display:none or move the container
-off-screen).
-
-If you find there's a specific thing we can do to Flot to help, feel
-free to submit a bug report. Otherwise, you're welcome to ask for help
-on the forum/mailing list, but please don't submit a bug report to
-Flot.
diff --git a/htdocs/includes/jquery/plugins/flot/LICENSE.txt b/htdocs/includes/jquery/plugins/flot/LICENSE.txt
deleted file mode 100644
index 719da064fef..00000000000
--- a/htdocs/includes/jquery/plugins/flot/LICENSE.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-Copyright (c) 2007-2014 IOLA and Ole Laursen
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
diff --git a/htdocs/includes/jquery/plugins/flot/Makefile b/htdocs/includes/jquery/plugins/flot/Makefile
deleted file mode 100644
index 2e070d0c3c0..00000000000
--- a/htdocs/includes/jquery/plugins/flot/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-# Makefile for generating minified files
-
-.PHONY: all
-
-# we cheat and process all .js files instead of an exhaustive list
-all: $(patsubst %.js,%.min.js,$(filter-out %.min.js,$(wildcard *.js)))
-
-%.min.js: %.js
- yui-compressor $< -o $@
-
-test:
- ./node_modules/.bin/jshint *jquery.flot.js
diff --git a/htdocs/includes/jquery/plugins/flot/NEWS.md b/htdocs/includes/jquery/plugins/flot/NEWS.md
deleted file mode 100644
index ad0303d742e..00000000000
--- a/htdocs/includes/jquery/plugins/flot/NEWS.md
+++ /dev/null
@@ -1,1026 +0,0 @@
-## Flot 0.8.3 ##
-
-### Changes ###
-
-- Updated example code to avoid encouraging unnecessary re-plots.
- (patch by soenter, pull request #1221)
-
-### Bug fixes ###
-
- - Added a work-around to disable the allocation of extra space for first and
- last axis ticks, allowing plots to span the full width of their container.
- A proper solution for this bug will be implemented in the 0.9 release.
- (reported by Josh Pigford and andig, issue #1212, pull request #1290)
-
- - Fixed a regression introduced in 0.8.1, where the last tick label would
- sometimes wrap rather than extending the plot's offset to create space.
- (reported by Elite Gamer, issue #1283)
-
- - Fixed a regression introduced in 0.8.2, where the resize plugin would use
- unexpectedly high amounts of CPU even when idle.
- (reported by tommie, issue #1277, pull request #1289)
-
- - Fixed the selection example to work with jQuery 1.9.x and later.
- (reported by EGLadona and dmfalke, issue #1250, pull request #1285)
-
- - Added a detach shim to fix support for jQuery versions earlier than 1.4.x.
- (reported by ngavard, issue #1240, pull request #1286)
-
- - Fixed a rare 'Uncaught TypeError' when using the resize plugin in IE 7/8.
- (reported by tleish, issue #1265, pull request #1289)
-
- - Fixed zoom constraints to apply only in the direction of the zoom.
- (patch by Neil Katin, issue #1204, pull request #1205)
-
- - Markings lines are no longer blurry when drawn on pixel boundaries.
- (reported by btccointicker and Rouillard, issue #1210)
-
- - Don't discard original pie data-series values when combining slices.
- (patch by Phil Tsarik, pull request #1238)
-
- - Fixed broken auto-scale behavior when using deprecated [x|y]2axis options.
- (reported by jorese, issue #1228, pull request #1284)
-
- - Exposed the dateGenerator function on the plot object, as it used to be
- before time-mode was moved into a separate plugin.
- (patch by Paolo Valleri, pull request #1028)
-
-
-## Flot 0.8.2 ##
-
-### Changes ###
-
- - Added a plot.destroy method as a way to free memory when emptying the plot
- placeholder and then re-using it for some other purpose.
- (patch by Thodoris Greasidis, issue #1129, pull request #1130)
-
- - Added a table of contents and PLUGINS link to the API documentation.
- (patches by Brian Peiris, pull requests #1064 and #1127)
-
- - Added Ruby code examples for time conversion.
- (patch by Mike Połtyn, pull request #1182)
-
- - Minor improvements to API.md and README.md.
- (patches by Patrik Ragnarsson, pull requests #1085 and #1086)
-
- - Updated inlined jQuery Resize to the latest version to fix errors.
- (reported by Matthew Sabol and sloker, issues #997 ad #1081)
-
-### Bug fixes ###
-
- - Fixed an unexpected change in behavior that resulted in duplicate tick
- labels when using a plugin, like flot-tickrotor, that overrode tick labels.
- (patch by Mark Cote, pull request #1091)
-
- - Fixed a regression from 0.7 where axis labels were given the wrong width,
- causing them to overlap at certain scales and ignore the labelWidth option.
- (patch by Benjamin Gram, pull request #1177)
-
- - Fixed a bug where the second axis in an xaxes/yaxes array incorrectly had
- its 'innermost' property set to false or undefined, even if it was on the
- other side of the plot from the first axis. This resulted in the axis bar
- being visible when it shouldn't have been, which was especially obvious
- when the grid had a left/right border width of zero.
- (reported by Teq1, fix researched by ryleyb, issue #1056)
-
- - Fixed an error when using a placeholder that has no font-size property.
- (patch by Craig Oldford, pull request #1135)
-
- - Fixed a regression from 0.7 where nulls at the end of a series were ignored
- for purposes of determing the range of the x-axis.
- (reported by Munsifali Rashid, issue #1095)
-
- - If a font size is provided, base the default lineHeight on that size rather
- that the font size of the plot placeholder, which may be very different.
- (reported by Daniel Hoffmann Bernardes, issue #1131, pull request #1199)
-
- - Fix broken highlighting for right-aligned bars.
- (reported by BeWiBu and Mihai Stanciu, issues #975 and #1093, with further
- assistance by Eric Byers, pull request #1120)
-
- - Prevent white circles from sometimes showing up inside of pie charts.
- (reported by Pierre Dubois and Jack Klink, issues #1128 and #1073)
-
- - Label formatting no longer breaks when a page contains multiple pie charts.
- (reported by Brend Wanders, issue #1055)
-
- - When using multiple axes on opposite sides of the plot, the innermost axis
- coming later in the list no longer has its bar drawn incorrectly.
- (reported by ryleyb, issue #1056)
-
- - When removing series labels and redrawing the plot, the legend now updates
- correctly even when using an external container.
- (patch by Luis Silva, issue #1159, pull request #1160)
-
- - The pie plugin no longer ignores the value of the left offset option.
- (reported by melanker, issue #1136)
-
- - Fixed a regression from 0.7, where extra padding was added unnecessarily to
- sides of the plot where there was no last tick label.
- (reported by sknob001, issue #1048, pull request #1200)
-
- - Fixed incorrect tooltip behavior in the interacting example.
- (patch by cleroux, issue #686, pull request #1074)
-
- - Fixed an error in CSS color extraction with elements outside the DOM.
- (patch by execjosh, pull request #1084)
-
- - Fixed :not selector error when using jQuery without Sizzle.
- (patch by Anthony Ryan, pull request #1180)
-
- - Worked around a browser issue that caused bars to appear un-filled.
- (reported by irbian, issue #915)
-
-## Flot 0.8.1 ##
-
-### Bug fixes ###
-
- - Fixed a regression in the time plugin, introduced in 0.8, that caused dates
- to align to the minute rather than to the highest appropriate unit. This
- caused many x-axes in 0.8 to have different ticks than they did in 0.7.
- (reported by Tom Sheppard, patch by Daniel Shapiro, issue #1017, pull
- request #1023)
-
- - Fixed a regression in text rendering, introduced in 0.8, that caused axis
- labels with the same text as another label on the same axis to disappear.
- More generally, it's again possible to have the same text in two locations.
- (issue #1032)
-
- - Fixed a regression in text rendering, introduced in 0.8, where axis labels
- were no longer assigned an explicit width, and their text could not wrap.
- (reported by sabregreen, issue #1019)
-
- - Fixed a regression in the pie plugin, introduced in 0.8, that prevented it
- from accepting data in the format '[[x, y]]'.
- (patch by Nicolas Morel, pull request #1024)
-
- - The 'zero' series option and 'autoscale' format option are no longer
- ignored when the series contains a null value.
- (reported by Daniel Shapiro, issue #1033)
-
- - Avoid triggering the time-mode plugin exception when there are zero series.
- (reported by Daniel Rothig, patch by Mark Raymond, issue #1016)
-
- - When a custom color palette has fewer colors than the default palette, Flot
- no longer fills out the colors with the remainder of the default.
- (patch by goorpy, issue #1031, pull request #1034)
-
- - Fixed missing update for bar highlights after a zoom or other redraw.
- (reported by Paolo Valleri, issue #1030)
-
- - Fixed compatibility with jQuery versions earlier than 1.7.
- (patch by Lee Willis, issue #1027, pull request #1027)
-
- - The mouse wheel no longer scrolls the page when using the navigate plugin.
- (patch by vird, pull request #1020)
-
- - Fixed missing semicolons in the core library.
- (reported by Michal Zglinski)
-
-
-## Flot 0.8.0 ##
-
-### API changes ###
-
-Support for time series has been moved into a plugin, jquery.flot.time.js.
-This results in less code if time series are not used. The functionality
-remains the same (plus timezone support, as described below); however, the
-plugin must be included if axis.mode is set to "time".
-
-When the axis mode is "time", the axis option "timezone" can be set to null,
-"browser", or a particular timezone (e.g. "America/New_York") to control how
-the dates are displayed. If null, the dates are displayed as UTC. If
-"browser", the dates are displayed in the time zone of the user's browser.
-
-Date/time formatting has changed and now follows a proper subset of the
-standard strftime specifiers, plus one nonstandard specifier for quarters.
-Additionally, if a strftime function is found in the Date object's prototype,
-it will be used instead of the built-in formatter.
-
-Axis tick labels now use the class 'flot-tick-label' instead of 'tickLabel'.
-The text containers for each axis now use the classes 'flot-[x|y]-axis' and
-'flot-[x|y]#-axis' instead of '[x|y]Axis' and '[x|y]#Axis'. For compatibility
-with Flot 0.7 and earlier text will continue to use the old classes as well,
-but they are considered deprecated and will be removed in a future version.
-
-In previous versions the axis 'color' option was used to set the color of tick
-marks and their label text. It now controls the color of the axis line, which
-previously could not be changed separately, and continues to act as a default
-for the tick-mark color. The color of tick label text is now set either by
-overriding the 'flot-tick-label' CSS rule or via the axis 'font' option.
-
-A new plugin, jquery.flot.canvas.js, allows axis tick labels to be rendered
-directly to the canvas, rather than using HTML elements. This feature can be
-toggled with a simple option, making it easy to create interactive plots in the
-browser using HTML, then re-render them to canvas for export as an image.
-
-The plugin tries to remain as faithful as possible to the original HTML render,
-and goes so far as to automatically extract styles from CSS, to avoid having to
-provide a separate set of styles when rendering to canvas. Due to limitations
-of the canvas text API, the plugin cannot reproduce certain features, including
-HTML markup embedded in labels, and advanced text styles such as 'em' units.
-
-The plugin requires support for canvas text, which may not be present in some
-older browsers, even if they support the canvas tag itself. To use the plugin
-with these browsers try using a shim such as canvas-text or FlashCanvas.
-
-The base and overlay canvas are now using the CSS classes "flot-base" and
-"flot-overlay" to prevent accidental clashes (issue 540).
-
-### Changes ###
-
- - Addition of nonstandard %q specifier to date/time formatting. (patch
- by risicle, issue 49)
-
- - Date/time formatting follows proper subset of strftime specifiers, and
- support added for Date.prototype.strftime, if found. (patch by Mark Cote,
- issues 419 and 558)
-
- - Fixed display of year ticks. (patch by Mark Cote, issue 195)
-
- - Support for time series moved to plugin. (patch by Mark Cote)
-
- - Display time series in different time zones. (patch by Knut Forkalsrud,
- issue 141)
-
- - Added a canvas plugin to enable rendering axis tick labels to the canvas.
- (sponsored by YCharts.com, implementation by Ole Laursen and David Schnur)
-
- - Support for setting the interval between redraws of the overlay canvas with
- redrawOverlayInterval. (suggested in issue 185)
-
- - Support for multiple thresholds in thresholds plugin. (patch by Arnaud
- Bellec, issue 523)
-
- - Support for plotting categories/textual data directly with new categories
- plugin.
-
- - Tick generators now get the whole axis rather than just min/max.
-
- - Added processOffset and drawBackground hooks. (suggested in issue 639)
-
- - Added a grid "margin" option to set the space between the canvas edge and
- the grid.
-
- - Prevent the pie example page from generating single-slice pies. (patch by
- Shane Reustle)
-
- - In addition to "left" and "center", bars now recognize "right" as an
- alignment option. (patch by Michael Mayer, issue 520)
-
- - Switched from toFixed to a much faster default tickFormatter. (patch by
- Clemens Stolle)
-
- - Added to a more helpful error when using a time-mode axis without including
- the flot.time plugin. (patch by Yael Elmatad)
-
- - Added a legend "sorted" option to control sorting of legend entries
- independent of their series order. (patch by Tom Cleaveland)
-
- - Added a series "highlightColor" option to control the color of the
- translucent overlay that identifies the dataset when the mouse hovers over
- it. (patch by Eric Wendelin and Nate Abele, issues 168 and 299)
-
- - Added a plugin jquery.flot.errorbars, with an accompanying example, that
- adds the ability to plot error bars, commonly used in many kinds of
- statistical data visualizations. (patch by Rui Pereira, issue 215)
-
- - The legend now omits entries whose labelFormatter returns null. (patch by
- Tom Cleaveland, Christopher Lambert, and Simon Strandgaard)
-
- - Added support for high pixel density (retina) displays, resulting in much
- crisper charts on such devices. (patch by Olivier Guerriat, additional
- fixes by Julien Thomas, maimairel, and Lau Bech Lauritzen)
-
- - Added the ability to control pie shadow position and alpha via a new pie
- 'shadow' option. (patch by Julien Thomas, pull request #78)
-
- - Added the ability to set width and color for individual sides of the grid.
- (patch by Ara Anjargolian, additional fixes by Karl Swedberg, pull requests #855
- and #880)
-
- - The selection plugin's getSelection now returns null when the selection
- has been cleared. (patch by Nick Campbell, pull request #852)
-
- - Added a new option called 'zero' to bars and filled lines series, to control
- whether the y-axis minimum is scaled to fit the data or set to zero.
- (patch by David Schnur, issues #316, #529, and #856, pull request #911)
-
- - The plot function is now also a jQuery chainable property.
- (patch by David Schnur, issues #734 and #816, pull request #953)
-
- - When only a single pie slice is beneath the combine threshold it is no longer
- replaced by an 'other' slice. (suggested by Devin Bayer, issue #638)
-
- - Added lineJoin and minSize options to the selection plugin to control the
- corner style and minimum size of the selection, respectively.
- (patch by Ruth Linehan, pull request #963)
-
-### Bug fixes ###
-
- - Fix problem with null values and pie plugin. (patch by gcruxifix,
- issue 500)
-
- - Fix problem with threshold plugin and bars. (based on patch by
- kaarlenkaski, issue 348)
-
- - Fix axis box calculations so the boxes include the outermost part of the
- labels too.
-
- - Fix problem with event clicking and hovering in IE 8 by updating Excanvas
- and removing previous work-around. (test case by Ara Anjargolian)
-
- - Fix issues with blurry 1px border when some measures aren't integer.
- (reported by Ara Anjargolian)
-
- - Fix bug with formats in the data processor. (reported by Peter Hull,
- issue 534)
-
- - Prevent i from being declared global in extractRange. (reported by
- Alexander Obukhov, issue 627)
-
- - Throw errors in a more cross-browser-compatible manner. (patch by
- Eddie Kay)
-
- - Prevent pie slice outlines from being drawn when the stroke width is zero.
- (reported by Chris Minett, issue 585)
-
- - Updated the navigate plugin's inline copy of jquery.mousewheel to fix
- Webkit zoom problems. (reported by Hau Nguyen, issue 685)
-
- - Axis labels no longer appear as decimals rather than integers in certain
- cases. (patch by Clemens Stolle, issue 541)
-
- - Automatic color generation no longer produces only whites and blacks when
- there are many series. (patch by David Schnur and Tom Cleaveland)
-
- - Fixed an error when custom tick labels weren't provided as strings. (patch
- by Shad Downey)
-
- - Prevented the local insertSteps and fmt variables from becoming global.
- (first reported by Marc Bennewitz and Szymon Barglowski, patch by Nick
- Campbell, issues #825 and #831, pull request #851)
-
- - Prevented several threshold plugin variables from becoming global. (patch
- by Lasse Dahl Ebert)
-
- - Fixed various jQuery 1.8 compatibility issues. (issues #814 and #819,
- pull request #877)
-
- - Pie charts with a slice equal to or approaching 100% of the pie no longer
- appear invisible. (patch by David Schnur, issues #444, #658, #726, #824
- and #850, pull request #879)
-
- - Prevented several local variables from becoming global. (patch by aaa707)
-
- - Ensure that the overlay and primary canvases remain aligned. (issue #670,
- pull request #901)
-
- - Added support for jQuery 1.9 by removing and replacing uses of $.browser.
- (analysis and patch by Anthony Ryan, pull request #905)
-
- - Pie charts no longer disappear when redrawn during a resize or update.
- (reported by Julien Bec, issue #656, pull request #910)
-
- - Avoided floating-point precision errors when calculating pie percentages.
- (patch by James Ward, pull request #918)
-
- - Fixed compatibility with jQuery 1.2.6, which has no 'mouseleave' shortcut.
- (reported by Bevan, original pull request #920, replaced by direct patch)
-
- - Fixed sub-pixel rendering issues with crosshair and selection lines.
- (patches by alanayoub and Daniel Shapiro, pull requests #17 and #925)
-
- - Fixed rendering issues when using the threshold plugin with several series.
- (patch by Ivan Novikov, pull request #934)
-
- - Pie charts no longer disappear when redrawn after calling setData().
- (reported by zengge1984 and pareeohnos, issues #810 and #945)
-
- - Added a work-around for the problem where points with a lineWidth of zero
- still showed up with a visible line. (reported by SalvoSav, issue #842,
- patch by Jamie Hamel-Smith, pull request #937)
-
- - Pie charts now accept values in string form, like other plot types.
- (reported by laerdal.no, issue #534)
-
- - Avoid rounding errors in the threshold plugin.
- (reported by jerikojerk, issue #895)
-
- - Fixed an error when using the navigate plugin with jQuery 1.9.x or later.
- (reported by Paolo Valleri, issue #964)
-
- - Fixed inconsistencies between the highlight and unhighlight functions.
- (reported by djamshed, issue #987)
-
- - Fixed recalculation of tickSize and tickDecimals on calls to setupGrid.
- (patch by thecountofzero, pull request #861, issues #860, #1000)
-
-
-## Flot 0.7 ##
-
-### API changes ###
-
-Multiple axes support. Code using dual axes should be changed from using
-x2axis/y2axis in the options to using an array (although backwards-
-compatibility hooks are in place). For instance,
-
-```js
-{
- xaxis: { ... }, x2axis: { ... },
- yaxis: { ... }, y2axis: { ... }
-}
-```
-
-becomes
-
-```js
-{
- xaxes: [ { ... }, { ... } ],
- yaxes: [ { ... }, { ... } ]
-}
-```
-
-Note that if you're just using one axis, continue to use the xaxis/yaxis
-directly (it now sets the default settings for the arrays). Plugins touching
-the axes must be ported to take the extra axes into account, check the source
-to see some examples.
-
-A related change is that the visibility of axes is now auto-detected. So if
-you were relying on an axis to show up even without any data in the chart, you
-now need to set the axis "show" option explicitly.
-
-"tickColor" on the grid options is now deprecated in favour of a corresponding
-option on the axes, so:
-
-```js
-{ grid: { tickColor: "#000" }}
-```
-
-becomes
-
-```js
-{ xaxis: { tickColor: "#000"}, yaxis: { tickColor: "#000"} }
-```
-
-But if you just configure a base color Flot will now autogenerate a tick color
-by adding transparency. Backwards-compatibility hooks are in place.
-
-Final note: now that IE 9 is coming out with canvas support, you may want to
-adapt the excanvas include to skip loading it in IE 9 (the examples have been
-adapted thanks to Ryley Breiddal). An alternative to excanvas using Flash has
-also surfaced, if your graphs are slow in IE, you may want to give it a spin:
-
- http://code.google.com/p/flashcanvas/
-
-### Changes ###
-
- - Support for specifying a bottom for each point for line charts when filling
- them, this means that an arbitrary bottom can be used instead of just the x
- axis. (based on patches patiently provided by Roman V. Prikhodchenko)
-
- - New fillbetween plugin that can compute a bottom for a series from another
- series, useful for filling areas between lines.
-
- See new example percentiles.html for a use case.
-
- - More predictable handling of gaps for the stacking plugin, now all
- undefined ranges are skipped.
-
- - Stacking plugin can stack horizontal bar charts.
-
- - Navigate plugin now redraws the plot while panning instead of only after
- the fact. (raised by lastthemy, issue 235)
-
- Can be disabled by setting the pan.frameRate option to null.
-
- - Date formatter now accepts %0m and %0d to get a zero-padded month or day.
- (issue raised by Maximillian Dornseif)
-
- - Revamped internals to support an unlimited number of axes, not just dual.
- (sponsored by Flight Data Services, www.flightdataservices.com)
-
- - New setting on axes, "tickLength", to control the size of ticks or turn
- them off without turning off the labels.
-
- - Axis labels are now put in container divs with classes, for instance labels
- in the x axes can be reached via ".xAxis .tickLabel".
-
- - Support for setting the color of an axis. (sponsored by Flight Data
- Services, www.flightdataservices.com)
-
- - Tick color is now auto-generated as the base color with some transparency,
- unless you override it.
-
- - Support for aligning ticks in the axes with "alignTicksWithAxis" to ensure
- that they appear next to each other rather than in between, at the expense
- of possibly awkward tick steps. (sponsored by Flight Data Services,
- www.flightdataservices.com)
-
- - Support for customizing the point type through a callback when plotting
- points and new symbol plugin with some predefined point types. (sponsored
- by Utility Data Corporation)
-
- - Resize plugin for automatically redrawing when the placeholder changes
- size, e.g. on window resizes. (sponsored by Novus Partners)
-
- A resize() method has been added to plot object facilitate this.
-
- - Support Infinity/-Infinity for plotting asymptotes by hacking it into
- +/-Number.MAX_VALUE. (reported by rabaea.mircea)
-
- - Support for restricting navigate plugin to not pan/zoom an axis. (based on
- patch by kkaefer)
-
- - Support for providing the drag cursor for the navigate plugin as an option.
- (based on patch by Kelly T. Moore)
-
- - Options for controlling whether an axis is shown or not (suggestion by Timo
- Tuominen) and whether to reserve space for it even if it isn't shown.
-
- - New attribute $.plot.version with the Flot version as a string.
-
- - The version comment is now included in the minified jquery.flot.min.js.
-
- - New options.grid.minBorderMargin for adjusting the minimum margin provided
- around the border (based on patch by corani, issue 188).
-
- - Refactor replot behaviour so Flot tries to reuse the existing canvas,
- adding shutdown() methods to the plot. (based on patch by Ryley Breiddal,
- issue 269)
-
- This prevents a memory leak in Chrome and hopefully makes replotting faster
- for those who are using $.plot instead of .setData()/.draw(). Also update
- jQuery to 1.5.1 to prevent IE leaks fixed in jQuery.
-
- - New real-time line chart example.
-
- - New hooks: drawSeries, shutdown.
-
-### Bug fixes ###
-
- - Fixed problem with findNearbyItem and bars on top of each other. (reported
- by ragingchikn, issue 242)
-
- - Fixed problem with ticks and the border. (based on patch from
- ultimatehustler69, issue 236)
-
- - Fixed problem with plugins adding options to the series objects.
-
- - Fixed a problem introduced in 0.6 with specifying a gradient with:
-
- ```{brightness: x, opacity: y }```
-
- - Don't use $.browser.msie, check for getContext on the created canvas element
- instead and try to use excanvas if it's not found.
-
- Fixes IE 9 compatibility.
-
- - highlight(s, index) was looking up the point in the original s.data instead
- of in the computed datapoints array, which breaks with plugins that modify
- the datapoints, such as the stacking plugin. (reported by curlypaul924,
- issue 316)
-
- - More robust handling of axis from data passed in from getData(). (reported)
- by Morgan)
-
- - Fixed problem with turning off bar outline. (fix by Jordi Castells,
- issue 253)
-
- - Check the selection passed into setSelection in the selection
- plugin, to guard against errors when synchronizing plots (fix by Lau
- Bech Lauritzen).
-
- - Fix bug in crosshair code with mouseout resetting the crosshair even
- if it is locked (fix by Lau Bech Lauritzen and Banko Adam).
-
- - Fix bug with points plotting using line width from lines rather than
- points.
-
- - Fix bug with passing non-array 0 data (for plugins that don't expect
- arrays, patch by vpapp1).
-
- - Fix errors in JSON in examples so they work with jQuery 1.4.2
- (fix reported by honestbleeps, issue 357).
-
- - Fix bug with tooltip in interacting.html, this makes the tooltip
- much smoother (fix by bdkahn). Fix related bug inside highlighting
- handler in Flot.
-
- - Use closure trick to make inline colorhelpers plugin respect
- jQuery.noConflict(true), renaming the global jQuery object (reported
- by Nick Stielau).
-
- - Listen for mouseleave events and fire a plothover event with empty
- item when it occurs to drop highlights when the mouse leaves the
- plot (reported by by outspirit).
-
- - Fix bug with using aboveData with a background (reported by
- amitayd).
-
- - Fix possible excanvas leak (report and suggested fix by tom9729).
-
- - Fix bug with backwards compatibility for shadowSize = 0 (report and
- suggested fix by aspinak).
-
- - Adapt examples to skip loading excanvas (fix by Ryley Breiddal).
-
- - Fix bug that prevent a simple f(x) = -x transform from working
- correctly (fix by Mike, issue 263).
-
- - Fix bug in restoring cursor in navigate plugin (reported by Matteo
- Gattanini, issue 395).
-
- - Fix bug in picking items when transform/inverseTransform is in use
- (reported by Ofri Raviv, and patches and analysis by Jan and Tom
- Paton, issue 334 and 467).
-
- - Fix problem with unaligned ticks and hover/click events caused by
- padding on the placeholder by hardcoding the placeholder padding to
- 0 (reported by adityadineshsaxena, Matt Sommer, Daniel Atos and some
- other people, issue 301).
-
- - Update colorhelpers plugin to avoid dying when trying to parse an
- invalid string (reported by cadavor, issue 483).
-
-
-
-## Flot 0.6 ##
-
-### API changes ###
-
-Selection support has been moved to a plugin. Thus if you're passing
-selection: { mode: something }, you MUST include the file
-jquery.flot.selection.js after jquery.flot.js. This reduces the size of
-base Flot and makes it easier to customize the selection as well as
-improving code clarity. The change is based on a patch from andershol.
-
-In the global options specified in the $.plot command, "lines", "points",
-"bars" and "shadowSize" have been moved to a sub-object called "series":
-
-```js
-$.plot(placeholder, data, { lines: { show: true }})
-```
-
-should be changed to
-
-```js
- $.plot(placeholder, data, { series: { lines: { show: true }}})
-```
-
-All future series-specific options will go into this sub-object to
-simplify plugin writing. Backward-compatibility code is in place, so
-old code should not break.
-
-"plothover" no longer provides the original data point, but instead a
-normalized one, since there may be no corresponding original point.
-
-Due to a bug in previous versions of jQuery, you now need at least
-jQuery 1.2.6. But if you can, try jQuery 1.3.2 as it got some improvements
-in event handling speed.
-
-## Changes ##
-
- - Added support for disabling interactivity for specific data series.
- (request from Ronald Schouten and Steve Upton)
-
- - Flot now calls $() on the placeholder and optional legend container passed
- in so you can specify DOM elements or CSS expressions to make it easier to
- use Flot with libraries like Prototype or Mootools or through raw JSON from
- Ajax responses.
-
- - A new "plotselecting" event is now emitted while the user is making a
- selection.
-
- - The "plothover" event is now emitted immediately instead of at most 10
- times per second, you'll have to put in a setTimeout yourself if you're
- doing something really expensive on this event.
-
- - The built-in date formatter can now be accessed as $.plot.formatDate(...)
- (suggestion by Matt Manela) and even replaced.
-
- - Added "borderColor" option to the grid. (patches from Amaury Chamayou and
- Mike R. Williamson)
-
- - Added support for gradient backgrounds for the grid. (based on patch from
- Amaury Chamayou, issue 90)
-
- The "setting options" example provides a demonstration.
-
- - Gradient bars. (suggestion by stefpet)
-
- - Added a "plotunselected" event which is triggered when the selection is
- removed, see "selection" example. (suggestion by Meda Ugo)
-
- - The option legend.margin can now specify horizontal and vertical margins
- independently. (suggestion by someone who's annoyed)
-
- - Data passed into Flot is now copied to a new canonical format to enable
- further processing before it hits the drawing routines. As a side-effect,
- this should make Flot more robust in the face of bad data. (issue 112)
-
- - Step-wise charting: line charts have a new option "steps" that when set to
- true connects the points with horizontal/vertical steps instead of diagonal
- lines.
-
- - The legend labelFormatter now passes the series in addition to just the
- label. (suggestion by Vincent Lemeltier)
-
- - Horizontal bars (based on patch by Jason LeBrun).
-
- - Support for partial bars by specifying a third coordinate, i.e. they don't
- have to start from the axis. This can be used to make stacked bars.
-
- - New option to disable the (grid.show).
-
- - Added pointOffset method for converting a point in data space to an offset
- within the placeholder.
-
- - Plugin system: register an init method in the $.flot.plugins array to get
- started, see PLUGINS.txt for details on how to write plugins (it's easy).
- There are also some extra methods to enable access to internal state.
-
- - Hooks: you can register functions that are called while Flot is crunching
- the data and doing the plot. This can be used to modify Flot without
- changing the source, useful for writing plugins. Some hooks are defined,
- more are likely to come.
-
- - Threshold plugin: you can set a threshold and a color, and the data points
- below that threshold will then get the color. Useful for marking data
- below 0, for instance.
-
- - Stack plugin: you can specify a stack key for each series to have them
- summed. This is useful for drawing additive/cumulative graphs with bars and
- (currently unfilled) lines.
-
- - Crosshairs plugin: trace the mouse position on the axes, enable with
- crosshair: { mode: "x"} (see the new tracking example for a use).
-
- - Image plugin: plot prerendered images.
-
- - Navigation plugin for panning and zooming a plot.
-
- - More configurable grid.
-
- - Axis transformation support, useful for non-linear plots, e.g. log axes and
- compressed time axes (like omitting weekends).
-
- - Support for twelve-hour date formatting (patch by Forrest Aldridge).
-
- - The color parsing code in Flot has been cleaned up and split out so it's
- now available as a separate jQuery plugin. It's included inline in the Flot
- source to make dependency managing easier. This also makes it really easy
- to use the color helpers in Flot plugins.
-
-## Bug fixes ##
-
- - Fixed two corner-case bugs when drawing filled curves. (report and analysis
- by Joshua Varner)
-
- - Fix auto-adjustment code when setting min to 0 for an axis where the
- dataset is completely flat on that axis. (report by chovy)
-
- - Fixed a bug with passing in data from getData to setData when the secondary
- axes are used. (reported by nperelman, issue 65)
-
- - Fixed so that it is possible to turn lines off when no other chart type is
- shown (based on problem reported by Glenn Vanderburg), and fixed so that
- setting lineWidth to 0 also hides the shadow. (based on problem reported by
- Sergio Nunes)
-
- - Updated mousemove position expression to the latest from jQuery. (reported
- by meyuchas)
-
- - Use CSS borders instead of background in legend. (issues 25 and 45)
-
- - Explicitly convert axis min/max to numbers.
-
- - Fixed a bug with drawing marking lines with different colors. (reported by
- Khurram)
-
- - Fixed a bug with returning y2 values in the selection event. (fix by
- exists, issue 75)
-
- - Only set position relative on placeholder if it hasn't already a position
- different from static. (reported by kyberneticist, issue 95)
-
- - Don't round markings to prevent sub-pixel problems. (reported by
- Dan Lipsitt)
-
- - Make the grid border act similarly to a regular CSS border, i.e. prevent
- it from overlapping the plot itself. This also fixes a problem with anti-
- aliasing when the width is 1 pixel. (reported by Anthony Ettinger)
-
- - Imported version 3 of excanvas and fixed two issues with the newer version.
- Hopefully, this will make Flot work with IE8. (nudge by Fabien Menager,
- further analysis by Booink, issue 133)
-
- - Changed the shadow code for lines to hopefully look a bit better with
- vertical lines.
-
- - Round tick positions to avoid possible problems with fractions. (suggestion
- by Fred, issue 130)
-
- - Made the heuristic for determining how many ticks to aim for a bit smarter.
-
- - Fix for uneven axis margins (report and patch by Paul Kienzle) and snapping
- to ticks. (report and patch by lifthrasiir)
-
- - Fixed bug with slicing in findNearbyItems. (patch by zollman)
-
- - Make heuristic for x axis label widths more dynamic. (patch by
- rickinhethuis)
-
- - Make sure points on top take precedence when finding nearby points when
- hovering. (reported by didroe, issue 224)
-
-
-
-## Flot 0.5 ##
-
-Timestamps are now in UTC. Also "selected" event -> becomes "plotselected"
-with new data, the parameters for setSelection are now different (but
-backwards compatibility hooks are in place), coloredAreas becomes markings
-with a new interface (but backwards compatibility hooks are in place).
-
-### API changes ###
-
-Timestamps in time mode are now displayed according to UTC instead of the time
-zone of the visitor. This affects the way the timestamps should be input;
-you'll probably have to offset the timestamps according to your local time
-zone. It also affects any custom date handling code (which basically now
-should use the equivalent UTC date mehods, e.g. .setUTCMonth() instead of
-.setMonth().
-
-Markings, previously coloredAreas, are now specified as ranges on the axes,
-like ```{ xaxis: { from: 0, to: 10 }}```. Furthermore with markings you can
-now draw horizontal/vertical lines by setting from and to to the same
-coordinate. (idea from line support patch by by Ryan Funduk)
-
-Interactivity: added a new "plothover" event and this and the "plotclick"
-event now returns the closest data item (based on patch by /david, patch by
-Mark Byers for bar support). See the revamped "interacting with the data"
-example for some hints on what you can do.
-
-Highlighting: you can now highlight points and datapoints are autohighlighted
-when you hover over them (if hovering is turned on).
-
-Support for dual axis has been added (based on patch by someone who's annoyed
-and /david). For each data series you can specify which axes it belongs to,
-and there are two more axes, x2axis and y2axis, to customize. This affects the
-"selected" event which has been renamed to "plotselected" and spews out
-```{ xaxis: { from: -10, to: 20 } ... },``` setSelection in which the
-parameters are on a new form (backwards compatible hooks are in place so old
-code shouldn't break) and markings (formerly coloredAreas).
-
-## Changes ##
-
- - Added support for specifying the size of tick labels (axis.labelWidth,
- axis.labelHeight). Useful for specifying a max label size to keep multiple
- plots aligned.
-
- - The "fill" option can now be a number that specifies the opacity of the
- fill.
-
- - You can now specify a coordinate as null (like [2, null]) and Flot will
- take the other coordinate into account when scaling the axes. (based on
- patch by joebno)
-
- - New option for bars "align". Set it to "center" to center the bars on the
- value they represent.
-
- - setSelection now takes a second parameter which you can use to prevent the
- method from firing the "plotselected" handler.
-
- - Improved the handling of axis auto-scaling with bars.
-
-## Bug fixes ##
-
- - Fixed a bug in calculating spacing around the plot. (reported by
- timothytoe)
-
- - Fixed a bug in finding max values for all-negative data sets.
-
- - Prevent the possibility of eternal looping in tick calculations.
-
- - Fixed a bug when borderWidth is set to 0. (reported by Rob/sanchothefat)
-
- - Fixed a bug with drawing bars extending below 0. (reported by James Hewitt,
- patch by Ryan Funduk).
-
- - Fixed a bug with line widths of bars. (reported by MikeM)
-
- - Fixed a bug with 'nw' and 'sw' legend positions.
-
- - Fixed a bug with multi-line x-axis tick labels. (reported by Luca Ciano,
- IE-fix help by Savage Zhang)
-
- - Using the "container" option in legend now overwrites the container element
- instead of just appending to it, fixing the infinite legend bug. (reported
- by several people, fix by Brad Dewey)
-
-
-
-## Flot 0.4 ##
-
-### API changes ###
-
-Deprecated axis.noTicks in favor of just specifying the number as axis.ticks.
-So ```xaxis: { noTicks: 10 }``` becomes ```xaxis: { ticks: 10 }```.
-
-Time series support. Specify axis.mode: "time", put in Javascript timestamps
-as data, and Flot will automatically spit out sensible ticks. Take a look at
-the two new examples. The format can be customized with axis.timeformat and
-axis.monthNames, or if that fails with axis.tickFormatter.
-
-Support for colored background areas via grid.coloredAreas. Specify an array
-of { x1, y1, x2, y2 } objects or a function that returns these given
-{ xmin, xmax, ymin, ymax }.
-
-More members on the plot object (report by Chris Davies and others).
-"getData" for inspecting the assigned settings on data series (e.g. color) and
-"setData", "setupGrid" and "draw" for updating the contents without a total
-replot.
-
-The default number of ticks to aim for is now dependent on the size of the
-plot in pixels. Support for customizing tick interval sizes directly with
-axis.minTickSize and axis.tickSize.
-
-Cleaned up the automatic axis scaling algorithm and fixed how it interacts
-with ticks. Also fixed a couple of tick-related corner case bugs (one reported
-by mainstreetmark, another reported by timothytoe).
-
-The option axis.tickFormatter now takes a function with two parameters, the
-second parameter is an optional object with information about the axis. It has
-min, max, tickDecimals, tickSize.
-
-## Changes ##
-
- - Added support for segmented lines. (based on patch from Michael MacDonald)
-
- - Added support for ignoring null and bad values. (suggestion from Nick
- Konidaris and joshwaihi)
-
- - Added support for changing the border width. (thanks to joebno and safoo)
-
- - Label colors can be changed via CSS by selecting the tickLabel class.
-
-## Bug fixes ##
-
- - Fixed a bug in handling single-item bar series. (reported by Emil Filipov)
-
- - Fixed erratic behaviour when interacting with the plot with IE 7. (reported
- by Lau Bech Lauritzen).
-
- - Prevent IE/Safari text selection when selecting stuff on the canvas.
-
-
-
-## Flot 0.3 ##
-
-This is mostly a quick-fix release because jquery.js wasn't included in the
-previous zip/tarball.
-
-## Changes ##
-
- - Include jquery.js in the zip/tarball.
-
- - Support clicking on the plot. Turn it on with grid: { clickable: true },
- then you get a "plotclick" event on the graph placeholder with the position
- in units of the plot.
-
-## Bug fixes ##
-
- - Fixed a bug in dealing with data where min = max. (thanks to Michael
- Messinides)
-
-
-
-## Flot 0.2 ##
-
-The API should now be fully documented.
-
-### API changes ###
-
-Moved labelMargin option to grid from x/yaxis.
-
-## Changes ##
-
- - Added support for putting a background behind the default legend. The
- default is the partly transparent background color. Added backgroundColor
- and backgroundOpacity to the legend options to control this.
-
- - The ticks options can now be a callback function that takes one parameter,
- an object with the attributes min and max. The function should return a
- ticks array.
-
- - Added labelFormatter option in legend, useful for turning the legend
- labels into links.
-
- - Reduced the size of the code. (patch by Guy Fraser)
-
-
-
-## Flot 0.1 ##
-
-First public release.
diff --git a/htdocs/includes/jquery/plugins/flot/PLUGINS.md b/htdocs/includes/jquery/plugins/flot/PLUGINS.md
deleted file mode 100644
index b5bf3002033..00000000000
--- a/htdocs/includes/jquery/plugins/flot/PLUGINS.md
+++ /dev/null
@@ -1,143 +0,0 @@
-## Writing plugins ##
-
-All you need to do to make a new plugin is creating an init function
-and a set of options (if needed), stuffing it into an object and
-putting it in the $.plot.plugins array. For example:
-
-```js
-function myCoolPluginInit(plot) {
- plot.coolstring = "Hello!";
-};
-
-$.plot.plugins.push({ init: myCoolPluginInit, options: { ... } });
-
-// if $.plot is called, it will return a plot object with the
-// attribute "coolstring"
-```
-
-Now, given that the plugin might run in many different places, it's
-a good idea to avoid leaking names. The usual trick here is wrap the
-above lines in an anonymous function which is called immediately, like
-this: (function () { inner code ... })(). To make it even more robust
-in case $ is not bound to jQuery but some other Javascript library, we
-can write it as
-
-```js
-(function ($) {
- // plugin definition
- // ...
-})(jQuery);
-```
-
-There's a complete example below, but you should also check out the
-plugins bundled with Flot.
-
-
-## Complete example ##
-
-Here is a simple debug plugin which alerts each of the series in the
-plot. It has a single option that control whether it is enabled and
-how much info to output:
-
-```js
-(function ($) {
- function init(plot) {
- var debugLevel = 1;
-
- function checkDebugEnabled(plot, options) {
- if (options.debug) {
- debugLevel = options.debug;
- plot.hooks.processDatapoints.push(alertSeries);
- }
- }
-
- function alertSeries(plot, series, datapoints) {
- var msg = "series " + series.label;
- if (debugLevel > 1) {
- msg += " with " + series.data.length + " points";
- alert(msg);
- }
- }
-
- plot.hooks.processOptions.push(checkDebugEnabled);
- }
-
- var options = { debug: 0 };
-
- $.plot.plugins.push({
- init: init,
- options: options,
- name: "simpledebug",
- version: "0.1"
- });
-})(jQuery);
-```
-
-We also define "name" and "version". It's not used by Flot, but might
-be helpful for other plugins in resolving dependencies.
-
-Put the above in a file named "jquery.flot.debug.js", include it in an
-HTML page and then it can be used with:
-
-```js
- $.plot($("#placeholder"), [...], { debug: 2 });
-```
-
-This simple plugin illustrates a couple of points:
-
- - It uses the anonymous function trick to avoid name pollution.
- - It can be enabled/disabled through an option.
- - Variables in the init function can be used to store plot-specific
- state between the hooks.
-
-The two last points are important because there may be multiple plots
-on the same page, and you'd want to make sure they are not mixed up.
-
-
-## Shutting down a plugin ##
-
-Each plot object has a shutdown hook which is run when plot.shutdown()
-is called. This usually mostly happens in case another plot is made on
-top of an existing one.
-
-The purpose of the hook is to give you a chance to unbind any event
-handlers you've registered and remove any extra DOM things you've
-inserted.
-
-The problem with event handlers is that you can have registered a
-handler which is run in some point in the future, e.g. with
-setTimeout(). Meanwhile, the plot may have been shutdown and removed,
-but because your event handler is still referencing it, it can't be
-garbage collected yet, and worse, if your handler eventually runs, it
-may overwrite stuff on a completely different plot.
-
-
-## Some hints on the options ##
-
-Plugins should always support appropriate options to enable/disable
-them because the plugin user may have several plots on the same page
-where only one should use the plugin. In most cases it's probably a
-good idea if the plugin is turned off rather than on per default, just
-like most of the powerful features in Flot.
-
-If the plugin needs options that are specific to each series, like the
-points or lines options in core Flot, you can put them in "series" in
-the options object, e.g.
-
-```js
-var options = {
- series: {
- downsample: {
- algorithm: null,
- maxpoints: 1000
- }
- }
-}
-```
-
-Then they will be copied by Flot into each series, providing default
-values in case none are specified.
-
-Think hard and long about naming the options. These names are going to
-be public API, and code is going to depend on them if the plugin is
-successful.
diff --git a/htdocs/includes/jquery/plugins/flot/README.md b/htdocs/includes/jquery/plugins/flot/README.md
deleted file mode 100644
index a8f70640a6b..00000000000
--- a/htdocs/includes/jquery/plugins/flot/README.md
+++ /dev/null
@@ -1,110 +0,0 @@
-# Flot [](https://travis-ci.org/flot/flot)
-
-## About ##
-
-Flot is a Javascript plotting library for jQuery.
-Read more at the website:
-
-Take a look at the the examples in examples/index.html; they should give a good
-impression of what Flot can do, and the source code of the examples is probably
-the fastest way to learn how to use Flot.
-
-
-## Installation ##
-
-Just include the Javascript file after you've included jQuery.
-
-Generally, all browsers that support the HTML5 canvas tag are
-supported.
-
-For support for Internet Explorer < 9, you can use [Excanvas]
-[excanvas], a canvas emulator; this is used in the examples bundled
-with Flot. You just include the excanvas script like this:
-
-```html
-
-```
-
-If it's not working on your development IE 6.0, check that it has
-support for VML which Excanvas is relying on. It appears that some
-stripped down versions used for test environments on virtual machines
-lack the VML support.
-
-You can also try using [Flashcanvas][flashcanvas], which uses Flash to
-do the emulation. Although Flash can be a bit slower to load than VML,
-if you've got a lot of points, the Flash version can be much faster
-overall. Flot contains some wrapper code for activating Excanvas which
-Flashcanvas is compatible with.
-
-You need at least jQuery 1.2.6, but try at least 1.3.2 for interactive
-charts because of performance improvements in event handling.
-
-
-## Basic usage ##
-
-Create a placeholder div to put the graph in:
-
-```html
-
-```
-
-You need to set the width and height of this div, otherwise the plot
-library doesn't know how to scale the graph. You can do it inline like
-this:
-
-```html
-
-```
-
-You can also do it with an external stylesheet. Make sure that the
-placeholder isn't within something with a display:none CSS property -
-in that case, Flot has trouble measuring label dimensions which
-results in garbled looks and might have trouble measuring the
-placeholder dimensions which is fatal (it'll throw an exception).
-
-Then when the div is ready in the DOM, which is usually on document
-ready, run the plot function:
-
-```js
-$.plot($("#placeholder"), data, options);
-```
-
-Here, data is an array of data series and options is an object with
-settings if you want to customize the plot. Take a look at the
-examples for some ideas of what to put in or look at the
-[API reference](API.md). Here's a quick example that'll draw a line
-from (0, 0) to (1, 1):
-
-```js
-$.plot($("#placeholder"), [ [[0, 0], [1, 1]] ], { yaxis: { max: 1 } });
-```
-
-The plot function immediately draws the chart and then returns a plot
-object with a couple of methods.
-
-
-## What's with the name? ##
-
-First: it's pronounced with a short o, like "plot". Not like "flawed".
-
-So "Flot" rhymes with "plot".
-
-And if you look up "flot" in a Danish-to-English dictionary, some of
-the words that come up are "good-looking", "attractive", "stylish",
-"smart", "impressive", "extravagant". One of the main goals with Flot
-is pretty looks.
-
-
-## Notes about the examples ##
-
-In order to have a useful, functional example of time-series plots using time
-zones, date.js from [timezone-js][timezone-js] (released under the Apache 2.0
-license) and the [Olson][olson] time zone database (released to the public
-domain) have been included in the examples directory. They are used in
-examples/axes-time-zones/index.html.
-
-
-[excanvas]: http://code.google.com/p/explorercanvas/
-[flashcanvas]: http://code.google.com/p/flashcanvas/
-[timezone-js]: https://github.com/mde/timezone-js
-[olson]: http://ftp.iana.org/time-zones
diff --git a/htdocs/includes/jquery/plugins/flot/excanvas.js b/htdocs/includes/jquery/plugins/flot/excanvas.js
deleted file mode 100644
index 70a8f25ca86..00000000000
--- a/htdocs/includes/jquery/plugins/flot/excanvas.js
+++ /dev/null
@@ -1,1428 +0,0 @@
-// Copyright 2006 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-// Known Issues:
-//
-// * Patterns only support repeat.
-// * Radial gradient are not implemented. The VML version of these look very
-// different from the canvas one.
-// * Clipping paths are not implemented.
-// * Coordsize. The width and height attribute have higher priority than the
-// width and height style values which isn't correct.
-// * Painting mode isn't implemented.
-// * Canvas width/height should is using content-box by default. IE in
-// Quirks mode will draw the canvas using border-box. Either change your
-// doctype to HTML5
-// (http://www.whatwg.org/specs/web-apps/current-work/#the-doctype)
-// or use Box Sizing Behavior from WebFX
-// (http://webfx.eae.net/dhtml/boxsizing/boxsizing.html)
-// * Non uniform scaling does not correctly scale strokes.
-// * Filling very large shapes (above 5000 points) is buggy.
-// * Optimize. There is always room for speed improvements.
-
-// Only add this code if we do not already have a canvas implementation
-if (!document.createElement('canvas').getContext) {
-
-(function() {
-
- // alias some functions to make (compiled) code shorter
- var m = Math;
- var mr = m.round;
- var ms = m.sin;
- var mc = m.cos;
- var abs = m.abs;
- var sqrt = m.sqrt;
-
- // this is used for sub pixel precision
- var Z = 10;
- var Z2 = Z / 2;
-
- var IE_VERSION = +navigator.userAgent.match(/MSIE ([\d.]+)?/)[1];
-
- /**
- * This funtion is assigned to the