text: /**
   * jqPlot
   * Pure JavaScript plotting plugin using jQuery
   *
   * Version: 1.0.8
   * Revision: 1250
   *
   * Copyright (c) 2009-2013 Chris Leonello
   * jqPlot is currently available for use in all personal or commercial projects 
   * under both the MIT (http://www.opensource.org/licenses/mit-license.php) and GPL 
   * version 2.0 (http://www.gnu.org/licenses/gpl-2.0.html) licenses. This means that you can 
   * choose the license that best suits your project and use it accordingly. 
   *
   * Although not required, the author would appreciate an email letting him 
   * know of any substantial use of jqPlot.  You can reach the author at: 
   * chris at jqplot dot com or see http://www.jqplot.com/info.php .
   *
   * If you are feeling kind and generous, consider supporting the project by
   * making a donation at: http://www.jqplot.com/donate.php .
   *
   * sprintf functions contained in jqplot.sprintf.js by Ash Searle:
   *
   *     version 2007.04.27
   *     author Ash Searle
   *     http://hexmen.com/blog/2007/03/printf-sprintf/
   *     http://hexmen.com/js/sprintf.js
   *     The author (Ash Searle) has placed this code in the public domain:
   *     "This code is unrestricted: you are free to use it however you like."
   * 
   */
  (function($) {
      /**
       * Class: $.jqplot.OHLCRenderer
       * jqPlot Plugin to draw Open Hi Low Close, Candlestick and Hi Low Close charts.
       * 
       * To use this plugin, include the renderer js file in 
       * your source:
       * 
       * > <script type="text/javascript" src="plugins/jqplot.ohlcRenderer.js"></script>
       * 
       * You will most likely want to use a date axis renderer
       * for the x axis also, so include the date axis render js file also:
       * 
       * > <script type="text/javascript" src="plugins/jqplot.dateAxisRenderer.js"></script>
       * 
       * Then you set the renderer in the series options on your plot:
       * 
       * > series: [{renderer:$.jqplot.OHLCRenderer}]
       * 
       * For OHLC and candlestick charts, data should be specified
       * like so:
       * 
       * > dat = [['07/06/2009',138.7,139.68,135.18,135.4], ['06/29/2009',143.46,144.66,139.79,140.02], ...]
       * 
       * If the data array has only 4 values per point instead of 5,
       * the renderer will create a Hi Low Close module instead.  In that case,
       * data should be supplied like:
       * 
       * > dat = [['07/06/2009',139.68,135.18,135.4], ['06/29/2009',144.66,139.79,140.02], ...]
       * 
       * To generate a candlestick module instead of an OHLC module,
       * set the "candlestick" option to true:
       * 
       * > series: [{renderer:$.jqplot.OHLCRenderer, rendererOptions:{candleStick:true}}],
       * 
       */
      $.jqplot.OHLCRenderer = function(){
          // subclass line renderer to make use of some of its methods.
          $.jqplot.LineRenderer.call(this);
          // prop: candleStick
          // true to render module as candleStick.
          // Must have an open price, cannot be a hlc module.
          this.candleStick = false;
          // prop: tickLength
          // length of the line in pixels indicating open and close price.
          // Default will auto calculate based on plot width and 
          // number of points displayed.
          this.tickLength = 'auto';
          // prop: bodyWidth
          // width of the candlestick body in pixels.  Default will auto calculate
          // based on plot width and number of candlesticks displayed.
          this.bodyWidth = 'auto';
          // prop: openColor
          // color of the open price tick mark.  Default is series color.
          this.openColor = null;
          // prop: closeColor
          // color of the close price tick mark.  Default is series color.
          this.closeColor = null;
          // prop: wickColor
          // color of the hi-lo line thorugh the candlestick body.
          // Default is the series color.
          this.wickColor = null;
          // prop: fillUpBody
          // true to render an "up" day (close price greater than open price)
          // with a filled candlestick body.
          this.fillUpBody = false;
          // prop: fillDownBody
          // true to render a "down" day (close price lower than open price)
          // with a filled candlestick body.
          this.fillDownBody = true;
          // prop: upBodyColor
          // Color of candlestick body of an "up" day.  Default is series color.
          this.upBodyColor = null;
          // prop: downBodyColor
          // Color of candlestick body on a "down" day.  Default is series color.
          this.downBodyColor = null;
          // prop: hlc
          // true if is a hi-low-close module (no open price).
          // This is determined automatically from the series data.
          this.hlc = false;
          // prop: lineWidth
          // Width of the hi-low line and open/close ticks.
          // Must be set in the rendererOptions for the series.
          this.lineWidth = 1.5;
          this._tickLength;
          this._bodyWidth;
      };
      
      $.jqplot.OHLCRenderer.prototype = new $.jqplot.LineRenderer();
      $.jqplot.OHLCRenderer.prototype.constructor = $.jqplot.OHLCRenderer;
      
      // called with scope of series.
      $.jqplot.OHLCRenderer.prototype.init = function(options) {
          options = options || {};
          // lineWidth has to be set on the series, changes in renderer
          // constructor have no effect.  set the default here
          // if no renderer option for lineWidth is specified.
          this.lineWidth = options.lineWidth || 1.5;
          $.jqplot.LineRenderer.prototype.init.call(this, options);
          this._type = 'ohlc';
          // set the yaxis data bounds here to account for hi and low values
          var db = this._yaxis._dataBounds;
          var d = this._plotData;
          // if data points have less than 5 values, force a hlc module.
          if (d[0].length < 5) {
              this.renderer.hlc = true;
  
              for (var j=0; j<d.length; j++) { 
                  if (d[j][2] < db.min || db.min == null) {
                      db.min = d[j][2];
                  }
                  if (d[j][1] > db.max || db.max == null) {
                      db.max = d[j][1];
                  }             
              }
          }
          else {
              for (var j=0; j<d.length; j++) { 
                  if (d[j][3] < db.min || db.min == null) {
                      db.min = d[j][3];
                  }
                  if (d[j][2] > db.max || db.max == null) {
                      db.max = d[j][2];
                  }             
              }
          }
          
      };
      
      // called within scope of series.
      $.jqplot.OHLCRenderer.prototype.draw = function(ctx, gd, options) {
          var d = this.data;
          var xmin = this._xaxis.min;
          var xmax = this._xaxis.max;
          // index of last value below range of plot.
          var xminidx = 0;
          // index of first value above range of plot.
          var xmaxidx = d.length;
          var xp = this._xaxis.series_u2p;
          var yp = this._yaxis.series_u2p;
          var i, prevColor, ops, b, h, w, a, points;
          var o;
          var r = this.renderer;
          var opts = (options != undefined) ? options : {};
          var shadow = (opts.shadow != undefined) ? opts.shadow : this.shadow;
          var fill = (opts.fill != undefined) ? opts.fill : this.fill;
          var fillAndStroke = (opts.fillAndStroke != undefined) ? opts.fillAndStroke : this.fillAndStroke;
          r.bodyWidth = (opts.bodyWidth != undefined) ? opts.bodyWidth : r.bodyWidth;
          r.tickLength = (opts.tickLength != undefined) ? opts.tickLength : r.tickLength;
          ctx.save();
          if (this.show) {
              var x, open, hi, low, close;
              // need to get widths based on number of points shown,
              // not on total number of points.  Use the results 
              // to speed up drawing in next step.
              for (var i=0; i<d.length; i++) {
                  if (d[i][0] < xmin) {
                      xminidx = i;
                  }
                  else if (d[i][0] < xmax) {
                      xmaxidx = i+1;
                  }
              }
  
              var dwidth = this.gridData[xmaxidx-1][0] - this.gridData[xminidx][0];
              var nvisiblePoints = xmaxidx - xminidx;
              try {
                  var dinterval = Math.abs(this._xaxis.series_u2p(parseInt(this._xaxis._intervalStats[0].sortedIntervals[0].interval, 10)) - this._xaxis.series_u2p(0)); 
              }
  
              catch (e) {
                  var dinterval = dwidth / nvisiblePoints;
              }
              
              if (r.candleStick) {
                  if (typeof(r.bodyWidth) == 'number') {
                      r._bodyWidth = r.bodyWidth;
                  }
                  else {
                      r._bodyWidth = Math.min(20, dinterval/1.65);
                  }
              }
              else {
                  if (typeof(r.tickLength) == 'number') {
                      r._tickLength = r.tickLength;
                  }
                  else {
                      r._tickLength = Math.min(10, dinterval/3.5);
                  }
              }
              
              for (var i=xminidx; i<xmaxidx; i++) {
                  x = xp(d[i][0]);
                  if (r.hlc) {
                      open = null;
                      hi = yp(d[i][1]);
                      low = yp(d[i][2]);
                      close = yp(d[i][3]);
                  }
                  else {
                      open = yp(d[i][1]);
                      hi = yp(d[i][2]);
                      low = yp(d[i][3]);
                      close = yp(d[i][4]);
                  }
                  o = {};
                  if (r.candleStick && !r.hlc) {
                      w = r._bodyWidth;
                      a = x - w/2;
                      // draw candle
                      // determine if candle up or down
                      // up, remember grid coordinates increase downward
                      if (close < open) {
                          // draw wick
                          if (r.wickColor) {
                              o.color = r.wickColor;
                          }
                          else if (r.downBodyColor) {
                              o.color = r.upBodyColor;
                          }
                          ops = $.extend(true, {}, opts, o);
                          r.shapeRenderer.draw(ctx, [[x, hi], [x, close]], ops); 
                          r.shapeRenderer.draw(ctx, [[x, open], [x, low]], ops); 
                          o = {};
                          b = close;
                          h = open - close;
                          // if color specified, use it
                          if (r.fillUpBody) {
                              o.fillRect = true;
                          }
                          else {
                              o.strokeRect = true;
                              w = w - this.lineWidth;
                              a = x - w/2;
                          }
                          if (r.upBodyColor) {
                              o.color = r.upBodyColor;
                              o.fillStyle = r.upBodyColor;
                          }
                          points = [a, b, w, h];
                      }
                      // down
                      else if (close >  open) {
                          // draw wick
                          if (r.wickColor) {
                              o.color = r.wickColor;
                          }
                          else if (r.downBodyColor) {
                              o.color = r.downBodyColor;
                          }
                          ops = $.extend(true, {}, opts, o);
                          r.shapeRenderer.draw(ctx, [[x, hi], [x, open]], ops); 
                          r.shapeRenderer.draw(ctx, [[x, close], [x, low]], ops);
                           
                          o = {};
                          
                          b = open;
                          h = close - open;
                          // if color specified, use it
                          if (r.fillDownBody) {
                              o.fillRect = true;
                          }
                          else {
                              o.strokeRect = true;
                              w = w - this.lineWidth;
                              a = x - w/2;
                          }
                          if (r.downBodyColor) {
                              o.color = r.downBodyColor;
                              o.fillStyle = r.downBodyColor;
                          }
                          points = [a, b, w, h];
                      }
                      // even, open = close
                      else  {
                          // draw wick
                          if (r.wickColor) {
                              o.color = r.wickColor;
                          }
                          ops = $.extend(true, {}, opts, o);
                          r.shapeRenderer.draw(ctx, [[x, hi], [x, low]], ops); 
                          o = {};
                          o.fillRect = false;
                          o.strokeRect = false;
                          a = [x - w/2, open];
                          b = [x + w/2, close];
                          w = null;
                          h = null;
                          points = [a, b];
                      }
                      ops = $.extend(true, {}, opts, o);
                      r.shapeRenderer.draw(ctx, points, ops);
                  }
                  else {
                      prevColor = opts.color;
                      if (r.openColor) {
                          opts.color = r.openColor;
                      }
                      // draw open tick
                      if (!r.hlc) {
                          r.shapeRenderer.draw(ctx, [[x-r._tickLength, open], [x, open]], opts);    
                      }
                      opts.color = prevColor;
                      // draw wick
                      if (r.wickColor) {
                          opts.color = r.wickColor;
                      }
                      r.shapeRenderer.draw(ctx, [[x, hi], [x, low]], opts); 
                      opts.color  = prevColor;
                      // draw close tick
                      if (r.closeColor) {
                          opts.color = r.closeColor;
                      }
                      r.shapeRenderer.draw(ctx, [[x, close], [x+r._tickLength, close]], opts); 
                      opts.color = prevColor;
                  }
              }
          }
          
          ctx.restore();
      };  
      
      $.jqplot.OHLCRenderer.prototype.drawShadow = function(ctx, gd, options) {
          // This is a no-op, shadows drawn with lines.
      };
      
      // called with scope of plot.
      $.jqplot.OHLCRenderer.checkOptions = function(target, data, options) {
          // provide some sensible highlighter options by default
          // These aren't good for hlc, only for ohlc or candlestick
          if (!options.highlighter) {
              options.highlighter = {
                  showMarker:false,
                  tooltipAxes: 'y',
                  yvalues: 4,
                  formatString:'<table class="jqplot-highlighter"><tr><td>date:</td><td>%s</td></tr><tr><td>open:</td><td>%s</td></tr><tr><td>hi:</td><td>%s</td></tr><tr><td>low:</td><td>%s</td></tr><tr><td>close:</td><td>%s</td></tr></table>'
              };
          }
      };
      
      //$.jqplot.preInitHooks.push($.jqplot.OHLCRenderer.checkOptions);
      
  })(jQuery);    
  