Integrate Elastic recheck with Upstream opensearch
- updated opensearch URL and index - updated regex to check failed jobs - elasticsearch is no longer compatible with opensearch, so we are using opensearch-py now. Some instances of elasticsearch still remain - will remove in a follow up patch - updated unit tests - changed the mock from elasticsearch to opensearch - removed patch to elasticsearch's stats endpoint as we do not use stats anymore (we use search endpoint which is already mocked) - removed mock date, instead made the expected indices reflect current date. - changed utcnow() to now(datetime.timezone.utc) as utcnow does not work [1] - removing init.py from cmd as we do not need it and it causes conflict with pdb when we try to debug [1] https://blog.ganssle.io/articles/2019/11/utcnow.html Change-Id: I141db0a33a5f83aaf15e5294f1733a7affaa86f5
This commit is contained in:
parent
851b9e0a48
commit
95b43c9dc8
|
@ -22,4 +22,4 @@ key=/root/.ssh/id_ecdsa
|
||||||
es_url=http://logstash.openstack.org:80/elasticsearch
|
es_url=http://logstash.openstack.org:80/elasticsearch
|
||||||
ls_url=http://logstash.openstack.org
|
ls_url=http://logstash.openstack.org
|
||||||
db_uri=mysql+pymysql://query:query@logstash.openstack.org/subunit2sql
|
db_uri=mysql+pymysql://query:query@logstash.openstack.org/subunit2sql
|
||||||
index_format=logstash-%Y.%m.%d
|
index_format=logstash-logs-%Y.%m.%d
|
||||||
|
|
|
@ -20,21 +20,19 @@ import codecs
|
||||||
# Can be overriden by defining environment variables with same name
|
# Can be overriden by defining environment variables with same name
|
||||||
DEFAULTS = {
|
DEFAULTS = {
|
||||||
'ES_URL': codecs.decode(
|
'ES_URL': codecs.decode(
|
||||||
'uggcf://xvonan:on5r4np6-624n-49sr-956r-48no8poso2o6@erivrj.' +
|
'uggcf://bcrafgnpx:bcrafgnpx@bcrafrnepu.ybtf.bcrafgnpx.bet:443/',
|
||||||
'eqbcebwrpg.bet/rynfgvpfrnepu/',
|
|
||||||
'rot_13'),
|
'rot_13'),
|
||||||
'LS_URL': codecs.decode(
|
'LS_URL': codecs.decode(
|
||||||
'uggcf://xvonan:on5r4np6-624n-49sr-956r-48no8poso2o6@erivrj.' +
|
'uggcf://bcrafgnpx:bcrafgnpx@bcrafrnepu.ybtf.bcrafgnpx.bet:443/',
|
||||||
'eqbcebwrpg.bet/rynfgvpfrnepu/',
|
|
||||||
'rot_13'),
|
'rot_13'),
|
||||||
'DB_URI': 'mysql+pymysql://query:query@logstash.openstack.org/subunit2sql',
|
'DB_URI': 'mysql+pymysql://query:query@logstash.openstack.org/subunit2sql',
|
||||||
'server_password': '',
|
'server_password': '',
|
||||||
'CI_USERNAME': 'jenkins',
|
'CI_USERNAME': 'jenkins',
|
||||||
'JOBS_RE': '(dsvm|tripleo|tox)',
|
'JOBS_RE': '(tripleo)',
|
||||||
'PID_FN': '/var/run/elastic-recheck/elastic-recheck.pid',
|
'PID_FN': '/var/run/elastic-recheck/elastic-recheck.pid',
|
||||||
'INDEX_FORMAT': r'logstash-%Y.%m.%d',
|
'INDEX_FORMAT': r'logstash-logs-%Y.%m.%d',
|
||||||
'GERRIT_QUERY_FILE': 'queries',
|
'GERRIT_QUERY_FILE': 'queries',
|
||||||
'GERRIT_HOST': 'review.rdoproject.org',
|
'GERRIT_HOST': 'review.opendev.org',
|
||||||
'GERRIT_USER': None,
|
'GERRIT_USER': None,
|
||||||
'IRC_LOG_CONFIG': '',
|
'IRC_LOG_CONFIG': '',
|
||||||
'IRC_SERVER': "irc.oftc.net",
|
'IRC_SERVER': "irc.oftc.net",
|
||||||
|
|
|
@ -312,7 +312,7 @@ class Stream(object):
|
||||||
# bail if the failure is from a project
|
# bail if the failure is from a project
|
||||||
# that hasn't run any of the included jobs
|
# that hasn't run any of the included jobs
|
||||||
if not fevent.is_included_job():
|
if not fevent.is_included_job():
|
||||||
self.log.debug("Ignored comment: %s", fevent.comment)
|
# self.log.debug("Ignored comment: %s", fevent.comment)
|
||||||
continue
|
continue
|
||||||
|
|
||||||
self.log.info("Looking for failures in %d,%d on %s",
|
self.log.info("Looking for failures in %d,%d on %s",
|
||||||
|
|
|
@ -20,8 +20,8 @@ import datetime
|
||||||
import pprint
|
import pprint
|
||||||
|
|
||||||
import dateutil.parser as dp
|
import dateutil.parser as dp
|
||||||
|
from opensearchpy import OpenSearch
|
||||||
import elasticsearch
|
import elasticsearch
|
||||||
from elasticsearch import Elasticsearch
|
|
||||||
import pytz
|
import pytz
|
||||||
|
|
||||||
|
|
||||||
|
@ -29,8 +29,8 @@ pp = pprint.PrettyPrinter()
|
||||||
|
|
||||||
|
|
||||||
class SearchEngine(object):
|
class SearchEngine(object):
|
||||||
"""Wrapper for pyelasticsearch so that it returns result sets."""
|
"""Wrapper for opensearch so that it returns result sets."""
|
||||||
def __init__(self, url, indexfmt='logstash-%Y.%m.%d'):
|
def __init__(self, url, indexfmt='logstash-logs-%Y.%m.%d'):
|
||||||
self._url = url
|
self._url = url
|
||||||
self._indexfmt = indexfmt
|
self._indexfmt = indexfmt
|
||||||
self.index_cache = {}
|
self.index_cache = {}
|
||||||
|
@ -40,8 +40,7 @@ class SearchEngine(object):
|
||||||
return self.index_cache[index]
|
return self.index_cache[index]
|
||||||
|
|
||||||
try:
|
try:
|
||||||
es.indices.stats(index=index)
|
es.search(index=index)
|
||||||
# es.indices.status(index=index)
|
|
||||||
self.index_cache[index] = True
|
self.index_cache[index] = True
|
||||||
return True
|
return True
|
||||||
except elasticsearch.exceptions.NotFoundError:
|
except elasticsearch.exceptions.NotFoundError:
|
||||||
|
@ -67,13 +66,13 @@ class SearchEngine(object):
|
||||||
The returned result is a ResultSet query.
|
The returned result is a ResultSet query.
|
||||||
|
|
||||||
"""
|
"""
|
||||||
es = Elasticsearch(self._url)
|
es = OpenSearch(self._url)
|
||||||
args = {'size': size}
|
args = {'size': size}
|
||||||
indexes = []
|
indexes = []
|
||||||
if recent or days:
|
if recent or days:
|
||||||
# today's index
|
# today's index
|
||||||
datefmt = self._indexfmt
|
datefmt = self._indexfmt
|
||||||
now = datetime.datetime.utcnow()
|
now = datetime.datetime.now(tz=datetime.timezone.utc)
|
||||||
indexes = []
|
indexes = []
|
||||||
latest_index = now.strftime(datefmt)
|
latest_index = now.strftime(datefmt)
|
||||||
if self._is_valid_index(es, latest_index):
|
if self._is_valid_index(es, latest_index):
|
||||||
|
|
|
@ -8,7 +8,7 @@
|
||||||
"hits": [
|
"hits": [
|
||||||
{
|
{
|
||||||
"_id": "kY_XRtRFQXivpv1FIaSk1w",
|
"_id": "kY_XRtRFQXivpv1FIaSk1w",
|
||||||
"_index": "logstash-2014.11.25",
|
"_index": "logstash-014.11.25",
|
||||||
"_score": null,
|
"_score": null,
|
||||||
"_source": {
|
"_source": {
|
||||||
"@timestamp": "2014-11-25T00:49:21.685+00:00",
|
"@timestamp": "2014-11-25T00:49:21.685+00:00",
|
||||||
|
|
|
@ -18,6 +18,7 @@ import json
|
||||||
import mock
|
import mock
|
||||||
import elasticsearch
|
import elasticsearch
|
||||||
from elasticsearch import Elasticsearch
|
from elasticsearch import Elasticsearch
|
||||||
|
from opensearchpy import OpenSearch
|
||||||
|
|
||||||
from elastic_recheck import results
|
from elastic_recheck import results
|
||||||
from elastic_recheck import tests
|
from elastic_recheck import tests
|
||||||
|
@ -94,26 +95,33 @@ class TestBasicParsing(tests.TestCase):
|
||||||
self.assertEqual(list(facets[1382101200000].keys()), ["FAILURE"])
|
self.assertEqual(list(facets[1382101200000].keys()), ["FAILURE"])
|
||||||
|
|
||||||
|
|
||||||
# NOTE(mriedem): We can't mock built-ins so we have to override utcnow().
|
indexfmt = 'logstash-logs-%Y.%m.%d'
|
||||||
|
today = datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%S')
|
||||||
|
yesterday = datetime.datetime.strftime(datetime.datetime.now(datetime.timezone.utc) -
|
||||||
|
datetime.timedelta(1), '%Y-%m-%dT%H:%M:%S')
|
||||||
|
date_today = datetime.datetime.now(datetime.timezone.utc).strftime(indexfmt)
|
||||||
|
date_yesterday = datetime.datetime.strftime(datetime.datetime.now(datetime.timezone.utc) -
|
||||||
|
datetime.timedelta(1), indexfmt)
|
||||||
|
|
||||||
class MockDatetimeToday(datetime.datetime):
|
class MockDatetimeToday(datetime.datetime):
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def utcnow(cls):
|
def now(cls, *args, **kwargs):
|
||||||
# One hour and one second into today.
|
# One hour and one second into today.
|
||||||
return datetime.datetime.strptime('2014-06-12T01:00:01',
|
return datetime.datetime.strptime(today,
|
||||||
'%Y-%m-%dT%H:%M:%S')
|
'%Y-%m-%dT%H:%M:%S')
|
||||||
|
|
||||||
|
|
||||||
class MockDatetimeYesterday(datetime.datetime):
|
class MockDatetimeYesterday(datetime.datetime):
|
||||||
|
|
||||||
@classmethod
|
@classmethod
|
||||||
def utcnow(cls):
|
def now(cls, *args, **kwargs):
|
||||||
# 59 minutes and 59 seconds into today.
|
# 59 minutes and 59 seconds into today.
|
||||||
return datetime.datetime.strptime('2014-06-12T00:59:59',
|
return datetime.datetime.strptime(yesterday,
|
||||||
'%Y-%m-%dT%H:%M:%S')
|
'%Y-%m-%dT%H:%M:%S')
|
||||||
|
|
||||||
|
|
||||||
@mock.patch.object(Elasticsearch, 'search', return_value={})
|
@mock.patch.object(OpenSearch, 'search', return_value={})
|
||||||
class TestSearchEngine(tests.TestCase):
|
class TestSearchEngine(tests.TestCase):
|
||||||
"""Tests that the elastic search API is called correctly."""
|
"""Tests that the elastic search API is called correctly."""
|
||||||
|
|
||||||
|
@ -135,54 +143,45 @@ class TestSearchEngine(tests.TestCase):
|
||||||
datetime.datetime = datetime_mock
|
datetime.datetime = datetime_mock
|
||||||
result_set = self.engine.search(self.query, size=10, recent=True)
|
result_set = self.engine.search(self.query, size=10, recent=True)
|
||||||
self.assertEqual(0, len(result_set))
|
self.assertEqual(0, len(result_set))
|
||||||
search_mock.assert_called_once_with(
|
if expected_indexes:
|
||||||
body={'query': {'query_string': {'query': self.query}}},
|
search_mock.assert_has_calls([
|
||||||
params={'size': 10, "request_timeout": 40},
|
mock.call(
|
||||||
index=expected_indexes)
|
body={'query': {'query_string': {'query': self.query}}},
|
||||||
|
params={'size': 10, "request_timeout": 40},
|
||||||
|
index=expected_indexes)])
|
||||||
|
else:
|
||||||
|
search_mock.assert_has_calls([
|
||||||
|
mock.call(
|
||||||
|
body={'query': {'query_string': {'query': self.query}}},
|
||||||
|
params={'size': 10, "request_timeout": 40},
|
||||||
|
index=[date_today])])
|
||||||
|
|
||||||
|
|
||||||
def test_search_recent_current_index_only(self, search_mock):
|
def test_search_recent_current_index_only(self, search_mock):
|
||||||
# The search index comparison goes back one hour and cuts off by day,
|
# The search index comparison goes back one hour and cuts off by day,
|
||||||
# so test that we're one hour and one second into today so we only have
|
# so test that we're one hour and one second into today so we only have
|
||||||
# one index in the search call.
|
# one index in the search call.
|
||||||
with mock.patch.object(
|
|
||||||
elasticsearch.client.indices.IndicesClient, 'stats') \
|
|
||||||
as mock_data:
|
|
||||||
mock_data.return_value = "Not an exception"
|
|
||||||
self._test_search_recent(search_mock, MockDatetimeToday,
|
self._test_search_recent(search_mock, MockDatetimeToday,
|
||||||
expected_indexes=['logstash-2014.06.12'])
|
expected_indexes=[date_today])
|
||||||
|
|
||||||
def test_search_recent_multiple_indexes(self, search_mock):
|
def test_search_recent_multiple_indexes(self, search_mock):
|
||||||
# The search index comparison goes back one hour and cuts off by day,
|
# The search index comparison goes back one hour and cuts off by day,
|
||||||
# so test that we're 59 minutes and 59 seconds into today so that we
|
# so test that we're 59 minutes and 59 seconds into today so that we
|
||||||
# have an index for today and yesterday in the search call.
|
# have an index for today and yesterday in the search call.
|
||||||
with mock.patch.object(
|
self._test_search_recent(search_mock, MockDatetimeYesterday,
|
||||||
elasticsearch.client.indices.IndicesClient, 'stats') \
|
expected_indexes=[date_yesterday])
|
||||||
as mock_data:
|
|
||||||
mock_data.return_value = "Not an exception"
|
|
||||||
self._test_search_recent(search_mock, MockDatetimeYesterday,
|
|
||||||
expected_indexes=['logstash-2014.06.12',
|
|
||||||
'logstash-2014.06.11'])
|
|
||||||
|
|
||||||
def test_search_no_indexes(self, search_mock):
|
def test_search_no_indexes(self, search_mock):
|
||||||
# Test when no indexes are valid
|
# Test when no indexes are valid
|
||||||
with mock.patch.object(
|
self._test_search_recent(search_mock, MockDatetimeToday,
|
||||||
elasticsearch.client.indices.IndicesClient, 'stats') \
|
|
||||||
as mock_data:
|
|
||||||
mock_data.side_effect = elasticsearch.exceptions.NotFoundError
|
|
||||||
self._test_search_recent(search_mock, MockDatetimeYesterday,
|
|
||||||
expected_indexes=[])
|
expected_indexes=[])
|
||||||
|
|
||||||
def test_search_days(self, search_mock):
|
def test_search_days(self, search_mock):
|
||||||
# Test when specific days are used.
|
# Test when specific days are used.
|
||||||
with mock.patch.object(
|
result_set = self.engine.search(self.query, size=10, days=2,
|
||||||
elasticsearch.client.indices.IndicesClient, 'stats') \
|
|
||||||
as mock_data:
|
|
||||||
mock_data.return_value = "Not an exception"
|
|
||||||
datetime.datetime = MockDatetimeYesterday
|
|
||||||
result_set = self.engine.search(self.query, size=10, days=3,
|
|
||||||
recent=False)
|
recent=False)
|
||||||
self.assertEqual(0, len(result_set))
|
self.assertEqual(0, len(result_set))
|
||||||
search_mock.assert_called_once_with(body={
|
search_mock.assert_has_calls([mock.call(body={
|
||||||
'query': {
|
'query': {
|
||||||
'query_string': {
|
'query_string': {
|
||||||
'query': self.query
|
'query': self.query
|
||||||
|
@ -190,6 +189,5 @@ class TestSearchEngine(tests.TestCase):
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
params={'size': 10, "request_timeout": 40},
|
params={'size': 10, "request_timeout": 40},
|
||||||
index=['logstash-2014.06.12',
|
index=[date_today,
|
||||||
'logstash-2014.06.11',
|
date_yesterday])])
|
||||||
'logstash-2014.06.10'])
|
|
||||||
|
|
|
@ -2,6 +2,7 @@ pbr>=1.8
|
||||||
python-dateutil>=2.0
|
python-dateutil>=2.0
|
||||||
pytz
|
pytz
|
||||||
elasticsearch==7.14.0
|
elasticsearch==7.14.0
|
||||||
|
opensearch-py==2.0.0
|
||||||
gerritlib
|
gerritlib
|
||||||
python-daemon>=2.2.0
|
python-daemon>=2.2.0
|
||||||
irc>=17.0
|
irc>=17.0
|
||||||
|
|
|
@ -0,0 +1,6 @@
|
||||||
|
"use strict";
|
||||||
|
function __export(m) {
|
||||||
|
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
|
||||||
|
}
|
||||||
|
__export(require('./src/commonComponent.component'));
|
||||||
|
//# sourceMappingURL=common.js.map
|
|
@ -0,0 +1,71 @@
|
||||||
|
// graphite.js
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
$.fn.graphite = function (options) {
|
||||||
|
if (options === "update") {
|
||||||
|
$.fn.graphite.update(this, arguments[1]);
|
||||||
|
return this;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initialize plugin //
|
||||||
|
options = options || {};
|
||||||
|
var settings = $.extend({}, $.fn.graphite.defaults, options);
|
||||||
|
|
||||||
|
return this.each(function () {
|
||||||
|
var $this = $(this);
|
||||||
|
|
||||||
|
$this.data("graphOptions", settings);
|
||||||
|
$.fn.graphite.render($this, settings);
|
||||||
|
});
|
||||||
|
|
||||||
|
};
|
||||||
|
|
||||||
|
$.fn.graphite.geturl = function(rawOptions) {
|
||||||
|
var src = rawOptions.url + "?";
|
||||||
|
|
||||||
|
// use random parameter to force image refresh
|
||||||
|
var options = $.extend({}, rawOptions);
|
||||||
|
|
||||||
|
options["_t"] = options["_t"] || Math.random();
|
||||||
|
|
||||||
|
$.each(options, function (key, value) {
|
||||||
|
if (key === "target") {
|
||||||
|
$.each(value, function (index, value) {
|
||||||
|
src += "&target=" + value;
|
||||||
|
});
|
||||||
|
} else if (value !== null && key !== "url") {
|
||||||
|
src += "&" + key + "=" + value;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
return src.replace(/\?&/, "?");
|
||||||
|
};
|
||||||
|
|
||||||
|
$.fn.graphite.render = function($img, options) {
|
||||||
|
$img.attr("src", $.fn.graphite.geturl(options));
|
||||||
|
$img.attr("height", options.height);
|
||||||
|
$img.attr("width", options.width);
|
||||||
|
};
|
||||||
|
|
||||||
|
$.fn.graphite.update = function($img, options) {
|
||||||
|
options = options || {};
|
||||||
|
$img.each(function () {
|
||||||
|
var $this = $(this);
|
||||||
|
var settings = $.extend({}, $this.data("graphOptions"), options);
|
||||||
|
$this.data("graphOptions", settings);
|
||||||
|
$.fn.graphite.render($this, settings);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
// Default settings.
|
||||||
|
// Override with the options argument for per-case setup
|
||||||
|
// or set $.fn.graphite.defaults.<value> for global changes
|
||||||
|
$.fn.graphite.defaults = {
|
||||||
|
from: "-1hour",
|
||||||
|
height: "300",
|
||||||
|
until: "now",
|
||||||
|
url: "/render/",
|
||||||
|
width: "940"
|
||||||
|
};
|
||||||
|
|
||||||
|
}(jQuery));
|
|
@ -0,0 +1,2 @@
|
||||||
|
/*! jquery-visibility v1.0.11 | MIT license | http://mths.be/visibility */
|
||||||
|
!function(e,i){"function"==typeof define&&define.amd?define(["jquery"],function(t){return i(e,t)}):"object"==typeof exports?module.exports=i(e,require("jquery")):i(e,jQuery)}(this,function(e,i,t){"use strict";function o(){"hidden"!==n&&(r.hidden=f.pageVisibility?r[n]:t)}for(var n,u,r=e.document,s=["webkit","o","ms","moz",""],f=i.support||{},c=("onfocusin"in r&&"hasFocus"in r?"focusin focusout":"focus blur");(u=s.pop())!==t;)if(n=(u?u+"H":"h")+"idden",f.pageVisibility=r[n]!==t,f.pageVisibility){c=u+"visibilitychange";break}o(),i(/blur$/.test(c)?e:r).on(c,function(e){var u=e.type,s=e.originalEvent;if(s){var f=s.toElement;(!/^focus./.test(u)||f===t&&s.fromElement===t&&s.relatedTarget===t)&&i(r).triggerHandler(n&&r[n]||/^(?:blur|focusout)$/.test(u)?"hide":"show"),o()}})});
|
|
@ -0,0 +1,78 @@
|
||||||
|
(function($){
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Copyright 2012, Digital Fusion
|
||||||
|
* Licensed under the MIT license.
|
||||||
|
* http://teamdf.com/jquery-plugins/license/
|
||||||
|
*
|
||||||
|
* @author Sam Sehnert
|
||||||
|
* @desc A small plugin that checks whether elements are within
|
||||||
|
* the user visible viewport of a web browser.
|
||||||
|
* only accounts for vertical position, not horizontal.
|
||||||
|
*/
|
||||||
|
$.fn.visible = function(partial,hidden,direction,container){
|
||||||
|
|
||||||
|
if (this.length < 1)
|
||||||
|
return;
|
||||||
|
|
||||||
|
var $t = this.length > 1 ? this.eq(0) : this,
|
||||||
|
isContained = typeof container !== 'undefined' && container !== null,
|
||||||
|
$w = isContained ? $(container) : $(window),
|
||||||
|
wPosition = isContained ? $w.position() : 0,
|
||||||
|
t = $t.get(0),
|
||||||
|
vpWidth = $w.outerWidth(),
|
||||||
|
vpHeight = $w.outerHeight(),
|
||||||
|
direction = (direction) ? direction : 'both',
|
||||||
|
clientSize = hidden === true ? t.offsetWidth * t.offsetHeight : true;
|
||||||
|
|
||||||
|
if (typeof t.getBoundingClientRect === 'function'){
|
||||||
|
|
||||||
|
// Use this native browser method, if available.
|
||||||
|
var rec = t.getBoundingClientRect(),
|
||||||
|
tViz = isContained ?
|
||||||
|
rec.top - wPosition.top >= 0 && rec.top < vpHeight + wPosition.top :
|
||||||
|
rec.top >= 0 && rec.top < vpHeight,
|
||||||
|
bViz = isContained ?
|
||||||
|
rec.bottom - wPosition.top > 0 && rec.bottom <= vpHeight + wPosition.top :
|
||||||
|
rec.bottom > 0 && rec.bottom <= vpHeight,
|
||||||
|
lViz = isContained ?
|
||||||
|
rec.left - wPosition.left >= 0 && rec.left < vpWidth + wPosition.left :
|
||||||
|
rec.left >= 0 && rec.left < vpWidth,
|
||||||
|
rViz = isContained ?
|
||||||
|
rec.right - wPosition.left > 0 && rec.right < vpWidth + wPosition.left :
|
||||||
|
rec.right > 0 && rec.right <= vpWidth,
|
||||||
|
vVisible = partial ? tViz || bViz : tViz && bViz,
|
||||||
|
hVisible = partial ? lViz || rViz : lViz && rViz;
|
||||||
|
|
||||||
|
if(direction === 'both')
|
||||||
|
return clientSize && vVisible && hVisible;
|
||||||
|
else if(direction === 'vertical')
|
||||||
|
return clientSize && vVisible;
|
||||||
|
else if(direction === 'horizontal')
|
||||||
|
return clientSize && hVisible;
|
||||||
|
} else {
|
||||||
|
|
||||||
|
var viewTop = isContained ? 0 : wPosition,
|
||||||
|
viewBottom = viewTop + vpHeight,
|
||||||
|
viewLeft = $w.scrollLeft(),
|
||||||
|
viewRight = viewLeft + vpWidth,
|
||||||
|
position = $t.position(),
|
||||||
|
_top = position.top,
|
||||||
|
_bottom = _top + $t.height(),
|
||||||
|
_left = position.left,
|
||||||
|
_right = _left + $t.width(),
|
||||||
|
compareTop = partial === true ? _bottom : _top,
|
||||||
|
compareBottom = partial === true ? _top : _bottom,
|
||||||
|
compareLeft = partial === true ? _right : _left,
|
||||||
|
compareRight = partial === true ? _left : _right;
|
||||||
|
|
||||||
|
if(direction === 'both')
|
||||||
|
return !!clientSize && ((compareBottom <= viewBottom) && (compareTop >= viewTop)) && ((compareRight <= viewRight) && (compareLeft >= viewLeft));
|
||||||
|
else if(direction === 'vertical')
|
||||||
|
return !!clientSize && ((compareBottom <= viewBottom) && (compareTop >= viewTop));
|
||||||
|
else if(direction === 'horizontal')
|
||||||
|
return !!clientSize && ((compareRight <= viewRight) && (compareLeft >= viewLeft));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1 @@
|
||||||
|
!function(t){var i=t(window);t.fn.visible=function(t,e,o){if(!(this.length<1)){var r=this.length>1?this.eq(0):this,n=r.get(0),f=i.width(),h=i.height(),o=o?o:"both",l=e===!0?n.offsetWidth*n.offsetHeight:!0;if("function"==typeof n.getBoundingClientRect){var g=n.getBoundingClientRect(),u=g.top>=0&&g.top<h,s=g.bottom>0&&g.bottom<=h,c=g.left>=0&&g.left<f,a=g.right>0&&g.right<=f,v=t?u||s:u&&s,b=t?c||a:c&&a;if("both"===o)return l&&v&&b;if("vertical"===o)return l&&v;if("horizontal"===o)return l&&b}else{var d=i.scrollTop(),p=d+h,w=i.scrollLeft(),m=w+f,y=r.offset(),z=y.top,B=z+r.height(),C=y.left,R=C+r.width(),j=t===!0?B:z,q=t===!0?z:B,H=t===!0?R:C,L=t===!0?C:R;if("both"===o)return!!l&&p>=q&&j>=d&&m>=L&&H>=w;if("vertical"===o)return!!l&&p>=q&&j>=d;if("horizontal"===o)return!!l&&m>=L&&H>=w}}}}(jQuery);
|
|
@ -0,0 +1,549 @@
|
||||||
|
/** ## jquery.flot.canvaswrapper
|
||||||
|
|
||||||
|
This plugin contains the function for creating and manipulating both the canvas
|
||||||
|
layers and svg layers.
|
||||||
|
|
||||||
|
The Canvas object is a wrapper around an HTML5 canvas tag.
|
||||||
|
The constructor Canvas(cls, container) takes as parameters cls,
|
||||||
|
the list of classes to apply to the canvas adnd the containter,
|
||||||
|
element onto which to append the canvas. The canvas operations
|
||||||
|
don't work unless the canvas is attached to the DOM.
|
||||||
|
|
||||||
|
### jquery.canvaswrapper.js API functions
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
var Canvas = function(cls, container) {
|
||||||
|
var element = container.getElementsByClassName(cls)[0];
|
||||||
|
|
||||||
|
if (!element) {
|
||||||
|
element = document.createElement('canvas');
|
||||||
|
element.className = cls;
|
||||||
|
element.style.direction = 'ltr';
|
||||||
|
element.style.position = 'absolute';
|
||||||
|
element.style.left = '0px';
|
||||||
|
element.style.top = '0px';
|
||||||
|
|
||||||
|
container.appendChild(element);
|
||||||
|
|
||||||
|
// If HTML5 Canvas isn't available, throw
|
||||||
|
|
||||||
|
if (!element.getContext) {
|
||||||
|
throw new Error('Canvas is not available.');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
this.element = element;
|
||||||
|
|
||||||
|
var context = this.context = element.getContext('2d');
|
||||||
|
this.pixelRatio = $.plot.browser.getPixelRatio(context);
|
||||||
|
|
||||||
|
// Size the canvas to match the internal dimensions of its container
|
||||||
|
var width = $(container).width();
|
||||||
|
var height = $(container).height();
|
||||||
|
this.resize(width, height);
|
||||||
|
|
||||||
|
// Collection of HTML div layers for text overlaid onto the canvas
|
||||||
|
|
||||||
|
this.SVGContainer = null;
|
||||||
|
this.SVG = {};
|
||||||
|
|
||||||
|
// Cache of text fragments and metrics, so we can avoid expensively
|
||||||
|
// re-calculating them when the plot is re-rendered in a loop.
|
||||||
|
|
||||||
|
this._textCache = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- resize(width, height)
|
||||||
|
|
||||||
|
Resizes the canvas to the given dimensions.
|
||||||
|
The width represents the new width of the canvas, meanwhile the height
|
||||||
|
is the new height of the canvas, both of them in pixels.
|
||||||
|
*/
|
||||||
|
|
||||||
|
Canvas.prototype.resize = function(width, height) {
|
||||||
|
var minSize = 10;
|
||||||
|
width = width < minSize ? minSize : width;
|
||||||
|
height = height < minSize ? minSize : height;
|
||||||
|
|
||||||
|
var element = this.element,
|
||||||
|
context = this.context,
|
||||||
|
pixelRatio = this.pixelRatio;
|
||||||
|
|
||||||
|
// Resize the canvas, increasing its density based on the display's
|
||||||
|
// pixel ratio; basically giving it more pixels without increasing the
|
||||||
|
// size of its element, to take advantage of the fact that retina
|
||||||
|
// displays have that many more pixels in the same advertised space.
|
||||||
|
|
||||||
|
// Resizing should reset the state (excanvas seems to be buggy though)
|
||||||
|
|
||||||
|
if (this.width !== width) {
|
||||||
|
element.width = width * pixelRatio;
|
||||||
|
element.style.width = width + 'px';
|
||||||
|
this.width = width;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (this.height !== height) {
|
||||||
|
element.height = height * pixelRatio;
|
||||||
|
element.style.height = height + 'px';
|
||||||
|
this.height = height;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Save the context, so we can reset in case we get replotted. The
|
||||||
|
// restore ensure that we're really back at the initial state, and
|
||||||
|
// should be safe even if we haven't saved the initial state yet.
|
||||||
|
|
||||||
|
context.restore();
|
||||||
|
context.save();
|
||||||
|
|
||||||
|
// Scale the coordinate space to match the display density; so even though we
|
||||||
|
// may have twice as many pixels, we still want lines and other drawing to
|
||||||
|
// appear at the same size; the extra pixels will just make them crisper.
|
||||||
|
|
||||||
|
context.scale(pixelRatio, pixelRatio);
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
- clear()
|
||||||
|
|
||||||
|
Clears the entire canvas area, not including any overlaid HTML text
|
||||||
|
*/
|
||||||
|
Canvas.prototype.clear = function() {
|
||||||
|
this.context.clearRect(0, 0, this.width, this.height);
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
- render()
|
||||||
|
|
||||||
|
Finishes rendering the canvas, including managing the text overlay.
|
||||||
|
*/
|
||||||
|
Canvas.prototype.render = function() {
|
||||||
|
var cache = this._textCache;
|
||||||
|
|
||||||
|
// For each text layer, add elements marked as active that haven't
|
||||||
|
// already been rendered, and remove those that are no longer active.
|
||||||
|
|
||||||
|
for (var layerKey in cache) {
|
||||||
|
if (hasOwnProperty.call(cache, layerKey)) {
|
||||||
|
var layer = this.getSVGLayer(layerKey),
|
||||||
|
layerCache = cache[layerKey];
|
||||||
|
|
||||||
|
var display = layer.style.display;
|
||||||
|
layer.style.display = 'none';
|
||||||
|
|
||||||
|
for (var styleKey in layerCache) {
|
||||||
|
if (hasOwnProperty.call(layerCache, styleKey)) {
|
||||||
|
var styleCache = layerCache[styleKey];
|
||||||
|
for (var key in styleCache) {
|
||||||
|
if (hasOwnProperty.call(styleCache, key)) {
|
||||||
|
var val = styleCache[key],
|
||||||
|
positions = val.positions;
|
||||||
|
|
||||||
|
for (var i = 0, position; positions[i]; i++) {
|
||||||
|
position = positions[i];
|
||||||
|
if (position.active) {
|
||||||
|
if (!position.rendered) {
|
||||||
|
layer.appendChild(position.element);
|
||||||
|
position.rendered = true;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
positions.splice(i--, 1);
|
||||||
|
if (position.rendered) {
|
||||||
|
while (position.element.firstChild) {
|
||||||
|
position.element.removeChild(position.element.firstChild);
|
||||||
|
}
|
||||||
|
position.element.parentNode.removeChild(position.element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (positions.length === 0) {
|
||||||
|
if (val.measured) {
|
||||||
|
val.measured = false;
|
||||||
|
} else {
|
||||||
|
delete styleCache[key];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
layer.style.display = display;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
- getSVGLayer(classes)
|
||||||
|
|
||||||
|
Creates (if necessary) and returns the SVG overlay container.
|
||||||
|
The classes string represents the string of space-separated CSS classes
|
||||||
|
used to uniquely identify the text layer. It return the svg-layer div.
|
||||||
|
*/
|
||||||
|
Canvas.prototype.getSVGLayer = function(classes) {
|
||||||
|
var layer = this.SVG[classes];
|
||||||
|
|
||||||
|
// Create the SVG layer if it doesn't exist
|
||||||
|
|
||||||
|
if (!layer) {
|
||||||
|
// Create the svg layer container, if it doesn't exist
|
||||||
|
|
||||||
|
var svgElement;
|
||||||
|
|
||||||
|
if (!this.SVGContainer) {
|
||||||
|
this.SVGContainer = document.createElement('div');
|
||||||
|
this.SVGContainer.className = 'flot-svg';
|
||||||
|
this.SVGContainer.style.position = 'absolute';
|
||||||
|
this.SVGContainer.style.top = '0px';
|
||||||
|
this.SVGContainer.style.left = '0px';
|
||||||
|
this.SVGContainer.style.height = '100%';
|
||||||
|
this.SVGContainer.style.width = '100%';
|
||||||
|
this.SVGContainer.style.pointerEvents = 'none';
|
||||||
|
this.element.parentNode.appendChild(this.SVGContainer);
|
||||||
|
|
||||||
|
svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
|
||||||
|
svgElement.style.width = '100%';
|
||||||
|
svgElement.style.height = '100%';
|
||||||
|
|
||||||
|
this.SVGContainer.appendChild(svgElement);
|
||||||
|
} else {
|
||||||
|
svgElement = this.SVGContainer.firstChild;
|
||||||
|
}
|
||||||
|
|
||||||
|
layer = document.createElementNS('http://www.w3.org/2000/svg', 'g');
|
||||||
|
layer.setAttribute('class', classes);
|
||||||
|
layer.style.position = 'absolute';
|
||||||
|
layer.style.top = '0px';
|
||||||
|
layer.style.left = '0px';
|
||||||
|
layer.style.bottom = '0px';
|
||||||
|
layer.style.right = '0px';
|
||||||
|
svgElement.appendChild(layer);
|
||||||
|
this.SVG[classes] = layer;
|
||||||
|
}
|
||||||
|
|
||||||
|
return layer;
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
- getTextInfo(layer, text, font, angle, width)
|
||||||
|
|
||||||
|
Creates (if necessary) and returns a text info object.
|
||||||
|
The object looks like this:
|
||||||
|
```js
|
||||||
|
{
|
||||||
|
width //Width of the text's wrapper div.
|
||||||
|
height //Height of the text's wrapper div.
|
||||||
|
element //The HTML div containing the text.
|
||||||
|
positions //Array of positions at which this text is drawn.
|
||||||
|
}
|
||||||
|
```
|
||||||
|
The positions array contains objects that look like this:
|
||||||
|
```js
|
||||||
|
{
|
||||||
|
active //Flag indicating whether the text should be visible.
|
||||||
|
rendered //Flag indicating whether the text is currently visible.
|
||||||
|
element //The HTML div containing the text.
|
||||||
|
text //The actual text and is identical with element[0].textContent.
|
||||||
|
x //X coordinate at which to draw the text.
|
||||||
|
y //Y coordinate at which to draw the text.
|
||||||
|
}
|
||||||
|
```
|
||||||
|
Each position after the first receives a clone of the original element.
|
||||||
|
The idea is that that the width, height, and general 'identity' of the
|
||||||
|
text is constant no matter where it is placed; the placements are a
|
||||||
|
secondary property.
|
||||||
|
|
||||||
|
Canvas maintains a cache of recently-used text info objects; getTextInfo
|
||||||
|
either returns the cached element or creates a new entry.
|
||||||
|
|
||||||
|
The layer parameter is string of space-separated CSS classes uniquely
|
||||||
|
identifying the layer containing this text.
|
||||||
|
Text is the text string to retrieve info for.
|
||||||
|
Font is either a string of space-separated CSS classes or a font-spec object,
|
||||||
|
defining the text's font and style.
|
||||||
|
Angle is the angle at which to rotate the text, in degrees. Angle is currently unused,
|
||||||
|
it will be implemented in the future.
|
||||||
|
The last parameter is the Maximum width of the text before it wraps.
|
||||||
|
The method returns a text info object.
|
||||||
|
*/
|
||||||
|
Canvas.prototype.getTextInfo = function(layer, text, font, angle, width) {
|
||||||
|
var textStyle, layerCache, styleCache, info;
|
||||||
|
|
||||||
|
// Cast the value to a string, in case we were given a number or such
|
||||||
|
|
||||||
|
text = '' + text;
|
||||||
|
|
||||||
|
// If the font is a font-spec object, generate a CSS font definition
|
||||||
|
|
||||||
|
if (typeof font === 'object') {
|
||||||
|
textStyle = font.style + ' ' + font.variant + ' ' + font.weight + ' ' + font.size + 'px/' + font.lineHeight + 'px ' + font.family;
|
||||||
|
} else {
|
||||||
|
textStyle = font;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Retrieve (or create) the cache for the text's layer and styles
|
||||||
|
|
||||||
|
layerCache = this._textCache[layer];
|
||||||
|
|
||||||
|
if (layerCache == null) {
|
||||||
|
layerCache = this._textCache[layer] = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
styleCache = layerCache[textStyle];
|
||||||
|
|
||||||
|
if (styleCache == null) {
|
||||||
|
styleCache = layerCache[textStyle] = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
var key = generateKey(text);
|
||||||
|
info = styleCache[key];
|
||||||
|
|
||||||
|
// If we can't find a matching element in our cache, create a new one
|
||||||
|
|
||||||
|
if (!info) {
|
||||||
|
var element = document.createElementNS('http://www.w3.org/2000/svg', 'text');
|
||||||
|
if (text.indexOf('<br>') !== -1) {
|
||||||
|
addTspanElements(text, element, -9999);
|
||||||
|
} else {
|
||||||
|
var textNode = document.createTextNode(text);
|
||||||
|
element.appendChild(textNode);
|
||||||
|
}
|
||||||
|
|
||||||
|
element.style.position = 'absolute';
|
||||||
|
element.style.maxWidth = width;
|
||||||
|
element.setAttributeNS(null, 'x', -9999);
|
||||||
|
element.setAttributeNS(null, 'y', -9999);
|
||||||
|
|
||||||
|
if (typeof font === 'object') {
|
||||||
|
element.style.font = textStyle;
|
||||||
|
element.style.fill = font.fill;
|
||||||
|
} else if (typeof font === 'string') {
|
||||||
|
element.setAttribute('class', font);
|
||||||
|
}
|
||||||
|
|
||||||
|
this.getSVGLayer(layer).appendChild(element);
|
||||||
|
var elementRect = element.getBBox();
|
||||||
|
|
||||||
|
info = styleCache[key] = {
|
||||||
|
width: elementRect.width,
|
||||||
|
height: elementRect.height,
|
||||||
|
measured: true,
|
||||||
|
element: element,
|
||||||
|
positions: []
|
||||||
|
};
|
||||||
|
|
||||||
|
//remove elements from dom
|
||||||
|
while (element.firstChild) {
|
||||||
|
element.removeChild(element.firstChild);
|
||||||
|
}
|
||||||
|
element.parentNode.removeChild(element);
|
||||||
|
}
|
||||||
|
|
||||||
|
info.measured = true;
|
||||||
|
return info;
|
||||||
|
};
|
||||||
|
|
||||||
|
function updateTransforms (element, transforms) {
|
||||||
|
element.transform.baseVal.clear();
|
||||||
|
if (transforms) {
|
||||||
|
transforms.forEach(function(t) {
|
||||||
|
element.transform.baseVal.appendItem(t);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- addText (layer, x, y, text, font, angle, width, halign, valign, transforms)
|
||||||
|
|
||||||
|
Adds a text string to the canvas text overlay.
|
||||||
|
The text isn't drawn immediately; it is marked as rendering, which will
|
||||||
|
result in its addition to the canvas on the next render pass.
|
||||||
|
|
||||||
|
The layer is string of space-separated CSS classes uniquely
|
||||||
|
identifying the layer containing this text.
|
||||||
|
X and Y represents the X and Y coordinate at which to draw the text.
|
||||||
|
and text is the string to draw
|
||||||
|
*/
|
||||||
|
Canvas.prototype.addText = function(layer, x, y, text, font, angle, width, halign, valign, transforms) {
|
||||||
|
var info = this.getTextInfo(layer, text, font, angle, width),
|
||||||
|
positions = info.positions;
|
||||||
|
|
||||||
|
// Tweak the div's position to match the text's alignment
|
||||||
|
|
||||||
|
if (halign === 'center') {
|
||||||
|
x -= info.width / 2;
|
||||||
|
} else if (halign === 'right') {
|
||||||
|
x -= info.width;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (valign === 'middle') {
|
||||||
|
y -= info.height / 2;
|
||||||
|
} else if (valign === 'bottom') {
|
||||||
|
y -= info.height;
|
||||||
|
}
|
||||||
|
|
||||||
|
y += 0.75 * info.height;
|
||||||
|
|
||||||
|
// Determine whether this text already exists at this position.
|
||||||
|
// If so, mark it for inclusion in the next render pass.
|
||||||
|
|
||||||
|
for (var i = 0, position; positions[i]; i++) {
|
||||||
|
position = positions[i];
|
||||||
|
if (position.x === x && position.y === y && position.text === text) {
|
||||||
|
position.active = true;
|
||||||
|
// update the transforms
|
||||||
|
updateTransforms(position.element, transforms);
|
||||||
|
|
||||||
|
return;
|
||||||
|
} else if (position.active === false) {
|
||||||
|
position.active = true;
|
||||||
|
position.text = text;
|
||||||
|
if (text.indexOf('<br>') !== -1) {
|
||||||
|
y -= 0.25 * info.height;
|
||||||
|
addTspanElements(text, position.element, x);
|
||||||
|
} else {
|
||||||
|
position.element.textContent = text;
|
||||||
|
}
|
||||||
|
position.element.setAttributeNS(null, 'x', x);
|
||||||
|
position.element.setAttributeNS(null, 'y', y);
|
||||||
|
position.x = x;
|
||||||
|
position.y = y;
|
||||||
|
// update the transforms
|
||||||
|
updateTransforms(position.element, transforms);
|
||||||
|
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the text doesn't exist at this position, create a new entry
|
||||||
|
|
||||||
|
// For the very first position we'll re-use the original element,
|
||||||
|
// while for subsequent ones we'll clone it.
|
||||||
|
|
||||||
|
position = {
|
||||||
|
active: true,
|
||||||
|
rendered: false,
|
||||||
|
element: positions.length ? info.element.cloneNode() : info.element,
|
||||||
|
text: text,
|
||||||
|
x: x,
|
||||||
|
y: y
|
||||||
|
};
|
||||||
|
|
||||||
|
positions.push(position);
|
||||||
|
|
||||||
|
if (text.indexOf('<br>') !== -1) {
|
||||||
|
y -= 0.25 * info.height;
|
||||||
|
addTspanElements(text, position.element, x);
|
||||||
|
} else {
|
||||||
|
position.element.textContent = text;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Move the element to its final position within the container
|
||||||
|
position.element.setAttributeNS(null, 'x', x);
|
||||||
|
position.element.setAttributeNS(null, 'y', y);
|
||||||
|
position.element.style.textAlign = halign;
|
||||||
|
// update the transforms
|
||||||
|
updateTransforms(position.element, transforms);
|
||||||
|
};
|
||||||
|
|
||||||
|
var addTspanElements = function(text, element, x) {
|
||||||
|
var lines = text.split('<br>'),
|
||||||
|
tspan, i, offset;
|
||||||
|
|
||||||
|
for (i = 0; i < lines.length; i++) {
|
||||||
|
if (!element.childNodes[i]) {
|
||||||
|
tspan = document.createElementNS('http://www.w3.org/2000/svg', 'tspan');
|
||||||
|
element.appendChild(tspan);
|
||||||
|
} else {
|
||||||
|
tspan = element.childNodes[i];
|
||||||
|
}
|
||||||
|
tspan.textContent = lines[i];
|
||||||
|
offset = (i === 0 ? 0 : 1) + 'em';
|
||||||
|
tspan.setAttributeNS(null, 'dy', offset);
|
||||||
|
tspan.setAttributeNS(null, 'x', x);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- removeText (layer, x, y, text, font, angle)
|
||||||
|
|
||||||
|
The function removes one or more text strings from the canvas text overlay.
|
||||||
|
If no parameters are given, all text within the layer is removed.
|
||||||
|
|
||||||
|
Note that the text is not immediately removed; it is simply marked as
|
||||||
|
inactive, which will result in its removal on the next render pass.
|
||||||
|
This avoids the performance penalty for 'clear and redraw' behavior,
|
||||||
|
where we potentially get rid of all text on a layer, but will likely
|
||||||
|
add back most or all of it later, as when redrawing axes, for example.
|
||||||
|
|
||||||
|
The layer is a string of space-separated CSS classes uniquely
|
||||||
|
identifying the layer containing this text. The following parameter are
|
||||||
|
X and Y coordinate of the text.
|
||||||
|
Text is the string to remove, while the font is either a string of space-separated CSS
|
||||||
|
classes or a font-spec object, defining the text's font and style.
|
||||||
|
*/
|
||||||
|
Canvas.prototype.removeText = function(layer, x, y, text, font, angle) {
|
||||||
|
var info, htmlYCoord;
|
||||||
|
if (text == null) {
|
||||||
|
var layerCache = this._textCache[layer];
|
||||||
|
if (layerCache != null) {
|
||||||
|
for (var styleKey in layerCache) {
|
||||||
|
if (hasOwnProperty.call(layerCache, styleKey)) {
|
||||||
|
var styleCache = layerCache[styleKey];
|
||||||
|
for (var key in styleCache) {
|
||||||
|
if (hasOwnProperty.call(styleCache, key)) {
|
||||||
|
var positions = styleCache[key].positions;
|
||||||
|
positions.forEach(function(position) {
|
||||||
|
position.active = false;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
info = this.getTextInfo(layer, text, font, angle);
|
||||||
|
positions = info.positions;
|
||||||
|
positions.forEach(function(position) {
|
||||||
|
htmlYCoord = y + 0.75 * info.height;
|
||||||
|
if (position.x === x && position.y === htmlYCoord && position.text === text) {
|
||||||
|
position.active = false;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
- clearCache()
|
||||||
|
|
||||||
|
Clears the cache used to speed up the text size measurements.
|
||||||
|
As an (unfortunate) side effect all text within the text Layer is removed.
|
||||||
|
Use this function before plot.setupGrid() and plot.draw() if the plot just
|
||||||
|
became visible or the styles changed.
|
||||||
|
*/
|
||||||
|
Canvas.prototype.clearCache = function() {
|
||||||
|
var cache = this._textCache;
|
||||||
|
for (var layerKey in cache) {
|
||||||
|
if (hasOwnProperty.call(cache, layerKey)) {
|
||||||
|
var layer = this.getSVGLayer(layerKey);
|
||||||
|
while (layer.firstChild) {
|
||||||
|
layer.removeChild(layer.firstChild);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
this._textCache = {};
|
||||||
|
};
|
||||||
|
|
||||||
|
function generateKey(text) {
|
||||||
|
return text.replace(/0|1|2|3|4|5|6|7|8|9/g, '0');
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!window.Flot) {
|
||||||
|
window.Flot = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
window.Flot.Canvas = Canvas;
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,199 @@
|
||||||
|
/* Plugin for jQuery for working with colors.
|
||||||
|
*
|
||||||
|
* Version 1.1.
|
||||||
|
*
|
||||||
|
* Inspiration from jQuery color animation plugin by John Resig.
|
||||||
|
*
|
||||||
|
* Released under the MIT license by Ole Laursen, October 2009.
|
||||||
|
*
|
||||||
|
* Examples:
|
||||||
|
*
|
||||||
|
* $.color.parse("#fff").scale('rgb', 0.25).add('a', -0.5).toString()
|
||||||
|
* var c = $.color.extract($("#mydiv"), 'background-color');
|
||||||
|
* console.log(c.r, c.g, c.b, c.a);
|
||||||
|
* $.color.make(100, 50, 25, 0.4).toString() // returns "rgba(100,50,25,0.4)"
|
||||||
|
*
|
||||||
|
* Note that .scale() and .add() return the same modified object
|
||||||
|
* instead of making a new one.
|
||||||
|
*
|
||||||
|
* V. 1.1: Fix error handling so e.g. parsing an empty string does
|
||||||
|
* produce a color rather than just crashing.
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
$.color = {};
|
||||||
|
|
||||||
|
// construct color object with some convenient chainable helpers
|
||||||
|
$.color.make = function (r, g, b, a) {
|
||||||
|
var o = {};
|
||||||
|
o.r = r || 0;
|
||||||
|
o.g = g || 0;
|
||||||
|
o.b = b || 0;
|
||||||
|
o.a = a != null ? a : 1;
|
||||||
|
|
||||||
|
o.add = function (c, d) {
|
||||||
|
for (var i = 0; i < c.length; ++i) {
|
||||||
|
o[c.charAt(i)] += d;
|
||||||
|
}
|
||||||
|
|
||||||
|
return o.normalize();
|
||||||
|
};
|
||||||
|
|
||||||
|
o.scale = function (c, f) {
|
||||||
|
for (var i = 0; i < c.length; ++i) {
|
||||||
|
o[c.charAt(i)] *= f;
|
||||||
|
}
|
||||||
|
|
||||||
|
return o.normalize();
|
||||||
|
};
|
||||||
|
|
||||||
|
o.toString = function () {
|
||||||
|
if (o.a >= 1.0) {
|
||||||
|
return "rgb(" + [o.r, o.g, o.b].join(",") + ")";
|
||||||
|
} else {
|
||||||
|
return "rgba(" + [o.r, o.g, o.b, o.a].join(",") + ")";
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
o.normalize = function () {
|
||||||
|
function clamp(min, value, max) {
|
||||||
|
return value < min ? min : (value > max ? max : value);
|
||||||
|
}
|
||||||
|
|
||||||
|
o.r = clamp(0, parseInt(o.r), 255);
|
||||||
|
o.g = clamp(0, parseInt(o.g), 255);
|
||||||
|
o.b = clamp(0, parseInt(o.b), 255);
|
||||||
|
o.a = clamp(0, o.a, 1);
|
||||||
|
return o;
|
||||||
|
};
|
||||||
|
|
||||||
|
o.clone = function () {
|
||||||
|
return $.color.make(o.r, o.b, o.g, o.a);
|
||||||
|
};
|
||||||
|
|
||||||
|
return o.normalize();
|
||||||
|
}
|
||||||
|
|
||||||
|
// extract CSS color property from element, going up in the DOM
|
||||||
|
// if it's "transparent"
|
||||||
|
$.color.extract = function (elem, css) {
|
||||||
|
var c;
|
||||||
|
|
||||||
|
do {
|
||||||
|
c = elem.css(css).toLowerCase();
|
||||||
|
// keep going until we find an element that has color, or
|
||||||
|
// we hit the body or root (have no parent)
|
||||||
|
if (c !== '' && c !== 'transparent') {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
elem = elem.parent();
|
||||||
|
} while (elem.length && !$.nodeName(elem.get(0), "body"));
|
||||||
|
|
||||||
|
// catch Safari's way of signalling transparent
|
||||||
|
if (c === "rgba(0, 0, 0, 0)") {
|
||||||
|
c = "transparent";
|
||||||
|
}
|
||||||
|
|
||||||
|
return $.color.parse(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
// parse CSS color string (like "rgb(10, 32, 43)" or "#fff"),
|
||||||
|
// returns color object, if parsing failed, you get black (0, 0,
|
||||||
|
// 0) out
|
||||||
|
$.color.parse = function (str) {
|
||||||
|
var res, m = $.color.make;
|
||||||
|
|
||||||
|
// Look for rgb(num,num,num)
|
||||||
|
res = /rgb\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*\)/.exec(str);
|
||||||
|
if (res) {
|
||||||
|
return m(parseInt(res[1], 10), parseInt(res[2], 10), parseInt(res[3], 10));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Look for rgba(num,num,num,num)
|
||||||
|
res = /rgba\(\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]{1,3})\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str)
|
||||||
|
if (res) {
|
||||||
|
return m(parseInt(res[1], 10), parseInt(res[2], 10), parseInt(res[3], 10), parseFloat(res[4]));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Look for rgb(num%,num%,num%)
|
||||||
|
res = /rgb\(\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)%\s*\)/.exec(str);
|
||||||
|
if (res) {
|
||||||
|
return m(parseFloat(res[1]) * 2.55, parseFloat(res[2]) * 2.55, parseFloat(res[3]) * 2.55);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Look for rgba(num%,num%,num%,num)
|
||||||
|
res = /rgba\(\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)%\s*,\s*([0-9]+(?:\.[0-9]+)?)\s*\)/.exec(str);
|
||||||
|
if (res) {
|
||||||
|
return m(parseFloat(res[1]) * 2.55, parseFloat(res[2]) * 2.55, parseFloat(res[3]) * 2.55, parseFloat(res[4]));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Look for #a0b1c2
|
||||||
|
res = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(str);
|
||||||
|
if (res) {
|
||||||
|
return m(parseInt(res[1], 16), parseInt(res[2], 16), parseInt(res[3], 16));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Look for #fff
|
||||||
|
res = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(str);
|
||||||
|
if (res) {
|
||||||
|
return m(parseInt(res[1] + res[1], 16), parseInt(res[2] + res[2], 16), parseInt(res[3] + res[3], 16));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Otherwise, we're most likely dealing with a named color
|
||||||
|
var name = $.trim(str).toLowerCase();
|
||||||
|
if (name === "transparent") {
|
||||||
|
return m(255, 255, 255, 0);
|
||||||
|
} else {
|
||||||
|
// default to black
|
||||||
|
res = lookupColors[name] || [0, 0, 0];
|
||||||
|
return m(res[0], res[1], res[2]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var lookupColors = {
|
||||||
|
aqua: [0, 255, 255],
|
||||||
|
azure: [240, 255, 255],
|
||||||
|
beige: [245, 245, 220],
|
||||||
|
black: [0, 0, 0],
|
||||||
|
blue: [0, 0, 255],
|
||||||
|
brown: [165, 42, 42],
|
||||||
|
cyan: [0, 255, 255],
|
||||||
|
darkblue: [0, 0, 139],
|
||||||
|
darkcyan: [0, 139, 139],
|
||||||
|
darkgrey: [169, 169, 169],
|
||||||
|
darkgreen: [0, 100, 0],
|
||||||
|
darkkhaki: [189, 183, 107],
|
||||||
|
darkmagenta: [139, 0, 139],
|
||||||
|
darkolivegreen: [85, 107, 47],
|
||||||
|
darkorange: [255, 140, 0],
|
||||||
|
darkorchid: [153, 50, 204],
|
||||||
|
darkred: [139, 0, 0],
|
||||||
|
darksalmon: [233, 150, 122],
|
||||||
|
darkviolet: [148, 0, 211],
|
||||||
|
fuchsia: [255, 0, 255],
|
||||||
|
gold: [255, 215, 0],
|
||||||
|
green: [0, 128, 0],
|
||||||
|
indigo: [75, 0, 130],
|
||||||
|
khaki: [240, 230, 140],
|
||||||
|
lightblue: [173, 216, 230],
|
||||||
|
lightcyan: [224, 255, 255],
|
||||||
|
lightgreen: [144, 238, 144],
|
||||||
|
lightgrey: [211, 211, 211],
|
||||||
|
lightpink: [255, 182, 193],
|
||||||
|
lightyellow: [255, 255, 224],
|
||||||
|
lime: [0, 255, 0],
|
||||||
|
magenta: [255, 0, 255],
|
||||||
|
maroon: [128, 0, 0],
|
||||||
|
navy: [0, 0, 128],
|
||||||
|
olive: [128, 128, 0],
|
||||||
|
orange: [255, 165, 0],
|
||||||
|
pink: [255, 192, 203],
|
||||||
|
purple: [128, 0, 128],
|
||||||
|
violet: [128, 0, 128],
|
||||||
|
red: [255, 0, 0],
|
||||||
|
silver: [192, 192, 192],
|
||||||
|
white: [255, 255, 255],
|
||||||
|
yellow: [255, 255, 0]
|
||||||
|
};
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,212 @@
|
||||||
|
/*
|
||||||
|
Axis label plugin for flot
|
||||||
|
|
||||||
|
Derived from:
|
||||||
|
Axis Labels Plugin for flot.
|
||||||
|
http://github.com/markrcote/flot-axislabels
|
||||||
|
|
||||||
|
Original code is Copyright (c) 2010 Xuan Luo.
|
||||||
|
Original code was released under the GPLv3 license by Xuan Luo, September 2010.
|
||||||
|
Original code was rereleased under the MIT license by Xuan Luo, April 2012.
|
||||||
|
|
||||||
|
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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
"use strict";
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
axisLabels: {
|
||||||
|
show: true
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function AxisLabel(axisName, position, padding, placeholder, axisLabel, surface) {
|
||||||
|
this.axisName = axisName;
|
||||||
|
this.position = position;
|
||||||
|
this.padding = padding;
|
||||||
|
this.placeholder = placeholder;
|
||||||
|
this.axisLabel = axisLabel;
|
||||||
|
this.surface = surface;
|
||||||
|
this.width = 0;
|
||||||
|
this.height = 0;
|
||||||
|
this.elem = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
AxisLabel.prototype.calculateSize = function() {
|
||||||
|
var axisId = this.axisName + 'Label',
|
||||||
|
layerId = axisId + 'Layer',
|
||||||
|
className = axisId + ' axisLabels';
|
||||||
|
|
||||||
|
var info = this.surface.getTextInfo(layerId, this.axisLabel, className);
|
||||||
|
this.labelWidth = info.width;
|
||||||
|
this.labelHeight = info.height;
|
||||||
|
|
||||||
|
if (this.position === 'left' || this.position === 'right') {
|
||||||
|
this.width = this.labelHeight + this.padding;
|
||||||
|
this.height = 0;
|
||||||
|
} else {
|
||||||
|
this.width = 0;
|
||||||
|
this.height = this.labelHeight + this.padding;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
AxisLabel.prototype.transforms = function(degrees, x, y, svgLayer) {
|
||||||
|
var transforms = [], translate, rotate;
|
||||||
|
if (x !== 0 || y !== 0) {
|
||||||
|
translate = svgLayer.createSVGTransform();
|
||||||
|
translate.setTranslate(x, y);
|
||||||
|
transforms.push(translate);
|
||||||
|
}
|
||||||
|
if (degrees !== 0) {
|
||||||
|
rotate = svgLayer.createSVGTransform();
|
||||||
|
var centerX = Math.round(this.labelWidth / 2),
|
||||||
|
centerY = 0;
|
||||||
|
rotate.setRotate(degrees, centerX, centerY);
|
||||||
|
transforms.push(rotate);
|
||||||
|
}
|
||||||
|
|
||||||
|
return transforms;
|
||||||
|
};
|
||||||
|
|
||||||
|
AxisLabel.prototype.calculateOffsets = function(box) {
|
||||||
|
var offsets = {
|
||||||
|
x: 0,
|
||||||
|
y: 0,
|
||||||
|
degrees: 0
|
||||||
|
};
|
||||||
|
if (this.position === 'bottom') {
|
||||||
|
offsets.x = box.left + box.width / 2 - this.labelWidth / 2;
|
||||||
|
offsets.y = box.top + box.height - this.labelHeight;
|
||||||
|
} else if (this.position === 'top') {
|
||||||
|
offsets.x = box.left + box.width / 2 - this.labelWidth / 2;
|
||||||
|
offsets.y = box.top;
|
||||||
|
} else if (this.position === 'left') {
|
||||||
|
offsets.degrees = -90;
|
||||||
|
offsets.x = box.left - this.labelWidth / 2;
|
||||||
|
offsets.y = box.height / 2 + box.top;
|
||||||
|
} else if (this.position === 'right') {
|
||||||
|
offsets.degrees = 90;
|
||||||
|
offsets.x = box.left + box.width - this.labelWidth / 2;
|
||||||
|
offsets.y = box.height / 2 + box.top;
|
||||||
|
}
|
||||||
|
offsets.x = Math.round(offsets.x);
|
||||||
|
offsets.y = Math.round(offsets.y);
|
||||||
|
|
||||||
|
return offsets;
|
||||||
|
};
|
||||||
|
|
||||||
|
AxisLabel.prototype.cleanup = function() {
|
||||||
|
var axisId = this.axisName + 'Label',
|
||||||
|
layerId = axisId + 'Layer',
|
||||||
|
className = axisId + ' axisLabels';
|
||||||
|
this.surface.removeText(layerId, 0, 0, this.axisLabel, className);
|
||||||
|
};
|
||||||
|
|
||||||
|
AxisLabel.prototype.draw = function(box) {
|
||||||
|
var axisId = this.axisName + 'Label',
|
||||||
|
layerId = axisId + 'Layer',
|
||||||
|
className = axisId + ' axisLabels',
|
||||||
|
offsets = this.calculateOffsets(box),
|
||||||
|
style = {
|
||||||
|
position: 'absolute',
|
||||||
|
bottom: '',
|
||||||
|
right: '',
|
||||||
|
display: 'inline-block',
|
||||||
|
'white-space': 'nowrap'
|
||||||
|
};
|
||||||
|
|
||||||
|
var layer = this.surface.getSVGLayer(layerId);
|
||||||
|
var transforms = this.transforms(offsets.degrees, offsets.x, offsets.y, layer.parentNode);
|
||||||
|
|
||||||
|
this.surface.addText(layerId, 0, 0, this.axisLabel, className, undefined, undefined, undefined, undefined, transforms);
|
||||||
|
this.surface.render();
|
||||||
|
Object.keys(style).forEach(function(key) {
|
||||||
|
layer.style[key] = style[key];
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processOptions.push(function(plot, options) {
|
||||||
|
if (!options.axisLabels.show) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var axisLabels = {};
|
||||||
|
var defaultPadding = 2; // padding between axis and tick labels
|
||||||
|
|
||||||
|
plot.hooks.axisReserveSpace.push(function(plot, axis) {
|
||||||
|
var opts = axis.options;
|
||||||
|
var axisName = axis.direction + axis.n;
|
||||||
|
|
||||||
|
axis.labelHeight += axis.boxPosition.centerY;
|
||||||
|
axis.labelWidth += axis.boxPosition.centerX;
|
||||||
|
|
||||||
|
if (!opts || !opts.axisLabel || !axis.show) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var padding = opts.axisLabelPadding === undefined
|
||||||
|
? defaultPadding
|
||||||
|
: opts.axisLabelPadding;
|
||||||
|
|
||||||
|
var axisLabel = axisLabels[axisName];
|
||||||
|
if (!axisLabel) {
|
||||||
|
axisLabel = new AxisLabel(axisName,
|
||||||
|
opts.position, padding,
|
||||||
|
plot.getPlaceholder()[0], opts.axisLabel, plot.getSurface());
|
||||||
|
axisLabels[axisName] = axisLabel;
|
||||||
|
}
|
||||||
|
|
||||||
|
axisLabel.calculateSize();
|
||||||
|
|
||||||
|
// Incrementing the sizes of the tick labels.
|
||||||
|
axis.labelHeight += axisLabel.height;
|
||||||
|
axis.labelWidth += axisLabel.width;
|
||||||
|
});
|
||||||
|
|
||||||
|
// TODO - use the drawAxis hook
|
||||||
|
plot.hooks.draw.push(function(plot, ctx) {
|
||||||
|
$.each(plot.getAxes(), function(flotAxisName, axis) {
|
||||||
|
var opts = axis.options;
|
||||||
|
if (!opts || !opts.axisLabel || !axis.show) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var axisName = axis.direction + axis.n;
|
||||||
|
axisLabels[axisName].draw(axis.box);
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.shutdown.push(function(plot, eventHolder) {
|
||||||
|
for (var axisName in axisLabels) {
|
||||||
|
axisLabels[axisName].cleanup();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'axisLabels',
|
||||||
|
version: '3.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,98 @@
|
||||||
|
/** ## jquery.flot.browser.js
|
||||||
|
|
||||||
|
This plugin is used to make available some browser-related utility functions.
|
||||||
|
|
||||||
|
### Methods
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var browser = {
|
||||||
|
/**
|
||||||
|
- getPageXY(e)
|
||||||
|
|
||||||
|
Calculates the pageX and pageY using the screenX, screenY properties of the event
|
||||||
|
and the scrolling of the page. This is needed because the pageX and pageY
|
||||||
|
properties of the event are not correct while running tests in Edge. */
|
||||||
|
getPageXY: function (e) {
|
||||||
|
// This code is inspired from https://stackoverflow.com/a/3464890
|
||||||
|
var doc = document.documentElement,
|
||||||
|
pageX = e.clientX + (window.pageXOffset || doc.scrollLeft) - (doc.clientLeft || 0),
|
||||||
|
pageY = e.clientY + (window.pageYOffset || doc.scrollTop) - (doc.clientTop || 0);
|
||||||
|
return { X: pageX, Y: pageY };
|
||||||
|
},
|
||||||
|
|
||||||
|
/**
|
||||||
|
- getPixelRatio(context)
|
||||||
|
|
||||||
|
This function returns the current pixel ratio defined by the product of desktop
|
||||||
|
zoom and page zoom.
|
||||||
|
Additional info: https://www.html5rocks.com/en/tutorials/canvas/hidpi/
|
||||||
|
*/
|
||||||
|
getPixelRatio: function(context) {
|
||||||
|
var devicePixelRatio = window.devicePixelRatio || 1,
|
||||||
|
backingStoreRatio =
|
||||||
|
context.webkitBackingStorePixelRatio ||
|
||||||
|
context.mozBackingStorePixelRatio ||
|
||||||
|
context.msBackingStorePixelRatio ||
|
||||||
|
context.oBackingStorePixelRatio ||
|
||||||
|
context.backingStorePixelRatio || 1;
|
||||||
|
return devicePixelRatio / backingStoreRatio;
|
||||||
|
},
|
||||||
|
|
||||||
|
/**
|
||||||
|
- isSafari, isMobileSafari, isOpera, isFirefox, isIE, isEdge, isChrome, isBlink
|
||||||
|
|
||||||
|
This is a collection of functions, used to check if the code is running in a
|
||||||
|
particular browser or Javascript engine.
|
||||||
|
*/
|
||||||
|
isSafari: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
// Safari 3.0+ "[object HTMLElementConstructor]"
|
||||||
|
return /constructor/i.test(window.top.HTMLElement) || (function (p) { return p.toString() === "[object SafariRemoteNotification]"; })(!window.top['safari'] || (typeof window.top.safari !== 'undefined' && window.top.safari.pushNotification));
|
||||||
|
},
|
||||||
|
|
||||||
|
isMobileSafari: function() {
|
||||||
|
//isMobileSafari adapted from https://stackoverflow.com/questions/3007480/determine-if-user-navigated-from-mobile-safari
|
||||||
|
return navigator.userAgent.match(/(iPod|iPhone|iPad)/) && navigator.userAgent.match(/AppleWebKit/);
|
||||||
|
},
|
||||||
|
|
||||||
|
isOpera: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
//Opera 8.0+
|
||||||
|
return (!!window.opr && !!opr.addons) || !!window.opera || navigator.userAgent.indexOf(' OPR/') >= 0;
|
||||||
|
},
|
||||||
|
|
||||||
|
isFirefox: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
// Firefox 1.0+
|
||||||
|
return typeof InstallTrigger !== 'undefined';
|
||||||
|
},
|
||||||
|
|
||||||
|
isIE: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
// Internet Explorer 6-11
|
||||||
|
return /*@cc_on!@*/false || !!document.documentMode;
|
||||||
|
},
|
||||||
|
|
||||||
|
isEdge: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
// Edge 20+
|
||||||
|
return !browser.isIE() && !!window.StyleMedia;
|
||||||
|
},
|
||||||
|
|
||||||
|
isChrome: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
// Chrome 1+
|
||||||
|
return !!window.chrome && !!window.chrome.webstore;
|
||||||
|
},
|
||||||
|
|
||||||
|
isBlink: function() {
|
||||||
|
// *** https://stackoverflow.com/questions/9847580/how-to-detect-safari-chrome-ie-firefox-and-opera-browser
|
||||||
|
return (browser.isChrome() || browser.isOpera()) && !!window.CSS;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
$.plot.browser = browser;
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,345 @@
|
||||||
|
/* Flot plugin for drawing all elements of a plot on the canvas.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
Flot normally produces certain elements, like axis labels and the legend, using
|
||||||
|
HTML elements. This permits greater interactivity and customization, and often
|
||||||
|
looks better, due to cross-browser canvas text inconsistencies and limitations.
|
||||||
|
|
||||||
|
It can also be desirable to render the plot entirely in canvas, particularly
|
||||||
|
if the goal is to save it as an image, or if Flot is being used in a context
|
||||||
|
where the HTML DOM does not exist, as is the case within Node.js. This plugin
|
||||||
|
switches out Flot's standard drawing operations for canvas-only replacements.
|
||||||
|
|
||||||
|
Currently the plugin supports only axis labels, but it will eventually allow
|
||||||
|
every element of the plot to be rendered directly to canvas.
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
{
|
||||||
|
canvas: boolean
|
||||||
|
}
|
||||||
|
|
||||||
|
The "canvas" option controls whether full canvas drawing is enabled, making it
|
||||||
|
possible to toggle on and off. This is useful when a plot uses HTML text in the
|
||||||
|
browser, but needs to redraw with canvas text when exporting as an image.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
canvas: true
|
||||||
|
};
|
||||||
|
|
||||||
|
var render, getTextInfo, addText;
|
||||||
|
|
||||||
|
// Cache the prototype hasOwnProperty for faster access
|
||||||
|
|
||||||
|
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||||||
|
|
||||||
|
function init(plot, classes) {
|
||||||
|
|
||||||
|
var Canvas = classes.Canvas;
|
||||||
|
|
||||||
|
// We only want to replace the functions once; the second time around
|
||||||
|
// we would just get our new function back. This whole replacing of
|
||||||
|
// prototype functions is a disaster, and needs to be changed ASAP.
|
||||||
|
|
||||||
|
if (render == null) {
|
||||||
|
getTextInfo = Canvas.prototype.getTextInfo,
|
||||||
|
addText = Canvas.prototype.addText,
|
||||||
|
render = Canvas.prototype.render;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Finishes rendering the canvas, including overlaid text
|
||||||
|
|
||||||
|
Canvas.prototype.render = function() {
|
||||||
|
|
||||||
|
if (!plot.getOptions().canvas) {
|
||||||
|
return render.call(this);
|
||||||
|
}
|
||||||
|
|
||||||
|
var context = this.context,
|
||||||
|
cache = this._textCache;
|
||||||
|
|
||||||
|
// For each text layer, render elements marked as active
|
||||||
|
|
||||||
|
context.save();
|
||||||
|
context.textBaseline = "middle";
|
||||||
|
|
||||||
|
for (var layerKey in cache) {
|
||||||
|
if (hasOwnProperty.call(cache, layerKey)) {
|
||||||
|
var layerCache = cache[layerKey];
|
||||||
|
for (var styleKey in layerCache) {
|
||||||
|
if (hasOwnProperty.call(layerCache, styleKey)) {
|
||||||
|
var styleCache = layerCache[styleKey],
|
||||||
|
updateStyles = true;
|
||||||
|
for (var key in styleCache) {
|
||||||
|
if (hasOwnProperty.call(styleCache, key)) {
|
||||||
|
|
||||||
|
var info = styleCache[key],
|
||||||
|
positions = info.positions,
|
||||||
|
lines = info.lines;
|
||||||
|
|
||||||
|
// Since every element at this level of the cache have the
|
||||||
|
// same font and fill styles, we can just change them once
|
||||||
|
// using the values from the first element.
|
||||||
|
|
||||||
|
if (updateStyles) {
|
||||||
|
context.fillStyle = info.font.color;
|
||||||
|
context.font = info.font.definition;
|
||||||
|
updateStyles = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var i = 0, position; position = positions[i]; i++) {
|
||||||
|
if (position.active) {
|
||||||
|
for (var j = 0, line; line = position.lines[j]; j++) {
|
||||||
|
context.fillText(lines[j].text, line[0], line[1]);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
positions.splice(i--, 1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (positions.length == 0) {
|
||||||
|
delete styleCache[key];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
context.restore();
|
||||||
|
};
|
||||||
|
|
||||||
|
// Creates (if necessary) and returns a text info object.
|
||||||
|
//
|
||||||
|
// When the canvas option is set, the object looks like this:
|
||||||
|
//
|
||||||
|
// {
|
||||||
|
// width: Width of the text's bounding box.
|
||||||
|
// height: Height of the text's bounding box.
|
||||||
|
// positions: Array of positions at which this text is drawn.
|
||||||
|
// lines: [{
|
||||||
|
// height: Height of this line.
|
||||||
|
// widths: Width of this line.
|
||||||
|
// text: Text on this line.
|
||||||
|
// }],
|
||||||
|
// font: {
|
||||||
|
// definition: Canvas font property string.
|
||||||
|
// color: Color of the text.
|
||||||
|
// },
|
||||||
|
// }
|
||||||
|
//
|
||||||
|
// The positions array contains objects that look like this:
|
||||||
|
//
|
||||||
|
// {
|
||||||
|
// active: Flag indicating whether the text should be visible.
|
||||||
|
// lines: Array of [x, y] coordinates at which to draw the line.
|
||||||
|
// x: X coordinate at which to draw the text.
|
||||||
|
// y: Y coordinate at which to draw the text.
|
||||||
|
// }
|
||||||
|
|
||||||
|
Canvas.prototype.getTextInfo = function(layer, text, font, angle, width) {
|
||||||
|
|
||||||
|
if (!plot.getOptions().canvas) {
|
||||||
|
return getTextInfo.call(this, layer, text, font, angle, width);
|
||||||
|
}
|
||||||
|
|
||||||
|
var textStyle, layerCache, styleCache, info;
|
||||||
|
|
||||||
|
// Cast the value to a string, in case we were given a number
|
||||||
|
|
||||||
|
text = "" + text;
|
||||||
|
|
||||||
|
// If the font is a font-spec object, generate a CSS definition
|
||||||
|
|
||||||
|
if (typeof font === "object") {
|
||||||
|
textStyle = font.style + " " + font.variant + " " + font.weight + " " + font.size + "px " + font.family;
|
||||||
|
} else {
|
||||||
|
textStyle = font;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Retrieve (or create) the cache for the text's layer and styles
|
||||||
|
|
||||||
|
layerCache = this._textCache[layer];
|
||||||
|
|
||||||
|
if (layerCache == null) {
|
||||||
|
layerCache = this._textCache[layer] = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
styleCache = layerCache[textStyle];
|
||||||
|
|
||||||
|
if (styleCache == null) {
|
||||||
|
styleCache = layerCache[textStyle] = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
info = styleCache[text];
|
||||||
|
|
||||||
|
if (info == null) {
|
||||||
|
|
||||||
|
var context = this.context;
|
||||||
|
|
||||||
|
// If the font was provided as CSS, create a div with those
|
||||||
|
// classes and examine it to generate a canvas font spec.
|
||||||
|
|
||||||
|
if (typeof font !== "object") {
|
||||||
|
|
||||||
|
var element = $("<div> </div>")
|
||||||
|
.css("position", "absolute")
|
||||||
|
.addClass(typeof font === "string" ? font : null)
|
||||||
|
.appendTo(this.getTextLayer(layer));
|
||||||
|
|
||||||
|
font = {
|
||||||
|
lineHeight: element.height(),
|
||||||
|
style: element.css("font-style"),
|
||||||
|
variant: element.css("font-variant"),
|
||||||
|
weight: element.css("font-weight"),
|
||||||
|
family: element.css("font-family"),
|
||||||
|
color: element.css("color")
|
||||||
|
};
|
||||||
|
|
||||||
|
// Setting line-height to 1, without units, sets it equal
|
||||||
|
// to the font-size, even if the font-size is abstract,
|
||||||
|
// like 'smaller'. This enables us to read the real size
|
||||||
|
// via the element's height, working around browsers that
|
||||||
|
// return the literal 'smaller' value.
|
||||||
|
|
||||||
|
font.size = element.css("line-height", 1).height();
|
||||||
|
|
||||||
|
element.remove();
|
||||||
|
}
|
||||||
|
|
||||||
|
textStyle = font.style + " " + font.variant + " " + font.weight + " " + font.size + "px " + font.family;
|
||||||
|
|
||||||
|
// Create a new info object, initializing the dimensions to
|
||||||
|
// zero so we can count them up line-by-line.
|
||||||
|
|
||||||
|
info = styleCache[text] = {
|
||||||
|
width: 0,
|
||||||
|
height: 0,
|
||||||
|
positions: [],
|
||||||
|
lines: [],
|
||||||
|
font: {
|
||||||
|
definition: textStyle,
|
||||||
|
color: font.color
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
context.save();
|
||||||
|
context.font = textStyle;
|
||||||
|
|
||||||
|
// Canvas can't handle multi-line strings; break on various
|
||||||
|
// newlines, including HTML brs, to build a list of lines.
|
||||||
|
// Note that we could split directly on regexps, but IE < 9 is
|
||||||
|
// broken; revisit when we drop IE 7/8 support.
|
||||||
|
|
||||||
|
var lines = (text + "").replace(/<br ?\/?>|\r\n|\r/g, "\n").split("\n");
|
||||||
|
|
||||||
|
for (var i = 0; i < lines.length; ++i) {
|
||||||
|
|
||||||
|
var lineText = lines[i],
|
||||||
|
measured = context.measureText(lineText);
|
||||||
|
|
||||||
|
info.width = Math.max(measured.width, info.width);
|
||||||
|
info.height += font.lineHeight;
|
||||||
|
|
||||||
|
info.lines.push({
|
||||||
|
text: lineText,
|
||||||
|
width: measured.width,
|
||||||
|
height: font.lineHeight
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
context.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
return info;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Adds a text string to the canvas text overlay.
|
||||||
|
|
||||||
|
Canvas.prototype.addText = function(layer, x, y, text, font, angle, width, halign, valign) {
|
||||||
|
|
||||||
|
if (!plot.getOptions().canvas) {
|
||||||
|
return addText.call(this, layer, x, y, text, font, angle, width, halign, valign);
|
||||||
|
}
|
||||||
|
|
||||||
|
var info = this.getTextInfo(layer, text, font, angle, width),
|
||||||
|
positions = info.positions,
|
||||||
|
lines = info.lines;
|
||||||
|
|
||||||
|
// Text is drawn with baseline 'middle', which we need to account
|
||||||
|
// for by adding half a line's height to the y position.
|
||||||
|
|
||||||
|
y += info.height / lines.length / 2;
|
||||||
|
|
||||||
|
// Tweak the initial y-position to match vertical alignment
|
||||||
|
|
||||||
|
if (valign == "middle") {
|
||||||
|
y = Math.round(y - info.height / 2);
|
||||||
|
} else if (valign == "bottom") {
|
||||||
|
y = Math.round(y - info.height);
|
||||||
|
} else {
|
||||||
|
y = Math.round(y);
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME: LEGACY BROWSER FIX
|
||||||
|
// AFFECTS: Opera < 12.00
|
||||||
|
|
||||||
|
// Offset the y coordinate, since Opera is off pretty
|
||||||
|
// consistently compared to the other browsers.
|
||||||
|
|
||||||
|
if (!!(window.opera && window.opera.version().split(".")[0] < 12)) {
|
||||||
|
y -= 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine whether this text already exists at this position.
|
||||||
|
// If so, mark it for inclusion in the next render pass.
|
||||||
|
|
||||||
|
for (var i = 0, position; position = positions[i]; i++) {
|
||||||
|
if (position.x == x && position.y == y) {
|
||||||
|
position.active = true;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the text doesn't exist at this position, create a new entry
|
||||||
|
|
||||||
|
position = {
|
||||||
|
active: true,
|
||||||
|
lines: [],
|
||||||
|
x: x,
|
||||||
|
y: y
|
||||||
|
};
|
||||||
|
|
||||||
|
positions.push(position);
|
||||||
|
|
||||||
|
// Fill in the x & y positions of each line, adjusting them
|
||||||
|
// individually for horizontal alignment.
|
||||||
|
|
||||||
|
for (var i = 0, line; line = lines[i]; i++) {
|
||||||
|
if (halign == "center") {
|
||||||
|
position.lines.push([Math.round(x - line.width / 2), y]);
|
||||||
|
} else if (halign == "right") {
|
||||||
|
position.lines.push([Math.round(x - line.width), y]);
|
||||||
|
} else {
|
||||||
|
position.lines.push([Math.round(x), y]);
|
||||||
|
}
|
||||||
|
y += line.height;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: "canvas",
|
||||||
|
version: "1.0"
|
||||||
|
});
|
||||||
|
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,202 @@
|
||||||
|
/* Flot plugin for plotting textual data or categories.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
Consider a dataset like [["February", 34], ["March", 20], ...]. This plugin
|
||||||
|
allows you to plot such a dataset directly.
|
||||||
|
|
||||||
|
To enable it, you must specify mode: "categories" on the axis with the textual
|
||||||
|
labels, e.g.
|
||||||
|
|
||||||
|
$.plot("#placeholder", data, { xaxis: { mode: "categories" } });
|
||||||
|
|
||||||
|
By default, the labels are ordered as they are met in the data series. If you
|
||||||
|
need a different ordering, you can specify "categories" on the axis options
|
||||||
|
and list the categories there:
|
||||||
|
|
||||||
|
xaxis: {
|
||||||
|
mode: "categories",
|
||||||
|
categories: ["February", "March", "April"]
|
||||||
|
}
|
||||||
|
|
||||||
|
If you need to customize the distances between the categories, you can specify
|
||||||
|
"categories" as an object mapping labels to values
|
||||||
|
|
||||||
|
xaxis: {
|
||||||
|
mode: "categories",
|
||||||
|
categories: { "February": 1, "March": 3, "April": 4 }
|
||||||
|
}
|
||||||
|
|
||||||
|
If you don't specify all categories, the remaining categories will be numbered
|
||||||
|
from the max value plus 1 (with a spacing of 1 between each).
|
||||||
|
|
||||||
|
Internally, the plugin works by transforming the input data through an auto-
|
||||||
|
generated mapping where the first category becomes 0, the second 1, etc.
|
||||||
|
Hence, a point like ["February", 34] becomes [0, 34] internally in Flot (this
|
||||||
|
is visible in hover and click events that return numbers rather than the
|
||||||
|
category labels). The plugin also overrides the tick generator to spit out the
|
||||||
|
categories as ticks instead of the values.
|
||||||
|
|
||||||
|
If you need to map a value back to its label, the mapping is always accessible
|
||||||
|
as "categories" on the axis object, e.g. plot.getAxes().xaxis.categories.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
xaxis: {
|
||||||
|
categories: null
|
||||||
|
},
|
||||||
|
yaxis: {
|
||||||
|
categories: null
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function processRawData(plot, series, data, datapoints) {
|
||||||
|
// if categories are enabled, we need to disable
|
||||||
|
// auto-transformation to numbers so the strings are intact
|
||||||
|
// for later processing
|
||||||
|
|
||||||
|
var xCategories = series.xaxis.options.mode === "categories",
|
||||||
|
yCategories = series.yaxis.options.mode === "categories";
|
||||||
|
|
||||||
|
if (!(xCategories || yCategories)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var format = datapoints.format;
|
||||||
|
|
||||||
|
if (!format) {
|
||||||
|
// FIXME: auto-detection should really not be defined here
|
||||||
|
var s = series;
|
||||||
|
format = [];
|
||||||
|
format.push({ x: true, number: true, required: true, computeRange: true});
|
||||||
|
format.push({ y: true, number: true, required: true, computeRange: true });
|
||||||
|
|
||||||
|
if (s.bars.show || (s.lines.show && s.lines.fill)) {
|
||||||
|
var autoScale = !!((s.bars.show && s.bars.zero) || (s.lines.show && s.lines.zero));
|
||||||
|
format.push({ y: true, number: true, required: false, defaultValue: 0, computeRange: autoScale });
|
||||||
|
if (s.bars.horizontal) {
|
||||||
|
delete format[format.length - 1].y;
|
||||||
|
format[format.length - 1].x = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
datapoints.format = format;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var m = 0; m < format.length; ++m) {
|
||||||
|
if (format[m].x && xCategories) {
|
||||||
|
format[m].number = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (format[m].y && yCategories) {
|
||||||
|
format[m].number = false;
|
||||||
|
format[m].computeRange = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function getNextIndex(categories) {
|
||||||
|
var index = -1;
|
||||||
|
|
||||||
|
for (var v in categories) {
|
||||||
|
if (categories[v] > index) {
|
||||||
|
index = categories[v];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return index + 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
function categoriesTickGenerator(axis) {
|
||||||
|
var res = [];
|
||||||
|
for (var label in axis.categories) {
|
||||||
|
var v = axis.categories[label];
|
||||||
|
if (v >= axis.min && v <= axis.max) {
|
||||||
|
res.push([v, label]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
res.sort(function (a, b) { return a[0] - b[0]; });
|
||||||
|
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
function setupCategoriesForAxis(series, axis, datapoints) {
|
||||||
|
if (series[axis].options.mode !== "categories") {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!series[axis].categories) {
|
||||||
|
// parse options
|
||||||
|
var c = {}, o = series[axis].options.categories || {};
|
||||||
|
if ($.isArray(o)) {
|
||||||
|
for (var i = 0; i < o.length; ++i) {
|
||||||
|
c[o[i]] = i;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
for (var v in o) {
|
||||||
|
c[v] = o[v];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
series[axis].categories = c;
|
||||||
|
}
|
||||||
|
|
||||||
|
// fix ticks
|
||||||
|
if (!series[axis].options.ticks) {
|
||||||
|
series[axis].options.ticks = categoriesTickGenerator;
|
||||||
|
}
|
||||||
|
|
||||||
|
transformPointsOnAxis(datapoints, axis, series[axis].categories);
|
||||||
|
}
|
||||||
|
|
||||||
|
function transformPointsOnAxis(datapoints, axis, categories) {
|
||||||
|
// go through the points, transforming them
|
||||||
|
var points = datapoints.points,
|
||||||
|
ps = datapoints.pointsize,
|
||||||
|
format = datapoints.format,
|
||||||
|
formatColumn = axis.charAt(0),
|
||||||
|
index = getNextIndex(categories);
|
||||||
|
|
||||||
|
for (var i = 0; i < points.length; i += ps) {
|
||||||
|
if (points[i] == null) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var m = 0; m < ps; ++m) {
|
||||||
|
var val = points[i + m];
|
||||||
|
|
||||||
|
if (val == null || !format[m][formatColumn]) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!(val in categories)) {
|
||||||
|
categories[val] = index;
|
||||||
|
++index;
|
||||||
|
}
|
||||||
|
|
||||||
|
points[i + m] = categories[val];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function processDatapoints(plot, series, datapoints) {
|
||||||
|
setupCategoriesForAxis(series, "xaxis", datapoints);
|
||||||
|
setupCategoriesForAxis(series, "yaxis", datapoints);
|
||||||
|
}
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processRawData.push(processRawData);
|
||||||
|
plot.hooks.processDatapoints.push(processDatapoints);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'categories',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,330 @@
|
||||||
|
/** ## jquery.flot.composeImages.js
|
||||||
|
|
||||||
|
This plugin is used to expose a function used to overlap several canvases and
|
||||||
|
SVGs, for the purpose of creating a snaphot out of them.
|
||||||
|
|
||||||
|
### When composeImages is used:
|
||||||
|
When multiple canvases and SVGs have to be overlapped into a single image
|
||||||
|
and their offset on the page, must be preserved.
|
||||||
|
|
||||||
|
### Where can be used:
|
||||||
|
In creating a downloadable snapshot of the plots, axes, cursors etc of a graph.
|
||||||
|
|
||||||
|
### How it works:
|
||||||
|
The entry point is composeImages function. It expects an array of objects,
|
||||||
|
which should be either canvases or SVGs (or a mix). It does a prevalidation
|
||||||
|
of them, by verifying if they will be usable or not, later in the flow.
|
||||||
|
After selecting only usable sources, it passes them to getGenerateTempImg
|
||||||
|
function, which generates temporary images out of them. This function
|
||||||
|
expects that some of the passed sources (canvas or SVG) may still have
|
||||||
|
problems being converted to an image and makes sure the promises system,
|
||||||
|
used by composeImages function, moves forward. As an example, SVGs with
|
||||||
|
missing information from header or with unsupported content, may lead to
|
||||||
|
failure in generating the temporary image. Temporary images are required
|
||||||
|
mostly on extracting content from SVGs, but this is also where the x/y
|
||||||
|
offsets are extracted for each image which will be added. For SVGs in
|
||||||
|
particular, their CSS rules have to be applied.
|
||||||
|
After all temporary images are generated, they are overlapped using
|
||||||
|
getExecuteImgComposition function. This is where the destination canvas
|
||||||
|
is set to the proper dimensions. It is then output by composeImages.
|
||||||
|
This function returns a promise, which can be used to wait for the whole
|
||||||
|
composition process. It requires to be asynchronous, because this is how
|
||||||
|
temporary images load their data.
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
"use strict";
|
||||||
|
const GENERALFAILURECALLBACKERROR = -100; //simply a negative number
|
||||||
|
const SUCCESSFULIMAGEPREPARATION = 0;
|
||||||
|
const EMPTYARRAYOFIMAGESOURCES = -1;
|
||||||
|
const NEGATIVEIMAGESIZE = -2;
|
||||||
|
var pixelRatio = 1;
|
||||||
|
var browser = $.plot.browser;
|
||||||
|
var getPixelRatio = browser.getPixelRatio;
|
||||||
|
|
||||||
|
function composeImages(canvasOrSvgSources, destinationCanvas) {
|
||||||
|
var validCanvasOrSvgSources = canvasOrSvgSources.filter(isValidSource);
|
||||||
|
pixelRatio = getPixelRatio(destinationCanvas.getContext('2d'));
|
||||||
|
|
||||||
|
var allImgCompositionPromises = validCanvasOrSvgSources.map(function(validCanvasOrSvgSource) {
|
||||||
|
var tempImg = new Image();
|
||||||
|
var currentPromise = new Promise(getGenerateTempImg(tempImg, validCanvasOrSvgSource));
|
||||||
|
return currentPromise;
|
||||||
|
});
|
||||||
|
|
||||||
|
var lastPromise = Promise.all(allImgCompositionPromises).then(getExecuteImgComposition(destinationCanvas), failureCallback);
|
||||||
|
return lastPromise;
|
||||||
|
}
|
||||||
|
|
||||||
|
function isValidSource(canvasOrSvgSource) {
|
||||||
|
var isValidFromCanvas = true;
|
||||||
|
var isValidFromContent = true;
|
||||||
|
if ((canvasOrSvgSource === null) || (canvasOrSvgSource === undefined)) {
|
||||||
|
isValidFromContent = false;
|
||||||
|
} else {
|
||||||
|
if (canvasOrSvgSource.tagName === 'CANVAS') {
|
||||||
|
if ((canvasOrSvgSource.getBoundingClientRect().right === canvasOrSvgSource.getBoundingClientRect().left) ||
|
||||||
|
(canvasOrSvgSource.getBoundingClientRect().bottom === canvasOrSvgSource.getBoundingClientRect().top)) {
|
||||||
|
isValidFromCanvas = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return isValidFromContent && isValidFromCanvas && (window.getComputedStyle(canvasOrSvgSource).visibility === 'visible');
|
||||||
|
}
|
||||||
|
|
||||||
|
function getGenerateTempImg(tempImg, canvasOrSvgSource) {
|
||||||
|
tempImg.sourceDescription = '<info className="' + canvasOrSvgSource.className + '" tagName="' + canvasOrSvgSource.tagName + '" id="' + canvasOrSvgSource.id + '">';
|
||||||
|
tempImg.sourceComponent = canvasOrSvgSource;
|
||||||
|
|
||||||
|
return function doGenerateTempImg(successCallbackFunc, failureCallbackFunc) {
|
||||||
|
tempImg.onload = function(evt) {
|
||||||
|
tempImg.successfullyLoaded = true;
|
||||||
|
successCallbackFunc(tempImg);
|
||||||
|
};
|
||||||
|
|
||||||
|
tempImg.onabort = function(evt) {
|
||||||
|
tempImg.successfullyLoaded = false;
|
||||||
|
console.log('Can\'t generate temp image from ' + tempImg.sourceDescription + '. It is possible that it is missing some properties or its content is not supported by this browser. Source component:', tempImg.sourceComponent);
|
||||||
|
successCallbackFunc(tempImg); //call successCallback, to allow snapshot of all working images
|
||||||
|
};
|
||||||
|
|
||||||
|
tempImg.onerror = function(evt) {
|
||||||
|
tempImg.successfullyLoaded = false;
|
||||||
|
console.log('Can\'t generate temp image from ' + tempImg.sourceDescription + '. It is possible that it is missing some properties or its content is not supported by this browser. Source component:', tempImg.sourceComponent);
|
||||||
|
successCallbackFunc(tempImg); //call successCallback, to allow snapshot of all working images
|
||||||
|
};
|
||||||
|
|
||||||
|
generateTempImageFromCanvasOrSvg(canvasOrSvgSource, tempImg);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function getExecuteImgComposition(destinationCanvas) {
|
||||||
|
return function executeImgComposition(tempImgs) {
|
||||||
|
var compositionResult = copyImgsToCanvas(tempImgs, destinationCanvas);
|
||||||
|
return compositionResult;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function copyCanvasToImg(canvas, img) {
|
||||||
|
img.src = canvas.toDataURL('image/png');
|
||||||
|
}
|
||||||
|
|
||||||
|
function getCSSRules(document) {
|
||||||
|
var styleSheets = document.styleSheets,
|
||||||
|
rulesList = [];
|
||||||
|
for (var i = 0; i < styleSheets.length; i++) {
|
||||||
|
// CORS requests for style sheets throw and an exception on Chrome > 64
|
||||||
|
try {
|
||||||
|
// in Chrome, the external CSS files are empty when the page is directly loaded from disk
|
||||||
|
var rules = styleSheets[i].cssRules || [];
|
||||||
|
for (var j = 0; j < rules.length; j++) {
|
||||||
|
var rule = rules[j];
|
||||||
|
rulesList.push(rule.cssText);
|
||||||
|
}
|
||||||
|
} catch (e) {
|
||||||
|
console.log('Failed to get some css rules');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return rulesList;
|
||||||
|
}
|
||||||
|
|
||||||
|
function embedCSSRulesInSVG(rules, svg) {
|
||||||
|
var text = [
|
||||||
|
'<svg class="snapshot ' + svg.classList + '" width="' + svg.width.baseVal.value * pixelRatio + '" height="' + svg.height.baseVal.value * pixelRatio + '" viewBox="0 0 ' + svg.width.baseVal.value + ' ' + svg.height.baseVal.value + '" xmlns="http://www.w3.org/2000/svg">',
|
||||||
|
'<style>',
|
||||||
|
'/* <![CDATA[ */',
|
||||||
|
rules.join('\n'),
|
||||||
|
'/* ]]> */',
|
||||||
|
'</style>',
|
||||||
|
svg.innerHTML,
|
||||||
|
'</svg>'
|
||||||
|
].join('\n');
|
||||||
|
return text;
|
||||||
|
}
|
||||||
|
|
||||||
|
function copySVGToImgMostBrowsers(svg, img) {
|
||||||
|
var rules = getCSSRules(document),
|
||||||
|
source = embedCSSRulesInSVG(rules, svg);
|
||||||
|
|
||||||
|
source = patchSVGSource(source);
|
||||||
|
|
||||||
|
var blob = new Blob([source], {type: "image/svg+xml;charset=utf-8"}),
|
||||||
|
domURL = self.URL || self.webkitURL || self,
|
||||||
|
url = domURL.createObjectURL(blob);
|
||||||
|
img.src = url;
|
||||||
|
}
|
||||||
|
|
||||||
|
function copySVGToImgSafari(svg, img) {
|
||||||
|
// Use this method to convert a string buffer array to a binary string.
|
||||||
|
// Do so by breaking up large strings into smaller substrings; this is necessary to avoid the
|
||||||
|
// "maximum call stack size exceeded" exception that can happen when calling 'String.fromCharCode.apply'
|
||||||
|
// with a very long array.
|
||||||
|
function buildBinaryString (arrayBuffer) {
|
||||||
|
var binaryString = "";
|
||||||
|
const utf8Array = new Uint8Array(arrayBuffer);
|
||||||
|
const blockSize = 16384;
|
||||||
|
for (var i = 0; i < utf8Array.length; i = i + blockSize) {
|
||||||
|
const binarySubString = String.fromCharCode.apply(null, utf8Array.subarray(i, i + blockSize));
|
||||||
|
binaryString = binaryString + binarySubString;
|
||||||
|
}
|
||||||
|
return binaryString;
|
||||||
|
};
|
||||||
|
|
||||||
|
var rules = getCSSRules(document),
|
||||||
|
source = embedCSSRulesInSVG(rules, svg),
|
||||||
|
data,
|
||||||
|
utf8BinaryString;
|
||||||
|
|
||||||
|
source = patchSVGSource(source);
|
||||||
|
|
||||||
|
// Encode the string as UTF-8 and convert it to a binary string. The UTF-8 encoding is required to
|
||||||
|
// capture unicode characters correctly.
|
||||||
|
utf8BinaryString = buildBinaryString(new (TextEncoder || TextEncoderLite)('utf-8').encode(source));
|
||||||
|
|
||||||
|
data = "data:image/svg+xml;base64," + btoa(utf8BinaryString);
|
||||||
|
img.src = data;
|
||||||
|
}
|
||||||
|
|
||||||
|
function patchSVGSource(svgSource) {
|
||||||
|
var source = '';
|
||||||
|
//add name spaces.
|
||||||
|
if (!svgSource.match(/^<svg[^>]+xmlns="http:\/\/www\.w3\.org\/2000\/svg"/)) {
|
||||||
|
source = svgSource.replace(/^<svg/, '<svg xmlns="http://www.w3.org/2000/svg"');
|
||||||
|
}
|
||||||
|
if (!svgSource.match(/^<svg[^>]+"http:\/\/www\.w3\.org\/1999\/xlink"/)) {
|
||||||
|
source = svgSource.replace(/^<svg/, '<svg xmlns:xlink="http://www.w3.org/1999/xlink"');
|
||||||
|
}
|
||||||
|
|
||||||
|
//add xml declaration
|
||||||
|
return '<?xml version="1.0" standalone="no"?>\r\n' + source;
|
||||||
|
}
|
||||||
|
|
||||||
|
function copySVGToImg(svg, img) {
|
||||||
|
if (browser.isSafari() || browser.isMobileSafari()) {
|
||||||
|
copySVGToImgSafari(svg, img);
|
||||||
|
} else {
|
||||||
|
copySVGToImgMostBrowsers(svg, img);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function adaptDestSizeToZoom(destinationCanvas, sources) {
|
||||||
|
function containsSVGs(source) {
|
||||||
|
return source.srcImgTagName === 'svg';
|
||||||
|
}
|
||||||
|
|
||||||
|
if (sources.find(containsSVGs) !== undefined) {
|
||||||
|
if (pixelRatio < 1) {
|
||||||
|
destinationCanvas.width = destinationCanvas.width * pixelRatio;
|
||||||
|
destinationCanvas.height = destinationCanvas.height * pixelRatio;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function prepareImagesToBeComposed(sources, destination) {
|
||||||
|
var result = SUCCESSFULIMAGEPREPARATION;
|
||||||
|
if (sources.length === 0) {
|
||||||
|
result = EMPTYARRAYOFIMAGESOURCES; //nothing to do if called without sources
|
||||||
|
} else {
|
||||||
|
var minX = sources[0].genLeft;
|
||||||
|
var minY = sources[0].genTop;
|
||||||
|
var maxX = sources[0].genRight;
|
||||||
|
var maxY = sources[0].genBottom;
|
||||||
|
var i = 0;
|
||||||
|
|
||||||
|
for (i = 1; i < sources.length; i++) {
|
||||||
|
if (minX > sources[i].genLeft) {
|
||||||
|
minX = sources[i].genLeft;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (minY > sources[i].genTop) {
|
||||||
|
minY = sources[i].genTop;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 1; i < sources.length; i++) {
|
||||||
|
if (maxX < sources[i].genRight) {
|
||||||
|
maxX = sources[i].genRight;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (maxY < sources[i].genBottom) {
|
||||||
|
maxY = sources[i].genBottom;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((maxX - minX <= 0) || (maxY - minY <= 0)) {
|
||||||
|
result = NEGATIVEIMAGESIZE; //this might occur on hidden images
|
||||||
|
} else {
|
||||||
|
destination.width = Math.round(maxX - minX);
|
||||||
|
destination.height = Math.round(maxY - minY);
|
||||||
|
|
||||||
|
for (i = 0; i < sources.length; i++) {
|
||||||
|
sources[i].xCompOffset = sources[i].genLeft - minX;
|
||||||
|
sources[i].yCompOffset = sources[i].genTop - minY;
|
||||||
|
}
|
||||||
|
|
||||||
|
adaptDestSizeToZoom(destination, sources);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
function copyImgsToCanvas(sources, destination) {
|
||||||
|
var prepareImagesResult = prepareImagesToBeComposed(sources, destination);
|
||||||
|
if (prepareImagesResult === SUCCESSFULIMAGEPREPARATION) {
|
||||||
|
var destinationCtx = destination.getContext('2d');
|
||||||
|
|
||||||
|
for (var i = 0; i < sources.length; i++) {
|
||||||
|
if (sources[i].successfullyLoaded === true) {
|
||||||
|
destinationCtx.drawImage(sources[i], sources[i].xCompOffset * pixelRatio, sources[i].yCompOffset * pixelRatio);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return prepareImagesResult;
|
||||||
|
}
|
||||||
|
|
||||||
|
function adnotateDestImgWithBoundingClientRect(srcCanvasOrSvg, destImg) {
|
||||||
|
destImg.genLeft = srcCanvasOrSvg.getBoundingClientRect().left;
|
||||||
|
destImg.genTop = srcCanvasOrSvg.getBoundingClientRect().top;
|
||||||
|
|
||||||
|
if (srcCanvasOrSvg.tagName === 'CANVAS') {
|
||||||
|
destImg.genRight = destImg.genLeft + srcCanvasOrSvg.width;
|
||||||
|
destImg.genBottom = destImg.genTop + srcCanvasOrSvg.height;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (srcCanvasOrSvg.tagName === 'svg') {
|
||||||
|
destImg.genRight = srcCanvasOrSvg.getBoundingClientRect().right;
|
||||||
|
destImg.genBottom = srcCanvasOrSvg.getBoundingClientRect().bottom;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function generateTempImageFromCanvasOrSvg(srcCanvasOrSvg, destImg) {
|
||||||
|
if (srcCanvasOrSvg.tagName === 'CANVAS') {
|
||||||
|
copyCanvasToImg(srcCanvasOrSvg, destImg);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (srcCanvasOrSvg.tagName === 'svg') {
|
||||||
|
copySVGToImg(srcCanvasOrSvg, destImg);
|
||||||
|
}
|
||||||
|
|
||||||
|
destImg.srcImgTagName = srcCanvasOrSvg.tagName;
|
||||||
|
adnotateDestImgWithBoundingClientRect(srcCanvasOrSvg, destImg);
|
||||||
|
}
|
||||||
|
|
||||||
|
function failureCallback() {
|
||||||
|
return GENERALFAILURECALLBACKERROR;
|
||||||
|
}
|
||||||
|
|
||||||
|
// used for testing
|
||||||
|
$.plot.composeImages = composeImages;
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
// used to extend the public API of the plot
|
||||||
|
plot.composeImages = composeImages;
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
name: 'composeImages',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,202 @@
|
||||||
|
/* Flot plugin for showing crosshairs when the mouse hovers over the plot.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
crosshair: {
|
||||||
|
mode: null or "x" or "y" or "xy"
|
||||||
|
color: color
|
||||||
|
lineWidth: number
|
||||||
|
}
|
||||||
|
|
||||||
|
Set the mode to one of "x", "y" or "xy". The "x" mode enables a vertical
|
||||||
|
crosshair that lets you trace the values on the x axis, "y" enables a
|
||||||
|
horizontal crosshair and "xy" enables them both. "color" is the color of the
|
||||||
|
crosshair (default is "rgba(170, 0, 0, 0.80)"), "lineWidth" is the width of
|
||||||
|
the drawn lines (default is 1).
|
||||||
|
|
||||||
|
The plugin also adds four public methods:
|
||||||
|
|
||||||
|
- setCrosshair( pos )
|
||||||
|
|
||||||
|
Set the position of the crosshair. Note that this is cleared if the user
|
||||||
|
moves the mouse. "pos" is in coordinates of the plot and should be on the
|
||||||
|
form { x: xpos, y: ypos } (you can use x2/x3/... if you're using multiple
|
||||||
|
axes), which is coincidentally the same format as what you get from a
|
||||||
|
"plothover" event. If "pos" is null, the crosshair is cleared.
|
||||||
|
|
||||||
|
- clearCrosshair()
|
||||||
|
|
||||||
|
Clear the crosshair.
|
||||||
|
|
||||||
|
- lockCrosshair(pos)
|
||||||
|
|
||||||
|
Cause the crosshair to lock to the current location, no longer updating if
|
||||||
|
the user moves the mouse. Optionally supply a position (passed on to
|
||||||
|
setCrosshair()) to move it to.
|
||||||
|
|
||||||
|
Example usage:
|
||||||
|
|
||||||
|
var myFlot = $.plot( $("#graph"), ..., { crosshair: { mode: "x" } } };
|
||||||
|
$("#graph").bind( "plothover", function ( evt, position, item ) {
|
||||||
|
if ( item ) {
|
||||||
|
// Lock the crosshair to the data point being hovered
|
||||||
|
myFlot.lockCrosshair({
|
||||||
|
x: item.datapoint[ 0 ],
|
||||||
|
y: item.datapoint[ 1 ]
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
// Return normal crosshair operation
|
||||||
|
myFlot.unlockCrosshair();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
- unlockCrosshair()
|
||||||
|
|
||||||
|
Free the crosshair to move again after locking it.
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
crosshair: {
|
||||||
|
mode: null, // one of null, "x", "y" or "xy",
|
||||||
|
color: "rgba(170, 0, 0, 0.80)",
|
||||||
|
lineWidth: 1
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
// position of crosshair in pixels
|
||||||
|
var crosshair = {x: -1, y: -1, locked: false, highlighted: false};
|
||||||
|
|
||||||
|
plot.setCrosshair = function setCrosshair(pos) {
|
||||||
|
if (!pos) {
|
||||||
|
crosshair.x = -1;
|
||||||
|
} else {
|
||||||
|
var o = plot.p2c(pos);
|
||||||
|
crosshair.x = Math.max(0, Math.min(o.left, plot.width()));
|
||||||
|
crosshair.y = Math.max(0, Math.min(o.top, plot.height()));
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.clearCrosshair = plot.setCrosshair; // passes null for pos
|
||||||
|
|
||||||
|
plot.lockCrosshair = function lockCrosshair(pos) {
|
||||||
|
if (pos) {
|
||||||
|
plot.setCrosshair(pos);
|
||||||
|
}
|
||||||
|
|
||||||
|
crosshair.locked = true;
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.unlockCrosshair = function unlockCrosshair() {
|
||||||
|
crosshair.locked = false;
|
||||||
|
crosshair.rect = null;
|
||||||
|
};
|
||||||
|
|
||||||
|
function onMouseOut(e) {
|
||||||
|
if (crosshair.locked) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (crosshair.x !== -1) {
|
||||||
|
crosshair.x = -1;
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function onMouseMove(e) {
|
||||||
|
var offset = plot.offset();
|
||||||
|
if (crosshair.locked) {
|
||||||
|
var mouseX = Math.max(0, Math.min(e.pageX - offset.left, plot.width()));
|
||||||
|
var mouseY = Math.max(0, Math.min(e.pageY - offset.top, plot.height()));
|
||||||
|
|
||||||
|
if ((mouseX > crosshair.x - 4) && (mouseX < crosshair.x + 4) && (mouseY > crosshair.y - 4) && (mouseY < crosshair.y + 4)) {
|
||||||
|
if (!crosshair.highlighted) {
|
||||||
|
crosshair.highlighted = true;
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
if (crosshair.highlighted) {
|
||||||
|
crosshair.highlighted = false;
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (plot.getSelection && plot.getSelection()) {
|
||||||
|
crosshair.x = -1; // hide the crosshair while selecting
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
crosshair.x = Math.max(0, Math.min(e.pageX - offset.left, plot.width()));
|
||||||
|
crosshair.y = Math.max(0, Math.min(e.pageY - offset.top, plot.height()));
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.bindEvents.push(function (plot, eventHolder) {
|
||||||
|
if (!plot.getOptions().crosshair.mode) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
eventHolder.mouseout(onMouseOut);
|
||||||
|
eventHolder.mousemove(onMouseMove);
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.drawOverlay.push(function (plot, ctx) {
|
||||||
|
var c = plot.getOptions().crosshair;
|
||||||
|
if (!c.mode) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var plotOffset = plot.getPlotOffset();
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
|
||||||
|
if (crosshair.x !== -1) {
|
||||||
|
var adj = plot.getOptions().crosshair.lineWidth % 2 ? 0.5 : 0;
|
||||||
|
|
||||||
|
ctx.strokeStyle = c.color;
|
||||||
|
ctx.lineWidth = c.lineWidth;
|
||||||
|
ctx.lineJoin = "round";
|
||||||
|
|
||||||
|
ctx.beginPath();
|
||||||
|
if (c.mode.indexOf("x") !== -1) {
|
||||||
|
var drawX = Math.floor(crosshair.x) + adj;
|
||||||
|
ctx.moveTo(drawX, 0);
|
||||||
|
ctx.lineTo(drawX, plot.height());
|
||||||
|
}
|
||||||
|
if (c.mode.indexOf("y") !== -1) {
|
||||||
|
var drawY = Math.floor(crosshair.y) + adj;
|
||||||
|
ctx.moveTo(0, drawY);
|
||||||
|
ctx.lineTo(plot.width(), drawY);
|
||||||
|
}
|
||||||
|
if (crosshair.locked) {
|
||||||
|
if (crosshair.highlighted) ctx.fillStyle = 'orange';
|
||||||
|
else ctx.fillStyle = c.color;
|
||||||
|
ctx.fillRect(Math.floor(crosshair.x) + adj - 4, Math.floor(crosshair.y) + adj - 4, 8, 8);
|
||||||
|
}
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
ctx.restore();
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.shutdown.push(function (plot, eventHolder) {
|
||||||
|
eventHolder.unbind("mouseout", onMouseOut);
|
||||||
|
eventHolder.unbind("mousemove", onMouseMove);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'crosshair',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,662 @@
|
||||||
|
/**
|
||||||
|
## jquery.flot.drawSeries.js
|
||||||
|
|
||||||
|
This plugin is used by flot for drawing lines, plots, bars or area.
|
||||||
|
|
||||||
|
### Public methods
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
"use strict";
|
||||||
|
|
||||||
|
function DrawSeries() {
|
||||||
|
function plotLine(datapoints, xoffset, yoffset, axisx, axisy, ctx, steps) {
|
||||||
|
var points = datapoints.points,
|
||||||
|
ps = datapoints.pointsize,
|
||||||
|
prevx = null,
|
||||||
|
prevy = null;
|
||||||
|
var x1 = 0.0,
|
||||||
|
y1 = 0.0,
|
||||||
|
x2 = 0.0,
|
||||||
|
y2 = 0.0,
|
||||||
|
mx = null,
|
||||||
|
my = null,
|
||||||
|
i = 0;
|
||||||
|
|
||||||
|
ctx.beginPath();
|
||||||
|
for (i = ps; i < points.length; i += ps) {
|
||||||
|
x1 = points[i - ps];
|
||||||
|
y1 = points[i - ps + 1];
|
||||||
|
x2 = points[i];
|
||||||
|
y2 = points[i + 1];
|
||||||
|
|
||||||
|
if (x1 === null || x2 === null) {
|
||||||
|
mx = null;
|
||||||
|
my = null;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isNaN(x1) || isNaN(x2) || isNaN(y1) || isNaN(y2)) {
|
||||||
|
prevx = null;
|
||||||
|
prevy = null;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (steps) {
|
||||||
|
if (mx !== null && my !== null) {
|
||||||
|
// if middle point exists, transfer p2 -> p1 and p1 -> mp
|
||||||
|
x2 = x1;
|
||||||
|
y2 = y1;
|
||||||
|
x1 = mx;
|
||||||
|
y1 = my;
|
||||||
|
|
||||||
|
// 'remove' middle point
|
||||||
|
mx = null;
|
||||||
|
my = null;
|
||||||
|
|
||||||
|
// subtract pointsize from i to have current point p1 handled again
|
||||||
|
i -= ps;
|
||||||
|
} else if (y1 !== y2 && x1 !== x2) {
|
||||||
|
// create a middle point
|
||||||
|
y2 = y1;
|
||||||
|
mx = x2;
|
||||||
|
my = y1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip with ymin
|
||||||
|
if (y1 <= y2 && y1 < axisy.min) {
|
||||||
|
if (y2 < axisy.min) {
|
||||||
|
// line segment is outside
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
// compute new intersection point
|
||||||
|
x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y1 = axisy.min;
|
||||||
|
} else if (y2 <= y1 && y2 < axisy.min) {
|
||||||
|
if (y1 < axisy.min) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y2 = axisy.min;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip with ymax
|
||||||
|
if (y1 >= y2 && y1 > axisy.max) {
|
||||||
|
if (y2 > axisy.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y1 = axisy.max;
|
||||||
|
} else if (y2 >= y1 && y2 > axisy.max) {
|
||||||
|
if (y1 > axisy.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y2 = axisy.max;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip with xmin
|
||||||
|
if (x1 <= x2 && x1 < axisx.min) {
|
||||||
|
if (x2 < axisx.min) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x1 = axisx.min;
|
||||||
|
} else if (x2 <= x1 && x2 < axisx.min) {
|
||||||
|
if (x1 < axisx.min) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x2 = axisx.min;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip with xmax
|
||||||
|
if (x1 >= x2 && x1 > axisx.max) {
|
||||||
|
if (x2 > axisx.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x1 = axisx.max;
|
||||||
|
} else if (x2 >= x1 && x2 > axisx.max) {
|
||||||
|
if (x1 > axisx.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x2 = axisx.max;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (x1 !== prevx || y1 !== prevy) {
|
||||||
|
ctx.moveTo(axisx.p2c(x1) + xoffset, axisy.p2c(y1) + yoffset);
|
||||||
|
}
|
||||||
|
|
||||||
|
prevx = x2;
|
||||||
|
prevy = y2;
|
||||||
|
ctx.lineTo(axisx.p2c(x2) + xoffset, axisy.p2c(y2) + yoffset);
|
||||||
|
}
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
function plotLineArea(datapoints, axisx, axisy, fillTowards, ctx, steps) {
|
||||||
|
var points = datapoints.points,
|
||||||
|
ps = datapoints.pointsize,
|
||||||
|
bottom = fillTowards > axisy.min ? Math.min(axisy.max, fillTowards) : axisy.min,
|
||||||
|
i = 0,
|
||||||
|
ypos = 1,
|
||||||
|
areaOpen = false,
|
||||||
|
segmentStart = 0,
|
||||||
|
segmentEnd = 0,
|
||||||
|
mx = null,
|
||||||
|
my = null;
|
||||||
|
|
||||||
|
// we process each segment in two turns, first forward
|
||||||
|
// direction to sketch out top, then once we hit the
|
||||||
|
// end we go backwards to sketch the bottom
|
||||||
|
while (true) {
|
||||||
|
if (ps > 0 && i > points.length + ps) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
i += ps; // ps is negative if going backwards
|
||||||
|
|
||||||
|
var x1 = points[i - ps],
|
||||||
|
y1 = points[i - ps + ypos],
|
||||||
|
x2 = points[i],
|
||||||
|
y2 = points[i + ypos];
|
||||||
|
|
||||||
|
if (ps === -2) {
|
||||||
|
/* going backwards and no value for the bottom provided in the series*/
|
||||||
|
y1 = y2 = bottom;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (areaOpen) {
|
||||||
|
if (ps > 0 && x1 != null && x2 == null) {
|
||||||
|
// at turning point
|
||||||
|
segmentEnd = i;
|
||||||
|
ps = -ps;
|
||||||
|
ypos = 2;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ps < 0 && i === segmentStart + ps) {
|
||||||
|
// done with the reverse sweep
|
||||||
|
ctx.fill();
|
||||||
|
areaOpen = false;
|
||||||
|
ps = -ps;
|
||||||
|
ypos = 1;
|
||||||
|
i = segmentStart = segmentEnd + ps;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (x1 == null || x2 == null) {
|
||||||
|
mx = null;
|
||||||
|
my = null;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (steps) {
|
||||||
|
if (mx !== null && my !== null) {
|
||||||
|
// if middle point exists, transfer p2 -> p1 and p1 -> mp
|
||||||
|
x2 = x1;
|
||||||
|
y2 = y1;
|
||||||
|
x1 = mx;
|
||||||
|
y1 = my;
|
||||||
|
|
||||||
|
// 'remove' middle point
|
||||||
|
mx = null;
|
||||||
|
my = null;
|
||||||
|
|
||||||
|
// subtract pointsize from i to have current point p1 handled again
|
||||||
|
i -= ps;
|
||||||
|
} else if (y1 !== y2 && x1 !== x2) {
|
||||||
|
// create a middle point
|
||||||
|
y2 = y1;
|
||||||
|
mx = x2;
|
||||||
|
my = y1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip x values
|
||||||
|
|
||||||
|
// clip with xmin
|
||||||
|
if (x1 <= x2 && x1 < axisx.min) {
|
||||||
|
if (x2 < axisx.min) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x1 = axisx.min;
|
||||||
|
} else if (x2 <= x1 && x2 < axisx.min) {
|
||||||
|
if (x1 < axisx.min) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x2 = axisx.min;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip with xmax
|
||||||
|
if (x1 >= x2 && x1 > axisx.max) {
|
||||||
|
if (x2 > axisx.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x1 = axisx.max;
|
||||||
|
} else if (x2 >= x1 && x2 > axisx.max) {
|
||||||
|
if (x1 > axisx.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
|
||||||
|
x2 = axisx.max;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!areaOpen) {
|
||||||
|
// open area
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.moveTo(axisx.p2c(x1), axisy.p2c(bottom));
|
||||||
|
areaOpen = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// now first check the case where both is outside
|
||||||
|
if (y1 >= axisy.max && y2 >= axisy.max) {
|
||||||
|
ctx.lineTo(axisx.p2c(x1), axisy.p2c(axisy.max));
|
||||||
|
ctx.lineTo(axisx.p2c(x2), axisy.p2c(axisy.max));
|
||||||
|
continue;
|
||||||
|
} else if (y1 <= axisy.min && y2 <= axisy.min) {
|
||||||
|
ctx.lineTo(axisx.p2c(x1), axisy.p2c(axisy.min));
|
||||||
|
ctx.lineTo(axisx.p2c(x2), axisy.p2c(axisy.min));
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// else it's a bit more complicated, there might
|
||||||
|
// be a flat maxed out rectangle first, then a
|
||||||
|
// triangular cutout or reverse; to find these
|
||||||
|
// keep track of the current x values
|
||||||
|
var x1old = x1,
|
||||||
|
x2old = x2;
|
||||||
|
|
||||||
|
// clip the y values, without shortcutting, we
|
||||||
|
// go through all cases in turn
|
||||||
|
|
||||||
|
// clip with ymin
|
||||||
|
if (y1 <= y2 && y1 < axisy.min && y2 >= axisy.min) {
|
||||||
|
x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y1 = axisy.min;
|
||||||
|
} else if (y2 <= y1 && y2 < axisy.min && y1 >= axisy.min) {
|
||||||
|
x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y2 = axisy.min;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip with ymax
|
||||||
|
if (y1 >= y2 && y1 > axisy.max && y2 <= axisy.max) {
|
||||||
|
x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y1 = axisy.max;
|
||||||
|
} else if (y2 >= y1 && y2 > axisy.max && y1 <= axisy.max) {
|
||||||
|
x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
|
||||||
|
y2 = axisy.max;
|
||||||
|
}
|
||||||
|
|
||||||
|
// if the x value was changed we got a rectangle
|
||||||
|
// to fill
|
||||||
|
if (x1 !== x1old) {
|
||||||
|
ctx.lineTo(axisx.p2c(x1old), axisy.p2c(y1));
|
||||||
|
// it goes to (x1, y1), but we fill that below
|
||||||
|
}
|
||||||
|
|
||||||
|
// fill triangular section, this sometimes result
|
||||||
|
// in redundant points if (x1, y1) hasn't changed
|
||||||
|
// from previous line to, but we just ignore that
|
||||||
|
ctx.lineTo(axisx.p2c(x1), axisy.p2c(y1));
|
||||||
|
ctx.lineTo(axisx.p2c(x2), axisy.p2c(y2));
|
||||||
|
|
||||||
|
// fill the other rectangle if it's there
|
||||||
|
if (x2 !== x2old) {
|
||||||
|
ctx.lineTo(axisx.p2c(x2), axisy.p2c(y2));
|
||||||
|
ctx.lineTo(axisx.p2c(x2old), axisy.p2c(y2));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- drawSeriesLines(series, ctx, plotOffset, plotWidth, plotHeight, drawSymbol, getColorOrGradient)
|
||||||
|
|
||||||
|
This function is used for drawing lines or area fill. In case the series has line decimation function
|
||||||
|
attached, before starting to draw, as an optimization the points will first be decimated.
|
||||||
|
|
||||||
|
The series parameter contains the series to be drawn on ctx context. The plotOffset, plotWidth and
|
||||||
|
plotHeight are the corresponding parameters of flot used to determine the drawing surface.
|
||||||
|
The function getColorOrGradient is used to compute the fill style of lines and area.
|
||||||
|
*/
|
||||||
|
function drawSeriesLines(series, ctx, plotOffset, plotWidth, plotHeight, drawSymbol, getColorOrGradient) {
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
ctx.lineJoin = "round";
|
||||||
|
|
||||||
|
if (series.lines.dashes && ctx.setLineDash) {
|
||||||
|
ctx.setLineDash(series.lines.dashes);
|
||||||
|
}
|
||||||
|
|
||||||
|
var datapoints = {
|
||||||
|
format: series.datapoints.format,
|
||||||
|
points: series.datapoints.points,
|
||||||
|
pointsize: series.datapoints.pointsize
|
||||||
|
};
|
||||||
|
|
||||||
|
if (series.decimate) {
|
||||||
|
datapoints.points = series.decimate(series, series.xaxis.min, series.xaxis.max, plotWidth, series.yaxis.min, series.yaxis.max, plotHeight);
|
||||||
|
}
|
||||||
|
|
||||||
|
var lw = series.lines.lineWidth;
|
||||||
|
|
||||||
|
ctx.lineWidth = lw;
|
||||||
|
ctx.strokeStyle = series.color;
|
||||||
|
var fillStyle = getFillStyle(series.lines, series.color, 0, plotHeight, getColorOrGradient);
|
||||||
|
if (fillStyle) {
|
||||||
|
ctx.fillStyle = fillStyle;
|
||||||
|
plotLineArea(datapoints, series.xaxis, series.yaxis, series.lines.fillTowards || 0, ctx, series.lines.steps);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (lw > 0) {
|
||||||
|
plotLine(datapoints, 0, 0, series.xaxis, series.yaxis, ctx, series.lines.steps);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- drawSeriesPoints(series, ctx, plotOffset, plotWidth, plotHeight, drawSymbol, getColorOrGradient)
|
||||||
|
|
||||||
|
This function is used for drawing points using a given symbol. In case the series has points decimation
|
||||||
|
function attached, before starting to draw, as an optimization the points will first be decimated.
|
||||||
|
|
||||||
|
The series parameter contains the series to be drawn on ctx context. The plotOffset, plotWidth and
|
||||||
|
plotHeight are the corresponding parameters of flot used to determine the drawing surface.
|
||||||
|
The function drawSymbol is used to compute and draw the symbol chosen for the points.
|
||||||
|
*/
|
||||||
|
function drawSeriesPoints(series, ctx, plotOffset, plotWidth, plotHeight, drawSymbol, getColorOrGradient) {
|
||||||
|
function drawCircle(ctx, x, y, radius, shadow, fill) {
|
||||||
|
ctx.moveTo(x + radius, y);
|
||||||
|
ctx.arc(x, y, radius, 0, shadow ? Math.PI : Math.PI * 2, false);
|
||||||
|
}
|
||||||
|
drawCircle.fill = true;
|
||||||
|
function plotPoints(datapoints, radius, fill, offset, shadow, axisx, axisy, drawSymbolFn) {
|
||||||
|
var points = datapoints.points,
|
||||||
|
ps = datapoints.pointsize;
|
||||||
|
|
||||||
|
ctx.beginPath();
|
||||||
|
for (var i = 0; i < points.length; i += ps) {
|
||||||
|
var x = points[i],
|
||||||
|
y = points[i + 1];
|
||||||
|
if (x == null || x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
x = axisx.p2c(x);
|
||||||
|
y = axisy.p2c(y) + offset;
|
||||||
|
|
||||||
|
drawSymbolFn(ctx, x, y, radius, shadow, fill);
|
||||||
|
}
|
||||||
|
if (drawSymbolFn.fill && !shadow) {
|
||||||
|
ctx.fill();
|
||||||
|
}
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
|
||||||
|
var datapoints = {
|
||||||
|
format: series.datapoints.format,
|
||||||
|
points: series.datapoints.points,
|
||||||
|
pointsize: series.datapoints.pointsize
|
||||||
|
};
|
||||||
|
|
||||||
|
if (series.decimatePoints) {
|
||||||
|
datapoints.points = series.decimatePoints(series, series.xaxis.min, series.xaxis.max, plotWidth, series.yaxis.min, series.yaxis.max, plotHeight);
|
||||||
|
}
|
||||||
|
|
||||||
|
var lw = series.points.lineWidth,
|
||||||
|
radius = series.points.radius,
|
||||||
|
symbol = series.points.symbol,
|
||||||
|
drawSymbolFn;
|
||||||
|
|
||||||
|
if (symbol === 'circle') {
|
||||||
|
drawSymbolFn = drawCircle;
|
||||||
|
} else if (typeof symbol === 'string' && drawSymbol && drawSymbol[symbol]) {
|
||||||
|
drawSymbolFn = drawSymbol[symbol];
|
||||||
|
} else if (typeof drawSymbol === 'function') {
|
||||||
|
drawSymbolFn = drawSymbol;
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the user sets the line width to 0, we change it to a very
|
||||||
|
// small value. A line width of 0 seems to force the default of 1.
|
||||||
|
|
||||||
|
if (lw === 0) {
|
||||||
|
lw = 0.0001;
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.lineWidth = lw;
|
||||||
|
ctx.fillStyle = getFillStyle(series.points, series.color, null, null, getColorOrGradient);
|
||||||
|
ctx.strokeStyle = series.color;
|
||||||
|
plotPoints(datapoints, radius,
|
||||||
|
true, 0, false,
|
||||||
|
series.xaxis, series.yaxis, drawSymbolFn);
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawBar(x, y, b, barLeft, barRight, fillStyleCallback, axisx, axisy, c, horizontal, lineWidth) {
|
||||||
|
var left = x + barLeft,
|
||||||
|
right = x + barRight,
|
||||||
|
bottom = b, top = y,
|
||||||
|
drawLeft, drawRight, drawTop, drawBottom = false,
|
||||||
|
tmp;
|
||||||
|
|
||||||
|
drawLeft = drawRight = drawTop = true;
|
||||||
|
|
||||||
|
// in horizontal mode, we start the bar from the left
|
||||||
|
// instead of from the bottom so it appears to be
|
||||||
|
// horizontal rather than vertical
|
||||||
|
if (horizontal) {
|
||||||
|
drawBottom = drawRight = drawTop = true;
|
||||||
|
drawLeft = false;
|
||||||
|
left = b;
|
||||||
|
right = x;
|
||||||
|
top = y + barLeft;
|
||||||
|
bottom = y + barRight;
|
||||||
|
|
||||||
|
// account for negative bars
|
||||||
|
if (right < left) {
|
||||||
|
tmp = right;
|
||||||
|
right = left;
|
||||||
|
left = tmp;
|
||||||
|
drawLeft = true;
|
||||||
|
drawRight = false;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
drawLeft = drawRight = drawTop = true;
|
||||||
|
drawBottom = false;
|
||||||
|
left = x + barLeft;
|
||||||
|
right = x + barRight;
|
||||||
|
bottom = b;
|
||||||
|
top = y;
|
||||||
|
|
||||||
|
// account for negative bars
|
||||||
|
if (top < bottom) {
|
||||||
|
tmp = top;
|
||||||
|
top = bottom;
|
||||||
|
bottom = tmp;
|
||||||
|
drawBottom = true;
|
||||||
|
drawTop = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip
|
||||||
|
if (right < axisx.min || left > axisx.max ||
|
||||||
|
top < axisy.min || bottom > axisy.max) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (left < axisx.min) {
|
||||||
|
left = axisx.min;
|
||||||
|
drawLeft = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (right > axisx.max) {
|
||||||
|
right = axisx.max;
|
||||||
|
drawRight = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (bottom < axisy.min) {
|
||||||
|
bottom = axisy.min;
|
||||||
|
drawBottom = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (top > axisy.max) {
|
||||||
|
top = axisy.max;
|
||||||
|
drawTop = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
left = axisx.p2c(left);
|
||||||
|
bottom = axisy.p2c(bottom);
|
||||||
|
right = axisx.p2c(right);
|
||||||
|
top = axisy.p2c(top);
|
||||||
|
|
||||||
|
// fill the bar
|
||||||
|
if (fillStyleCallback) {
|
||||||
|
c.fillStyle = fillStyleCallback(bottom, top);
|
||||||
|
c.fillRect(left, top, right - left, bottom - top)
|
||||||
|
}
|
||||||
|
|
||||||
|
// draw outline
|
||||||
|
if (lineWidth > 0 && (drawLeft || drawRight || drawTop || drawBottom)) {
|
||||||
|
c.beginPath();
|
||||||
|
|
||||||
|
// FIXME: inline moveTo is buggy with excanvas
|
||||||
|
c.moveTo(left, bottom);
|
||||||
|
if (drawLeft) {
|
||||||
|
c.lineTo(left, top);
|
||||||
|
} else {
|
||||||
|
c.moveTo(left, top);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (drawTop) {
|
||||||
|
c.lineTo(right, top);
|
||||||
|
} else {
|
||||||
|
c.moveTo(right, top);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (drawRight) {
|
||||||
|
c.lineTo(right, bottom);
|
||||||
|
} else {
|
||||||
|
c.moveTo(right, bottom);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (drawBottom) {
|
||||||
|
c.lineTo(left, bottom);
|
||||||
|
} else {
|
||||||
|
c.moveTo(left, bottom);
|
||||||
|
}
|
||||||
|
|
||||||
|
c.stroke();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- drawSeriesBars(series, ctx, plotOffset, plotWidth, plotHeight, drawSymbol, getColorOrGradient)
|
||||||
|
|
||||||
|
This function is used for drawing series represented as bars. In case the series has decimation
|
||||||
|
function attached, before starting to draw, as an optimization the points will first be decimated.
|
||||||
|
|
||||||
|
The series parameter contains the series to be drawn on ctx context. The plotOffset, plotWidth and
|
||||||
|
plotHeight are the corresponding parameters of flot used to determine the drawing surface.
|
||||||
|
The function getColorOrGradient is used to compute the fill style of bars.
|
||||||
|
*/
|
||||||
|
function drawSeriesBars(series, ctx, plotOffset, plotWidth, plotHeight, drawSymbol, getColorOrGradient) {
|
||||||
|
function plotBars(datapoints, barLeft, barRight, fillStyleCallback, axisx, axisy) {
|
||||||
|
var points = datapoints.points,
|
||||||
|
ps = datapoints.pointsize,
|
||||||
|
fillTowards = series.bars.fillTowards || 0,
|
||||||
|
defaultBottom = fillTowards > axisy.min ? Math.min(axisy.max, fillTowards) : axisy.min;
|
||||||
|
|
||||||
|
for (var i = 0; i < points.length; i += ps) {
|
||||||
|
if (points[i] == null) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Use third point as bottom if pointsize is 3
|
||||||
|
var bottom = ps === 3 ? points[i + 2] : defaultBottom;
|
||||||
|
drawBar(points[i], points[i + 1], bottom, barLeft, barRight, fillStyleCallback, axisx, axisy, ctx, series.bars.horizontal, series.bars.lineWidth);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
|
||||||
|
var datapoints = {
|
||||||
|
format: series.datapoints.format,
|
||||||
|
points: series.datapoints.points,
|
||||||
|
pointsize: series.datapoints.pointsize
|
||||||
|
};
|
||||||
|
|
||||||
|
if (series.decimate) {
|
||||||
|
datapoints.points = series.decimate(series, series.xaxis.min, series.xaxis.max, plotWidth);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.lineWidth = series.bars.lineWidth;
|
||||||
|
ctx.strokeStyle = series.color;
|
||||||
|
|
||||||
|
var barLeft;
|
||||||
|
var barWidth = series.bars.barWidth[0] || series.bars.barWidth;
|
||||||
|
switch (series.bars.align) {
|
||||||
|
case "left":
|
||||||
|
barLeft = 0;
|
||||||
|
break;
|
||||||
|
case "right":
|
||||||
|
barLeft = -barWidth;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
barLeft = -barWidth / 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
var fillStyleCallback = series.bars.fill ? function(bottom, top) {
|
||||||
|
return getFillStyle(series.bars, series.color, bottom, top, getColorOrGradient);
|
||||||
|
} : null;
|
||||||
|
|
||||||
|
plotBars(datapoints, barLeft, barLeft + barWidth, fillStyleCallback, series.xaxis, series.yaxis);
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
function getFillStyle(filloptions, seriesColor, bottom, top, getColorOrGradient) {
|
||||||
|
var fill = filloptions.fill;
|
||||||
|
if (!fill) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (filloptions.fillColor) {
|
||||||
|
return getColorOrGradient(filloptions.fillColor, bottom, top, seriesColor);
|
||||||
|
}
|
||||||
|
|
||||||
|
var c = $.color.parse(seriesColor);
|
||||||
|
c.a = typeof fill === "number" ? fill : 0.4;
|
||||||
|
c.normalize();
|
||||||
|
return c.toString();
|
||||||
|
}
|
||||||
|
|
||||||
|
this.drawSeriesLines = drawSeriesLines;
|
||||||
|
this.drawSeriesPoints = drawSeriesPoints;
|
||||||
|
this.drawSeriesBars = drawSeriesBars;
|
||||||
|
this.drawBar = drawBar;
|
||||||
|
};
|
||||||
|
|
||||||
|
$.plot.drawSeries = new DrawSeries();
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,375 @@
|
||||||
|
/* Flot plugin for plotting error bars.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
Error bars are used to show standard deviation and other statistical
|
||||||
|
properties in a plot.
|
||||||
|
|
||||||
|
* Created by Rui Pereira - rui (dot) pereira (at) gmail (dot) com
|
||||||
|
|
||||||
|
This plugin allows you to plot error-bars over points. Set "errorbars" inside
|
||||||
|
the points series to the axis name over which there will be error values in
|
||||||
|
your data array (*even* if you do not intend to plot them later, by setting
|
||||||
|
"show: null" on xerr/yerr).
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
series: {
|
||||||
|
points: {
|
||||||
|
errorbars: "x" or "y" or "xy",
|
||||||
|
xerr: {
|
||||||
|
show: null/false or true,
|
||||||
|
asymmetric: null/false or true,
|
||||||
|
upperCap: null or "-" or function,
|
||||||
|
lowerCap: null or "-" or function,
|
||||||
|
color: null or color,
|
||||||
|
radius: null or number
|
||||||
|
},
|
||||||
|
yerr: { same options as xerr }
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Each data point array is expected to be of the type:
|
||||||
|
|
||||||
|
"x" [ x, y, xerr ]
|
||||||
|
"y" [ x, y, yerr ]
|
||||||
|
"xy" [ x, y, xerr, yerr ]
|
||||||
|
|
||||||
|
Where xerr becomes xerr_lower,xerr_upper for the asymmetric error case, and
|
||||||
|
equivalently for yerr. Eg., a datapoint for the "xy" case with symmetric
|
||||||
|
error-bars on X and asymmetric on Y would be:
|
||||||
|
|
||||||
|
[ x, y, xerr, yerr_lower, yerr_upper ]
|
||||||
|
|
||||||
|
By default no end caps are drawn. Setting upperCap and/or lowerCap to "-" will
|
||||||
|
draw a small cap perpendicular to the error bar. They can also be set to a
|
||||||
|
user-defined drawing function, with (ctx, x, y, radius) as parameters, as eg.
|
||||||
|
|
||||||
|
function drawSemiCircle( ctx, x, y, radius ) {
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.arc( x, y, radius, 0, Math.PI, false );
|
||||||
|
ctx.moveTo( x - radius, y );
|
||||||
|
ctx.lineTo( x + radius, y );
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
Color and radius both default to the same ones of the points series if not
|
||||||
|
set. The independent radius parameter on xerr/yerr is useful for the case when
|
||||||
|
we may want to add error-bars to a line, without showing the interconnecting
|
||||||
|
points (with radius: 0), and still showing end caps on the error-bars.
|
||||||
|
shadowSize and lineWidth are derived as well from the points series.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
series: {
|
||||||
|
points: {
|
||||||
|
errorbars: null, //should be 'x', 'y' or 'xy'
|
||||||
|
xerr: {err: 'x', show: null, asymmetric: null, upperCap: null, lowerCap: null, color: null, radius: null},
|
||||||
|
yerr: {err: 'y', show: null, asymmetric: null, upperCap: null, lowerCap: null, color: null, radius: null}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function processRawData(plot, series, data, datapoints) {
|
||||||
|
if (!series.points.errorbars) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// x,y values
|
||||||
|
var format = [
|
||||||
|
{ x: true, number: true, required: true },
|
||||||
|
{ y: true, number: true, required: true }
|
||||||
|
];
|
||||||
|
|
||||||
|
var errors = series.points.errorbars;
|
||||||
|
// error bars - first X then Y
|
||||||
|
if (errors === 'x' || errors === 'xy') {
|
||||||
|
// lower / upper error
|
||||||
|
if (series.points.xerr.asymmetric) {
|
||||||
|
format.push({ x: true, number: true, required: true });
|
||||||
|
format.push({ x: true, number: true, required: true });
|
||||||
|
} else {
|
||||||
|
format.push({ x: true, number: true, required: true });
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (errors === 'y' || errors === 'xy') {
|
||||||
|
// lower / upper error
|
||||||
|
if (series.points.yerr.asymmetric) {
|
||||||
|
format.push({ y: true, number: true, required: true });
|
||||||
|
format.push({ y: true, number: true, required: true });
|
||||||
|
} else {
|
||||||
|
format.push({ y: true, number: true, required: true });
|
||||||
|
}
|
||||||
|
}
|
||||||
|
datapoints.format = format;
|
||||||
|
}
|
||||||
|
|
||||||
|
function parseErrors(series, i) {
|
||||||
|
var points = series.datapoints.points;
|
||||||
|
|
||||||
|
// read errors from points array
|
||||||
|
var exl = null,
|
||||||
|
exu = null,
|
||||||
|
eyl = null,
|
||||||
|
eyu = null;
|
||||||
|
var xerr = series.points.xerr,
|
||||||
|
yerr = series.points.yerr;
|
||||||
|
|
||||||
|
var eb = series.points.errorbars;
|
||||||
|
// error bars - first X
|
||||||
|
if (eb === 'x' || eb === 'xy') {
|
||||||
|
if (xerr.asymmetric) {
|
||||||
|
exl = points[i + 2];
|
||||||
|
exu = points[i + 3];
|
||||||
|
if (eb === 'xy') {
|
||||||
|
if (yerr.asymmetric) {
|
||||||
|
eyl = points[i + 4];
|
||||||
|
eyu = points[i + 5];
|
||||||
|
} else {
|
||||||
|
eyl = points[i + 4];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
exl = points[i + 2];
|
||||||
|
if (eb === 'xy') {
|
||||||
|
if (yerr.asymmetric) {
|
||||||
|
eyl = points[i + 3];
|
||||||
|
eyu = points[i + 4];
|
||||||
|
} else {
|
||||||
|
eyl = points[i + 3];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// only Y
|
||||||
|
} else {
|
||||||
|
if (eb === 'y') {
|
||||||
|
if (yerr.asymmetric) {
|
||||||
|
eyl = points[i + 2];
|
||||||
|
eyu = points[i + 3];
|
||||||
|
} else {
|
||||||
|
eyl = points[i + 2];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// symmetric errors?
|
||||||
|
if (exu == null) exu = exl;
|
||||||
|
if (eyu == null) eyu = eyl;
|
||||||
|
|
||||||
|
var errRanges = [exl, exu, eyl, eyu];
|
||||||
|
// nullify if not showing
|
||||||
|
if (!xerr.show) {
|
||||||
|
errRanges[0] = null;
|
||||||
|
errRanges[1] = null;
|
||||||
|
}
|
||||||
|
if (!yerr.show) {
|
||||||
|
errRanges[2] = null;
|
||||||
|
errRanges[3] = null;
|
||||||
|
}
|
||||||
|
return errRanges;
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawSeriesErrors(plot, ctx, s) {
|
||||||
|
var points = s.datapoints.points,
|
||||||
|
ps = s.datapoints.pointsize,
|
||||||
|
ax = [s.xaxis, s.yaxis],
|
||||||
|
radius = s.points.radius,
|
||||||
|
err = [s.points.xerr, s.points.yerr],
|
||||||
|
tmp;
|
||||||
|
|
||||||
|
//sanity check, in case some inverted axis hack is applied to flot
|
||||||
|
var invertX = false;
|
||||||
|
if (ax[0].p2c(ax[0].max) < ax[0].p2c(ax[0].min)) {
|
||||||
|
invertX = true;
|
||||||
|
tmp = err[0].lowerCap;
|
||||||
|
err[0].lowerCap = err[0].upperCap;
|
||||||
|
err[0].upperCap = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
var invertY = false;
|
||||||
|
if (ax[1].p2c(ax[1].min) < ax[1].p2c(ax[1].max)) {
|
||||||
|
invertY = true;
|
||||||
|
tmp = err[1].lowerCap;
|
||||||
|
err[1].lowerCap = err[1].upperCap;
|
||||||
|
err[1].upperCap = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var i = 0; i < s.datapoints.points.length; i += ps) {
|
||||||
|
//parse
|
||||||
|
var errRanges = parseErrors(s, i);
|
||||||
|
|
||||||
|
//cycle xerr & yerr
|
||||||
|
for (var e = 0; e < err.length; e++) {
|
||||||
|
var minmax = [ax[e].min, ax[e].max];
|
||||||
|
|
||||||
|
//draw this error?
|
||||||
|
if (errRanges[e * err.length]) {
|
||||||
|
//data coordinates
|
||||||
|
var x = points[i],
|
||||||
|
y = points[i + 1];
|
||||||
|
|
||||||
|
//errorbar ranges
|
||||||
|
var upper = [x, y][e] + errRanges[e * err.length + 1],
|
||||||
|
lower = [x, y][e] - errRanges[e * err.length];
|
||||||
|
|
||||||
|
//points outside of the canvas
|
||||||
|
if (err[e].err === 'x') {
|
||||||
|
if (y > ax[1].max || y < ax[1].min || upper < ax[0].min || lower > ax[0].max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (err[e].err === 'y') {
|
||||||
|
if (x > ax[0].max || x < ax[0].min || upper < ax[1].min || lower > ax[1].max) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// prevent errorbars getting out of the canvas
|
||||||
|
var drawUpper = true,
|
||||||
|
drawLower = true;
|
||||||
|
|
||||||
|
if (upper > minmax[1]) {
|
||||||
|
drawUpper = false;
|
||||||
|
upper = minmax[1];
|
||||||
|
}
|
||||||
|
if (lower < minmax[0]) {
|
||||||
|
drawLower = false;
|
||||||
|
lower = minmax[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
//sanity check, in case some inverted axis hack is applied to flot
|
||||||
|
if ((err[e].err === 'x' && invertX) || (err[e].err === 'y' && invertY)) {
|
||||||
|
//swap coordinates
|
||||||
|
tmp = lower;
|
||||||
|
lower = upper;
|
||||||
|
upper = tmp;
|
||||||
|
tmp = drawLower;
|
||||||
|
drawLower = drawUpper;
|
||||||
|
drawUpper = tmp;
|
||||||
|
tmp = minmax[0];
|
||||||
|
minmax[0] = minmax[1];
|
||||||
|
minmax[1] = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// convert to pixels
|
||||||
|
x = ax[0].p2c(x);
|
||||||
|
y = ax[1].p2c(y);
|
||||||
|
upper = ax[e].p2c(upper);
|
||||||
|
lower = ax[e].p2c(lower);
|
||||||
|
minmax[0] = ax[e].p2c(minmax[0]);
|
||||||
|
minmax[1] = ax[e].p2c(minmax[1]);
|
||||||
|
|
||||||
|
//same style as points by default
|
||||||
|
var lw = err[e].lineWidth ? err[e].lineWidth : s.points.lineWidth,
|
||||||
|
sw = s.points.shadowSize != null ? s.points.shadowSize : s.shadowSize;
|
||||||
|
|
||||||
|
//shadow as for points
|
||||||
|
if (lw > 0 && sw > 0) {
|
||||||
|
var w = sw / 2;
|
||||||
|
ctx.lineWidth = w;
|
||||||
|
ctx.strokeStyle = "rgba(0,0,0,0.1)";
|
||||||
|
drawError(ctx, err[e], x, y, upper, lower, drawUpper, drawLower, radius, w + w / 2, minmax);
|
||||||
|
|
||||||
|
ctx.strokeStyle = "rgba(0,0,0,0.2)";
|
||||||
|
drawError(ctx, err[e], x, y, upper, lower, drawUpper, drawLower, radius, w / 2, minmax);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.strokeStyle = err[e].color
|
||||||
|
? err[e].color
|
||||||
|
: s.color;
|
||||||
|
ctx.lineWidth = lw;
|
||||||
|
//draw it
|
||||||
|
drawError(ctx, err[e], x, y, upper, lower, drawUpper, drawLower, radius, 0, minmax);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawError(ctx, err, x, y, upper, lower, drawUpper, drawLower, radius, offset, minmax) {
|
||||||
|
//shadow offset
|
||||||
|
y += offset;
|
||||||
|
upper += offset;
|
||||||
|
lower += offset;
|
||||||
|
|
||||||
|
// error bar - avoid plotting over circles
|
||||||
|
if (err.err === 'x') {
|
||||||
|
if (upper > x + radius) drawPath(ctx, [[upper, y], [Math.max(x + radius, minmax[0]), y]]);
|
||||||
|
else drawUpper = false;
|
||||||
|
|
||||||
|
if (lower < x - radius) drawPath(ctx, [[Math.min(x - radius, minmax[1]), y], [lower, y]]);
|
||||||
|
else drawLower = false;
|
||||||
|
} else {
|
||||||
|
if (upper < y - radius) drawPath(ctx, [[x, upper], [x, Math.min(y - radius, minmax[0])]]);
|
||||||
|
else drawUpper = false;
|
||||||
|
|
||||||
|
if (lower > y + radius) drawPath(ctx, [[x, Math.max(y + radius, minmax[1])], [x, lower]]);
|
||||||
|
else drawLower = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
//internal radius value in errorbar, allows to plot radius 0 points and still keep proper sized caps
|
||||||
|
//this is a way to get errorbars on lines without visible connecting dots
|
||||||
|
radius = err.radius != null
|
||||||
|
? err.radius
|
||||||
|
: radius;
|
||||||
|
|
||||||
|
// upper cap
|
||||||
|
if (drawUpper) {
|
||||||
|
if (err.upperCap === '-') {
|
||||||
|
if (err.err === 'x') drawPath(ctx, [[upper, y - radius], [upper, y + radius]]);
|
||||||
|
else drawPath(ctx, [[x - radius, upper], [x + radius, upper]]);
|
||||||
|
} else if ($.isFunction(err.upperCap)) {
|
||||||
|
if (err.err === 'x') err.upperCap(ctx, upper, y, radius);
|
||||||
|
else err.upperCap(ctx, x, upper, radius);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// lower cap
|
||||||
|
if (drawLower) {
|
||||||
|
if (err.lowerCap === '-') {
|
||||||
|
if (err.err === 'x') drawPath(ctx, [[lower, y - radius], [lower, y + radius]]);
|
||||||
|
else drawPath(ctx, [[x - radius, lower], [x + radius, lower]]);
|
||||||
|
} else if ($.isFunction(err.lowerCap)) {
|
||||||
|
if (err.err === 'x') err.lowerCap(ctx, lower, y, radius);
|
||||||
|
else err.lowerCap(ctx, x, lower, radius);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawPath(ctx, pts) {
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.moveTo(pts[0][0], pts[0][1]);
|
||||||
|
for (var p = 1; p < pts.length; p++) {
|
||||||
|
ctx.lineTo(pts[p][0], pts[p][1]);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
function draw(plot, ctx) {
|
||||||
|
var plotOffset = plot.getPlotOffset();
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
$.each(plot.getData(), function (i, s) {
|
||||||
|
if (s.points.errorbars && (s.points.xerr.show || s.points.yerr.show)) {
|
||||||
|
drawSeriesErrors(plot, ctx, s);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processRawData.push(processRawData);
|
||||||
|
plot.hooks.draw.push(draw);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'errorbars',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,254 @@
|
||||||
|
/* Flot plugin for computing bottoms for filled line and bar charts.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The case: you've got two series that you want to fill the area between. In Flot
|
||||||
|
terms, you need to use one as the fill bottom of the other. You can specify the
|
||||||
|
bottom of each data point as the third coordinate manually, or you can use this
|
||||||
|
plugin to compute it for you.
|
||||||
|
|
||||||
|
In order to name the other series, you need to give it an id, like this:
|
||||||
|
|
||||||
|
var dataset = [
|
||||||
|
{ data: [ ... ], id: "foo" } , // use default bottom
|
||||||
|
{ data: [ ... ], fillBetween: "foo" }, // use first dataset as bottom
|
||||||
|
];
|
||||||
|
|
||||||
|
$.plot($("#placeholder"), dataset, { lines: { show: true, fill: true }});
|
||||||
|
|
||||||
|
As a convenience, if the id given is a number that doesn't appear as an id in
|
||||||
|
the series, it is interpreted as the index in the array instead (so fillBetween:
|
||||||
|
0 can also mean the first series).
|
||||||
|
|
||||||
|
Internally, the plugin modifies the datapoints in each series. For line series,
|
||||||
|
extra data points might be inserted through interpolation. Note that at points
|
||||||
|
where the bottom line is not defined (due to a null point or start/end of line),
|
||||||
|
the current line will show a gap too. The algorithm comes from the
|
||||||
|
jquery.flot.stack.js plugin, possibly some code could be shared.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
series: {
|
||||||
|
fillBetween: null // or number
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
function findBottomSeries(s, allseries) {
|
||||||
|
var i;
|
||||||
|
|
||||||
|
for (i = 0; i < allseries.length; ++i) {
|
||||||
|
if (allseries[ i ].id === s.fillBetween) {
|
||||||
|
return allseries[ i ];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (typeof s.fillBetween === "number") {
|
||||||
|
if (s.fillBetween < 0 || s.fillBetween >= allseries.length) {
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
return allseries[ s.fillBetween ];
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
function computeFormat(plot, s, data, datapoints) {
|
||||||
|
if (s.fillBetween == null) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var format = datapoints.format;
|
||||||
|
var plotHasId = function(id) {
|
||||||
|
var plotData = plot.getData();
|
||||||
|
for (var i = 0; i < plotData.length; i++) {
|
||||||
|
if (plotData[i].id === id) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!format) {
|
||||||
|
format = [];
|
||||||
|
|
||||||
|
format.push({
|
||||||
|
x: true,
|
||||||
|
number: true,
|
||||||
|
computeRange: s.xaxis.options.autoScale !== 'none',
|
||||||
|
required: true
|
||||||
|
});
|
||||||
|
format.push({
|
||||||
|
y: true,
|
||||||
|
number: true,
|
||||||
|
computeRange: s.yaxis.options.autoScale !== 'none',
|
||||||
|
required: true
|
||||||
|
});
|
||||||
|
|
||||||
|
if (s.fillBetween !== undefined && s.fillBetween !== '' && plotHasId(s.fillBetween) && s.fillBetween !== s.id) {
|
||||||
|
format.push({
|
||||||
|
x: false,
|
||||||
|
y: true,
|
||||||
|
number: true,
|
||||||
|
required: false,
|
||||||
|
computeRange: s.yaxis.options.autoScale !== 'none',
|
||||||
|
defaultValue: 0
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
datapoints.format = format;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function computeFillBottoms(plot, s, datapoints) {
|
||||||
|
if (s.fillBetween == null) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var other = findBottomSeries(s, plot.getData());
|
||||||
|
|
||||||
|
if (!other) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var ps = datapoints.pointsize,
|
||||||
|
points = datapoints.points,
|
||||||
|
otherps = other.datapoints.pointsize,
|
||||||
|
otherpoints = other.datapoints.points,
|
||||||
|
newpoints = [],
|
||||||
|
px, py, intery, qx, qy, bottom,
|
||||||
|
withlines = s.lines.show,
|
||||||
|
withbottom = ps > 2 && datapoints.format[2].y,
|
||||||
|
withsteps = withlines && s.lines.steps,
|
||||||
|
fromgap = true,
|
||||||
|
i = 0,
|
||||||
|
j = 0,
|
||||||
|
l, m;
|
||||||
|
|
||||||
|
while (true) {
|
||||||
|
if (i >= points.length) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
l = newpoints.length;
|
||||||
|
|
||||||
|
if (points[ i ] == null) {
|
||||||
|
// copy gaps
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[ i + m ]);
|
||||||
|
}
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
} else if (j >= otherpoints.length) {
|
||||||
|
// for lines, we can't use the rest of the points
|
||||||
|
if (!withlines) {
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[ i + m ]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
} else if (otherpoints[ j ] == null) {
|
||||||
|
// oops, got a gap
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(null);
|
||||||
|
}
|
||||||
|
|
||||||
|
fromgap = true;
|
||||||
|
j += otherps;
|
||||||
|
} else {
|
||||||
|
// cases where we actually got two points
|
||||||
|
px = points[ i ];
|
||||||
|
py = points[ i + 1 ];
|
||||||
|
qx = otherpoints[ j ];
|
||||||
|
qy = otherpoints[ j + 1 ];
|
||||||
|
bottom = 0;
|
||||||
|
|
||||||
|
if (px === qx) {
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[ i + m ]);
|
||||||
|
}
|
||||||
|
|
||||||
|
//newpoints[ l + 1 ] += qy;
|
||||||
|
bottom = qy;
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
j += otherps;
|
||||||
|
} else if (px > qx) {
|
||||||
|
// we got past point below, might need to
|
||||||
|
// insert interpolated extra point
|
||||||
|
|
||||||
|
if (withlines && i > 0 && points[ i - ps ] != null) {
|
||||||
|
intery = py + (points[ i - ps + 1 ] - py) * (qx - px) / (points[ i - ps ] - px);
|
||||||
|
newpoints.push(qx);
|
||||||
|
newpoints.push(intery);
|
||||||
|
for (m = 2; m < ps; ++m) {
|
||||||
|
newpoints.push(points[ i + m ]);
|
||||||
|
}
|
||||||
|
bottom = qy;
|
||||||
|
}
|
||||||
|
|
||||||
|
j += otherps;
|
||||||
|
} else {
|
||||||
|
// px < qx
|
||||||
|
// if we come from a gap, we just skip this point
|
||||||
|
|
||||||
|
if (fromgap && withlines) {
|
||||||
|
i += ps;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[ i + m ]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// we might be able to interpolate a point below,
|
||||||
|
// this can give us a better y
|
||||||
|
|
||||||
|
if (withlines && j > 0 && otherpoints[ j - otherps ] != null) {
|
||||||
|
bottom = qy + (otherpoints[ j - otherps + 1 ] - qy) * (px - qx) / (otherpoints[ j - otherps ] - qx);
|
||||||
|
}
|
||||||
|
|
||||||
|
//newpoints[l + 1] += bottom;
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
}
|
||||||
|
|
||||||
|
fromgap = false;
|
||||||
|
|
||||||
|
if (l !== newpoints.length && withbottom) {
|
||||||
|
newpoints[ l + 2 ] = bottom;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// maintain the line steps invariant
|
||||||
|
|
||||||
|
if (withsteps && l !== newpoints.length && l > 0 &&
|
||||||
|
newpoints[ l ] !== null &&
|
||||||
|
newpoints[ l ] !== newpoints[ l - ps ] &&
|
||||||
|
newpoints[ l + 1 ] !== newpoints[ l - ps + 1 ]) {
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints[ l + ps + m ] = newpoints[ l + m ];
|
||||||
|
}
|
||||||
|
newpoints[ l + 1 ] = newpoints[ l - ps + 1 ];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
datapoints.points = newpoints;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.processRawData.push(computeFormat);
|
||||||
|
plot.hooks.processDatapoints.push(computeFillBottoms);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: "fillbetween",
|
||||||
|
version: "1.0"
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,47 @@
|
||||||
|
/* Support for flat 1D data series.
|
||||||
|
|
||||||
|
A 1D flat data series is a data series in the form of a regular 1D array. The
|
||||||
|
main reason for using a flat data series is that it performs better, consumes
|
||||||
|
less memory and generates less garbage collection than the regular flot format.
|
||||||
|
|
||||||
|
Example:
|
||||||
|
|
||||||
|
plot.setData([[[0,0], [1,1], [2,2], [3,3]]]); // regular flot format
|
||||||
|
plot.setData([{flatdata: true, data: [0, 1, 2, 3]}]); // flatdata format
|
||||||
|
|
||||||
|
Set series.flatdata to true to enable this plugin.
|
||||||
|
|
||||||
|
You can use series.start to specify the starting index of the series (default is 0)
|
||||||
|
You can use series.step to specify the interval between consecutive indexes of the series (default is 1)
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* global jQuery*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
function process1DRawData(plot, series, data, datapoints) {
|
||||||
|
if (series.flatdata === true) {
|
||||||
|
var start = series.start || 0;
|
||||||
|
var step = typeof series.step === 'number' ? series.step : 1;
|
||||||
|
datapoints.pointsize = 2;
|
||||||
|
for (var i = 0, j = 0; i < data.length; i++, j += 2) {
|
||||||
|
datapoints.points[j] = start + (i * step);
|
||||||
|
datapoints.points[j + 1] = data[i];
|
||||||
|
}
|
||||||
|
if (datapoints.points !== undefined) {
|
||||||
|
datapoints.points.length = data.length * 2;
|
||||||
|
} else {
|
||||||
|
datapoints.points = [];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: function(plot) {
|
||||||
|
plot.hooks.processRawData.push(process1DRawData);
|
||||||
|
},
|
||||||
|
name: 'flatdata',
|
||||||
|
version: '0.0.2'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,359 @@
|
||||||
|
/* global jQuery */
|
||||||
|
|
||||||
|
/**
|
||||||
|
## jquery.flot.hover.js
|
||||||
|
|
||||||
|
This plugin is used for mouse hover and tap on a point of plot series.
|
||||||
|
It supports the following options:
|
||||||
|
```js
|
||||||
|
grid: {
|
||||||
|
hoverable: false, //to trigger plothover event on mouse hover or tap on a point
|
||||||
|
clickable: false //to trigger plotclick event on mouse hover
|
||||||
|
}
|
||||||
|
```
|
||||||
|
|
||||||
|
It listens to native mouse move event or click, as well as artificial generated
|
||||||
|
tap and touchevent.
|
||||||
|
|
||||||
|
When the mouse is over a point or a tap on a point is performed, that point or
|
||||||
|
the correscponding bar will be highlighted and a "plothover" event will be generated.
|
||||||
|
|
||||||
|
Custom "touchevent" is triggered when any touch interaction is made. Hover plugin
|
||||||
|
handles this events by unhighlighting all of the previously highlighted points and generates
|
||||||
|
"plothovercleanup" event to notify any part that is handling plothover (for exemple to cleanup
|
||||||
|
the tooltip from webcharts).
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
grid: {
|
||||||
|
hoverable: false,
|
||||||
|
clickable: false
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var browser = $.plot.browser;
|
||||||
|
|
||||||
|
var eventType = {
|
||||||
|
click: 'click',
|
||||||
|
hover: 'hover'
|
||||||
|
}
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
var lastMouseMoveEvent;
|
||||||
|
var highlights = [];
|
||||||
|
|
||||||
|
function bindEvents(plot, eventHolder) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
|
||||||
|
if (o.grid.hoverable || o.grid.clickable) {
|
||||||
|
eventHolder[0].addEventListener('touchevent', triggerCleanupEvent, false);
|
||||||
|
eventHolder[0].addEventListener('tap', generatePlothoverEvent, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (o.grid.clickable) {
|
||||||
|
eventHolder.bind("click", onClick);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (o.grid.hoverable) {
|
||||||
|
eventHolder.bind("mousemove", onMouseMove);
|
||||||
|
|
||||||
|
// Use bind, rather than .mouseleave, because we officially
|
||||||
|
// still support jQuery 1.2.6, which doesn't define a shortcut
|
||||||
|
// for mouseenter or mouseleave. This was a bug/oversight that
|
||||||
|
// was fixed somewhere around 1.3.x. We can return to using
|
||||||
|
// .mouseleave when we drop support for 1.2.6.
|
||||||
|
|
||||||
|
eventHolder.bind("mouseleave", onMouseLeave);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function shutdown(plot, eventHolder) {
|
||||||
|
eventHolder[0].removeEventListener('tap', generatePlothoverEvent);
|
||||||
|
eventHolder[0].removeEventListener('touchevent', triggerCleanupEvent);
|
||||||
|
eventHolder.unbind("mousemove", onMouseMove);
|
||||||
|
eventHolder.unbind("mouseleave", onMouseLeave);
|
||||||
|
eventHolder.unbind("click", onClick);
|
||||||
|
highlights = [];
|
||||||
|
}
|
||||||
|
|
||||||
|
function generatePlothoverEvent(e) {
|
||||||
|
var o = plot.getOptions(),
|
||||||
|
newEvent = new CustomEvent('mouseevent');
|
||||||
|
|
||||||
|
//transform from touch event to mouse event format
|
||||||
|
newEvent.pageX = e.detail.changedTouches[0].pageX;
|
||||||
|
newEvent.pageY = e.detail.changedTouches[0].pageY;
|
||||||
|
newEvent.clientX = e.detail.changedTouches[0].clientX;
|
||||||
|
newEvent.clientY = e.detail.changedTouches[0].clientY;
|
||||||
|
|
||||||
|
if (o.grid.hoverable) {
|
||||||
|
doTriggerClickHoverEvent(newEvent, eventType.hover, 30);
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
function doTriggerClickHoverEvent(event, eventType, searchDistance) {
|
||||||
|
var series = plot.getData();
|
||||||
|
if (event !== undefined &&
|
||||||
|
series.length > 0 &&
|
||||||
|
series[0].xaxis.c2p !== undefined &&
|
||||||
|
series[0].yaxis.c2p !== undefined) {
|
||||||
|
var eventToTrigger = "plot" + eventType;
|
||||||
|
var seriesFlag = eventType + "able";
|
||||||
|
triggerClickHoverEvent(eventToTrigger, event,
|
||||||
|
function(i) {
|
||||||
|
return series[i][seriesFlag] !== false;
|
||||||
|
}, searchDistance);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function onMouseMove(e) {
|
||||||
|
lastMouseMoveEvent = e;
|
||||||
|
plot.getPlaceholder()[0].lastMouseMoveEvent = e;
|
||||||
|
doTriggerClickHoverEvent(e, eventType.hover);
|
||||||
|
}
|
||||||
|
|
||||||
|
function onMouseLeave(e) {
|
||||||
|
lastMouseMoveEvent = undefined;
|
||||||
|
plot.getPlaceholder()[0].lastMouseMoveEvent = undefined;
|
||||||
|
triggerClickHoverEvent("plothover", e,
|
||||||
|
function(i) {
|
||||||
|
return false;
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
function onClick(e) {
|
||||||
|
doTriggerClickHoverEvent(e, eventType.click);
|
||||||
|
}
|
||||||
|
|
||||||
|
function triggerCleanupEvent() {
|
||||||
|
plot.unhighlight();
|
||||||
|
plot.getPlaceholder().trigger('plothovercleanup');
|
||||||
|
}
|
||||||
|
|
||||||
|
// trigger click or hover event (they send the same parameters
|
||||||
|
// so we share their code)
|
||||||
|
function triggerClickHoverEvent(eventname, event, seriesFilter, searchDistance) {
|
||||||
|
var options = plot.getOptions(),
|
||||||
|
offset = plot.offset(),
|
||||||
|
page = browser.getPageXY(event),
|
||||||
|
canvasX = page.X - offset.left,
|
||||||
|
canvasY = page.Y - offset.top,
|
||||||
|
pos = plot.c2p({
|
||||||
|
left: canvasX,
|
||||||
|
top: canvasY
|
||||||
|
}),
|
||||||
|
distance = searchDistance !== undefined ? searchDistance : options.grid.mouseActiveRadius;
|
||||||
|
|
||||||
|
pos.pageX = page.X;
|
||||||
|
pos.pageY = page.Y;
|
||||||
|
|
||||||
|
var items = plot.findNearbyItems(canvasX, canvasY, seriesFilter, distance);
|
||||||
|
var item = items[0];
|
||||||
|
|
||||||
|
for (let i = 1; i < items.length; ++i) {
|
||||||
|
if (item.distance === undefined ||
|
||||||
|
items[i].distance < item.distance) {
|
||||||
|
item = items[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (item) {
|
||||||
|
// fill in mouse pos for any listeners out there
|
||||||
|
item.pageX = parseInt(item.series.xaxis.p2c(item.datapoint[0]) + offset.left, 10);
|
||||||
|
item.pageY = parseInt(item.series.yaxis.p2c(item.datapoint[1]) + offset.top, 10);
|
||||||
|
} else {
|
||||||
|
item = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (options.grid.autoHighlight) {
|
||||||
|
// clear auto-highlights
|
||||||
|
for (let i = 0; i < highlights.length; ++i) {
|
||||||
|
var h = highlights[i];
|
||||||
|
if ((h.auto === eventname &&
|
||||||
|
!(item && h.series === item.series &&
|
||||||
|
h.point[0] === item.datapoint[0] &&
|
||||||
|
h.point[1] === item.datapoint[1])) || !item) {
|
||||||
|
unhighlight(h.series, h.point);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (item) {
|
||||||
|
highlight(item.series, item.datapoint, eventname);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.getPlaceholder().trigger(eventname, [pos, item, items]);
|
||||||
|
}
|
||||||
|
|
||||||
|
function highlight(s, point, auto) {
|
||||||
|
if (typeof s === "number") {
|
||||||
|
s = plot.getData()[s];
|
||||||
|
}
|
||||||
|
|
||||||
|
if (typeof point === "number") {
|
||||||
|
var ps = s.datapoints.pointsize;
|
||||||
|
point = s.datapoints.points.slice(ps * point, ps * (point + 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
var i = indexOfHighlight(s, point);
|
||||||
|
if (i === -1) {
|
||||||
|
highlights.push({
|
||||||
|
series: s,
|
||||||
|
point: point,
|
||||||
|
auto: auto
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
} else if (!auto) {
|
||||||
|
highlights[i].auto = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function unhighlight(s, point) {
|
||||||
|
if (s == null && point == null) {
|
||||||
|
highlights = [];
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (typeof s === "number") {
|
||||||
|
s = plot.getData()[s];
|
||||||
|
}
|
||||||
|
|
||||||
|
if (typeof point === "number") {
|
||||||
|
var ps = s.datapoints.pointsize;
|
||||||
|
point = s.datapoints.points.slice(ps * point, ps * (point + 1));
|
||||||
|
}
|
||||||
|
|
||||||
|
var i = indexOfHighlight(s, point);
|
||||||
|
if (i !== -1) {
|
||||||
|
highlights.splice(i, 1);
|
||||||
|
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function indexOfHighlight(s, p) {
|
||||||
|
for (var i = 0; i < highlights.length; ++i) {
|
||||||
|
var h = highlights[i];
|
||||||
|
if (h.series === s &&
|
||||||
|
h.point[0] === p[0] &&
|
||||||
|
h.point[1] === p[1]) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
function processDatapoints() {
|
||||||
|
triggerCleanupEvent();
|
||||||
|
doTriggerClickHoverEvent(lastMouseMoveEvent, eventType.hover);
|
||||||
|
}
|
||||||
|
|
||||||
|
function setupGrid() {
|
||||||
|
doTriggerClickHoverEvent(lastMouseMoveEvent, eventType.hover);
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawOverlay(plot, octx, overlay) {
|
||||||
|
var plotOffset = plot.getPlotOffset(),
|
||||||
|
i, hi;
|
||||||
|
|
||||||
|
octx.save();
|
||||||
|
octx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
for (i = 0; i < highlights.length; ++i) {
|
||||||
|
hi = highlights[i];
|
||||||
|
|
||||||
|
if (hi.series.bars.show) drawBarHighlight(hi.series, hi.point, octx);
|
||||||
|
else drawPointHighlight(hi.series, hi.point, octx, plot);
|
||||||
|
}
|
||||||
|
octx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawPointHighlight(series, point, octx, plot) {
|
||||||
|
var x = point[0],
|
||||||
|
y = point[1],
|
||||||
|
axisx = series.xaxis,
|
||||||
|
axisy = series.yaxis,
|
||||||
|
highlightColor = (typeof series.highlightColor === "string") ? series.highlightColor : $.color.parse(series.color).scale('a', 0.5).toString();
|
||||||
|
|
||||||
|
if (x < axisx.min || x > axisx.max || y < axisy.min || y > axisy.max) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var pointRadius = series.points.radius + series.points.lineWidth / 2;
|
||||||
|
octx.lineWidth = pointRadius;
|
||||||
|
octx.strokeStyle = highlightColor;
|
||||||
|
var radius = 1.5 * pointRadius;
|
||||||
|
x = axisx.p2c(x);
|
||||||
|
y = axisy.p2c(y);
|
||||||
|
|
||||||
|
octx.beginPath();
|
||||||
|
var symbol = series.points.symbol;
|
||||||
|
if (symbol === 'circle') {
|
||||||
|
octx.arc(x, y, radius, 0, 2 * Math.PI, false);
|
||||||
|
} else if (typeof symbol === 'string' && plot.drawSymbol && plot.drawSymbol[symbol]) {
|
||||||
|
plot.drawSymbol[symbol](octx, x, y, radius, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
octx.closePath();
|
||||||
|
octx.stroke();
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawBarHighlight(series, point, octx) {
|
||||||
|
var highlightColor = (typeof series.highlightColor === "string") ? series.highlightColor : $.color.parse(series.color).scale('a', 0.5).toString(),
|
||||||
|
fillStyle = highlightColor,
|
||||||
|
barLeft;
|
||||||
|
|
||||||
|
var barWidth = series.bars.barWidth[0] || series.bars.barWidth;
|
||||||
|
switch (series.bars.align) {
|
||||||
|
case "left":
|
||||||
|
barLeft = 0;
|
||||||
|
break;
|
||||||
|
case "right":
|
||||||
|
barLeft = -barWidth;
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
barLeft = -barWidth / 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
octx.lineWidth = series.bars.lineWidth;
|
||||||
|
octx.strokeStyle = highlightColor;
|
||||||
|
|
||||||
|
var fillTowards = series.bars.fillTowards || 0,
|
||||||
|
bottom = fillTowards > series.yaxis.min ? Math.min(series.yaxis.max, fillTowards) : series.yaxis.min;
|
||||||
|
|
||||||
|
$.plot.drawSeries.drawBar(point[0], point[1], point[2] || bottom, barLeft, barLeft + barWidth,
|
||||||
|
function() {
|
||||||
|
return fillStyle;
|
||||||
|
}, series.xaxis, series.yaxis, octx, series.bars.horizontal, series.bars.lineWidth);
|
||||||
|
}
|
||||||
|
|
||||||
|
function initHover(plot, options) {
|
||||||
|
plot.highlight = highlight;
|
||||||
|
plot.unhighlight = unhighlight;
|
||||||
|
if (options.grid.hoverable || options.grid.clickable) {
|
||||||
|
plot.hooks.drawOverlay.push(drawOverlay);
|
||||||
|
plot.hooks.processDatapoints.push(processDatapoints);
|
||||||
|
plot.hooks.setupGrid.push(setupGrid);
|
||||||
|
}
|
||||||
|
|
||||||
|
lastMouseMoveEvent = plot.getPlaceholder()[0].lastMouseMoveEvent;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.bindEvents.push(bindEvents);
|
||||||
|
plot.hooks.shutdown.push(shutdown);
|
||||||
|
plot.hooks.processOptions.push(initHover);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'hover',
|
||||||
|
version: '0.1'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,249 @@
|
||||||
|
/* Flot plugin for plotting images.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The data syntax is [ [ image, x1, y1, x2, y2 ], ... ] where (x1, y1) and
|
||||||
|
(x2, y2) are where you intend the two opposite corners of the image to end up
|
||||||
|
in the plot. Image must be a fully loaded Javascript image (you can make one
|
||||||
|
with new Image()). If the image is not complete, it's skipped when plotting.
|
||||||
|
|
||||||
|
There are two helpers included for retrieving images. The easiest work the way
|
||||||
|
that you put in URLs instead of images in the data, like this:
|
||||||
|
|
||||||
|
[ "myimage.png", 0, 0, 10, 10 ]
|
||||||
|
|
||||||
|
Then call $.plot.image.loadData( data, options, callback ) where data and
|
||||||
|
options are the same as you pass in to $.plot. This loads the images, replaces
|
||||||
|
the URLs in the data with the corresponding images and calls "callback" when
|
||||||
|
all images are loaded (or failed loading). In the callback, you can then call
|
||||||
|
$.plot with the data set. See the included example.
|
||||||
|
|
||||||
|
A more low-level helper, $.plot.image.load(urls, callback) is also included.
|
||||||
|
Given a list of URLs, it calls callback with an object mapping from URL to
|
||||||
|
Image object when all images are loaded or have failed loading.
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
series: {
|
||||||
|
images: {
|
||||||
|
show: boolean
|
||||||
|
anchor: "corner" or "center"
|
||||||
|
alpha: [ 0, 1 ]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
They can be specified for a specific series:
|
||||||
|
|
||||||
|
$.plot( $("#placeholder"), [{
|
||||||
|
data: [ ... ],
|
||||||
|
images: { ... }
|
||||||
|
])
|
||||||
|
|
||||||
|
Note that because the data format is different from usual data points, you
|
||||||
|
can't use images with anything else in a specific data series.
|
||||||
|
|
||||||
|
Setting "anchor" to "center" causes the pixels in the image to be anchored at
|
||||||
|
the corner pixel centers inside of at the pixel corners, effectively letting
|
||||||
|
half a pixel stick out to each side in the plot.
|
||||||
|
|
||||||
|
A possible future direction could be support for tiling for large images (like
|
||||||
|
Google Maps).
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
series: {
|
||||||
|
images: {
|
||||||
|
show: false,
|
||||||
|
alpha: 1,
|
||||||
|
anchor: "corner" // or "center"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
$.plot.image = {};
|
||||||
|
|
||||||
|
$.plot.image.loadDataImages = function (series, options, callback) {
|
||||||
|
var urls = [], points = [];
|
||||||
|
|
||||||
|
var defaultShow = options.series.images.show;
|
||||||
|
|
||||||
|
$.each(series, function (i, s) {
|
||||||
|
if (!(defaultShow || s.images.show)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (s.data) {
|
||||||
|
s = s.data;
|
||||||
|
}
|
||||||
|
|
||||||
|
$.each(s, function (i, p) {
|
||||||
|
if (typeof p[0] === "string") {
|
||||||
|
urls.push(p[0]);
|
||||||
|
points.push(p);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
|
||||||
|
$.plot.image.load(urls, function (loadedImages) {
|
||||||
|
$.each(points, function (i, p) {
|
||||||
|
var url = p[0];
|
||||||
|
if (loadedImages[url]) {
|
||||||
|
p[0] = loadedImages[url];
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
callback();
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.image.load = function (urls, callback) {
|
||||||
|
var missing = urls.length, loaded = {};
|
||||||
|
if (missing === 0) {
|
||||||
|
callback({});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.each(urls, function (i, url) {
|
||||||
|
var handler = function () {
|
||||||
|
--missing;
|
||||||
|
loaded[url] = this;
|
||||||
|
|
||||||
|
if (missing === 0) {
|
||||||
|
callback(loaded);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
$('<img />').load(handler).error(handler).attr('src', url);
|
||||||
|
});
|
||||||
|
};
|
||||||
|
|
||||||
|
function drawSeries(plot, ctx, series) {
|
||||||
|
var plotOffset = plot.getPlotOffset();
|
||||||
|
|
||||||
|
if (!series.images || !series.images.show) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var points = series.datapoints.points,
|
||||||
|
ps = series.datapoints.pointsize;
|
||||||
|
|
||||||
|
for (var i = 0; i < points.length; i += ps) {
|
||||||
|
var img = points[i],
|
||||||
|
x1 = points[i + 1], y1 = points[i + 2],
|
||||||
|
x2 = points[i + 3], y2 = points[i + 4],
|
||||||
|
xaxis = series.xaxis, yaxis = series.yaxis,
|
||||||
|
tmp;
|
||||||
|
|
||||||
|
// actually we should check img.complete, but it
|
||||||
|
// appears to be a somewhat unreliable indicator in
|
||||||
|
// IE6 (false even after load event)
|
||||||
|
if (!img || img.width <= 0 || img.height <= 0) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (x1 > x2) {
|
||||||
|
tmp = x2;
|
||||||
|
x2 = x1;
|
||||||
|
x1 = tmp;
|
||||||
|
}
|
||||||
|
if (y1 > y2) {
|
||||||
|
tmp = y2;
|
||||||
|
y2 = y1;
|
||||||
|
y1 = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// if the anchor is at the center of the pixel, expand the
|
||||||
|
// image by 1/2 pixel in each direction
|
||||||
|
if (series.images.anchor === "center") {
|
||||||
|
tmp = 0.5 * (x2 - x1) / (img.width - 1);
|
||||||
|
x1 -= tmp;
|
||||||
|
x2 += tmp;
|
||||||
|
tmp = 0.5 * (y2 - y1) / (img.height - 1);
|
||||||
|
y1 -= tmp;
|
||||||
|
y2 += tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// clip
|
||||||
|
if (x1 === x2 || y1 === y2 ||
|
||||||
|
x1 >= xaxis.max || x2 <= xaxis.min ||
|
||||||
|
y1 >= yaxis.max || y2 <= yaxis.min) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
var sx1 = 0, sy1 = 0, sx2 = img.width, sy2 = img.height;
|
||||||
|
if (x1 < xaxis.min) {
|
||||||
|
sx1 += (sx2 - sx1) * (xaxis.min - x1) / (x2 - x1);
|
||||||
|
x1 = xaxis.min;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (x2 > xaxis.max) {
|
||||||
|
sx2 += (sx2 - sx1) * (xaxis.max - x2) / (x2 - x1);
|
||||||
|
x2 = xaxis.max;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (y1 < yaxis.min) {
|
||||||
|
sy2 += (sy1 - sy2) * (yaxis.min - y1) / (y2 - y1);
|
||||||
|
y1 = yaxis.min;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (y2 > yaxis.max) {
|
||||||
|
sy1 += (sy1 - sy2) * (yaxis.max - y2) / (y2 - y1);
|
||||||
|
y2 = yaxis.max;
|
||||||
|
}
|
||||||
|
|
||||||
|
x1 = xaxis.p2c(x1);
|
||||||
|
x2 = xaxis.p2c(x2);
|
||||||
|
y1 = yaxis.p2c(y1);
|
||||||
|
y2 = yaxis.p2c(y2);
|
||||||
|
|
||||||
|
// the transformation may have swapped us
|
||||||
|
if (x1 > x2) {
|
||||||
|
tmp = x2;
|
||||||
|
x2 = x1;
|
||||||
|
x1 = tmp;
|
||||||
|
}
|
||||||
|
if (y1 > y2) {
|
||||||
|
tmp = y2;
|
||||||
|
y2 = y1;
|
||||||
|
y1 = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
tmp = ctx.globalAlpha;
|
||||||
|
ctx.globalAlpha *= series.images.alpha;
|
||||||
|
ctx.drawImage(img,
|
||||||
|
sx1, sy1, sx2 - sx1, sy2 - sy1,
|
||||||
|
x1 + plotOffset.left, y1 + plotOffset.top,
|
||||||
|
x2 - x1, y2 - y1);
|
||||||
|
ctx.globalAlpha = tmp;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function processRawData(plot, series, data, datapoints) {
|
||||||
|
if (!series.images.show) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// format is Image, x1, y1, x2, y2 (opposite corners)
|
||||||
|
datapoints.format = [
|
||||||
|
{ required: true },
|
||||||
|
{ x: true, number: true, required: true },
|
||||||
|
{ y: true, number: true, required: true },
|
||||||
|
{ x: true, number: true, required: true },
|
||||||
|
{ y: true, number: true, required: true }
|
||||||
|
];
|
||||||
|
}
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processRawData.push(processRawData);
|
||||||
|
plot.hooks.drawSeries.push(drawSeries);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'image',
|
||||||
|
version: '1.1'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,437 @@
|
||||||
|
/* Flot plugin for drawing legends.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
var defaultOptions = {
|
||||||
|
legend: {
|
||||||
|
show: false,
|
||||||
|
noColumns: 1,
|
||||||
|
labelFormatter: null, // fn: string -> string
|
||||||
|
container: null, // container (as jQuery object) to put legend in, null means default on top of graph
|
||||||
|
position: 'ne', // position of default legend container within plot
|
||||||
|
margin: 5, // distance from grid edge to default legend container within plot
|
||||||
|
sorted: null // default to no legend sorting
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
function insertLegend(plot, options, placeholder, legendEntries) {
|
||||||
|
// clear before redraw
|
||||||
|
if (options.legend.container != null) {
|
||||||
|
$(options.legend.container).html('');
|
||||||
|
} else {
|
||||||
|
placeholder.find('.legend').remove();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!options.legend.show) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Save the legend entries in legend options
|
||||||
|
var entries = options.legend.legendEntries = legendEntries,
|
||||||
|
plotOffset = options.legend.plotOffset = plot.getPlotOffset(),
|
||||||
|
html = [],
|
||||||
|
entry, labelHtml, iconHtml,
|
||||||
|
j = 0,
|
||||||
|
i,
|
||||||
|
pos = "",
|
||||||
|
p = options.legend.position,
|
||||||
|
m = options.legend.margin,
|
||||||
|
shape = {
|
||||||
|
name: '',
|
||||||
|
label: '',
|
||||||
|
xPos: '',
|
||||||
|
yPos: ''
|
||||||
|
};
|
||||||
|
|
||||||
|
html[j++] = '<svg class="legendLayer" style="width:inherit;height:inherit;">';
|
||||||
|
html[j++] = '<rect class="background" width="100%" height="100%"/>';
|
||||||
|
html[j++] = svgShapeDefs;
|
||||||
|
|
||||||
|
var left = 0;
|
||||||
|
var columnWidths = [];
|
||||||
|
var style = window.getComputedStyle(document.querySelector('body'));
|
||||||
|
for (i = 0; i < entries.length; ++i) {
|
||||||
|
let columnIndex = i % options.legend.noColumns;
|
||||||
|
entry = entries[i];
|
||||||
|
shape.label = entry.label;
|
||||||
|
var info = plot.getSurface().getTextInfo('', shape.label, {
|
||||||
|
style: style.fontStyle,
|
||||||
|
variant: style.fontVariant,
|
||||||
|
weight: style.fontWeight,
|
||||||
|
size: parseInt(style.fontSize),
|
||||||
|
lineHeight: parseInt(style.lineHeight),
|
||||||
|
family: style.fontFamily
|
||||||
|
});
|
||||||
|
|
||||||
|
var labelWidth = info.width;
|
||||||
|
// 36px = 1.5em + 6px margin
|
||||||
|
var iconWidth = 48;
|
||||||
|
if (columnWidths[columnIndex]) {
|
||||||
|
if (labelWidth > columnWidths[columnIndex]) {
|
||||||
|
columnWidths[columnIndex] = labelWidth + iconWidth;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
columnWidths[columnIndex] = labelWidth + iconWidth;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Generate html for icons and labels from a list of entries
|
||||||
|
for (i = 0; i < entries.length; ++i) {
|
||||||
|
let columnIndex = i % options.legend.noColumns;
|
||||||
|
entry = entries[i];
|
||||||
|
iconHtml = '';
|
||||||
|
shape.label = entry.label;
|
||||||
|
shape.xPos = (left + 3) + 'px';
|
||||||
|
left += columnWidths[columnIndex];
|
||||||
|
if ((i + 1) % options.legend.noColumns === 0) {
|
||||||
|
left = 0;
|
||||||
|
}
|
||||||
|
shape.yPos = Math.floor(i / options.legend.noColumns) * 1.5 + 'em';
|
||||||
|
// area
|
||||||
|
if (entry.options.lines.show && entry.options.lines.fill) {
|
||||||
|
shape.name = 'area';
|
||||||
|
shape.fillColor = entry.color;
|
||||||
|
iconHtml += getEntryIconHtml(shape);
|
||||||
|
}
|
||||||
|
// bars
|
||||||
|
if (entry.options.bars.show) {
|
||||||
|
shape.name = 'bar';
|
||||||
|
shape.fillColor = entry.color;
|
||||||
|
iconHtml += getEntryIconHtml(shape);
|
||||||
|
}
|
||||||
|
// lines
|
||||||
|
if (entry.options.lines.show && !entry.options.lines.fill) {
|
||||||
|
shape.name = 'line';
|
||||||
|
shape.strokeColor = entry.color;
|
||||||
|
shape.strokeWidth = entry.options.lines.lineWidth;
|
||||||
|
iconHtml += getEntryIconHtml(shape);
|
||||||
|
}
|
||||||
|
// points
|
||||||
|
if (entry.options.points.show) {
|
||||||
|
shape.name = entry.options.points.symbol;
|
||||||
|
shape.strokeColor = entry.color;
|
||||||
|
shape.fillColor = entry.options.points.fillColor;
|
||||||
|
shape.strokeWidth = entry.options.points.lineWidth;
|
||||||
|
iconHtml += getEntryIconHtml(shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
labelHtml = '<text x="' + shape.xPos + '" y="' + shape.yPos + '" text-anchor="start"><tspan dx="2em" dy="1.2em">' + shape.label + '</tspan></text>'
|
||||||
|
html[j++] = '<g>' + iconHtml + labelHtml + '</g>';
|
||||||
|
}
|
||||||
|
|
||||||
|
html[j++] = '</svg>';
|
||||||
|
if (m[0] == null) {
|
||||||
|
m = [m, m];
|
||||||
|
}
|
||||||
|
|
||||||
|
if (p.charAt(0) === 'n') {
|
||||||
|
pos += 'top:' + (m[1] + plotOffset.top) + 'px;';
|
||||||
|
} else if (p.charAt(0) === 's') {
|
||||||
|
pos += 'bottom:' + (m[1] + plotOffset.bottom) + 'px;';
|
||||||
|
}
|
||||||
|
|
||||||
|
if (p.charAt(1) === 'e') {
|
||||||
|
pos += 'right:' + (m[0] + plotOffset.right) + 'px;';
|
||||||
|
} else if (p.charAt(1) === 'w') {
|
||||||
|
pos += 'left:' + (m[0] + plotOffset.left) + 'px;';
|
||||||
|
}
|
||||||
|
|
||||||
|
var width = 6;
|
||||||
|
for (i = 0; i < columnWidths.length; ++i) {
|
||||||
|
width += columnWidths[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
var legendEl,
|
||||||
|
height = Math.ceil(entries.length / options.legend.noColumns) * 1.6;
|
||||||
|
if (!options.legend.container) {
|
||||||
|
legendEl = $('<div class="legend" style="position:absolute;' + pos + '">' + html.join('') + '</div>').appendTo(placeholder);
|
||||||
|
legendEl.css('width', width + 'px');
|
||||||
|
legendEl.css('height', height + 'em');
|
||||||
|
legendEl.css('pointerEvents', 'none');
|
||||||
|
} else {
|
||||||
|
legendEl = $(html.join('')).appendTo(options.legend.container)[0];
|
||||||
|
options.legend.container.style.width = width + 'px';
|
||||||
|
options.legend.container.style.height = height + 'em';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Generate html for a shape
|
||||||
|
function getEntryIconHtml(shape) {
|
||||||
|
var html = '',
|
||||||
|
name = shape.name,
|
||||||
|
x = shape.xPos,
|
||||||
|
y = shape.yPos,
|
||||||
|
fill = shape.fillColor,
|
||||||
|
stroke = shape.strokeColor,
|
||||||
|
width = shape.strokeWidth;
|
||||||
|
switch (name) {
|
||||||
|
case 'circle':
|
||||||
|
html = '<use xlink:href="#circle" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'diamond':
|
||||||
|
html = '<use xlink:href="#diamond" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'cross':
|
||||||
|
html = '<use xlink:href="#cross" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
// 'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'rectangle':
|
||||||
|
html = '<use xlink:href="#rectangle" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'plus':
|
||||||
|
html = '<use xlink:href="#plus" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
// 'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'bar':
|
||||||
|
html = '<use xlink:href="#bars" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
'fill="' + fill + '" ' +
|
||||||
|
// 'stroke="' + stroke + '" ' +
|
||||||
|
// 'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'area':
|
||||||
|
html = '<use xlink:href="#area" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
'fill="' + fill + '" ' +
|
||||||
|
// 'stroke="' + stroke + '" ' +
|
||||||
|
// 'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
case 'line':
|
||||||
|
html = '<use xlink:href="#line" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
// 'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
// default is circle
|
||||||
|
html = '<use xlink:href="#circle" class="legendIcon" ' +
|
||||||
|
'x="' + x + '" ' +
|
||||||
|
'y="' + y + '" ' +
|
||||||
|
'fill="' + fill + '" ' +
|
||||||
|
'stroke="' + stroke + '" ' +
|
||||||
|
'stroke-width="' + width + '" ' +
|
||||||
|
'width="1.5em" height="1.5em"' +
|
||||||
|
'/>';
|
||||||
|
}
|
||||||
|
|
||||||
|
return html;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Define svg symbols for shapes
|
||||||
|
var svgShapeDefs = '' +
|
||||||
|
'<defs>' +
|
||||||
|
'<symbol id="line" fill="none" viewBox="-5 -5 25 25">' +
|
||||||
|
'<polyline points="0,15 5,5 10,10 15,0"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="area" stroke-width="1" viewBox="-5 -5 25 25">' +
|
||||||
|
'<polyline points="0,15 5,5 10,10 15,0, 15,15, 0,15"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="bars" stroke-width="1" viewBox="-5 -5 25 25">' +
|
||||||
|
'<polyline points="1.5,15.5 1.5,12.5, 4.5,12.5 4.5,15.5 6.5,15.5 6.5,3.5, 9.5,3.5 9.5,15.5 11.5,15.5 11.5,7.5 14.5,7.5 14.5,15.5 1.5,15.5"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="circle" viewBox="-5 -5 25 25">' +
|
||||||
|
'<circle cx="0" cy="15" r="2.5"/>' +
|
||||||
|
'<circle cx="5" cy="5" r="2.5"/>' +
|
||||||
|
'<circle cx="10" cy="10" r="2.5"/>' +
|
||||||
|
'<circle cx="15" cy="0" r="2.5"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="rectangle" viewBox="-5 -5 25 25">' +
|
||||||
|
'<rect x="-2.1" y="12.9" width="4.2" height="4.2"/>' +
|
||||||
|
'<rect x="2.9" y="2.9" width="4.2" height="4.2"/>' +
|
||||||
|
'<rect x="7.9" y="7.9" width="4.2" height="4.2"/>' +
|
||||||
|
'<rect x="12.9" y="-2.1" width="4.2" height="4.2"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="diamond" viewBox="-5 -5 25 25">' +
|
||||||
|
'<path d="M-3,15 L0,12 L3,15, L0,18 Z"/>' +
|
||||||
|
'<path d="M2,5 L5,2 L8,5, L5,8 Z"/>' +
|
||||||
|
'<path d="M7,10 L10,7 L13,10, L10,13 Z"/>' +
|
||||||
|
'<path d="M12,0 L15,-3 L18,0, L15,3 Z"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="cross" fill="none" viewBox="-5 -5 25 25">' +
|
||||||
|
'<path d="M-2.1,12.9 L2.1,17.1, M2.1,12.9 L-2.1,17.1 Z"/>' +
|
||||||
|
'<path d="M2.9,2.9 L7.1,7.1 M7.1,2.9 L2.9,7.1 Z"/>' +
|
||||||
|
'<path d="M7.9,7.9 L12.1,12.1 M12.1,7.9 L7.9,12.1 Z"/>' +
|
||||||
|
'<path d="M12.9,-2.1 L17.1,2.1 M17.1,-2.1 L12.9,2.1 Z"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
|
||||||
|
'<symbol id="plus" fill="none" viewBox="-5 -5 25 25">' +
|
||||||
|
'<path d="M0,12 L0,18, M-3,15 L3,15 Z"/>' +
|
||||||
|
'<path d="M5,2 L5,8 M2,5 L8,5 Z"/>' +
|
||||||
|
'<path d="M10,7 L10,13 M7,10 L13,10 Z"/>' +
|
||||||
|
'<path d="M15,-3 L15,3 M12,0 L18,0 Z"/>' +
|
||||||
|
'</symbol>' +
|
||||||
|
'</defs>';
|
||||||
|
|
||||||
|
// Generate a list of legend entries in their final order
|
||||||
|
function getLegendEntries(series, labelFormatter, sorted) {
|
||||||
|
var lf = labelFormatter,
|
||||||
|
legendEntries = series.reduce(function(validEntries, s, i) {
|
||||||
|
var labelEval = (lf ? lf(s.label, s) : s.label)
|
||||||
|
if (s.hasOwnProperty("label") ? labelEval : true) {
|
||||||
|
var entry = {
|
||||||
|
label: labelEval || 'Plot ' + (i + 1),
|
||||||
|
color: s.color,
|
||||||
|
options: {
|
||||||
|
lines: s.lines,
|
||||||
|
points: s.points,
|
||||||
|
bars: s.bars
|
||||||
|
}
|
||||||
|
}
|
||||||
|
validEntries.push(entry)
|
||||||
|
}
|
||||||
|
return validEntries;
|
||||||
|
}, []);
|
||||||
|
|
||||||
|
// Sort the legend using either the default or a custom comparator
|
||||||
|
if (sorted) {
|
||||||
|
if ($.isFunction(sorted)) {
|
||||||
|
legendEntries.sort(sorted);
|
||||||
|
} else if (sorted === 'reverse') {
|
||||||
|
legendEntries.reverse();
|
||||||
|
} else {
|
||||||
|
var ascending = (sorted !== 'descending');
|
||||||
|
legendEntries.sort(function(a, b) {
|
||||||
|
return a.label === b.label
|
||||||
|
? 0
|
||||||
|
: ((a.label < b.label) !== ascending ? 1 : -1 // Logical XOR
|
||||||
|
);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return legendEntries;
|
||||||
|
}
|
||||||
|
|
||||||
|
// return false if opts1 same as opts2
|
||||||
|
function checkOptions(opts1, opts2) {
|
||||||
|
for (var prop in opts1) {
|
||||||
|
if (opts1.hasOwnProperty(prop)) {
|
||||||
|
if (opts1[prop] !== opts2[prop]) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compare two lists of legend entries
|
||||||
|
function shouldRedraw(oldEntries, newEntries) {
|
||||||
|
if (!oldEntries || !newEntries) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (oldEntries.length !== newEntries.length) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
var i, newEntry, oldEntry, newOpts, oldOpts;
|
||||||
|
for (i = 0; i < newEntries.length; i++) {
|
||||||
|
newEntry = newEntries[i];
|
||||||
|
oldEntry = oldEntries[i];
|
||||||
|
|
||||||
|
if (newEntry.label !== oldEntry.label) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (newEntry.color !== oldEntry.color) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// check for changes in lines options
|
||||||
|
newOpts = newEntry.options.lines;
|
||||||
|
oldOpts = oldEntry.options.lines;
|
||||||
|
if (checkOptions(newOpts, oldOpts)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// check for changes in points options
|
||||||
|
newOpts = newEntry.options.points;
|
||||||
|
oldOpts = oldEntry.options.points;
|
||||||
|
if (checkOptions(newOpts, oldOpts)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// check for changes in bars options
|
||||||
|
newOpts = newEntry.options.bars;
|
||||||
|
oldOpts = oldEntry.options.bars;
|
||||||
|
if (checkOptions(newOpts, oldOpts)) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.setupGrid.push(function (plot) {
|
||||||
|
var options = plot.getOptions();
|
||||||
|
var series = plot.getData(),
|
||||||
|
labelFormatter = options.legend.labelFormatter,
|
||||||
|
oldEntries = options.legend.legendEntries,
|
||||||
|
oldPlotOffset = options.legend.plotOffset,
|
||||||
|
newEntries = getLegendEntries(series, labelFormatter, options.legend.sorted),
|
||||||
|
newPlotOffset = plot.getPlotOffset();
|
||||||
|
|
||||||
|
if (shouldRedraw(oldEntries, newEntries) ||
|
||||||
|
checkOptions(oldPlotOffset, newPlotOffset)) {
|
||||||
|
insertLegend(plot, options, plot.getPlaceholder(), newEntries);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: defaultOptions,
|
||||||
|
name: 'legend',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,298 @@
|
||||||
|
/* Pretty handling of log axes.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Copyright (c) 2015 Ciprian Ceteras cipix2000@gmail.com.
|
||||||
|
Copyright (c) 2017 Raluca Portase
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
Set axis.mode to "log" to enable.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* global jQuery*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
## jquery.flot.logaxis
|
||||||
|
This plugin is used to create logarithmic axis. This includes tick generation,
|
||||||
|
formatters and transformers to and from logarithmic representation.
|
||||||
|
|
||||||
|
### Methods and hooks
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
xaxis: {}
|
||||||
|
};
|
||||||
|
|
||||||
|
/*tick generators and formatters*/
|
||||||
|
var PREFERRED_LOG_TICK_VALUES = computePreferedLogTickValues(Number.MAX_VALUE, 10),
|
||||||
|
EXTENDED_LOG_TICK_VALUES = computePreferedLogTickValues(Number.MAX_VALUE, 4);
|
||||||
|
|
||||||
|
function computePreferedLogTickValues(endLimit, rangeStep) {
|
||||||
|
var log10End = Math.floor(Math.log(endLimit) * Math.LOG10E) - 1,
|
||||||
|
log10Start = -log10End,
|
||||||
|
val, range, vals = [];
|
||||||
|
|
||||||
|
for (var power = log10Start; power <= log10End; power++) {
|
||||||
|
range = parseFloat('1e' + power);
|
||||||
|
for (var mult = 1; mult < 9; mult += rangeStep) {
|
||||||
|
val = range * mult;
|
||||||
|
vals.push(val);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return vals;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- logTickGenerator(plot, axis, noTicks)
|
||||||
|
|
||||||
|
Generates logarithmic ticks, depending on axis range.
|
||||||
|
In case the number of ticks that can be generated is less than the expected noTicks/4,
|
||||||
|
a linear tick generation is used.
|
||||||
|
*/
|
||||||
|
var logTickGenerator = function (plot, axis, noTicks) {
|
||||||
|
var ticks = [],
|
||||||
|
minIdx = -1,
|
||||||
|
maxIdx = -1,
|
||||||
|
surface = plot.getCanvas(),
|
||||||
|
logTickValues = PREFERRED_LOG_TICK_VALUES,
|
||||||
|
min = clampAxis(axis, plot),
|
||||||
|
max = axis.max;
|
||||||
|
|
||||||
|
if (!noTicks) {
|
||||||
|
noTicks = 0.3 * Math.sqrt(axis.direction === "x" ? surface.width : surface.height);
|
||||||
|
}
|
||||||
|
|
||||||
|
PREFERRED_LOG_TICK_VALUES.some(function (val, i) {
|
||||||
|
if (val >= min) {
|
||||||
|
minIdx = i;
|
||||||
|
return true;
|
||||||
|
} else {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
PREFERRED_LOG_TICK_VALUES.some(function (val, i) {
|
||||||
|
if (val >= max) {
|
||||||
|
maxIdx = i;
|
||||||
|
return true;
|
||||||
|
} else {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
if (maxIdx === -1) {
|
||||||
|
maxIdx = PREFERRED_LOG_TICK_VALUES.length - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (maxIdx - minIdx <= noTicks / 4 && logTickValues.length !== EXTENDED_LOG_TICK_VALUES.length) {
|
||||||
|
//try with multiple of 5 for tick values
|
||||||
|
logTickValues = EXTENDED_LOG_TICK_VALUES;
|
||||||
|
minIdx *= 2;
|
||||||
|
maxIdx *= 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
var lastDisplayed = null,
|
||||||
|
inverseNoTicks = 1 / noTicks,
|
||||||
|
tickValue, pixelCoord, tick;
|
||||||
|
|
||||||
|
// Count the number of tick values would appear, if we can get at least
|
||||||
|
// nTicks / 4 accept them.
|
||||||
|
if (maxIdx - minIdx >= noTicks / 4) {
|
||||||
|
for (var idx = maxIdx; idx >= minIdx; idx--) {
|
||||||
|
tickValue = logTickValues[idx];
|
||||||
|
pixelCoord = (Math.log(tickValue) - Math.log(min)) / (Math.log(max) - Math.log(min));
|
||||||
|
tick = tickValue;
|
||||||
|
|
||||||
|
if (lastDisplayed === null) {
|
||||||
|
lastDisplayed = {
|
||||||
|
pixelCoord: pixelCoord,
|
||||||
|
idealPixelCoord: pixelCoord
|
||||||
|
};
|
||||||
|
} else {
|
||||||
|
if (Math.abs(pixelCoord - lastDisplayed.pixelCoord) >= inverseNoTicks) {
|
||||||
|
lastDisplayed = {
|
||||||
|
pixelCoord: pixelCoord,
|
||||||
|
idealPixelCoord: lastDisplayed.idealPixelCoord - inverseNoTicks
|
||||||
|
};
|
||||||
|
} else {
|
||||||
|
tick = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (tick) {
|
||||||
|
ticks.push(tick);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
// Since we went in backwards order.
|
||||||
|
ticks.reverse();
|
||||||
|
} else {
|
||||||
|
var tickSize = plot.computeTickSize(min, max, noTicks),
|
||||||
|
customAxis = {min: min, max: max, tickSize: tickSize};
|
||||||
|
ticks = $.plot.linearTickGenerator(customAxis);
|
||||||
|
}
|
||||||
|
|
||||||
|
return ticks;
|
||||||
|
};
|
||||||
|
|
||||||
|
var clampAxis = function (axis, plot) {
|
||||||
|
var min = axis.min,
|
||||||
|
max = axis.max;
|
||||||
|
|
||||||
|
if (min <= 0) {
|
||||||
|
//for empty graph if axis.min is not strictly positive make it 0.1
|
||||||
|
if (axis.datamin === null) {
|
||||||
|
min = axis.min = 0.1;
|
||||||
|
} else {
|
||||||
|
min = processAxisOffset(plot, axis);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (max < min) {
|
||||||
|
axis.max = axis.datamax !== null ? axis.datamax : axis.options.max;
|
||||||
|
axis.options.offset.below = 0;
|
||||||
|
axis.options.offset.above = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return min;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- logTickFormatter(value, axis, precision)
|
||||||
|
|
||||||
|
This is the corresponding tickFormatter of the logaxis.
|
||||||
|
For a number greater that 10^6 or smaller than 10^(-3), this will be drawn
|
||||||
|
with e representation
|
||||||
|
*/
|
||||||
|
var logTickFormatter = function (value, axis, precision) {
|
||||||
|
var tenExponent = value > 0 ? Math.floor(Math.log(value) / Math.LN10) : 0;
|
||||||
|
|
||||||
|
if (precision) {
|
||||||
|
if ((tenExponent >= -4) && (tenExponent <= 7)) {
|
||||||
|
return $.plot.defaultTickFormatter(value, axis, precision);
|
||||||
|
} else {
|
||||||
|
return $.plot.expRepTickFormatter(value, axis, precision);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if ((tenExponent >= -4) && (tenExponent <= 7)) {
|
||||||
|
//if we have float numbers, return a limited length string(ex: 0.0009 is represented as 0.000900001)
|
||||||
|
var formattedValue = tenExponent < 0 ? value.toFixed(-tenExponent) : value.toFixed(tenExponent + 2);
|
||||||
|
if (formattedValue.indexOf('.') !== -1) {
|
||||||
|
var lastZero = formattedValue.lastIndexOf('0');
|
||||||
|
|
||||||
|
while (lastZero === formattedValue.length - 1) {
|
||||||
|
formattedValue = formattedValue.slice(0, -1);
|
||||||
|
lastZero = formattedValue.lastIndexOf('0');
|
||||||
|
}
|
||||||
|
|
||||||
|
//delete the dot if is last
|
||||||
|
if (formattedValue.indexOf('.') === formattedValue.length - 1) {
|
||||||
|
formattedValue = formattedValue.slice(0, -1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return formattedValue;
|
||||||
|
} else {
|
||||||
|
return $.plot.expRepTickFormatter(value, axis);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/*logaxis caracteristic functions*/
|
||||||
|
var logTransform = function (v) {
|
||||||
|
if (v < PREFERRED_LOG_TICK_VALUES[0]) {
|
||||||
|
v = PREFERRED_LOG_TICK_VALUES[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
return Math.log(v);
|
||||||
|
};
|
||||||
|
|
||||||
|
var logInverseTransform = function (v) {
|
||||||
|
return Math.exp(v);
|
||||||
|
};
|
||||||
|
|
||||||
|
var invertedTransform = function (v) {
|
||||||
|
return -v;
|
||||||
|
}
|
||||||
|
|
||||||
|
var invertedLogTransform = function (v) {
|
||||||
|
return -logTransform(v);
|
||||||
|
}
|
||||||
|
|
||||||
|
var invertedLogInverseTransform = function (v) {
|
||||||
|
return logInverseTransform(-v);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
- setDataminRange(plot, axis)
|
||||||
|
|
||||||
|
It is used for clamping the starting point of a logarithmic axis.
|
||||||
|
This will set the axis datamin range to 0.1 or to the first datapoint greater then 0.
|
||||||
|
The function is usefull since the logarithmic representation can not show
|
||||||
|
values less than or equal to 0.
|
||||||
|
*/
|
||||||
|
function setDataminRange(plot, axis) {
|
||||||
|
if (axis.options.mode === 'log' && axis.datamin <= 0) {
|
||||||
|
if (axis.datamin === null) {
|
||||||
|
axis.datamin = 0.1;
|
||||||
|
} else {
|
||||||
|
axis.datamin = processAxisOffset(plot, axis);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function processAxisOffset(plot, axis) {
|
||||||
|
var series = plot.getData(),
|
||||||
|
range = series
|
||||||
|
.filter(function(series) {
|
||||||
|
return series.xaxis === axis || series.yaxis === axis;
|
||||||
|
})
|
||||||
|
.map(function(series) {
|
||||||
|
return plot.computeRangeForDataSeries(series, null, isValid);
|
||||||
|
}),
|
||||||
|
min = axis.direction === 'x'
|
||||||
|
? Math.min(0.1, range && range[0] ? range[0].xmin : 0.1)
|
||||||
|
: Math.min(0.1, range && range[0] ? range[0].ymin : 0.1);
|
||||||
|
|
||||||
|
axis.min = min;
|
||||||
|
|
||||||
|
return min;
|
||||||
|
}
|
||||||
|
|
||||||
|
function isValid(a) {
|
||||||
|
return a > 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processOptions.push(function (plot) {
|
||||||
|
$.each(plot.getAxes(), function (axisName, axis) {
|
||||||
|
var opts = axis.options;
|
||||||
|
if (opts.mode === 'log') {
|
||||||
|
axis.tickGenerator = function (axis) {
|
||||||
|
var noTicks = 11;
|
||||||
|
return logTickGenerator(plot, axis, noTicks);
|
||||||
|
};
|
||||||
|
if (typeof axis.options.tickFormatter !== 'function') {
|
||||||
|
axis.options.tickFormatter = logTickFormatter;
|
||||||
|
}
|
||||||
|
axis.options.transform = opts.inverted ? invertedLogTransform : logTransform;
|
||||||
|
axis.options.inverseTransform = opts.inverted ? invertedLogInverseTransform : logInverseTransform;
|
||||||
|
axis.options.autoScaleMargin = 0;
|
||||||
|
plot.hooks.setRange.push(setDataminRange);
|
||||||
|
} else if (opts.inverted) {
|
||||||
|
axis.options.transform = invertedTransform;
|
||||||
|
axis.options.inverseTransform = invertedTransform;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'log',
|
||||||
|
version: '0.1'
|
||||||
|
});
|
||||||
|
|
||||||
|
$.plot.logTicksGenerator = logTickGenerator;
|
||||||
|
$.plot.logTickFormatter = logTickFormatter;
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,834 @@
|
||||||
|
/* Flot plugin for adding the ability to pan and zoom the plot.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Copyright (c) 2016 Ciprian Ceteras.
|
||||||
|
Copyright (c) 2017 Raluca Portase.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**
|
||||||
|
## jquery.flot.navigate.js
|
||||||
|
|
||||||
|
This flot plugin is used for adding the ability to pan and zoom the plot.
|
||||||
|
A higher level overview is available at [interactions](interactions.md) documentation.
|
||||||
|
|
||||||
|
The default behaviour is scrollwheel up/down to zoom in, drag
|
||||||
|
to pan. The plugin defines plot.zoom({ center }), plot.zoomOut() and
|
||||||
|
plot.pan( offset ) so you easily can add custom controls. It also fires
|
||||||
|
"plotpan" and "plotzoom" events, useful for synchronizing plots.
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
```js
|
||||||
|
zoom: {
|
||||||
|
interactive: false,
|
||||||
|
active: false,
|
||||||
|
amount: 1.5 // 2 = 200% (zoom in), 0.5 = 50% (zoom out)
|
||||||
|
}
|
||||||
|
|
||||||
|
pan: {
|
||||||
|
interactive: false,
|
||||||
|
active: false,
|
||||||
|
cursor: "move", // CSS mouse cursor value used when dragging, e.g. "pointer"
|
||||||
|
frameRate: 60,
|
||||||
|
mode: "smart" // enable smart pan mode
|
||||||
|
}
|
||||||
|
|
||||||
|
xaxis: {
|
||||||
|
axisZoom: true, //zoom axis when mouse over it is allowed
|
||||||
|
plotZoom: true, //zoom axis is allowed for plot zoom
|
||||||
|
axisPan: true, //pan axis when mouse over it is allowed
|
||||||
|
plotPan: true, //pan axis is allowed for plot pan
|
||||||
|
panRange: [undefined, undefined], // no limit on pan range, or [min, max] in axis units
|
||||||
|
zoomRange: [undefined, undefined], // no limit on zoom range, or [closest zoom, furthest zoom] in axis units
|
||||||
|
}
|
||||||
|
|
||||||
|
yaxis: {
|
||||||
|
axisZoom: true, //zoom axis when mouse over it is allowed
|
||||||
|
plotZoom: true, //zoom axis is allowed for plot zoom
|
||||||
|
axisPan: true, //pan axis when mouse over it is allowed
|
||||||
|
plotPan: true //pan axis is allowed for plot pan
|
||||||
|
panRange: [undefined, undefined], // no limit on pan range, or [min, max] in axis units
|
||||||
|
zoomRange: [undefined, undefined], // no limit on zoom range, or [closest zoom, furthest zoom] in axis units
|
||||||
|
}
|
||||||
|
```
|
||||||
|
**interactive** enables the built-in drag/click behaviour. If you enable
|
||||||
|
interactive for pan, then you'll have a basic plot that supports moving
|
||||||
|
around; the same for zoom.
|
||||||
|
|
||||||
|
**active** is true after a touch tap on plot. This enables plot navigation.
|
||||||
|
Once activated, zoom and pan cannot be deactivated. When the plot becomes active,
|
||||||
|
"plotactivated" event is triggered.
|
||||||
|
|
||||||
|
**amount** specifies the default amount to zoom in (so 1.5 = 150%) relative to
|
||||||
|
the current viewport.
|
||||||
|
|
||||||
|
**cursor** is a standard CSS mouse cursor string used for visual feedback to the
|
||||||
|
user when dragging.
|
||||||
|
|
||||||
|
**frameRate** specifies the maximum number of times per second the plot will
|
||||||
|
update itself while the user is panning around on it (set to null to disable
|
||||||
|
intermediate pans, the plot will then not update until the mouse button is
|
||||||
|
released).
|
||||||
|
|
||||||
|
**mode** a string specifies the pan mode for mouse interaction. Accepted values:
|
||||||
|
'manual': no pan hint or direction snapping;
|
||||||
|
'smart': The graph shows pan hint bar and the pan movement will snap
|
||||||
|
to one direction when the drag direction is close to it;
|
||||||
|
'smartLock'. The graph shows pan hint bar and the pan movement will always
|
||||||
|
snap to a direction that the drag diorection started with.
|
||||||
|
|
||||||
|
Example API usage:
|
||||||
|
```js
|
||||||
|
plot = $.plot(...);
|
||||||
|
|
||||||
|
// zoom default amount in on the pixel ( 10, 20 )
|
||||||
|
plot.zoom({ center: { left: 10, top: 20 } });
|
||||||
|
|
||||||
|
// zoom out again
|
||||||
|
plot.zoomOut({ center: { left: 10, top: 20 } });
|
||||||
|
|
||||||
|
// zoom 200% in on the pixel (10, 20)
|
||||||
|
plot.zoom({ amount: 2, center: { left: 10, top: 20 } });
|
||||||
|
|
||||||
|
// pan 100 pixels to the left (changing x-range in a positive way) and 20 down
|
||||||
|
plot.pan({ left: -100, top: 20 })
|
||||||
|
```
|
||||||
|
|
||||||
|
Here, "center" specifies where the center of the zooming should happen. Note
|
||||||
|
that this is defined in pixel space, not the space of the data points (you can
|
||||||
|
use the p2c helpers on the axes in Flot to help you convert between these).
|
||||||
|
|
||||||
|
**amount** is the amount to zoom the viewport relative to the current range, so
|
||||||
|
1 is 100% (i.e. no change), 1.5 is 150% (zoom in), 0.7 is 70% (zoom out). You
|
||||||
|
can set the default in the options.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* eslint-enable */
|
||||||
|
(function($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
zoom: {
|
||||||
|
interactive: false,
|
||||||
|
active: false,
|
||||||
|
amount: 1.5 // how much to zoom relative to current position, 2 = 200% (zoom in), 0.5 = 50% (zoom out)
|
||||||
|
},
|
||||||
|
pan: {
|
||||||
|
interactive: false,
|
||||||
|
active: false,
|
||||||
|
cursor: "move",
|
||||||
|
frameRate: 60,
|
||||||
|
mode: 'smart'
|
||||||
|
},
|
||||||
|
recenter: {
|
||||||
|
interactive: true
|
||||||
|
},
|
||||||
|
xaxis: {
|
||||||
|
axisZoom: true, //zoom axis when mouse over it is allowed
|
||||||
|
plotZoom: true, //zoom axis is allowed for plot zoom
|
||||||
|
axisPan: true, //pan axis when mouse over it is allowed
|
||||||
|
plotPan: true, //pan axis is allowed for plot pan
|
||||||
|
panRange: [undefined, undefined], // no limit on pan range, or [min, max] in axis units
|
||||||
|
zoomRange: [undefined, undefined] // no limit on zoom range, or [closest zoom, furthest zoom] in axis units
|
||||||
|
},
|
||||||
|
yaxis: {
|
||||||
|
axisZoom: true,
|
||||||
|
plotZoom: true,
|
||||||
|
axisPan: true,
|
||||||
|
plotPan: true,
|
||||||
|
panRange: [undefined, undefined], // no limit on pan range, or [min, max] in axis units
|
||||||
|
zoomRange: [undefined, undefined] // no limit on zoom range, or [closest zoom, furthest zoom] in axis units
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var saturated = $.plot.saturated;
|
||||||
|
var browser = $.plot.browser;
|
||||||
|
var SNAPPING_CONSTANT = $.plot.uiConstants.SNAPPING_CONSTANT;
|
||||||
|
var PANHINT_LENGTH_CONSTANT = $.plot.uiConstants.PANHINT_LENGTH_CONSTANT;
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processOptions.push(initNevigation);
|
||||||
|
}
|
||||||
|
|
||||||
|
function initNevigation(plot, options) {
|
||||||
|
var panAxes = null;
|
||||||
|
var canDrag = false;
|
||||||
|
var useManualPan = options.pan.mode === 'manual',
|
||||||
|
smartPanLock = options.pan.mode === 'smartLock',
|
||||||
|
useSmartPan = smartPanLock || options.pan.mode === 'smart';
|
||||||
|
|
||||||
|
function onZoomClick(e, zoomOut, amount) {
|
||||||
|
var page = browser.getPageXY(e);
|
||||||
|
|
||||||
|
var c = plot.offset();
|
||||||
|
c.left = page.X - c.left;
|
||||||
|
c.top = page.Y - c.top;
|
||||||
|
|
||||||
|
var ec = plot.getPlaceholder().offset();
|
||||||
|
ec.left = page.X - ec.left;
|
||||||
|
ec.top = page.Y - ec.top;
|
||||||
|
|
||||||
|
var axes = plot.getXAxes().concat(plot.getYAxes()).filter(function (axis) {
|
||||||
|
var box = axis.box;
|
||||||
|
if (box !== undefined) {
|
||||||
|
return (ec.left > box.left) && (ec.left < box.left + box.width) &&
|
||||||
|
(ec.top > box.top) && (ec.top < box.top + box.height);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
if (axes.length === 0) {
|
||||||
|
axes = undefined;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (zoomOut) {
|
||||||
|
plot.zoomOut({
|
||||||
|
center: c,
|
||||||
|
axes: axes,
|
||||||
|
amount: amount
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
plot.zoom({
|
||||||
|
center: c,
|
||||||
|
axes: axes,
|
||||||
|
amount: amount
|
||||||
|
});
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var prevCursor = 'default',
|
||||||
|
panHint = null,
|
||||||
|
panTimeout = null,
|
||||||
|
plotState,
|
||||||
|
prevDragPosition = { x: 0, y: 0 },
|
||||||
|
isPanAction = false;
|
||||||
|
|
||||||
|
function onMouseWheel(e, delta) {
|
||||||
|
var maxAbsoluteDeltaOnMac = 1,
|
||||||
|
isMacScroll = Math.abs(e.originalEvent.deltaY) <= maxAbsoluteDeltaOnMac,
|
||||||
|
defaultNonMacScrollAmount = null,
|
||||||
|
macMagicRatio = 50,
|
||||||
|
amount = isMacScroll ? 1 + Math.abs(e.originalEvent.deltaY) / macMagicRatio : defaultNonMacScrollAmount;
|
||||||
|
|
||||||
|
if (isPanAction) {
|
||||||
|
onDragEnd(e);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (plot.getOptions().zoom.active) {
|
||||||
|
e.preventDefault();
|
||||||
|
onZoomClick(e, delta < 0, amount);
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.navigationState = function(startPageX, startPageY) {
|
||||||
|
var axes = this.getAxes();
|
||||||
|
var result = {};
|
||||||
|
Object.keys(axes).forEach(function(axisName) {
|
||||||
|
var axis = axes[axisName];
|
||||||
|
result[axisName] = {
|
||||||
|
navigationOffset: { below: axis.options.offset.below || 0,
|
||||||
|
above: axis.options.offset.above || 0},
|
||||||
|
axisMin: axis.min,
|
||||||
|
axisMax: axis.max,
|
||||||
|
diagMode: false
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
result.startPageX = startPageX || 0;
|
||||||
|
result.startPageY = startPageY || 0;
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
function onMouseDown(e) {
|
||||||
|
canDrag = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
function onMouseUp(e) {
|
||||||
|
canDrag = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
function isLeftMouseButtonPressed(e) {
|
||||||
|
return e.button === 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
function onDragStart(e) {
|
||||||
|
if (!canDrag || !isLeftMouseButtonPressed(e)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
isPanAction = true;
|
||||||
|
var page = browser.getPageXY(e);
|
||||||
|
|
||||||
|
var ec = plot.getPlaceholder().offset();
|
||||||
|
ec.left = page.X - ec.left;
|
||||||
|
ec.top = page.Y - ec.top;
|
||||||
|
|
||||||
|
panAxes = plot.getXAxes().concat(plot.getYAxes()).filter(function (axis) {
|
||||||
|
var box = axis.box;
|
||||||
|
if (box !== undefined) {
|
||||||
|
return (ec.left > box.left) && (ec.left < box.left + box.width) &&
|
||||||
|
(ec.top > box.top) && (ec.top < box.top + box.height);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
if (panAxes.length === 0) {
|
||||||
|
panAxes = undefined;
|
||||||
|
}
|
||||||
|
|
||||||
|
var c = plot.getPlaceholder().css('cursor');
|
||||||
|
if (c) {
|
||||||
|
prevCursor = c;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.getPlaceholder().css('cursor', plot.getOptions().pan.cursor);
|
||||||
|
|
||||||
|
if (useSmartPan) {
|
||||||
|
plotState = plot.navigationState(page.X, page.Y);
|
||||||
|
} else if (useManualPan) {
|
||||||
|
prevDragPosition.x = page.X;
|
||||||
|
prevDragPosition.y = page.Y;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function onDrag(e) {
|
||||||
|
if (!isPanAction) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
var page = browser.getPageXY(e);
|
||||||
|
var frameRate = plot.getOptions().pan.frameRate;
|
||||||
|
|
||||||
|
if (frameRate === -1) {
|
||||||
|
if (useSmartPan) {
|
||||||
|
plot.smartPan({
|
||||||
|
x: plotState.startPageX - page.X,
|
||||||
|
y: plotState.startPageY - page.Y
|
||||||
|
}, plotState, panAxes, false, smartPanLock);
|
||||||
|
} else if (useManualPan) {
|
||||||
|
plot.pan({
|
||||||
|
left: prevDragPosition.x - page.X,
|
||||||
|
top: prevDragPosition.y - page.Y,
|
||||||
|
axes: panAxes
|
||||||
|
});
|
||||||
|
prevDragPosition.x = page.X;
|
||||||
|
prevDragPosition.y = page.Y;
|
||||||
|
}
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (panTimeout || !frameRate) return;
|
||||||
|
|
||||||
|
panTimeout = setTimeout(function() {
|
||||||
|
if (useSmartPan) {
|
||||||
|
plot.smartPan({
|
||||||
|
x: plotState.startPageX - page.X,
|
||||||
|
y: plotState.startPageY - page.Y
|
||||||
|
}, plotState, panAxes, false, smartPanLock);
|
||||||
|
} else if (useManualPan) {
|
||||||
|
plot.pan({
|
||||||
|
left: prevDragPosition.x - page.X,
|
||||||
|
top: prevDragPosition.y - page.Y,
|
||||||
|
axes: panAxes
|
||||||
|
});
|
||||||
|
prevDragPosition.x = page.X;
|
||||||
|
prevDragPosition.y = page.Y;
|
||||||
|
}
|
||||||
|
|
||||||
|
panTimeout = null;
|
||||||
|
}, 1 / frameRate * 1000);
|
||||||
|
}
|
||||||
|
|
||||||
|
function onDragEnd(e) {
|
||||||
|
if (!isPanAction) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (panTimeout) {
|
||||||
|
clearTimeout(panTimeout);
|
||||||
|
panTimeout = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
isPanAction = false;
|
||||||
|
var page = browser.getPageXY(e);
|
||||||
|
|
||||||
|
plot.getPlaceholder().css('cursor', prevCursor);
|
||||||
|
|
||||||
|
if (useSmartPan) {
|
||||||
|
plot.smartPan({
|
||||||
|
x: plotState.startPageX - page.X,
|
||||||
|
y: plotState.startPageY - page.Y
|
||||||
|
}, plotState, panAxes, false, smartPanLock);
|
||||||
|
plot.smartPan.end();
|
||||||
|
} else if (useManualPan) {
|
||||||
|
plot.pan({
|
||||||
|
left: prevDragPosition.x - page.X,
|
||||||
|
top: prevDragPosition.y - page.Y,
|
||||||
|
axes: panAxes
|
||||||
|
});
|
||||||
|
prevDragPosition.x = 0;
|
||||||
|
prevDragPosition.y = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function onDblClick(e) {
|
||||||
|
plot.activate();
|
||||||
|
var o = plot.getOptions()
|
||||||
|
|
||||||
|
if (!o.recenter.interactive) { return; }
|
||||||
|
|
||||||
|
var axes = plot.getTouchedAxis(e.clientX, e.clientY),
|
||||||
|
event;
|
||||||
|
|
||||||
|
plot.recenter({ axes: axes[0] ? axes : null });
|
||||||
|
|
||||||
|
if (axes[0]) {
|
||||||
|
event = new $.Event('re-center', { detail: {
|
||||||
|
axisTouched: axes[0]
|
||||||
|
}});
|
||||||
|
} else {
|
||||||
|
event = new $.Event('re-center', { detail: e });
|
||||||
|
}
|
||||||
|
plot.getPlaceholder().trigger(event);
|
||||||
|
}
|
||||||
|
|
||||||
|
function onClick(e) {
|
||||||
|
plot.activate();
|
||||||
|
|
||||||
|
if (isPanAction) {
|
||||||
|
onDragEnd(e);
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.activate = function() {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
if (!o.pan.active || !o.zoom.active) {
|
||||||
|
o.pan.active = true;
|
||||||
|
o.zoom.active = true;
|
||||||
|
plot.getPlaceholder().trigger("plotactivated", [plot]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function bindEvents(plot, eventHolder) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
if (o.zoom.interactive) {
|
||||||
|
eventHolder.mousewheel(onMouseWheel);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (o.pan.interactive) {
|
||||||
|
plot.addEventHandler("dragstart", onDragStart, eventHolder, 0);
|
||||||
|
plot.addEventHandler("drag", onDrag, eventHolder, 0);
|
||||||
|
plot.addEventHandler("dragend", onDragEnd, eventHolder, 0);
|
||||||
|
eventHolder.bind("mousedown", onMouseDown);
|
||||||
|
eventHolder.bind("mouseup", onMouseUp);
|
||||||
|
}
|
||||||
|
|
||||||
|
eventHolder.dblclick(onDblClick);
|
||||||
|
eventHolder.click(onClick);
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.zoomOut = function(args) {
|
||||||
|
if (!args) {
|
||||||
|
args = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!args.amount) {
|
||||||
|
args.amount = plot.getOptions().zoom.amount;
|
||||||
|
}
|
||||||
|
|
||||||
|
args.amount = 1 / args.amount;
|
||||||
|
plot.zoom(args);
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.zoom = function(args) {
|
||||||
|
if (!args) {
|
||||||
|
args = {};
|
||||||
|
}
|
||||||
|
|
||||||
|
var c = args.center,
|
||||||
|
amount = args.amount || plot.getOptions().zoom.amount,
|
||||||
|
w = plot.width(),
|
||||||
|
h = plot.height(),
|
||||||
|
axes = args.axes || plot.getAxes();
|
||||||
|
|
||||||
|
if (!c) {
|
||||||
|
c = {
|
||||||
|
left: w / 2,
|
||||||
|
top: h / 2
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
var xf = c.left / w,
|
||||||
|
yf = c.top / h,
|
||||||
|
minmax = {
|
||||||
|
x: {
|
||||||
|
min: c.left - xf * w / amount,
|
||||||
|
max: c.left + (1 - xf) * w / amount
|
||||||
|
},
|
||||||
|
y: {
|
||||||
|
min: c.top - yf * h / amount,
|
||||||
|
max: c.top + (1 - yf) * h / amount
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
for (var key in axes) {
|
||||||
|
if (!axes.hasOwnProperty(key)) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
var axis = axes[key],
|
||||||
|
opts = axis.options,
|
||||||
|
min = minmax[axis.direction].min,
|
||||||
|
max = minmax[axis.direction].max,
|
||||||
|
navigationOffset = axis.options.offset;
|
||||||
|
|
||||||
|
//skip axis without axisZoom when zooming only on certain axis or axis without plotZoom for zoom on entire plot
|
||||||
|
if ((!opts.axisZoom && args.axes) || (!args.axes && !opts.plotZoom)) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
min = $.plot.saturated.saturate(axis.c2p(min));
|
||||||
|
max = $.plot.saturated.saturate(axis.c2p(max));
|
||||||
|
if (min > max) {
|
||||||
|
// make sure min < max
|
||||||
|
var tmp = min;
|
||||||
|
min = max;
|
||||||
|
max = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
// test for zoom limits zoomRange: [min,max]
|
||||||
|
if (opts.zoomRange) {
|
||||||
|
// zoomed in too far
|
||||||
|
if (max - min < opts.zoomRange[0]) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
// zoomed out to far
|
||||||
|
if (max - min > opts.zoomRange[1]) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var offsetBelow = $.plot.saturated.saturate(navigationOffset.below - (axis.min - min));
|
||||||
|
var offsetAbove = $.plot.saturated.saturate(navigationOffset.above - (axis.max - max));
|
||||||
|
opts.offset = { below: offsetBelow, above: offsetAbove };
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.setupGrid(true);
|
||||||
|
plot.draw();
|
||||||
|
|
||||||
|
if (!args.preventEvent) {
|
||||||
|
plot.getPlaceholder().trigger("plotzoom", [plot, args]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.pan = function(args) {
|
||||||
|
var delta = {
|
||||||
|
x: +args.left,
|
||||||
|
y: +args.top
|
||||||
|
};
|
||||||
|
|
||||||
|
if (isNaN(delta.x)) delta.x = 0;
|
||||||
|
if (isNaN(delta.y)) delta.y = 0;
|
||||||
|
|
||||||
|
$.each(args.axes || plot.getAxes(), function(_, axis) {
|
||||||
|
var opts = axis.options,
|
||||||
|
d = delta[axis.direction];
|
||||||
|
|
||||||
|
//skip axis without axisPan when panning only on certain axis or axis without plotPan for pan the entire plot
|
||||||
|
if ((!opts.axisPan && args.axes) || (!opts.plotPan && !args.axes)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// calc min delta (revealing left edge of plot)
|
||||||
|
var minD = axis.p2c(opts.panRange[0]) - axis.p2c(axis.min);
|
||||||
|
// calc max delta (revealing right edge of plot)
|
||||||
|
var maxD = axis.p2c(opts.panRange[1]) - axis.p2c(axis.max);
|
||||||
|
// limit delta to min or max if enabled
|
||||||
|
if (opts.panRange[0] !== undefined && d >= maxD) d = maxD;
|
||||||
|
if (opts.panRange[1] !== undefined && d <= minD) d = minD;
|
||||||
|
|
||||||
|
if (d !== 0) {
|
||||||
|
var navigationOffsetBelow = saturated.saturate(axis.c2p(axis.p2c(axis.min) + d) - axis.c2p(axis.p2c(axis.min))),
|
||||||
|
navigationOffsetAbove = saturated.saturate(axis.c2p(axis.p2c(axis.max) + d) - axis.c2p(axis.p2c(axis.max)));
|
||||||
|
|
||||||
|
if (!isFinite(navigationOffsetBelow)) {
|
||||||
|
navigationOffsetBelow = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!isFinite(navigationOffsetAbove)) {
|
||||||
|
navigationOffsetAbove = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
opts.offset = {
|
||||||
|
below: saturated.saturate(navigationOffsetBelow + (opts.offset.below || 0)),
|
||||||
|
above: saturated.saturate(navigationOffsetAbove + (opts.offset.above || 0))
|
||||||
|
};
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.setupGrid(true);
|
||||||
|
plot.draw();
|
||||||
|
if (!args.preventEvent) {
|
||||||
|
plot.getPlaceholder().trigger("plotpan", [plot, args]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.recenter = function(args) {
|
||||||
|
$.each(args.axes || plot.getAxes(), function(_, axis) {
|
||||||
|
if (args.axes) {
|
||||||
|
if (this.direction === 'x') {
|
||||||
|
axis.options.offset = { below: 0 };
|
||||||
|
} else if (this.direction === 'y') {
|
||||||
|
axis.options.offset = { above: 0 };
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
axis.options.offset = { below: 0, above: 0 };
|
||||||
|
}
|
||||||
|
});
|
||||||
|
plot.setupGrid(true);
|
||||||
|
plot.draw();
|
||||||
|
};
|
||||||
|
|
||||||
|
var shouldSnap = function(delta) {
|
||||||
|
return (Math.abs(delta.y) < SNAPPING_CONSTANT && Math.abs(delta.x) >= SNAPPING_CONSTANT) ||
|
||||||
|
(Math.abs(delta.x) < SNAPPING_CONSTANT && Math.abs(delta.y) >= SNAPPING_CONSTANT);
|
||||||
|
}
|
||||||
|
|
||||||
|
// adjust delta so the pan action is constrained on the vertical or horizontal direction
|
||||||
|
// it the movements in the other direction are small
|
||||||
|
var adjustDeltaToSnap = function(delta) {
|
||||||
|
if (Math.abs(delta.x) < SNAPPING_CONSTANT && Math.abs(delta.y) >= SNAPPING_CONSTANT) {
|
||||||
|
return {x: 0, y: delta.y};
|
||||||
|
}
|
||||||
|
|
||||||
|
if (Math.abs(delta.y) < SNAPPING_CONSTANT && Math.abs(delta.x) >= SNAPPING_CONSTANT) {
|
||||||
|
return {x: delta.x, y: 0};
|
||||||
|
}
|
||||||
|
|
||||||
|
return delta;
|
||||||
|
}
|
||||||
|
|
||||||
|
var lockedDirection = null;
|
||||||
|
var lockDeltaDirection = function(delta) {
|
||||||
|
if (!lockedDirection && Math.max(Math.abs(delta.x), Math.abs(delta.y)) >= SNAPPING_CONSTANT) {
|
||||||
|
lockedDirection = Math.abs(delta.x) < Math.abs(delta.y) ? 'y' : 'x';
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (lockedDirection) {
|
||||||
|
case 'x':
|
||||||
|
return { x: delta.x, y: 0 };
|
||||||
|
case 'y':
|
||||||
|
return { x: 0, y: delta.y };
|
||||||
|
default:
|
||||||
|
return { x: 0, y: 0 };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var isDiagonalMode = function(delta) {
|
||||||
|
if (Math.abs(delta.x) > 0 && Math.abs(delta.y) > 0) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
var restoreAxisOffset = function(axes, initialState, delta) {
|
||||||
|
var axis;
|
||||||
|
Object.keys(axes).forEach(function(axisName) {
|
||||||
|
axis = axes[axisName];
|
||||||
|
if (delta[axis.direction] === 0) {
|
||||||
|
axis.options.offset.below = initialState[axisName].navigationOffset.below;
|
||||||
|
axis.options.offset.above = initialState[axisName].navigationOffset.above;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
var prevDelta = { x: 0, y: 0 };
|
||||||
|
plot.smartPan = function(delta, initialState, panAxes, preventEvent, smartLock) {
|
||||||
|
var snap = smartLock ? true : shouldSnap(delta),
|
||||||
|
axes = plot.getAxes(),
|
||||||
|
opts;
|
||||||
|
delta = smartLock ? lockDeltaDirection(delta) : adjustDeltaToSnap(delta);
|
||||||
|
|
||||||
|
if (isDiagonalMode(delta)) {
|
||||||
|
initialState.diagMode = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (snap && initialState.diagMode === true) {
|
||||||
|
initialState.diagMode = false;
|
||||||
|
restoreAxisOffset(axes, initialState, delta);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (snap) {
|
||||||
|
panHint = {
|
||||||
|
start: {
|
||||||
|
x: initialState.startPageX - plot.offset().left + plot.getPlotOffset().left,
|
||||||
|
y: initialState.startPageY - plot.offset().top + plot.getPlotOffset().top
|
||||||
|
},
|
||||||
|
end: {
|
||||||
|
x: initialState.startPageX - delta.x - plot.offset().left + plot.getPlotOffset().left,
|
||||||
|
y: initialState.startPageY - delta.y - plot.offset().top + plot.getPlotOffset().top
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
panHint = {
|
||||||
|
start: {
|
||||||
|
x: initialState.startPageX - plot.offset().left + plot.getPlotOffset().left,
|
||||||
|
y: initialState.startPageY - plot.offset().top + plot.getPlotOffset().top
|
||||||
|
},
|
||||||
|
end: false
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (isNaN(delta.x)) delta.x = 0;
|
||||||
|
if (isNaN(delta.y)) delta.y = 0;
|
||||||
|
|
||||||
|
if (panAxes) {
|
||||||
|
axes = panAxes;
|
||||||
|
}
|
||||||
|
|
||||||
|
var axis, axisMin, axisMax, p, d;
|
||||||
|
Object.keys(axes).forEach(function(axisName) {
|
||||||
|
axis = axes[axisName];
|
||||||
|
axisMin = axis.min;
|
||||||
|
axisMax = axis.max;
|
||||||
|
opts = axis.options;
|
||||||
|
|
||||||
|
d = delta[axis.direction];
|
||||||
|
p = prevDelta[axis.direction];
|
||||||
|
|
||||||
|
//skip axis without axisPan when panning only on certain axis or axis without plotPan for pan the entire plot
|
||||||
|
if ((!opts.axisPan && panAxes) || (!panAxes && !opts.plotPan)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// calc min delta (revealing left edge of plot)
|
||||||
|
var minD = p + axis.p2c(opts.panRange[0]) - axis.p2c(axisMin);
|
||||||
|
// calc max delta (revealing right edge of plot)
|
||||||
|
var maxD = p + axis.p2c(opts.panRange[1]) - axis.p2c(axisMax);
|
||||||
|
// limit delta to min or max if enabled
|
||||||
|
if (opts.panRange[0] !== undefined && d >= maxD) d = maxD;
|
||||||
|
if (opts.panRange[1] !== undefined && d <= minD) d = minD;
|
||||||
|
|
||||||
|
if (d !== 0) {
|
||||||
|
var navigationOffsetBelow = saturated.saturate(axis.c2p(axis.p2c(axisMin) - (p - d)) - axis.c2p(axis.p2c(axisMin))),
|
||||||
|
navigationOffsetAbove = saturated.saturate(axis.c2p(axis.p2c(axisMax) - (p - d)) - axis.c2p(axis.p2c(axisMax)));
|
||||||
|
|
||||||
|
if (!isFinite(navigationOffsetBelow)) {
|
||||||
|
navigationOffsetBelow = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!isFinite(navigationOffsetAbove)) {
|
||||||
|
navigationOffsetAbove = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
axis.options.offset.below = saturated.saturate(navigationOffsetBelow + (axis.options.offset.below || 0));
|
||||||
|
axis.options.offset.above = saturated.saturate(navigationOffsetAbove + (axis.options.offset.above || 0));
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
prevDelta = delta;
|
||||||
|
plot.setupGrid(true);
|
||||||
|
plot.draw();
|
||||||
|
|
||||||
|
if (!preventEvent) {
|
||||||
|
plot.getPlaceholder().trigger("plotpan", [plot, delta, panAxes, initialState]);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
plot.smartPan.end = function() {
|
||||||
|
panHint = null;
|
||||||
|
lockedDirection = null;
|
||||||
|
prevDelta = { x: 0, y: 0 };
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
|
||||||
|
function shutdown(plot, eventHolder) {
|
||||||
|
eventHolder.unbind("mousewheel", onMouseWheel);
|
||||||
|
eventHolder.unbind("mousedown", onMouseDown);
|
||||||
|
eventHolder.unbind("mouseup", onMouseUp);
|
||||||
|
eventHolder.unbind("dragstart", onDragStart);
|
||||||
|
eventHolder.unbind("drag", onDrag);
|
||||||
|
eventHolder.unbind("dragend", onDragEnd);
|
||||||
|
eventHolder.unbind("dblclick", onDblClick);
|
||||||
|
eventHolder.unbind("click", onClick);
|
||||||
|
|
||||||
|
if (panTimeout) clearTimeout(panTimeout);
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawOverlay(plot, ctx) {
|
||||||
|
if (panHint) {
|
||||||
|
ctx.strokeStyle = 'rgba(96, 160, 208, 0.7)';
|
||||||
|
ctx.lineWidth = 2;
|
||||||
|
ctx.lineJoin = "round";
|
||||||
|
var startx = Math.round(panHint.start.x),
|
||||||
|
starty = Math.round(panHint.start.y),
|
||||||
|
endx, endy;
|
||||||
|
|
||||||
|
if (panAxes) {
|
||||||
|
if (panAxes[0].direction === 'x') {
|
||||||
|
endy = Math.round(panHint.start.y);
|
||||||
|
endx = Math.round(panHint.end.x);
|
||||||
|
} else if (panAxes[0].direction === 'y') {
|
||||||
|
endx = Math.round(panHint.start.x);
|
||||||
|
endy = Math.round(panHint.end.y);
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
endx = Math.round(panHint.end.x);
|
||||||
|
endy = Math.round(panHint.end.y);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.beginPath();
|
||||||
|
|
||||||
|
if (panHint.end === false) {
|
||||||
|
ctx.moveTo(startx, starty - PANHINT_LENGTH_CONSTANT);
|
||||||
|
ctx.lineTo(startx, starty + PANHINT_LENGTH_CONSTANT);
|
||||||
|
|
||||||
|
ctx.moveTo(startx + PANHINT_LENGTH_CONSTANT, starty);
|
||||||
|
ctx.lineTo(startx - PANHINT_LENGTH_CONSTANT, starty);
|
||||||
|
} else {
|
||||||
|
var dirX = starty === endy;
|
||||||
|
|
||||||
|
ctx.moveTo(startx - (dirX ? 0 : PANHINT_LENGTH_CONSTANT), starty - (dirX ? PANHINT_LENGTH_CONSTANT : 0));
|
||||||
|
ctx.lineTo(startx + (dirX ? 0 : PANHINT_LENGTH_CONSTANT), starty + (dirX ? PANHINT_LENGTH_CONSTANT : 0));
|
||||||
|
|
||||||
|
ctx.moveTo(startx, starty);
|
||||||
|
ctx.lineTo(endx, endy);
|
||||||
|
|
||||||
|
ctx.moveTo(endx - (dirX ? 0 : PANHINT_LENGTH_CONSTANT), endy - (dirX ? PANHINT_LENGTH_CONSTANT : 0));
|
||||||
|
ctx.lineTo(endx + (dirX ? 0 : PANHINT_LENGTH_CONSTANT), endy + (dirX ? PANHINT_LENGTH_CONSTANT : 0));
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.getTouchedAxis = function(touchPointX, touchPointY) {
|
||||||
|
var ec = plot.getPlaceholder().offset();
|
||||||
|
ec.left = touchPointX - ec.left;
|
||||||
|
ec.top = touchPointY - ec.top;
|
||||||
|
|
||||||
|
var axis = plot.getXAxes().concat(plot.getYAxes()).filter(function (axis) {
|
||||||
|
var box = axis.box;
|
||||||
|
if (box !== undefined) {
|
||||||
|
return (ec.left > box.left) && (ec.left < box.left + box.width) &&
|
||||||
|
(ec.top > box.top) && (ec.top < box.top + box.height);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
return axis;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.drawOverlay.push(drawOverlay);
|
||||||
|
plot.hooks.bindEvents.push(bindEvents);
|
||||||
|
plot.hooks.shutdown.push(shutdown);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'navigate',
|
||||||
|
version: '1.3'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,794 @@
|
||||||
|
/* Flot plugin for rendering pie charts.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The plugin assumes that each series has a single data value, and that each
|
||||||
|
value is a positive integer or zero. Negative numbers don't make sense for a
|
||||||
|
pie chart, and have unpredictable results. The values do NOT need to be
|
||||||
|
passed in as percentages; the plugin will calculate the total and per-slice
|
||||||
|
percentages internally.
|
||||||
|
|
||||||
|
* Created by Brian Medendorp
|
||||||
|
|
||||||
|
* Updated with contributions from btburnett3, Anthony Aragues and Xavi Ivars
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
series: {
|
||||||
|
pie: {
|
||||||
|
show: true/false
|
||||||
|
radius: 0-1 for percentage of fullsize, or a specified pixel length, or 'auto'
|
||||||
|
innerRadius: 0-1 for percentage of fullsize or a specified pixel length, for creating a donut effect
|
||||||
|
startAngle: 0-2 factor of PI used for starting angle (in radians) i.e 3/2 starts at the top, 0 and 2 have the same result
|
||||||
|
tilt: 0-1 for percentage to tilt the pie, where 1 is no tilt, and 0 is completely flat (nothing will show)
|
||||||
|
offset: {
|
||||||
|
top: integer value to move the pie up or down
|
||||||
|
left: integer value to move the pie left or right, or 'auto'
|
||||||
|
},
|
||||||
|
stroke: {
|
||||||
|
color: any hexidecimal color value (other formats may or may not work, so best to stick with something like '#FFF')
|
||||||
|
width: integer pixel width of the stroke
|
||||||
|
},
|
||||||
|
label: {
|
||||||
|
show: true/false, or 'auto'
|
||||||
|
formatter: a user-defined function that modifies the text/style of the label text
|
||||||
|
radius: 0-1 for percentage of fullsize, or a specified pixel length
|
||||||
|
background: {
|
||||||
|
color: any hexidecimal color value (other formats may or may not work, so best to stick with something like '#000')
|
||||||
|
opacity: 0-1
|
||||||
|
},
|
||||||
|
threshold: 0-1 for the percentage value at which to hide labels (if they're too small)
|
||||||
|
},
|
||||||
|
combine: {
|
||||||
|
threshold: 0-1 for the percentage value at which to combine slices (if they're too small)
|
||||||
|
color: any hexidecimal color value (other formats may or may not work, so best to stick with something like '#CCC'), if null, the plugin will automatically use the color of the first slice to be combined
|
||||||
|
label: any text value of what the combined slice should be labeled
|
||||||
|
}
|
||||||
|
highlight: {
|
||||||
|
opacity: 0-1
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
More detail and specific examples can be found in the included HTML file.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
// Maximum redraw attempts when fitting labels within the plot
|
||||||
|
|
||||||
|
var REDRAW_ATTEMPTS = 10;
|
||||||
|
|
||||||
|
// Factor by which to shrink the pie when fitting labels within the plot
|
||||||
|
|
||||||
|
var REDRAW_SHRINK = 0.95;
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
var canvas = null,
|
||||||
|
target = null,
|
||||||
|
options = null,
|
||||||
|
maxRadius = null,
|
||||||
|
centerLeft = null,
|
||||||
|
centerTop = null,
|
||||||
|
processed = false,
|
||||||
|
ctx = null;
|
||||||
|
|
||||||
|
// interactive variables
|
||||||
|
|
||||||
|
var highlights = [];
|
||||||
|
|
||||||
|
// add hook to determine if pie plugin in enabled, and then perform necessary operations
|
||||||
|
|
||||||
|
plot.hooks.processOptions.push(function(plot, options) {
|
||||||
|
if (options.series.pie.show) {
|
||||||
|
options.grid.show = false;
|
||||||
|
|
||||||
|
// set labels.show
|
||||||
|
|
||||||
|
if (options.series.pie.label.show === "auto") {
|
||||||
|
if (options.legend.show) {
|
||||||
|
options.series.pie.label.show = false;
|
||||||
|
} else {
|
||||||
|
options.series.pie.label.show = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// set radius
|
||||||
|
|
||||||
|
if (options.series.pie.radius === "auto") {
|
||||||
|
if (options.series.pie.label.show) {
|
||||||
|
options.series.pie.radius = 3 / 4;
|
||||||
|
} else {
|
||||||
|
options.series.pie.radius = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ensure sane tilt
|
||||||
|
|
||||||
|
if (options.series.pie.tilt > 1) {
|
||||||
|
options.series.pie.tilt = 1;
|
||||||
|
} else if (options.series.pie.tilt < 0) {
|
||||||
|
options.series.pie.tilt = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.bindEvents.push(function(plot, eventHolder) {
|
||||||
|
var options = plot.getOptions();
|
||||||
|
if (options.series.pie.show) {
|
||||||
|
if (options.grid.hoverable) {
|
||||||
|
eventHolder.unbind("mousemove").mousemove(onMouseMove);
|
||||||
|
eventHolder.bind("mouseleave", onMouseMove);
|
||||||
|
}
|
||||||
|
if (options.grid.clickable) {
|
||||||
|
eventHolder.unbind("click").click(onClick);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.shutdown.push(function (plot, eventHolder) {
|
||||||
|
eventHolder.unbind("mousemove", onMouseMove);
|
||||||
|
eventHolder.unbind("mouseleave", onMouseMove);
|
||||||
|
eventHolder.unbind("click", onClick);
|
||||||
|
highlights = [];
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.processDatapoints.push(function(plot, series, data, datapoints) {
|
||||||
|
var options = plot.getOptions();
|
||||||
|
if (options.series.pie.show) {
|
||||||
|
processDatapoints(plot, series, data, datapoints);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.drawOverlay.push(function(plot, octx) {
|
||||||
|
var options = plot.getOptions();
|
||||||
|
if (options.series.pie.show) {
|
||||||
|
drawOverlay(plot, octx);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.draw.push(function(plot, newCtx) {
|
||||||
|
var options = plot.getOptions();
|
||||||
|
if (options.series.pie.show) {
|
||||||
|
draw(plot, newCtx);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
function processDatapoints(plot, series, datapoints) {
|
||||||
|
if (!processed) {
|
||||||
|
processed = true;
|
||||||
|
canvas = plot.getCanvas();
|
||||||
|
target = $(canvas).parent();
|
||||||
|
options = plot.getOptions();
|
||||||
|
plot.setData(combine(plot.getData()));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function combine(data) {
|
||||||
|
var total = 0,
|
||||||
|
combined = 0,
|
||||||
|
numCombined = 0,
|
||||||
|
color = options.series.pie.combine.color,
|
||||||
|
newdata = [],
|
||||||
|
i,
|
||||||
|
value;
|
||||||
|
|
||||||
|
// Fix up the raw data from Flot, ensuring the data is numeric
|
||||||
|
|
||||||
|
for (i = 0; i < data.length; ++i) {
|
||||||
|
value = data[i].data;
|
||||||
|
|
||||||
|
// If the data is an array, we'll assume that it's a standard
|
||||||
|
// Flot x-y pair, and are concerned only with the second value.
|
||||||
|
|
||||||
|
// Note how we use the original array, rather than creating a
|
||||||
|
// new one; this is more efficient and preserves any extra data
|
||||||
|
// that the user may have stored in higher indexes.
|
||||||
|
|
||||||
|
if ($.isArray(value) && value.length === 1) {
|
||||||
|
value = value[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
if ($.isArray(value)) {
|
||||||
|
// Equivalent to $.isNumeric() but compatible with jQuery < 1.7
|
||||||
|
if (!isNaN(parseFloat(value[1])) && isFinite(value[1])) {
|
||||||
|
value[1] = +value[1];
|
||||||
|
} else {
|
||||||
|
value[1] = 0;
|
||||||
|
}
|
||||||
|
} else if (!isNaN(parseFloat(value)) && isFinite(value)) {
|
||||||
|
value = [1, +value];
|
||||||
|
} else {
|
||||||
|
value = [1, 0];
|
||||||
|
}
|
||||||
|
|
||||||
|
data[i].data = [value];
|
||||||
|
}
|
||||||
|
|
||||||
|
// Sum up all the slices, so we can calculate percentages for each
|
||||||
|
|
||||||
|
for (i = 0; i < data.length; ++i) {
|
||||||
|
total += data[i].data[0][1];
|
||||||
|
}
|
||||||
|
|
||||||
|
// Count the number of slices with percentages below the combine
|
||||||
|
// threshold; if it turns out to be just one, we won't combine.
|
||||||
|
|
||||||
|
for (i = 0; i < data.length; ++i) {
|
||||||
|
value = data[i].data[0][1];
|
||||||
|
if (value / total <= options.series.pie.combine.threshold) {
|
||||||
|
combined += value;
|
||||||
|
numCombined++;
|
||||||
|
if (!color) {
|
||||||
|
color = data[i].color;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (i = 0; i < data.length; ++i) {
|
||||||
|
value = data[i].data[0][1];
|
||||||
|
if (numCombined < 2 || value / total > options.series.pie.combine.threshold) {
|
||||||
|
newdata.push(
|
||||||
|
$.extend(data[i], { /* extend to allow keeping all other original data values
|
||||||
|
and using them e.g. in labelFormatter. */
|
||||||
|
data: [[1, value]],
|
||||||
|
color: data[i].color,
|
||||||
|
label: data[i].label,
|
||||||
|
angle: value * Math.PI * 2 / total,
|
||||||
|
percent: value / (total / 100)
|
||||||
|
})
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (numCombined > 1) {
|
||||||
|
newdata.push({
|
||||||
|
data: [[1, combined]],
|
||||||
|
color: color,
|
||||||
|
label: options.series.pie.combine.label,
|
||||||
|
angle: combined * Math.PI * 2 / total,
|
||||||
|
percent: combined / (total / 100)
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
return newdata;
|
||||||
|
}
|
||||||
|
|
||||||
|
function draw(plot, newCtx) {
|
||||||
|
if (!target) {
|
||||||
|
return; // if no series were passed
|
||||||
|
}
|
||||||
|
|
||||||
|
var canvasWidth = plot.getPlaceholder().width(),
|
||||||
|
canvasHeight = plot.getPlaceholder().height(),
|
||||||
|
legendWidth = target.children().filter(".legend").children().width() || 0;
|
||||||
|
|
||||||
|
ctx = newCtx;
|
||||||
|
|
||||||
|
// WARNING: HACK! REWRITE THIS CODE AS SOON AS POSSIBLE!
|
||||||
|
|
||||||
|
// When combining smaller slices into an 'other' slice, we need to
|
||||||
|
// add a new series. Since Flot gives plugins no way to modify the
|
||||||
|
// list of series, the pie plugin uses a hack where the first call
|
||||||
|
// to processDatapoints results in a call to setData with the new
|
||||||
|
// list of series, then subsequent processDatapoints do nothing.
|
||||||
|
|
||||||
|
// The plugin-global 'processed' flag is used to control this hack;
|
||||||
|
// it starts out false, and is set to true after the first call to
|
||||||
|
// processDatapoints.
|
||||||
|
|
||||||
|
// Unfortunately this turns future setData calls into no-ops; they
|
||||||
|
// call processDatapoints, the flag is true, and nothing happens.
|
||||||
|
|
||||||
|
// To fix this we'll set the flag back to false here in draw, when
|
||||||
|
// all series have been processed, so the next sequence of calls to
|
||||||
|
// processDatapoints once again starts out with a slice-combine.
|
||||||
|
// This is really a hack; in 0.9 we need to give plugins a proper
|
||||||
|
// way to modify series before any processing begins.
|
||||||
|
|
||||||
|
processed = false;
|
||||||
|
|
||||||
|
// calculate maximum radius and center point
|
||||||
|
maxRadius = Math.min(canvasWidth, canvasHeight / options.series.pie.tilt) / 2;
|
||||||
|
centerTop = canvasHeight / 2 + options.series.pie.offset.top;
|
||||||
|
centerLeft = canvasWidth / 2;
|
||||||
|
|
||||||
|
if (options.series.pie.offset.left === "auto") {
|
||||||
|
if (options.legend.position.match("w")) {
|
||||||
|
centerLeft += legendWidth / 2;
|
||||||
|
} else {
|
||||||
|
centerLeft -= legendWidth / 2;
|
||||||
|
}
|
||||||
|
if (centerLeft < maxRadius) {
|
||||||
|
centerLeft = maxRadius;
|
||||||
|
} else if (centerLeft > canvasWidth - maxRadius) {
|
||||||
|
centerLeft = canvasWidth - maxRadius;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
centerLeft += options.series.pie.offset.left;
|
||||||
|
}
|
||||||
|
|
||||||
|
var slices = plot.getData(),
|
||||||
|
attempts = 0;
|
||||||
|
|
||||||
|
// Keep shrinking the pie's radius until drawPie returns true,
|
||||||
|
// indicating that all the labels fit, or we try too many times.
|
||||||
|
do {
|
||||||
|
if (attempts > 0) {
|
||||||
|
maxRadius *= REDRAW_SHRINK;
|
||||||
|
}
|
||||||
|
attempts += 1;
|
||||||
|
clear();
|
||||||
|
if (options.series.pie.tilt <= 0.8) {
|
||||||
|
drawShadow();
|
||||||
|
}
|
||||||
|
} while (!drawPie() && attempts < REDRAW_ATTEMPTS)
|
||||||
|
|
||||||
|
if (attempts >= REDRAW_ATTEMPTS) {
|
||||||
|
clear();
|
||||||
|
target.prepend("<div class='error'>Could not draw pie with labels contained inside canvas</div>");
|
||||||
|
}
|
||||||
|
|
||||||
|
if (plot.setSeries && plot.insertLegend) {
|
||||||
|
plot.setSeries(slices);
|
||||||
|
plot.insertLegend();
|
||||||
|
}
|
||||||
|
|
||||||
|
// we're actually done at this point, just defining internal functions at this point
|
||||||
|
function clear() {
|
||||||
|
ctx.clearRect(0, 0, canvasWidth, canvasHeight);
|
||||||
|
target.children().filter(".pieLabel, .pieLabelBackground").remove();
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawShadow() {
|
||||||
|
var shadowLeft = options.series.pie.shadow.left;
|
||||||
|
var shadowTop = options.series.pie.shadow.top;
|
||||||
|
var edge = 10;
|
||||||
|
var alpha = options.series.pie.shadow.alpha;
|
||||||
|
var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
|
||||||
|
|
||||||
|
if (radius >= canvasWidth / 2 - shadowLeft || radius * options.series.pie.tilt >= canvasHeight / 2 - shadowTop || radius <= edge) {
|
||||||
|
return; // shadow would be outside canvas, so don't draw it
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(shadowLeft, shadowTop);
|
||||||
|
ctx.globalAlpha = alpha;
|
||||||
|
ctx.fillStyle = "#000";
|
||||||
|
|
||||||
|
// center and rotate to starting position
|
||||||
|
ctx.translate(centerLeft, centerTop);
|
||||||
|
ctx.scale(1, options.series.pie.tilt);
|
||||||
|
|
||||||
|
//radius -= edge;
|
||||||
|
for (var i = 1; i <= edge; i++) {
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.arc(0, 0, radius, 0, Math.PI * 2, false);
|
||||||
|
ctx.fill();
|
||||||
|
radius -= i;
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawPie() {
|
||||||
|
var startAngle = Math.PI * options.series.pie.startAngle;
|
||||||
|
var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
|
||||||
|
var i;
|
||||||
|
// center and rotate to starting position
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(centerLeft, centerTop);
|
||||||
|
ctx.scale(1, options.series.pie.tilt);
|
||||||
|
//ctx.rotate(startAngle); // start at top; -- This doesn't work properly in Opera
|
||||||
|
|
||||||
|
// draw slices
|
||||||
|
ctx.save();
|
||||||
|
|
||||||
|
var currentAngle = startAngle;
|
||||||
|
for (i = 0; i < slices.length; ++i) {
|
||||||
|
slices[i].startAngle = currentAngle;
|
||||||
|
drawSlice(slices[i].angle, slices[i].color, true);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
|
||||||
|
// draw slice outlines
|
||||||
|
if (options.series.pie.stroke.width > 0) {
|
||||||
|
ctx.save();
|
||||||
|
ctx.lineWidth = options.series.pie.stroke.width;
|
||||||
|
currentAngle = startAngle;
|
||||||
|
for (i = 0; i < slices.length; ++i) {
|
||||||
|
drawSlice(slices[i].angle, options.series.pie.stroke.color, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
|
||||||
|
// draw donut hole
|
||||||
|
drawDonutHole(ctx);
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
|
||||||
|
// Draw the labels, returning true if they fit within the plot
|
||||||
|
if (options.series.pie.label.show) {
|
||||||
|
return drawLabels();
|
||||||
|
} else return true;
|
||||||
|
|
||||||
|
function drawSlice(angle, color, fill) {
|
||||||
|
if (angle <= 0 || isNaN(angle)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (fill) {
|
||||||
|
ctx.fillStyle = color;
|
||||||
|
} else {
|
||||||
|
ctx.strokeStyle = color;
|
||||||
|
ctx.lineJoin = "round";
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.beginPath();
|
||||||
|
if (Math.abs(angle - Math.PI * 2) > 0.000000001) {
|
||||||
|
ctx.moveTo(0, 0); // Center of the pie
|
||||||
|
}
|
||||||
|
|
||||||
|
//ctx.arc(0, 0, radius, 0, angle, false); // This doesn't work properly in Opera
|
||||||
|
ctx.arc(0, 0, radius, currentAngle, currentAngle + angle / 2, false);
|
||||||
|
ctx.arc(0, 0, radius, currentAngle + angle / 2, currentAngle + angle, false);
|
||||||
|
ctx.closePath();
|
||||||
|
//ctx.rotate(angle); // This doesn't work properly in Opera
|
||||||
|
currentAngle += angle;
|
||||||
|
|
||||||
|
if (fill) {
|
||||||
|
ctx.fill();
|
||||||
|
} else {
|
||||||
|
ctx.stroke();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawLabels() {
|
||||||
|
var currentAngle = startAngle;
|
||||||
|
var radius = options.series.pie.label.radius > 1 ? options.series.pie.label.radius : maxRadius * options.series.pie.label.radius;
|
||||||
|
|
||||||
|
for (var i = 0; i < slices.length; ++i) {
|
||||||
|
if (slices[i].percent >= options.series.pie.label.threshold * 100) {
|
||||||
|
if (!drawLabel(slices[i], currentAngle, i)) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
currentAngle += slices[i].angle;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
|
||||||
|
function drawLabel(slice, startAngle, index) {
|
||||||
|
if (slice.data[0][1] === 0) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// format label text
|
||||||
|
var lf = options.legend.labelFormatter, text, plf = options.series.pie.label.formatter;
|
||||||
|
|
||||||
|
if (lf) {
|
||||||
|
text = lf(slice.label, slice);
|
||||||
|
} else {
|
||||||
|
text = slice.label;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (plf) {
|
||||||
|
text = plf(text, slice);
|
||||||
|
}
|
||||||
|
|
||||||
|
var halfAngle = ((startAngle + slice.angle) + startAngle) / 2;
|
||||||
|
var x = centerLeft + Math.round(Math.cos(halfAngle) * radius);
|
||||||
|
var y = centerTop + Math.round(Math.sin(halfAngle) * radius) * options.series.pie.tilt;
|
||||||
|
|
||||||
|
var html = "<span class='pieLabel' id='pieLabel" + index + "' style='position:absolute;top:" + y + "px;left:" + x + "px;'>" + text + "</span>";
|
||||||
|
target.append(html);
|
||||||
|
|
||||||
|
var label = target.children("#pieLabel" + index);
|
||||||
|
var labelTop = (y - label.height() / 2);
|
||||||
|
var labelLeft = (x - label.width() / 2);
|
||||||
|
|
||||||
|
label.css("top", labelTop);
|
||||||
|
label.css("left", labelLeft);
|
||||||
|
|
||||||
|
// check to make sure that the label is not outside the canvas
|
||||||
|
if (0 - labelTop > 0 || 0 - labelLeft > 0 || canvasHeight - (labelTop + label.height()) < 0 || canvasWidth - (labelLeft + label.width()) < 0) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (options.series.pie.label.background.opacity !== 0) {
|
||||||
|
// put in the transparent background separately to avoid blended labels and label boxes
|
||||||
|
var c = options.series.pie.label.background.color;
|
||||||
|
if (c == null) {
|
||||||
|
c = slice.color;
|
||||||
|
}
|
||||||
|
|
||||||
|
var pos = "top:" + labelTop + "px;left:" + labelLeft + "px;";
|
||||||
|
$("<div class='pieLabelBackground' style='position:absolute;width:" + label.width() + "px;height:" + label.height() + "px;" + pos + "background-color:" + c + ";'></div>")
|
||||||
|
.css("opacity", options.series.pie.label.background.opacity)
|
||||||
|
.insertBefore(label);
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
} // end individual label function
|
||||||
|
} // end drawLabels function
|
||||||
|
} // end drawPie function
|
||||||
|
} // end draw function
|
||||||
|
|
||||||
|
// Placed here because it needs to be accessed from multiple locations
|
||||||
|
|
||||||
|
function drawDonutHole(layer) {
|
||||||
|
if (options.series.pie.innerRadius > 0) {
|
||||||
|
// subtract the center
|
||||||
|
layer.save();
|
||||||
|
var innerRadius = options.series.pie.innerRadius > 1 ? options.series.pie.innerRadius : maxRadius * options.series.pie.innerRadius;
|
||||||
|
layer.globalCompositeOperation = "destination-out"; // this does not work with excanvas, but it will fall back to using the stroke color
|
||||||
|
layer.beginPath();
|
||||||
|
layer.fillStyle = options.series.pie.stroke.color;
|
||||||
|
layer.arc(0, 0, innerRadius, 0, Math.PI * 2, false);
|
||||||
|
layer.fill();
|
||||||
|
layer.closePath();
|
||||||
|
layer.restore();
|
||||||
|
|
||||||
|
// add inner stroke
|
||||||
|
layer.save();
|
||||||
|
layer.beginPath();
|
||||||
|
layer.strokeStyle = options.series.pie.stroke.color;
|
||||||
|
layer.arc(0, 0, innerRadius, 0, Math.PI * 2, false);
|
||||||
|
layer.stroke();
|
||||||
|
layer.closePath();
|
||||||
|
layer.restore();
|
||||||
|
|
||||||
|
// TODO: add extra shadow inside hole (with a mask) if the pie is tilted.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
//-- Additional Interactive related functions --
|
||||||
|
|
||||||
|
function isPointInPoly(poly, pt) {
|
||||||
|
for (var c = false, i = -1, l = poly.length, j = l - 1; ++i < l; j = i) {
|
||||||
|
((poly[i][1] <= pt[1] && pt[1] < poly[j][1]) ||
|
||||||
|
(poly[j][1] <= pt[1] && pt[1] < poly[i][1])) &&
|
||||||
|
(pt[0] < (poly[j][0] - poly[i][0]) * (pt[1] - poly[i][1]) / (poly[j][1] - poly[i][1]) + poly[i][0]) &&
|
||||||
|
(c = !c);
|
||||||
|
}
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
function findNearbySlice(mouseX, mouseY) {
|
||||||
|
var slices = plot.getData(),
|
||||||
|
options = plot.getOptions(),
|
||||||
|
radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius,
|
||||||
|
x, y;
|
||||||
|
|
||||||
|
for (var i = 0; i < slices.length; ++i) {
|
||||||
|
var s = slices[i];
|
||||||
|
if (s.pie.show) {
|
||||||
|
ctx.save();
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.moveTo(0, 0); // Center of the pie
|
||||||
|
//ctx.scale(1, options.series.pie.tilt); // this actually seems to break everything when here.
|
||||||
|
ctx.arc(0, 0, radius, s.startAngle, s.startAngle + s.angle / 2, false);
|
||||||
|
ctx.arc(0, 0, radius, s.startAngle + s.angle / 2, s.startAngle + s.angle, false);
|
||||||
|
ctx.closePath();
|
||||||
|
x = mouseX - centerLeft;
|
||||||
|
y = mouseY - centerTop;
|
||||||
|
|
||||||
|
if (ctx.isPointInPath) {
|
||||||
|
if (ctx.isPointInPath(mouseX - centerLeft, mouseY - centerTop)) {
|
||||||
|
ctx.restore();
|
||||||
|
return {
|
||||||
|
datapoint: [s.percent, s.data],
|
||||||
|
dataIndex: 0,
|
||||||
|
series: s,
|
||||||
|
seriesIndex: i
|
||||||
|
};
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// excanvas for IE doesn;t support isPointInPath, this is a workaround.
|
||||||
|
var p1X = radius * Math.cos(s.startAngle),
|
||||||
|
p1Y = radius * Math.sin(s.startAngle),
|
||||||
|
p2X = radius * Math.cos(s.startAngle + s.angle / 4),
|
||||||
|
p2Y = radius * Math.sin(s.startAngle + s.angle / 4),
|
||||||
|
p3X = radius * Math.cos(s.startAngle + s.angle / 2),
|
||||||
|
p3Y = radius * Math.sin(s.startAngle + s.angle / 2),
|
||||||
|
p4X = radius * Math.cos(s.startAngle + s.angle / 1.5),
|
||||||
|
p4Y = radius * Math.sin(s.startAngle + s.angle / 1.5),
|
||||||
|
p5X = radius * Math.cos(s.startAngle + s.angle),
|
||||||
|
p5Y = radius * Math.sin(s.startAngle + s.angle),
|
||||||
|
arrPoly = [[0, 0], [p1X, p1Y], [p2X, p2Y], [p3X, p3Y], [p4X, p4Y], [p5X, p5Y]],
|
||||||
|
arrPoint = [x, y];
|
||||||
|
|
||||||
|
// TODO: perhaps do some mathmatical trickery here with the Y-coordinate to compensate for pie tilt?
|
||||||
|
|
||||||
|
if (isPointInPoly(arrPoly, arrPoint)) {
|
||||||
|
ctx.restore();
|
||||||
|
return {
|
||||||
|
datapoint: [s.percent, s.data],
|
||||||
|
dataIndex: 0,
|
||||||
|
series: s,
|
||||||
|
seriesIndex: i
|
||||||
|
};
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return null;
|
||||||
|
}
|
||||||
|
|
||||||
|
function onMouseMove(e) {
|
||||||
|
triggerClickHoverEvent("plothover", e);
|
||||||
|
}
|
||||||
|
|
||||||
|
function onClick(e) {
|
||||||
|
triggerClickHoverEvent("plotclick", e);
|
||||||
|
}
|
||||||
|
|
||||||
|
// trigger click or hover event (they send the same parameters so we share their code)
|
||||||
|
|
||||||
|
function triggerClickHoverEvent(eventname, e) {
|
||||||
|
var offset = plot.offset();
|
||||||
|
var canvasX = parseInt(e.pageX - offset.left);
|
||||||
|
var canvasY = parseInt(e.pageY - offset.top);
|
||||||
|
var item = findNearbySlice(canvasX, canvasY);
|
||||||
|
|
||||||
|
if (options.grid.autoHighlight) {
|
||||||
|
// clear auto-highlights
|
||||||
|
for (var i = 0; i < highlights.length; ++i) {
|
||||||
|
var h = highlights[i];
|
||||||
|
if (h.auto === eventname && !(item && h.series === item.series)) {
|
||||||
|
unhighlight(h.series);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// highlight the slice
|
||||||
|
|
||||||
|
if (item) {
|
||||||
|
highlight(item.series, eventname);
|
||||||
|
}
|
||||||
|
|
||||||
|
// trigger any hover bind events
|
||||||
|
|
||||||
|
var pos = { pageX: e.pageX, pageY: e.pageY };
|
||||||
|
target.trigger(eventname, [pos, item]);
|
||||||
|
}
|
||||||
|
|
||||||
|
function highlight(s, auto) {
|
||||||
|
//if (typeof s == "number") {
|
||||||
|
// s = series[s];
|
||||||
|
//}
|
||||||
|
|
||||||
|
var i = indexOfHighlight(s);
|
||||||
|
|
||||||
|
if (i === -1) {
|
||||||
|
highlights.push({ series: s, auto: auto });
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
} else if (!auto) {
|
||||||
|
highlights[i].auto = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function unhighlight(s) {
|
||||||
|
if (s == null) {
|
||||||
|
highlights = [];
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
|
||||||
|
//if (typeof s == "number") {
|
||||||
|
// s = series[s];
|
||||||
|
//}
|
||||||
|
|
||||||
|
var i = indexOfHighlight(s);
|
||||||
|
|
||||||
|
if (i !== -1) {
|
||||||
|
highlights.splice(i, 1);
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function indexOfHighlight(s) {
|
||||||
|
for (var i = 0; i < highlights.length; ++i) {
|
||||||
|
var h = highlights[i];
|
||||||
|
if (h.series === s) {
|
||||||
|
return i;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
function drawOverlay(plot, octx) {
|
||||||
|
var options = plot.getOptions();
|
||||||
|
var radius = options.series.pie.radius > 1 ? options.series.pie.radius : maxRadius * options.series.pie.radius;
|
||||||
|
|
||||||
|
octx.save();
|
||||||
|
octx.translate(centerLeft, centerTop);
|
||||||
|
octx.scale(1, options.series.pie.tilt);
|
||||||
|
|
||||||
|
for (var i = 0; i < highlights.length; ++i) {
|
||||||
|
drawHighlight(highlights[i].series);
|
||||||
|
}
|
||||||
|
|
||||||
|
drawDonutHole(octx);
|
||||||
|
|
||||||
|
octx.restore();
|
||||||
|
|
||||||
|
function drawHighlight(series) {
|
||||||
|
if (series.angle <= 0 || isNaN(series.angle)) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
//octx.fillStyle = parseColor(options.series.pie.highlight.color).scale(null, null, null, options.series.pie.highlight.opacity).toString();
|
||||||
|
octx.fillStyle = "rgba(255, 255, 255, " + options.series.pie.highlight.opacity + ")"; // this is temporary until we have access to parseColor
|
||||||
|
octx.beginPath();
|
||||||
|
if (Math.abs(series.angle - Math.PI * 2) > 0.000000001) {
|
||||||
|
octx.moveTo(0, 0); // Center of the pie
|
||||||
|
}
|
||||||
|
octx.arc(0, 0, radius, series.startAngle, series.startAngle + series.angle / 2, false);
|
||||||
|
octx.arc(0, 0, radius, series.startAngle + series.angle / 2, series.startAngle + series.angle, false);
|
||||||
|
octx.closePath();
|
||||||
|
octx.fill();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // end init (plugin body)
|
||||||
|
|
||||||
|
// define pie specific options and their default values
|
||||||
|
var options = {
|
||||||
|
series: {
|
||||||
|
pie: {
|
||||||
|
show: false,
|
||||||
|
radius: "auto", // actual radius of the visible pie (based on full calculated radius if <=1, or hard pixel value)
|
||||||
|
innerRadius: 0, /* for donut */
|
||||||
|
startAngle: 3 / 2,
|
||||||
|
tilt: 1,
|
||||||
|
shadow: {
|
||||||
|
left: 5, // shadow left offset
|
||||||
|
top: 15, // shadow top offset
|
||||||
|
alpha: 0.02 // shadow alpha
|
||||||
|
},
|
||||||
|
offset: {
|
||||||
|
top: 0,
|
||||||
|
left: "auto"
|
||||||
|
},
|
||||||
|
stroke: {
|
||||||
|
color: "#fff",
|
||||||
|
width: 1
|
||||||
|
},
|
||||||
|
label: {
|
||||||
|
show: "auto",
|
||||||
|
formatter: function(label, slice) {
|
||||||
|
return "<div style='font-size:x-small;text-align:center;padding:2px;color:" + slice.color + ";'>" + label + "<br/>" + Math.round(slice.percent) + "%</div>";
|
||||||
|
}, // formatter function
|
||||||
|
radius: 1, // radius at which to place the labels (based on full calculated radius if <=1, or hard pixel value)
|
||||||
|
background: {
|
||||||
|
color: null,
|
||||||
|
opacity: 0
|
||||||
|
},
|
||||||
|
threshold: 0 // percentage at which to hide the label (i.e. the slice is too narrow)
|
||||||
|
},
|
||||||
|
combine: {
|
||||||
|
threshold: -1, // percentage at which to combine little slices into one larger slice
|
||||||
|
color: null, // color to give the new slice (auto-generated if null)
|
||||||
|
label: "Other" // label to give the new slice
|
||||||
|
},
|
||||||
|
highlight: {
|
||||||
|
//color: "#fff", // will add this functionality once parseColor is available
|
||||||
|
opacity: 0.5
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: "pie",
|
||||||
|
version: "1.1"
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,60 @@
|
||||||
|
/* eslint-disable */
|
||||||
|
/* Flot plugin for automatically redrawing plots as the placeholder resizes.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
It works by listening for changes on the placeholder div (through the jQuery
|
||||||
|
resize event plugin) - if the size changes, it will redraw the plot.
|
||||||
|
|
||||||
|
There are no options. If you need to disable the plugin for some plots, you
|
||||||
|
can just fix the size of their placeholders.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Inline dependency:
|
||||||
|
* jQuery resize event - v1.1 - 3/14/2010
|
||||||
|
* http://benalman.com/projects/jquery-resize-plugin/
|
||||||
|
*
|
||||||
|
* Copyright (c) 2010 "Cowboy" Ben Alman
|
||||||
|
* Dual licensed under the MIT and GPL licenses.
|
||||||
|
* http://benalman.com/about/license/
|
||||||
|
*/
|
||||||
|
(function($,e,t){"$:nomunge";var i=[],n=$.resize=$.extend($.resize,{}),a,r=false,s="setTimeout",u="resize",m=u+"-special-event",o="pendingDelay",l="activeDelay",f="throttleWindow";n[o]=200;n[l]=20;n[f]=true;$.event.special[u]={setup:function(){if(!n[f]&&this[s]){return false}var e=$(this);i.push(this);e.data(m,{w:e.width(),h:e.height()});if(i.length===1){a=t;h()}},teardown:function(){if(!n[f]&&this[s]){return false}var e=$(this);for(var t=i.length-1;t>=0;t--){if(i[t]==this){i.splice(t,1);break}}e.removeData(m);if(!i.length){if(r){cancelAnimationFrame(a)}else{clearTimeout(a)}a=null}},add:function(e){if(!n[f]&&this[s]){return false}var i;function a(e,n,a){var r=$(this),s=r.data(m)||{};s.w=n!==t?n:r.width();s.h=a!==t?a:r.height();i.apply(this,arguments)}if($.isFunction(e)){i=e;return a}else{i=e.handler;e.handler=a}}};function h(t){if(r===true){r=t||1}for(var s=i.length-1;s>=0;s--){var l=$(i[s]);if(l[0]==e||l.is(":visible")){var f=l.width(),c=l.height(),d=l.data(m);if(d&&(f!==d.w||c!==d.h)){l.trigger(u,[d.w=f,d.h=c]);r=t||true}}else{d=l.data(m);d.w=0;d.h=0}}if(a!==null){if(r&&(t==null||t-r<1e3)){a=e.requestAnimationFrame(h)}else{a=setTimeout(h,n[o]);r=false}}}if(!e.requestAnimationFrame){e.requestAnimationFrame=function(){return e.webkitRequestAnimationFrame||e.mozRequestAnimationFrame||e.oRequestAnimationFrame||e.msRequestAnimationFrame||function(t,i){return e.setTimeout(function(){t((new Date).getTime())},n[l])}}()}if(!e.cancelAnimationFrame){e.cancelAnimationFrame=function(){return e.webkitCancelRequestAnimationFrame||e.mozCancelRequestAnimationFrame||e.oCancelRequestAnimationFrame||e.msCancelRequestAnimationFrame||clearTimeout}()}})(jQuery,window);
|
||||||
|
|
||||||
|
/* eslint-enable */
|
||||||
|
(function ($) {
|
||||||
|
var options = { }; // no options
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
function onResize() {
|
||||||
|
var placeholder = plot.getPlaceholder();
|
||||||
|
|
||||||
|
// somebody might have hidden us and we can't plot
|
||||||
|
// when we don't have the dimensions
|
||||||
|
if (placeholder.width() === 0 || placeholder.height() === 0) return;
|
||||||
|
|
||||||
|
plot.resize();
|
||||||
|
plot.setupGrid();
|
||||||
|
plot.draw();
|
||||||
|
}
|
||||||
|
|
||||||
|
function bindEvents(plot, eventHolder) {
|
||||||
|
plot.getPlaceholder().resize(onResize);
|
||||||
|
}
|
||||||
|
|
||||||
|
function shutdown(plot, eventHolder) {
|
||||||
|
plot.getPlaceholder().unbind("resize", onResize);
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.bindEvents.push(bindEvents);
|
||||||
|
plot.hooks.shutdown.push(shutdown);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'resize',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,43 @@
|
||||||
|
(function ($) {
|
||||||
|
'use strict';
|
||||||
|
var saturated = {
|
||||||
|
saturate: function (a) {
|
||||||
|
if (a === Infinity) {
|
||||||
|
return Number.MAX_VALUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (a === -Infinity) {
|
||||||
|
return -Number.MAX_VALUE;
|
||||||
|
}
|
||||||
|
|
||||||
|
return a;
|
||||||
|
},
|
||||||
|
delta: function(min, max, noTicks) {
|
||||||
|
return ((max - min) / noTicks) === Infinity ? (max / noTicks - min / noTicks) : (max - min) / noTicks
|
||||||
|
},
|
||||||
|
multiply: function (a, b) {
|
||||||
|
return saturated.saturate(a * b);
|
||||||
|
},
|
||||||
|
// returns c * bInt * a. Beahves properly in the case where c is negative
|
||||||
|
// and bInt * a is bigger that Number.MAX_VALUE (Infinity)
|
||||||
|
multiplyAdd: function (a, bInt, c) {
|
||||||
|
if (isFinite(a * bInt)) {
|
||||||
|
return saturated.saturate(a * bInt + c);
|
||||||
|
} else {
|
||||||
|
var result = c;
|
||||||
|
|
||||||
|
for (var i = 0; i < bInt; i++) {
|
||||||
|
result += a;
|
||||||
|
}
|
||||||
|
|
||||||
|
return saturated.saturate(result);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
// round to nearby lower multiple of base
|
||||||
|
floorInBase: function(n, base) {
|
||||||
|
return base * Math.floor(n / base);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
$.plot.saturated = saturated;
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,527 @@
|
||||||
|
/* Flot plugin for selecting regions of a plot.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
selection: {
|
||||||
|
mode: null or "x" or "y" or "xy" or "smart",
|
||||||
|
color: color,
|
||||||
|
shape: "round" or "miter" or "bevel",
|
||||||
|
visualization: "fill" or "focus",
|
||||||
|
displaySelectionDecorations: true or false,
|
||||||
|
minSize: number of pixels
|
||||||
|
}
|
||||||
|
|
||||||
|
Selection support is enabled by setting the mode to one of "x", "y" or "xy".
|
||||||
|
In "x" mode, the user will only be able to specify the x range, similarly for
|
||||||
|
"y" mode. For "xy", the selection becomes a rectangle where both ranges can be
|
||||||
|
specified. "color" is color of the selection (if you need to change the color
|
||||||
|
later on, you can get to it with plot.getOptions().selection.color). "shape"
|
||||||
|
is the shape of the corners of the selection.
|
||||||
|
|
||||||
|
The way how the selection is visualized, can be changed by using the option
|
||||||
|
"visualization". Flot currently supports two modes: "focus" and "fill". The
|
||||||
|
option "focus" draws a colored bezel around the selected area while keeping
|
||||||
|
the selected area clear. The option "fill" highlights (i.e., fills) the
|
||||||
|
selected area with a colored highlight.
|
||||||
|
|
||||||
|
There are optional selection decorations (handles) that are rendered with the
|
||||||
|
"focus" visualization option. The selection decoration is rendered by default
|
||||||
|
but can be turned off by setting displaySelectionDecorations to false.
|
||||||
|
|
||||||
|
"minSize" is the minimum size a selection can be in pixels. This value can
|
||||||
|
be customized to determine the smallest size a selection can be and still
|
||||||
|
have the selection rectangle be displayed. When customizing this value, the
|
||||||
|
fact that it refers to pixels, not axis units must be taken into account.
|
||||||
|
Thus, for example, if there is a bar graph in time mode with BarWidth set to 1
|
||||||
|
minute, setting "minSize" to 1 will not make the minimum selection size 1
|
||||||
|
minute, but rather 1 pixel. Note also that setting "minSize" to 0 will prevent
|
||||||
|
"plotunselected" events from being fired when the user clicks the mouse without
|
||||||
|
dragging.
|
||||||
|
|
||||||
|
When selection support is enabled, a "plotselected" event will be emitted on
|
||||||
|
the DOM element you passed into the plot function. The event handler gets a
|
||||||
|
parameter with the ranges selected on the axes, like this:
|
||||||
|
|
||||||
|
placeholder.bind( "plotselected", function( event, ranges ) {
|
||||||
|
alert("You selected " + ranges.xaxis.from + " to " + ranges.xaxis.to)
|
||||||
|
// similar for yaxis - with multiple axes, the extra ones are in
|
||||||
|
// x2axis, x3axis, ...
|
||||||
|
});
|
||||||
|
|
||||||
|
The "plotselected" event is only fired when the user has finished making the
|
||||||
|
selection. A "plotselecting" event is fired during the process with the same
|
||||||
|
parameters as the "plotselected" event, in case you want to know what's
|
||||||
|
happening while it's happening,
|
||||||
|
|
||||||
|
A "plotunselected" event with no arguments is emitted when the user clicks the
|
||||||
|
mouse to remove the selection. As stated above, setting "minSize" to 0 will
|
||||||
|
destroy this behavior.
|
||||||
|
|
||||||
|
The plugin allso adds the following methods to the plot object:
|
||||||
|
|
||||||
|
- setSelection( ranges, preventEvent )
|
||||||
|
|
||||||
|
Set the selection rectangle. The passed in ranges is on the same form as
|
||||||
|
returned in the "plotselected" event. If the selection mode is "x", you
|
||||||
|
should put in either an xaxis range, if the mode is "y" you need to put in
|
||||||
|
an yaxis range and both xaxis and yaxis if the selection mode is "xy", like
|
||||||
|
this:
|
||||||
|
|
||||||
|
setSelection({ xaxis: { from: 0, to: 10 }, yaxis: { from: 40, to: 60 } });
|
||||||
|
|
||||||
|
setSelection will trigger the "plotselected" event when called. If you don't
|
||||||
|
want that to happen, e.g. if you're inside a "plotselected" handler, pass
|
||||||
|
true as the second parameter. If you are using multiple axes, you can
|
||||||
|
specify the ranges on any of those, e.g. as x2axis/x3axis/... instead of
|
||||||
|
xaxis, the plugin picks the first one it sees.
|
||||||
|
|
||||||
|
- clearSelection( preventEvent )
|
||||||
|
|
||||||
|
Clear the selection rectangle. Pass in true to avoid getting a
|
||||||
|
"plotunselected" event.
|
||||||
|
|
||||||
|
- getSelection()
|
||||||
|
|
||||||
|
Returns the current selection in the same format as the "plotselected"
|
||||||
|
event. If there's currently no selection, the function returns null.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
function init(plot) {
|
||||||
|
var selection = {
|
||||||
|
first: {x: -1, y: -1},
|
||||||
|
second: {x: -1, y: -1},
|
||||||
|
show: false,
|
||||||
|
currentMode: 'xy',
|
||||||
|
active: false
|
||||||
|
};
|
||||||
|
|
||||||
|
var SNAPPING_CONSTANT = $.plot.uiConstants.SNAPPING_CONSTANT;
|
||||||
|
|
||||||
|
// FIXME: The drag handling implemented here should be
|
||||||
|
// abstracted out, there's some similar code from a library in
|
||||||
|
// the navigation plugin, this should be massaged a bit to fit
|
||||||
|
// the Flot cases here better and reused. Doing this would
|
||||||
|
// make this plugin much slimmer.
|
||||||
|
var savedhandlers = {};
|
||||||
|
|
||||||
|
function onDrag(e) {
|
||||||
|
if (selection.active) {
|
||||||
|
updateSelection(e);
|
||||||
|
|
||||||
|
plot.getPlaceholder().trigger("plotselecting", [ getSelection() ]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function onDragStart(e) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
// only accept left-click
|
||||||
|
if (e.which !== 1 || o.selection.mode === null) return;
|
||||||
|
|
||||||
|
// reinitialize currentMode
|
||||||
|
selection.currentMode = 'xy';
|
||||||
|
|
||||||
|
// cancel out any text selections
|
||||||
|
document.body.focus();
|
||||||
|
|
||||||
|
// prevent text selection and drag in old-school browsers
|
||||||
|
if (document.onselectstart !== undefined && savedhandlers.onselectstart == null) {
|
||||||
|
savedhandlers.onselectstart = document.onselectstart;
|
||||||
|
document.onselectstart = function () { return false; };
|
||||||
|
}
|
||||||
|
if (document.ondrag !== undefined && savedhandlers.ondrag == null) {
|
||||||
|
savedhandlers.ondrag = document.ondrag;
|
||||||
|
document.ondrag = function () { return false; };
|
||||||
|
}
|
||||||
|
|
||||||
|
setSelectionPos(selection.first, e);
|
||||||
|
|
||||||
|
selection.active = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
function onDragEnd(e) {
|
||||||
|
// revert drag stuff for old-school browsers
|
||||||
|
if (document.onselectstart !== undefined) {
|
||||||
|
document.onselectstart = savedhandlers.onselectstart;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (document.ondrag !== undefined) {
|
||||||
|
document.ondrag = savedhandlers.ondrag;
|
||||||
|
}
|
||||||
|
|
||||||
|
// no more dragging
|
||||||
|
selection.active = false;
|
||||||
|
updateSelection(e);
|
||||||
|
|
||||||
|
if (selectionIsSane()) {
|
||||||
|
triggerSelectedEvent();
|
||||||
|
} else {
|
||||||
|
// this counts as a clear
|
||||||
|
plot.getPlaceholder().trigger("plotunselected", [ ]);
|
||||||
|
plot.getPlaceholder().trigger("plotselecting", [ null ]);
|
||||||
|
}
|
||||||
|
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
function getSelection() {
|
||||||
|
if (!selectionIsSane()) return null;
|
||||||
|
|
||||||
|
if (!selection.show) return null;
|
||||||
|
|
||||||
|
var r = {},
|
||||||
|
c1 = {x: selection.first.x, y: selection.first.y},
|
||||||
|
c2 = {x: selection.second.x, y: selection.second.y};
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === 'x') {
|
||||||
|
c1.y = 0;
|
||||||
|
c2.y = plot.height();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === 'y') {
|
||||||
|
c1.x = 0;
|
||||||
|
c2.x = plot.width();
|
||||||
|
}
|
||||||
|
|
||||||
|
$.each(plot.getAxes(), function (name, axis) {
|
||||||
|
if (axis.used) {
|
||||||
|
var p1 = axis.c2p(c1[axis.direction]), p2 = axis.c2p(c2[axis.direction]);
|
||||||
|
r[name] = { from: Math.min(p1, p2), to: Math.max(p1, p2) };
|
||||||
|
}
|
||||||
|
});
|
||||||
|
return r;
|
||||||
|
}
|
||||||
|
|
||||||
|
function triggerSelectedEvent() {
|
||||||
|
var r = getSelection();
|
||||||
|
|
||||||
|
plot.getPlaceholder().trigger("plotselected", [ r ]);
|
||||||
|
|
||||||
|
// backwards-compat stuff, to be removed in future
|
||||||
|
if (r.xaxis && r.yaxis) {
|
||||||
|
plot.getPlaceholder().trigger("selected", [ { x1: r.xaxis.from, y1: r.yaxis.from, x2: r.xaxis.to, y2: r.yaxis.to } ]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function clamp(min, value, max) {
|
||||||
|
return value < min ? min : (value > max ? max : value);
|
||||||
|
}
|
||||||
|
|
||||||
|
function selectionDirection(plot) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
|
||||||
|
if (o.selection.mode === 'smart') {
|
||||||
|
return selection.currentMode;
|
||||||
|
} else {
|
||||||
|
return o.selection.mode;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function updateMode(pos) {
|
||||||
|
if (selection.first) {
|
||||||
|
var delta = {
|
||||||
|
x: pos.x - selection.first.x,
|
||||||
|
y: pos.y - selection.first.y
|
||||||
|
};
|
||||||
|
|
||||||
|
if (Math.abs(delta.x) < SNAPPING_CONSTANT) {
|
||||||
|
selection.currentMode = 'y';
|
||||||
|
} else if (Math.abs(delta.y) < SNAPPING_CONSTANT) {
|
||||||
|
selection.currentMode = 'x';
|
||||||
|
} else {
|
||||||
|
selection.currentMode = 'xy';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function setSelectionPos(pos, e) {
|
||||||
|
var offset = plot.getPlaceholder().offset();
|
||||||
|
var plotOffset = plot.getPlotOffset();
|
||||||
|
pos.x = clamp(0, e.pageX - offset.left - plotOffset.left, plot.width());
|
||||||
|
pos.y = clamp(0, e.pageY - offset.top - plotOffset.top, plot.height());
|
||||||
|
|
||||||
|
if (pos !== selection.first) updateMode(pos);
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === "y") {
|
||||||
|
pos.x = pos === selection.first ? 0 : plot.width();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === "x") {
|
||||||
|
pos.y = pos === selection.first ? 0 : plot.height();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function updateSelection(pos) {
|
||||||
|
if (pos.pageX == null) return;
|
||||||
|
|
||||||
|
setSelectionPos(selection.second, pos);
|
||||||
|
if (selectionIsSane()) {
|
||||||
|
selection.show = true;
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
} else clearSelection(true);
|
||||||
|
}
|
||||||
|
|
||||||
|
function clearSelection(preventEvent) {
|
||||||
|
if (selection.show) {
|
||||||
|
selection.show = false;
|
||||||
|
selection.currentMode = '';
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
if (!preventEvent) {
|
||||||
|
plot.getPlaceholder().trigger("plotunselected", [ ]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// function taken from markings support in Flot
|
||||||
|
function extractRange(ranges, coord) {
|
||||||
|
var axis, from, to, key, axes = plot.getAxes();
|
||||||
|
|
||||||
|
for (var k in axes) {
|
||||||
|
axis = axes[k];
|
||||||
|
if (axis.direction === coord) {
|
||||||
|
key = coord + axis.n + "axis";
|
||||||
|
if (!ranges[key] && axis.n === 1) {
|
||||||
|
// support x1axis as xaxis
|
||||||
|
key = coord + "axis";
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ranges[key]) {
|
||||||
|
from = ranges[key].from;
|
||||||
|
to = ranges[key].to;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// backwards-compat stuff - to be removed in future
|
||||||
|
if (!ranges[key]) {
|
||||||
|
axis = coord === "x" ? plot.getXAxes()[0] : plot.getYAxes()[0];
|
||||||
|
from = ranges[coord + "1"];
|
||||||
|
to = ranges[coord + "2"];
|
||||||
|
}
|
||||||
|
|
||||||
|
// auto-reverse as an added bonus
|
||||||
|
if (from != null && to != null && from > to) {
|
||||||
|
var tmp = from;
|
||||||
|
from = to;
|
||||||
|
to = tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
return { from: from, to: to, axis: axis };
|
||||||
|
}
|
||||||
|
|
||||||
|
function setSelection(ranges, preventEvent) {
|
||||||
|
var range;
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === "y") {
|
||||||
|
selection.first.x = 0;
|
||||||
|
selection.second.x = plot.width();
|
||||||
|
} else {
|
||||||
|
range = extractRange(ranges, "x");
|
||||||
|
selection.first.x = range.axis.p2c(range.from);
|
||||||
|
selection.second.x = range.axis.p2c(range.to);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === "x") {
|
||||||
|
selection.first.y = 0;
|
||||||
|
selection.second.y = plot.height();
|
||||||
|
} else {
|
||||||
|
range = extractRange(ranges, "y");
|
||||||
|
selection.first.y = range.axis.p2c(range.from);
|
||||||
|
selection.second.y = range.axis.p2c(range.to);
|
||||||
|
}
|
||||||
|
|
||||||
|
selection.show = true;
|
||||||
|
plot.triggerRedrawOverlay();
|
||||||
|
if (!preventEvent && selectionIsSane()) {
|
||||||
|
triggerSelectedEvent();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function selectionIsSane() {
|
||||||
|
var minSize = plot.getOptions().selection.minSize;
|
||||||
|
return Math.abs(selection.second.x - selection.first.x) >= minSize &&
|
||||||
|
Math.abs(selection.second.y - selection.first.y) >= minSize;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.clearSelection = clearSelection;
|
||||||
|
plot.setSelection = setSelection;
|
||||||
|
plot.getSelection = getSelection;
|
||||||
|
|
||||||
|
plot.hooks.bindEvents.push(function(plot, eventHolder) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
if (o.selection.mode != null) {
|
||||||
|
plot.addEventHandler("dragstart", onDragStart, eventHolder, 0);
|
||||||
|
plot.addEventHandler("drag", onDrag, eventHolder, 0);
|
||||||
|
plot.addEventHandler("dragend", onDragEnd, eventHolder, 0);
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
function drawSelectionDecorations(ctx, x, y, w, h, oX, oY, mode) {
|
||||||
|
var spacing = 3;
|
||||||
|
var fullEarWidth = 15;
|
||||||
|
var earWidth = Math.max(0, Math.min(fullEarWidth, w / 2 - 2, h / 2 - 2));
|
||||||
|
ctx.fillStyle = '#ffffff';
|
||||||
|
|
||||||
|
if (mode === 'xy') {
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.moveTo(x, y + earWidth);
|
||||||
|
ctx.lineTo(x - 3, y + earWidth);
|
||||||
|
ctx.lineTo(x - 3, y - 3);
|
||||||
|
ctx.lineTo(x + earWidth, y - 3);
|
||||||
|
ctx.lineTo(x + earWidth, y);
|
||||||
|
ctx.lineTo(x, y);
|
||||||
|
ctx.closePath();
|
||||||
|
|
||||||
|
ctx.moveTo(x, y + h - earWidth);
|
||||||
|
ctx.lineTo(x - 3, y + h - earWidth);
|
||||||
|
ctx.lineTo(x - 3, y + h + 3);
|
||||||
|
ctx.lineTo(x + earWidth, y + h + 3);
|
||||||
|
ctx.lineTo(x + earWidth, y + h);
|
||||||
|
ctx.lineTo(x, y + h);
|
||||||
|
ctx.closePath();
|
||||||
|
|
||||||
|
ctx.moveTo(x + w, y + earWidth);
|
||||||
|
ctx.lineTo(x + w + 3, y + earWidth);
|
||||||
|
ctx.lineTo(x + w + 3, y - 3);
|
||||||
|
ctx.lineTo(x + w - earWidth, y - 3);
|
||||||
|
ctx.lineTo(x + w - earWidth, y);
|
||||||
|
ctx.lineTo(x + w, y);
|
||||||
|
ctx.closePath();
|
||||||
|
|
||||||
|
ctx.moveTo(x + w, y + h - earWidth);
|
||||||
|
ctx.lineTo(x + w + 3, y + h - earWidth);
|
||||||
|
ctx.lineTo(x + w + 3, y + h + 3);
|
||||||
|
ctx.lineTo(x + w - earWidth, y + h + 3);
|
||||||
|
ctx.lineTo(x + w - earWidth, y + h);
|
||||||
|
ctx.lineTo(x + w, y + h);
|
||||||
|
ctx.closePath();
|
||||||
|
|
||||||
|
ctx.stroke();
|
||||||
|
ctx.fill();
|
||||||
|
}
|
||||||
|
|
||||||
|
x = oX;
|
||||||
|
y = oY;
|
||||||
|
|
||||||
|
if (mode === 'x') {
|
||||||
|
ctx.beginPath();
|
||||||
|
ctx.moveTo(x, y + fullEarWidth);
|
||||||
|
ctx.lineTo(x, y - fullEarWidth);
|
||||||
|
ctx.lineTo(x - spacing, y - fullEarWidth);
|
||||||
|
ctx.lineTo(x - spacing, y + fullEarWidth);
|
||||||
|
ctx.closePath();
|
||||||
|
|
||||||
|
ctx.moveTo(x + w, y + fullEarWidth);
|
||||||
|
ctx.lineTo(x + w, y - fullEarWidth);
|
||||||
|
ctx.lineTo(x + w + spacing, y - fullEarWidth);
|
||||||
|
ctx.lineTo(x + w + spacing, y + fullEarWidth);
|
||||||
|
ctx.closePath();
|
||||||
|
ctx.stroke();
|
||||||
|
ctx.fill();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (mode === 'y') {
|
||||||
|
ctx.beginPath();
|
||||||
|
|
||||||
|
ctx.moveTo(x - fullEarWidth, y);
|
||||||
|
ctx.lineTo(x + fullEarWidth, y);
|
||||||
|
ctx.lineTo(x + fullEarWidth, y - spacing);
|
||||||
|
ctx.lineTo(x - fullEarWidth, y - spacing);
|
||||||
|
ctx.closePath();
|
||||||
|
|
||||||
|
ctx.moveTo(x - fullEarWidth, y + h);
|
||||||
|
ctx.lineTo(x + fullEarWidth, y + h);
|
||||||
|
ctx.lineTo(x + fullEarWidth, y + h + spacing);
|
||||||
|
ctx.lineTo(x - fullEarWidth, y + h + spacing);
|
||||||
|
ctx.closePath();
|
||||||
|
ctx.stroke();
|
||||||
|
ctx.fill();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.drawOverlay.push(function (plot, ctx) {
|
||||||
|
// draw selection
|
||||||
|
if (selection.show && selectionIsSane()) {
|
||||||
|
var plotOffset = plot.getPlotOffset();
|
||||||
|
var o = plot.getOptions();
|
||||||
|
|
||||||
|
ctx.save();
|
||||||
|
ctx.translate(plotOffset.left, plotOffset.top);
|
||||||
|
|
||||||
|
var c = $.color.parse(o.selection.color);
|
||||||
|
var visualization = o.selection.visualization;
|
||||||
|
var displaySelectionDecorations = o.selection.displaySelectionDecorations;
|
||||||
|
|
||||||
|
var scalingFactor = 1;
|
||||||
|
|
||||||
|
// use a dimmer scaling factor if visualization is "fill"
|
||||||
|
if (visualization === "fill") {
|
||||||
|
scalingFactor = 0.8;
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.strokeStyle = c.scale('a', scalingFactor).toString();
|
||||||
|
ctx.lineWidth = 1;
|
||||||
|
ctx.lineJoin = o.selection.shape;
|
||||||
|
ctx.fillStyle = c.scale('a', 0.4).toString();
|
||||||
|
|
||||||
|
var x = Math.min(selection.first.x, selection.second.x) + 0.5,
|
||||||
|
oX = x,
|
||||||
|
y = Math.min(selection.first.y, selection.second.y) + 0.5,
|
||||||
|
oY = y,
|
||||||
|
w = Math.abs(selection.second.x - selection.first.x) - 1,
|
||||||
|
h = Math.abs(selection.second.y - selection.first.y) - 1;
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === 'x') {
|
||||||
|
h += y;
|
||||||
|
y = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (selectionDirection(plot) === 'y') {
|
||||||
|
w += x;
|
||||||
|
x = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (visualization === "fill") {
|
||||||
|
ctx.fillRect(x, y, w, h);
|
||||||
|
ctx.strokeRect(x, y, w, h);
|
||||||
|
} else {
|
||||||
|
ctx.fillRect(0, 0, plot.width(), plot.height());
|
||||||
|
ctx.clearRect(x, y, w, h);
|
||||||
|
|
||||||
|
if (displaySelectionDecorations) {
|
||||||
|
drawSelectionDecorations(ctx, x, y, w, h, oX, oY, selectionDirection(plot));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx.restore();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
plot.hooks.shutdown.push(function (plot, eventHolder) {
|
||||||
|
eventHolder.unbind("dragstart", onDragStart);
|
||||||
|
eventHolder.unbind("drag", onDrag);
|
||||||
|
eventHolder.unbind("dragend", onDragEnd);
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: {
|
||||||
|
selection: {
|
||||||
|
mode: null, // one of null, "x", "y" or "xy"
|
||||||
|
visualization: "focus", // "focus" or "fill"
|
||||||
|
displaySelectionDecorations: true, // true or false (currently only relevant for the focus visualization)
|
||||||
|
color: "#888888",
|
||||||
|
shape: "round", // one of "round", "miter", or "bevel"
|
||||||
|
minSize: 5 // minimum number of pixels
|
||||||
|
}
|
||||||
|
},
|
||||||
|
name: 'selection',
|
||||||
|
version: '1.1'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,220 @@
|
||||||
|
/* Flot plugin for stacking data sets rather than overlaying them.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The plugin assumes the data is sorted on x (or y if stacking horizontally).
|
||||||
|
For line charts, it is assumed that if a line has an undefined gap (from a
|
||||||
|
null point), then the line above it should have the same gap - insert zeros
|
||||||
|
instead of "null" if you want another behaviour. This also holds for the start
|
||||||
|
and end of the chart. Note that stacking a mix of positive and negative values
|
||||||
|
in most instances doesn't make sense (so it looks weird).
|
||||||
|
|
||||||
|
Two or more series are stacked when their "stack" attribute is set to the same
|
||||||
|
key (which can be any number or string or just "true"). To specify the default
|
||||||
|
stack, you can set the stack option like this:
|
||||||
|
|
||||||
|
series: {
|
||||||
|
stack: null/false, true, or a key (number/string)
|
||||||
|
}
|
||||||
|
|
||||||
|
You can also specify it for a single series, like this:
|
||||||
|
|
||||||
|
$.plot( $("#placeholder"), [{
|
||||||
|
data: [ ... ],
|
||||||
|
stack: true
|
||||||
|
}])
|
||||||
|
|
||||||
|
The stacking order is determined by the order of the data series in the array
|
||||||
|
(later series end up on top of the previous).
|
||||||
|
|
||||||
|
Internally, the plugin modifies the datapoints in each series, adding an
|
||||||
|
offset to the y value. For line series, extra data points are inserted through
|
||||||
|
interpolation. If there's a second y value, it's also adjusted (e.g for bar
|
||||||
|
charts or filled areas).
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
series: { stack: null } // or number/string
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
function findMatchingSeries(s, allseries) {
|
||||||
|
var res = null;
|
||||||
|
for (var i = 0; i < allseries.length; ++i) {
|
||||||
|
if (s === allseries[i]) break;
|
||||||
|
|
||||||
|
if (allseries[i].stack === s.stack) {
|
||||||
|
res = allseries[i];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return res;
|
||||||
|
}
|
||||||
|
|
||||||
|
function addBottomPoints (s, datapoints) {
|
||||||
|
var formattedPoints = [];
|
||||||
|
for (var i = 0; i < datapoints.points.length; i += 2) {
|
||||||
|
formattedPoints.push(datapoints.points[i]);
|
||||||
|
formattedPoints.push(datapoints.points[i + 1]);
|
||||||
|
formattedPoints.push(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
datapoints.format.push({
|
||||||
|
x: s.bars.horizontal,
|
||||||
|
y: !s.bars.horizontal,
|
||||||
|
number: true,
|
||||||
|
required: false,
|
||||||
|
computeRange: s.yaxis.options.autoScale !== 'none',
|
||||||
|
defaultValue: 0
|
||||||
|
});
|
||||||
|
datapoints.points = formattedPoints;
|
||||||
|
datapoints.pointsize = 3;
|
||||||
|
}
|
||||||
|
|
||||||
|
function stackData(plot, s, datapoints) {
|
||||||
|
if (s.stack == null || s.stack === false) return;
|
||||||
|
|
||||||
|
var needsBottom = s.bars.show || (s.lines.show && s.lines.fill);
|
||||||
|
var hasBottom = datapoints.pointsize > 2 && (s.bars.horizontal ? datapoints.format[2].x : datapoints.format[2].y);
|
||||||
|
// Series data is missing bottom points - need to format
|
||||||
|
if (needsBottom && !hasBottom) {
|
||||||
|
addBottomPoints(s, datapoints);
|
||||||
|
}
|
||||||
|
|
||||||
|
var other = findMatchingSeries(s, plot.getData());
|
||||||
|
if (!other) return;
|
||||||
|
|
||||||
|
var ps = datapoints.pointsize,
|
||||||
|
points = datapoints.points,
|
||||||
|
otherps = other.datapoints.pointsize,
|
||||||
|
otherpoints = other.datapoints.points,
|
||||||
|
newpoints = [],
|
||||||
|
px, py, intery, qx, qy, bottom,
|
||||||
|
withlines = s.lines.show,
|
||||||
|
horizontal = s.bars.horizontal,
|
||||||
|
withsteps = withlines && s.lines.steps,
|
||||||
|
fromgap = true,
|
||||||
|
keyOffset = horizontal ? 1 : 0,
|
||||||
|
accumulateOffset = horizontal ? 0 : 1,
|
||||||
|
i = 0, j = 0, l, m;
|
||||||
|
|
||||||
|
while (true) {
|
||||||
|
if (i >= points.length) break;
|
||||||
|
|
||||||
|
l = newpoints.length;
|
||||||
|
|
||||||
|
if (points[i] == null) {
|
||||||
|
// copy gaps
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[i + m]);
|
||||||
|
}
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
} else if (j >= otherpoints.length) {
|
||||||
|
// for lines, we can't use the rest of the points
|
||||||
|
if (!withlines) {
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[i + m]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
} else if (otherpoints[j] == null) {
|
||||||
|
// oops, got a gap
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(null);
|
||||||
|
}
|
||||||
|
|
||||||
|
fromgap = true;
|
||||||
|
j += otherps;
|
||||||
|
} else {
|
||||||
|
// cases where we actually got two points
|
||||||
|
px = points[i + keyOffset];
|
||||||
|
py = points[i + accumulateOffset];
|
||||||
|
qx = otherpoints[j + keyOffset];
|
||||||
|
qy = otherpoints[j + accumulateOffset];
|
||||||
|
bottom = 0;
|
||||||
|
|
||||||
|
if (px === qx) {
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[i + m]);
|
||||||
|
}
|
||||||
|
|
||||||
|
newpoints[l + accumulateOffset] += qy;
|
||||||
|
bottom = qy;
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
j += otherps;
|
||||||
|
} else if (px > qx) {
|
||||||
|
// we got past point below, might need to
|
||||||
|
// insert interpolated extra point
|
||||||
|
if (withlines && i > 0 && points[i - ps] != null) {
|
||||||
|
intery = py + (points[i - ps + accumulateOffset] - py) * (qx - px) / (points[i - ps + keyOffset] - px);
|
||||||
|
newpoints.push(qx);
|
||||||
|
newpoints.push(intery + qy);
|
||||||
|
for (m = 2; m < ps; ++m) {
|
||||||
|
newpoints.push(points[i + m]);
|
||||||
|
}
|
||||||
|
|
||||||
|
bottom = qy;
|
||||||
|
}
|
||||||
|
|
||||||
|
j += otherps;
|
||||||
|
} else { // px < qx
|
||||||
|
if (fromgap && withlines) {
|
||||||
|
// if we come from a gap, we just skip this point
|
||||||
|
i += ps;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints.push(points[i + m]);
|
||||||
|
}
|
||||||
|
|
||||||
|
// we might be able to interpolate a point below,
|
||||||
|
// this can give us a better y
|
||||||
|
if (withlines && j > 0 && otherpoints[j - otherps] != null) {
|
||||||
|
bottom = qy + (otherpoints[j - otherps + accumulateOffset] - qy) * (px - qx) / (otherpoints[j - otherps + keyOffset] - qx);
|
||||||
|
}
|
||||||
|
|
||||||
|
newpoints[l + accumulateOffset] += bottom;
|
||||||
|
|
||||||
|
i += ps;
|
||||||
|
}
|
||||||
|
|
||||||
|
fromgap = false;
|
||||||
|
|
||||||
|
if (l !== newpoints.length && needsBottom) {
|
||||||
|
newpoints[l + 2] += bottom;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// maintain the line steps invariant
|
||||||
|
if (withsteps && l !== newpoints.length && l > 0 &&
|
||||||
|
newpoints[l] !== null &&
|
||||||
|
newpoints[l] !== newpoints[l - ps] &&
|
||||||
|
newpoints[l + 1] !== newpoints[l - ps + 1]) {
|
||||||
|
for (m = 0; m < ps; ++m) {
|
||||||
|
newpoints[l + ps + m] = newpoints[l + m];
|
||||||
|
}
|
||||||
|
|
||||||
|
newpoints[l + 1] = newpoints[l - ps + 1];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
datapoints.points = newpoints;
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.processDatapoints.push(stackData);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'stack',
|
||||||
|
version: '1.2'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,98 @@
|
||||||
|
/* Flot plugin that adds some extra symbols for plotting points.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The symbols are accessed as strings through the standard symbol options:
|
||||||
|
|
||||||
|
series: {
|
||||||
|
points: {
|
||||||
|
symbol: "square" // or "diamond", "triangle", "cross", "plus", "ellipse", "rectangle"
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
// we normalize the area of each symbol so it is approximately the
|
||||||
|
// same as a circle of the given radius
|
||||||
|
|
||||||
|
var square = function (ctx, x, y, radius, shadow) {
|
||||||
|
// pi * r^2 = (2s)^2 => s = r * sqrt(pi)/2
|
||||||
|
var size = radius * Math.sqrt(Math.PI) / 2;
|
||||||
|
ctx.rect(x - size, y - size, size + size, size + size);
|
||||||
|
},
|
||||||
|
rectangle = function (ctx, x, y, radius, shadow) {
|
||||||
|
// pi * r^2 = (2s)^2 => s = r * sqrt(pi)/2
|
||||||
|
var size = radius * Math.sqrt(Math.PI) / 2;
|
||||||
|
ctx.rect(x - size, y - size, size + size, size + size);
|
||||||
|
},
|
||||||
|
diamond = function (ctx, x, y, radius, shadow) {
|
||||||
|
// pi * r^2 = 2s^2 => s = r * sqrt(pi/2)
|
||||||
|
var size = radius * Math.sqrt(Math.PI / 2);
|
||||||
|
ctx.moveTo(x - size, y);
|
||||||
|
ctx.lineTo(x, y - size);
|
||||||
|
ctx.lineTo(x + size, y);
|
||||||
|
ctx.lineTo(x, y + size);
|
||||||
|
ctx.lineTo(x - size, y);
|
||||||
|
ctx.lineTo(x, y - size);
|
||||||
|
},
|
||||||
|
triangle = function (ctx, x, y, radius, shadow) {
|
||||||
|
// pi * r^2 = 1/2 * s^2 * sin (pi / 3) => s = r * sqrt(2 * pi / sin(pi / 3))
|
||||||
|
var size = radius * Math.sqrt(2 * Math.PI / Math.sin(Math.PI / 3));
|
||||||
|
var height = size * Math.sin(Math.PI / 3);
|
||||||
|
ctx.moveTo(x - size / 2, y + height / 2);
|
||||||
|
ctx.lineTo(x + size / 2, y + height / 2);
|
||||||
|
if (!shadow) {
|
||||||
|
ctx.lineTo(x, y - height / 2);
|
||||||
|
ctx.lineTo(x - size / 2, y + height / 2);
|
||||||
|
ctx.lineTo(x + size / 2, y + height / 2);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
cross = function (ctx, x, y, radius, shadow) {
|
||||||
|
// pi * r^2 = (2s)^2 => s = r * sqrt(pi)/2
|
||||||
|
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);
|
||||||
|
},
|
||||||
|
ellipse = function(ctx, x, y, radius, shadow, fill) {
|
||||||
|
if (!shadow) {
|
||||||
|
ctx.moveTo(x + radius, y);
|
||||||
|
ctx.arc(x, y, radius, 0, Math.PI * 2, false);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
plus = function (ctx, x, y, radius, shadow) {
|
||||||
|
var size = radius * Math.sqrt(Math.PI / 2);
|
||||||
|
ctx.moveTo(x - size, y);
|
||||||
|
ctx.lineTo(x + size, y);
|
||||||
|
ctx.moveTo(x, y + size);
|
||||||
|
ctx.lineTo(x, y - size);
|
||||||
|
},
|
||||||
|
handlers = {
|
||||||
|
square: square,
|
||||||
|
rectangle: rectangle,
|
||||||
|
diamond: diamond,
|
||||||
|
triangle: triangle,
|
||||||
|
cross: cross,
|
||||||
|
ellipse: ellipse,
|
||||||
|
plus: plus
|
||||||
|
};
|
||||||
|
|
||||||
|
square.fill = true;
|
||||||
|
rectangle.fill = true;
|
||||||
|
diamond.fill = true;
|
||||||
|
triangle.fill = true;
|
||||||
|
ellipse.fill = true;
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.drawSymbol = handlers;
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
name: 'symbols',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,143 @@
|
||||||
|
/* Flot plugin for thresholding data.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
The plugin supports these options:
|
||||||
|
|
||||||
|
series: {
|
||||||
|
threshold: {
|
||||||
|
below: number
|
||||||
|
color: colorspec
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
It can also be applied to a single series, like this:
|
||||||
|
|
||||||
|
$.plot( $("#placeholder"), [{
|
||||||
|
data: [ ... ],
|
||||||
|
threshold: { ... }
|
||||||
|
}])
|
||||||
|
|
||||||
|
An array can be passed for multiple thresholding, like this:
|
||||||
|
|
||||||
|
threshold: [{
|
||||||
|
below: number1
|
||||||
|
color: color1
|
||||||
|
},{
|
||||||
|
below: number2
|
||||||
|
color: color2
|
||||||
|
}]
|
||||||
|
|
||||||
|
These multiple threshold objects can be passed in any order since they are
|
||||||
|
sorted by the processing function.
|
||||||
|
|
||||||
|
The data points below "below" are drawn with the specified color. This makes
|
||||||
|
it easy to mark points below 0, e.g. for budget data.
|
||||||
|
|
||||||
|
Internally, the plugin works by splitting the data into two series, above and
|
||||||
|
below the threshold. The extra series below the threshold will have its label
|
||||||
|
cleared and the special "originSeries" attribute set to the original series.
|
||||||
|
You may need to check for this in hover events.
|
||||||
|
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function ($) {
|
||||||
|
var options = {
|
||||||
|
series: { threshold: null } // or { below: number, color: color spec}
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
function thresholdData(plot, s, datapoints, below, color) {
|
||||||
|
var ps = datapoints.pointsize, i, x, y, p, prevp,
|
||||||
|
thresholded = $.extend({}, s); // note: shallow copy
|
||||||
|
|
||||||
|
thresholded.datapoints = { points: [], pointsize: ps, format: datapoints.format };
|
||||||
|
thresholded.label = null;
|
||||||
|
thresholded.color = color;
|
||||||
|
thresholded.threshold = null;
|
||||||
|
thresholded.originSeries = s;
|
||||||
|
thresholded.data = [];
|
||||||
|
|
||||||
|
var origpoints = datapoints.points,
|
||||||
|
addCrossingPoints = s.lines.show;
|
||||||
|
|
||||||
|
var threspoints = [];
|
||||||
|
var newpoints = [];
|
||||||
|
var m;
|
||||||
|
|
||||||
|
for (i = 0; i < origpoints.length; i += ps) {
|
||||||
|
x = origpoints[i];
|
||||||
|
y = origpoints[i + 1];
|
||||||
|
|
||||||
|
prevp = p;
|
||||||
|
if (y < below) p = threspoints;
|
||||||
|
else p = newpoints;
|
||||||
|
|
||||||
|
if (addCrossingPoints && prevp !== p &&
|
||||||
|
x !== null && i > 0 &&
|
||||||
|
origpoints[i - ps] != null) {
|
||||||
|
var interx = x + (below - y) * (x - origpoints[i - ps]) / (y - origpoints[i - ps + 1]);
|
||||||
|
prevp.push(interx);
|
||||||
|
prevp.push(below);
|
||||||
|
for (m = 2; m < ps; ++m) {
|
||||||
|
prevp.push(origpoints[i + m]);
|
||||||
|
}
|
||||||
|
|
||||||
|
p.push(null); // start new segment
|
||||||
|
p.push(null);
|
||||||
|
for (m = 2; m < ps; ++m) {
|
||||||
|
p.push(origpoints[i + m]);
|
||||||
|
}
|
||||||
|
|
||||||
|
p.push(interx);
|
||||||
|
p.push(below);
|
||||||
|
for (m = 2; m < ps; ++m) {
|
||||||
|
p.push(origpoints[i + m]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
p.push(x);
|
||||||
|
p.push(y);
|
||||||
|
for (m = 2; m < ps; ++m) {
|
||||||
|
p.push(origpoints[i + m]);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
datapoints.points = newpoints;
|
||||||
|
thresholded.datapoints.points = threspoints;
|
||||||
|
|
||||||
|
if (thresholded.datapoints.points.length > 0) {
|
||||||
|
var origIndex = $.inArray(s, plot.getData());
|
||||||
|
// Insert newly-generated series right after original one (to prevent it from becoming top-most)
|
||||||
|
plot.getData().splice(origIndex + 1, 0, thresholded);
|
||||||
|
}
|
||||||
|
|
||||||
|
// FIXME: there are probably some edge cases left in bars
|
||||||
|
}
|
||||||
|
|
||||||
|
function processThresholds(plot, s, datapoints) {
|
||||||
|
if (!s.threshold) return;
|
||||||
|
if (s.threshold instanceof Array) {
|
||||||
|
s.threshold.sort(function(a, b) {
|
||||||
|
return a.below - b.below;
|
||||||
|
});
|
||||||
|
|
||||||
|
$(s.threshold).each(function(i, th) {
|
||||||
|
thresholdData(plot, s, datapoints, th.below, th.color);
|
||||||
|
});
|
||||||
|
} else {
|
||||||
|
thresholdData(plot, s, datapoints, s.threshold.below, s.threshold.color);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
plot.hooks.processDatapoints.push(processThresholds);
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'threshold',
|
||||||
|
version: '1.2'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,586 @@
|
||||||
|
/* Pretty handling of time axes.
|
||||||
|
|
||||||
|
Copyright (c) 2007-2014 IOLA and Ole Laursen.
|
||||||
|
Licensed under the MIT license.
|
||||||
|
|
||||||
|
Set axis.mode to "time" to enable. See the section "Time series data" in
|
||||||
|
API.txt for details.
|
||||||
|
*/
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
xaxis: {
|
||||||
|
timezone: null, // "browser" for local to the client or timezone for timezone-js
|
||||||
|
timeformat: null, // format string to use
|
||||||
|
twelveHourClock: false, // 12 or 24 time in time mode
|
||||||
|
monthNames: null, // list of names of months
|
||||||
|
timeBase: 'seconds' // are the values in given in mircoseconds, milliseconds or seconds
|
||||||
|
},
|
||||||
|
yaxis: {
|
||||||
|
timeBase: 'seconds'
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var floorInBase = $.plot.saturated.floorInBase;
|
||||||
|
|
||||||
|
// Method to provide microsecond support to Date like classes.
|
||||||
|
var CreateMicroSecondDate = function(DateType, microEpoch) {
|
||||||
|
var newDate = new DateType(microEpoch);
|
||||||
|
|
||||||
|
var oldSetTime = newDate.setTime.bind(newDate);
|
||||||
|
newDate.update = function(microEpoch) {
|
||||||
|
// Round epoch to 3 decimal accuracy
|
||||||
|
microEpoch = Math.round(microEpoch * 1000) / 1000;
|
||||||
|
|
||||||
|
oldSetTime(microEpoch);
|
||||||
|
|
||||||
|
// Microseconds are stored as integers
|
||||||
|
this.microseconds = 1000 * (microEpoch - Math.floor(microEpoch));
|
||||||
|
};
|
||||||
|
|
||||||
|
var oldGetTime = newDate.getTime.bind(newDate);
|
||||||
|
newDate.getTime = function () {
|
||||||
|
var microEpoch = oldGetTime() + this.microseconds / 1000;
|
||||||
|
return microEpoch;
|
||||||
|
};
|
||||||
|
|
||||||
|
newDate.setTime = function (microEpoch) {
|
||||||
|
this.update(microEpoch);
|
||||||
|
};
|
||||||
|
|
||||||
|
newDate.getMicroseconds = function() {
|
||||||
|
return this.microseconds;
|
||||||
|
};
|
||||||
|
|
||||||
|
newDate.setMicroseconds = function(microseconds) {
|
||||||
|
var epochWithoutMicroseconds = oldGetTime();
|
||||||
|
var newEpoch = epochWithoutMicroseconds + microseconds / 1000;
|
||||||
|
this.update(newEpoch);
|
||||||
|
};
|
||||||
|
|
||||||
|
newDate.setUTCMicroseconds = function(microseconds) { this.setMicroseconds(microseconds); }
|
||||||
|
|
||||||
|
newDate.getUTCMicroseconds = function() { return this.getMicroseconds(); }
|
||||||
|
|
||||||
|
newDate.microseconds = null;
|
||||||
|
newDate.microEpoch = null;
|
||||||
|
newDate.update(microEpoch);
|
||||||
|
return newDate;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Returns a string with the date d formatted according to fmt.
|
||||||
|
// A subset of the Open Group's strftime format is supported.
|
||||||
|
|
||||||
|
function formatDate(d, fmt, monthNames, dayNames) {
|
||||||
|
if (typeof d.strftime === "function") {
|
||||||
|
return d.strftime(fmt);
|
||||||
|
}
|
||||||
|
|
||||||
|
var leftPad = function(n, pad) {
|
||||||
|
n = "" + n;
|
||||||
|
pad = "" + (pad == null ? "0" : pad);
|
||||||
|
return n.length === 1 ? pad + n : n;
|
||||||
|
};
|
||||||
|
|
||||||
|
var formatSubSeconds = function(milliseconds, microseconds, numberDecimalPlaces) {
|
||||||
|
var totalMicroseconds = milliseconds * 1000 + microseconds;
|
||||||
|
var formattedString;
|
||||||
|
if (numberDecimalPlaces < 6 && numberDecimalPlaces > 0) {
|
||||||
|
var magnitude = parseFloat('1e' + (numberDecimalPlaces - 6));
|
||||||
|
totalMicroseconds = Math.round(Math.round(totalMicroseconds * magnitude) / magnitude);
|
||||||
|
formattedString = ('00000' + totalMicroseconds).slice(-6, -(6 - numberDecimalPlaces));
|
||||||
|
} else {
|
||||||
|
totalMicroseconds = Math.round(totalMicroseconds)
|
||||||
|
formattedString = ('00000' + totalMicroseconds).slice(-6);
|
||||||
|
}
|
||||||
|
return formattedString;
|
||||||
|
};
|
||||||
|
|
||||||
|
var r = [];
|
||||||
|
var escape = false;
|
||||||
|
var hours = d.getHours();
|
||||||
|
var isAM = hours < 12;
|
||||||
|
|
||||||
|
if (!monthNames) {
|
||||||
|
monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!dayNames) {
|
||||||
|
dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
|
||||||
|
}
|
||||||
|
|
||||||
|
var hours12;
|
||||||
|
if (hours > 12) {
|
||||||
|
hours12 = hours - 12;
|
||||||
|
} else if (hours === 0) {
|
||||||
|
hours12 = 12;
|
||||||
|
} else {
|
||||||
|
hours12 = hours;
|
||||||
|
}
|
||||||
|
|
||||||
|
var decimals = -1;
|
||||||
|
for (var i = 0; i < fmt.length; ++i) {
|
||||||
|
var c = fmt.charAt(i);
|
||||||
|
|
||||||
|
if (!isNaN(Number(c)) && Number(c) > 0) {
|
||||||
|
decimals = Number(c);
|
||||||
|
} else if (escape) {
|
||||||
|
switch (c) {
|
||||||
|
case 'a': c = "" + dayNames[d.getDay()]; break;
|
||||||
|
case 'b': c = "" + monthNames[d.getMonth()]; break;
|
||||||
|
case 'd': c = leftPad(d.getDate()); break;
|
||||||
|
case 'e': c = leftPad(d.getDate(), " "); break;
|
||||||
|
case 'h': // For back-compat with 0.7; remove in 1.0
|
||||||
|
case 'H': c = leftPad(hours); break;
|
||||||
|
case 'I': c = leftPad(hours12); break;
|
||||||
|
case 'l': c = leftPad(hours12, " "); break;
|
||||||
|
case 'm': c = leftPad(d.getMonth() + 1); break;
|
||||||
|
case 'M': c = leftPad(d.getMinutes()); break;
|
||||||
|
// quarters not in Open Group's strftime specification
|
||||||
|
case 'q':
|
||||||
|
c = "" + (Math.floor(d.getMonth() / 3) + 1); break;
|
||||||
|
case 'S': c = leftPad(d.getSeconds()); break;
|
||||||
|
case 's': c = "" + formatSubSeconds(d.getMilliseconds(), d.getMicroseconds(), decimals); break;
|
||||||
|
case 'y': c = leftPad(d.getFullYear() % 100); break;
|
||||||
|
case 'Y': c = "" + d.getFullYear(); break;
|
||||||
|
case 'p': c = (isAM) ? ("" + "am") : ("" + "pm"); break;
|
||||||
|
case 'P': c = (isAM) ? ("" + "AM") : ("" + "PM"); break;
|
||||||
|
case 'w': c = "" + d.getDay(); break;
|
||||||
|
}
|
||||||
|
r.push(c);
|
||||||
|
escape = false;
|
||||||
|
} else {
|
||||||
|
if (c === "%") {
|
||||||
|
escape = true;
|
||||||
|
} else {
|
||||||
|
r.push(c);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return r.join("");
|
||||||
|
}
|
||||||
|
|
||||||
|
// To have a consistent view of time-based data independent of which time
|
||||||
|
// zone the client happens to be in we need a date-like object independent
|
||||||
|
// of time zones. This is done through a wrapper that only calls the UTC
|
||||||
|
// versions of the accessor methods.
|
||||||
|
|
||||||
|
function makeUtcWrapper(d) {
|
||||||
|
function addProxyMethod(sourceObj, sourceMethod, targetObj, targetMethod) {
|
||||||
|
sourceObj[sourceMethod] = function() {
|
||||||
|
return targetObj[targetMethod].apply(targetObj, arguments);
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
var utc = {
|
||||||
|
date: d
|
||||||
|
};
|
||||||
|
|
||||||
|
// support strftime, if found
|
||||||
|
if (d.strftime !== undefined) {
|
||||||
|
addProxyMethod(utc, "strftime", d, "strftime");
|
||||||
|
}
|
||||||
|
|
||||||
|
addProxyMethod(utc, "getTime", d, "getTime");
|
||||||
|
addProxyMethod(utc, "setTime", d, "setTime");
|
||||||
|
|
||||||
|
var props = ["Date", "Day", "FullYear", "Hours", "Minutes", "Month", "Seconds", "Milliseconds", "Microseconds"];
|
||||||
|
|
||||||
|
for (var p = 0; p < props.length; p++) {
|
||||||
|
addProxyMethod(utc, "get" + props[p], d, "getUTC" + props[p]);
|
||||||
|
addProxyMethod(utc, "set" + props[p], d, "setUTC" + props[p]);
|
||||||
|
}
|
||||||
|
|
||||||
|
return utc;
|
||||||
|
}
|
||||||
|
|
||||||
|
// select time zone strategy. This returns a date-like object tied to the
|
||||||
|
// desired timezone
|
||||||
|
function dateGenerator(ts, opts) {
|
||||||
|
var maxDateValue = 8640000000000000;
|
||||||
|
|
||||||
|
if (opts && opts.timeBase === 'seconds') {
|
||||||
|
ts *= 1000;
|
||||||
|
} else if (opts.timeBase === 'microseconds') {
|
||||||
|
ts /= 1000;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ts > maxDateValue) {
|
||||||
|
ts = maxDateValue;
|
||||||
|
} else if (ts < -maxDateValue) {
|
||||||
|
ts = -maxDateValue;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (opts.timezone === "browser") {
|
||||||
|
return CreateMicroSecondDate(Date, ts);
|
||||||
|
} else if (!opts.timezone || opts.timezone === "utc") {
|
||||||
|
return makeUtcWrapper(CreateMicroSecondDate(Date, ts));
|
||||||
|
} else if (typeof timezoneJS !== "undefined" && typeof timezoneJS.Date !== "undefined") {
|
||||||
|
var d = CreateMicroSecondDate(timezoneJS.Date, ts);
|
||||||
|
// timezone-js is fickle, so be sure to set the time zone before
|
||||||
|
// setting the time.
|
||||||
|
d.setTimezone(opts.timezone);
|
||||||
|
d.setTime(ts);
|
||||||
|
return d;
|
||||||
|
} else {
|
||||||
|
return makeUtcWrapper(CreateMicroSecondDate(Date, ts));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// map of app. size of time units in seconds
|
||||||
|
var timeUnitSizeSeconds = {
|
||||||
|
"microsecond": 0.000001,
|
||||||
|
"millisecond": 0.001,
|
||||||
|
"second": 1,
|
||||||
|
"minute": 60,
|
||||||
|
"hour": 60 * 60,
|
||||||
|
"day": 24 * 60 * 60,
|
||||||
|
"month": 30 * 24 * 60 * 60,
|
||||||
|
"quarter": 3 * 30 * 24 * 60 * 60,
|
||||||
|
"year": 365.2425 * 24 * 60 * 60
|
||||||
|
};
|
||||||
|
|
||||||
|
// map of app. size of time units in milliseconds
|
||||||
|
var timeUnitSizeMilliseconds = {
|
||||||
|
"microsecond": 0.001,
|
||||||
|
"millisecond": 1,
|
||||||
|
"second": 1000,
|
||||||
|
"minute": 60 * 1000,
|
||||||
|
"hour": 60 * 60 * 1000,
|
||||||
|
"day": 24 * 60 * 60 * 1000,
|
||||||
|
"month": 30 * 24 * 60 * 60 * 1000,
|
||||||
|
"quarter": 3 * 30 * 24 * 60 * 60 * 1000,
|
||||||
|
"year": 365.2425 * 24 * 60 * 60 * 1000
|
||||||
|
};
|
||||||
|
|
||||||
|
// map of app. size of time units in microseconds
|
||||||
|
var timeUnitSizeMicroseconds = {
|
||||||
|
"microsecond": 1,
|
||||||
|
"millisecond": 1000,
|
||||||
|
"second": 1000000,
|
||||||
|
"minute": 60 * 1000000,
|
||||||
|
"hour": 60 * 60 * 1000000,
|
||||||
|
"day": 24 * 60 * 60 * 1000000,
|
||||||
|
"month": 30 * 24 * 60 * 60 * 1000000,
|
||||||
|
"quarter": 3 * 30 * 24 * 60 * 60 * 1000000,
|
||||||
|
"year": 365.2425 * 24 * 60 * 60 * 1000000
|
||||||
|
};
|
||||||
|
|
||||||
|
// the allowed tick sizes, after 1 year we use
|
||||||
|
// an integer algorithm
|
||||||
|
|
||||||
|
var baseSpec = [
|
||||||
|
[1, "microsecond"], [2, "microsecond"], [5, "microsecond"], [10, "microsecond"],
|
||||||
|
[25, "microsecond"], [50, "microsecond"], [100, "microsecond"], [250, "microsecond"], [500, "microsecond"],
|
||||||
|
[1, "millisecond"], [2, "millisecond"], [5, "millisecond"], [10, "millisecond"],
|
||||||
|
[25, "millisecond"], [50, "millisecond"], [100, "millisecond"], [250, "millisecond"], [500, "millisecond"],
|
||||||
|
[1, "second"], [2, "second"], [5, "second"], [10, "second"],
|
||||||
|
[30, "second"],
|
||||||
|
[1, "minute"], [2, "minute"], [5, "minute"], [10, "minute"],
|
||||||
|
[30, "minute"],
|
||||||
|
[1, "hour"], [2, "hour"], [4, "hour"],
|
||||||
|
[8, "hour"], [12, "hour"],
|
||||||
|
[1, "day"], [2, "day"], [3, "day"],
|
||||||
|
[0.25, "month"], [0.5, "month"], [1, "month"],
|
||||||
|
[2, "month"]
|
||||||
|
];
|
||||||
|
|
||||||
|
// we don't know which variant(s) we'll need yet, but generating both is
|
||||||
|
// cheap
|
||||||
|
|
||||||
|
var specMonths = baseSpec.concat([[3, "month"], [6, "month"],
|
||||||
|
[1, "year"]]);
|
||||||
|
var specQuarters = baseSpec.concat([[1, "quarter"], [2, "quarter"],
|
||||||
|
[1, "year"]]);
|
||||||
|
|
||||||
|
function dateTickGenerator(axis) {
|
||||||
|
var opts = axis.options,
|
||||||
|
ticks = [],
|
||||||
|
d = dateGenerator(axis.min, opts),
|
||||||
|
minSize = 0;
|
||||||
|
|
||||||
|
// make quarter use a possibility if quarters are
|
||||||
|
// mentioned in either of these options
|
||||||
|
var spec = (opts.tickSize && opts.tickSize[1] ===
|
||||||
|
"quarter") ||
|
||||||
|
(opts.minTickSize && opts.minTickSize[1] ===
|
||||||
|
"quarter") ? specQuarters : specMonths;
|
||||||
|
|
||||||
|
var timeUnitSize;
|
||||||
|
if (opts.timeBase === 'seconds') {
|
||||||
|
timeUnitSize = timeUnitSizeSeconds;
|
||||||
|
} else if (opts.timeBase === 'microseconds') {
|
||||||
|
timeUnitSize = timeUnitSizeMicroseconds;
|
||||||
|
} else {
|
||||||
|
timeUnitSize = timeUnitSizeMilliseconds;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (opts.minTickSize !== null && opts.minTickSize !== undefined) {
|
||||||
|
if (typeof opts.tickSize === "number") {
|
||||||
|
minSize = opts.tickSize;
|
||||||
|
} else {
|
||||||
|
minSize = opts.minTickSize[0] * timeUnitSize[opts.minTickSize[1]];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
for (var i = 0; i < spec.length - 1; ++i) {
|
||||||
|
if (axis.delta < (spec[i][0] * timeUnitSize[spec[i][1]] +
|
||||||
|
spec[i + 1][0] * timeUnitSize[spec[i + 1][1]]) / 2 &&
|
||||||
|
spec[i][0] * timeUnitSize[spec[i][1]] >= minSize) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var size = spec[i][0];
|
||||||
|
var unit = spec[i][1];
|
||||||
|
// special-case the possibility of several years
|
||||||
|
if (unit === "year") {
|
||||||
|
// if given a minTickSize in years, just use it,
|
||||||
|
// ensuring that it's an integer
|
||||||
|
|
||||||
|
if (opts.minTickSize !== null && opts.minTickSize !== undefined && opts.minTickSize[1] === "year") {
|
||||||
|
size = Math.floor(opts.minTickSize[0]);
|
||||||
|
} else {
|
||||||
|
var magn = parseFloat('1e' + Math.floor(Math.log(axis.delta / timeUnitSize.year) / Math.LN10));
|
||||||
|
var norm = (axis.delta / timeUnitSize.year) / magn;
|
||||||
|
|
||||||
|
if (norm < 1.5) {
|
||||||
|
size = 1;
|
||||||
|
} else if (norm < 3) {
|
||||||
|
size = 2;
|
||||||
|
} else if (norm < 7.5) {
|
||||||
|
size = 5;
|
||||||
|
} else {
|
||||||
|
size = 10;
|
||||||
|
}
|
||||||
|
|
||||||
|
size *= magn;
|
||||||
|
}
|
||||||
|
|
||||||
|
// minimum size for years is 1
|
||||||
|
|
||||||
|
if (size < 1) {
|
||||||
|
size = 1;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
axis.tickSize = opts.tickSize || [size, unit];
|
||||||
|
var tickSize = axis.tickSize[0];
|
||||||
|
unit = axis.tickSize[1];
|
||||||
|
|
||||||
|
var step = tickSize * timeUnitSize[unit];
|
||||||
|
|
||||||
|
if (unit === "microsecond") {
|
||||||
|
d.setMicroseconds(floorInBase(d.getMicroseconds(), tickSize));
|
||||||
|
} else if (unit === "millisecond") {
|
||||||
|
d.setMilliseconds(floorInBase(d.getMilliseconds(), tickSize));
|
||||||
|
} else if (unit === "second") {
|
||||||
|
d.setSeconds(floorInBase(d.getSeconds(), tickSize));
|
||||||
|
} else if (unit === "minute") {
|
||||||
|
d.setMinutes(floorInBase(d.getMinutes(), tickSize));
|
||||||
|
} else if (unit === "hour") {
|
||||||
|
d.setHours(floorInBase(d.getHours(), tickSize));
|
||||||
|
} else if (unit === "month") {
|
||||||
|
d.setMonth(floorInBase(d.getMonth(), tickSize));
|
||||||
|
} else if (unit === "quarter") {
|
||||||
|
d.setMonth(3 * floorInBase(d.getMonth() / 3,
|
||||||
|
tickSize));
|
||||||
|
} else if (unit === "year") {
|
||||||
|
d.setFullYear(floorInBase(d.getFullYear(), tickSize));
|
||||||
|
}
|
||||||
|
|
||||||
|
// reset smaller components
|
||||||
|
|
||||||
|
if (step >= timeUnitSize.millisecond) {
|
||||||
|
d.setMicroseconds(0);
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.second) {
|
||||||
|
d.setMilliseconds(0);
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.minute) {
|
||||||
|
d.setSeconds(0);
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.hour) {
|
||||||
|
d.setMinutes(0);
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.day) {
|
||||||
|
d.setHours(0);
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.day * 4) {
|
||||||
|
d.setDate(1);
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.month * 2) {
|
||||||
|
d.setMonth(floorInBase(d.getMonth(), 3));
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.quarter * 2) {
|
||||||
|
d.setMonth(floorInBase(d.getMonth(), 6));
|
||||||
|
}
|
||||||
|
if (step >= timeUnitSize.year) {
|
||||||
|
d.setMonth(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
var carry = 0;
|
||||||
|
var v = Number.NaN;
|
||||||
|
var v1000;
|
||||||
|
var prev;
|
||||||
|
do {
|
||||||
|
prev = v;
|
||||||
|
v1000 = d.getTime();
|
||||||
|
if (opts && opts.timeBase === 'seconds') {
|
||||||
|
v = v1000 / 1000;
|
||||||
|
} else if (opts && opts.timeBase === 'microseconds') {
|
||||||
|
v = v1000 * 1000;
|
||||||
|
} else {
|
||||||
|
v = v1000;
|
||||||
|
}
|
||||||
|
|
||||||
|
ticks.push(v);
|
||||||
|
|
||||||
|
if (unit === "month" || unit === "quarter") {
|
||||||
|
if (tickSize < 1) {
|
||||||
|
// a bit complicated - we'll divide the
|
||||||
|
// month/quarter up but we need to take
|
||||||
|
// care of fractions so we don't end up in
|
||||||
|
// the middle of a day
|
||||||
|
d.setDate(1);
|
||||||
|
var start = d.getTime();
|
||||||
|
d.setMonth(d.getMonth() +
|
||||||
|
(unit === "quarter" ? 3 : 1));
|
||||||
|
var end = d.getTime();
|
||||||
|
d.setTime((v + carry * timeUnitSize.hour + (end - start) * tickSize));
|
||||||
|
carry = d.getHours();
|
||||||
|
d.setHours(0);
|
||||||
|
} else {
|
||||||
|
d.setMonth(d.getMonth() +
|
||||||
|
tickSize * (unit === "quarter" ? 3 : 1));
|
||||||
|
}
|
||||||
|
} else if (unit === "year") {
|
||||||
|
d.setFullYear(d.getFullYear() + tickSize);
|
||||||
|
} else {
|
||||||
|
if (opts.timeBase === 'seconds') {
|
||||||
|
d.setTime((v + step) * 1000);
|
||||||
|
} else if (opts.timeBase === 'microseconds') {
|
||||||
|
d.setTime((v + step) / 1000);
|
||||||
|
} else {
|
||||||
|
d.setTime(v + step);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} while (v < axis.max && v !== prev);
|
||||||
|
|
||||||
|
return ticks;
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processOptions.push(function (plot) {
|
||||||
|
$.each(plot.getAxes(), function(axisName, axis) {
|
||||||
|
var opts = axis.options;
|
||||||
|
if (opts.mode === "time") {
|
||||||
|
axis.tickGenerator = dateTickGenerator;
|
||||||
|
|
||||||
|
// if a tick formatter is already provided do not overwrite it
|
||||||
|
if ('tickFormatter' in opts && typeof opts.tickFormatter === 'function') return;
|
||||||
|
|
||||||
|
axis.tickFormatter = function (v, axis) {
|
||||||
|
var d = dateGenerator(v, axis.options);
|
||||||
|
|
||||||
|
// first check global format
|
||||||
|
if (opts.timeformat != null) {
|
||||||
|
return formatDate(d, opts.timeformat, opts.monthNames, opts.dayNames);
|
||||||
|
}
|
||||||
|
|
||||||
|
// possibly use quarters if quarters are mentioned in
|
||||||
|
// any of these places
|
||||||
|
var useQuarters = (axis.options.tickSize &&
|
||||||
|
axis.options.tickSize[1] === "quarter") ||
|
||||||
|
(axis.options.minTickSize &&
|
||||||
|
axis.options.minTickSize[1] === "quarter");
|
||||||
|
|
||||||
|
var timeUnitSize;
|
||||||
|
if (opts.timeBase === 'seconds') {
|
||||||
|
timeUnitSize = timeUnitSizeSeconds;
|
||||||
|
} else if (opts.timeBase === 'microseconds') {
|
||||||
|
timeUnitSize = timeUnitSizeMicroseconds;
|
||||||
|
} else {
|
||||||
|
timeUnitSize = timeUnitSizeMilliseconds;
|
||||||
|
}
|
||||||
|
|
||||||
|
var t = axis.tickSize[0] * timeUnitSize[axis.tickSize[1]];
|
||||||
|
var span = axis.max - axis.min;
|
||||||
|
var suffix = (opts.twelveHourClock) ? " %p" : "";
|
||||||
|
var hourCode = (opts.twelveHourClock) ? "%I" : "%H";
|
||||||
|
var factor;
|
||||||
|
var fmt;
|
||||||
|
|
||||||
|
if (opts.timeBase === 'seconds') {
|
||||||
|
factor = 1;
|
||||||
|
} else if (opts.timeBase === 'microseconds') {
|
||||||
|
factor = 1000000
|
||||||
|
} else {
|
||||||
|
factor = 1000;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (t < timeUnitSize.second) {
|
||||||
|
var decimals = -Math.floor(Math.log10(t / factor))
|
||||||
|
|
||||||
|
// the two-and-halves require an additional decimal
|
||||||
|
if (String(t).indexOf('25') > -1) {
|
||||||
|
decimals++;
|
||||||
|
}
|
||||||
|
|
||||||
|
fmt = "%S.%" + decimals + "s";
|
||||||
|
} else
|
||||||
|
if (t < timeUnitSize.minute) {
|
||||||
|
fmt = hourCode + ":%M:%S" + suffix;
|
||||||
|
} else if (t < timeUnitSize.day) {
|
||||||
|
if (span < 2 * timeUnitSize.day) {
|
||||||
|
fmt = hourCode + ":%M" + suffix;
|
||||||
|
} else {
|
||||||
|
fmt = "%b %d " + hourCode + ":%M" + suffix;
|
||||||
|
}
|
||||||
|
} else if (t < timeUnitSize.month) {
|
||||||
|
fmt = "%b %d";
|
||||||
|
} else if ((useQuarters && t < timeUnitSize.quarter) ||
|
||||||
|
(!useQuarters && t < timeUnitSize.year)) {
|
||||||
|
if (span < timeUnitSize.year) {
|
||||||
|
fmt = "%b";
|
||||||
|
} else {
|
||||||
|
fmt = "%b %Y";
|
||||||
|
}
|
||||||
|
} else if (useQuarters && t < timeUnitSize.year) {
|
||||||
|
if (span < timeUnitSize.year) {
|
||||||
|
fmt = "Q%q";
|
||||||
|
} else {
|
||||||
|
fmt = "Q%q %Y";
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
fmt = "%Y";
|
||||||
|
}
|
||||||
|
|
||||||
|
var rt = formatDate(d, fmt, opts.monthNames, opts.dayNames);
|
||||||
|
|
||||||
|
return rt;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
});
|
||||||
|
});
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'time',
|
||||||
|
version: '1.0'
|
||||||
|
});
|
||||||
|
|
||||||
|
// Time-axis support used to be in Flot core, which exposed the
|
||||||
|
// formatDate function on the plot object. Various plugins depend
|
||||||
|
// on the function, so we need to re-expose it here.
|
||||||
|
|
||||||
|
$.plot.formatDate = formatDate;
|
||||||
|
$.plot.dateGenerator = dateGenerator;
|
||||||
|
$.plot.dateTickGenerator = dateTickGenerator;
|
||||||
|
$.plot.makeUtcWrapper = makeUtcWrapper;
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,320 @@
|
||||||
|
|
||||||
|
/* global jQuery */
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
propagateSupportedGesture: false
|
||||||
|
};
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processOptions.push(initTouchNavigation);
|
||||||
|
}
|
||||||
|
|
||||||
|
function initTouchNavigation(plot, options) {
|
||||||
|
var gestureState = {
|
||||||
|
twoTouches: false,
|
||||||
|
currentTapStart: { x: 0, y: 0 },
|
||||||
|
currentTapEnd: { x: 0, y: 0 },
|
||||||
|
prevTap: { x: 0, y: 0 },
|
||||||
|
currentTap: { x: 0, y: 0 },
|
||||||
|
interceptedLongTap: false,
|
||||||
|
isUnsupportedGesture: false,
|
||||||
|
prevTapTime: null,
|
||||||
|
tapStartTime: null,
|
||||||
|
longTapTriggerId: null
|
||||||
|
},
|
||||||
|
maxDistanceBetweenTaps = 20,
|
||||||
|
maxIntervalBetweenTaps = 500,
|
||||||
|
maxLongTapDistance = 20,
|
||||||
|
minLongTapDuration = 1500,
|
||||||
|
pressedTapDuration = 125,
|
||||||
|
mainEventHolder;
|
||||||
|
|
||||||
|
function interpretGestures(e) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
|
||||||
|
if (!o.pan.active && !o.zoom.active) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
updateOnMultipleTouches(e);
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('touchevent', { detail: e }));
|
||||||
|
|
||||||
|
if (isPinchEvent(e)) {
|
||||||
|
executeAction(e, 'pinch');
|
||||||
|
} else {
|
||||||
|
executeAction(e, 'pan');
|
||||||
|
if (!wasPinchEvent(e)) {
|
||||||
|
if (isDoubleTap(e)) {
|
||||||
|
executeAction(e, 'doubleTap');
|
||||||
|
}
|
||||||
|
executeAction(e, 'tap');
|
||||||
|
executeAction(e, 'longTap');
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function executeAction(e, gesture) {
|
||||||
|
switch (gesture) {
|
||||||
|
case 'pan':
|
||||||
|
pan[e.type](e);
|
||||||
|
break;
|
||||||
|
case 'pinch':
|
||||||
|
pinch[e.type](e);
|
||||||
|
break;
|
||||||
|
case 'doubleTap':
|
||||||
|
doubleTap.onDoubleTap(e);
|
||||||
|
break;
|
||||||
|
case 'longTap':
|
||||||
|
longTap[e.type](e);
|
||||||
|
break;
|
||||||
|
case 'tap':
|
||||||
|
tap[e.type](e);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function bindEvents(plot, eventHolder) {
|
||||||
|
mainEventHolder = eventHolder[0];
|
||||||
|
eventHolder[0].addEventListener('touchstart', interpretGestures, false);
|
||||||
|
eventHolder[0].addEventListener('touchmove', interpretGestures, false);
|
||||||
|
eventHolder[0].addEventListener('touchend', interpretGestures, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
function shutdown(plot, eventHolder) {
|
||||||
|
eventHolder[0].removeEventListener('touchstart', interpretGestures);
|
||||||
|
eventHolder[0].removeEventListener('touchmove', interpretGestures);
|
||||||
|
eventHolder[0].removeEventListener('touchend', interpretGestures);
|
||||||
|
if (gestureState.longTapTriggerId) {
|
||||||
|
clearTimeout(gestureState.longTapTriggerId);
|
||||||
|
gestureState.longTapTriggerId = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
var pan = {
|
||||||
|
touchstart: function(e) {
|
||||||
|
updatePrevForDoubleTap();
|
||||||
|
updateCurrentForDoubleTap(e);
|
||||||
|
updateStateForLongTapStart(e);
|
||||||
|
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('panstart', { detail: e }));
|
||||||
|
},
|
||||||
|
|
||||||
|
touchmove: function(e) {
|
||||||
|
preventEventBehaviors(e);
|
||||||
|
|
||||||
|
updateCurrentForDoubleTap(e);
|
||||||
|
updateStateForLongTapEnd(e);
|
||||||
|
|
||||||
|
if (!gestureState.isUnsupportedGesture) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('pandrag', { detail: e }));
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
touchend: function(e) {
|
||||||
|
preventEventBehaviors(e);
|
||||||
|
|
||||||
|
if (wasPinchEvent(e)) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('pinchend', { detail: e }));
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('panstart', { detail: e }));
|
||||||
|
} else if (noTouchActive(e)) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('panend', { detail: e }));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var pinch = {
|
||||||
|
touchstart: function(e) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('pinchstart', { detail: e }));
|
||||||
|
},
|
||||||
|
|
||||||
|
touchmove: function(e) {
|
||||||
|
preventEventBehaviors(e);
|
||||||
|
gestureState.twoTouches = isPinchEvent(e);
|
||||||
|
if (!gestureState.isUnsupportedGesture) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('pinchdrag', { detail: e }));
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
touchend: function(e) {
|
||||||
|
preventEventBehaviors(e);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var doubleTap = {
|
||||||
|
onDoubleTap: function(e) {
|
||||||
|
preventEventBehaviors(e);
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('doubletap', { detail: e }));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var longTap = {
|
||||||
|
touchstart: function(e) {
|
||||||
|
longTap.waitForLongTap(e);
|
||||||
|
},
|
||||||
|
|
||||||
|
touchmove: function(e) {
|
||||||
|
},
|
||||||
|
|
||||||
|
touchend: function(e) {
|
||||||
|
if (gestureState.longTapTriggerId) {
|
||||||
|
clearTimeout(gestureState.longTapTriggerId);
|
||||||
|
gestureState.longTapTriggerId = null;
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
isLongTap: function(e) {
|
||||||
|
var currentTime = new Date().getTime(),
|
||||||
|
tapDuration = currentTime - gestureState.tapStartTime;
|
||||||
|
if (tapDuration >= minLongTapDuration && !gestureState.interceptedLongTap) {
|
||||||
|
if (distance(gestureState.currentTapStart.x, gestureState.currentTapStart.y, gestureState.currentTapEnd.x, gestureState.currentTapEnd.y) < maxLongTapDistance) {
|
||||||
|
gestureState.interceptedLongTap = true;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
},
|
||||||
|
|
||||||
|
waitForLongTap: function(e) {
|
||||||
|
var longTapTrigger = function() {
|
||||||
|
if (longTap.isLongTap(e)) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('longtap', { detail: e }));
|
||||||
|
}
|
||||||
|
gestureState.longTapTriggerId = null;
|
||||||
|
};
|
||||||
|
if (!gestureState.longTapTriggerId) {
|
||||||
|
gestureState.longTapTriggerId = setTimeout(longTapTrigger, minLongTapDuration);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var tap = {
|
||||||
|
touchstart: function(e) {
|
||||||
|
gestureState.tapStartTime = new Date().getTime();
|
||||||
|
},
|
||||||
|
|
||||||
|
touchmove: function(e) {
|
||||||
|
},
|
||||||
|
|
||||||
|
touchend: function(e) {
|
||||||
|
if (tap.isTap(e)) {
|
||||||
|
mainEventHolder.dispatchEvent(new CustomEvent('tap', { detail: e }));
|
||||||
|
preventEventBehaviors(e);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
isTap: function(e) {
|
||||||
|
var currentTime = new Date().getTime(),
|
||||||
|
tapDuration = currentTime - gestureState.tapStartTime;
|
||||||
|
if (tapDuration <= pressedTapDuration) {
|
||||||
|
if (distance(gestureState.currentTapStart.x, gestureState.currentTapStart.y, gestureState.currentTapEnd.x, gestureState.currentTapEnd.y) < maxLongTapDistance) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
if (options.pan.enableTouch === true || options.zoom.enableTouch) {
|
||||||
|
plot.hooks.bindEvents.push(bindEvents);
|
||||||
|
plot.hooks.shutdown.push(shutdown);
|
||||||
|
};
|
||||||
|
|
||||||
|
function updatePrevForDoubleTap() {
|
||||||
|
gestureState.prevTap = {
|
||||||
|
x: gestureState.currentTap.x,
|
||||||
|
y: gestureState.currentTap.y
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
function updateCurrentForDoubleTap(e) {
|
||||||
|
gestureState.currentTap = {
|
||||||
|
x: e.touches[0].pageX,
|
||||||
|
y: e.touches[0].pageY
|
||||||
|
};
|
||||||
|
}
|
||||||
|
|
||||||
|
function updateStateForLongTapStart(e) {
|
||||||
|
gestureState.tapStartTime = new Date().getTime();
|
||||||
|
gestureState.interceptedLongTap = false;
|
||||||
|
gestureState.currentTapStart = {
|
||||||
|
x: e.touches[0].pageX,
|
||||||
|
y: e.touches[0].pageY
|
||||||
|
};
|
||||||
|
gestureState.currentTapEnd = {
|
||||||
|
x: e.touches[0].pageX,
|
||||||
|
y: e.touches[0].pageY
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
function updateStateForLongTapEnd(e) {
|
||||||
|
gestureState.currentTapEnd = {
|
||||||
|
x: e.touches[0].pageX,
|
||||||
|
y: e.touches[0].pageY
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
function isDoubleTap(e) {
|
||||||
|
var currentTime = new Date().getTime(),
|
||||||
|
intervalBetweenTaps = currentTime - gestureState.prevTapTime;
|
||||||
|
|
||||||
|
if (intervalBetweenTaps >= 0 && intervalBetweenTaps < maxIntervalBetweenTaps) {
|
||||||
|
if (distance(gestureState.prevTap.x, gestureState.prevTap.y, gestureState.currentTap.x, gestureState.currentTap.y) < maxDistanceBetweenTaps) {
|
||||||
|
e.firstTouch = gestureState.prevTap;
|
||||||
|
e.secondTouch = gestureState.currentTap;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
gestureState.prevTapTime = currentTime;
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
function preventEventBehaviors(e) {
|
||||||
|
if (!gestureState.isUnsupportedGesture) {
|
||||||
|
e.preventDefault();
|
||||||
|
if (!plot.getOptions().propagateSupportedGesture) {
|
||||||
|
e.stopPropagation();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function distance(x1, y1, x2, y2) {
|
||||||
|
return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
|
||||||
|
}
|
||||||
|
|
||||||
|
function noTouchActive(e) {
|
||||||
|
return (e.touches && e.touches.length === 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
function wasPinchEvent(e) {
|
||||||
|
return (gestureState.twoTouches && e.touches.length === 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
function updateOnMultipleTouches(e) {
|
||||||
|
if (e.touches.length >= 3) {
|
||||||
|
gestureState.isUnsupportedGesture = true;
|
||||||
|
} else {
|
||||||
|
gestureState.isUnsupportedGesture = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function isPinchEvent(e) {
|
||||||
|
if (e.touches && e.touches.length >= 2) {
|
||||||
|
if (e.touches[0].target === plot.getEventHolder() &&
|
||||||
|
e.touches[1].target === plot.getEventHolder()) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'navigateTouch',
|
||||||
|
version: '0.3'
|
||||||
|
});
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,360 @@
|
||||||
|
/* global jQuery */
|
||||||
|
|
||||||
|
(function($) {
|
||||||
|
'use strict';
|
||||||
|
|
||||||
|
var options = {
|
||||||
|
zoom: {
|
||||||
|
enableTouch: false
|
||||||
|
},
|
||||||
|
pan: {
|
||||||
|
enableTouch: false,
|
||||||
|
touchMode: 'manual'
|
||||||
|
},
|
||||||
|
recenter: {
|
||||||
|
enableTouch: true
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var ZOOM_DISTANCE_MARGIN = $.plot.uiConstants.ZOOM_DISTANCE_MARGIN;
|
||||||
|
|
||||||
|
function init(plot) {
|
||||||
|
plot.hooks.processOptions.push(initTouchNavigation);
|
||||||
|
}
|
||||||
|
|
||||||
|
function initTouchNavigation(plot, options) {
|
||||||
|
var gestureState = {
|
||||||
|
zoomEnable: false,
|
||||||
|
prevDistance: null,
|
||||||
|
prevTapTime: 0,
|
||||||
|
prevPanPosition: { x: 0, y: 0 },
|
||||||
|
prevTapPosition: { x: 0, y: 0 }
|
||||||
|
},
|
||||||
|
navigationState = {
|
||||||
|
prevTouchedAxis: 'none',
|
||||||
|
currentTouchedAxis: 'none',
|
||||||
|
touchedAxis: null,
|
||||||
|
navigationConstraint: 'unconstrained',
|
||||||
|
initialState: null
|
||||||
|
},
|
||||||
|
useManualPan = options.pan.interactive && options.pan.touchMode === 'manual',
|
||||||
|
smartPanLock = options.pan.touchMode === 'smartLock',
|
||||||
|
useSmartPan = options.pan.interactive && (smartPanLock || options.pan.touchMode === 'smart'),
|
||||||
|
pan, pinch, doubleTap;
|
||||||
|
|
||||||
|
function bindEvents(plot, eventHolder) {
|
||||||
|
var o = plot.getOptions();
|
||||||
|
|
||||||
|
if (o.zoom.interactive && o.zoom.enableTouch) {
|
||||||
|
eventHolder[0].addEventListener('pinchstart', pinch.start, false);
|
||||||
|
eventHolder[0].addEventListener('pinchdrag', pinch.drag, false);
|
||||||
|
eventHolder[0].addEventListener('pinchend', pinch.end, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (o.pan.interactive && o.pan.enableTouch) {
|
||||||
|
eventHolder[0].addEventListener('panstart', pan.start, false);
|
||||||
|
eventHolder[0].addEventListener('pandrag', pan.drag, false);
|
||||||
|
eventHolder[0].addEventListener('panend', pan.end, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
if ((o.recenter.interactive && o.recenter.enableTouch)) {
|
||||||
|
eventHolder[0].addEventListener('doubletap', doubleTap.recenterPlot, false);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function shutdown(plot, eventHolder) {
|
||||||
|
eventHolder[0].removeEventListener('panstart', pan.start);
|
||||||
|
eventHolder[0].removeEventListener('pandrag', pan.drag);
|
||||||
|
eventHolder[0].removeEventListener('panend', pan.end);
|
||||||
|
eventHolder[0].removeEventListener('pinchstart', pinch.start);
|
||||||
|
eventHolder[0].removeEventListener('pinchdrag', pinch.drag);
|
||||||
|
eventHolder[0].removeEventListener('pinchend', pinch.end);
|
||||||
|
eventHolder[0].removeEventListener('doubletap', doubleTap.recenterPlot);
|
||||||
|
}
|
||||||
|
|
||||||
|
pan = {
|
||||||
|
start: function(e) {
|
||||||
|
presetNavigationState(e, 'pan', gestureState);
|
||||||
|
updateData(e, 'pan', gestureState, navigationState);
|
||||||
|
|
||||||
|
if (useSmartPan) {
|
||||||
|
var point = getPoint(e, 'pan');
|
||||||
|
navigationState.initialState = plot.navigationState(point.x, point.y);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
drag: function(e) {
|
||||||
|
presetNavigationState(e, 'pan', gestureState);
|
||||||
|
|
||||||
|
if (useSmartPan) {
|
||||||
|
var point = getPoint(e, 'pan');
|
||||||
|
plot.smartPan({
|
||||||
|
x: navigationState.initialState.startPageX - point.x,
|
||||||
|
y: navigationState.initialState.startPageY - point.y
|
||||||
|
}, navigationState.initialState, navigationState.touchedAxis, false, smartPanLock);
|
||||||
|
} else if (useManualPan) {
|
||||||
|
plot.pan({
|
||||||
|
left: -delta(e, 'pan', gestureState).x,
|
||||||
|
top: -delta(e, 'pan', gestureState).y,
|
||||||
|
axes: navigationState.touchedAxis
|
||||||
|
});
|
||||||
|
updatePrevPanPosition(e, 'pan', gestureState, navigationState);
|
||||||
|
}
|
||||||
|
},
|
||||||
|
|
||||||
|
end: function(e) {
|
||||||
|
presetNavigationState(e, 'pan', gestureState);
|
||||||
|
|
||||||
|
if (useSmartPan) {
|
||||||
|
plot.smartPan.end();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (wasPinchEvent(e, gestureState)) {
|
||||||
|
updateprevPanPosition(e, 'pan', gestureState, navigationState);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
var pinchDragTimeout;
|
||||||
|
pinch = {
|
||||||
|
start: function(e) {
|
||||||
|
if (pinchDragTimeout) {
|
||||||
|
clearTimeout(pinchDragTimeout);
|
||||||
|
pinchDragTimeout = null;
|
||||||
|
}
|
||||||
|
presetNavigationState(e, 'pinch', gestureState);
|
||||||
|
setPrevDistance(e, gestureState);
|
||||||
|
updateData(e, 'pinch', gestureState, navigationState);
|
||||||
|
},
|
||||||
|
|
||||||
|
drag: function(e) {
|
||||||
|
if (pinchDragTimeout) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
pinchDragTimeout = setTimeout(function() {
|
||||||
|
presetNavigationState(e, 'pinch', gestureState);
|
||||||
|
plot.pan({
|
||||||
|
left: -delta(e, 'pinch', gestureState).x,
|
||||||
|
top: -delta(e, 'pinch', gestureState).y,
|
||||||
|
axes: navigationState.touchedAxis
|
||||||
|
});
|
||||||
|
updatePrevPanPosition(e, 'pinch', gestureState, navigationState);
|
||||||
|
|
||||||
|
var dist = pinchDistance(e);
|
||||||
|
|
||||||
|
if (gestureState.zoomEnable || Math.abs(dist - gestureState.prevDistance) > ZOOM_DISTANCE_MARGIN) {
|
||||||
|
zoomPlot(plot, e, gestureState, navigationState);
|
||||||
|
|
||||||
|
//activate zoom mode
|
||||||
|
gestureState.zoomEnable = true;
|
||||||
|
}
|
||||||
|
pinchDragTimeout = null;
|
||||||
|
}, 1000 / 60);
|
||||||
|
},
|
||||||
|
|
||||||
|
end: function(e) {
|
||||||
|
if (pinchDragTimeout) {
|
||||||
|
clearTimeout(pinchDragTimeout);
|
||||||
|
pinchDragTimeout = null;
|
||||||
|
}
|
||||||
|
presetNavigationState(e, 'pinch', gestureState);
|
||||||
|
gestureState.prevDistance = null;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
doubleTap = {
|
||||||
|
recenterPlot: function(e) {
|
||||||
|
if (e && e.detail && e.detail.type === 'touchstart') {
|
||||||
|
// only do not recenter for touch start;
|
||||||
|
recenterPlotOnDoubleTap(plot, e, gestureState, navigationState);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
if (options.pan.enableTouch === true || options.zoom.enableTouch === true) {
|
||||||
|
plot.hooks.bindEvents.push(bindEvents);
|
||||||
|
plot.hooks.shutdown.push(shutdown);
|
||||||
|
}
|
||||||
|
|
||||||
|
function presetNavigationState(e, gesture, gestureState) {
|
||||||
|
navigationState.touchedAxis = getAxis(plot, e, gesture, navigationState);
|
||||||
|
if (noAxisTouched(navigationState)) {
|
||||||
|
navigationState.navigationConstraint = 'unconstrained';
|
||||||
|
} else {
|
||||||
|
navigationState.navigationConstraint = 'axisConstrained';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
$.plot.plugins.push({
|
||||||
|
init: init,
|
||||||
|
options: options,
|
||||||
|
name: 'navigateTouch',
|
||||||
|
version: '0.3'
|
||||||
|
});
|
||||||
|
|
||||||
|
function recenterPlotOnDoubleTap(plot, e, gestureState, navigationState) {
|
||||||
|
checkAxesForDoubleTap(plot, e, navigationState);
|
||||||
|
if ((navigationState.currentTouchedAxis === 'x' && navigationState.prevTouchedAxis === 'x') ||
|
||||||
|
(navigationState.currentTouchedAxis === 'y' && navigationState.prevTouchedAxis === 'y') ||
|
||||||
|
(navigationState.currentTouchedAxis === 'none' && navigationState.prevTouchedAxis === 'none')) {
|
||||||
|
var event;
|
||||||
|
|
||||||
|
plot.recenter({ axes: navigationState.touchedAxis });
|
||||||
|
|
||||||
|
if (navigationState.touchedAxis) {
|
||||||
|
event = new $.Event('re-center', { detail: { axisTouched: navigationState.touchedAxis } });
|
||||||
|
} else {
|
||||||
|
event = new $.Event('re-center', { detail: e });
|
||||||
|
}
|
||||||
|
plot.getPlaceholder().trigger(event);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function checkAxesForDoubleTap(plot, e, navigationState) {
|
||||||
|
var axis = plot.getTouchedAxis(e.detail.firstTouch.x, e.detail.firstTouch.y);
|
||||||
|
if (axis[0] !== undefined) {
|
||||||
|
navigationState.prevTouchedAxis = axis[0].direction;
|
||||||
|
}
|
||||||
|
|
||||||
|
axis = plot.getTouchedAxis(e.detail.secondTouch.x, e.detail.secondTouch.y);
|
||||||
|
if (axis[0] !== undefined) {
|
||||||
|
navigationState.touchedAxis = axis;
|
||||||
|
navigationState.currentTouchedAxis = axis[0].direction;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (noAxisTouched(navigationState)) {
|
||||||
|
navigationState.touchedAxis = null;
|
||||||
|
navigationState.prevTouchedAxis = 'none';
|
||||||
|
navigationState.currentTouchedAxis = 'none';
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function zoomPlot(plot, e, gestureState, navigationState) {
|
||||||
|
var offset = plot.offset(),
|
||||||
|
center = {
|
||||||
|
left: 0,
|
||||||
|
top: 0
|
||||||
|
},
|
||||||
|
zoomAmount = pinchDistance(e) / gestureState.prevDistance,
|
||||||
|
dist = pinchDistance(e);
|
||||||
|
|
||||||
|
center.left = getPoint(e, 'pinch').x - offset.left;
|
||||||
|
center.top = getPoint(e, 'pinch').y - offset.top;
|
||||||
|
|
||||||
|
// send the computed touched axis to the zoom function so that it only zooms on that one
|
||||||
|
plot.zoom({
|
||||||
|
center: center,
|
||||||
|
amount: zoomAmount,
|
||||||
|
axes: navigationState.touchedAxis
|
||||||
|
});
|
||||||
|
gestureState.prevDistance = dist;
|
||||||
|
}
|
||||||
|
|
||||||
|
function wasPinchEvent(e, gestureState) {
|
||||||
|
return (gestureState.zoomEnable && e.detail.touches.length === 1);
|
||||||
|
}
|
||||||
|
|
||||||
|
function getAxis(plot, e, gesture, navigationState) {
|
||||||
|
if (e.type === 'pinchstart') {
|
||||||
|
var axisTouch1 = plot.getTouchedAxis(e.detail.touches[0].pageX, e.detail.touches[0].pageY);
|
||||||
|
var axisTouch2 = plot.getTouchedAxis(e.detail.touches[1].pageX, e.detail.touches[1].pageY);
|
||||||
|
|
||||||
|
if (axisTouch1.length === axisTouch2.length && axisTouch1.toString() === axisTouch2.toString()) {
|
||||||
|
return axisTouch1;
|
||||||
|
}
|
||||||
|
} else if (e.type === 'panstart') {
|
||||||
|
return plot.getTouchedAxis(e.detail.touches[0].pageX, e.detail.touches[0].pageY);
|
||||||
|
} else if (e.type === 'pinchend') {
|
||||||
|
//update axis since instead on pinch, a pan event is made
|
||||||
|
return plot.getTouchedAxis(e.detail.touches[0].pageX, e.detail.touches[0].pageY);
|
||||||
|
} else {
|
||||||
|
return navigationState.touchedAxis;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function noAxisTouched(navigationState) {
|
||||||
|
return (!navigationState.touchedAxis || navigationState.touchedAxis.length === 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
function setPrevDistance(e, gestureState) {
|
||||||
|
gestureState.prevDistance = pinchDistance(e);
|
||||||
|
}
|
||||||
|
|
||||||
|
function updateData(e, gesture, gestureState, navigationState) {
|
||||||
|
var axisDir,
|
||||||
|
point = getPoint(e, gesture);
|
||||||
|
|
||||||
|
switch (navigationState.navigationConstraint) {
|
||||||
|
case 'unconstrained':
|
||||||
|
navigationState.touchedAxis = null;
|
||||||
|
gestureState.prevTapPosition = {
|
||||||
|
x: gestureState.prevPanPosition.x,
|
||||||
|
y: gestureState.prevPanPosition.y
|
||||||
|
};
|
||||||
|
gestureState.prevPanPosition = {
|
||||||
|
x: point.x,
|
||||||
|
y: point.y
|
||||||
|
};
|
||||||
|
break;
|
||||||
|
case 'axisConstrained':
|
||||||
|
axisDir = navigationState.touchedAxis[0].direction;
|
||||||
|
navigationState.currentTouchedAxis = axisDir;
|
||||||
|
gestureState.prevTapPosition[axisDir] = gestureState.prevPanPosition[axisDir];
|
||||||
|
gestureState.prevPanPosition[axisDir] = point[axisDir];
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function distance(x1, y1, x2, y2) {
|
||||||
|
return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
|
||||||
|
}
|
||||||
|
|
||||||
|
function pinchDistance(e) {
|
||||||
|
var t1 = e.detail.touches[0],
|
||||||
|
t2 = e.detail.touches[1];
|
||||||
|
return distance(t1.pageX, t1.pageY, t2.pageX, t2.pageY);
|
||||||
|
}
|
||||||
|
|
||||||
|
function updatePrevPanPosition(e, gesture, gestureState, navigationState) {
|
||||||
|
var point = getPoint(e, gesture);
|
||||||
|
|
||||||
|
switch (navigationState.navigationConstraint) {
|
||||||
|
case 'unconstrained':
|
||||||
|
gestureState.prevPanPosition.x = point.x;
|
||||||
|
gestureState.prevPanPosition.y = point.y;
|
||||||
|
break;
|
||||||
|
case 'axisConstrained':
|
||||||
|
gestureState.prevPanPosition[navigationState.currentTouchedAxis] =
|
||||||
|
point[navigationState.currentTouchedAxis];
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function delta(e, gesture, gestureState) {
|
||||||
|
var point = getPoint(e, gesture);
|
||||||
|
|
||||||
|
return {
|
||||||
|
x: point.x - gestureState.prevPanPosition.x,
|
||||||
|
y: point.y - gestureState.prevPanPosition.y
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
function getPoint(e, gesture) {
|
||||||
|
if (gesture === 'pinch') {
|
||||||
|
return {
|
||||||
|
x: (e.detail.touches[0].pageX + e.detail.touches[1].pageX) / 2,
|
||||||
|
y: (e.detail.touches[0].pageY + e.detail.touches[1].pageY) / 2
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
return {
|
||||||
|
x: e.detail.touches[0].pageX,
|
||||||
|
y: e.detail.touches[0].pageY
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
})(jQuery);
|
|
@ -0,0 +1,10 @@
|
||||||
|
(function ($) {
|
||||||
|
'use strict';
|
||||||
|
$.plot.uiConstants = {
|
||||||
|
SNAPPING_CONSTANT: 20,
|
||||||
|
PANHINT_LENGTH_CONSTANT: 10,
|
||||||
|
MINOR_TICKS_COUNT_CONSTANT: 4,
|
||||||
|
TICK_LENGTH_CONSTANT: 10,
|
||||||
|
ZOOM_DISTANCE_MARGIN: 25
|
||||||
|
};
|
||||||
|
})(jQuery);
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because one or more lines are too long
Loading…
Reference in New Issue