")[0], Yb = va.textContent !== l, Zb = /<.*?>/g;
+ p = function (a) {
+ this.$ = function (a, b) {
+ return this.api(!0).$(a, b)
+ };
+ this._ = function (a, b) {
+ return this.api(!0).rows(a, b).data()
+ };
+ this.api = function (a) {
+ return a ? new q(ya(this[w.iApiIndex])) : new q(this)
+ };
+ this.fnAddData = function (a, b) {
+ var c = this.api(!0), e = g.isArray(a) && (g.isArray(a[0]) || g.isPlainObject(a[0])) ?
+ c.rows.add(a) : c.row.add(a);
+ (b === l || b) && c.draw();
+ return e.flatten().toArray()
+ };
+ this.fnAdjustColumnSizing = function (a) {
+ var b = this.api(!0).columns.adjust(), c = b.settings()[0], e = c.oScroll;
+ a === l || a ? b.draw(!1) : ("" !== e.sX || "" !== e.sY) && Y(c)
+ };
+ this.fnClearTable = function (a) {
+ var b = this.api(!0).clear();
+ (a === l || a) && b.draw()
+ };
+ this.fnClose = function (a) {
+ this.api(!0).row(a).child.hide()
+ };
+ this.fnDeleteRow = function (a, b, c) {
+ var e = this.api(!0), a = e.rows(a), d = a.settings()[0], g = d.aoData[a[0][0]];
+ a.remove();
+ b && b.call(this, d, g);
+ (c === l || c) && e.draw();
+ return g
+ };
+ this.fnDestroy = function (a) {
+ this.api(!0).destroy(a)
+ };
+ this.fnDraw = function (a) {
+ this.api(!0).draw(!a)
+ };
+ this.fnFilter = function (a, b, c, e, d, g) {
+ d = this.api(!0);
+ null === b || b === l ? d.search(a, c, e, g) : d.column(b).search(a, c, e, g);
+ d.draw()
+ };
+ this.fnGetData = function (a, b) {
+ var c = this.api(!0);
+ if (a !== l) {
+ var e = a.nodeName ? a.nodeName.toLowerCase() : "";
+ return b !== l || "td" == e || "th" == e ? c.cell(a, b).data() : c.row(a).data() || null
+ }
+ return c.data().toArray()
+ };
+ this.fnGetNodes = function (a) {
+ var b = this.api(!0);
+ return a !== l ? b.row(a).node() : b.rows().nodes().flatten().toArray()
+ };
+ this.fnGetPosition = function (a) {
+ var b = this.api(!0), c = a.nodeName.toUpperCase();
+ return"TR" == c ? b.row(a).index() : "TD" == c || "TH" == c ? (a = b.cell(a).index(), [a.row, a.columnVisible, a.column]) : null
+ };
+ this.fnIsOpen = function (a) {
+ return this.api(!0).row(a).child.isShown()
+ };
+ this.fnOpen = function (a, b, c) {
+ return this.api(!0).row(a).child(b, c).show().child()[0]
+ };
+ this.fnPageChange = function (a, b) {
+ var c = this.api(!0).page(a);
+ (b === l || b) && c.draw(!1)
+ };
+ this.fnSetColumnVis =
+ function (a, b, c) {
+ a = this.api(!0).column(a).visible(b);
+ (c === l || c) && a.columns.adjust().draw()
+ };
+ this.fnSettings = function () {
+ return ya(this[w.iApiIndex])
+ };
+ this.fnSort = function (a) {
+ this.api(!0).order(a).draw()
+ };
+ this.fnSortListener = function (a, b, c) {
+ this.api(!0).order.listener(a, b, c)
+ };
+ this.fnUpdate = function (a, b, c, e, d) {
+ var g = this.api(!0);
+ c === l || null === c ? g.row(b).data(a) : g.cell(b, c).data(a);
+ (d === l || d) && g.columns.adjust();
+ (e === l || e) && g.draw();
+ return 0
+ };
+ this.fnVersionCheck = w.fnVersionCheck;
+ var b = this, c = a === l, e = this.length;
+ c && (a = {});
+ this.oApi = this.internal = w.internal;
+ for (var d in p.ext.internal)d && (this[d] = Mb(d));
+ this.each(function () {
+ var d = {}, d = 1 < e ? Kb(d, a, !0) : a, h = 0, i, j = this.getAttribute("id"), n = !1, m = p.defaults;
+ if ("table" != this.nodeName.toLowerCase())R(null, 0, "Non-table node initialisation (" + this.nodeName + ")", 2); else {
+ db(m);
+ eb(m.column);
+ G(m, m, !0);
+ G(m.column, m.column, !0);
+ G(m, d);
+ var o = p.settings, h = 0;
+ for (i = o.length; h < i; h++) {
+ if (o[h].nTable == this) {
+ i = d.bRetrieve !== l ? d.bRetrieve : m.bRetrieve;
+ if (c || i)return o[h].oInstance;
+ if (d.bDestroy !==
+ l ? d.bDestroy : m.bDestroy) {
+ o[h].oInstance.fnDestroy();
+ break
+ } else {
+ R(o[h], 0, "Cannot reinitialise DataTable", 3);
+ return
+ }
+ }
+ if (o[h].sTableId == this.id) {
+ o.splice(h, 1);
+ break
+ }
+ }
+ if (null === j || "" === j)this.id = j = "DataTables_Table_" + p.ext._unique++;
+ var k = g.extend(!0, {}, p.models.oSettings, {nTable: this, oApi: b.internal, oInit: d, sDestroyWidth: g(this)[0].style.width, sInstance: j, sTableId: j});
+ o.push(k);
+ k.oInstance = 1 === b.length ? b : g(this).dataTable();
+ db(d);
+ d.oLanguage && O(d.oLanguage);
+ d.aLengthMenu && !d.iDisplayLength && (d.iDisplayLength =
+ g.isArray(d.aLengthMenu[0]) ? d.aLengthMenu[0][0] : d.aLengthMenu[0]);
+ d = Kb(g.extend(!0, {}, m), d);
+ D(k.oFeatures, d, "bPaginate bLengthChange bFilter bSort bSortMulti bInfo bProcessing bAutoWidth bSortClasses bServerSide bDeferRender".split(" "));
+ D(k, d, ["asStripeClasses", "ajax", "fnServerData", "fnFormatNumber", "sServerMethod", "aaSorting", "aaSortingFixed", "aLengthMenu", "sPaginationType", "sAjaxSource", "sAjaxDataProp", "iStateDuration", "sDom", "bSortCellsTop", "iTabIndex", "fnStateLoadCallback", "fnStateSaveCallback",
+ "renderer", "searchDelay", ["iCookieDuration", "iStateDuration"], ["oSearch", "oPreviousSearch"], ["aoSearchCols", "aoPreSearchCols"], ["iDisplayLength", "_iDisplayLength"], ["bJQueryUI", "bJUI"]]);
+ D(k.oScroll, d, [
+ ["sScrollX", "sX"],
+ ["sScrollXInner", "sXInner"],
+ ["sScrollY", "sY"],
+ ["bScrollCollapse", "bCollapse"]
+ ]);
+ D(k.oLanguage, d, "fnInfoCallback");
+ x(k, "aoDrawCallback", d.fnDrawCallback, "user");
+ x(k, "aoServerParams", d.fnServerParams, "user");
+ x(k, "aoStateSaveParams", d.fnStateSaveParams, "user");
+ x(k, "aoStateLoadParams",
+ d.fnStateLoadParams, "user");
+ x(k, "aoStateLoaded", d.fnStateLoaded, "user");
+ x(k, "aoRowCallback", d.fnRowCallback, "user");
+ x(k, "aoRowCreatedCallback", d.fnCreatedRow, "user");
+ x(k, "aoHeaderCallback", d.fnHeaderCallback, "user");
+ x(k, "aoFooterCallback", d.fnFooterCallback, "user");
+ x(k, "aoInitComplete", d.fnInitComplete, "user");
+ x(k, "aoPreDrawCallback", d.fnPreDrawCallback, "user");
+ j = k.oClasses;
+ d.bJQueryUI ? (g.extend(j, p.ext.oJUIClasses, d.oClasses), d.sDom === m.sDom && "lfrtip" === m.sDom && (k.sDom = '<"H"lfr>t<"F"ip>'), k.renderer) ?
+ g.isPlainObject(k.renderer) && !k.renderer.header && (k.renderer.header = "jqueryui") : k.renderer = "jqueryui" : g.extend(j, p.ext.classes, d.oClasses);
+ g(this).addClass(j.sTable);
+ if ("" !== k.oScroll.sX || "" !== k.oScroll.sY)k.oScroll.iBarWidth = Gb();
+ !0 === k.oScroll.sX && (k.oScroll.sX = "100%");
+ k.iInitDisplayStart === l && (k.iInitDisplayStart = d.iDisplayStart, k._iDisplayStart = d.iDisplayStart);
+ null !== d.iDeferLoading && (k.bDeferLoading = !0, h = g.isArray(d.iDeferLoading), k._iRecordsDisplay = h ? d.iDeferLoading[0] : d.iDeferLoading, k._iRecordsTotal =
+ h ? d.iDeferLoading[1] : d.iDeferLoading);
+ var r = k.oLanguage;
+ g.extend(!0, r, d.oLanguage);
+ "" !== r.sUrl && (g.ajax({dataType: "json", url: r.sUrl, success: function (a) {
+ O(a);
+ G(m.oLanguage, a);
+ g.extend(true, r, a);
+ ga(k)
+ }, error: function () {
+ ga(k)
+ }}), n = !0);
+ null === d.asStripeClasses && (k.asStripeClasses = [j.sStripeOdd, j.sStripeEven]);
+ var h = k.asStripeClasses, q = g("tbody tr:eq(0)", this);
+ -1 !== g.inArray(!0, g.map(h, function (a) {
+ return q.hasClass(a)
+ })) && (g("tbody tr", this).removeClass(h.join(" ")), k.asDestroyStripes = h.slice());
+ var o =
+ [], s, h = this.getElementsByTagName("thead");
+ 0 !== h.length && (da(k.aoHeader, h[0]), o = pa(k));
+ if (null === d.aoColumns) {
+ s = [];
+ h = 0;
+ for (i = o.length; h < i; h++)s.push(null)
+ } else s = d.aoColumns;
+ h = 0;
+ for (i = s.length; h < i; h++)Ea(k, o ? o[h] : null);
+ hb(k, d.aoColumnDefs, s, function (a, b) {
+ ja(k, a, b)
+ });
+ if (q.length) {
+ var t = function (a, b) {
+ return a.getAttribute("data-" + b) ? b : null
+ };
+ g.each(ma(k, q[0]).cells, function (a, b) {
+ var c = k.aoColumns[a];
+ if (c.mData === a) {
+ var e = t(b, "sort") || t(b, "order"), d = t(b, "filter") || t(b, "search");
+ if (e !== null || d !== null) {
+ c.mData =
+ {_: a + ".display", sort: e !== null ? a + ".@data-" + e : l, type: e !== null ? a + ".@data-" + e : l, filter: d !== null ? a + ".@data-" + d : l};
+ ja(k, a)
+ }
+ }
+ })
+ }
+ var v = k.oFeatures;
+ d.bStateSave && (v.bStateSave = !0, Jb(k, d), x(k, "aoDrawCallback", xa, "state_save"));
+ if (d.aaSorting === l) {
+ o = k.aaSorting;
+ h = 0;
+ for (i = o.length; h < i; h++)o[h][1] = k.aoColumns[h].asSorting[0]
+ }
+ wa(k);
+ v.bSort && x(k, "aoDrawCallback", function () {
+ if (k.bSorted) {
+ var a = T(k), b = {};
+ g.each(a, function (a, c) {
+ b[c.src] = c.dir
+ });
+ u(k, null, "order", [k, a, b]);
+ Ib(k)
+ }
+ });
+ x(k, "aoDrawCallback", function () {
+ (k.bSorted ||
+ A(k) === "ssp" || v.bDeferRender) && wa(k)
+ }, "sc");
+ fb(k);
+ h = g(this).children("caption").each(function () {
+ this._captionSide = g(this).css("caption-side")
+ });
+ i = g(this).children("thead");
+ 0 === i.length && (i = g("
").appendTo(this));
+ k.nTHead = i[0];
+ i = g(this).children("tbody");
+ 0 === i.length && (i = g("
").appendTo(this));
+ k.nTBody = i[0];
+ i = g(this).children("tfoot");
+ if (0 === i.length && 0 < h.length && ("" !== k.oScroll.sX || "" !== k.oScroll.sY))i = g("
").appendTo(this);
+ 0 === i.length || 0 === i.children().length ? g(this).addClass(j.sNoFooter) :
+ 0 < i.length && (k.nTFoot = i[0], da(k.aoFooter, k.nTFoot));
+ if (d.aaData)for (h = 0; h < d.aaData.length; h++)I(k, d.aaData[h]); else(k.bDeferLoading || "dom" == A(k)) && la(k, g(k.nTBody).children("tr"));
+ k.aiDisplay = k.aiDisplayMaster.slice();
+ k.bInitialised = !0;
+ !1 === n && ga(k)
+ }
+ });
+ b = null;
+ return this
+ };
+ var Sb = [], y = Array.prototype, bc = function (a) {
+ var b, c, e = p.settings, d = g.map(e, function (a) {
+ return a.nTable
+ });
+ if (a) {
+ if (a.nTable && a.oApi)return[a];
+ if (a.nodeName && "table" === a.nodeName.toLowerCase())return b = g.inArray(a, d), -1 !== b ? [e[b]] :
+ null;
+ if (a && "function" === typeof a.settings)return a.settings().toArray();
+ "string" === typeof a ? c = g(a) : a instanceof g && (c = a)
+ } else return[];
+ if (c)return c.map(function () {
+ b = g.inArray(this, d);
+ return-1 !== b ? e[b] : null
+ }).toArray()
+ };
+ q = function (a, b) {
+ if (!this instanceof q)throw"DT API must be constructed as a new object";
+ var c = [], e = function (a) {
+ (a = bc(a)) && c.push.apply(c, a)
+ };
+ if (g.isArray(a))for (var d = 0, f = a.length; d < f; d++)e(a[d]); else e(a);
+ this.context = Ma(c);
+ b && this.push.apply(this, b.toArray ? b.toArray() : b);
+ this.selector =
+ {rows: null, cols: null, opts: null};
+ q.extend(this, this, Sb)
+ };
+ p.Api = q;
+ q.prototype = {concat: y.concat, context: [], each: function (a) {
+ for (var b = 0, c = this.length; b < c; b++)a.call(this, this[b], b, this);
+ return this
+ }, eq: function (a) {
+ var b = this.context;
+ return b.length > a ? new q(b[a], this[a]) : null
+ }, filter: function (a) {
+ var b = [];
+ if (y.filter)b = y.filter.call(this, a, this); else for (var c = 0, e = this.length; c < e; c++)a.call(this, this[c], c, this) && b.push(this[c]);
+ return new q(this.context, b)
+ }, flatten: function () {
+ var a = [];
+ return new q(this.context,
+ a.concat.apply(a, this.toArray()))
+ }, join: y.join, indexOf: y.indexOf || function (a, b) {
+ for (var c = b || 0, e = this.length; c < e; c++)if (this[c] === a)return c;
+ return-1
+ }, iterator: function (a, b, c, e) {
+ var d = [], f, h, g, j, n, m = this.context, o, k, p = this.selector;
+ "string" === typeof a && (e = c, c = b, b = a, a = !1);
+ h = 0;
+ for (g = m.length; h < g; h++) {
+ var r = new q(m[h]);
+ if ("table" === b)f = c.call(r, m[h], h), f !== l && d.push(f); else if ("columns" === b || "rows" === b)f = c.call(r, m[h], this[h], h), f !== l && d.push(f); else if ("column" === b || "column-rows" === b || "row" === b || "cell" ===
+ b) {
+ k = this[h];
+ "column-rows" === b && (o = Ba(m[h], p.opts));
+ j = 0;
+ for (n = k.length; j < n; j++)f = k[j], f = "cell" === b ? c.call(r, m[h], f.row, f.column, h, j) : c.call(r, m[h], f, h, j, o), f !== l && d.push(f)
+ }
+ }
+ return d.length || e ? (a = new q(m, a ? d.concat.apply([], d) : d), b = a.selector, b.rows = p.rows, b.cols = p.cols, b.opts = p.opts, a) : this
+ }, lastIndexOf: y.lastIndexOf || function (a, b) {
+ return this.indexOf.apply(this.toArray.reverse(), arguments)
+ }, length: 0, map: function (a) {
+ var b = [];
+ if (y.map)b = y.map.call(this, a, this); else for (var c = 0, e = this.length; c < e; c++)b.push(a.call(this,
+ this[c], c));
+ return new q(this.context, b)
+ }, pluck: function (a) {
+ return this.map(function (b) {
+ return b[a]
+ })
+ }, pop: y.pop, push: y.push, reduce: y.reduce || function (a, b) {
+ return gb(this, a, b, 0, this.length, 1)
+ }, reduceRight: y.reduceRight || function (a, b) {
+ return gb(this, a, b, this.length - 1, -1, -1)
+ }, reverse: y.reverse, selector: null, shift: y.shift, sort: y.sort, splice: y.splice, toArray: function () {
+ return y.slice.call(this)
+ }, to$: function () {
+ return g(this)
+ }, toJQuery: function () {
+ return g(this)
+ }, unique: function () {
+ return new q(this.context,
+ Ma(this))
+ }, unshift: y.unshift};
+ q.extend = function (a, b, c) {
+ if (b && (b instanceof q || b.__dt_wrapper)) {
+ var e, d, f, h = function (a, b, c) {
+ return function () {
+ var e = b.apply(a, arguments);
+ q.extend(e, e, c.methodExt);
+ return e
+ }
+ };
+ e = 0;
+ for (d = c.length; e < d; e++)f = c[e], b[f.name] = "function" === typeof f.val ? h(a, f.val, f) : g.isPlainObject(f.val) ? {} : f.val, b[f.name].__dt_wrapper = !0, q.extend(a, b[f.name], f.propExt)
+ }
+ };
+ q.register = r = function (a, b) {
+ if (g.isArray(a))for (var c = 0, e = a.length; c < e; c++)q.register(a[c], b); else for (var d = a.split("."),
+ f = Sb, h, i, c = 0, e = d.length; c < e; c++) {
+ h = (i = -1 !== d[c].indexOf("()")) ? d[c].replace("()", "") : d[c];
+ var j;
+ a:{
+ j = 0;
+ for (var n = f.length; j < n; j++)if (f[j].name === h) {
+ j = f[j];
+ break a
+ }
+ j = null
+ }
+ j || (j = {name: h, val: {}, methodExt: [], propExt: []}, f.push(j));
+ c === e - 1 ? j.val = b : f = i ? j.methodExt : j.propExt
+ }
+ };
+ q.registerPlural = t = function (a, b, c) {
+ q.register(a, c);
+ q.register(b, function () {
+ var a = c.apply(this, arguments);
+ return a === this ? this : a instanceof q ? a.length ? g.isArray(a[0]) ? new q(a.context, a[0]) : a[0] : l : a
+ })
+ };
+ r("tables()", function (a) {
+ var b;
+ if (a) {
+ b = q;
+ var c = this.context;
+ if ("number" === typeof a)a = [c[a]]; else var e = g.map(c, function (a) {
+ return a.nTable
+ }), a = g(e).filter(a).map(function () {
+ var a = g.inArray(this, e);
+ return c[a]
+ }).toArray();
+ b = new b(a)
+ } else b = this;
+ return b
+ });
+ r("table()", function (a) {
+ var a = this.tables(a), b = a.context;
+ return b.length ? new q(b[0]) : a
+ });
+ t("tables().nodes()", "table().node()", function () {
+ return this.iterator("table", function (a) {
+ return a.nTable
+ }, 1)
+ });
+ t("tables().body()", "table().body()", function () {
+ return this.iterator("table",
+ function (a) {
+ return a.nTBody
+ }, 1)
+ });
+ t("tables().header()", "table().header()", function () {
+ return this.iterator("table", function (a) {
+ return a.nTHead
+ }, 1)
+ });
+ t("tables().footer()", "table().footer()", function () {
+ return this.iterator("table", function (a) {
+ return a.nTFoot
+ }, 1)
+ });
+ t("tables().containers()", "table().container()", function () {
+ return this.iterator("table", function (a) {
+ return a.nTableWrapper
+ }, 1)
+ });
+ r("draw()", function (a) {
+ return this.iterator("table", function (b) {
+ M(b, !1 === a)
+ })
+ });
+ r("page()", function (a) {
+ return a ===
+ l ? this.page.info().page : this.iterator("table", function (b) {
+ Sa(b, a)
+ })
+ });
+ r("page.info()", function () {
+ if (0 === this.context.length)return l;
+ var a = this.context[0], b = a._iDisplayStart, c = a._iDisplayLength, e = a.fnRecordsDisplay(), d = -1 === c;
+ return{page: d ? 0 : Math.floor(b / c), pages: d ? 1 : Math.ceil(e / c), start: b, end: a.fnDisplayEnd(), length: c, recordsTotal: a.fnRecordsTotal(), recordsDisplay: e}
+ });
+ r("page.len()", function (a) {
+ return a === l ? 0 !== this.context.length ? this.context[0]._iDisplayLength : l : this.iterator("table", function (b) {
+ Qa(b,
+ a)
+ })
+ });
+ var Tb = function (a, b, c) {
+ "ssp" == A(a) ? M(a, b) : (B(a, !0), qa(a, [], function (c) {
+ na(a);
+ for (var c = ra(a, c), e = 0, h = c.length; e < h; e++)I(a, c[e]);
+ M(a, b);
+ B(a, !1)
+ }));
+ if (c) {
+ var e = new q(a);
+ e.one("draw", function () {
+ c(e.ajax.json())
+ })
+ }
+ };
+ r("ajax.json()", function () {
+ var a = this.context;
+ if (0 < a.length)return a[0].json
+ });
+ r("ajax.params()", function () {
+ var a = this.context;
+ if (0 < a.length)return a[0].oAjaxData
+ });
+ r("ajax.reload()", function (a, b) {
+ return this.iterator("table", function (c) {
+ Tb(c, !1 === b, a)
+ })
+ });
+ r("ajax.url()", function (a) {
+ var b =
+ this.context;
+ if (a === l) {
+ if (0 === b.length)return l;
+ b = b[0];
+ return b.ajax ? g.isPlainObject(b.ajax) ? b.ajax.url : b.ajax : b.sAjaxSource
+ }
+ return this.iterator("table", function (b) {
+ g.isPlainObject(b.ajax) ? b.ajax.url = a : b.ajax = a
+ })
+ });
+ r("ajax.url().load()", function (a, b) {
+ return this.iterator("table", function (c) {
+ Tb(c, !1 === b, a)
+ })
+ });
+ var Za = function (a, b) {
+ var c = [], e, d, f, h, i, j;
+ e = typeof a;
+ if (!a || "string" === e || "function" === e || a.length === l)a = [a];
+ f = 0;
+ for (h = a.length; f < h; f++) {
+ d = a[f] && a[f].split ? a[f].split(",") : [a[f]];
+ i = 0;
+ for (j =
+ d.length; i < j; i++)(e = b("string" === typeof d[i] ? g.trim(d[i]) : d[i])) && e.length && c.push.apply(c, e)
+ }
+ return c
+ }, $a = function (a) {
+ a || (a = {});
+ a.filter && !a.search && (a.search = a.filter);
+ return{search: a.search || "none", order: a.order || "current", page: a.page || "all"}
+ }, ab = function (a) {
+ for (var b = 0, c = a.length; b < c; b++)if (0 < a[b].length)return a[0] = a[b], a.length = 1, a.context = [a.context[b]], a;
+ a.length = 0;
+ return a
+ }, Ba = function (a, b) {
+ var c, e, d, f = [], h = a.aiDisplay;
+ c = a.aiDisplayMaster;
+ var i = b.search;
+ e = b.order;
+ d = b.page;
+ if ("ssp" == A(a))return"removed" ===
+ i ? [] : U(0, c.length);
+ if ("current" == d) {
+ c = a._iDisplayStart;
+ for (e = a.fnDisplayEnd(); c < e; c++)f.push(h[c])
+ } else if ("current" == e || "applied" == e)f = "none" == i ? c.slice() : "applied" == i ? h.slice() : g.map(c, function (a) {
+ return-1 === g.inArray(a, h) ? a : null
+ }); else if ("index" == e || "original" == e) {
+ c = 0;
+ for (e = a.aoData.length; c < e; c++)"none" == i ? f.push(c) : (d = g.inArray(c, h), (-1 === d && "removed" == i || 0 <= d && "applied" == i) && f.push(c))
+ }
+ return f
+ };
+ r("rows()", function (a, b) {
+ a === l ? a = "" : g.isPlainObject(a) && (b = a, a = "");
+ var b = $a(b), c = this.iterator("table",
+ function (c) {
+ var d = b;
+ return Za(a, function (a) {
+ var b = Ob(a);
+ if (b !== null && !d)return[b];
+ var i = Ba(c, d);
+ if (b !== null && g.inArray(b, i) !== -1)return[b];
+ if (!a)return i;
+ if (typeof a === "function")return g.map(i, function (b) {
+ var d = c.aoData[b];
+ return a(b, d._aData, d.nTr) ? b : null
+ });
+ b = Rb(ha(c.aoData, i, "nTr"));
+ return a.nodeName && g.inArray(a, b) !== -1 ? [a._DT_RowIndex] : g(b).filter(a).map(function () {
+ return this._DT_RowIndex
+ }).toArray()
+ })
+ }, 1);
+ c.selector.rows = a;
+ c.selector.opts = b;
+ return c
+ });
+ r("rows().nodes()", function () {
+ return this.iterator("row",
+ function (a, b) {
+ return a.aoData[b].nTr || l
+ }, 1)
+ });
+ r("rows().data()", function () {
+ return this.iterator(!0, "rows", function (a, b) {
+ return ha(a.aoData, b, "_aData")
+ }, 1)
+ });
+ t("rows().cache()", "row().cache()", function (a) {
+ return this.iterator("row", function (b, c) {
+ var e = b.aoData[c];
+ return"search" === a ? e._aFilterData : e._aSortData
+ }, 1)
+ });
+ t("rows().invalidate()", "row().invalidate()", function (a) {
+ return this.iterator("row", function (b, c) {
+ ca(b, c, a)
+ })
+ });
+ t("rows().indexes()", "row().index()", function () {
+ return this.iterator("row",
+ function (a, b) {
+ return b
+ }, 1)
+ });
+ t("rows().remove()", "row().remove()", function () {
+ var a = this;
+ return this.iterator("row", function (b, c, e) {
+ var d = b.aoData;
+ d.splice(c, 1);
+ for (var f = 0, h = d.length; f < h; f++)null !== d[f].nTr && (d[f].nTr._DT_RowIndex = f);
+ g.inArray(c, b.aiDisplay);
+ oa(b.aiDisplayMaster, c);
+ oa(b.aiDisplay, c);
+ oa(a[e], c, !1);
+ Ra(b)
+ })
+ });
+ r("rows.add()", function (a) {
+ var b = this.iterator("table", function (b) {
+ var c, f, h, g = [];
+ f = 0;
+ for (h = a.length; f < h; f++)c = a[f], c.nodeName && "TR" === c.nodeName.toUpperCase() ? g.push(la(b, c)[0]) :
+ g.push(I(b, c));
+ return g
+ }, 1), c = this.rows(-1);
+ c.pop();
+ c.push.apply(c, b.toArray());
+ return c
+ });
+ r("row()", function (a, b) {
+ return ab(this.rows(a, b))
+ });
+ r("row().data()", function (a) {
+ var b = this.context;
+ if (a === l)return b.length && this.length ? b[0].aoData[this[0]]._aData : l;
+ b[0].aoData[this[0]]._aData = a;
+ ca(b[0], this[0], "data");
+ return this
+ });
+ r("row().node()", function () {
+ var a = this.context;
+ return a.length && this.length ? a[0].aoData[this[0]].nTr || null : null
+ });
+ r("row.add()", function (a) {
+ a instanceof g && a.length && (a = a[0]);
+ var b = this.iterator("table", function (b) {
+ return a.nodeName && "TR" === a.nodeName.toUpperCase() ? la(b, a)[0] : I(b, a)
+ });
+ return this.row(b[0])
+ });
+ var bb = function (a, b) {
+ var c = a.context;
+ c.length && (c = c[0].aoData[b !== l ? b : a[0]], c._details && (c._details.remove(), c._detailsShow = l, c._details = l))
+ }, Ub = function (a, b) {
+ var c = a.context;
+ if (c.length && a.length) {
+ var e = c[0].aoData[a[0]];
+ if (e._details) {
+ (e._detailsShow = b) ? e._details.insertAfter(e.nTr) : e._details.detach();
+ var d = c[0], f = new q(d), h = d.aoData;
+ f.off("draw.dt.DT_details column-visibility.dt.DT_details destroy.dt.DT_details");
+ 0 < C(h, "_details").length && (f.on("draw.dt.DT_details", function (a, b) {
+ d === b && f.rows({page: "current"}).eq(0).each(function (a) {
+ a = h[a];
+ a._detailsShow && a._details.insertAfter(a.nTr)
+ })
+ }), f.on("column-visibility.dt.DT_details", function (a, b) {
+ if (d === b)for (var c, e = aa(b), f = 0, g = h.length; f < g; f++)c = h[f], c._details && c._details.children("td[colspan]").attr("colspan", e)
+ }), f.on("destroy.dt.DT_details", function (a, b) {
+ if (d === b)for (var c = 0, e = h.length; c < e; c++)h[c]._details && bb(f, c)
+ }))
+ }
+ }
+ };
+ r("row().child()", function (a, b) {
+ var c =
+ this.context;
+ if (a === l)return c.length && this.length ? c[0].aoData[this[0]]._details : l;
+ if (!0 === a)this.child.show(); else if (!1 === a)bb(this); else if (c.length && this.length) {
+ var e = c[0], c = c[0].aoData[this[0]], d = [], f = function (a, b) {
+ if (a.nodeName && "tr" === a.nodeName.toLowerCase())d.push(a); else {
+ var c = g("
").addClass(b);
+ g("td", c).addClass(b).html(a)[0].colSpan = aa(e);
+ d.push(c[0])
+ }
+ };
+ if (g.isArray(a) || a instanceof g)for (var h = 0, i = a.length; h < i; h++)f(a[h], b); else f(a, b);
+ c._details && c._details.remove();
+ c._details =
+ g(d);
+ c._detailsShow && c._details.insertAfter(c.nTr)
+ }
+ return this
+ });
+ r(["row().child.show()", "row().child().show()"], function () {
+ Ub(this, !0);
+ return this
+ });
+ r(["row().child.hide()", "row().child().hide()"], function () {
+ Ub(this, !1);
+ return this
+ });
+ r(["row().child.remove()", "row().child().remove()"], function () {
+ bb(this);
+ return this
+ });
+ r("row().child.isShown()", function () {
+ var a = this.context;
+ return a.length && this.length ? a[0].aoData[this[0]]._detailsShow || !1 : !1
+ });
+ var cc = /^(.+):(name|visIdx|visible)$/, Vb = function (a, b, c, e, d) {
+ for (var c = [], e = 0, f = d.length; e < f; e++)c.push(v(a, d[e], b));
+ return c
+ };
+ r("columns()", function (a, b) {
+ a === l ? a = "" : g.isPlainObject(a) && (b = a, a = "");
+ var b = $a(b), c = this.iterator("table", function (c) {
+ var d = a, f = b, h = c.aoColumns, i = C(h, "sName"), j = C(h, "nTh");
+ return Za(d, function (a) {
+ var b = Ob(a);
+ if (a === "")return U(h.length);
+ if (b !== null)return[b >= 0 ? b : h.length + b];
+ if (typeof a === "function") {
+ var d = Ba(c, f);
+ return g.map(h, function (b, f) {
+ return a(f, Vb(c, f, 0, 0, d), j[f]) ? f : null
+ })
+ }
+ var k = typeof a === "string" ? a.match(cc) : "";
+ if (k)switch (k[2]) {
+ case "visIdx":
+ case "visible":
+ b =
+ parseInt(k[1], 10);
+ if (b < 0) {
+ var l = g.map(h, function (a, b) {
+ return a.bVisible ? b : null
+ });
+ return[l[l.length + b]]
+ }
+ return[ka(c, b)];
+ case "name":
+ return g.map(i, function (a, b) {
+ return a === k[1] ? b : null
+ })
+ } else return g(j).filter(a).map(function () {
+ return g.inArray(this, j)
+ }).toArray()
+ })
+ }, 1);
+ c.selector.cols = a;
+ c.selector.opts = b;
+ return c
+ });
+ t("columns().header()", "column().header()", function () {
+ return this.iterator("column", function (a, b) {
+ return a.aoColumns[b].nTh
+ }, 1)
+ });
+ t("columns().footer()", "column().footer()", function () {
+ return this.iterator("column",
+ function (a, b) {
+ return a.aoColumns[b].nTf
+ }, 1)
+ });
+ t("columns().data()", "column().data()", function () {
+ return this.iterator("column-rows", Vb, 1)
+ });
+ t("columns().dataSrc()", "column().dataSrc()", function () {
+ return this.iterator("column", function (a, b) {
+ return a.aoColumns[b].mData
+ }, 1)
+ });
+ t("columns().cache()", "column().cache()", function (a) {
+ return this.iterator("column-rows", function (b, c, e, d, f) {
+ return ha(b.aoData, f, "search" === a ? "_aFilterData" : "_aSortData", c)
+ }, 1)
+ });
+ t("columns().nodes()", "column().nodes()", function () {
+ return this.iterator("column-rows",
+ function (a, b, c, e, d) {
+ return ha(a.aoData, d, "anCells", b)
+ }, 1)
+ });
+ t("columns().visible()", "column().visible()", function (a, b) {
+ return this.iterator("column", function (c, e) {
+ if (a === l)return c.aoColumns[e].bVisible;
+ var d = c.aoColumns, f = d[e], h = c.aoData, i, j, n;
+ if (a !== l && f.bVisible !== a) {
+ if (a) {
+ var m = g.inArray(!0, C(d, "bVisible"), e + 1);
+ i = 0;
+ for (j = h.length; i < j; i++)n = h[i].nTr, d = h[i].anCells, n && n.insertBefore(d[e], d[m] || null)
+ } else g(C(c.aoData, "anCells", e)).detach();
+ f.bVisible = a;
+ ea(c, c.aoHeader);
+ ea(c, c.aoFooter);
+ if (b === l ||
+ b)X(c), (c.oScroll.sX || c.oScroll.sY) && Y(c);
+ u(c, null, "column-visibility", [c, e, a]);
+ xa(c)
+ }
+ })
+ });
+ t("columns().indexes()", "column().index()", function (a) {
+ return this.iterator("column", function (b, c) {
+ return"visible" === a ? $(b, c) : c
+ }, 1)
+ });
+ r("columns.adjust()", function () {
+ return this.iterator("table", function (a) {
+ X(a)
+ }, 1)
+ });
+ r("column.index()", function (a, b) {
+ if (0 !== this.context.length) {
+ var c = this.context[0];
+ if ("fromVisible" === a || "toData" === a)return ka(c, b);
+ if ("fromData" === a || "toVisible" === a)return $(c, b)
+ }
+ });
+ r("column()",
+ function (a, b) {
+ return ab(this.columns(a, b))
+ });
+ r("cells()", function (a, b, c) {
+ g.isPlainObject(a) && (typeof a.row !== l ? (c = b, b = null) : (c = a, a = null));
+ g.isPlainObject(b) && (c = b, b = null);
+ if (null === b || b === l)return this.iterator("table", function (b) {
+ var e = a, d = $a(c), f = b.aoData, h = Ba(b, d), d = Rb(ha(f, h, "anCells")), i = g([].concat.apply([], d)), j, m = b.aoColumns.length, n, p, r, q, s, t;
+ return Za(e, function (a) {
+ var c = typeof a === "function";
+ if (a === null || a === l || c) {
+ n = [];
+ p = 0;
+ for (r = h.length; p < r; p++) {
+ j = h[p];
+ for (q = 0; q < m; q++) {
+ s = {row: j, column: q};
+ if (c) {
+ t = b.aoData[j];
+ a(s, v(b, j, q), t.anCells[q]) && n.push(s)
+ } else n.push(s)
+ }
+ }
+ return n
+ }
+ return g.isPlainObject(a) ? [a] : i.filter(a).map(function (a, b) {
+ j = b.parentNode._DT_RowIndex;
+ return{row: j, column: g.inArray(b, f[j].anCells)}
+ }).toArray()
+ })
+ });
+ var e = this.columns(b, c), d = this.rows(a, c), f, h, i, j, n, m = this.iterator("table", function (a, b) {
+ f = [];
+ h = 0;
+ for (i = d[b].length; h < i; h++) {
+ j = 0;
+ for (n = e[b].length; j < n; j++)f.push({row: d[b][h], column: e[b][j]})
+ }
+ return f
+ }, 1);
+ g.extend(m.selector, {cols: b, rows: a, opts: c});
+ return m
+ });
+ t("cells().nodes()",
+ "cell().node()", function () {
+ return this.iterator("cell", function (a, b, c) {
+ return(a = a.aoData[b].anCells) ? a[c] : l
+ }, 1)
+ });
+ r("cells().data()", function () {
+ return this.iterator("cell", function (a, b, c) {
+ return v(a, b, c)
+ }, 1)
+ });
+ t("cells().cache()", "cell().cache()", function (a) {
+ a = "search" === a ? "_aFilterData" : "_aSortData";
+ return this.iterator("cell", function (b, c, e) {
+ return b.aoData[c][a][e]
+ }, 1)
+ });
+ t("cells().render()", "cell().render()", function (a) {
+ return this.iterator("cell", function (b, c, e) {
+ return v(b, c, e, a)
+ }, 1)
+ });
+ t("cells().indexes()",
+ "cell().index()", function () {
+ return this.iterator("cell", function (a, b, c) {
+ return{row: b, column: c, columnVisible: $(a, c)}
+ }, 1)
+ });
+ t("cells().invalidate()", "cell().invalidate()", function (a) {
+ return this.iterator("cell", function (b, c, e) {
+ ca(b, c, a, e)
+ })
+ });
+ r("cell()", function (a, b, c) {
+ return ab(this.cells(a, b, c))
+ });
+ r("cell().data()", function (a) {
+ var b = this.context, c = this[0];
+ if (a === l)return b.length && c.length ? v(b[0], c[0].row, c[0].column) : l;
+ Ha(b[0], c[0].row, c[0].column, a);
+ ca(b[0], c[0].row, "data", c[0].column);
+ return this
+ });
+ r("order()", function (a, b) {
+ var c = this.context;
+ if (a === l)return 0 !== c.length ? c[0].aaSorting : l;
+ "number" === typeof a ? a = [
+ [a, b]
+ ] : g.isArray(a[0]) || (a = Array.prototype.slice.call(arguments));
+ return this.iterator("table", function (b) {
+ b.aaSorting = a.slice()
+ })
+ });
+ r("order.listener()", function (a, b, c) {
+ return this.iterator("table", function (e) {
+ Na(e, a, b, c)
+ })
+ });
+ r(["columns().order()", "column().order()"], function (a) {
+ var b = this;
+ return this.iterator("table", function (c, e) {
+ var d = [];
+ g.each(b[e], function (b, c) {
+ d.push([c, a])
+ });
+ c.aaSorting = d
+ })
+ });
+ r("search()", function (a, b, c, e) {
+ var d = this.context;
+ return a === l ? 0 !== d.length ? d[0].oPreviousSearch.sSearch : l : this.iterator("table", function (d) {
+ d.oFeatures.bFilter && fa(d, g.extend({}, d.oPreviousSearch, {sSearch: a + "", bRegex: null === b ? !1 : b, bSmart: null === c ? !0 : c, bCaseInsensitive: null === e ? !0 : e}), 1)
+ })
+ });
+ t("columns().search()", "column().search()", function (a, b, c, e) {
+ return this.iterator("column", function (d, f) {
+ var h = d.aoPreSearchCols;
+ if (a === l)return h[f].sSearch;
+ d.oFeatures.bFilter && (g.extend(h[f],
+ {sSearch: a + "", bRegex: null === b ? !1 : b, bSmart: null === c ? !0 : c, bCaseInsensitive: null === e ? !0 : e}), fa(d, d.oPreviousSearch, 1))
+ })
+ });
+ r("state()", function () {
+ return this.context.length ? this.context[0].oSavedState : null
+ });
+ r("state.clear()", function () {
+ return this.iterator("table", function (a) {
+ a.fnStateSaveCallback.call(a.oInstance, a, {})
+ })
+ });
+ r("state.loaded()", function () {
+ return this.context.length ? this.context[0].oLoadedState : null
+ });
+ r("state.save()", function () {
+ return this.iterator("table", function (a) {
+ xa(a)
+ })
+ });
+ p.versionCheck =
+ p.fnVersionCheck = function (a) {
+ for (var b = p.version.split("."), a = a.split("."), c, e, d = 0, f = a.length; d < f; d++)if (c = parseInt(b[d], 10) || 0, e = parseInt(a[d], 10) || 0, c !== e)return c > e;
+ return!0
+ };
+ p.isDataTable = p.fnIsDataTable = function (a) {
+ var b = g(a).get(0), c = !1;
+ g.each(p.settings, function (a, d) {
+ if (d.nTable === b || d.nScrollHead === b || d.nScrollFoot === b)c = !0
+ });
+ return c
+ };
+ p.tables = p.fnTables = function (a) {
+ return g.map(p.settings, function (b) {
+ if (!a || a && g(b.nTable).is(":visible"))return b.nTable
+ })
+ };
+ p.util = {throttle: ta, escapeRegex: ua};
+ p.camelToHungarian = G;
+ r("$()", function (a, b) {
+ var c = this.rows(b).nodes(), c = g(c);
+ return g([].concat(c.filter(a).toArray(), c.find(a).toArray()))
+ });
+ g.each(["on", "one", "off"], function (a, b) {
+ r(b + "()", function () {
+ var a = Array.prototype.slice.call(arguments);
+ a[0].match(/\.dt\b/) || (a[0] += ".dt");
+ var e = g(this.tables().nodes());
+ e[b].apply(e, a);
+ return this
+ })
+ });
+ r("clear()", function () {
+ return this.iterator("table", function (a) {
+ na(a)
+ })
+ });
+ r("settings()", function () {
+ return new q(this.context, this.context)
+ });
+ r("data()", function () {
+ return this.iterator("table",
+ function (a) {
+ return C(a.aoData, "_aData")
+ }).flatten()
+ });
+ r("destroy()", function (a) {
+ a = a || !1;
+ return this.iterator("table", function (b) {
+ var c = b.nTableWrapper.parentNode, e = b.oClasses, d = b.nTable, f = b.nTBody, h = b.nTHead, i = b.nTFoot, j = g(d), f = g(f), l = g(b.nTableWrapper), m = g.map(b.aoData, function (a) {
+ return a.nTr
+ }), o;
+ b.bDestroying = !0;
+ u(b, "aoDestroyCallback", "destroy", [b]);
+ a || (new q(b)).columns().visible(!0);
+ l.unbind(".DT").find(":not(tbody *)").unbind(".DT");
+ g(Da).unbind(".DT-" + b.sInstance);
+ d != h.parentNode && (j.children("thead").detach(),
+ j.append(h));
+ i && d != i.parentNode && (j.children("tfoot").detach(), j.append(i));
+ j.detach();
+ l.detach();
+ b.aaSorting = [];
+ b.aaSortingFixed = [];
+ wa(b);
+ g(m).removeClass(b.asStripeClasses.join(" "));
+ g("th, td", h).removeClass(e.sSortable + " " + e.sSortableAsc + " " + e.sSortableDesc + " " + e.sSortableNone);
+ b.bJUI && (g("th span." + e.sSortIcon + ", td span." + e.sSortIcon, h).detach(), g("th, td", h).each(function () {
+ var a = g("div." + e.sSortJUIWrapper, this);
+ g(this).append(a.contents());
+ a.detach()
+ }));
+ !a && c && c.insertBefore(d, b.nTableReinsertBefore);
+ f.children().detach();
+ f.append(m);
+ j.css("width", b.sDestroyWidth).removeClass(e.sTable);
+ (o = b.asDestroyStripes.length) && f.children().each(function (a) {
+ g(this).addClass(b.asDestroyStripes[a % o])
+ });
+ c = g.inArray(b, p.settings);
+ -1 !== c && p.settings.splice(c, 1)
+ })
+ });
+ p.version = "1.10.4";
+ p.settings = [];
+ p.models = {};
+ p.models.oSearch = {bCaseInsensitive: !0, sSearch: "", bRegex: !1, bSmart: !0};
+ p.models.oRow = {nTr: null, anCells: null, _aData: [], _aSortData: null, _aFilterData: null, _sFilterRow: null, _sRowStripe: "", src: null};
+ p.models.oColumn =
+ {idx: null, aDataSort: null, asSorting: null, bSearchable: null, bSortable: null, bVisible: null, _sManualType: null, _bAttrSrc: !1, fnCreatedCell: null, fnGetData: null, fnSetData: null, mData: null, mRender: null, nTh: null, nTf: null, sClass: null, sContentPadding: null, sDefaultContent: null, sName: null, sSortDataType: "std", sSortingClass: null, sSortingClassJUI: null, sTitle: null, sType: null, sWidth: null, sWidthOrig: null};
+ p.defaults = {aaData: null, aaSorting: [
+ [0, "asc"]
+ ], aaSortingFixed: [], ajax: null, aLengthMenu: [10, 25, 50, 100], aoColumns: null,
+ aoColumnDefs: null, aoSearchCols: [], asStripeClasses: null, bAutoWidth: !0, bDeferRender: !1, bDestroy: !1, bFilter: !0, bInfo: !0, bJQueryUI: !1, bLengthChange: !0, bPaginate: !0, bProcessing: !1, bRetrieve: !1, bScrollCollapse: !1, bServerSide: !1, bSort: !0, bSortMulti: !0, bSortCellsTop: !1, bSortClasses: !0, bStateSave: !1, fnCreatedRow: null, fnDrawCallback: null, fnFooterCallback: null, fnFormatNumber: function (a) {
+ return a.toString().replace(/\B(?=(\d{3})+(?!\d))/g, this.oLanguage.sThousands)
+ }, fnHeaderCallback: null, fnInfoCallback: null,
+ fnInitComplete: null, fnPreDrawCallback: null, fnRowCallback: null, fnServerData: null, fnServerParams: null, fnStateLoadCallback: function (a) {
+ try {
+ return JSON.parse((-1 === a.iStateDuration ? sessionStorage : localStorage).getItem("DataTables_" + a.sInstance + "_" + location.pathname))
+ } catch (b) {
+ }
+ }, fnStateLoadParams: null, fnStateLoaded: null, fnStateSaveCallback: function (a, b) {
+ try {
+ (-1 === a.iStateDuration ? sessionStorage : localStorage).setItem("DataTables_" + a.sInstance + "_" + location.pathname, JSON.stringify(b))
+ } catch (c) {
+ }
+ }, fnStateSaveParams: null,
+ iStateDuration: 7200, iDeferLoading: null, iDisplayLength: 10, iDisplayStart: 0, iTabIndex: 0, oClasses: {}, oLanguage: {oAria: {sSortAscending: ": activate to sort column ascending", sSortDescending: ": activate to sort column descending"}, oPaginate: {sFirst: "First", sLast: "Last", sNext: "Next", sPrevious: "Previous"}, sEmptyTable: "No data available in table", sInfo: "Showing _START_ to _END_ of _TOTAL_ entries", sInfoEmpty: "Showing 0 to 0 of 0 entries", sInfoFiltered: "(filtered from _MAX_ total entries)", sInfoPostFix: "", sDecimal: "",
+ sThousands: ",", sLengthMenu: "Show _MENU_ entries", sLoadingRecords: "Loading...", sProcessing: "Processing...", sSearch: "Search:", sSearchPlaceholder: "", sUrl: "", sZeroRecords: "No matching records found"}, oSearch: g.extend({}, p.models.oSearch), sAjaxDataProp: "data", sAjaxSource: null, sDom: "lfrtip", searchDelay: null, sPaginationType: "simple_numbers", sScrollX: "", sScrollXInner: "", sScrollY: "", sServerMethod: "GET", renderer: null};
+ V(p.defaults);
+ p.defaults.column = {aDataSort: null, iDataSort: -1, asSorting: ["asc", "desc"], bSearchable: !0,
+ bSortable: !0, bVisible: !0, fnCreatedCell: null, mData: null, mRender: null, sCellType: "td", sClass: "", sContentPadding: "", sDefaultContent: null, sName: "", sSortDataType: "std", sTitle: null, sType: null, sWidth: null};
+ V(p.defaults.column);
+ p.models.oSettings = {oFeatures: {bAutoWidth: null, bDeferRender: null, bFilter: null, bInfo: null, bLengthChange: null, bPaginate: null, bProcessing: null, bServerSide: null, bSort: null, bSortMulti: null, bSortClasses: null, bStateSave: null}, oScroll: {bCollapse: null, iBarWidth: 0, sX: null, sXInner: null, sY: null},
+ oLanguage: {fnInfoCallback: null}, oBrowser: {bScrollOversize: !1, bScrollbarLeft: !1}, ajax: null, aanFeatures: [], aoData: [], aiDisplay: [], aiDisplayMaster: [], aoColumns: [], aoHeader: [], aoFooter: [], oPreviousSearch: {}, aoPreSearchCols: [], aaSorting: null, aaSortingFixed: [], asStripeClasses: null, asDestroyStripes: [], sDestroyWidth: 0, aoRowCallback: [], aoHeaderCallback: [], aoFooterCallback: [], aoDrawCallback: [], aoRowCreatedCallback: [], aoPreDrawCallback: [], aoInitComplete: [], aoStateSaveParams: [], aoStateLoadParams: [], aoStateLoaded: [],
+ sTableId: "", nTable: null, nTHead: null, nTFoot: null, nTBody: null, nTableWrapper: null, bDeferLoading: !1, bInitialised: !1, aoOpenRows: [], sDom: null, searchDelay: null, sPaginationType: "two_button", iStateDuration: 0, aoStateSave: [], aoStateLoad: [], oSavedState: null, oLoadedState: null, sAjaxSource: null, sAjaxDataProp: null, bAjaxDataGet: !0, jqXHR: null, json: l, oAjaxData: l, fnServerData: null, aoServerParams: [], sServerMethod: null, fnFormatNumber: null, aLengthMenu: null, iDraw: 0, bDrawing: !1, iDrawError: -1, _iDisplayLength: 10, _iDisplayStart: 0,
+ _iRecordsTotal: 0, _iRecordsDisplay: 0, bJUI: null, oClasses: {}, bFiltered: !1, bSorted: !1, bSortCellsTop: null, oInit: null, aoDestroyCallback: [], fnRecordsTotal: function () {
+ return"ssp" == A(this) ? 1 * this._iRecordsTotal : this.aiDisplayMaster.length
+ }, fnRecordsDisplay: function () {
+ return"ssp" == A(this) ? 1 * this._iRecordsDisplay : this.aiDisplay.length
+ }, fnDisplayEnd: function () {
+ var a = this._iDisplayLength, b = this._iDisplayStart, c = b + a, e = this.aiDisplay.length, d = this.oFeatures, f = d.bPaginate;
+ return d.bServerSide ? !1 === f || -1 === a ? b + e :
+ Math.min(b + a, this._iRecordsDisplay) : !f || c > e || -1 === a ? e : c
+ }, oInstance: null, sInstance: null, iTabIndex: 0, nScrollHead: null, nScrollFoot: null, aLastSort: [], oPlugins: {}};
+ p.ext = w = {classes: {}, errMode: "alert", feature: [], search: [], internal: {}, legacy: {ajax: null}, pager: {}, renderer: {pageButton: {}, header: {}}, order: {}, type: {detect: [], search: {}, order: {}}, _unique: 0, fnVersionCheck: p.fnVersionCheck, iApiIndex: 0, oJUIClasses: {}, sVersion: p.version};
+ g.extend(w, {afnFiltering: w.search, aTypes: w.type.detect, ofnSearch: w.type.search,
+ oSort: w.type.order, afnSortData: w.order, aoFeatures: w.feature, oApi: w.internal, oStdClasses: w.classes, oPagination: w.pager});
+ g.extend(p.ext.classes, {sTable: "dataTable", sNoFooter: "no-footer", sPageButton: "paginate_button", sPageButtonActive: "current", sPageButtonDisabled: "disabled", sStripeOdd: "odd", sStripeEven: "even", sRowEmpty: "dataTables_empty", sWrapper: "dataTables_wrapper", sFilter: "dataTables_filter", sInfo: "dataTables_info", sPaging: "dataTables_paginate paging_", sLength: "dataTables_length", sProcessing: "dataTables_processing",
+ sSortAsc: "sorting_asc", sSortDesc: "sorting_desc", sSortable: "sorting", sSortableAsc: "sorting_asc_disabled", sSortableDesc: "sorting_desc_disabled", sSortableNone: "sorting_disabled", sSortColumn: "sorting_", sFilterInput: "", sLengthSelect: "", sScrollWrapper: "dataTables_scroll", sScrollHead: "dataTables_scrollHead", sScrollHeadInner: "dataTables_scrollHeadInner", sScrollBody: "dataTables_scrollBody", sScrollFoot: "dataTables_scrollFoot", sScrollFootInner: "dataTables_scrollFootInner", sHeaderTH: "", sFooterTH: "", sSortJUIAsc: "",
+ sSortJUIDesc: "", sSortJUI: "", sSortJUIAscAllowed: "", sSortJUIDescAllowed: "", sSortJUIWrapper: "", sSortIcon: "", sJUIHeader: "", sJUIFooter: ""});
+ var Ca = "", Ca = "", E = Ca + "ui-state-default", ia = Ca + "css_right ui-icon ui-icon-", Wb = Ca + "fg-toolbar ui-toolbar ui-widget-header ui-helper-clearfix";
+ g.extend(p.ext.oJUIClasses, p.ext.classes, {sPageButton: "fg-button ui-button " + E, sPageButtonActive: "ui-state-disabled", sPageButtonDisabled: "ui-state-disabled", sPaging: "dataTables_paginate fg-buttonset ui-buttonset fg-buttonset-multi ui-buttonset-multi paging_",
+ sSortAsc: E + " sorting_asc", sSortDesc: E + " sorting_desc", sSortable: E + " sorting", sSortableAsc: E + " sorting_asc_disabled", sSortableDesc: E + " sorting_desc_disabled", sSortableNone: E + " sorting_disabled", sSortJUIAsc: ia + "triangle-1-n", sSortJUIDesc: ia + "triangle-1-s", sSortJUI: ia + "carat-2-n-s", sSortJUIAscAllowed: ia + "carat-1-n", sSortJUIDescAllowed: ia + "carat-1-s", sSortJUIWrapper: "DataTables_sort_wrapper", sSortIcon: "DataTables_sort_icon", sScrollHead: "dataTables_scrollHead " + E, sScrollFoot: "dataTables_scrollFoot " + E,
+ sHeaderTH: E, sFooterTH: E, sJUIHeader: Wb + " ui-corner-tl ui-corner-tr", sJUIFooter: Wb + " ui-corner-bl ui-corner-br"});
+ var Lb = p.ext.pager;
+ g.extend(Lb, {simple: function () {
+ return["previous", "next"]
+ }, full: function () {
+ return["first", "previous", "next", "last"]
+ }, simple_numbers: function (a, b) {
+ return["previous", Va(a, b), "next"]
+ }, full_numbers: function (a, b) {
+ return["first", "previous", Va(a, b), "next", "last"]
+ }, _numbers: Va, numbers_length: 7});
+ g.extend(!0, p.ext.renderer, {pageButton: {_: function (a, b, c, e, d, f) {
+ var h = a.oClasses, i =
+ a.oLanguage.oPaginate, j, l, m = 0, o = function (b, e) {
+ var k, p, r, q, s = function (b) {
+ Sa(a, b.data.action, true)
+ };
+ k = 0;
+ for (p = e.length; k < p; k++) {
+ q = e[k];
+ if (g.isArray(q)) {
+ r = g("<" + (q.DT_el || "div") + "/>").appendTo(b);
+ o(r, q)
+ } else {
+ l = j = "";
+ switch (q) {
+ case "ellipsis":
+ b.append("
… ");
+ break;
+ case "first":
+ j = i.sFirst;
+ l = q + (d > 0 ? "" : " " + h.sPageButtonDisabled);
+ break;
+ case "previous":
+ j = i.sPrevious;
+ l = q + (d > 0 ? "" : " " + h.sPageButtonDisabled);
+ break;
+ case "next":
+ j = i.sNext;
+ l = q + (d < f - 1 ? "" : " " + h.sPageButtonDisabled);
+ break;
+ case "last":
+ j =
+ i.sLast;
+ l = q + (d < f - 1 ? "" : " " + h.sPageButtonDisabled);
+ break;
+ default:
+ j = q + 1;
+ l = d === q ? h.sPageButtonActive : ""
+ }
+ if (j) {
+ r = g("
", {"class": h.sPageButton + " " + l, "aria-controls": a.sTableId, "data-dt-idx": m, tabindex: a.iTabIndex, id: c === 0 && typeof q === "string" ? a.sTableId + "_" + q : null}).html(j).appendTo(b);
+ Ua(r, {action: q}, s);
+ m++
+ }
+ }
+ }
+ };
+ try {
+ var k = g(P.activeElement).data("dt-idx");
+ o(g(b).empty(), e);
+ k !== null && g(b).find("[data-dt-idx=" + k + "]").focus()
+ } catch (p) {
+ }
+ }}});
+ g.extend(p.ext.type.detect, [function (a, b) {
+ var c = b.oLanguage.sDecimal;
+ return Ya(a, c) ? "num" + c : null
+ }, function (a) {
+ if (a && !(a instanceof Date) && (!$b.test(a) || !ac.test(a)))return null;
+ var b = Date.parse(a);
+ return null !== b && !isNaN(b) || H(a) ? "date" : null
+ }, function (a, b) {
+ var c = b.oLanguage.sDecimal;
+ return Ya(a, c, !0) ? "num-fmt" + c : null
+ }, function (a, b) {
+ var c = b.oLanguage.sDecimal;
+ return Qb(a, c) ? "html-num" + c : null
+ }, function (a, b) {
+ var c = b.oLanguage.sDecimal;
+ return Qb(a, c, !0) ? "html-num-fmt" + c : null
+ }, function (a) {
+ return H(a) || "string" === typeof a && -1 !== a.indexOf("<") ? "html" : null
+ }]);
+ g.extend(p.ext.type.search,
+ {html: function (a) {
+ return H(a) ? a : "string" === typeof a ? a.replace(Nb, " ").replace(Aa, "") : ""
+ }, string: function (a) {
+ return H(a) ? a : "string" === typeof a ? a.replace(Nb, " ") : a
+ }});
+ var za = function (a, b, c, e) {
+ if (0 !== a && (!a || "-" === a))return-Infinity;
+ b && (a = Pb(a, b));
+ a.replace && (c && (a = a.replace(c, "")), e && (a = a.replace(e, "")));
+ return 1 * a
+ };
+ g.extend(w.type.order, {"date-pre": function (a) {
+ return Date.parse(a) || 0
+ }, "html-pre": function (a) {
+ return H(a) ? "" : a.replace ? a.replace(/<.*?>/g, "").toLowerCase() : a + ""
+ }, "string-pre": function (a) {
+ return H(a) ?
+ "" : "string" === typeof a ? a.toLowerCase() : !a.toString ? "" : a.toString()
+ }, "string-asc": function (a, b) {
+ return a < b ? -1 : a > b ? 1 : 0
+ }, "string-desc": function (a, b) {
+ return a < b ? 1 : a > b ? -1 : 0
+ }});
+ cb("");
+ g.extend(!0, p.ext.renderer, {header: {_: function (a, b, c, e) {
+ g(a.nTable).on("order.dt.DT", function (d, f, h, g) {
+ if (a === f) {
+ d = c.idx;
+ b.removeClass(c.sSortingClass + " " + e.sSortAsc + " " + e.sSortDesc).addClass(g[d] == "asc" ? e.sSortAsc : g[d] == "desc" ? e.sSortDesc : c.sSortingClass)
+ }
+ })
+ }, jqueryui: function (a, b, c, e) {
+ g("
").addClass(e.sSortJUIWrapper).append(b.contents()).append(g(" tag.
+ //
+ // @constructor
+ // @param {string} cls List of classes to apply to the canvas.
+ // @param {element} container Element onto which to append the canvas.
+ //
+ // Requiring a container is a little iffy, but unfortunately canvas
+ // operations don't work unless the canvas is attached to the DOM.
+
+ function Canvas(cls, container) {
+
+ var element = container.children("." + cls)[0];
+
+ if (element == null) {
+
+ element = document.createElement("canvas");
+ element.className = cls;
+
+ $(element).css({ direction: "ltr", position: "absolute", left: 0, top: 0 })
+ .appendTo(container);
+
+ // If HTML5 Canvas isn't available, fall back to [Ex|Flash]canvas
+
+ if (!element.getContext) {
+ if (window.G_vmlCanvasManager) {
+ element = window.G_vmlCanvasManager.initElement(element);
+ } else {
+ throw new Error("Canvas is not available. If you're using IE with a fall-back such as Excanvas, then there's either a mistake in your conditional include, or the page has no DOCTYPE and is rendering in Quirks Mode.");
+ }
+ }
+ }
+
+ this.element = element;
+
+ var context = this.context = element.getContext("2d");
+
+ // Determine the screen's ratio of physical to device-independent
+ // pixels. This is the ratio between the canvas width that the browser
+ // advertises and the number of pixels actually present in that space.
+
+ // The iPhone 4, for example, has a device-independent width of 320px,
+ // but its screen is actually 640px wide. It therefore has a pixel
+ // ratio of 2, while most normal devices have a ratio of 1.
+
+ var devicePixelRatio = window.devicePixelRatio || 1,
+ backingStoreRatio =
+ context.webkitBackingStorePixelRatio ||
+ context.mozBackingStorePixelRatio ||
+ context.msBackingStorePixelRatio ||
+ context.oBackingStorePixelRatio ||
+ context.backingStorePixelRatio || 1;
+
+ this.pixelRatio = devicePixelRatio / backingStoreRatio;
+
+ // Size the canvas to match the internal dimensions of its container
+
+ this.resize(container.width(), container.height());
+
+ // Collection of HTML div layers for text overlaid onto the canvas
+
+ this.textContainer = null;
+ this.text = {};
+
+ // 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 = {};
+ }
+
+ // Resizes the canvas to the given dimensions.
+ //
+ // @param {number} width New width of the canvas, in pixels.
+ // @param {number} width New height of the canvas, in pixels.
+
+ Canvas.prototype.resize = function (width, height) {
+
+ if (width <= 0 || height <= 0) {
+ throw new Error("Invalid dimensions for plot, width = " + width + ", height = " + 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);
+ };
+
+ // Clears the entire canvas area, not including any overlaid HTML text
+
+ Canvas.prototype.clear = function () {
+ this.context.clearRect(0, 0, this.width, this.height);
+ };
+
+ // 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.getTextLayer(layerKey),
+ layerCache = cache[layerKey];
+
+ layer.hide();
+
+ 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;
+
+ for (var i = 0, position; position = positions[i]; i++) {
+ if (position.active) {
+ if (!position.rendered) {
+ layer.append(position.element);
+ position.rendered = true;
+ }
+ } else {
+ positions.splice(i--, 1);
+ if (position.rendered) {
+ position.element.detach();
+ }
+ }
+ }
+
+ if (positions.length == 0) {
+ delete styleCache[key];
+ }
+ }
+ }
+ }
+ }
+
+ layer.show();
+ }
+ }
+ };
+
+ // Creates (if necessary) and returns the text overlay container.
+ //
+ // @param {string} classes String of space-separated CSS classes used to
+ // uniquely identify the text layer.
+ // @return {object} The jQuery-wrapped text-layer div.
+
+ Canvas.prototype.getTextLayer = function (classes) {
+
+ var layer = this.text[classes];
+
+ // Create the text layer if it doesn't exist
+
+ if (layer == null) {
+
+ // Create the text layer container, if it doesn't exist
+
+ if (this.textContainer == null) {
+ this.textContainer = $("
")
+ .css({
+ position: "absolute",
+ top: 0,
+ left: 0,
+ bottom: 0,
+ right: 0,
+ 'font-size': "smaller",
+ color: "#545454"
+ })
+ .insertAfter(this.element);
+ }
+
+ layer = this.text[classes] = $("
")
+ .addClass(classes)
+ .css({
+ position: "absolute",
+ top: 0,
+ left: 0,
+ bottom: 0,
+ right: 0
+ })
+ .appendTo(this.textContainer);
+ }
+
+ return layer;
+ };
+
+ // Creates (if necessary) and returns a text info object.
+ //
+ // The object looks like this:
+ //
+ // {
+ // width: Width of the text's wrapper div.
+ // height: Height of the text's wrapper div.
+ // element: The jQuery-wrapped HTML div containing the text.
+ // positions: Array of positions at which this text is drawn.
+ // }
+ //
+ // The positions array contains objects that look like this:
+ //
+ // {
+ // active: Flag indicating whether the text should be visible.
+ // rendered: Flag indicating whether the text is currently visible.
+ // element: The jQuery-wrapped HTML div containing the text.
+ // 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.
+ //
+ // @param {string} layer A string of space-separated CSS classes uniquely
+ // identifying the layer containing this text.
+ // @param {string} text Text string to retrieve info for.
+ // @param {(string|object)=} font Either a string of space-separated CSS
+ // classes or a font-spec object, defining the text's font and style.
+ // @param {number=} angle Angle at which to rotate the text, in degrees.
+ // Angle is currently unused, it will be implemented in the future.
+ // @param {number=} width Maximum width of the text before it wraps.
+ // @return {object} 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] = {};
+ }
+
+ info = styleCache[text];
+
+ // If we can't find a matching element in our cache, create a new one
+
+ if (info == null) {
+
+ var element = $("
").html(text)
+ .css({
+ position: "absolute",
+ 'max-width': width,
+ top: -9999
+ })
+ .appendTo(this.getTextLayer(layer));
+
+ if (typeof font === "object") {
+ element.css({
+ font: textStyle,
+ color: font.color
+ });
+ } else if (typeof font === "string") {
+ element.addClass(font);
+ }
+
+ info = styleCache[text] = {
+ width: element.outerWidth(true),
+ height: element.outerHeight(true),
+ element: element,
+ positions: []
+ };
+
+ element.detach();
+ }
+
+ return info;
+ };
+
+ // 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.
+ //
+ // @param {string} layer A string of space-separated CSS classes uniquely
+ // identifying the layer containing this text.
+ // @param {number} x X coordinate at which to draw the text.
+ // @param {number} y Y coordinate at which to draw the text.
+ // @param {string} text Text string to draw.
+ // @param {(string|object)=} font Either a string of space-separated CSS
+ // classes or a font-spec object, defining the text's font and style.
+ // @param {number=} angle Angle at which to rotate the text, in degrees.
+ // Angle is currently unused, it will be implemented in the future.
+ // @param {number=} width Maximum width of the text before it wraps.
+ // @param {string=} halign Horizontal alignment of the text; either "left",
+ // "center" or "right".
+ // @param {string=} valign Vertical alignment of the text; either "top",
+ // "middle" or "bottom".
+
+ Canvas.prototype.addText = function (layer, x, y, text, font, angle, width, halign, valign) {
+
+ 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;
+ }
+
+ // 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
+
+ // 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.clone() : info.element,
+ x: x,
+ y: y
+ };
+
+ positions.push(position);
+
+ // Move the element to its final position within the container
+
+ position.element.css({
+ top: Math.round(y),
+ left: Math.round(x),
+ 'text-align': halign // In case the text wraps
+ });
+ };
+
+ // 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.
+ //
+ // @param {string} layer A string of space-separated CSS classes uniquely
+ // identifying the layer containing this text.
+ // @param {number=} x X coordinate of the text.
+ // @param {number=} y Y coordinate of the text.
+ // @param {string=} text Text string to remove.
+ // @param {(string|object)=} font Either a string of space-separated CSS
+ // classes or a font-spec object, defining the text's font and style.
+ // @param {number=} angle Angle at which the text is rotated, in degrees.
+ // Angle is currently unused, it will be implemented in the future.
+
+ Canvas.prototype.removeText = function (layer, x, y, text, font, angle) {
+ 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;
+ for (var i = 0, position; position = positions[i]; i++) {
+ position.active = false;
+ }
+ }
+ }
+ }
+ }
+ }
+ } else {
+ var positions = this.getTextInfo(layer, text, font, angle).positions;
+ for (var i = 0, position; position = positions[i]; i++) {
+ if (position.x == x && position.y == y) {
+ position.active = false;
+ }
+ }
+ }
+ };
+
+ ///////////////////////////////////////////////////////////////////////////
+ // The top-level container for the entire plot.
+
+ function Plot(placeholder, data_, options_, plugins) {
+ // data is on the form:
+ // [ series1, series2 ... ]
+ // where series is either just the data as [ [x1, y1], [x2, y2], ... ]
+ // or { data: [ [x1, y1], [x2, y2], ... ], label: "some label", ... }
+
+ var series = [],
+ options = {
+ // the color theme used for graphs
+ colors: ["#edc240", "#afd8f8", "#cb4b4b", "#4da74d", "#9440ed"],
+ legend: {
+ show: true,
+ noColumns: 1, // number of colums in legend table
+ labelFormatter: null, // fn: string -> string
+ labelBoxBorderColor: "#ccc", // border color for the little label boxes
+ 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
+ backgroundColor: null, // null means auto-detect
+ backgroundOpacity: 0.85, // set to 0 to avoid background
+ sorted: null // default to no legend sorting
+ },
+ xaxis: {
+ show: null, // null = auto-detect, true = always, false = never
+ position: "bottom", // or "top"
+ mode: null, // null or "time"
+ font: null, // null (derived from CSS in placeholder) or object like { size: 11, lineHeight: 13, style: "italic", weight: "bold", family: "sans-serif", variant: "small-caps" }
+ color: null, // base color, labels, ticks
+ tickColor: null, // possibly different color of ticks, e.g. "rgba(0,0,0,0.15)"
+ transform: null, // null or f: number -> number to transform axis
+ inverseTransform: null, // if transform is set, this should be the inverse function
+ min: null, // min. value to show, null means set automatically
+ max: null, // max. value to show, null means set automatically
+ autoscaleMargin: null, // margin in % to add if auto-setting min/max
+ ticks: null, // either [1, 3] or [[1, "a"], 3] or (fn: axis info -> ticks) or app. number of ticks for auto-ticks
+ tickFormatter: null, // fn: number -> string
+ labelWidth: null, // size of tick labels in pixels
+ labelHeight: null,
+ reserveSpace: null, // whether to reserve space even if axis isn't shown
+ tickLength: null, // size in pixels of ticks, or "full" for whole line
+ alignTicksWithAxis: null, // axis number or null for no sync
+ tickDecimals: null, // no. of decimals, null means auto
+ tickSize: null, // number or [number, "unit"]
+ minTickSize: null // number or [number, "unit"]
+ },
+ yaxis: {
+ autoscaleMargin: 0.02,
+ position: "left" // or "right"
+ },
+ xaxes: [],
+ yaxes: [],
+ series: {
+ points: {
+ show: false,
+ radius: 3,
+ lineWidth: 2, // in pixels
+ fill: true,
+ fillColor: "#ffffff",
+ symbol: "circle" // or callback
+ },
+ lines: {
+ // we don't put in show: false so we can see
+ // whether lines were actively disabled
+ lineWidth: 2, // in pixels
+ fill: false,
+ fillColor: null,
+ steps: false
+ // Omit 'zero', so we can later default its value to
+ // match that of the 'fill' option.
+ },
+ bars: {
+ show: false,
+ lineWidth: 2, // in pixels
+ barWidth: 1, // in units of the x axis
+ fill: true,
+ fillColor: null,
+ align: "left", // "left", "right", or "center"
+ horizontal: false,
+ zero: true
+ },
+ shadowSize: 3,
+ highlightColor: null
+ },
+ grid: {
+ show: true,
+ aboveData: false,
+ color: "#545454", // primary color used for outline and labels
+ backgroundColor: null, // null for transparent, else color
+ borderColor: null, // set if different from the grid color
+ tickColor: null, // color for the ticks, e.g. "rgba(0,0,0,0.15)"
+ margin: 0, // distance from the canvas edge to the grid
+ labelMargin: 5, // in pixels
+ axisMargin: 8, // in pixels
+ borderWidth: 2, // in pixels
+ minBorderMargin: null, // in pixels, null means taken from points radius
+ markings: null, // array of ranges or fn: axes -> array of ranges
+ markingsColor: "#f4f4f4",
+ markingsLineWidth: 2,
+ // interactive stuff
+ clickable: false,
+ hoverable: false,
+ autoHighlight: true, // highlight in case mouse is near
+ mouseActiveRadius: 10 // how far the mouse can be away to activate an item
+ },
+ interaction: {
+ redrawOverlayInterval: 1000 / 60 // time between updates, -1 means in same flow
+ },
+ hooks: {}
+ },
+ surface = null, // the canvas for the plot itself
+ overlay = null, // canvas for interactive stuff on top of plot
+ eventHolder = null, // jQuery object that events should be bound to
+ ctx = null, octx = null,
+ xaxes = [], yaxes = [],
+ plotOffset = { left: 0, right: 0, top: 0, bottom: 0},
+ plotWidth = 0, plotHeight = 0,
+ hooks = {
+ processOptions: [],
+ processRawData: [],
+ processDatapoints: [],
+ processOffset: [],
+ drawBackground: [],
+ drawSeries: [],
+ draw: [],
+ bindEvents: [],
+ drawOverlay: [],
+ shutdown: []
+ },
+ plot = this;
+
+ // public functions
+ plot.setData = setData;
+ plot.setupGrid = setupGrid;
+ plot.draw = draw;
+ plot.getPlaceholder = function () {
+ return placeholder;
+ };
+ plot.getCanvas = function () {
+ return surface.element;
+ };
+ plot.getPlotOffset = function () {
+ return plotOffset;
+ };
+ plot.width = function () {
+ return plotWidth;
+ };
+ plot.height = function () {
+ return plotHeight;
+ };
+ plot.offset = function () {
+ var o = eventHolder.offset();
+ o.left += plotOffset.left;
+ o.top += plotOffset.top;
+ return o;
+ };
+ plot.getData = function () {
+ return series;
+ };
+ plot.getAxes = function () {
+ var res = {}, i;
+ $.each(xaxes.concat(yaxes), function (_, axis) {
+ if (axis)
+ res[axis.direction + (axis.n != 1 ? axis.n : "") + "axis"] = axis;
+ });
+ return res;
+ };
+ plot.getXAxes = function () {
+ return xaxes;
+ };
+ plot.getYAxes = function () {
+ return yaxes;
+ };
+ plot.c2p = canvasToAxisCoords;
+ plot.p2c = axisToCanvasCoords;
+ plot.getOptions = function () {
+ return options;
+ };
+ plot.highlight = highlight;
+ plot.unhighlight = unhighlight;
+ plot.triggerRedrawOverlay = triggerRedrawOverlay;
+ plot.pointOffset = function (point) {
+ return {
+ left: parseInt(xaxes[axisNumber(point, "x") - 1].p2c(+point.x) + plotOffset.left, 10),
+ top: parseInt(yaxes[axisNumber(point, "y") - 1].p2c(+point.y) + plotOffset.top, 10)
+ };
+ };
+ plot.shutdown = shutdown;
+ plot.destroy = function () {
+ shutdown();
+ placeholder.removeData("plot").empty();
+
+ series = [];
+ options = null;
+ surface = null;
+ overlay = null;
+ eventHolder = null;
+ ctx = null;
+ octx = null;
+ xaxes = [];
+ yaxes = [];
+ hooks = null;
+ highlights = [];
+ plot = null;
+ };
+ plot.resize = function () {
+ var width = placeholder.width(),
+ height = placeholder.height();
+ surface.resize(width, height);
+ overlay.resize(width, height);
+ };
+
+ // public attributes
+ plot.hooks = hooks;
+
+ // initialize
+ initPlugins(plot);
+ parseOptions(options_);
+ setupCanvases();
+ setData(data_);
+ setupGrid();
+ draw();
+ bindEvents();
+
+
+ function executeHooks(hook, args) {
+ args = [plot].concat(args);
+ for (var i = 0; i < hook.length; ++i)
+ hook[i].apply(this, args);
+ }
+
+ function initPlugins() {
+
+ // References to key classes, allowing plugins to modify them
+
+ var classes = {
+ Canvas: Canvas
+ };
+
+ for (var i = 0; i < plugins.length; ++i) {
+ var p = plugins[i];
+ p.init(plot, classes);
+ if (p.options)
+ $.extend(true, options, p.options);
+ }
+ }
+
+ function parseOptions(opts) {
+
+ $.extend(true, options, opts);
+
+ // $.extend merges arrays, rather than replacing them. When less
+ // colors are provided than the size of the default palette, we
+ // end up with those colors plus the remaining defaults, which is
+ // not expected behavior; avoid it by replacing them here.
+
+ if (opts && opts.colors) {
+ options.colors = opts.colors;
+ }
+
+ if (options.xaxis.color == null)
+ options.xaxis.color = $.color.parse(options.grid.color).scale('a', 0.22).toString();
+ if (options.yaxis.color == null)
+ options.yaxis.color = $.color.parse(options.grid.color).scale('a', 0.22).toString();
+
+ if (options.xaxis.tickColor == null) // grid.tickColor for back-compatibility
+ options.xaxis.tickColor = options.grid.tickColor || options.xaxis.color;
+ if (options.yaxis.tickColor == null) // grid.tickColor for back-compatibility
+ options.yaxis.tickColor = options.grid.tickColor || options.yaxis.color;
+
+ if (options.grid.borderColor == null)
+ options.grid.borderColor = options.grid.color;
+ if (options.grid.tickColor == null)
+ options.grid.tickColor = $.color.parse(options.grid.color).scale('a', 0.22).toString();
+
+ // Fill in defaults for axis options, including any unspecified
+ // font-spec fields, if a font-spec was provided.
+
+ // If no x/y axis options were provided, create one of each anyway,
+ // since the rest of the code assumes that they exist.
+
+ var i, axisOptions, axisCount,
+ fontSize = placeholder.css("font-size"),
+ fontSizeDefault = fontSize ? +fontSize.replace("px", "") : 13,
+ fontDefaults = {
+ style: placeholder.css("font-style"),
+ size: Math.round(0.8 * fontSizeDefault),
+ variant: placeholder.css("font-variant"),
+ weight: placeholder.css("font-weight"),
+ family: placeholder.css("font-family")
+ };
+
+ axisCount = options.xaxes.length || 1;
+ for (i = 0; i < axisCount; ++i) {
+
+ axisOptions = options.xaxes[i];
+ if (axisOptions && !axisOptions.tickColor) {
+ axisOptions.tickColor = axisOptions.color;
+ }
+
+ axisOptions = $.extend(true, {}, options.xaxis, axisOptions);
+ options.xaxes[i] = axisOptions;
+
+ if (axisOptions.font) {
+ axisOptions.font = $.extend({}, fontDefaults, axisOptions.font);
+ if (!axisOptions.font.color) {
+ axisOptions.font.color = axisOptions.color;
+ }
+ if (!axisOptions.font.lineHeight) {
+ axisOptions.font.lineHeight = Math.round(axisOptions.font.size * 1.15);
+ }
+ }
+ }
+
+ axisCount = options.yaxes.length || 1;
+ for (i = 0; i < axisCount; ++i) {
+
+ axisOptions = options.yaxes[i];
+ if (axisOptions && !axisOptions.tickColor) {
+ axisOptions.tickColor = axisOptions.color;
+ }
+
+ axisOptions = $.extend(true, {}, options.yaxis, axisOptions);
+ options.yaxes[i] = axisOptions;
+
+ if (axisOptions.font) {
+ axisOptions.font = $.extend({}, fontDefaults, axisOptions.font);
+ if (!axisOptions.font.color) {
+ axisOptions.font.color = axisOptions.color;
+ }
+ if (!axisOptions.font.lineHeight) {
+ axisOptions.font.lineHeight = Math.round(axisOptions.font.size * 1.15);
+ }
+ }
+ }
+
+ // backwards compatibility, to be removed in future
+ if (options.xaxis.noTicks && options.xaxis.ticks == null)
+ options.xaxis.ticks = options.xaxis.noTicks;
+ if (options.yaxis.noTicks && options.yaxis.ticks == null)
+ options.yaxis.ticks = options.yaxis.noTicks;
+ if (options.x2axis) {
+ options.xaxes[1] = $.extend(true, {}, options.xaxis, options.x2axis);
+ options.xaxes[1].position = "top";
+ // Override the inherit to allow the axis to auto-scale
+ if (options.x2axis.min == null) {
+ options.xaxes[1].min = null;
+ }
+ if (options.x2axis.max == null) {
+ options.xaxes[1].max = null;
+ }
+ }
+ if (options.y2axis) {
+ options.yaxes[1] = $.extend(true, {}, options.yaxis, options.y2axis);
+ options.yaxes[1].position = "right";
+ // Override the inherit to allow the axis to auto-scale
+ if (options.y2axis.min == null) {
+ options.yaxes[1].min = null;
+ }
+ if (options.y2axis.max == null) {
+ options.yaxes[1].max = null;
+ }
+ }
+ if (options.grid.coloredAreas)
+ options.grid.markings = options.grid.coloredAreas;
+ if (options.grid.coloredAreasColor)
+ options.grid.markingsColor = options.grid.coloredAreasColor;
+ if (options.lines)
+ $.extend(true, options.series.lines, options.lines);
+ if (options.points)
+ $.extend(true, options.series.points, options.points);
+ if (options.bars)
+ $.extend(true, options.series.bars, options.bars);
+ if (options.shadowSize != null)
+ options.series.shadowSize = options.shadowSize;
+ if (options.highlightColor != null)
+ options.series.highlightColor = options.highlightColor;
+
+ // save options on axes for future reference
+ for (i = 0; i < options.xaxes.length; ++i)
+ getOrCreateAxis(xaxes, i + 1).options = options.xaxes[i];
+ for (i = 0; i < options.yaxes.length; ++i)
+ getOrCreateAxis(yaxes, i + 1).options = options.yaxes[i];
+
+ // add hooks from options
+ for (var n in hooks)
+ if (options.hooks[n] && options.hooks[n].length)
+ hooks[n] = hooks[n].concat(options.hooks[n]);
+
+ executeHooks(hooks.processOptions, [options]);
+ }
+
+ function setData(d) {
+ series = parseData(d);
+ fillInSeriesOptions();
+ processData();
+ }
+
+ function parseData(d) {
+ var res = [];
+ for (var i = 0; i < d.length; ++i) {
+ var s = $.extend(true, {}, options.series);
+
+ if (d[i].data != null) {
+ s.data = d[i].data; // move the data instead of deep-copy
+ delete d[i].data;
+
+ $.extend(true, s, d[i]);
+
+ d[i].data = s.data;
+ }
+ else
+ s.data = d[i];
+ res.push(s);
+ }
+
+ return res;
+ }
+
+ function axisNumber(obj, coord) {
+ var a = obj[coord + "axis"];
+ if (typeof a == "object") // if we got a real axis, extract number
+ a = a.n;
+ if (typeof a != "number")
+ a = 1; // default to first axis
+ return a;
+ }
+
+ function allAxes() {
+ // return flat array without annoying null entries
+ return $.grep(xaxes.concat(yaxes), function (a) {
+ return a;
+ });
+ }
+
+ function canvasToAxisCoords(pos) {
+ // return an object with x/y corresponding to all used axes
+ var res = {}, i, axis;
+ for (i = 0; i < xaxes.length; ++i) {
+ axis = xaxes[i];
+ if (axis && axis.used)
+ res["x" + axis.n] = axis.c2p(pos.left);
+ }
+
+ for (i = 0; i < yaxes.length; ++i) {
+ axis = yaxes[i];
+ if (axis && axis.used)
+ res["y" + axis.n] = axis.c2p(pos.top);
+ }
+
+ if (res.x1 !== undefined)
+ res.x = res.x1;
+ if (res.y1 !== undefined)
+ res.y = res.y1;
+
+ return res;
+ }
+
+ function axisToCanvasCoords(pos) {
+ // get canvas coords from the first pair of x/y found in pos
+ var res = {}, i, axis, key;
+
+ for (i = 0; i < xaxes.length; ++i) {
+ axis = xaxes[i];
+ if (axis && axis.used) {
+ key = "x" + axis.n;
+ if (pos[key] == null && axis.n == 1)
+ key = "x";
+
+ if (pos[key] != null) {
+ res.left = axis.p2c(pos[key]);
+ break;
+ }
+ }
+ }
+
+ for (i = 0; i < yaxes.length; ++i) {
+ axis = yaxes[i];
+ if (axis && axis.used) {
+ key = "y" + axis.n;
+ if (pos[key] == null && axis.n == 1)
+ key = "y";
+
+ if (pos[key] != null) {
+ res.top = axis.p2c(pos[key]);
+ break;
+ }
+ }
+ }
+
+ return res;
+ }
+
+ function getOrCreateAxis(axes, number) {
+ if (!axes[number - 1])
+ axes[number - 1] = {
+ n: number, // save the number for future reference
+ direction: axes == xaxes ? "x" : "y",
+ options: $.extend(true, {}, axes == xaxes ? options.xaxis : options.yaxis)
+ };
+
+ return axes[number - 1];
+ }
+
+ function fillInSeriesOptions() {
+
+ var neededColors = series.length, maxIndex = -1, i;
+
+ // Subtract the number of series that already have fixed colors or
+ // color indexes from the number that we still need to generate.
+
+ for (i = 0; i < series.length; ++i) {
+ var sc = series[i].color;
+ if (sc != null) {
+ neededColors--;
+ if (typeof sc == "number" && sc > maxIndex) {
+ maxIndex = sc;
+ }
+ }
+ }
+
+ // If any of the series have fixed color indexes, then we need to
+ // generate at least as many colors as the highest index.
+
+ if (neededColors <= maxIndex) {
+ neededColors = maxIndex + 1;
+ }
+
+ // Generate all the colors, using first the option colors and then
+ // variations on those colors once they're exhausted.
+
+ var c, colors = [], colorPool = options.colors,
+ colorPoolSize = colorPool.length, variation = 0;
+
+ for (i = 0; i < neededColors; i++) {
+
+ c = $.color.parse(colorPool[i % colorPoolSize] || "#666");
+
+ // Each time we exhaust the colors in the pool we adjust
+ // a scaling factor used to produce more variations on
+ // those colors. The factor alternates negative/positive
+ // to produce lighter/darker colors.
+
+ // Reset the variation after every few cycles, or else
+ // it will end up producing only white or black colors.
+
+ if (i % colorPoolSize == 0 && i) {
+ if (variation >= 0) {
+ if (variation < 0.5) {
+ variation = -variation - 0.2;
+ } else variation = 0;
+ } else variation = -variation;
+ }
+
+ colors[i] = c.scale('rgb', 1 + variation);
+ }
+
+ // Finalize the series options, filling in their colors
+
+ var colori = 0, s;
+ for (i = 0; i < series.length; ++i) {
+ s = series[i];
+
+ // assign colors
+ if (s.color == null) {
+ s.color = colors[colori].toString();
+ ++colori;
+ }
+ else if (typeof s.color == "number")
+ s.color = colors[s.color].toString();
+
+ // turn on lines automatically in case nothing is set
+ if (s.lines.show == null) {
+ var v, show = true;
+ for (v in s)
+ if (s[v] && s[v].show) {
+ show = false;
+ break;
+ }
+ if (show)
+ s.lines.show = true;
+ }
+
+ // If nothing was provided for lines.zero, default it to match
+ // lines.fill, since areas by default should extend to zero.
+
+ if (s.lines.zero == null) {
+ s.lines.zero = !!s.lines.fill;
+ }
+
+ // setup axes
+ s.xaxis = getOrCreateAxis(xaxes, axisNumber(s, "x"));
+ s.yaxis = getOrCreateAxis(yaxes, axisNumber(s, "y"));
+ }
+ }
+
+ function processData() {
+ var topSentry = Number.POSITIVE_INFINITY,
+ bottomSentry = Number.NEGATIVE_INFINITY,
+ fakeInfinity = Number.MAX_VALUE,
+ i, j, k, m, length,
+ s, points, ps, x, y, axis, val, f, p,
+ data, format;
+
+ function updateAxis(axis, min, max) {
+ if (min < axis.datamin && min != -fakeInfinity)
+ axis.datamin = min;
+ if (max > axis.datamax && max != fakeInfinity)
+ axis.datamax = max;
+ }
+
+ $.each(allAxes(), function (_, axis) {
+ // init axis
+ axis.datamin = topSentry;
+ axis.datamax = bottomSentry;
+ axis.used = false;
+ });
+
+ for (i = 0; i < series.length; ++i) {
+ s = series[i];
+ s.datapoints = { points: [] };
+
+ executeHooks(hooks.processRawData, [ s, s.data, s.datapoints ]);
+ }
+
+ // first pass: clean and copy data
+ for (i = 0; i < series.length; ++i) {
+ s = series[i];
+
+ data = s.data;
+ format = s.datapoints.format;
+
+ if (!format) {
+ format = [];
+ // find out how to copy
+ format.push({ x: true, number: true, required: true });
+ format.push({ y: true, number: true, required: 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, autoscale: autoscale });
+ if (s.bars.horizontal) {
+ delete format[format.length - 1].y;
+ format[format.length - 1].x = true;
+ }
+ }
+
+ s.datapoints.format = format;
+ }
+
+ if (s.datapoints.pointsize != null)
+ continue; // already filled in
+
+ s.datapoints.pointsize = format.length;
+
+ ps = s.datapoints.pointsize;
+ points = s.datapoints.points;
+
+ var insertSteps = s.lines.show && s.lines.steps;
+ s.xaxis.used = s.yaxis.used = true;
+
+ for (j = k = 0; j < data.length; ++j, k += ps) {
+ p = data[j];
+
+ var nullify = p == null;
+ if (!nullify) {
+ for (m = 0; m < ps; ++m) {
+ val = p[m];
+ f = format[m];
+
+ if (f) {
+ if (f.number && val != null) {
+ val = +val; // convert to number
+ if (isNaN(val))
+ val = null;
+ else if (val == Infinity)
+ val = fakeInfinity;
+ else if (val == -Infinity)
+ val = -fakeInfinity;
+ }
+
+ if (val == null) {
+ if (f.required)
+ nullify = true;
+
+ if (f.defaultValue != null)
+ val = f.defaultValue;
+ }
+ }
+
+ points[k + m] = val;
+ }
+ }
+
+ if (nullify) {
+ for (m = 0; m < ps; ++m) {
+ val = points[k + m];
+ if (val != null) {
+ f = format[m];
+ // extract min/max info
+ if (f.autoscale !== false) {
+ if (f.x) {
+ updateAxis(s.xaxis, val, val);
+ }
+ if (f.y) {
+ updateAxis(s.yaxis, val, val);
+ }
+ }
+ }
+ points[k + m] = null;
+ }
+ }
+ else {
+ // a little bit of line specific stuff that
+ // perhaps shouldn't be here, but lacking
+ // better means...
+ if (insertSteps && k > 0
+ && points[k - ps] != null
+ && points[k - ps] != points[k]
+ && points[k - ps + 1] != points[k + 1]) {
+ // copy the point to make room for a middle point
+ for (m = 0; m < ps; ++m)
+ points[k + ps + m] = points[k + m];
+
+ // middle point has same y
+ points[k + 1] = points[k - ps + 1];
+
+ // we've added a point, better reflect that
+ k += ps;
+ }
+ }
+ }
+ }
+
+ // give the hooks a chance to run
+ for (i = 0; i < series.length; ++i) {
+ s = series[i];
+
+ executeHooks(hooks.processDatapoints, [ s, s.datapoints]);
+ }
+
+ // second pass: find datamax/datamin for auto-scaling
+ for (i = 0; i < series.length; ++i) {
+ s = series[i];
+ points = s.datapoints.points;
+ ps = s.datapoints.pointsize;
+ format = s.datapoints.format;
+
+ var xmin = topSentry, ymin = topSentry,
+ xmax = bottomSentry, ymax = bottomSentry;
+
+ for (j = 0; j < points.length; j += ps) {
+ if (points[j] == null)
+ continue;
+
+ for (m = 0; m < ps; ++m) {
+ val = points[j + m];
+ f = format[m];
+ if (!f || f.autoscale === false || val == fakeInfinity || val == -fakeInfinity)
+ continue;
+
+ if (f.x) {
+ if (val < xmin)
+ xmin = val;
+ if (val > xmax)
+ xmax = val;
+ }
+ if (f.y) {
+ if (val < ymin)
+ ymin = val;
+ if (val > ymax)
+ ymax = val;
+ }
+ }
+ }
+
+ if (s.bars.show) {
+ // make sure we got room for the bar on the dancing floor
+ var delta;
+
+ switch (s.bars.align) {
+ case "left":
+ delta = 0;
+ break;
+ case "right":
+ delta = -s.bars.barWidth;
+ break;
+ default:
+ delta = -s.bars.barWidth / 2;
+ }
+
+ if (s.bars.horizontal) {
+ ymin += delta;
+ ymax += delta + s.bars.barWidth;
+ }
+ else {
+ xmin += delta;
+ xmax += delta + s.bars.barWidth;
+ }
+ }
+
+ updateAxis(s.xaxis, xmin, xmax);
+ updateAxis(s.yaxis, ymin, ymax);
+ }
+
+ $.each(allAxes(), function (_, axis) {
+ if (axis.datamin == topSentry)
+ axis.datamin = null;
+ if (axis.datamax == bottomSentry)
+ axis.datamax = null;
+ });
+ }
+
+ function setupCanvases() {
+
+ // Make sure the placeholder is clear of everything except canvases
+ // from a previous plot in this container that we'll try to re-use.
+
+ placeholder.css("padding", 0) // padding messes up the positioning
+ .children().filter(function () {
+ return !$(this).hasClass("flot-overlay") && !$(this).hasClass('flot-base');
+ }).remove();
+
+ if (placeholder.css("position") == 'static')
+ placeholder.css("position", "relative"); // for positioning labels and overlay
+
+ surface = new Canvas("flot-base", placeholder);
+ overlay = new Canvas("flot-overlay", placeholder); // overlay canvas for interactive features
+
+ ctx = surface.context;
+ octx = overlay.context;
+
+ // define which element we're listening for events on
+ eventHolder = $(overlay.element).unbind();
+
+ // If we're re-using a plot object, shut down the old one
+
+ var existing = placeholder.data("plot");
+
+ if (existing) {
+ existing.shutdown();
+ overlay.clear();
+ }
+
+ // save in case we get replotted
+ placeholder.data("plot", plot);
+ }
+
+ function bindEvents() {
+ // bind events
+ if (options.grid.hoverable) {
+ eventHolder.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);
+ }
+
+ if (options.grid.clickable)
+ eventHolder.click(onClick);
+
+ executeHooks(hooks.bindEvents, [eventHolder]);
+ }
+
+ function shutdown() {
+ if (redrawTimeout)
+ clearTimeout(redrawTimeout);
+
+ eventHolder.unbind("mousemove", onMouseMove);
+ eventHolder.unbind("mouseleave", onMouseLeave);
+ eventHolder.unbind("click", onClick);
+
+ executeHooks(hooks.shutdown, [eventHolder]);
+ }
+
+ function setTransformationHelpers(axis) {
+ // set helper functions on the axis, assumes plot area
+ // has been computed already
+
+ function identity(x) {
+ return x;
+ }
+
+ var s, m, t = axis.options.transform || identity,
+ it = axis.options.inverseTransform;
+
+ // precompute how much the axis is scaling a point
+ // in canvas space
+ if (axis.direction == "x") {
+ s = axis.scale = plotWidth / Math.abs(t(axis.max) - t(axis.min));
+ m = Math.min(t(axis.max), t(axis.min));
+ }
+ else {
+ s = axis.scale = plotHeight / Math.abs(t(axis.max) - t(axis.min));
+ s = -s;
+ m = Math.max(t(axis.max), t(axis.min));
+ }
+
+ // data point to canvas coordinate
+ if (t == identity) // slight optimization
+ axis.p2c = function (p) {
+ return (p - m) * s;
+ };
+ else
+ axis.p2c = function (p) {
+ return (t(p) - m) * s;
+ };
+ // canvas coordinate to data point
+ if (!it)
+ axis.c2p = function (c) {
+ return m + c / s;
+ };
+ else
+ axis.c2p = function (c) {
+ return it(m + c / s);
+ };
+ }
+
+ function measureTickLabels(axis) {
+
+ var opts = axis.options,
+ ticks = axis.ticks || [],
+ labelWidth = opts.labelWidth || 0,
+ labelHeight = opts.labelHeight || 0,
+ maxWidth = labelWidth || (axis.direction == "x" ? Math.floor(surface.width / (ticks.length || 1)) : null),
+ legacyStyles = axis.direction + "Axis " + axis.direction + axis.n + "Axis",
+ layer = "flot-" + axis.direction + "-axis flot-" + axis.direction + axis.n + "-axis " + legacyStyles,
+ font = opts.font || "flot-tick-label tickLabel";
+
+ for (var i = 0; i < ticks.length; ++i) {
+
+ var t = ticks[i];
+
+ if (!t.label)
+ continue;
+
+ var info = surface.getTextInfo(layer, t.label, font, null, maxWidth);
+
+ labelWidth = Math.max(labelWidth, info.width);
+ labelHeight = Math.max(labelHeight, info.height);
+ }
+
+ axis.labelWidth = opts.labelWidth || labelWidth;
+ axis.labelHeight = opts.labelHeight || labelHeight;
+ }
+
+ function allocateAxisBoxFirstPhase(axis) {
+ // find the bounding box of the axis by looking at label
+ // widths/heights and ticks, make room by diminishing the
+ // plotOffset; this first phase only looks at one
+ // dimension per axis, the other dimension depends on the
+ // other axes so will have to wait
+
+ var lw = axis.labelWidth,
+ lh = axis.labelHeight,
+ pos = axis.options.position,
+ isXAxis = axis.direction === "x",
+ tickLength = axis.options.tickLength,
+ axisMargin = options.grid.axisMargin,
+ padding = options.grid.labelMargin,
+ innermost = true,
+ outermost = true,
+ first = true,
+ found = false;
+
+ // Determine the axis's position in its direction and on its side
+
+ $.each(isXAxis ? xaxes : yaxes, function (i, a) {
+ if (a && (a.show || a.reserveSpace)) {
+ if (a === axis) {
+ found = true;
+ } else if (a.options.position === pos) {
+ if (found) {
+ outermost = false;
+ } else {
+ innermost = false;
+ }
+ }
+ if (!found) {
+ first = false;
+ }
+ }
+ });
+
+ // The outermost axis on each side has no margin
+
+ if (outermost) {
+ axisMargin = 0;
+ }
+
+ // The ticks for the first axis in each direction stretch across
+
+ if (tickLength == null) {
+ tickLength = first ? "full" : 5;
+ }
+
+ if (!isNaN(+tickLength))
+ padding += +tickLength;
+
+ if (isXAxis) {
+ lh += padding;
+
+ if (pos == "bottom") {
+ plotOffset.bottom += lh + axisMargin;
+ axis.box = { top: surface.height - plotOffset.bottom, height: lh };
+ }
+ else {
+ axis.box = { top: plotOffset.top + axisMargin, height: lh };
+ plotOffset.top += lh + axisMargin;
+ }
+ }
+ else {
+ lw += padding;
+
+ if (pos == "left") {
+ axis.box = { left: plotOffset.left + axisMargin, width: lw };
+ plotOffset.left += lw + axisMargin;
+ }
+ else {
+ plotOffset.right += lw + axisMargin;
+ axis.box = { left: surface.width - plotOffset.right, width: lw };
+ }
+ }
+
+ // save for future reference
+ axis.position = pos;
+ axis.tickLength = tickLength;
+ axis.box.padding = padding;
+ axis.innermost = innermost;
+ }
+
+ function allocateAxisBoxSecondPhase(axis) {
+ // now that all axis boxes have been placed in one
+ // dimension, we can set the remaining dimension coordinates
+ if (axis.direction == "x") {
+ axis.box.left = plotOffset.left - axis.labelWidth / 2;
+ axis.box.width = surface.width - plotOffset.left - plotOffset.right + axis.labelWidth;
+ }
+ else {
+ axis.box.top = plotOffset.top - axis.labelHeight / 2;
+ axis.box.height = surface.height - plotOffset.bottom - plotOffset.top + axis.labelHeight;
+ }
+ }
+
+ function adjustLayoutForThingsStickingOut() {
+ // possibly adjust plot offset to ensure everything stays
+ // inside the canvas and isn't clipped off
+
+ var minMargin = options.grid.minBorderMargin,
+ axis, i;
+
+ // check stuff from the plot (FIXME: this should just read
+ // a value from the series, otherwise it's impossible to
+ // customize)
+ if (minMargin == null) {
+ minMargin = 0;
+ for (i = 0; i < series.length; ++i)
+ minMargin = Math.max(minMargin, 2 * (series[i].points.radius + series[i].points.lineWidth / 2));
+ }
+
+ var margins = {
+ left: minMargin,
+ right: minMargin,
+ top: minMargin,
+ bottom: minMargin
+ };
+
+ // check axis labels, note we don't check the actual
+ // labels but instead use the overall width/height to not
+ // jump as much around with replots
+ $.each(allAxes(), function (_, axis) {
+ if (axis.reserveSpace && axis.ticks && axis.ticks.length) {
+ if (axis.direction === "x") {
+ margins.left = Math.max(margins.left, axis.labelWidth / 2);
+ margins.right = Math.max(margins.right, axis.labelWidth / 2);
+ } else {
+ margins.bottom = Math.max(margins.bottom, axis.labelHeight / 2);
+ margins.top = Math.max(margins.top, axis.labelHeight / 2);
+ }
+ }
+ });
+
+ plotOffset.left = Math.ceil(Math.max(margins.left, plotOffset.left));
+ plotOffset.right = Math.ceil(Math.max(margins.right, plotOffset.right));
+ plotOffset.top = Math.ceil(Math.max(margins.top, plotOffset.top));
+ plotOffset.bottom = Math.ceil(Math.max(margins.bottom, plotOffset.bottom));
+ }
+
+ function setupGrid() {
+ var i, axes = allAxes(), showGrid = options.grid.show;
+
+ // Initialize the plot's offset from the edge of the canvas
+
+ for (var a in plotOffset) {
+ var margin = options.grid.margin || 0;
+ plotOffset[a] = typeof margin == "number" ? margin : margin[a] || 0;
+ }
+
+ executeHooks(hooks.processOffset, [plotOffset]);
+
+ // If the grid is visible, add its border width to the offset
+
+ for (var a in plotOffset) {
+ if (typeof(options.grid.borderWidth) == "object") {
+ plotOffset[a] += showGrid ? options.grid.borderWidth[a] : 0;
+ }
+ else {
+ plotOffset[a] += showGrid ? options.grid.borderWidth : 0;
+ }
+ }
+
+ $.each(axes, function (_, axis) {
+ var axisOpts = axis.options;
+ axis.show = axisOpts.show == null ? axis.used : axisOpts.show;
+ axis.reserveSpace = axisOpts.reserveSpace == null ? axis.show : axisOpts.reserveSpace;
+ setRange(axis);
+ });
+
+ if (showGrid) {
+
+ var allocatedAxes = $.grep(axes, function (axis) {
+ return axis.show || axis.reserveSpace;
+ });
+
+ $.each(allocatedAxes, function (_, axis) {
+ // make the ticks
+ setupTickGeneration(axis);
+ setTicks(axis);
+ snapRangeToTicks(axis, axis.ticks);
+ // find labelWidth/Height for axis
+ measureTickLabels(axis);
+ });
+
+ // with all dimensions calculated, we can compute the
+ // axis bounding boxes, start from the outside
+ // (reverse order)
+ for (i = allocatedAxes.length - 1; i >= 0; --i)
+ allocateAxisBoxFirstPhase(allocatedAxes[i]);
+
+ // make sure we've got enough space for things that
+ // might stick out
+ adjustLayoutForThingsStickingOut();
+
+ $.each(allocatedAxes, function (_, axis) {
+ allocateAxisBoxSecondPhase(axis);
+ });
+ }
+
+ plotWidth = surface.width - plotOffset.left - plotOffset.right;
+ plotHeight = surface.height - plotOffset.bottom - plotOffset.top;
+
+ // now we got the proper plot dimensions, we can compute the scaling
+ $.each(axes, function (_, axis) {
+ setTransformationHelpers(axis);
+ });
+
+ if (showGrid) {
+ drawAxisLabels();
+ }
+
+ insertLegend();
+ }
+
+ function setRange(axis) {
+ var opts = axis.options,
+ min = +(opts.min != null ? opts.min : axis.datamin),
+ max = +(opts.max != null ? opts.max : axis.datamax),
+ delta = max - min;
+
+ if (delta == 0.0) {
+ // degenerate case
+ var widen = max == 0 ? 1 : 0.01;
+
+ if (opts.min == null)
+ min -= widen;
+ // always widen max if we couldn't widen min to ensure we
+ // don't fall into min == max which doesn't work
+ if (opts.max == null || opts.min != null)
+ max += widen;
+ }
+ else {
+ // consider autoscaling
+ var margin = opts.autoscaleMargin;
+ if (margin != null) {
+ if (opts.min == null) {
+ min -= delta * margin;
+ // make sure we don't go below zero if all values
+ // are positive
+ if (min < 0 && axis.datamin != null && axis.datamin >= 0)
+ min = 0;
+ }
+ if (opts.max == null) {
+ max += delta * margin;
+ if (max > 0 && axis.datamax != null && axis.datamax <= 0)
+ max = 0;
+ }
+ }
+ }
+ axis.min = min;
+ axis.max = max;
+ }
+
+ function setupTickGeneration(axis) {
+ var opts = axis.options;
+
+ // estimate number of ticks
+ var noTicks;
+ if (typeof opts.ticks == "number" && opts.ticks > 0)
+ noTicks = opts.ticks;
+ else
+ // heuristic based on the model a*sqrt(x) fitted to
+ // some data points that seemed reasonable
+ noTicks = 0.3 * Math.sqrt(axis.direction == "x" ? surface.width : surface.height);
+
+ var delta = (axis.max - axis.min) / noTicks,
+ dec = -Math.floor(Math.log(delta) / Math.LN10),
+ maxDec = opts.tickDecimals;
+
+ if (maxDec != null && dec > maxDec) {
+ dec = maxDec;
+ }
+
+ var magn = Math.pow(10, -dec),
+ norm = delta / magn, // norm is between 1.0 and 10.0
+ size;
+
+ if (norm < 1.5) {
+ size = 1;
+ } else if (norm < 3) {
+ size = 2;
+ // special case for 2.5, requires an extra decimal
+ if (norm > 2.25 && (maxDec == null || dec + 1 <= maxDec)) {
+ size = 2.5;
+ ++dec;
+ }
+ } else if (norm < 7.5) {
+ size = 5;
+ } else {
+ size = 10;
+ }
+
+ size *= magn;
+
+ if (opts.minTickSize != null && size < opts.minTickSize) {
+ size = opts.minTickSize;
+ }
+
+ axis.delta = delta;
+ axis.tickDecimals = Math.max(0, maxDec != null ? maxDec : dec);
+ axis.tickSize = opts.tickSize || size;
+
+ // Time mode was moved to a plug-in in 0.8, and since so many people use it
+ // we'll add an especially friendly reminder to make sure they included it.
+
+ if (opts.mode == "time" && !axis.tickGenerator) {
+ throw new Error("Time mode requires the flot.time plugin.");
+ }
+
+ // Flot supports base-10 axes; any other mode else is handled by a plug-in,
+ // like flot.time.js.
+
+ if (!axis.tickGenerator) {
+
+ axis.tickGenerator = function (axis) {
+
+ var ticks = [],
+ start = floorInBase(axis.min, axis.tickSize),
+ i = 0,
+ v = Number.NaN,
+ prev;
+
+ do {
+ prev = v;
+ v = start + i * axis.tickSize;
+ ticks.push(v);
+ ++i;
+ } while (v < axis.max && v != prev);
+ return ticks;
+ };
+
+ axis.tickFormatter = function (value, axis) {
+
+ var factor = axis.tickDecimals ? Math.pow(10, axis.tickDecimals) : 1;
+ var formatted = "" + Math.round(value * factor) / factor;
+
+ // If tickDecimals was specified, ensure that we have exactly that
+ // much precision; otherwise default to the value's own precision.
+
+ if (axis.tickDecimals != null) {
+ var decimal = formatted.indexOf(".");
+ var precision = decimal == -1 ? 0 : formatted.length - decimal - 1;
+ if (precision < axis.tickDecimals) {
+ return (precision ? formatted : formatted + ".") + ("" + factor).substr(1, axis.tickDecimals - precision);
+ }
+ }
+
+ return formatted;
+ };
+ }
+
+ if ($.isFunction(opts.tickFormatter))
+ axis.tickFormatter = function (v, axis) {
+ return "" + opts.tickFormatter(v, axis);
+ };
+
+ if (opts.alignTicksWithAxis != null) {
+ var otherAxis = (axis.direction == "x" ? xaxes : yaxes)[opts.alignTicksWithAxis - 1];
+ if (otherAxis && otherAxis.used && otherAxis != axis) {
+ // consider snapping min/max to outermost nice ticks
+ var niceTicks = axis.tickGenerator(axis);
+ if (niceTicks.length > 0) {
+ if (opts.min == null)
+ axis.min = Math.min(axis.min, niceTicks[0]);
+ if (opts.max == null && niceTicks.length > 1)
+ axis.max = Math.max(axis.max, niceTicks[niceTicks.length - 1]);
+ }
+
+ axis.tickGenerator = function (axis) {
+ // copy ticks, scaled to this axis
+ var ticks = [], v, i;
+ for (i = 0; i < otherAxis.ticks.length; ++i) {
+ v = (otherAxis.ticks[i].v - otherAxis.min) / (otherAxis.max - otherAxis.min);
+ v = axis.min + v * (axis.max - axis.min);
+ ticks.push(v);
+ }
+ return ticks;
+ };
+
+ // we might need an extra decimal since forced
+ // ticks don't necessarily fit naturally
+ if (!axis.mode && opts.tickDecimals == null) {
+ var extraDec = Math.max(0, -Math.floor(Math.log(axis.delta) / Math.LN10) + 1),
+ ts = axis.tickGenerator(axis);
+
+ // only proceed if the tick interval rounded
+ // with an extra decimal doesn't give us a
+ // zero at end
+ if (!(ts.length > 1 && /\..*0$/.test((ts[1] - ts[0]).toFixed(extraDec))))
+ axis.tickDecimals = extraDec;
+ }
+ }
+ }
+ }
+
+ function setTicks(axis) {
+ var oticks = axis.options.ticks, ticks = [];
+ if (oticks == null || (typeof oticks == "number" && oticks > 0))
+ ticks = axis.tickGenerator(axis);
+ else if (oticks) {
+ if ($.isFunction(oticks))
+ // generate the ticks
+ ticks = oticks(axis);
+ else
+ ticks = oticks;
+ }
+
+ // clean up/labelify the supplied ticks, copy them over
+ var i, v;
+ axis.ticks = [];
+ for (i = 0; i < ticks.length; ++i) {
+ var label = null;
+ var t = ticks[i];
+ if (typeof t == "object") {
+ v = +t[0];
+ if (t.length > 1)
+ label = t[1];
+ }
+ else
+ v = +t;
+ if (label == null)
+ label = axis.tickFormatter(v, axis);
+ if (!isNaN(v))
+ axis.ticks.push({ v: v, label: label });
+ }
+ }
+
+ function snapRangeToTicks(axis, ticks) {
+ if (axis.options.autoscaleMargin && ticks.length > 0) {
+ // snap to ticks
+ if (axis.options.min == null)
+ axis.min = Math.min(axis.min, ticks[0].v);
+ if (axis.options.max == null && ticks.length > 1)
+ axis.max = Math.max(axis.max, ticks[ticks.length - 1].v);
+ }
+ }
+
+ function draw() {
+
+ surface.clear();
+
+ executeHooks(hooks.drawBackground, [ctx]);
+
+ var grid = options.grid;
+
+ // draw background, if any
+ if (grid.show && grid.backgroundColor)
+ drawBackground();
+
+ if (grid.show && !grid.aboveData) {
+ drawGrid();
+ }
+
+ for (var i = 0; i < series.length; ++i) {
+ executeHooks(hooks.drawSeries, [ctx, series[i]]);
+ drawSeries(series[i]);
+ }
+
+ executeHooks(hooks.draw, [ctx]);
+
+ if (grid.show && grid.aboveData) {
+ drawGrid();
+ }
+
+ surface.render();
+
+ // A draw implies that either the axes or data have changed, so we
+ // should probably update the overlay highlights as well.
+
+ triggerRedrawOverlay();
+ }
+
+ function extractRange(ranges, coord) {
+ var axis, from, to, key, axes = allAxes();
+
+ for (var i = 0; i < axes.length; ++i) {
+ axis = axes[i];
+ if (axis.direction == coord) {
+ key = coord + axis.n + "axis";
+ if (!ranges[key] && axis.n == 1)
+ key = coord + "axis"; // support x1axis as xaxis
+ 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" ? xaxes[0] : yaxes[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 drawBackground() {
+ ctx.save();
+ ctx.translate(plotOffset.left, plotOffset.top);
+
+ ctx.fillStyle = getColorOrGradient(options.grid.backgroundColor, plotHeight, 0, "rgba(255, 255, 255, 0)");
+ ctx.fillRect(0, 0, plotWidth, plotHeight);
+ ctx.restore();
+ }
+
+ function drawGrid() {
+ var i, axes, bw, bc;
+
+ ctx.save();
+ ctx.translate(plotOffset.left, plotOffset.top);
+
+ // draw markings
+ var markings = options.grid.markings;
+ if (markings) {
+ if ($.isFunction(markings)) {
+ axes = plot.getAxes();
+ // xmin etc. is backwards compatibility, to be
+ // removed in the future
+ axes.xmin = axes.xaxis.min;
+ axes.xmax = axes.xaxis.max;
+ axes.ymin = axes.yaxis.min;
+ axes.ymax = axes.yaxis.max;
+
+ markings = markings(axes);
+ }
+
+ for (i = 0; i < markings.length; ++i) {
+ var m = markings[i],
+ xrange = extractRange(m, "x"),
+ yrange = extractRange(m, "y");
+
+ // fill in missing
+ if (xrange.from == null)
+ xrange.from = xrange.axis.min;
+ if (xrange.to == null)
+ xrange.to = xrange.axis.max;
+ if (yrange.from == null)
+ yrange.from = yrange.axis.min;
+ if (yrange.to == null)
+ yrange.to = yrange.axis.max;
+
+ // clip
+ if (xrange.to < xrange.axis.min || xrange.from > xrange.axis.max ||
+ yrange.to < yrange.axis.min || yrange.from > yrange.axis.max)
+ continue;
+
+ xrange.from = Math.max(xrange.from, xrange.axis.min);
+ xrange.to = Math.min(xrange.to, xrange.axis.max);
+ yrange.from = Math.max(yrange.from, yrange.axis.min);
+ yrange.to = Math.min(yrange.to, yrange.axis.max);
+
+ var xequal = xrange.from === xrange.to,
+ yequal = yrange.from === yrange.to;
+
+ if (xequal && yequal) {
+ continue;
+ }
+
+ // then draw
+ xrange.from = Math.floor(xrange.axis.p2c(xrange.from));
+ xrange.to = Math.floor(xrange.axis.p2c(xrange.to));
+ yrange.from = Math.floor(yrange.axis.p2c(yrange.from));
+ yrange.to = Math.floor(yrange.axis.p2c(yrange.to));
+
+ if (xequal || yequal) {
+ var lineWidth = m.lineWidth || options.grid.markingsLineWidth,
+ subPixel = lineWidth % 2 ? 0.5 : 0;
+ ctx.beginPath();
+ ctx.strokeStyle = m.color || options.grid.markingsColor;
+ ctx.lineWidth = lineWidth;
+ if (xequal) {
+ ctx.moveTo(xrange.to + subPixel, yrange.from);
+ ctx.lineTo(xrange.to + subPixel, yrange.to);
+ } else {
+ ctx.moveTo(xrange.from, yrange.to + subPixel);
+ ctx.lineTo(xrange.to, yrange.to + subPixel);
+ }
+ ctx.stroke();
+ } else {
+ ctx.fillStyle = m.color || options.grid.markingsColor;
+ ctx.fillRect(xrange.from, yrange.to,
+ xrange.to - xrange.from,
+ yrange.from - yrange.to);
+ }
+ }
+ }
+
+ // draw the ticks
+ axes = allAxes();
+ bw = options.grid.borderWidth;
+
+ for (var j = 0; j < axes.length; ++j) {
+ var axis = axes[j], box = axis.box,
+ t = axis.tickLength, x, y, xoff, yoff;
+ if (!axis.show || axis.ticks.length == 0)
+ continue;
+
+ ctx.lineWidth = 1;
+
+ // find the edges
+ if (axis.direction == "x") {
+ x = 0;
+ if (t == "full")
+ y = (axis.position == "top" ? 0 : plotHeight);
+ else
+ y = box.top - plotOffset.top + (axis.position == "top" ? box.height : 0);
+ }
+ else {
+ y = 0;
+ if (t == "full")
+ x = (axis.position == "left" ? 0 : plotWidth);
+ else
+ x = box.left - plotOffset.left + (axis.position == "left" ? box.width : 0);
+ }
+
+ // draw tick bar
+ if (!axis.innermost) {
+ ctx.strokeStyle = axis.options.color;
+ ctx.beginPath();
+ xoff = yoff = 0;
+ if (axis.direction == "x")
+ xoff = plotWidth + 1;
+ else
+ yoff = plotHeight + 1;
+
+ if (ctx.lineWidth == 1) {
+ if (axis.direction == "x") {
+ y = Math.floor(y) + 0.5;
+ } else {
+ x = Math.floor(x) + 0.5;
+ }
+ }
+
+ ctx.moveTo(x, y);
+ ctx.lineTo(x + xoff, y + yoff);
+ ctx.stroke();
+ }
+
+ // draw ticks
+
+ ctx.strokeStyle = axis.options.tickColor;
+
+ ctx.beginPath();
+ for (i = 0; i < axis.ticks.length; ++i) {
+ var v = axis.ticks[i].v;
+
+ xoff = yoff = 0;
+
+ if (isNaN(v) || v < axis.min || v > axis.max
+ // skip those lying on the axes if we got a border
+ || (t == "full"
+ && ((typeof bw == "object" && bw[axis.position] > 0) || bw > 0)
+ && (v == axis.min || v == axis.max)))
+ continue;
+
+ if (axis.direction == "x") {
+ x = axis.p2c(v);
+ yoff = t == "full" ? -plotHeight : t;
+
+ if (axis.position == "top")
+ yoff = -yoff;
+ }
+ else {
+ y = axis.p2c(v);
+ xoff = t == "full" ? -plotWidth : t;
+
+ if (axis.position == "left")
+ xoff = -xoff;
+ }
+
+ if (ctx.lineWidth == 1) {
+ if (axis.direction == "x")
+ x = Math.floor(x) + 0.5;
+ else
+ y = Math.floor(y) + 0.5;
+ }
+
+ ctx.moveTo(x, y);
+ ctx.lineTo(x + xoff, y + yoff);
+ }
+
+ ctx.stroke();
+ }
+
+
+ // draw border
+ if (bw) {
+ // If either borderWidth or borderColor is an object, then draw the border
+ // line by line instead of as one rectangle
+ bc = options.grid.borderColor;
+ if (typeof bw == "object" || typeof bc == "object") {
+ if (typeof bw !== "object") {
+ bw = {top: bw, right: bw, bottom: bw, left: bw};
+ }
+ if (typeof bc !== "object") {
+ bc = {top: bc, right: bc, bottom: bc, left: bc};
+ }
+
+ if (bw.top > 0) {
+ ctx.strokeStyle = bc.top;
+ ctx.lineWidth = bw.top;
+ ctx.beginPath();
+ ctx.moveTo(0 - bw.left, 0 - bw.top / 2);
+ ctx.lineTo(plotWidth, 0 - bw.top / 2);
+ ctx.stroke();
+ }
+
+ if (bw.right > 0) {
+ ctx.strokeStyle = bc.right;
+ ctx.lineWidth = bw.right;
+ ctx.beginPath();
+ ctx.moveTo(plotWidth + bw.right / 2, 0 - bw.top);
+ ctx.lineTo(plotWidth + bw.right / 2, plotHeight);
+ ctx.stroke();
+ }
+
+ if (bw.bottom > 0) {
+ ctx.strokeStyle = bc.bottom;
+ ctx.lineWidth = bw.bottom;
+ ctx.beginPath();
+ ctx.moveTo(plotWidth + bw.right, plotHeight + bw.bottom / 2);
+ ctx.lineTo(0, plotHeight + bw.bottom / 2);
+ ctx.stroke();
+ }
+
+ if (bw.left > 0) {
+ ctx.strokeStyle = bc.left;
+ ctx.lineWidth = bw.left;
+ ctx.beginPath();
+ ctx.moveTo(0 - bw.left / 2, plotHeight + bw.bottom);
+ ctx.lineTo(0 - bw.left / 2, 0);
+ ctx.stroke();
+ }
+ }
+ else {
+ ctx.lineWidth = bw;
+ ctx.strokeStyle = options.grid.borderColor;
+ ctx.strokeRect(-bw / 2, -bw / 2, plotWidth + bw, plotHeight + bw);
+ }
+ }
+
+ ctx.restore();
+ }
+
+ function drawAxisLabels() {
+
+ $.each(allAxes(), function (_, axis) {
+ var box = axis.box,
+ legacyStyles = axis.direction + "Axis " + axis.direction + axis.n + "Axis",
+ layer = "flot-" + axis.direction + "-axis flot-" + axis.direction + axis.n + "-axis " + legacyStyles,
+ font = axis.options.font || "flot-tick-label tickLabel",
+ tick, x, y, halign, valign;
+
+ // Remove text before checking for axis.show and ticks.length;
+ // otherwise plugins, like flot-tickrotor, that draw their own
+ // tick labels will end up with both theirs and the defaults.
+
+ surface.removeText(layer);
+
+ if (!axis.show || axis.ticks.length == 0)
+ return;
+
+ for (var i = 0; i < axis.ticks.length; ++i) {
+
+ tick = axis.ticks[i];
+ if (!tick.label || tick.v < axis.min || tick.v > axis.max)
+ continue;
+
+ if (axis.direction == "x") {
+ halign = "center";
+ x = plotOffset.left + axis.p2c(tick.v);
+ if (axis.position == "bottom") {
+ y = box.top + box.padding;
+ } else {
+ y = box.top + box.height - box.padding;
+ valign = "bottom";
+ }
+ } else {
+ valign = "middle";
+ y = plotOffset.top + axis.p2c(tick.v);
+ if (axis.position == "left") {
+ x = box.left + box.width - box.padding;
+ halign = "right";
+ } else {
+ x = box.left + box.padding;
+ }
+ }
+
+ surface.addText(layer, x, y, tick.label, font, null, null, halign, valign);
+ }
+ });
+ }
+
+ function drawSeries(series) {
+ if (series.lines.show)
+ drawSeriesLines(series);
+ if (series.bars.show)
+ drawSeriesBars(series);
+ if (series.points.show)
+ drawSeriesPoints(series);
+ }
+
+ function drawSeriesLines(series) {
+ function plotLine(datapoints, xoffset, yoffset, axisx, axisy) {
+ var points = datapoints.points,
+ ps = datapoints.pointsize,
+ prevx = null, prevy = null;
+
+ ctx.beginPath();
+ for (var i = ps; i < points.length; i += ps) {
+ var x1 = points[i - ps], y1 = points[i - ps + 1],
+ x2 = points[i], y2 = points[i + 1];
+
+ if (x1 == null || x2 == null)
+ continue;
+
+ // clip with ymin
+ if (y1 <= y2 && y1 < axisy.min) {
+ if (y2 < axisy.min)
+ continue; // line segment is outside
+ // 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) {
+ var points = datapoints.points,
+ ps = datapoints.pointsize,
+ bottom = Math.min(Math.max(0, axisy.min), axisy.max),
+ i = 0, top, areaOpen = false,
+ ypos = 1, segmentStart = 0, segmentEnd = 0;
+
+ // 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 (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)
+ continue;
+
+ // 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));
+ }
+ }
+ }
+
+ ctx.save();
+ ctx.translate(plotOffset.left, plotOffset.top);
+ ctx.lineJoin = "round";
+
+ var lw = series.lines.lineWidth,
+ sw = series.shadowSize;
+ // FIXME: consider another form of shadow when filling is turned on
+ if (lw > 0 && sw > 0) {
+ // draw shadow as a thick and thin line with transparency
+ ctx.lineWidth = sw;
+ ctx.strokeStyle = "rgba(0,0,0,0.1)";
+ // position shadow at angle from the mid of line
+ var angle = Math.PI / 18;
+ plotLine(series.datapoints, Math.sin(angle) * (lw / 2 + sw / 2), Math.cos(angle) * (lw / 2 + sw / 2), series.xaxis, series.yaxis);
+ ctx.lineWidth = sw / 2;
+ plotLine(series.datapoints, Math.sin(angle) * (lw / 2 + sw / 4), Math.cos(angle) * (lw / 2 + sw / 4), series.xaxis, series.yaxis);
+ }
+
+ ctx.lineWidth = lw;
+ ctx.strokeStyle = series.color;
+ var fillStyle = getFillStyle(series.lines, series.color, 0, plotHeight);
+ if (fillStyle) {
+ ctx.fillStyle = fillStyle;
+ plotLineArea(series.datapoints, series.xaxis, series.yaxis);
+ }
+
+ if (lw > 0)
+ plotLine(series.datapoints, 0, 0, series.xaxis, series.yaxis);
+ ctx.restore();
+ }
+
+ function drawSeriesPoints(series) {
+ function plotPoints(datapoints, radius, fillStyle, offset, shadow, axisx, axisy, symbol) {
+ var points = datapoints.points, ps = datapoints.pointsize;
+
+ 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;
+
+ ctx.beginPath();
+ x = axisx.p2c(x);
+ y = axisy.p2c(y) + offset;
+ if (symbol == "circle")
+ ctx.arc(x, y, radius, 0, shadow ? Math.PI : Math.PI * 2, false);
+ else
+ symbol(ctx, x, y, radius, shadow);
+ ctx.closePath();
+
+ if (fillStyle) {
+ ctx.fillStyle = fillStyle;
+ ctx.fill();
+ }
+ ctx.stroke();
+ }
+ }
+
+ ctx.save();
+ ctx.translate(plotOffset.left, plotOffset.top);
+
+ var lw = series.points.lineWidth,
+ sw = series.shadowSize,
+ radius = series.points.radius,
+ symbol = series.points.symbol;
+
+ // 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.
+ // Doing the conditional here allows the shadow setting to still be
+ // optional even with a lineWidth of 0.
+
+ if (lw == 0)
+ lw = 0.0001;
+
+ if (lw > 0 && sw > 0) {
+ // draw shadow in two steps
+ var w = sw / 2;
+ ctx.lineWidth = w;
+ ctx.strokeStyle = "rgba(0,0,0,0.1)";
+ plotPoints(series.datapoints, radius, null, w + w / 2, true,
+ series.xaxis, series.yaxis, symbol);
+
+ ctx.strokeStyle = "rgba(0,0,0,0.2)";
+ plotPoints(series.datapoints, radius, null, w / 2, true,
+ series.xaxis, series.yaxis, symbol);
+ }
+
+ ctx.lineWidth = lw;
+ ctx.strokeStyle = series.color;
+ plotPoints(series.datapoints, radius,
+ getFillStyle(series.points, series.color), 0, false,
+ series.xaxis, series.yaxis, symbol);
+ ctx.restore();
+ }
+
+ function drawBar(x, y, b, barLeft, barRight, fillStyleCallback, axisx, axisy, c, horizontal, lineWidth) {
+ var left, right, bottom, top,
+ drawLeft, drawRight, drawTop, drawBottom,
+ tmp;
+
+ // 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();
+ }
+ }
+
+ function drawSeriesBars(series) {
+ function plotBars(datapoints, barLeft, barRight, fillStyleCallback, axisx, axisy) {
+ var points = datapoints.points, ps = datapoints.pointsize;
+
+ for (var i = 0; i < points.length; i += ps) {
+ if (points[i] == null)
+ continue;
+ drawBar(points[i], points[i + 1], points[i + 2], barLeft, barRight, fillStyleCallback, axisx, axisy, ctx, series.bars.horizontal, series.bars.lineWidth);
+ }
+ }
+
+ ctx.save();
+ ctx.translate(plotOffset.left, plotOffset.top);
+
+ // FIXME: figure out a way to add shadows (for instance along the right edge)
+ ctx.lineWidth = series.bars.lineWidth;
+ ctx.strokeStyle = series.color;
+
+ var barLeft;
+
+ switch (series.bars.align) {
+ case "left":
+ barLeft = 0;
+ break;
+ case "right":
+ barLeft = -series.bars.barWidth;
+ break;
+ default:
+ barLeft = -series.bars.barWidth / 2;
+ }
+
+ var fillStyleCallback = series.bars.fill ? function (bottom, top) {
+ return getFillStyle(series.bars, series.color, bottom, top);
+ } : null;
+ plotBars(series.datapoints, barLeft, barLeft + series.bars.barWidth, fillStyleCallback, series.xaxis, series.yaxis);
+ ctx.restore();
+ }
+
+ function getFillStyle(filloptions, seriesColor, bottom, top) {
+ 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();
+ }
+
+ function insertLegend() {
+
+ if (options.legend.container != null) {
+ $(options.legend.container).html("");
+ } else {
+ placeholder.find(".legend").remove();
+ }
+
+ if (!options.legend.show) {
+ return;
+ }
+
+ var fragments = [], entries = [], rowStarted = false,
+ lf = options.legend.labelFormatter, s, label;
+
+ // Build a list of legend entries, with each having a label and a color
+
+ for (var i = 0; i < series.length; ++i) {
+ s = series[i];
+ if (s.label) {
+ label = lf ? lf(s.label, s) : s.label;
+ if (label) {
+ entries.push({
+ label: label,
+ color: s.color
+ });
+ }
+ }
+ }
+
+ // Sort the legend using either the default or a custom comparator
+
+ if (options.legend.sorted) {
+ if ($.isFunction(options.legend.sorted)) {
+ entries.sort(options.legend.sorted);
+ } else if (options.legend.sorted == "reverse") {
+ entries.reverse();
+ } else {
+ var ascending = options.legend.sorted != "descending";
+ entries.sort(function (a, b) {
+ return a.label == b.label ? 0 : (
+ (a.label < b.label) != ascending ? 1 : -1 // Logical XOR
+ );
+ });
+ }
+ }
+
+ // Generate markup for the list of entries, in their final order
+
+ for (var i = 0; i < entries.length; ++i) {
+
+ var entry = entries[i];
+
+ if (i % options.legend.noColumns == 0) {
+ if (rowStarted)
+ fragments.push('');
+ fragments.push('');
+ rowStarted = true;
+ }
+
+ fragments.push(
+ '' + entry.label + ' '
+ );
+ }
+
+ if (rowStarted)
+ fragments.push(' ');
+
+ if (fragments.length == 0)
+ return;
+
+ var table = '' + fragments.join("") + '
';
+ if (options.legend.container != null)
+ $(options.legend.container).html(table);
+ else {
+ var pos = "",
+ p = options.legend.position,
+ m = options.legend.margin;
+ 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 legend = $('' + table.replace('style="', 'style="position:absolute;' + pos + ';') + '
').appendTo(placeholder);
+ if (options.legend.backgroundOpacity != 0.0) {
+ // put in the transparent background
+ // separately to avoid blended labels and
+ // label boxes
+ var c = options.legend.backgroundColor;
+ if (c == null) {
+ c = options.grid.backgroundColor;
+ if (c && typeof c == "string")
+ c = $.color.parse(c);
+ else
+ c = $.color.extract(legend, 'background-color');
+ c.a = 1;
+ c = c.toString();
+ }
+ var div = legend.children();
+ $('
').prependTo(legend).css('opacity', options.legend.backgroundOpacity);
+ }
+ }
+ }
+
+
+ // interactive features
+
+ var highlights = [],
+ redrawTimeout = null;
+
+ // returns the data item the mouse is over, or null if none is found
+ function findNearbyItem(mouseX, mouseY, seriesFilter) {
+ var maxDistance = options.grid.mouseActiveRadius,
+ smallestDistance = maxDistance * maxDistance + 1,
+ item = null, foundPoint = false, i, j, ps;
+
+ for (i = series.length - 1; i >= 0; --i) {
+ if (!seriesFilter(series[i]))
+ continue;
+
+ var s = series[i],
+ axisx = s.xaxis,
+ axisy = s.yaxis,
+ points = s.datapoints.points,
+ mx = axisx.c2p(mouseX), // precompute some stuff to make the loop faster
+ my = axisy.c2p(mouseY),
+ maxx = maxDistance / axisx.scale,
+ maxy = maxDistance / axisy.scale;
+
+ ps = s.datapoints.pointsize;
+ // with inverse transforms, we can't use the maxx/maxy
+ // optimization, sadly
+ if (axisx.options.inverseTransform)
+ maxx = Number.MAX_VALUE;
+ if (axisy.options.inverseTransform)
+ maxy = Number.MAX_VALUE;
+
+ if (s.lines.show || s.points.show) {
+ for (j = 0; j < points.length; j += ps) {
+ var x = points[j], y = points[j + 1];
+ if (x == null)
+ continue;
+
+ // For points and lines, the cursor must be within a
+ // certain distance to the data point
+ if (x - mx > maxx || x - mx < -maxx ||
+ y - my > maxy || y - my < -maxy)
+ continue;
+
+ // We have to calculate distances in pixels, not in
+ // data units, because the scales of the axes may be different
+ var dx = Math.abs(axisx.p2c(x) - mouseX),
+ dy = Math.abs(axisy.p2c(y) - mouseY),
+ dist = dx * dx + dy * dy; // we save the sqrt
+
+ // use <= to ensure last point takes precedence
+ // (last generally means on top of)
+ if (dist < smallestDistance) {
+ smallestDistance = dist;
+ item = [i, j / ps];
+ }
+ }
+ }
+
+ if (s.bars.show && !item) { // no other point can be nearby
+
+ var barLeft, barRight;
+
+ switch (s.bars.align) {
+ case "left":
+ barLeft = 0;
+ break;
+ case "right":
+ barLeft = -s.bars.barWidth;
+ break;
+ default:
+ barLeft = -s.bars.barWidth / 2;
+ }
+
+ barRight = barLeft + s.bars.barWidth;
+
+ for (j = 0; j < points.length; j += ps) {
+ var x = points[j], y = points[j + 1], b = points[j + 2];
+ if (x == null)
+ continue;
+
+ // for a bar graph, the cursor must be inside the bar
+ if (series[i].bars.horizontal ?
+ (mx <= Math.max(b, x) && mx >= Math.min(b, x) &&
+ my >= y + barLeft && my <= y + barRight) :
+ (mx >= x + barLeft && mx <= x + barRight &&
+ my >= Math.min(b, y) && my <= Math.max(b, y)))
+ item = [i, j / ps];
+ }
+ }
+ }
+
+ if (item) {
+ i = item[0];
+ j = item[1];
+ ps = series[i].datapoints.pointsize;
+
+ return { datapoint: series[i].datapoints.points.slice(j * ps, (j + 1) * ps),
+ dataIndex: j,
+ series: series[i],
+ seriesIndex: i };
+ }
+
+ return null;
+ }
+
+ function onMouseMove(e) {
+ if (options.grid.hoverable)
+ triggerClickHoverEvent("plothover", e,
+ function (s) {
+ return s["hoverable"] != false;
+ });
+ }
+
+ function onMouseLeave(e) {
+ if (options.grid.hoverable)
+ triggerClickHoverEvent("plothover", e,
+ function (s) {
+ return false;
+ });
+ }
+
+ function onClick(e) {
+ triggerClickHoverEvent("plotclick", e,
+ function (s) {
+ return s["clickable"] != false;
+ });
+ }
+
+ // trigger click or hover event (they send the same parameters
+ // so we share their code)
+ function triggerClickHoverEvent(eventname, event, seriesFilter) {
+ var offset = eventHolder.offset(),
+ canvasX = event.pageX - offset.left - plotOffset.left,
+ canvasY = event.pageY - offset.top - plotOffset.top,
+ pos = canvasToAxisCoords({ left: canvasX, top: canvasY });
+
+ pos.pageX = event.pageX;
+ pos.pageY = event.pageY;
+
+ var item = findNearbyItem(canvasX, canvasY, seriesFilter);
+
+ if (item) {
+ // fill in mouse pos for any listeners out there
+ item.pageX = parseInt(item.series.xaxis.p2c(item.datapoint[0]) + offset.left + plotOffset.left, 10);
+ item.pageY = parseInt(item.series.yaxis.p2c(item.datapoint[1]) + offset.top + plotOffset.top, 10);
+ }
+
+ 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 &&
+ h.point[0] == item.datapoint[0] &&
+ h.point[1] == item.datapoint[1]))
+ unhighlight(h.series, h.point);
+ }
+
+ if (item)
+ highlight(item.series, item.datapoint, eventname);
+ }
+
+ placeholder.trigger(eventname, [ pos, item ]);
+ }
+
+ function triggerRedrawOverlay() {
+ var t = options.interaction.redrawOverlayInterval;
+ if (t == -1) { // skip event queue
+ drawOverlay();
+ return;
+ }
+
+ if (!redrawTimeout)
+ redrawTimeout = setTimeout(drawOverlay, t);
+ }
+
+ function drawOverlay() {
+ redrawTimeout = null;
+
+ // draw highlights
+ octx.save();
+ overlay.clear();
+ octx.translate(plotOffset.left, plotOffset.top);
+
+ var i, hi;
+ for (i = 0; i < highlights.length; ++i) {
+ hi = highlights[i];
+
+ if (hi.series.bars.show)
+ drawBarHighlight(hi.series, hi.point);
+ else
+ drawPointHighlight(hi.series, hi.point);
+ }
+ octx.restore();
+
+ executeHooks(hooks.drawOverlay, [octx]);
+ }
+
+ function highlight(s, point, auto) {
+ if (typeof s == "number")
+ s = series[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 });
+
+ triggerRedrawOverlay();
+ }
+ else if (!auto)
+ highlights[i].auto = false;
+ }
+
+ function unhighlight(s, point) {
+ if (s == null && point == null) {
+ highlights = [];
+ triggerRedrawOverlay();
+ return;
+ }
+
+ if (typeof s == "number")
+ s = series[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);
+
+ 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 drawPointHighlight(series, point) {
+ 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();
+ if (series.points.symbol == "circle")
+ octx.arc(x, y, radius, 0, 2 * Math.PI, false);
+ else
+ series.points.symbol(octx, x, y, radius, false);
+ octx.closePath();
+ octx.stroke();
+ }
+
+ function drawBarHighlight(series, point) {
+ var highlightColor = (typeof series.highlightColor === "string") ? series.highlightColor : $.color.parse(series.color).scale('a', 0.5).toString(),
+ fillStyle = highlightColor,
+ barLeft;
+
+ switch (series.bars.align) {
+ case "left":
+ barLeft = 0;
+ break;
+ case "right":
+ barLeft = -series.bars.barWidth;
+ break;
+ default:
+ barLeft = -series.bars.barWidth / 2;
+ }
+
+ octx.lineWidth = series.bars.lineWidth;
+ octx.strokeStyle = highlightColor;
+
+ drawBar(point[0], point[1], point[2] || 0, barLeft, barLeft + series.bars.barWidth,
+ function () {
+ return fillStyle;
+ }, series.xaxis, series.yaxis, octx, series.bars.horizontal, series.bars.lineWidth);
+ }
+
+ function getColorOrGradient(spec, bottom, top, defaultColor) {
+ if (typeof spec == "string")
+ return spec;
+ else {
+ // assume this is a gradient spec; IE currently only
+ // supports a simple vertical gradient properly, so that's
+ // what we support too
+ var gradient = ctx.createLinearGradient(0, top, 0, bottom);
+
+ for (var i = 0, l = spec.colors.length; i < l; ++i) {
+ var c = spec.colors[i];
+ if (typeof c != "string") {
+ var co = $.color.parse(defaultColor);
+ if (c.brightness != null)
+ co = co.scale('rgb', c.brightness);
+ if (c.opacity != null)
+ co.a *= c.opacity;
+ c = co.toString();
+ }
+ gradient.addColorStop(i / (l - 1), c);
+ }
+
+ return gradient;
+ }
+ }
+ }
+
+ // Add the plot function to the top level of the jQuery object
+
+ $.plot = function (placeholder, data, options) {
+ //var t0 = new Date();
+ var plot = new Plot($(placeholder), data, options, $.plot.plugins);
+ //(window.console ? console.log : alert)("time used (msecs): " + ((new Date()).getTime() - t0.getTime()));
+ return plot;
+ };
+
+ $.plot.version = "0.8.3";
+
+ $.plot.plugins = [];
+
+ // Also add the plot function as a chainable property
+
+ $.fn.plot = function (data, options) {
+ return this.each(function () {
+ $.plot(this, data, options);
+ });
+ };
+
+ // round to nearby lower multiple of base
+ function floorInBase(n, base) {
+ return base * Math.floor(n / base);
+ }
+
+})(jQuery);
diff --git a/src/main/resources/webapp/js/jquery.flot.pie.js b/src/main/resources/webapp/js/jquery.flot.pie.js
new file mode 100755
index 0000000..c421c51
--- /dev/null
+++ b/src/main/resources/webapp/js/jquery.flot.pie.js
@@ -0,0 +1,831 @@
+/* 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);
+ }
+ if (options.grid.clickable) {
+ eventHolder.unbind("click").click(onClick);
+ }
+ }
+ });
+
+ 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 = [];
+
+ // Fix up the raw data from Flot, ensuring the data is numeric
+
+ for (var i = 0; i < data.length; ++i) {
+
+ var 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 (var 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 (var i = 0; i < data.length; ++i) {
+ var value = data[i].data[0][1];
+ if (value / total <= options.series.pie.combine.threshold) {
+ combined += value;
+ numCombined++;
+ if (!color) {
+ color = data[i].color;
+ }
+ }
+ }
+
+ for (var i = 0; i < data.length; ++i) {
+ var 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("Could not draw pie with labels contained inside canvas
");
+ }
+
+ 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;
+
+ // 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 (var 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 (var 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 = "" + text + " ";
+ 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;";
+ $("
")
+ .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 "" + label + "
";
+ }, // 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);
diff --git a/src/main/resources/webapp/js/jquery.flot.resize.js b/src/main/resources/webapp/js/jquery.flot.resize.js
new file mode 100755
index 0000000..adcda57
--- /dev/null
+++ b/src/main/resources/webapp/js/jquery.flot.resize.js
@@ -0,0 +1,159 @@
+/* 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, this);
+
+(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);
diff --git a/src/main/resources/webapp/js/jquery.flot.time.js b/src/main/resources/webapp/js/jquery.flot.time.js
new file mode 100755
index 0000000..76d4b10
--- /dev/null
+++ b/src/main/resources/webapp/js/jquery.flot.time.js
@@ -0,0 +1,482 @@
+/* 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 ($) {
+
+ 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
+ }
+ };
+
+ // round to nearby lower multiple of base
+
+ function floorInBase(n, base) {
+ return base * Math.floor(n / base);
+ }
+
+ // 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 r = [];
+ var escape = false;
+ var hours = d.getHours();
+ var isAM = hours < 12;
+
+ if (monthNames == null) {
+ monthNames = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+ }
+
+ if (dayNames == null) {
+ 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;
+ }
+
+ for (var i = 0; i < fmt.length; ++i) {
+
+ var c = fmt.charAt(i);
+
+ 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 '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", "Milliseconds", "Minutes", "Month", "Seconds"];
+
+ 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) {
+ if (opts.timezone == "browser") {
+ return new Date(ts);
+ } else if (!opts.timezone || opts.timezone == "utc") {
+ return makeUtcWrapper(new Date(ts));
+ } else if (typeof timezoneJS != "undefined" && typeof timezoneJS.Date != "undefined") {
+ var d = new timezoneJS.Date();
+ // 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(new Date(ts));
+ }
+ }
+
+ // map of app. size of time units in milliseconds
+
+ var timeUnitSize = {
+ "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
+ };
+
+ // the allowed tick sizes, after 1 year we use
+ // an integer algorithm
+
+ var baseSpec = [
+ [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 init(plot) {
+ plot.hooks.processOptions.push(function (plot, options) {
+ $.each(plot.getAxes(), function (axisName, axis) {
+
+ var opts = axis.options;
+
+ if (opts.mode == "time") {
+ axis.tickGenerator = function (axis) {
+
+ var ticks = [];
+ var d = dateGenerator(axis.min, opts);
+ var 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;
+
+ if (opts.minTickSize != null) {
+ 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[1] == "year") {
+ size = Math.floor(opts.minTickSize[0]);
+ } else {
+
+ var magn = Math.pow(10, 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 == "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
+
+ 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 prev;
+
+ do {
+
+ prev = v;
+ v = d.getTime();
+ 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 {
+ d.setTime(v + step);
+ }
+ } while (v < axis.max && v != prev);
+
+ return ticks;
+ };
+
+ 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 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 fmt;
+
+ 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;
+
+})(jQuery);
diff --git a/src/main/resources/webapp/js/jquery.min.js b/src/main/resources/webapp/js/jquery.min.js
new file mode 100755
index 0000000..ec2b8be
--- /dev/null
+++ b/src/main/resources/webapp/js/jquery.min.js
@@ -0,0 +1,2058 @@
+/*! jQuery v2.1.3 | (c) 2005, 2014 jQuery Foundation, Inc. | jquery.org/license */
+!function (a, b) {
+ "object" == typeof module && "object" == typeof module.exports ? module.exports = a.document ? b(a, !0) : function (a) {
+ if (!a.document)throw new Error("jQuery requires a window with a document");
+ return b(a)
+ } : b(a)
+}("undefined" != typeof window ? window : this, function (a, b) {
+ var c = [], d = c.slice, e = c.concat, f = c.push, g = c.indexOf, h = {}, i = h.toString, j = h.hasOwnProperty, k = {}, l = a.document, m = "2.1.3", n = function (a, b) {
+ return new n.fn.init(a, b)
+ }, o = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, p = /^-ms-/, q = /-([\da-z])/gi, r = function (a, b) {
+ return b.toUpperCase()
+ };
+ n.fn = n.prototype = {jquery: m, constructor: n, selector: "", length: 0, toArray: function () {
+ return d.call(this)
+ }, get: function (a) {
+ return null != a ? 0 > a ? this[a + this.length] : this[a] : d.call(this)
+ }, pushStack: function (a) {
+ var b = n.merge(this.constructor(), a);
+ return b.prevObject = this, b.context = this.context, b
+ }, each: function (a, b) {
+ return n.each(this, a, b)
+ }, map: function (a) {
+ return this.pushStack(n.map(this, function (b, c) {
+ return a.call(b, c, b)
+ }))
+ }, slice: function () {
+ return this.pushStack(d.apply(this, arguments))
+ }, first: function () {
+ return this.eq(0)
+ }, last: function () {
+ return this.eq(-1)
+ }, eq: function (a) {
+ var b = this.length, c = +a + (0 > a ? b : 0);
+ return this.pushStack(c >= 0 && b > c ? [this[c]] : [])
+ }, end: function () {
+ return this.prevObject || this.constructor(null)
+ }, push: f, sort: c.sort, splice: c.splice}, n.extend = n.fn.extend = function () {
+ var a, b, c, d, e, f, g = arguments[0] || {}, h = 1, i = arguments.length, j = !1;
+ for ("boolean" == typeof g && (j = g, g = arguments[h] || {}, h++), "object" == typeof g || n.isFunction(g) || (g = {}), h === i && (g = this, h--); i > h; h++)if (null != (a = arguments[h]))for (b in a)c = g[b], d = a[b], g !== d && (j && d && (n.isPlainObject(d) || (e = n.isArray(d))) ? (e ? (e = !1, f = c && n.isArray(c) ? c : []) : f = c && n.isPlainObject(c) ? c : {}, g[b] = n.extend(j, f, d)) : void 0 !== d && (g[b] = d));
+ return g
+ }, n.extend({expando: "jQuery" + (m + Math.random()).replace(/\D/g, ""), isReady: !0, error: function (a) {
+ throw new Error(a)
+ }, noop: function () {
+ }, isFunction: function (a) {
+ return"function" === n.type(a)
+ }, isArray: Array.isArray, isWindow: function (a) {
+ return null != a && a === a.window
+ }, isNumeric: function (a) {
+ return!n.isArray(a) && a - parseFloat(a) + 1 >= 0
+ }, isPlainObject: function (a) {
+ return"object" !== n.type(a) || a.nodeType || n.isWindow(a) ? !1 : a.constructor && !j.call(a.constructor.prototype, "isPrototypeOf") ? !1 : !0
+ }, isEmptyObject: function (a) {
+ var b;
+ for (b in a)return!1;
+ return!0
+ }, type: function (a) {
+ return null == a ? a + "" : "object" == typeof a || "function" == typeof a ? h[i.call(a)] || "object" : typeof a
+ }, globalEval: function (a) {
+ var b, c = eval;
+ a = n.trim(a), a && (1 === a.indexOf("use strict") ? (b = l.createElement("script"), b.text = a, l.head.appendChild(b).parentNode.removeChild(b)) : c(a))
+ }, camelCase: function (a) {
+ return a.replace(p, "ms-").replace(q, r)
+ }, nodeName: function (a, b) {
+ return a.nodeName && a.nodeName.toLowerCase() === b.toLowerCase()
+ }, each: function (a, b, c) {
+ var d, e = 0, f = a.length, g = s(a);
+ if (c) {
+ if (g) {
+ for (; f > e; e++)if (d = b.apply(a[e], c), d === !1)break
+ } else for (e in a)if (d = b.apply(a[e], c), d === !1)break
+ } else if (g) {
+ for (; f > e; e++)if (d = b.call(a[e], e, a[e]), d === !1)break
+ } else for (e in a)if (d = b.call(a[e], e, a[e]), d === !1)break;
+ return a
+ }, trim: function (a) {
+ return null == a ? "" : (a + "").replace(o, "")
+ }, makeArray: function (a, b) {
+ var c = b || [];
+ return null != a && (s(Object(a)) ? n.merge(c, "string" == typeof a ? [a] : a) : f.call(c, a)), c
+ }, inArray: function (a, b, c) {
+ return null == b ? -1 : g.call(b, a, c)
+ }, merge: function (a, b) {
+ for (var c = +b.length, d = 0, e = a.length; c > d; d++)a[e++] = b[d];
+ return a.length = e, a
+ }, grep: function (a, b, c) {
+ for (var d, e = [], f = 0, g = a.length, h = !c; g > f; f++)d = !b(a[f], f), d !== h && e.push(a[f]);
+ return e
+ }, map: function (a, b, c) {
+ var d, f = 0, g = a.length, h = s(a), i = [];
+ if (h)for (; g > f; f++)d = b(a[f], f, c), null != d && i.push(d); else for (f in a)d = b(a[f], f, c), null != d && i.push(d);
+ return e.apply([], i)
+ }, guid: 1, proxy: function (a, b) {
+ var c, e, f;
+ return"string" == typeof b && (c = a[b], b = a, a = c), n.isFunction(a) ? (e = d.call(arguments, 2), f = function () {
+ return a.apply(b || this, e.concat(d.call(arguments)))
+ }, f.guid = a.guid = a.guid || n.guid++, f) : void 0
+ }, now: Date.now, support: k}), n.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function (a, b) {
+ h["[object " + b + "]"] = b.toLowerCase()
+ });
+ function s(a) {
+ var b = a.length, c = n.type(a);
+ return"function" === c || n.isWindow(a) ? !1 : 1 === a.nodeType && b ? !0 : "array" === c || 0 === b || "number" == typeof b && b > 0 && b - 1 in a
+ }
+
+ var t = function (a) {
+ var b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u = "sizzle" + 1 * new Date, v = a.document, w = 0, x = 0, y = hb(), z = hb(), A = hb(), B = function (a, b) {
+ return a === b && (l = !0), 0
+ }, C = 1 << 31, D = {}.hasOwnProperty, E = [], F = E.pop, G = E.push, H = E.push, I = E.slice, J = function (a, b) {
+ for (var c = 0, d = a.length; d > c; c++)if (a[c] === b)return c;
+ return-1
+ }, K = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", L = "[\\x20\\t\\r\\n\\f]", M = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", N = M.replace("w", "w#"), O = "\\[" + L + "*(" + M + ")(?:" + L + "*([*^$|!~]?=)" + L + "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + N + "))|)" + L + "*\\]", P = ":(" + M + ")(?:\\((('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|((?:\\\\.|[^\\\\()[\\]]|" + O + ")*)|.*)\\)|)", Q = new RegExp(L + "+", "g"), R = new RegExp("^" + L + "+|((?:^|[^\\\\])(?:\\\\.)*)" + L + "+$", "g"), S = new RegExp("^" + L + "*," + L + "*"), T = new RegExp("^" + L + "*([>+~]|" + L + ")" + L + "*"), U = new RegExp("=" + L + "*([^\\]'\"]*?)" + L + "*\\]", "g"), V = new RegExp(P), W = new RegExp("^" + N + "$"), X = {ID: new RegExp("^#(" + M + ")"), CLASS: new RegExp("^\\.(" + M + ")"), TAG: new RegExp("^(" + M.replace("w", "w*") + ")"), ATTR: new RegExp("^" + O), PSEUDO: new RegExp("^" + P), CHILD: new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + L + "*(even|odd|(([+-]|)(\\d*)n|)" + L + "*(?:([+-]|)" + L + "*(\\d+)|))" + L + "*\\)|)", "i"), bool: new RegExp("^(?:" + K + ")$", "i"), needsContext: new RegExp("^" + L + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + L + "*((?:-\\d)?\\d*)" + L + "*\\)|)(?=[^-]|$)", "i")}, Y = /^(?:input|select|textarea|button)$/i, Z = /^h\d$/i, $ = /^[^{]+\{\s*\[native \w/, _ = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, ab = /[+~]/, bb = /'|\\/g, cb = new RegExp("\\\\([\\da-f]{1,6}" + L + "?|(" + L + ")|.)", "ig"), db = function (a, b, c) {
+ var d = "0x" + b - 65536;
+ return d !== d || c ? b : 0 > d ? String.fromCharCode(d + 65536) : String.fromCharCode(d >> 10 | 55296, 1023 & d | 56320)
+ }, eb = function () {
+ m()
+ };
+ try {
+ H.apply(E = I.call(v.childNodes), v.childNodes), E[v.childNodes.length].nodeType
+ } catch (fb) {
+ H = {apply: E.length ? function (a, b) {
+ G.apply(a, I.call(b))
+ } : function (a, b) {
+ var c = a.length, d = 0;
+ while (a[c++] = b[d++]);
+ a.length = c - 1
+ }}
+ }
+ function gb(a, b, d, e) {
+ var f, h, j, k, l, o, r, s, w, x;
+ if ((b ? b.ownerDocument || b : v) !== n && m(b), b = b || n, d = d || [], k = b.nodeType, "string" != typeof a || !a || 1 !== k && 9 !== k && 11 !== k)return d;
+ if (!e && p) {
+ if (11 !== k && (f = _.exec(a)))if (j = f[1]) {
+ if (9 === k) {
+ if (h = b.getElementById(j), !h || !h.parentNode)return d;
+ if (h.id === j)return d.push(h), d
+ } else if (b.ownerDocument && (h = b.ownerDocument.getElementById(j)) && t(b, h) && h.id === j)return d.push(h), d
+ } else {
+ if (f[2])return H.apply(d, b.getElementsByTagName(a)), d;
+ if ((j = f[3]) && c.getElementsByClassName)return H.apply(d, b.getElementsByClassName(j)), d
+ }
+ if (c.qsa && (!q || !q.test(a))) {
+ if (s = r = u, w = b, x = 1 !== k && a, 1 === k && "object" !== b.nodeName.toLowerCase()) {
+ o = g(a), (r = b.getAttribute("id")) ? s = r.replace(bb, "\\$&") : b.setAttribute("id", s), s = "[id='" + s + "'] ", l = o.length;
+ while (l--)o[l] = s + rb(o[l]);
+ w = ab.test(a) && pb(b.parentNode) || b, x = o.join(",")
+ }
+ if (x)try {
+ return H.apply(d, w.querySelectorAll(x)), d
+ } catch (y) {
+ } finally {
+ r || b.removeAttribute("id")
+ }
+ }
+ }
+ return i(a.replace(R, "$1"), b, d, e)
+ }
+
+ function hb() {
+ var a = [];
+
+ function b(c, e) {
+ return a.push(c + " ") > d.cacheLength && delete b[a.shift()], b[c + " "] = e
+ }
+
+ return b
+ }
+
+ function ib(a) {
+ return a[u] = !0, a
+ }
+
+ function jb(a) {
+ var b = n.createElement("div");
+ try {
+ return!!a(b)
+ } catch (c) {
+ return!1
+ } finally {
+ b.parentNode && b.parentNode.removeChild(b), b = null
+ }
+ }
+
+ function kb(a, b) {
+ var c = a.split("|"), e = a.length;
+ while (e--)d.attrHandle[c[e]] = b
+ }
+
+ function lb(a, b) {
+ var c = b && a, d = c && 1 === a.nodeType && 1 === b.nodeType && (~b.sourceIndex || C) - (~a.sourceIndex || C);
+ if (d)return d;
+ if (c)while (c = c.nextSibling)if (c === b)return-1;
+ return a ? 1 : -1
+ }
+
+ function mb(a) {
+ return function (b) {
+ var c = b.nodeName.toLowerCase();
+ return"input" === c && b.type === a
+ }
+ }
+
+ function nb(a) {
+ return function (b) {
+ var c = b.nodeName.toLowerCase();
+ return("input" === c || "button" === c) && b.type === a
+ }
+ }
+
+ function ob(a) {
+ return ib(function (b) {
+ return b = +b, ib(function (c, d) {
+ var e, f = a([], c.length, b), g = f.length;
+ while (g--)c[e = f[g]] && (c[e] = !(d[e] = c[e]))
+ })
+ })
+ }
+
+ function pb(a) {
+ return a && "undefined" != typeof a.getElementsByTagName && a
+ }
+
+ c = gb.support = {}, f = gb.isXML = function (a) {
+ var b = a && (a.ownerDocument || a).documentElement;
+ return b ? "HTML" !== b.nodeName : !1
+ }, m = gb.setDocument = function (a) {
+ var b, e, g = a ? a.ownerDocument || a : v;
+ return g !== n && 9 === g.nodeType && g.documentElement ? (n = g, o = g.documentElement, e = g.defaultView, e && e !== e.top && (e.addEventListener ? e.addEventListener("unload", eb, !1) : e.attachEvent && e.attachEvent("onunload", eb)), p = !f(g), c.attributes = jb(function (a) {
+ return a.className = "i", !a.getAttribute("className")
+ }), c.getElementsByTagName = jb(function (a) {
+ return a.appendChild(g.createComment("")), !a.getElementsByTagName("*").length
+ }), c.getElementsByClassName = $.test(g.getElementsByClassName), c.getById = jb(function (a) {
+ return o.appendChild(a).id = u, !g.getElementsByName || !g.getElementsByName(u).length
+ }), c.getById ? (d.find.ID = function (a, b) {
+ if ("undefined" != typeof b.getElementById && p) {
+ var c = b.getElementById(a);
+ return c && c.parentNode ? [c] : []
+ }
+ }, d.filter.ID = function (a) {
+ var b = a.replace(cb, db);
+ return function (a) {
+ return a.getAttribute("id") === b
+ }
+ }) : (delete d.find.ID, d.filter.ID = function (a) {
+ var b = a.replace(cb, db);
+ return function (a) {
+ var c = "undefined" != typeof a.getAttributeNode && a.getAttributeNode("id");
+ return c && c.value === b
+ }
+ }), d.find.TAG = c.getElementsByTagName ? function (a, b) {
+ return"undefined" != typeof b.getElementsByTagName ? b.getElementsByTagName(a) : c.qsa ? b.querySelectorAll(a) : void 0
+ } : function (a, b) {
+ var c, d = [], e = 0, f = b.getElementsByTagName(a);
+ if ("*" === a) {
+ while (c = f[e++])1 === c.nodeType && d.push(c);
+ return d
+ }
+ return f
+ }, d.find.CLASS = c.getElementsByClassName && function (a, b) {
+ return p ? b.getElementsByClassName(a) : void 0
+ }, r = [], q = [], (c.qsa = $.test(g.querySelectorAll)) && (jb(function (a) {
+ o.appendChild(a).innerHTML = "", " "], thead: [1, ""], col: [2, ""], tr: [2, ""], td: [3, ""], _default: [0, "", ""]};
+ ib.optgroup = ib.option, ib.tbody = ib.tfoot = ib.colgroup = ib.caption = ib.thead, ib.th = ib.td;
+ function jb(a, b) {
+ return n.nodeName(a, "table") && n.nodeName(11 !== b.nodeType ? b : b.firstChild, "tr") ? a.getElementsByTagName("tbody")[0] || a.appendChild(a.ownerDocument.createElement("tbody")) : a
+ }
+
+ function kb(a) {
+ return a.type = (null !== a.getAttribute("type")) + "/" + a.type, a
+ }
+
+ function lb(a) {
+ var b = gb.exec(a.type);
+ return b ? a.type = b[1] : a.removeAttribute("type"), a
+ }
+
+ function mb(a, b) {
+ for (var c = 0, d = a.length; d > c; c++)L.set(a[c], "globalEval", !b || L.get(b[c], "globalEval"))
+ }
+
+ function nb(a, b) {
+ var c, d, e, f, g, h, i, j;
+ if (1 === b.nodeType) {
+ if (L.hasData(a) && (f = L.access(a), g = L.set(b, f), j = f.events)) {
+ delete g.handle, g.events = {};
+ for (e in j)for (c = 0, d = j[e].length; d > c; c++)n.event.add(b, e, j[e][c])
+ }
+ M.hasData(a) && (h = M.access(a), i = n.extend({}, h), M.set(b, i))
+ }
+ }
+
+ function ob(a, b) {
+ var c = a.getElementsByTagName ? a.getElementsByTagName(b || "*") : a.querySelectorAll ? a.querySelectorAll(b || "*") : [];
+ return void 0 === b || b && n.nodeName(a, b) ? n.merge([a], c) : c
+ }
+
+ function pb(a, b) {
+ var c = b.nodeName.toLowerCase();
+ "input" === c && T.test(a.type) ? b.checked = a.checked : ("input" === c || "textarea" === c) && (b.defaultValue = a.defaultValue)
+ }
+
+ n.extend({clone: function (a, b, c) {
+ var d, e, f, g, h = a.cloneNode(!0), i = n.contains(a.ownerDocument, a);
+ if (!(k.noCloneChecked || 1 !== a.nodeType && 11 !== a.nodeType || n.isXMLDoc(a)))for (g = ob(h), f = ob(a), d = 0, e = f.length; e > d; d++)pb(f[d], g[d]);
+ if (b)if (c)for (f = f || ob(a), g = g || ob(h), d = 0, e = f.length; e > d; d++)nb(f[d], g[d]); else nb(a, h);
+ return g = ob(h, "script"), g.length > 0 && mb(g, !i && ob(a, "script")), h
+ }, buildFragment: function (a, b, c, d) {
+ for (var e, f, g, h, i, j, k = b.createDocumentFragment(), l = [], m = 0, o = a.length; o > m; m++)if (e = a[m], e || 0 === e)if ("object" === n.type(e))n.merge(l, e.nodeType ? [e] : e); else if (cb.test(e)) {
+ f = f || k.appendChild(b.createElement("div")), g = (bb.exec(e) || ["", ""])[1].toLowerCase(), h = ib[g] || ib._default, f.innerHTML = h[1] + e.replace(ab, "<$1>") + h[2], j = h[0];
+ while (j--)f = f.lastChild;
+ n.merge(l, f.childNodes), f = k.firstChild, f.textContent = ""
+ } else l.push(b.createTextNode(e));
+ k.textContent = "", m = 0;
+ while (e = l[m++])if ((!d || -1 === n.inArray(e, d)) && (i = n.contains(e.ownerDocument, e), f = ob(k.appendChild(e), "script"), i && mb(f), c)) {
+ j = 0;
+ while (e = f[j++])fb.test(e.type || "") && c.push(e)
+ }
+ return k
+ }, cleanData: function (a) {
+ for (var b, c, d, e, f = n.event.special, g = 0; void 0 !== (c = a[g]); g++) {
+ if (n.acceptData(c) && (e = c[L.expando], e && (b = L.cache[e]))) {
+ if (b.events)for (d in b.events)f[d] ? n.event.remove(c, d) : n.removeEvent(c, d, b.handle);
+ L.cache[e] && delete L.cache[e]
+ }
+ delete M.cache[c[M.expando]]
+ }
+ }}), n.fn.extend({text: function (a) {
+ return J(this, function (a) {
+ return void 0 === a ? n.text(this) : this.empty().each(function () {
+ (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) && (this.textContent = a)
+ })
+ }, null, a, arguments.length)
+ }, append: function () {
+ return this.domManip(arguments, function (a) {
+ if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
+ var b = jb(this, a);
+ b.appendChild(a)
+ }
+ })
+ }, prepend: function () {
+ return this.domManip(arguments, function (a) {
+ if (1 === this.nodeType || 11 === this.nodeType || 9 === this.nodeType) {
+ var b = jb(this, a);
+ b.insertBefore(a, b.firstChild)
+ }
+ })
+ }, before: function () {
+ return this.domManip(arguments, function (a) {
+ this.parentNode && this.parentNode.insertBefore(a, this)
+ })
+ }, after: function () {
+ return this.domManip(arguments, function (a) {
+ this.parentNode && this.parentNode.insertBefore(a, this.nextSibling)
+ })
+ }, remove: function (a, b) {
+ for (var c, d = a ? n.filter(a, this) : this, e = 0; null != (c = d[e]); e++)b || 1 !== c.nodeType || n.cleanData(ob(c)), c.parentNode && (b && n.contains(c.ownerDocument, c) && mb(ob(c, "script")), c.parentNode.removeChild(c));
+ return this
+ }, empty: function () {
+ for (var a, b = 0; null != (a = this[b]); b++)1 === a.nodeType && (n.cleanData(ob(a, !1)), a.textContent = "");
+ return this
+ }, clone: function (a, b) {
+ return a = null == a ? !1 : a, b = null == b ? a : b, this.map(function () {
+ return n.clone(this, a, b)
+ })
+ }, html: function (a) {
+ return J(this, function (a) {
+ var b = this[0] || {}, c = 0, d = this.length;
+ if (void 0 === a && 1 === b.nodeType)return b.innerHTML;
+ if ("string" == typeof a && !db.test(a) && !ib[(bb.exec(a) || ["", ""])[1].toLowerCase()]) {
+ a = a.replace(ab, "<$1>");
+ try {
+ for (; d > c; c++)b = this[c] || {}, 1 === b.nodeType && (n.cleanData(ob(b, !1)), b.innerHTML = a);
+ b = 0
+ } catch (e) {
+ }
+ }
+ b && this.empty().append(a)
+ }, null, a, arguments.length)
+ }, replaceWith: function () {
+ var a = arguments[0];
+ return this.domManip(arguments, function (b) {
+ a = this.parentNode, n.cleanData(ob(this)), a && a.replaceChild(b, this)
+ }), a && (a.length || a.nodeType) ? this : this.remove()
+ }, detach: function (a) {
+ return this.remove(a, !0)
+ }, domManip: function (a, b) {
+ a = e.apply([], a);
+ var c, d, f, g, h, i, j = 0, l = this.length, m = this, o = l - 1, p = a[0], q = n.isFunction(p);
+ if (q || l > 1 && "string" == typeof p && !k.checkClone && eb.test(p))return this.each(function (c) {
+ var d = m.eq(c);
+ q && (a[0] = p.call(this, c, d.html())), d.domManip(a, b)
+ });
+ if (l && (c = n.buildFragment(a, this[0].ownerDocument, !1, this), d = c.firstChild, 1 === c.childNodes.length && (c = d), d)) {
+ for (f = n.map(ob(c, "script"), kb), g = f.length; l > j; j++)h = c, j !== o && (h = n.clone(h, !0, !0), g && n.merge(f, ob(h, "script"))), b.call(this[j], h, j);
+ if (g)for (i = f[f.length - 1].ownerDocument, n.map(f, lb), j = 0; g > j; j++)h = f[j], fb.test(h.type || "") && !L.access(h, "globalEval") && n.contains(i, h) && (h.src ? n._evalUrl && n._evalUrl(h.src) : n.globalEval(h.textContent.replace(hb, "")))
+ }
+ return this
+ }}), n.each({appendTo: "append", prependTo: "prepend", insertBefore: "before", insertAfter: "after", replaceAll: "replaceWith"}, function (a, b) {
+ n.fn[a] = function (a) {
+ for (var c, d = [], e = n(a), g = e.length - 1, h = 0; g >= h; h++)c = h === g ? this : this.clone(!0), n(e[h])[b](c), f.apply(d, c.get());
+ return this.pushStack(d)
+ }
+ });
+ var qb, rb = {};
+
+ function sb(b, c) {
+ var d, e = n(c.createElement(b)).appendTo(c.body), f = a.getDefaultComputedStyle && (d = a.getDefaultComputedStyle(e[0])) ? d.display : n.css(e[0], "display");
+ return e.detach(), f
+ }
+
+ function tb(a) {
+ var b = l, c = rb[a];
+ return c || (c = sb(a, b), "none" !== c && c || (qb = (qb || n("")).appendTo(b.documentElement), b = qb[0].contentDocument, b.write(), b.close(), c = sb(a, b), qb.detach()), rb[a] = c), c
+ }
+
+ var ub = /^margin/, vb = new RegExp("^(" + Q + ")(?!px)[a-z%]+$", "i"), wb = function (b) {
+ return b.ownerDocument.defaultView.opener ? b.ownerDocument.defaultView.getComputedStyle(b, null) : a.getComputedStyle(b, null)
+ };
+
+ function xb(a, b, c) {
+ var d, e, f, g, h = a.style;
+ return c = c || wb(a), c && (g = c.getPropertyValue(b) || c[b]), c && ("" !== g || n.contains(a.ownerDocument, a) || (g = n.style(a, b)), vb.test(g) && ub.test(b) && (d = h.width, e = h.minWidth, f = h.maxWidth, h.minWidth = h.maxWidth = h.width = g, g = c.width, h.width = d, h.minWidth = e, h.maxWidth = f)), void 0 !== g ? g + "" : g
+ }
+
+ function yb(a, b) {
+ return{get: function () {
+ return a() ? void delete this.get : (this.get = b).apply(this, arguments)
+ }}
+ }
+
+ !function () {
+ var b, c, d = l.documentElement, e = l.createElement("div"), f = l.createElement("div");
+ if (f.style) {
+ f.style.backgroundClip = "content-box", f.cloneNode(!0).style.backgroundClip = "", k.clearCloneStyle = "content-box" === f.style.backgroundClip, e.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;position:absolute", e.appendChild(f);
+ function g() {
+ f.style.cssText = "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;display:block;margin-top:1%;top:1%;border:1px;padding:1px;width:4px;position:absolute", f.innerHTML = "", d.appendChild(e);
+ var g = a.getComputedStyle(f, null);
+ b = "1%" !== g.top, c = "4px" === g.width, d.removeChild(e)
+ }
+
+ a.getComputedStyle && n.extend(k, {pixelPosition: function () {
+ return g(), b
+ }, boxSizingReliable: function () {
+ return null == c && g(), c
+ }, reliableMarginRight: function () {
+ var b, c = f.appendChild(l.createElement("div"));
+ return c.style.cssText = f.style.cssText = "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;display:block;margin:0;border:0;padding:0", c.style.marginRight = c.style.width = "0", f.style.width = "1px", d.appendChild(e), b = !parseFloat(a.getComputedStyle(c, null).marginRight), d.removeChild(e), f.removeChild(c), b
+ }})
+ }
+ }(), n.swap = function (a, b, c, d) {
+ var e, f, g = {};
+ for (f in b)g[f] = a.style[f], a.style[f] = b[f];
+ e = c.apply(a, d || []);
+ for (f in b)a.style[f] = g[f];
+ return e
+ };
+ var zb = /^(none|table(?!-c[ea]).+)/, Ab = new RegExp("^(" + Q + ")(.*)$", "i"), Bb = new RegExp("^([+-])=(" + Q + ")", "i"), Cb = {position: "absolute", visibility: "hidden", display: "block"}, Db = {letterSpacing: "0", fontWeight: "400"}, Eb = ["Webkit", "O", "Moz", "ms"];
+
+ function Fb(a, b) {
+ if (b in a)return b;
+ var c = b[0].toUpperCase() + b.slice(1), d = b, e = Eb.length;
+ while (e--)if (b = Eb[e] + c, b in a)return b;
+ return d
+ }
+
+ function Gb(a, b, c) {
+ var d = Ab.exec(b);
+ return d ? Math.max(0, d[1] - (c || 0)) + (d[2] || "px") : b
+ }
+
+ function Hb(a, b, c, d, e) {
+ for (var f = c === (d ? "border" : "content") ? 4 : "width" === b ? 1 : 0, g = 0; 4 > f; f += 2)"margin" === c && (g += n.css(a, c + R[f], !0, e)), d ? ("content" === c && (g -= n.css(a, "padding" + R[f], !0, e)), "margin" !== c && (g -= n.css(a, "border" + R[f] + "Width", !0, e))) : (g += n.css(a, "padding" + R[f], !0, e), "padding" !== c && (g += n.css(a, "border" + R[f] + "Width", !0, e)));
+ return g
+ }
+
+ function Ib(a, b, c) {
+ var d = !0, e = "width" === b ? a.offsetWidth : a.offsetHeight, f = wb(a), g = "border-box" === n.css(a, "boxSizing", !1, f);
+ if (0 >= e || null == e) {
+ if (e = xb(a, b, f), (0 > e || null == e) && (e = a.style[b]), vb.test(e))return e;
+ d = g && (k.boxSizingReliable() || e === a.style[b]), e = parseFloat(e) || 0
+ }
+ return e + Hb(a, b, c || (g ? "border" : "content"), d, f) + "px"
+ }
+
+ function Jb(a, b) {
+ for (var c, d, e, f = [], g = 0, h = a.length; h > g; g++)d = a[g], d.style && (f[g] = L.get(d, "olddisplay"), c = d.style.display, b ? (f[g] || "none" !== c || (d.style.display = ""), "" === d.style.display && S(d) && (f[g] = L.access(d, "olddisplay", tb(d.nodeName)))) : (e = S(d), "none" === c && e || L.set(d, "olddisplay", e ? c : n.css(d, "display"))));
+ for (g = 0; h > g; g++)d = a[g], d.style && (b && "none" !== d.style.display && "" !== d.style.display || (d.style.display = b ? f[g] || "" : "none"));
+ return a
+ }
+
+ n.extend({cssHooks: {opacity: {get: function (a, b) {
+ if (b) {
+ var c = xb(a, "opacity");
+ return"" === c ? "1" : c
+ }
+ }}}, cssNumber: {columnCount: !0, fillOpacity: !0, flexGrow: !0, flexShrink: !0, fontWeight: !0, lineHeight: !0, opacity: !0, order: !0, orphans: !0, widows: !0, zIndex: !0, zoom: !0}, cssProps: {"float": "cssFloat"}, style: function (a, b, c, d) {
+ if (a && 3 !== a.nodeType && 8 !== a.nodeType && a.style) {
+ var e, f, g, h = n.camelCase(b), i = a.style;
+ return b = n.cssProps[h] || (n.cssProps[h] = Fb(i, h)), g = n.cssHooks[b] || n.cssHooks[h], void 0 === c ? g && "get"in g && void 0 !== (e = g.get(a, !1, d)) ? e : i[b] : (f = typeof c, "string" === f && (e = Bb.exec(c)) && (c = (e[1] + 1) * e[2] + parseFloat(n.css(a, b)), f = "number"), null != c && c === c && ("number" !== f || n.cssNumber[h] || (c += "px"), k.clearCloneStyle || "" !== c || 0 !== b.indexOf("background") || (i[b] = "inherit"), g && "set"in g && void 0 === (c = g.set(a, c, d)) || (i[b] = c)), void 0)
+ }
+ }, css: function (a, b, c, d) {
+ var e, f, g, h = n.camelCase(b);
+ return b = n.cssProps[h] || (n.cssProps[h] = Fb(a.style, h)), g = n.cssHooks[b] || n.cssHooks[h], g && "get"in g && (e = g.get(a, !0, c)), void 0 === e && (e = xb(a, b, d)), "normal" === e && b in Db && (e = Db[b]), "" === c || c ? (f = parseFloat(e), c === !0 || n.isNumeric(f) ? f || 0 : e) : e
+ }}), n.each(["height", "width"], function (a, b) {
+ n.cssHooks[b] = {get: function (a, c, d) {
+ return c ? zb.test(n.css(a, "display")) && 0 === a.offsetWidth ? n.swap(a, Cb, function () {
+ return Ib(a, b, d)
+ }) : Ib(a, b, d) : void 0
+ }, set: function (a, c, d) {
+ var e = d && wb(a);
+ return Gb(a, c, d ? Hb(a, b, d, "border-box" === n.css(a, "boxSizing", !1, e), e) : 0)
+ }}
+ }), n.cssHooks.marginRight = yb(k.reliableMarginRight, function (a, b) {
+ return b ? n.swap(a, {display: "inline-block"}, xb, [a, "marginRight"]) : void 0
+ }), n.each({margin: "", padding: "", border: "Width"}, function (a, b) {
+ n.cssHooks[a + b] = {expand: function (c) {
+ for (var d = 0, e = {}, f = "string" == typeof c ? c.split(" ") : [c]; 4 > d; d++)e[a + R[d] + b] = f[d] || f[d - 2] || f[0];
+ return e
+ }}, ub.test(a) || (n.cssHooks[a + b].set = Gb)
+ }), n.fn.extend({css: function (a, b) {
+ return J(this, function (a, b, c) {
+ var d, e, f = {}, g = 0;
+ if (n.isArray(b)) {
+ for (d = wb(a), e = b.length; e > g; g++)f[b[g]] = n.css(a, b[g], !1, d);
+ return f
+ }
+ return void 0 !== c ? n.style(a, b, c) : n.css(a, b)
+ }, a, b, arguments.length > 1)
+ }, show: function () {
+ return Jb(this, !0)
+ }, hide: function () {
+ return Jb(this)
+ }, toggle: function (a) {
+ return"boolean" == typeof a ? a ? this.show() : this.hide() : this.each(function () {
+ S(this) ? n(this).show() : n(this).hide()
+ })
+ }});
+ function Kb(a, b, c, d, e) {
+ return new Kb.prototype.init(a, b, c, d, e)
+ }
+
+ n.Tween = Kb, Kb.prototype = {constructor: Kb, init: function (a, b, c, d, e, f) {
+ this.elem = a, this.prop = c, this.easing = e || "swing", this.options = b, this.start = this.now = this.cur(), this.end = d, this.unit = f || (n.cssNumber[c] ? "" : "px")
+ }, cur: function () {
+ var a = Kb.propHooks[this.prop];
+ return a && a.get ? a.get(this) : Kb.propHooks._default.get(this)
+ }, run: function (a) {
+ var b, c = Kb.propHooks[this.prop];
+ return this.pos = b = this.options.duration ? n.easing[this.easing](a, this.options.duration * a, 0, 1, this.options.duration) : a, this.now = (this.end - this.start) * b + this.start, this.options.step && this.options.step.call(this.elem, this.now, this), c && c.set ? c.set(this) : Kb.propHooks._default.set(this), this
+ }}, Kb.prototype.init.prototype = Kb.prototype, Kb.propHooks = {_default: {get: function (a) {
+ var b;
+ return null == a.elem[a.prop] || a.elem.style && null != a.elem.style[a.prop] ? (b = n.css(a.elem, a.prop, ""), b && "auto" !== b ? b : 0) : a.elem[a.prop]
+ }, set: function (a) {
+ n.fx.step[a.prop] ? n.fx.step[a.prop](a) : a.elem.style && (null != a.elem.style[n.cssProps[a.prop]] || n.cssHooks[a.prop]) ? n.style(a.elem, a.prop, a.now + a.unit) : a.elem[a.prop] = a.now
+ }}}, Kb.propHooks.scrollTop = Kb.propHooks.scrollLeft = {set: function (a) {
+ a.elem.nodeType && a.elem.parentNode && (a.elem[a.prop] = a.now)
+ }}, n.easing = {linear: function (a) {
+ return a
+ }, swing: function (a) {
+ return.5 - Math.cos(a * Math.PI) / 2
+ }}, n.fx = Kb.prototype.init, n.fx.step = {};
+ var Lb, Mb, Nb = /^(?:toggle|show|hide)$/, Ob = new RegExp("^(?:([+-])=|)(" + Q + ")([a-z%]*)$", "i"), Pb = /queueHooks$/, Qb = [Vb], Rb = {"*": [function (a, b) {
+ var c = this.createTween(a, b), d = c.cur(), e = Ob.exec(b), f = e && e[3] || (n.cssNumber[a] ? "" : "px"), g = (n.cssNumber[a] || "px" !== f && +d) && Ob.exec(n.css(c.elem, a)), h = 1, i = 20;
+ if (g && g[3] !== f) {
+ f = f || g[3], e = e || [], g = +d || 1;
+ do h = h || ".5", g /= h, n.style(c.elem, a, g + f); while (h !== (h = c.cur() / d) && 1 !== h && --i)
+ }
+ return e && (g = c.start = +g || +d || 0, c.unit = f, c.end = e[1] ? g + (e[1] + 1) * e[2] : +e[2]), c
+ }]};
+
+ function Sb() {
+ return setTimeout(function () {
+ Lb = void 0
+ }), Lb = n.now()
+ }
+
+ function Tb(a, b) {
+ var c, d = 0, e = {height: a};
+ for (b = b ? 1 : 0; 4 > d; d += 2 - b)c = R[d], e["margin" + c] = e["padding" + c] = a;
+ return b && (e.opacity = e.width = a), e
+ }
+
+ function Ub(a, b, c) {
+ for (var d, e = (Rb[b] || []).concat(Rb["*"]), f = 0, g = e.length; g > f; f++)if (d = e[f].call(c, b, a))return d
+ }
+
+ function Vb(a, b, c) {
+ var d, e, f, g, h, i, j, k, l = this, m = {}, o = a.style, p = a.nodeType && S(a), q = L.get(a, "fxshow");
+ c.queue || (h = n._queueHooks(a, "fx"), null == h.unqueued && (h.unqueued = 0, i = h.empty.fire, h.empty.fire = function () {
+ h.unqueued || i()
+ }), h.unqueued++, l.always(function () {
+ l.always(function () {
+ h.unqueued--, n.queue(a, "fx").length || h.empty.fire()
+ })
+ })), 1 === a.nodeType && ("height"in b || "width"in b) && (c.overflow = [o.overflow, o.overflowX, o.overflowY], j = n.css(a, "display"), k = "none" === j ? L.get(a, "olddisplay") || tb(a.nodeName) : j, "inline" === k && "none" === n.css(a, "float") && (o.display = "inline-block")), c.overflow && (o.overflow = "hidden", l.always(function () {
+ o.overflow = c.overflow[0], o.overflowX = c.overflow[1], o.overflowY = c.overflow[2]
+ }));
+ for (d in b)if (e = b[d], Nb.exec(e)) {
+ if (delete b[d], f = f || "toggle" === e, e === (p ? "hide" : "show")) {
+ if ("show" !== e || !q || void 0 === q[d])continue;
+ p = !0
+ }
+ m[d] = q && q[d] || n.style(a, d)
+ } else j = void 0;
+ if (n.isEmptyObject(m))"inline" === ("none" === j ? tb(a.nodeName) : j) && (o.display = j); else {
+ q ? "hidden"in q && (p = q.hidden) : q = L.access(a, "fxshow", {}), f && (q.hidden = !p), p ? n(a).show() : l.done(function () {
+ n(a).hide()
+ }), l.done(function () {
+ var b;
+ L.remove(a, "fxshow");
+ for (b in m)n.style(a, b, m[b])
+ });
+ for (d in m)g = Ub(p ? q[d] : 0, d, l), d in q || (q[d] = g.start, p && (g.end = g.start, g.start = "width" === d || "height" === d ? 1 : 0))
+ }
+ }
+
+ function Wb(a, b) {
+ var c, d, e, f, g;
+ for (c in a)if (d = n.camelCase(c), e = b[d], f = a[c], n.isArray(f) && (e = f[1], f = a[c] = f[0]), c !== d && (a[d] = f, delete a[c]), g = n.cssHooks[d], g && "expand"in g) {
+ f = g.expand(f), delete a[d];
+ for (c in f)c in a || (a[c] = f[c], b[c] = e)
+ } else b[d] = e
+ }
+
+ function Xb(a, b, c) {
+ var d, e, f = 0, g = Qb.length, h = n.Deferred().always(function () {
+ delete i.elem
+ }), i = function () {
+ if (e)return!1;
+ for (var b = Lb || Sb(), c = Math.max(0, j.startTime + j.duration - b), d = c / j.duration || 0, f = 1 - d, g = 0, i = j.tweens.length; i > g; g++)j.tweens[g].run(f);
+ return h.notifyWith(a, [j, f, c]), 1 > f && i ? c : (h.resolveWith(a, [j]), !1)
+ }, j = h.promise({elem: a, props: n.extend({}, b), opts: n.extend(!0, {specialEasing: {}}, c), originalProperties: b, originalOptions: c, startTime: Lb || Sb(), duration: c.duration, tweens: [], createTween: function (b, c) {
+ var d = n.Tween(a, j.opts, b, c, j.opts.specialEasing[b] || j.opts.easing);
+ return j.tweens.push(d), d
+ }, stop: function (b) {
+ var c = 0, d = b ? j.tweens.length : 0;
+ if (e)return this;
+ for (e = !0; d > c; c++)j.tweens[c].run(1);
+ return b ? h.resolveWith(a, [j, b]) : h.rejectWith(a, [j, b]), this
+ }}), k = j.props;
+ for (Wb(k, j.opts.specialEasing); g > f; f++)if (d = Qb[f].call(j, a, k, j.opts))return d;
+ return n.map(k, Ub, j), n.isFunction(j.opts.start) && j.opts.start.call(a, j), n.fx.timer(n.extend(i, {elem: a, anim: j, queue: j.opts.queue})), j.progress(j.opts.progress).done(j.opts.done, j.opts.complete).fail(j.opts.fail).always(j.opts.always)
+ }
+
+ n.Animation = n.extend(Xb, {tweener: function (a, b) {
+ n.isFunction(a) ? (b = a, a = ["*"]) : a = a.split(" ");
+ for (var c, d = 0, e = a.length; e > d; d++)c = a[d], Rb[c] = Rb[c] || [], Rb[c].unshift(b)
+ }, prefilter: function (a, b) {
+ b ? Qb.unshift(a) : Qb.push(a)
+ }}), n.speed = function (a, b, c) {
+ var d = a && "object" == typeof a ? n.extend({}, a) : {complete: c || !c && b || n.isFunction(a) && a, duration: a, easing: c && b || b && !n.isFunction(b) && b};
+ return d.duration = n.fx.off ? 0 : "number" == typeof d.duration ? d.duration : d.duration in n.fx.speeds ? n.fx.speeds[d.duration] : n.fx.speeds._default, (null == d.queue || d.queue === !0) && (d.queue = "fx"), d.old = d.complete, d.complete = function () {
+ n.isFunction(d.old) && d.old.call(this), d.queue && n.dequeue(this, d.queue)
+ }, d
+ }, n.fn.extend({fadeTo: function (a, b, c, d) {
+ return this.filter(S).css("opacity", 0).show().end().animate({opacity: b}, a, c, d)
+ }, animate: function (a, b, c, d) {
+ var e = n.isEmptyObject(a), f = n.speed(b, c, d), g = function () {
+ var b = Xb(this, n.extend({}, a), f);
+ (e || L.get(this, "finish")) && b.stop(!0)
+ };
+ return g.finish = g, e || f.queue === !1 ? this.each(g) : this.queue(f.queue, g)
+ }, stop: function (a, b, c) {
+ var d = function (a) {
+ var b = a.stop;
+ delete a.stop, b(c)
+ };
+ return"string" != typeof a && (c = b, b = a, a = void 0), b && a !== !1 && this.queue(a || "fx", []), this.each(function () {
+ var b = !0, e = null != a && a + "queueHooks", f = n.timers, g = L.get(this);
+ if (e)g[e] && g[e].stop && d(g[e]); else for (e in g)g[e] && g[e].stop && Pb.test(e) && d(g[e]);
+ for (e = f.length; e--;)f[e].elem !== this || null != a && f[e].queue !== a || (f[e].anim.stop(c), b = !1, f.splice(e, 1));
+ (b || !c) && n.dequeue(this, a)
+ })
+ }, finish: function (a) {
+ return a !== !1 && (a = a || "fx"), this.each(function () {
+ var b, c = L.get(this), d = c[a + "queue"], e = c[a + "queueHooks"], f = n.timers, g = d ? d.length : 0;
+ for (c.finish = !0, n.queue(this, a, []), e && e.stop && e.stop.call(this, !0), b = f.length; b--;)f[b].elem === this && f[b].queue === a && (f[b].anim.stop(!0), f.splice(b, 1));
+ for (b = 0; g > b; b++)d[b] && d[b].finish && d[b].finish.call(this);
+ delete c.finish
+ })
+ }}), n.each(["toggle", "show", "hide"], function (a, b) {
+ var c = n.fn[b];
+ n.fn[b] = function (a, d, e) {
+ return null == a || "boolean" == typeof a ? c.apply(this, arguments) : this.animate(Tb(b, !0), a, d, e)
+ }
+ }), n.each({slideDown: Tb("show"), slideUp: Tb("hide"), slideToggle: Tb("toggle"), fadeIn: {opacity: "show"}, fadeOut: {opacity: "hide"}, fadeToggle: {opacity: "toggle"}}, function (a, b) {
+ n.fn[a] = function (a, c, d) {
+ return this.animate(b, a, c, d)
+ }
+ }), n.timers = [], n.fx.tick = function () {
+ var a, b = 0, c = n.timers;
+ for (Lb = n.now(); b < c.length; b++)a = c[b], a() || c[b] !== a || c.splice(b--, 1);
+ c.length || n.fx.stop(), Lb = void 0
+ }, n.fx.timer = function (a) {
+ n.timers.push(a), a() ? n.fx.start() : n.timers.pop()
+ }, n.fx.interval = 13, n.fx.start = function () {
+ Mb || (Mb = setInterval(n.fx.tick, n.fx.interval))
+ }, n.fx.stop = function () {
+ clearInterval(Mb), Mb = null
+ }, n.fx.speeds = {slow: 600, fast: 200, _default: 400}, n.fn.delay = function (a, b) {
+ return a = n.fx ? n.fx.speeds[a] || a : a, b = b || "fx", this.queue(b, function (b, c) {
+ var d = setTimeout(b, a);
+ c.stop = function () {
+ clearTimeout(d)
+ }
+ })
+ }, function () {
+ var a = l.createElement("input"), b = l.createElement("select"), c = b.appendChild(l.createElement("option"));
+ a.type = "checkbox", k.checkOn = "" !== a.value, k.optSelected = c.selected, b.disabled = !0, k.optDisabled = !c.disabled, a = l.createElement("input"), a.value = "t", a.type = "radio", k.radioValue = "t" === a.value
+ }();
+ var Yb, Zb, $b = n.expr.attrHandle;
+ n.fn.extend({attr: function (a, b) {
+ return J(this, n.attr, a, b, arguments.length > 1)
+ }, removeAttr: function (a) {
+ return this.each(function () {
+ n.removeAttr(this, a)
+ })
+ }}), n.extend({attr: function (a, b, c) {
+ var d, e, f = a.nodeType;
+ if (a && 3 !== f && 8 !== f && 2 !== f)return typeof a.getAttribute === U ? n.prop(a, b, c) : (1 === f && n.isXMLDoc(a) || (b = b.toLowerCase(), d = n.attrHooks[b] || (n.expr.match.bool.test(b) ? Zb : Yb)), void 0 === c ? d && "get"in d && null !== (e = d.get(a, b)) ? e : (e = n.find.attr(a, b), null == e ? void 0 : e) : null !== c ? d && "set"in d && void 0 !== (e = d.set(a, c, b)) ? e : (a.setAttribute(b, c + ""), c) : void n.removeAttr(a, b))
+ }, removeAttr: function (a, b) {
+ var c, d, e = 0, f = b && b.match(E);
+ if (f && 1 === a.nodeType)while (c = f[e++])d = n.propFix[c] || c, n.expr.match.bool.test(c) && (a[d] = !1), a.removeAttribute(c)
+ }, attrHooks: {type: {set: function (a, b) {
+ if (!k.radioValue && "radio" === b && n.nodeName(a, "input")) {
+ var c = a.value;
+ return a.setAttribute("type", b), c && (a.value = c), b
+ }
+ }}}}), Zb = {set: function (a, b, c) {
+ return b === !1 ? n.removeAttr(a, c) : a.setAttribute(c, c), c
+ }}, n.each(n.expr.match.bool.source.match(/\w+/g), function (a, b) {
+ var c = $b[b] || n.find.attr;
+ $b[b] = function (a, b, d) {
+ var e, f;
+ return d || (f = $b[b], $b[b] = e, e = null != c(a, b, d) ? b.toLowerCase() : null, $b[b] = f), e
+ }
+ });
+ var _b = /^(?:input|select|textarea|button)$/i;
+ n.fn.extend({prop: function (a, b) {
+ return J(this, n.prop, a, b, arguments.length > 1)
+ }, removeProp: function (a) {
+ return this.each(function () {
+ delete this[n.propFix[a] || a]
+ })
+ }}), n.extend({propFix: {"for": "htmlFor", "class": "className"}, prop: function (a, b, c) {
+ var d, e, f, g = a.nodeType;
+ if (a && 3 !== g && 8 !== g && 2 !== g)return f = 1 !== g || !n.isXMLDoc(a), f && (b = n.propFix[b] || b, e = n.propHooks[b]), void 0 !== c ? e && "set"in e && void 0 !== (d = e.set(a, c, b)) ? d : a[b] = c : e && "get"in e && null !== (d = e.get(a, b)) ? d : a[b]
+ }, propHooks: {tabIndex: {get: function (a) {
+ return a.hasAttribute("tabindex") || _b.test(a.nodeName) || a.href ? a.tabIndex : -1
+ }}}}), k.optSelected || (n.propHooks.selected = {get: function (a) {
+ var b = a.parentNode;
+ return b && b.parentNode && b.parentNode.selectedIndex, null
+ }}), n.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () {
+ n.propFix[this.toLowerCase()] = this
+ });
+ var ac = /[\t\r\n\f]/g;
+ n.fn.extend({addClass: function (a) {
+ var b, c, d, e, f, g, h = "string" == typeof a && a, i = 0, j = this.length;
+ if (n.isFunction(a))return this.each(function (b) {
+ n(this).addClass(a.call(this, b, this.className))
+ });
+ if (h)for (b = (a || "").match(E) || []; j > i; i++)if (c = this[i], d = 1 === c.nodeType && (c.className ? (" " + c.className + " ").replace(ac, " ") : " ")) {
+ f = 0;
+ while (e = b[f++])d.indexOf(" " + e + " ") < 0 && (d += e + " ");
+ g = n.trim(d), c.className !== g && (c.className = g)
+ }
+ return this
+ }, removeClass: function (a) {
+ var b, c, d, e, f, g, h = 0 === arguments.length || "string" == typeof a && a, i = 0, j = this.length;
+ if (n.isFunction(a))return this.each(function (b) {
+ n(this).removeClass(a.call(this, b, this.className))
+ });
+ if (h)for (b = (a || "").match(E) || []; j > i; i++)if (c = this[i], d = 1 === c.nodeType && (c.className ? (" " + c.className + " ").replace(ac, " ") : "")) {
+ f = 0;
+ while (e = b[f++])while (d.indexOf(" " + e + " ") >= 0)d = d.replace(" " + e + " ", " ");
+ g = a ? n.trim(d) : "", c.className !== g && (c.className = g)
+ }
+ return this
+ }, toggleClass: function (a, b) {
+ var c = typeof a;
+ return"boolean" == typeof b && "string" === c ? b ? this.addClass(a) : this.removeClass(a) : this.each(n.isFunction(a) ? function (c) {
+ n(this).toggleClass(a.call(this, c, this.className, b), b)
+ } : function () {
+ if ("string" === c) {
+ var b, d = 0, e = n(this), f = a.match(E) || [];
+ while (b = f[d++])e.hasClass(b) ? e.removeClass(b) : e.addClass(b)
+ } else(c === U || "boolean" === c) && (this.className && L.set(this, "__className__", this.className), this.className = this.className || a === !1 ? "" : L.get(this, "__className__") || "")
+ })
+ }, hasClass: function (a) {
+ for (var b = " " + a + " ", c = 0, d = this.length; d > c; c++)if (1 === this[c].nodeType && (" " + this[c].className + " ").replace(ac, " ").indexOf(b) >= 0)return!0;
+ return!1
+ }});
+ var bc = /\r/g;
+ n.fn.extend({val: function (a) {
+ var b, c, d, e = this[0];
+ {
+ if (arguments.length)return d = n.isFunction(a), this.each(function (c) {
+ var e;
+ 1 === this.nodeType && (e = d ? a.call(this, c, n(this).val()) : a, null == e ? e = "" : "number" == typeof e ? e += "" : n.isArray(e) && (e = n.map(e, function (a) {
+ return null == a ? "" : a + ""
+ })), b = n.valHooks[this.type] || n.valHooks[this.nodeName.toLowerCase()], b && "set"in b && void 0 !== b.set(this, e, "value") || (this.value = e))
+ });
+ if (e)return b = n.valHooks[e.type] || n.valHooks[e.nodeName.toLowerCase()], b && "get"in b && void 0 !== (c = b.get(e, "value")) ? c : (c = e.value, "string" == typeof c ? c.replace(bc, "") : null == c ? "" : c)
+ }
+ }}), n.extend({valHooks: {option: {get: function (a) {
+ var b = n.find.attr(a, "value");
+ return null != b ? b : n.trim(n.text(a))
+ }}, select: {get: function (a) {
+ for (var b, c, d = a.options, e = a.selectedIndex, f = "select-one" === a.type || 0 > e, g = f ? null : [], h = f ? e + 1 : d.length, i = 0 > e ? h : f ? e : 0; h > i; i++)if (c = d[i], !(!c.selected && i !== e || (k.optDisabled ? c.disabled : null !== c.getAttribute("disabled")) || c.parentNode.disabled && n.nodeName(c.parentNode, "optgroup"))) {
+ if (b = n(c).val(), f)return b;
+ g.push(b)
+ }
+ return g
+ }, set: function (a, b) {
+ var c, d, e = a.options, f = n.makeArray(b), g = e.length;
+ while (g--)d = e[g], (d.selected = n.inArray(d.value, f) >= 0) && (c = !0);
+ return c || (a.selectedIndex = -1), f
+ }}}}), n.each(["radio", "checkbox"], function () {
+ n.valHooks[this] = {set: function (a, b) {
+ return n.isArray(b) ? a.checked = n.inArray(n(a).val(), b) >= 0 : void 0
+ }}, k.checkOn || (n.valHooks[this].get = function (a) {
+ return null === a.getAttribute("value") ? "on" : a.value
+ })
+ }), n.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error contextmenu".split(" "), function (a, b) {
+ n.fn[b] = function (a, c) {
+ return arguments.length > 0 ? this.on(b, null, a, c) : this.trigger(b)
+ }
+ }), n.fn.extend({hover: function (a, b) {
+ return this.mouseenter(a).mouseleave(b || a)
+ }, bind: function (a, b, c) {
+ return this.on(a, null, b, c)
+ }, unbind: function (a, b) {
+ return this.off(a, null, b)
+ }, delegate: function (a, b, c, d) {
+ return this.on(b, a, c, d)
+ }, undelegate: function (a, b, c) {
+ return 1 === arguments.length ? this.off(a, "**") : this.off(b, a || "**", c)
+ }});
+ var cc = n.now(), dc = /\?/;
+ n.parseJSON = function (a) {
+ return JSON.parse(a + "")
+ }, n.parseXML = function (a) {
+ var b, c;
+ if (!a || "string" != typeof a)return null;
+ try {
+ c = new DOMParser, b = c.parseFromString(a, "text/xml")
+ } catch (d) {
+ b = void 0
+ }
+ return(!b || b.getElementsByTagName("parsererror").length) && n.error("Invalid XML: " + a), b
+ };
+ var ec = /#.*$/, fc = /([?&])_=[^&]*/, gc = /^(.*?):[ \t]*([^\r\n]*)$/gm, hc = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, ic = /^(?:GET|HEAD)$/, jc = /^\/\//, kc = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, lc = {}, mc = {}, nc = "*/".concat("*"), oc = a.location.href, pc = kc.exec(oc.toLowerCase()) || [];
+
+ function qc(a) {
+ return function (b, c) {
+ "string" != typeof b && (c = b, b = "*");
+ var d, e = 0, f = b.toLowerCase().match(E) || [];
+ if (n.isFunction(c))while (d = f[e++])"+" === d[0] ? (d = d.slice(1) || "*", (a[d] = a[d] || []).unshift(c)) : (a[d] = a[d] || []).push(c)
+ }
+ }
+
+ function rc(a, b, c, d) {
+ var e = {}, f = a === mc;
+
+ function g(h) {
+ var i;
+ return e[h] = !0, n.each(a[h] || [], function (a, h) {
+ var j = h(b, c, d);
+ return"string" != typeof j || f || e[j] ? f ? !(i = j) : void 0 : (b.dataTypes.unshift(j), g(j), !1)
+ }), i
+ }
+
+ return g(b.dataTypes[0]) || !e["*"] && g("*")
+ }
+
+ function sc(a, b) {
+ var c, d, e = n.ajaxSettings.flatOptions || {};
+ for (c in b)void 0 !== b[c] && ((e[c] ? a : d || (d = {}))[c] = b[c]);
+ return d && n.extend(!0, a, d), a
+ }
+
+ function tc(a, b, c) {
+ var d, e, f, g, h = a.contents, i = a.dataTypes;
+ while ("*" === i[0])i.shift(), void 0 === d && (d = a.mimeType || b.getResponseHeader("Content-Type"));
+ if (d)for (e in h)if (h[e] && h[e].test(d)) {
+ i.unshift(e);
+ break
+ }
+ if (i[0]in c)f = i[0]; else {
+ for (e in c) {
+ if (!i[0] || a.converters[e + " " + i[0]]) {
+ f = e;
+ break
+ }
+ g || (g = e)
+ }
+ f = f || g
+ }
+ return f ? (f !== i[0] && i.unshift(f), c[f]) : void 0
+ }
+
+ function uc(a, b, c, d) {
+ var e, f, g, h, i, j = {}, k = a.dataTypes.slice();
+ if (k[1])for (g in a.converters)j[g.toLowerCase()] = a.converters[g];
+ f = k.shift();
+ while (f)if (a.responseFields[f] && (c[a.responseFields[f]] = b), !i && d && a.dataFilter && (b = a.dataFilter(b, a.dataType)), i = f, f = k.shift())if ("*" === f)f = i; else if ("*" !== i && i !== f) {
+ if (g = j[i + " " + f] || j["* " + f], !g)for (e in j)if (h = e.split(" "), h[1] === f && (g = j[i + " " + h[0]] || j["* " + h[0]])) {
+ g === !0 ? g = j[e] : j[e] !== !0 && (f = h[0], k.unshift(h[1]));
+ break
+ }
+ if (g !== !0)if (g && a["throws"])b = g(b); else try {
+ b = g(b)
+ } catch (l) {
+ return{state: "parsererror", error: g ? l : "No conversion from " + i + " to " + f}
+ }
+ }
+ return{state: "success", data: b}
+ }
+
+ n.extend({active: 0, lastModified: {}, etag: {}, ajaxSettings: {url: oc, type: "GET", isLocal: hc.test(pc[1]), global: !0, processData: !0, async: !0, contentType: "application/x-www-form-urlencoded; charset=UTF-8", accepts: {"*": nc, text: "text/plain", html: "text/html", xml: "application/xml, text/xml", json: "application/json, text/javascript"}, contents: {xml: /xml/, html: /html/, json: /json/}, responseFields: {xml: "responseXML", text: "responseText", json: "responseJSON"}, converters: {"* text": String, "text html": !0, "text json": n.parseJSON, "text xml": n.parseXML}, flatOptions: {url: !0, context: !0}}, ajaxSetup: function (a, b) {
+ return b ? sc(sc(a, n.ajaxSettings), b) : sc(n.ajaxSettings, a)
+ }, ajaxPrefilter: qc(lc), ajaxTransport: qc(mc), ajax: function (a, b) {
+ "object" == typeof a && (b = a, a = void 0), b = b || {};
+ var c, d, e, f, g, h, i, j, k = n.ajaxSetup({}, b), l = k.context || k, m = k.context && (l.nodeType || l.jquery) ? n(l) : n.event, o = n.Deferred(), p = n.Callbacks("once memory"), q = k.statusCode || {}, r = {}, s = {}, t = 0, u = "canceled", v = {readyState: 0, getResponseHeader: function (a) {
+ var b;
+ if (2 === t) {
+ if (!f) {
+ f = {};
+ while (b = gc.exec(e))f[b[1].toLowerCase()] = b[2]
+ }
+ b = f[a.toLowerCase()]
+ }
+ return null == b ? null : b
+ }, getAllResponseHeaders: function () {
+ return 2 === t ? e : null
+ }, setRequestHeader: function (a, b) {
+ var c = a.toLowerCase();
+ return t || (a = s[c] = s[c] || a, r[a] = b), this
+ }, overrideMimeType: function (a) {
+ return t || (k.mimeType = a), this
+ }, statusCode: function (a) {
+ var b;
+ if (a)if (2 > t)for (b in a)q[b] = [q[b], a[b]]; else v.always(a[v.status]);
+ return this
+ }, abort: function (a) {
+ var b = a || u;
+ return c && c.abort(b), x(0, b), this
+ }};
+ if (o.promise(v).complete = p.add, v.success = v.done, v.error = v.fail, k.url = ((a || k.url || oc) + "").replace(ec, "").replace(jc, pc[1] + "//"), k.type = b.method || b.type || k.method || k.type, k.dataTypes = n.trim(k.dataType || "*").toLowerCase().match(E) || [""], null == k.crossDomain && (h = kc.exec(k.url.toLowerCase()), k.crossDomain = !(!h || h[1] === pc[1] && h[2] === pc[2] && (h[3] || ("http:" === h[1] ? "80" : "443")) === (pc[3] || ("http:" === pc[1] ? "80" : "443")))), k.data && k.processData && "string" != typeof k.data && (k.data = n.param(k.data, k.traditional)), rc(lc, k, b, v), 2 === t)return v;
+ i = n.event && k.global, i && 0 === n.active++ && n.event.trigger("ajaxStart"), k.type = k.type.toUpperCase(), k.hasContent = !ic.test(k.type), d = k.url, k.hasContent || (k.data && (d = k.url += (dc.test(d) ? "&" : "?") + k.data, delete k.data), k.cache === !1 && (k.url = fc.test(d) ? d.replace(fc, "$1_=" + cc++) : d + (dc.test(d) ? "&" : "?") + "_=" + cc++)), k.ifModified && (n.lastModified[d] && v.setRequestHeader("If-Modified-Since", n.lastModified[d]), n.etag[d] && v.setRequestHeader("If-None-Match", n.etag[d])), (k.data && k.hasContent && k.contentType !== !1 || b.contentType) && v.setRequestHeader("Content-Type", k.contentType), v.setRequestHeader("Accept", k.dataTypes[0] && k.accepts[k.dataTypes[0]] ? k.accepts[k.dataTypes[0]] + ("*" !== k.dataTypes[0] ? ", " + nc + "; q=0.01" : "") : k.accepts["*"]);
+ for (j in k.headers)v.setRequestHeader(j, k.headers[j]);
+ if (k.beforeSend && (k.beforeSend.call(l, v, k) === !1 || 2 === t))return v.abort();
+ u = "abort";
+ for (j in{success: 1, error: 1, complete: 1})v[j](k[j]);
+ if (c = rc(mc, k, b, v)) {
+ v.readyState = 1, i && m.trigger("ajaxSend", [v, k]), k.async && k.timeout > 0 && (g = setTimeout(function () {
+ v.abort("timeout")
+ }, k.timeout));
+ try {
+ t = 1, c.send(r, x)
+ } catch (w) {
+ if (!(2 > t))throw w;
+ x(-1, w)
+ }
+ } else x(-1, "No Transport");
+ function x(a, b, f, h) {
+ var j, r, s, u, w, x = b;
+ 2 !== t && (t = 2, g && clearTimeout(g), c = void 0, e = h || "", v.readyState = a > 0 ? 4 : 0, j = a >= 200 && 300 > a || 304 === a, f && (u = tc(k, v, f)), u = uc(k, u, v, j), j ? (k.ifModified && (w = v.getResponseHeader("Last-Modified"), w && (n.lastModified[d] = w), w = v.getResponseHeader("etag"), w && (n.etag[d] = w)), 204 === a || "HEAD" === k.type ? x = "nocontent" : 304 === a ? x = "notmodified" : (x = u.state, r = u.data, s = u.error, j = !s)) : (s = x, (a || !x) && (x = "error", 0 > a && (a = 0))), v.status = a, v.statusText = (b || x) + "", j ? o.resolveWith(l, [r, x, v]) : o.rejectWith(l, [v, x, s]), v.statusCode(q), q = void 0, i && m.trigger(j ? "ajaxSuccess" : "ajaxError", [v, k, j ? r : s]), p.fireWith(l, [v, x]), i && (m.trigger("ajaxComplete", [v, k]), --n.active || n.event.trigger("ajaxStop")))
+ }
+
+ return v
+ }, getJSON: function (a, b, c) {
+ return n.get(a, b, c, "json")
+ }, getScript: function (a, b) {
+ return n.get(a, void 0, b, "script")
+ }}), n.each(["get", "post"], function (a, b) {
+ n[b] = function (a, c, d, e) {
+ return n.isFunction(c) && (e = e || d, d = c, c = void 0), n.ajax({url: a, type: b, dataType: e, data: c, success: d})
+ }
+ }), n._evalUrl = function (a) {
+ return n.ajax({url: a, type: "GET", dataType: "script", async: !1, global: !1, "throws": !0})
+ }, n.fn.extend({wrapAll: function (a) {
+ var b;
+ return n.isFunction(a) ? this.each(function (b) {
+ n(this).wrapAll(a.call(this, b))
+ }) : (this[0] && (b = n(a, this[0].ownerDocument).eq(0).clone(!0), this[0].parentNode && b.insertBefore(this[0]), b.map(function () {
+ var a = this;
+ while (a.firstElementChild)a = a.firstElementChild;
+ return a
+ }).append(this)), this)
+ }, wrapInner: function (a) {
+ return this.each(n.isFunction(a) ? function (b) {
+ n(this).wrapInner(a.call(this, b))
+ } : function () {
+ var b = n(this), c = b.contents();
+ c.length ? c.wrapAll(a) : b.append(a)
+ })
+ }, wrap: function (a) {
+ var b = n.isFunction(a);
+ return this.each(function (c) {
+ n(this).wrapAll(b ? a.call(this, c) : a)
+ })
+ }, unwrap: function () {
+ return this.parent().each(function () {
+ n.nodeName(this, "body") || n(this).replaceWith(this.childNodes)
+ }).end()
+ }}), n.expr.filters.hidden = function (a) {
+ return a.offsetWidth <= 0 && a.offsetHeight <= 0
+ }, n.expr.filters.visible = function (a) {
+ return!n.expr.filters.hidden(a)
+ };
+ var vc = /%20/g, wc = /\[\]$/, xc = /\r?\n/g, yc = /^(?:submit|button|image|reset|file)$/i, zc = /^(?:input|select|textarea|keygen)/i;
+
+ function Ac(a, b, c, d) {
+ var e;
+ if (n.isArray(b))n.each(b, function (b, e) {
+ c || wc.test(a) ? d(a, e) : Ac(a + "[" + ("object" == typeof e ? b : "") + "]", e, c, d)
+ }); else if (c || "object" !== n.type(b))d(a, b); else for (e in b)Ac(a + "[" + e + "]", b[e], c, d)
+ }
+
+ n.param = function (a, b) {
+ var c, d = [], e = function (a, b) {
+ b = n.isFunction(b) ? b() : null == b ? "" : b, d[d.length] = encodeURIComponent(a) + "=" + encodeURIComponent(b)
+ };
+ if (void 0 === b && (b = n.ajaxSettings && n.ajaxSettings.traditional), n.isArray(a) || a.jquery && !n.isPlainObject(a))n.each(a, function () {
+ e(this.name, this.value)
+ }); else for (c in a)Ac(c, a[c], b, e);
+ return d.join("&").replace(vc, "+")
+ }, n.fn.extend({serialize: function () {
+ return n.param(this.serializeArray())
+ }, serializeArray: function () {
+ return this.map(function () {
+ var a = n.prop(this, "elements");
+ return a ? n.makeArray(a) : this
+ }).filter(function () {
+ var a = this.type;
+ return this.name && !n(this).is(":disabled") && zc.test(this.nodeName) && !yc.test(a) && (this.checked || !T.test(a))
+ }).map(function (a, b) {
+ var c = n(this).val();
+ return null == c ? null : n.isArray(c) ? n.map(c, function (a) {
+ return{name: b.name, value: a.replace(xc, "\r\n")}
+ }) : {name: b.name, value: c.replace(xc, "\r\n")}
+ }).get()
+ }}), n.ajaxSettings.xhr = function () {
+ try {
+ return new XMLHttpRequest
+ } catch (a) {
+ }
+ };
+ var Bc = 0, Cc = {}, Dc = {0: 200, 1223: 204}, Ec = n.ajaxSettings.xhr();
+ a.attachEvent && a.attachEvent("onunload", function () {
+ for (var a in Cc)Cc[a]()
+ }), k.cors = !!Ec && "withCredentials"in Ec, k.ajax = Ec = !!Ec, n.ajaxTransport(function (a) {
+ var b;
+ return k.cors || Ec && !a.crossDomain ? {send: function (c, d) {
+ var e, f = a.xhr(), g = ++Bc;
+ if (f.open(a.type, a.url, a.async, a.username, a.password), a.xhrFields)for (e in a.xhrFields)f[e] = a.xhrFields[e];
+ a.mimeType && f.overrideMimeType && f.overrideMimeType(a.mimeType), a.crossDomain || c["X-Requested-With"] || (c["X-Requested-With"] = "XMLHttpRequest");
+ for (e in c)f.setRequestHeader(e, c[e]);
+ b = function (a) {
+ return function () {
+ b && (delete Cc[g], b = f.onload = f.onerror = null, "abort" === a ? f.abort() : "error" === a ? d(f.status, f.statusText) : d(Dc[f.status] || f.status, f.statusText, "string" == typeof f.responseText ? {text: f.responseText} : void 0, f.getAllResponseHeaders()))
+ }
+ }, f.onload = b(), f.onerror = b("error"), b = Cc[g] = b("abort");
+ try {
+ f.send(a.hasContent && a.data || null)
+ } catch (h) {
+ if (b)throw h
+ }
+ }, abort: function () {
+ b && b()
+ }} : void 0
+ }), n.ajaxSetup({accepts: {script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"}, contents: {script: /(?:java|ecma)script/}, converters: {"text script": function (a) {
+ return n.globalEval(a), a
+ }}}), n.ajaxPrefilter("script", function (a) {
+ void 0 === a.cache && (a.cache = !1), a.crossDomain && (a.type = "GET")
+ }), n.ajaxTransport("script", function (a) {
+ if (a.crossDomain) {
+ var b, c;
+ return{send: function (d, e) {
+ b = n("
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+