开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 网络 > 查看源码
jquery.flot.js
资源名称：com_comprofiler.zip　[点击查看]
上传用户：stephen_wu
上传日期：2008-07-05
资源大小：1757k
文件大小：52k
源码类别：

网络

开发平台：

Unix_Linux

jquery.flot.js：源码内容
  1. /* Javascript plotting library for jQuery, v. 0.3.
  2.  *
  3.  * Released under the MIT license by iola, December 2007.
  4.  *
  5.  */
  7. (function($) {
  8.     function Plot(target_, data_, options_) {
  9.         // data is on the form:
  10.         //   [ series1 series2 ... ]
  11.         // where series is either just the data as [ [x1, y1], [x2, y2], ... ]
  12.         // or { data: [ [x1, y1], [x2, y2], ... ], label: "some label" }
  13.         
  14.         var series = [];
  15.         var options = {
  16.             // the color theme used for graphs
  17.             colors: ["#edc240", "#afd8f8", "#cb4b4b", "#4da74d", "#9440ed"],
  18.             legend: {
  19.                 show: true,
  20.                 noColumns: 1, // number of colums in legend table
  21.                 labelFormatter: null, // fn: string -> string
  22.                 labelBoxBorderColor: "#ccc", // border color for the little label boxes
  23.                 container: null, // container (as jQuery object) to put legend in, null means default on top of graph
  24.                 position: "ne", // position of default legend container within plot
  25.                 margin: 5, // distance from grid edge to default legend container within plot
  26.                 backgroundColor: null, // null means auto-detect
  27.                 backgroundOpacity: 0.85 // set to 0 to avoid background
  28.             },
  29.             xaxis: {
  30.                 ticks: null, // either [1, 3] or [[1, "a"], 3]
  31.                 noTicks: 5, // approximate number of ticks for auto-ticks
  32.                 tickFormatter: defaultTickFormatter, // fn: number -> string
  33.                 tickDecimals: null, // no. of decimals, null means auto
  34.                 min: null, // min. value to show, null means set automatically
  35.                 max: null, // max. value to show, null means set automatically
  36.                 autoscaleMargin: 0 // margin in % to add if auto-setting min/max
  37.             },
  38.             yaxis: {
  39.                 noTicks: 5,
  40.                 ticks: null,
  41.                 tickFormatter: defaultTickFormatter,
  42.                 min: null,
  43.                 max: null,
  44.                 autoscaleMargin: 0.02
  45.             },
  46.             points: {
  47.                 show: false,
  48.                 radius: 3,
  49.                 lineWidth: 2, // in pixels
  50.                 fill: true,
  51.                 fillColor: "#ffffff"
  52.             },
  53.             lines: {
  54.                 show: false,
  55.                 lineWidth: 2, // in pixels
  56.                 fill: false,
  57.                 fillColor: null
  58.             },
  59.             bars: {
  60.                 show: false,
  61.                 lineWidth: 2, // in pixels
  62.                 barWidth: 1, // in units of the x axis
  63.                 fill: true,
  64.                 fillColor: null
  65.             },
  66.             grid: {
  67.                 color: "#545454", // primary color used for outline and labels
  68.                 backgroundColor: null, // null for transparent, else color
  69.                 tickColor: "#dddddd", // color used for the ticks
  70.                 labelMargin: 3, // in pixels
  71.                 clickable: null
  72.             },
  73.             selection: {
  74.                 mode: null, // one of null, "x", "y" or "xy"
  75.                 color: "#e8cfac"
  76.             },
  77.             shadowSize: 4
  78.         };
  79.         var canvas = null, overlay = null;
  80.         var ctx = null, octx = null;
  81.         var target = target_;
  82.         var xaxis = {};
  83.         var yaxis = {};
  84.         
  85.         var plotOffset = { left: 0, right: 0, top: 0, bottom: 0};
  86.         var labelMaxWidth = 0;
  87.         var labelMaxHeight = 0;
  88.         var canvasWidth = 0;
  89.         var canvasHeight = 0;
  90.         var plotWidth = 0;
  91.         var plotHeight = 0;
  92.         var hozScale = 0;
  93.         var vertScale = 0;
  94.         
  96.         // initialize
  97.         series = parseData(data_);
  98.         parseOptions(options_);
  99.         fillInSeriesOptions();
  101.         constructCanvas();
  102.         bindEvents();
  103.         findDataRanges();
  104.         calculateRange(xaxis, options.xaxis);
  105.         extendXRangeIfNeededByBar();
  106.         calculateRange(yaxis, options.yaxis);
  107.         calculateTicks(xaxis, options.xaxis);
  108.         calculateTicks(yaxis, options.yaxis);
  109.         calculateSpacing();
  110.         draw();
  111.         insertLegend();
  113.         this.getCanvas = function() { return canvas; };
  114.         this.getPlotOffset = function() { return plotOffset; };
  115.         this.clearSelection = clearSelection;
  116.         this.setSelection = setSelection;
  117.         
  118.         function parseData(d) {
  119.             var res = [];
  120.             for (var i = 0; i < d.length; ++i) {
  121.                 var s;
  122.                 if (d[i].data) {
  123.                     s = {};
  124.                     for (var v in d[i])
  125.                         s[v] = d[i][v];
  126.                 }
  127.                 else {
  128.                     s = { data: d[i] };
  129.                 }
  130.                 res.push(s);
  131.             }
  133.             return res;
  134.         }
  135.         
  136.         function parseOptions(o) {
  137.             $.extend(true, options, o);
  138.         }
  140.         function constructCanvas() {
  141.             canvasWidth = target.width();
  142.             canvasHeight = target.height();
  143.             target.html(""); // clear target
  144.             target.css("position", "relative"); // for positioning labels and overlay
  146.             if (canvasWidth <= 0 || canvasHeight <= 0)
  147.                 throw "Invalid dimensions for plot, width = " + canvasWidth + ", height = " + canvasHeight;
  149.             // the canvas
  150.             canvas = jQuery('<canvas width="' + canvasWidth + '" height="' + canvasHeight + '"></canvas>').appendTo(target).get(0);
  151.     if (jQuery.browser.msie) // excanvas hack
  152. canvas = window.G_vmlCanvasManager.initElement(canvas);
  153.             ctx = canvas.getContext("2d");
  155.             // overlay canvas for interactive features
  156.             overlay = jQuery('<canvas style="position:absolute;left:0px;top:0px;" width="' + canvasWidth + '" height="' + canvasHeight + '"></canvas>').appendTo(target).get(0);
  157.     if (jQuery.browser.msie) // excanvas hack
  158. overlay = window.G_vmlCanvasManager.initElement(overlay);
  159.             octx = overlay.getContext("2d");
  160.         }
  162.         function bindEvents() {
  163.             if (options.selection.mode != null) {
  164.                 $(overlay).mousedown(onMouseDown);
  165.                 // FIXME: temp. work-around until jQuery bug 1871 is fixed
  166.                 target.get(0).onmousemove = onMouseMove;
  167.             }
  169.             if (options.grid.clickable)
  170.                 $(overlay).click(onClick);
  171.         }
  173.         function findDataRanges() {
  174.             yaxis.datamin = xaxis.datamin = 0;
  175.             xaxis.datamax = yaxis.datamax = 1;
  177.             if (series.length == 0)
  178.                 return;
  180.             // get datamin, datamax start values
  181.             var i, found = false;
  182.             for (i = 0; i < series.length; ++i) {
  183.                 if (series[i].data.length > 0) {
  184.                     xaxis.datamin = xaxis.datamax = series[i].data[0][0];
  185.                     yaxis.datamin = yaxis.datamax = series[i].data[0][1];
  186.                     found = true;
  187.                     break;
  188.                 }
  189.             }
  191.             if (!found)
  192.                 return;
  194.             // then find real datamin, datamax
  195.             for (i = 0; i < series.length; ++i) {
  196.                 var data = series[i].data;
  197.                 for (var j = 0; j < data.length; ++j) {
  198.                     var x = data[j][0];
  199.                     var y = data[j][1];
  200.                     if (x < xaxis.datamin)
  201.                         xaxis.datamin = x;
  202.                     else if (x > xaxis.datamax)
  203.                         xaxis.datamax = x;
  204.                     if (y < yaxis.datamin)
  205.                         yaxis.datamin = y;
  206.                     else if (y > yaxis.datamax)
  207.                         yaxis.datamax = y;
  208.                 }
  209.             }
  210.         }
  212.         function getTickSize(noTicks, min, max, decimals) {
  213.             var delta = (max - min) / noTicks;
  214.             var magn = getMagnitude(delta);
  215.             var norm = delta / magn; // norm is between 1.0 and 10.0
  217.             var tickSize = 1;
  218.             if (norm < 1.5)
  219.                 tickSize = 1;
  220.             else if (norm < 2.25)
  221.                 tickSize = 2;
  222.             else if (norm < 3)
  223.                 tickSize = 2.5;
  224.             else if (norm < 7.5)
  225.                 tickSize = 5;
  226.             else
  227.                 tickSize = 10;
  229.             if (tickSize == 2.5 && decimals == 0)
  230.                 tickSize = 2;
  231.             
  232.             tickSize *= magn;
  233.             return tickSize;
  234.         }
  235.         
  236.         function calculateRange(axis, axisOptions) {
  237.             var min = axisOptions.min != null ? axisOptions.min : axis.datamin;
  238.             var max = axisOptions.max != null ? axisOptions.max : axis.datamax;
  240.             // check degenerate case
  241.             if (max - min == 0.0) {
  242.                 var widen;
  243.                 if (max == 0.0)
  244.                     widen = 1.0;
  245.                 else
  246.                     widen = 0.01;
  248.                 min -= widen;
  249.                 max += widen;
  250.             }
  251.             
  252.             axis.tickSize = getTickSize(axisOptions.noTicks, min, max, axisOptions.tickDecimals);
  253.                 
  254.             // consider autoscaling
  255.             var margin;
  256.             if (axisOptions.min == null) {
  257.                 // first add in a little margin
  258.                 margin = axisOptions.autoscaleMargin;
  259.                 if (margin != 0) {
  260.                     min -= axis.tickSize * margin;
  261.                     // make sure we don't go below zero if all
  262.                     // values are positive
  263.                     if (min < 0 && axis.datamin >= 0)
  264.                         min = 0;
  265.                     
  266.                     min = axis.tickSize * Math.floor(min / axis.tickSize);
  267.                 }
  268.             }
  269.             if (axisOptions.max == null) {
  270.                 margin = axisOptions.autoscaleMargin;
  271.                 if (margin != 0) {
  272.                     max += axis.tickSize * margin;
  273.                     if (max > 0 && axis.datamax <= 0)
  274.                         max = 0;
  275.                     
  276.                     max = axis.tickSize * Math.ceil(max / axis.tickSize);
  277.                 }
  278.             }
  279.             
  280.             axis.min = min;
  281.             axis.max = max;
  282.         }
  284.         function extendXRangeIfNeededByBar() {
  285.             if (options.xaxis.max == null) {
  286.                 // great, we're autoscaling, check if we might need a bump
  288.                 var newmax = xaxis.max;
  289.                 for (var i = 0; i < series.length; ++i)
  290.                     if (series[i].bars.show && series[i].bars.barWidth + xaxis.datamax > newmax)
  291.                         newmax = xaxis.max + series[i].bars.barWidth;
  292.                 xaxis.max = newmax;
  293.             }
  294.         }
  296.         function defaultTickFormatter(val) {
  297.             return "" + val;
  298.         }
  300.         function calculateTicks(axis, axisOptions) {
  301.             var i;
  302.             axis.ticks = [];
  304.             if (axisOptions.ticks) {
  305.                 var ticks = axisOptions.ticks;
  307.                 if ($.isFunction(ticks))
  308.                     // generate the ticks
  309.                     ticks = ticks({ min: axis.min, max: axis.max });
  310.                 
  311.                 // clean up the user-supplied ticks, copy them over
  312.                 for (i = 0; i < ticks.length; ++i) {
  313.                     var v, label;
  314.                     var t = ticks[i];
  315.                     if (typeof(t) == "object") {
  316.                         v = t[0];
  317.                         if (t.length > 1)
  318.                             label = t[1];
  319.                         else
  320.                             label = axisOptions.tickFormatter(v);
  321.                     }
  322.                     else {
  323.                         v = t;
  324.                         label = axisOptions.tickFormatter(v);
  325.                     }
  326.                     axis.ticks[i] = { v: v, label: label };
  327.                 }
  328.             }
  329.             else {
  330.                 // round to nearest multiple of tick size
  331.                 var start = axis.tickSize * Math.ceil(axis.min / axis.tickSize);
  332.                 // then spew out all possible ticks
  333.                 for (i = 0; start + i * axis.tickSize <= axis.max; ++i) {
  334.                     v = start + i * axis.tickSize;
  335.                     
  336.                     // round (this is always needed to fix numerical instability)
  337.                     var decimals = axisOptions.tickDecimals;
  338.                     if (decimals == null)
  339.                         decimals = 1 - Math.floor(Math.log(axis.tickSize) / Math.LN10);
  340.                     if (decimals < 0)
  341.                         decimals = 0;
  342.                     
  343.                     v = v.toFixed(decimals);
  344.                     axis.ticks.push({ v: v, label: axisOptions.tickFormatter(v) });
  345.                 }
  346.             }
  347.         }
  348.         
  349.         function calculateSpacing() {
  350.             // calculate spacing for labels, using the heuristic
  351.             // that the longest string is probably the one that takes
  352.             // up the most space
  353.             var i, max_label = "";
  354.             for (i = 0; i < yaxis.ticks.length; ++i) {
  355.                 var l = yaxis.ticks[i].label.length;
  356.                 if (l > max_label.length)
  357.                     max_label = yaxis.ticks[i].label;
  358.             }
  360.             // measure it
  361.             var dummyDiv = $('<div style="position:absolute;top:-10000px;font-size:smaller" class="gridLabel">' + max_label + '</div>').appendTo(target);
  362.             labelMaxWidth = dummyDiv.width();
  363.             labelMaxHeight = dummyDiv.height();
  364.             dummyDiv.remove();
  366.             var maxOutset = 2; // grid outline line width
  367.             if (options.points.show)
  368.                 maxOutset = Math.max(maxOutset, options.points.radius + options.points.lineWidth/2);
  369.             for (i = 0; i < series.length; ++i) {
  370.                 if (series[i].points.show)
  371.                     maxOutset = Math.max(maxOutset, series[i].points.radius + series[i].points.lineWidth/2);
  372.             }
  374.             plotOffset.left = plotOffset.right = plotOffset.top = plotOffset.bottom = maxOutset;
  375.             
  376.             plotOffset.left += labelMaxWidth + options.grid.labelMargin;
  377.             plotOffset.bottom += labelMaxHeight + options.grid.labelMargin;
  378.             
  379.             plotWidth = canvasWidth - plotOffset.left - plotOffset.right;
  380.             plotHeight = canvasHeight - plotOffset.bottom - plotOffset.top;
  381.             hozScale = plotWidth / (xaxis.max - xaxis.min);
  382.             vertScale = plotHeight / (yaxis.max - yaxis.min);
  383.         }
  384.         
  385.         function draw() {
  386.             drawGrid();
  387.             drawLabels();
  388.             for (var i = 0; i < series.length; i++) {
  389.                 drawSeries(series[i]);
  390.             }
  391.         }
  393.         function tHoz(x) {
  394.             return (x - xaxis.min) * hozScale;
  395.         }
  397.         function tVert(y) {
  398.             return plotHeight - (y - yaxis.min) * vertScale;
  399.         }
  401.         function drawGrid() {
  402.             ctx.save();
  403.             ctx.translate(plotOffset.left, plotOffset.top);
  405.             // draw background, if any
  406.             if (options.grid.backgroundColor != null) {
  407.                 ctx.fillStyle = options.grid.backgroundColor;
  408.                 ctx.fillRect(0, 0, plotWidth, plotHeight);
  409.             }
  410.             
  411.             // draw the inner grid
  412.             ctx.lineWidth = 1;
  413.             ctx.strokeStyle = options.grid.tickColor;
  414.             ctx.beginPath();
  415.             var i, v;
  416.             for (i = 0; i < xaxis.ticks.length; ++i) {
  417.                 v = xaxis.ticks[i].v;
  418.                 if (v == xaxis.min || v == xaxis.max)
  419.                     continue;   // skip those lying on the axes
  421.                 ctx.moveTo(Math.floor(tHoz(v)) + ctx.lineWidth/2, 0);
  422.                 ctx.lineTo(Math.floor(tHoz(v)) + ctx.lineWidth/2, plotHeight);
  423.             }
  425.             for (i = 0; i < yaxis.ticks.length; ++i) {
  426.                 v = yaxis.ticks[i].v;
  427.                 if (v == yaxis.min || v == yaxis.max)
  428.                     continue;
  430.                 ctx.moveTo(0, Math.floor(tVert(v)) + ctx.lineWidth/2);
  431.                 ctx.lineTo(plotWidth, Math.floor(tVert(v)) + ctx.lineWidth/2);
  432.             }
  433.             ctx.stroke();
  434.             
  435.             // draw outline
  436.             ctx.lineWidth = 2;
  437.             ctx.strokeStyle = options.grid.color;
  438.             ctx.lineJoin = "round";
  439.             ctx.strokeRect(0, 0, plotWidth, plotHeight);
  440.             ctx.restore();
  441.         }
  442.         
  443.         function drawLabels() {
  444.             var i;
  445.             var tick;
  446.             var html = '<div style="font-size:smaller;color:' + options.grid.color + '">';
  447.             // calculate width for labels; to avoid measuring the
  448.             // widths of the labels, we construct fixed-size boxes and
  449.             // put the labels inside them, the fixed-size boxes are
  450.             // easy to mid-align
  451.             var noLabels = 0;
  452.             for (i = 0; i < xaxis.ticks.length; ++i) {
  453.                 if (xaxis.ticks[i].label) {
  454.                     ++noLabels;
  455.                 }
  456.             }
  457.             var xBoxWidth = plotWidth / noLabels;
  458.             
  459.             // do the x-axis
  460.             for (i = 0; i < xaxis.ticks.length; ++i) {
  461.                 tick = xaxis.ticks[i];
  462.                 if (!tick.label)
  463.                     continue;
  464.                 html += '<div style="position:absolute;top:' + (plotOffset.top + plotHeight + options.grid.labelMargin) + 'px;left:' + (plotOffset.left + tHoz(tick.v) - xBoxWidth/2) + 'px;width:' + xBoxWidth + 'px;text-align:center" class="gridLabel">' + tick.label + "</div>";
  465.             }
  466.             
  467.             // do the y-axis
  468.             for (i = 0; i < yaxis.ticks.length; ++i) {
  469.                 tick = yaxis.ticks[i];
  470.                 if (!tick.label || tick.label.length == 0)
  471.                     continue;
  472.                 html += '<div style="position:absolute;top:' + (plotOffset.top + tVert(tick.v) - labelMaxHeight/2) + 'px;left:0;width:' + labelMaxWidth + 'px;text-align:right" class="gridLabel">' + tick.label + "</div>";
  473.             }
  475.             html += '</div>';
  476.             
  477.             target.append(html);
  478.         }
  480.         function fillInSeriesOptions() {
  481.             var i;
  482.             
  483.             // collect what we already got of colors
  484.             var neededColors = series.length;
  485.             var usedColors = [];
  486.             var assignedColors = [];
  487.             for (i = 0; i < series.length; ++i) {
  488.                 var sc = series[i].color;
  489.                 if (sc != null) {
  490.                     --neededColors;
  491.                     if (typeof(sc) == "number")
  492.                         assignedColors.push(sc);
  493.                     else
  494.                         usedColors.push(parseColor(series[i].color));
  495.                 }
  496.             }
  497.             
  498.             // we might need to generate more colors if higher indices
  499.             // are assigned
  500.             for (i = 0; i < assignedColors.length; ++i) {
  501.                 neededColors = Math.max(neededColors, assignedColors[i] + 1);
  502.             }
  504.             // produce colors as needed
  505.             var colors = [];
  506.             var variation = 0;
  507.             i = 0;
  508.             while (colors.length < neededColors) {
  509.                 var c;
  510.                 if (options.colors.length == i) // check degenerate case
  511.                     c = new Color(100, 100, 100);
  512.                 else
  513.                     c = parseColor(options.colors[i]);
  515.                 // vary color if needed
  516.                 var sign = variation % 2 == 1 ? -1 : 1;
  517.                 var factor = 1 + sign * Math.ceil(variation / 2) * 0.2;
  518.                 c.scale(factor, factor, factor);
  520.                 // FIXME: if we're getting to close to something else,
  521.                 // we should probably skip this one
  522.                 colors.push(c);
  523.                 
  524.                 ++i;
  525.                 if (i >= options.colors.length) {
  526.                     i = 0;
  527.                     ++variation;
  528.                 }
  529.             }
  531.             // fill in the options
  532.             var colori = 0;
  533.             for (i = 0; i < series.length; ++i) {
  534.                 var s = series[i];
  536.                 // assign colors
  537.                 if (s.color == null) {
  538.                     s.color = colors[colori].toString();
  539.                     ++colori;
  540.                 }
  541.                 else if (typeof(s.color) == "number")
  542.                     s.color = colors[s.color].toString();
  544.                 // copy the rest
  545.                 s.lines = $.extend(true, {}, options.lines, s.lines);
  546.                 s.points = $.extend(true, {}, options.points, s.points);
  547.                 s.bars = $.extend(true, {}, options.bars, s.bars);
  548.                 if (s.shadowSize == null)
  549.                     s.shadowSize = options.shadowSize;
  550.             }
  551.         }
  552.         
  553.         function drawSeries(series) {
  554.             if (series.lines.show || (!series.bars.show && !series.points.show))
  555.                 drawSeriesLines(series);
  556.             if (series.bars.show)
  557.                 drawSeriesBars(series);
  558.             if (series.points.show)
  559.                 drawSeriesPoints(series);
  560.         }
  561.         
  562.         function drawSeriesLines(series) {
  563.             function plotLine(data, offset) {
  564.                 if (data.length < 2)
  565.                     return;
  567.                 var prevx = tHoz(data[0][0]),
  568.                     prevy = tVert(data[0][1]) + offset;
  570.                 ctx.beginPath();
  571.                 ctx.moveTo(prevx, prevy);
  572.                 for (var i = 0; i < data.length - 1; ++i) {
  573.                     var x1 = data[i][0], y1 = data[i][1],
  574.                         x2 = data[i+1][0], y2 = data[i+1][1];
  576.                     // clip with ymin
  577.                     if (y1 <= y2 && y1 < yaxis.min) {
  578.                         if (y2 < yaxis.min)
  579.                             continue;   // line segment is outside
  580.                         // compute new intersection point
  581.                         x1 = (yaxis.min - y1) / (y2 - y1) * (x2 - x1) + x1;
  582.                         y1 = yaxis.min;
  583.                     }
  584.                     else if (y2 <= y1 && y2 < yaxis.min) {
  585.                         if (y1 < yaxis.min)
  586.                             continue;
  587.                         x2 = (yaxis.min - y1) / (y2 - y1) * (x2 - x1) + x1;
  588.                         y2 = yaxis.min;
  589.                     }
  591.                     // clip with ymax
  592.                     if (y1 >= y2 && y1 > yaxis.max) {
  593.                         if (y2 > yaxis.max)
  594.                             continue;
  595.                         x1 = (yaxis.max - y1) / (y2 - y1) * (x2 - x1) + x1;
  596.                         y1 = yaxis.max;
  597.                     }
  598.                     else if (y2 >= y1 && y2 > yaxis.max) {
  599.                         if (y1 > yaxis.max)
  600.                             continue;
  601.                         x2 = (yaxis.max - y1) / (y2 - y1) * (x2 - x1) + x1;
  602.                         y2 = yaxis.max;
  603.                     }
  605.                     // clip with xmin
  606.                     if (x1 <= x2 && x1 < xaxis.min) {
  607.                         if (x2 < xaxis.min)
  608.                             continue;
  609.                         y1 = (xaxis.min - x1) / (x2 - x1) * (y2 - y1) + y1;
  610.                         x1 = xaxis.min;
  611.                     }
  612.                     else if (x2 <= x1 && x2 < xaxis.min) {
  613.                         if (x1 < xaxis.min)
  614.                             continue;
  615.                         y2 = (xaxis.min - x1) / (x2 - x1) * (y2 - y1) + y1;
  616.                         x2 = xaxis.min;
  617.                     }
  619.                     // clip with xmax
  620.                     if (x1 >= x2 && x1 > xaxis.max) {
  621.                         if (x2 > xaxis.max)
  622.                             continue;
  623.                         y1 = (xaxis.max - x1) / (x2 - x1) * (y2 - y1) + y1;
  624.                         x1 = xaxis.max;
  625.                     }
  626.                     else if (x2 >= x1 && x2 > xaxis.max) {
  627.                         if (x1 > xaxis.max)
  628.                             continue;
  629.                         y2 = (xaxis.max - x1) / (x2 - x1) * (y2 - y1) + y1;
  630.                         x2 = xaxis.max;
  631.                     }
  633.                     if (prevx != tHoz(x1) || prevy != tVert(y1) + offset)
  634.                         ctx.moveTo(tHoz(x1), tVert(y1) + offset);
  635.                     
  636.                     prevx = tHoz(x2);
  637.                     prevy = tVert(y2) + offset;
  638.                     ctx.lineTo(prevx, prevy);
  639.                 }
  640.                 ctx.stroke();
  641.             }
  643.             function plotLineArea(data) {
  644.                 if (data.length < 2)
  645.                     return;
  647.                 var bottom = Math.min(Math.max(0, yaxis.min), yaxis.max);
  648.                 var top, lastX = 0;
  650.                 var first = true;
  651.                 
  652.                 ctx.beginPath();
  653.                 for (var i = 0; i < data.length - 1; ++i) {
  654.                     var x1 = data[i][0], y1 = data[i][1],
  655.                         x2 = data[i+1][0], y2 = data[i+1][1];
  657.                     // clip x values
  658.                     
  659.                     // clip with xmin
  660.                     if (x1 <= x2 && x1 < xaxis.min) {
  661.                         if (x2 < xaxis.min)
  662.                             continue;
  663.                         y1 = (xaxis.min - x1) / (x2 - x1) * (y2 - y1) + y1;
  664.                         x1 = xaxis.min;
  665.                     }
  666.                     else if (x2 <= x1 && x2 < xaxis.min) {
  667.                         if (x1 < xaxis.min)
  668.                             continue;
  669.                         y2 = (xaxis.min - x1) / (x2 - x1) * (y2 - y1) + y1;
  670.                         x2 = xaxis.min;
  671.                     }
  673.                     // clip with xmax
  674.                     if (x1 >= x2 && x1 > xaxis.max) {
  675.                         if (x2 > xaxis.max)
  676.                             continue;
  677.                         y1 = (xaxis.max - x1) / (x2 - x1) * (y2 - y1) + y1;
  678.                         x1 = xaxis.max;
  679.                     }
  680.                     else if (x2 >= x1 && x2 > xaxis.max) {
  681.                         if (x1 > xaxis.max)
  682.                             continue;
  683.                         y2 = (xaxis.max - x1) / (x2 - x1) * (y2 - y1) + y1;
  684.                         x2 = xaxis.max;
  685.                     }
  687.                     if (first) {
  688.                         ctx.moveTo(tHoz(x1), tVert(bottom));
  689.                         first = false;
  690.                     }
  691.                     
  692.                     // now first check the case where both is outside
  693.                     if (y1 >= yaxis.max && y2 >= yaxis.max) {
  694.                         ctx.lineTo(tHoz(x1), tVert(yaxis.max));
  695.                         ctx.lineTo(tHoz(x2), tVert(yaxis.max));
  696.                         continue;
  697.                     }
  698.                     else if (y1 <= yaxis.min && y2 <= yaxis.min) {
  699.                         ctx.lineTo(tHoz(x1), tVert(yaxis.min));
  700.                         ctx.lineTo(tHoz(x2), tVert(yaxis.min));
  701.                         continue;
  702.                     }
  703.                     
  704.                     // else it's a bit more complicated, there might
  705.                     // be two rectangles and two triangles we need to fill
  706.                     // in; to find these keep track of the current x values
  707.                     var x1old = x1, x2old = x2;
  709.                     // and clip the y values, without shortcutting
  710.                     
  711.                     // clip with ymin
  712.                     if (y1 <= y2 && y1 < yaxis.min && y2 >= yaxis.min) {
  713.                         x1 = (yaxis.min - y1) / (y2 - y1) * (x2 - x1) + x1;
  714.                         y1 = yaxis.min;
  715.                     }
  716.                     else if (y2 <= y1 && y2 < yaxis.min && y1 >= yaxis.min) {
  717.                         x2 = (yaxis.min - y1) / (y2 - y1) * (x2 - x1) + x1;
  718.                         y2 = yaxis.min;
  719.                     }
  721.                     // clip with ymax
  722.                     if (y1 >= y2 && y1 > yaxis.max && y2 <= yaxis.max) {
  723.                         x1 = (yaxis.max - y1) / (y2 - y1) * (x2 - x1) + x1;
  724.                         y1 = yaxis.max;
  725.                     }
  726.                     else if (y2 >= y1 && y2 > yaxis.max && y1 <= yaxis.max) {
  727.                         x2 = (yaxis.max - y1) / (y2 - y1) * (x2 - x1) + x1;
  728.                         y2 = yaxis.max;
  729.                     }
  732.                     // if the x value was changed we got a rectangle
  733.                     // to fill
  734.                     if (x1 != x1old) {
  735.                         if (y1 <= yaxis.min)
  736.                             top = yaxis.min;
  737.                         else
  738.                             top = yaxis.max;
  739.                         
  740.                         ctx.lineTo(tHoz(x1old), tVert(top));
  741.                         ctx.lineTo(tHoz(x1), tVert(top));
  742.                     }
  743.                     
  744.                     // fill the triangles
  745.                     ctx.lineTo(tHoz(x1), tVert(y1));
  746.                     ctx.lineTo(tHoz(x2), tVert(y2));
  748.                     // fill the other rectangle if it's there
  749.                     if (x2 != x2old) {
  750.                         if (y2 <= yaxis.min)
  751.                             top = yaxis.min;
  752.                         else
  753.                             top = yaxis.max;
  754.                         
  755.                         ctx.lineTo(tHoz(x2old), tVert(top));
  756.                         ctx.lineTo(tHoz(x2), tVert(top));
  757.                     }
  759.                     lastX = Math.max(x2, x2old);
  760.                 }
  761.                 /*
  762.                 ctx.beginPath();
  763.                 ctx.moveTo(tHoz(data[0][0]), tVert(0));
  764.                 for (var i = 0; i < data.length; i++) {
  765.                     ctx.lineTo(tHoz(data[i][0]), tVert(data[i][1]));
  766.                 }
  767.                 ctx.lineTo(tHoz(data[data.length - 1][0]), tVert(0));*/
  768.                 ctx.lineTo(tHoz(lastX), tVert(bottom));
  769.                 ctx.fill();
  770.             }
  771.             
  772.             ctx.save();
  773.             ctx.translate(plotOffset.left, plotOffset.top);
  774.             ctx.lineJoin = "round";
  776.             var lw = series.lines.lineWidth;
  777.             var sw = series.shadowSize;
  778.             // FIXME: consider another form of shadow when filling is turned on
  779.             if (sw > 0) {
  780.                 // draw shadow in two steps
  781.                 ctx.lineWidth = sw / 2;
  782.                 ctx.strokeStyle = "rgba(0,0,0,0.1)";
  783.                 plotLine(series.data, lw/2 + sw/2 + ctx.lineWidth/2);
  785.                 ctx.lineWidth = sw / 2;
  786.                 ctx.strokeStyle = "rgba(0,0,0,0.2)";
  787.                 plotLine(series.data, lw/2 + ctx.lineWidth/2);
  788.             }
  790.             ctx.lineWidth = lw;
  791.             ctx.strokeStyle = series.color;
  792.             if (series.lines.fill) {
  793.                 ctx.fillStyle = series.lines.fillColor != null ? series.lines.fillColor : parseColor(series.color).scale(null, null, null, 0.4).toString();
  794.                 plotLineArea(series.data, 0);
  795.             }
  797.             plotLine(series.data, 0);
  798.             ctx.restore();
  799.         }
  801.         function drawSeriesPoints(series) {
  802.             function plotPoints(data, radius, fill) {
  803.                 for (var i = 0; i < data.length; ++i) {
  804.                     var x = data[i][0], y = data[i][1];
  805.                     if (x < xaxis.min || x > xaxis.max || y < yaxis.min || y > yaxis.max)
  806.                         continue;
  807.                     
  808.                     ctx.beginPath();
  809.                     ctx.arc(tHoz(x), tVert(y), radius, 0, 2 * Math.PI, true);
  810.                     if (fill)
  811.                         ctx.fill();
  812.                     ctx.stroke();
  813.                 }
  814.             }
  816.             function plotPointShadows(data, offset, radius) {
  817.                 for (var i = 0; i < data.length; ++i) {
  818.                     var x = data[i][0], y = data[i][1];
  819.                     if (x < xaxis.min || x > xaxis.max || y < yaxis.min || y > yaxis.max)
  820.                         continue;
  821.                     ctx.beginPath();
  822.                     ctx.arc(tHoz(x), tVert(y) + offset, radius, 0, Math.PI, false);
  823.                     ctx.stroke();
  824.                 }
  825.             }
  826.             
  827.             ctx.save();
  828.             ctx.translate(plotOffset.left, plotOffset.top);
  830.             var lw = series.lines.lineWidth;
  831.             var sw = series.shadowSize;
  832.             if (sw > 0) {
  833.                 // draw shadow in two steps
  834.                 ctx.lineWidth = sw / 2;
  835.                 ctx.strokeStyle = "rgba(0,0,0,0.1)";
  836.                 plotPointShadows(series.data, sw/2 + ctx.lineWidth/2, series.points.radius);
  838.                 ctx.lineWidth = sw / 2;
  839.                 ctx.strokeStyle = "rgba(0,0,0,0.2)";
  840.                 plotPointShadows(series.data, ctx.lineWidth/2, series.points.radius);
  841.             }
  843.             ctx.lineWidth = series.points.lineWidth;
  844.             ctx.strokeStyle = series.color;
  845.             ctx.fillStyle = series.points.fillColor != null ? series.points.fillColor : series.color;
  846.             plotPoints(series.data, series.points.radius, series.points.fill);
  847.             ctx.restore();
  848.         }
  850.         function drawSeriesBars(series) {
  851.             function plotBars(data, barWidth, offset, fill) {
  852.                 if (data.length < 2)
  853.                     return;
  855.                 for (var i = 0; i < data.length; i++) {
  856.                     var x = data[i][0], y = data[i][1];
  857.                     var drawLeft = true, drawTop = true, drawRight = true;
  858.                     var left = x, right = x + barWidth, bottom = 0, top = y;
  860.                     if (right < xaxis.min || left > xaxis.max || top < yaxis.min || bottom > yaxis.max)
  861.                         continue;
  863.                     // clip
  864.                     if (left < xaxis.min) {
  865.                         left = xaxis.min;
  866.                         drawLeft = false;
  867.                     }
  869.                     if (right > xaxis.max) {
  870.                         right = xaxis.max;
  871.                         drawRight = false;
  872.                     }
  874.                     if (bottom < yaxis.min)
  875.                         bottom = yaxis.min;
  877.                     if (top > yaxis.max) {
  878.                         top = yaxis.max;
  879.                         drawTop = false;
  880.                     }
  882.                     // fill the bar
  883.                     if (fill) {
  884.                         ctx.beginPath();
  885.                         ctx.moveTo(tHoz(left), tVert(bottom) + offset);
  886.                         ctx.lineTo(tHoz(left), tVert(top) + offset);
  887.                         ctx.lineTo(tHoz(right), tVert(top) + offset);
  888.                         ctx.lineTo(tHoz(right), tVert(bottom) + offset);
  889.                         ctx.fill();
  890.                     }
  892.                     // draw outline
  893.                     if (drawLeft || drawRight || drawTop) {
  894.                         ctx.beginPath();
  895.                         ctx.moveTo(tHoz(left), tVert(bottom) + offset);
  896.                         if (drawLeft)
  897.                             ctx.lineTo(tHoz(left), tVert(top) + offset);
  898.                         else
  899.                             ctx.moveTo(tHoz(left), tVert(top) + offset);
  901.                         if (drawTop)
  902.                             ctx.lineTo(tHoz(right), tVert(top) + offset);
  903.                         else
  904.                             ctx.moveTo(tHoz(right), tVert(top) + offset);
  905.                         if (drawRight)
  906.                             ctx.lineTo(tHoz(right), tVert(bottom) + offset);
  907.                         else
  908.                             ctx.moveTo(tHoz(right), tVert(bottom) + offset);
  909.                         ctx.stroke();
  910.                     }
  911.                 }
  912.             }
  914.             ctx.save();
  915.             ctx.translate(plotOffset.left, plotOffset.top);
  916.             ctx.lineJoin = "round";
  918.             var bw = series.bars.barWidth;
  919.             var lw = Math.min(series.bars.lineWidth, bw);
  920.             // FIXME: figure out a way to add shadows
  921.             /*
  922.             var sw = series.shadowSize;
  923.             if (sw > 0) {
  924.                 // draw shadow in two steps
  925.                 ctx.lineWidth = sw / 2;
  926.                 ctx.strokeStyle = "rgba(0,0,0,0.1)";
  927.                 plotBars(series.data, bw, lw/2 + sw/2 + ctx.lineWidth/2, false);
  929.                 ctx.lineWidth = sw / 2;
  930.                 ctx.strokeStyle = "rgba(0,0,0,0.2)";
  931.                 plotBars(series.data, bw, lw/2 + ctx.lineWidth/2, false);
  932.             }*/
  934.             ctx.lineWidth = lw;
  935.             ctx.strokeStyle = series.color;
  936.             if (series.bars.fill) {
  937.                 ctx.fillStyle = series.bars.fillColor != null ? series.bars.fillColor : parseColor(series.color).scale(null, null, null, 0.4).toString();
  938.             }
  940.             plotBars(series.data, bw, 0, series.bars.fill);
  941.             ctx.restore();
  942.         }
  944.         function insertLegend() {
  945.             if (!options.legend.show)
  946.                 return;
  947.             
  948.             var fragments = [];
  949.             var rowStarted = false;
  950.             for (i = 0; i < series.length; ++i) {
  951.                 if (!series[i].label)
  952.                     continue;
  953.                 
  954.                 if (i % options.legend.noColumns == 0) {
  955.                     if (rowStarted)
  956.                         fragments.push('</tr>');
  957.                     fragments.push('<tr>');
  958.                     rowStarted = true;
  959.                 }
  961.                 var label = series[i].label;
  962.                 if (options.legend.labelFormatter != null)
  963.                     label = options.legend.labelFormatter(label);
  964.                 
  965.                 fragments.push(
  966.                     '<td class="legendColorBox"><div style="border:1px solid ' + options.legend.labelBoxBorderColor + ';padding:1px"><div style="width:14px;height:10px;background-color:' + series[i].color + '"></div></div></td>' +
  967.                     '<td class="legendLabel">' + label + '</td>');
  968.             }
  969.             if (rowStarted)
  970.                 fragments.push('</tr>');
  971.             
  972.             if (fragments.length > 0) {
  973.                 var table = '<table style="font-size:smaller;color:' + options.grid.color + '">' + fragments.join("") + '</table>';
  974.                 if (options.legend.container != null)
  975.                     options.legend.container.append(table);
  976.                 else {
  977.                     var pos = "";
  978.                     var p = options.legend.position, m = options.legend.margin;
  979.                     if (p.charAt(0) == "n")
  980.                         pos += 'top:' + (m + plotOffset.top) + 'px;';
  981.                     else if (p.charAt(0) == "s")
  982.                         pos += 'bottom:' + (m + plotOffset.bottom) + 'px;';
  983.                     if (p.charAt(1) == "e")
  984.                         pos += 'right:' + (m + plotOffset.right) + 'px;';
  985.                     else if (p.charAt(1) == "w")
  986.                         pos += 'left:' + (m + plotOffset.bottom) + 'px;';
  987.                     var div = $('<div class="legend" style="position:absolute;z-index:2;' + pos +'">' + table + '</div>').appendTo(target);
  988.                     if (options.legend.backgroundOpacity != 0.0) {
  989.                         // put in the transparent background
  990.                         // separately to avoid blended labels and
  991.                         // label boxes
  992.                         var c = options.legend.backgroundColor;
  993.                         if (c == null) {
  994.                             var tmp;
  995.                             if (options.grid.backgroundColor != null)
  996.                                 tmp = options.grid.backgroundColor;
  997.                             else
  998.                                 tmp = extractColor(div);
  999.                             c = parseColor(tmp).adjust(null, null, null, 1).toString();
  1000.                         }
  1001.                         $('<div style="position:absolute;width:' + div.width() + 'px;height:' + div.height() + 'px;' + pos +'background-color:' + c + ';"> </div>').appendTo(target).css('opacity', options.legend.backgroundOpacity);
  1002.                         
  1003.                     }
  1004.                 }
  1005.             }
  1006.         }
  1008.         var lastMousePos = { pageX: null, pageY: null };
  1009.         var selection = { first: { x: -1, y: -1}, second: { x: -1, y: -1} };
  1010.         var prevSelection = null;
  1011.         var selectionInterval = null;
  1012.         var ignoreClick = false;
  1013.         
  1014.         function onMouseMove(ev) {
  1015.             // FIXME: temp. work-around until jQuery bug 1871 is fixed
  1016.             var e = ev || window.event;
  1017.             if (e.pageX == null && e.clientX != null) {
  1018.                 var de = document.documentElement, b = document.body;
  1019.                 lastMousePos.pageX = e.clientX + (de && de.scrollLeft || b.scrollLeft || 0);
  1020.                 lastMousePos.pageY = e.clientY + (de && de.scrollTop || b.scrollTop || 0);
  1021.             }
  1022.             else {
  1023.                 lastMousePos.pageX = e.pageX;
  1024.                 lastMousePos.pageY = e.pageY;
  1025.             }
  1026.         }
  1027.         
  1028.         function onMouseDown(e) {
  1029.             if (e.which != 1)  // only accept left-click
  1030.                 return;
  1031.             
  1032.             setSelectionPos(selection.first, e);
  1033.                 
  1034.             if (selectionInterval != null)
  1035.                 clearInterval(selectionInterval);
  1036.             lastMousePos.pageX = null;
  1037.             selectionInterval = setInterval(updateSelectionOnMouseMove, 200);
  1038.             $(document).one("mouseup", onSelectionMouseUp);
  1039.         }
  1041.         function onClick(e) {
  1042.             if (ignoreClick) {
  1043.                 ignoreClick = false;
  1044.                 return;
  1045.             }
  1046.             
  1047.             var offset = $(overlay).offset();
  1048.             var pos = {};
  1049.             pos.x = e.pageX - offset.left - plotOffset.left;
  1050.             pos.x = xaxis.min + pos.x / hozScale;
  1051.             pos.y = e.pageY - offset.top - plotOffset.top;
  1052.             pos.y = yaxis.max - pos.y / vertScale;
  1054.             target.trigger("plotclick", [ pos ]);
  1055.         }
  1056.         
  1057.         function triggerSelectedEvent() {
  1058.             var x1, x2, y1, y2;
  1059.             if (selection.first.x <= selection.second.x) {
  1060.                 x1 = selection.first.x;
  1061.                 x2 = selection.second.x;
  1062.             }
  1063.             else {
  1064.                 x1 = selection.second.x;
  1065.                 x2 = selection.first.x;
  1066.             }
  1068.             if (selection.first.y >= selection.second.y) {
  1069.                 y1 = selection.first.y;
  1070.                 y2 = selection.second.y;
  1071.             }
  1072.             else {
  1073.                 y1 = selection.second.y;
  1074.                 y2 = selection.first.y;
  1075.             }
  1076.             
  1077.             x1 = xaxis.min + x1 / hozScale;
  1078.             x2 = xaxis.min + x2 / hozScale;
  1080.             y1 = yaxis.max - y1 / vertScale;
  1081.             y2 = yaxis.max - y2 / vertScale;
  1083.             target.trigger("selected", [ { x1: x1, y1: y1, x2: x2, y2: y2 } ]);
  1084.         }
  1085.         
  1086.         function onSelectionMouseUp(e) {
  1087.             if (selectionInterval != null) {
  1088.                 clearInterval(selectionInterval);
  1089.                 selectionInterval = null;
  1090.             }
  1092.             setSelectionPos(selection.second, e);
  1093.             clearSelection();
  1094.             if (!selectionIsSane() || e.which != 1)
  1095.                 return false;
  1096.             
  1097.             drawSelection();
  1098.             triggerSelectedEvent();
  1099.             ignoreClick = true;
  1101.             return false;
  1102.         }
  1104.         function setSelectionPos(pos, e) {
  1105.             var offset = $(overlay).offset();
  1106.             if (options.selection.mode == "y") {
  1107.                 if (pos == selection.first)
  1108.                     pos.x = 0;
  1109.                 else
  1110.                     pos.x = plotWidth;
  1111.             }
  1112.             else {
  1113.                 pos.x = e.pageX - offset.left - plotOffset.left;
  1114.                 pos.x = Math.min(Math.max(0, pos.x), plotWidth);
  1115.             }
  1117.             if (options.selection.mode == "x") {
  1118.                 if (pos == selection.first)
  1119.                     pos.y = 0;
  1120.                 else
  1121.                     pos.y = plotHeight;
  1122.             }
  1123.             else {
  1124.         pos.y = e.pageY - offset.top - plotOffset.top;
  1125.                 pos.y = Math.min(Math.max(0, pos.y), plotHeight);
  1126.             }
  1127.         }
  1128.         
  1129.         function updateSelectionOnMouseMove() {
  1130.             if (lastMousePos.pageX == null)
  1131.                 return;
  1132.             
  1133.             setSelectionPos(selection.second, lastMousePos);
  1134.             clearSelection();
  1135.             if (selectionIsSane())
  1136.                 drawSelection();
  1137.         }
  1139.         function clearSelection() {
  1140.             if (prevSelection == null)
  1141.                 return;
  1143.             var x = Math.min(prevSelection.first.x, prevSelection.second.x),
  1144.                 y = Math.min(prevSelection.first.y, prevSelection.second.y),
  1145.                 w = Math.abs(prevSelection.second.x - prevSelection.first.x),
  1146.                 h = Math.abs(prevSelection.second.y - prevSelection.first.y);
  1147.             
  1148.             octx.clearRect(x + plotOffset.left - octx.lineWidth,
  1149.                            y + plotOffset.top - octx.lineWidth,
  1150.                            w + octx.lineWidth*2,
  1151.                            h + octx.lineWidth*2);
  1152.             
  1153.             prevSelection = null;
  1154.         }
  1155.         
  1156.         function setSelection(area) {
  1157.             clearSelection();
  1158.             
  1159.             if (options.selection.mode == "x") {
  1160.                 selection.first.y = 0;
  1161.                 selection.second.y = plotHeight;
  1162.             }
  1163.             else {
  1164.                 selection.first.y = (yaxis.max - area.y1) * vertScale;
  1165.                 selection.second.y = (yaxis.max - area.y2) * vertScale;
  1166.             }
  1167.             if (options.selection.mode == "y") {
  1168.                 selection.first.x = 0;
  1169.                 selection.second.x = plotWidth;
  1170.             }
  1171.             else {
  1172.                 selection.first.x = (area.x1 - xaxis.min) * hozScale;
  1173.                 selection.second.x = (area.x2 - xaxis.min) * hozScale;
  1174.             }
  1176.             drawSelection();
  1177.             triggerSelectedEvent();
  1178.         }
  1179.         
  1180.         function drawSelection() {
  1181.             if (prevSelection != null &&
  1182.                 selection.first.x == prevSelection.first.x &&
  1183.                 selection.first.y == prevSelection.first.y && 
  1184.                 selection.second.x == prevSelection.second.x &&
  1185.                 selection.second.y == prevSelection.second.y)
  1186.                 return;
  1187.             
  1188.             octx.strokeStyle = parseColor(options.selection.color).scale(null, null, null, 0.8).toString();
  1189.             octx.lineWidth = 1;
  1190.             ctx.lineJoin = "round";
  1191.             octx.fillStyle = parseColor(options.selection.color).scale(null, null, null, 0.4).toString();
  1193.             prevSelection = { first:  { x: selection.first.x,
  1194.                                         y: selection.first.y },
  1195.                               second: { x: selection.second.x,
  1196.                                         y: selection.second.y } };
  1198.             var x = Math.min(selection.first.x, selection.second.x),
  1199.                 y = Math.min(selection.first.y, selection.second.y),
  1200.                 w = Math.abs(selection.second.x - selection.first.x),
  1201.                 h = Math.abs(selection.second.y - selection.first.y);
  1202.             
  1203.             octx.fillRect(x + plotOffset.left, y + plotOffset.top, w, h);
  1204.             octx.strokeRect(x + plotOffset.left, y + plotOffset.top, w, h);
  1205.         }
  1207.         function selectionIsSane() {
  1208.             var minSize = 5;
  1209.             return Math.abs(selection.second.x - selection.first.x) >= minSize &&
  1210.                 Math.abs(selection.second.y - selection.first.y) >= minSize;
  1211.         }
  1212.     }
  1213.     
  1214.     $.plot = function(target, data, options) {
  1215.         var plot = new Plot(target, data, options);
  1216.         /*var t0 = new Date();     
  1217.         var t1 = new Date();
  1218. var tstr = "time used (msecs): " + (t1.getTime() - t0.getTime())
  1219. if (window.console)
  1220.             console.log(tstr);
  1221. else
  1222.     alert(tstr);*/
  1223.         return plot;
  1224.     };
  1226.     function getMagnitude(x) {
  1227.         return Math.pow(10, Math.floor(Math.log(x) / Math.LN10));
  1228.     }
  1230.        
  1231.     // color helpers, inspiration from the jquery color animation
  1232.     // plugin by John Resig
  1233.     function Color (r, g, b, a) {
  1234.        
  1235.         var rgba = ['r','g','b','a'];
  1236.         var x = 4; //rgba.length
  1237.        
  1238.         while (-1<--x) {
  1239.             this[rgba[x]] = arguments[x] || ((x==3) ? 1.0 : 0);
  1240.         }
  1241.        
  1242.         this.toString = function() {
  1243.             if (this.a >= 1.0) {
  1244.                 return "rgb("+[this.r,this.g,this.b].join(",")+")";
  1245.             } else {
  1246.                 return "rgba("+[this.r,this.g,this.b,this.a].join(",")+")";
  1247.             }
  1248.         };
  1250.         this.scale = function(rf, gf, bf, af) {
  1251.             x = 4; //rgba.length
  1252.             while (-1<--x) {
  1253.                 if (arguments[x] != null)
  1254.                     this[rgba[x]] *= arguments[x];
  1255.             }
  1256.             return this.normalize();
  1257.         };
  1259.         this.adjust = function(rd, gd, bd, ad) {
  1260.             x = 4; //rgba.length
  1261.             while (-1<--x) {
  1262.                 if (arguments[x] != null)
  1263.                     this[rgba[x]] += arguments[x];
  1264.             }
  1265.             return this.normalize();
  1266.         };
  1268.         this.clone = function() {
  1269.             return new Color(this.r, this.b, this.g, this.a);
  1270.         };
  1272.         var limit = function(val,minVal,maxVal) {
  1273.             return Math.max(Math.min(val, maxVal), minVal);
  1274.         };
  1276.         this.normalize = function() {
  1277.             this.r = limit(parseInt(this.r), 0, 255);
  1278.             this.g = limit(parseInt(this.g), 0, 255);
  1279.             this.b = limit(parseInt(this.b), 0, 255);
  1280.             this.a = limit(this.a, 0, 1);
  1281.             return this;
  1282.         };
  1284.         this.normalize();
  1285.     }
  1286.     
  1287.     var lookupColors = {
  1288. aqua:[0,255,255],
  1289. azure:[240,255,255],
  1290. beige:[245,245,220],
  1291. black:[0,0,0],
  1292. blue:[0,0,255],
  1293. brown:[165,42,42],
  1294. cyan:[0,255,255],
  1295. darkblue:[0,0,139],
  1296. darkcyan:[0,139,139],
  1297. darkgrey:[169,169,169],
  1298. darkgreen:[0,100,0],
  1299. darkkhaki:[189,183,107],
  1300. darkmagenta:[139,0,139],
  1301. darkolivegreen:[85,107,47],
  1302. darkorange:[255,140,0],
  1303. darkorchid:[153,50,204],
  1304. darkred:[139,0,0],
  1305. darksalmon:[233,150,122],
  1306. darkviolet:[148,0,211],
  1307. fuchsia:[255,0,255],
  1308. gold:[255,215,0],
  1309. green:[0,128,0],
  1310. indigo:[75,0,130],
  1311. khaki:[240,230,140],
  1312. lightblue:[173,216,230],
  1313. lightcyan:[224,255,255],
  1314. lightgreen:[144,238,144],
  1315. lightgrey:[211,211,211],
  1316. lightpink:[255,182,193],
  1317. lightyellow:[255,255,224],
  1318. lime:[0,255,0],
  1319. magenta:[255,0,255],
  1320. maroon:[128,0,0],
  1321. navy:[0,0,128],
  1322. olive:[128,128,0],
  1323. orange:[255,165,0],
  1324. pink:[255,192,203],
  1325. purple:[128,0,128],
  1326. violet:[128,0,128],
  1327. red:[255,0,0],
  1328. silver:[192,192,192],
  1329. white:[255,255,255],
  1330. yellow:[255,255,0]
  1331.     };    
  1333.     function extractColor(element) {
  1334.         var color, elem = element;
  1335. do {
  1336.     color = elem.css("background-color").toLowerCase();
  1337.             // keep going until we find an element that has color, or
  1338.             // we hit the body
  1339.     if (color != '' && color != 'transparent')
  1340. break;
  1341.             elem = elem.parent();
  1342. } while (!$.nodeName(elem.get(0), "body"));
  1344.         // catch Safari's way of signalling transparent
  1345.         if (color == "rgba(0, 0, 0, 0)") 
  1346.             return "transparent";
  1347.         
  1348.         return color;
  1349.     }
  1350.     
  1351.     // parse string, returns Color
  1352.     function parseColor(str) {
  1353.         // Some named colors to work with
  1354.         // From Interface by Stefan Petre
  1355.         // http://interface.eyecon.ro/
  1357. var result;
  1359. // Look for rgb(num,num,num)
  1360. if (result = /rgb(s*([0-9]{1,3})s*,s*([0-9]{1,3})s*,s*([0-9]{1,3})s*)/.exec(str))
  1361.     return new Color(parseInt(result[1]), parseInt(result[2]), parseInt(result[3]));
  1363. // Look for rgba(num,num,num,num)
  1364. if (result = /rgba(s*([0-9]{1,3})s*,s*([0-9]{1,3})s*,s*([0-9]{1,3})s*,s*([0-9]+(?:.[0-9]+)?)s*)/.exec(str))
  1365.     return new Color(parseInt(result[1]), parseInt(result[2]), parseInt(result[3]), parseFloat(result[4]));
  1366.         
  1367. // Look for rgb(num%,num%,num%)
  1368. if (result = /rgb(s*([0-9]+(?:.[0-9]+)?)%s*,s*([0-9]+(?:.[0-9]+)?)%s*,s*([0-9]+(?:.[0-9]+)?)%s*)/.exec(str))
  1369.     return new Color(parseFloat(result[1])*2.55, parseFloat(result[2])*2.55, parseFloat(result[3])*2.55);
  1371. // Look for rgba(num%,num%,num%,num)
  1372. if (result = /rgba(s*([0-9]+(?:.[0-9]+)?)%s*,s*([0-9]+(?:.[0-9]+)?)%s*,s*([0-9]+(?:.[0-9]+)?)%s*,s*([0-9]+(?:.[0-9]+)?)s*)/.exec(str))
  1373.     return new Color(parseFloat(result[1])*2.55, parseFloat(result[2])*2.55, parseFloat(result[3])*2.55, parseFloat(result[4]));
  1374.         
  1375. // Look for #a0b1c2
  1376. if (result = /#([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})/.exec(str))
  1377.     return new Color(parseInt(result[1],16), parseInt(result[2],16), parseInt(result[3],16));
  1379. // Look for #fff
  1380. if (result = /#([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])/.exec(str))
  1381.     return new Color(parseInt(result[1]+result[1],16), parseInt(result[2]+result[2],16), parseInt(result[3]+result[3],16));
  1383. // Otherwise, we're most likely dealing with a named color
  1384.         var name = jQuery.trim(str).toLowerCase();
  1385.         if (name == "transparent")
  1386.             return new Color(255, 255, 255, 0);
  1387.         else {
  1388.             result = lookupColors[name];
  1389.     return new Color(result[0], result[1], result[2]);
  1390.         }
  1391.     }
  1393. })(jQuery);