Subversion-Projekte lars-tiefland.cienc

/**

 * Title: jqPlot Charts

 *

 * Pure JavaScript plotting plugin for jQuery.

 *

 * About: Version

 *

 * version: 1.0.8

 * revision: 1250

 *

 * About: Copyright & License

 *

 * Copyright (c) 2009-2013 Chris Leonello

 * jqPlot is currently available for use in all personal or commercial projects

 * under both the MIT and GPL version 2.0 licenses. This means that you can

 * choose the license that best suits your project and use it accordingly.

 *

 * See <GPL Version 2> and <MIT License> contained within this distribution for further information.

 *

 * 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.  This is, of course, not required.

 *

 * 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."

 *

 *

 * About: Introduction

 *

 * jqPlot requires jQuery (1.4+ required for certain features). jQuery 1.4.2 is included in the distribution.

 * To use jqPlot include jQuery, the jqPlot jQuery plugin, the jqPlot css file and optionally

 * the excanvas script for IE support in your web page:

 *

 * > <!--[if lt IE 9]><script language="javascript" type="text/javascript" src="excanvas.js"></script><![endif]-->

 * > <script language="javascript" type="text/javascript" src="jquery-1.4.4.min.js"></script>

 * > <script language="javascript" type="text/javascript" src="jquery.jqplot.min.js"></script>

 * > <link rel="stylesheet" type="text/css" href="jquery.jqplot.css" />

 *

 * jqPlot can be customized by overriding the defaults of any of the objects which make

 * up the plot. The general usage of jqplot is:

 *

 * > chart = $.jqplot('targetElemId', [dataArray,...], {optionsObject});

 *

 * The options available to jqplot are detailed in <jqPlot Options> in the jqPlotOptions.txt file.

 *

 * An actual call to $.jqplot() may look like the

 * examples below:

 *

 * > chart = $.jqplot('chartdiv',  [[[1, 2],[3,5.12],[5,13.1],[7,33.6],[9,85.9],[11,219.9]]]);

 *

 * or

 *

 * > dataArray = [34,12,43,55,77];

 * > chart = $.jqplot('targetElemId', [dataArray, ...], {title:'My Plot', axes:{yaxis:{min:20, max:100}}});

 *

 * For more inforrmation, see <jqPlot Usage>.

 *

 * About: Usage

 *

 * See <jqPlot Usage>

 *

 * About: Available Options

 *

 * See <jqPlot Options> for a list of options available thorugh the options object (not complete yet!)

 *

 * About: Options Usage

 *

 * See <Options Tutorial>

 *

 * About: Changes

 *

 * See <Change Log>

 *

 */

(function($) {

    // make sure undefined is undefined

    var undefined;

    $.fn.emptyForce = function() {

      for ( var i = 0, elem; (elem = $(this)[i]) != null; i++ ) {

        // Remove element nodes and prevent memory leaks

        if ( elem.nodeType === 1 ) {

          $.cleanData( elem.getElementsByTagName("*") );

        }

        // Remove any remaining nodes

        if ($.jqplot.use_excanvas) {

          elem.outerHTML = "";

        }

        else {

          while ( elem.firstChild ) {

            elem.removeChild( elem.firstChild );

          }

        }

        elem = null;

      }

      return $(this);

    };

    $.fn.removeChildForce = function(parent) {

      while ( parent.firstChild ) {

        this.removeChildForce( parent.firstChild );

        parent.removeChild( parent.firstChild );

      }

    };

    $.fn.jqplot = function() {

        var datas = [];

        var options = [];

        // see how many data arrays we have

        for (var i=0, l=arguments.length; i<l; i++) {

            if ($.isArray(arguments[i])) {

                datas.push(arguments[i]);

            }

            else if ($.isPlainObject(arguments[i])) {

                options.push(arguments[i]);

            }

        }

        return this.each(function(index) {

            var tid,

                plot,

                $this = $(this),

                dl = datas.length,

                ol = options.length,

                data,

                opts;

            if (index < dl) {

                data = datas[index];

            }

            else {

                data = dl ? datas[dl-1] : null;

            }

            if (index < ol) {

                opts = options[index];

            }

            else {

                opts = ol ? options[ol-1] : null;

            }

            // does el have an id?

            // if not assign it one.

            tid = $this.attr('id');

            if (tid === undefined) {

                tid = 'jqplot_target_' + $.jqplot.targetCounter++;

                $this.attr('id', tid);

            }

            plot = $.jqplot(tid, data, opts);

            $this.data('jqplot', plot);

        });

    };

    /**

     * Namespace: $.jqplot

     * jQuery function called by the user to create a plot.

     *

     * Parameters:

     * target - ID of target element to render the plot into.

     * data - an array of data series.

     * options - user defined options object.  See the individual classes for available options.

     *

     * Properties:

     * config - object to hold configuration information for jqPlot plot object.

     *

     * attributes:

     * enablePlugins - False to disable plugins by default.  Plugins must then be explicitly

     *   enabled in the individual plot options.  Default: false.

     *   This property sets the "show" property of certain plugins to true or false.

     *   Only plugins that can be immediately active upon loading are affected.  This includes

     *   non-renderer plugins like cursor, dragable, highlighter, and trendline.

     * defaultHeight - Default height for plots where no css height specification exists.  This

     *   is a jqplot wide default.

     * defaultWidth - Default height for plots where no css height specification exists.  This

     *   is a jqplot wide default.

     */

    $.jqplot = function(target, data, options) {

        var _data = null, _options = null;

        if (arguments.length === 3) {

            _data = data;

            _options = options;

        }

        else if (arguments.length === 2) {

            if ($.isArray(data)) {

                _data = data;

            }

            else if ($.isPlainObject(data)) {

                _options = data;

            }

        }

        if (_data === null && _options !== null && _options.data) {

            _data = _options.data;

        }

        var plot = new jqPlot();

        // remove any error class that may be stuck on target.

        $('#'+target).removeClass('jqplot-error');

        if ($.jqplot.config.catchErrors) {

            try {

                plot.init(target, _data, _options);

                plot.draw();

                plot.themeEngine.init.call(plot);

                return plot;

            }

            catch(e) {

                var msg = $.jqplot.config.errorMessage || e.message;

                $('#'+target).append('<div class="jqplot-error-message">'+msg+'</div>');

                $('#'+target).addClass('jqplot-error');

                document.getElementById(target).style.background = $.jqplot.config.errorBackground;

                document.getElementById(target).style.border = $.jqplot.config.errorBorder;

                document.getElementById(target).style.fontFamily = $.jqplot.config.errorFontFamily;

                document.getElementById(target).style.fontSize = $.jqplot.config.errorFontSize;

                document.getElementById(target).style.fontStyle = $.jqplot.config.errorFontStyle;

                document.getElementById(target).style.fontWeight = $.jqplot.config.errorFontWeight;

            }

        }

        else {

            plot.init(target, _data, _options);

            plot.draw();

            plot.themeEngine.init.call(plot);

            return plot;

        }

    };

    $.jqplot.version = "1.0.8";

    $.jqplot.revision = "1250";

    $.jqplot.targetCounter = 1;

    // canvas manager to reuse canvases on the plot.

    // Should help solve problem of canvases not being freed and

    // problem of waiting forever for firefox to decide to free memory.

    $.jqplot.CanvasManager = function() {

        // canvases are managed globally so that they can be reused

        // across plots after they have been freed

        if (typeof $.jqplot.CanvasManager.canvases == 'undefined') {

            $.jqplot.CanvasManager.canvases = [];

            $.jqplot.CanvasManager.free = [];

        }

        var myCanvases = [];

        this.getCanvas = function() {

            var canvas;

            var makeNew = true;

            if (!$.jqplot.use_excanvas) {

                for (var i = 0, l = $.jqplot.CanvasManager.canvases.length; i < l; i++) {

                    if ($.jqplot.CanvasManager.free[i] === true) {

                        makeNew = false;

                        canvas = $.jqplot.CanvasManager.canvases[i];

                        // $(canvas).removeClass('jqplot-canvasManager-free').addClass('jqplot-canvasManager-inuse');

                        $.jqplot.CanvasManager.free[i] = false;

                        myCanvases.push(i);

                        break;

                    }

                }

            }

            if (makeNew) {

                canvas = document.createElement('canvas');

                myCanvases.push($.jqplot.CanvasManager.canvases.length);

                $.jqplot.CanvasManager.canvases.push(canvas);

                $.jqplot.CanvasManager.free.push(false);

            }

            return canvas;

        };

        // this method has to be used after settings the dimesions

        // on the element returned by getCanvas()

        this.initCanvas = function(canvas) {

            if ($.jqplot.use_excanvas) {

                return window.G_vmlCanvasManager.initElement(canvas);

            }

            return canvas;

        };

        this.freeAllCanvases = function() {

            for (var i = 0, l=myCanvases.length; i < l; i++) {

                this.freeCanvas(myCanvases[i]);

            }

            myCanvases = [];

        };

        this.freeCanvas = function(idx) {

            if ($.jqplot.use_excanvas && window.G_vmlCanvasManager.uninitElement !== undefined) {

                // excanvas can't be reused, but properly unset

                window.G_vmlCanvasManager.uninitElement($.jqplot.CanvasManager.canvases[idx]);

                $.jqplot.CanvasManager.canvases[idx] = null;

            }

            else {

                var canvas = $.jqplot.CanvasManager.canvases[idx];

                canvas.getContext('2d').clearRect(0, 0, canvas.width, canvas.height);

                $(canvas).unbind().removeAttr('class').removeAttr('style');

                // Style attributes seemed to be still hanging around.  wierd.  Some ticks

                // still retained a left: 0px attribute after reusing a canvas.

                $(canvas).css({left: '', top: '', position: ''});

                // setting size to 0 may save memory of unused canvases?

                canvas.width = 0;

                canvas.height = 0;

                $.jqplot.CanvasManager.free[idx] = true;

            }

        };

    };

    // Convienence function that won't hang IE or FF without FireBug.

    $.jqplot.log = function() {

        if (window.console) {

            window.console.log.apply(window.console, arguments);

        }

    };

    $.jqplot.config = {

        addDomReference: false,

        enablePlugins:false,

        defaultHeight:300,

        defaultWidth:400,

        UTCAdjust:false,

        timezoneOffset: new Date(new Date().getTimezoneOffset() * 60000),

        errorMessage: '',

        errorBackground: '',

        errorBorder: '',

        errorFontFamily: '',

        errorFontSize: '',

        errorFontStyle: '',

        errorFontWeight: '',

        catchErrors: false,

        defaultTickFormatString: "%.1f",

        defaultColors: [ "#4bb2c5", "#EAA228", "#c5b47f", "#579575", "#839557", "#958c12", "#953579", "#4b5de4", "#d8b83f", "#ff5800", "#0085cc", "#c747a3", "#cddf54", "#FBD178", "#26B4E3", "#bd70c7"],

        defaultNegativeColors: [ "#498991", "#C08840", "#9F9274", "#546D61", "#646C4A", "#6F6621", "#6E3F5F", "#4F64B0", "#A89050", "#C45923", "#187399", "#945381", "#959E5C", "#C7AF7B", "#478396", "#907294"],

        dashLength: 4,

        gapLength: 4,

        dotGapLength: 2.5,

        srcLocation: 'jqplot/src/',

        pluginLocation: 'jqplot/src/plugins/'

    };

    $.jqplot.arrayMax = function( array ){

        return Math.max.apply( Math, array );

    };

    $.jqplot.arrayMin = function( array ){

        return Math.min.apply( Math, array );

    };

    $.jqplot.enablePlugins = $.jqplot.config.enablePlugins;

    // canvas related tests taken from modernizer:

    // Copyright (c) 2009 - 2010 Faruk Ates.

    // http://www.modernizr.com

    $.jqplot.support_canvas = function() {

        if (typeof $.jqplot.support_canvas.result == 'undefined') {

            $.jqplot.support_canvas.result = !!document.createElement('canvas').getContext;

        }

        return $.jqplot.support_canvas.result;

    };

    $.jqplot.support_canvas_text = function() {

        if (typeof $.jqplot.support_canvas_text.result == 'undefined') {

            if (window.G_vmlCanvasManager !== undefined && window.G_vmlCanvasManager._version > 887) {

                $.jqplot.support_canvas_text.result = true;

            }

            else {

                $.jqplot.support_canvas_text.result = !!(document.createElement('canvas').getContext && typeof document.createElement('canvas').getContext('2d').fillText == 'function');

            }

        }

        return $.jqplot.support_canvas_text.result;

    };

    $.jqplot.use_excanvas = ((!$.support.boxModel || !$.support.objectAll || !$support.leadingWhitespace) && !$.jqplot.support_canvas()) ? true : false;

    /**

     *

     * Hooks: jqPlot Pugin Hooks

     *

     * $.jqplot.preInitHooks - called before initialization.

     * $.jqplot.postInitHooks - called after initialization.

     * $.jqplot.preParseOptionsHooks - called before user options are parsed.

     * $.jqplot.postParseOptionsHooks - called after user options are parsed.

     * $.jqplot.preDrawHooks - called before plot draw.

     * $.jqplot.postDrawHooks - called after plot draw.

     * $.jqplot.preDrawSeriesHooks - called before each series is drawn.

     * $.jqplot.postDrawSeriesHooks - called after each series is drawn.

     * $.jqplot.preDrawLegendHooks - called before the legend is drawn.

     * $.jqplot.addLegendRowHooks - called at the end of legend draw, so plugins

     *     can add rows to the legend table.

     * $.jqplot.preSeriesInitHooks - called before series is initialized.

     * $.jqplot.postSeriesInitHooks - called after series is initialized.

     * $.jqplot.preParseSeriesOptionsHooks - called before series related options

     *     are parsed.

     * $.jqplot.postParseSeriesOptionsHooks - called after series related options

     *     are parsed.

     * $.jqplot.eventListenerHooks - called at the end of plot drawing, binds

     *     listeners to the event canvas which lays on top of the grid area.

     * $.jqplot.preDrawSeriesShadowHooks - called before series shadows are drawn.

     * $.jqplot.postDrawSeriesShadowHooks - called after series shadows are drawn.

     *

     */

    $.jqplot.preInitHooks = [];

    $.jqplot.postInitHooks = [];

    $.jqplot.preParseOptionsHooks = [];

    $.jqplot.postParseOptionsHooks = [];

    $.jqplot.preDrawHooks = [];

    $.jqplot.postDrawHooks = [];

    $.jqplot.preDrawSeriesHooks = [];

    $.jqplot.postDrawSeriesHooks = [];

    $.jqplot.preDrawLegendHooks = [];

    $.jqplot.addLegendRowHooks = [];

    $.jqplot.preSeriesInitHooks = [];

    $.jqplot.postSeriesInitHooks = [];

    $.jqplot.preParseSeriesOptionsHooks = [];

    $.jqplot.postParseSeriesOptionsHooks = [];

    $.jqplot.eventListenerHooks = [];

    $.jqplot.preDrawSeriesShadowHooks = [];

    $.jqplot.postDrawSeriesShadowHooks = [];

    // A superclass holding some common properties and methods.

    $.jqplot.ElemContainer = function() {

        this._elem;

        this._plotWidth;

        this._plotHeight;

        this._plotDimensions = {height:null, width:null};

    };

    $.jqplot.ElemContainer.prototype.createElement = function(el, offsets, clss, cssopts, attrib) {

        this._offsets = offsets;

        var klass = clss || 'jqplot';

        var elem = document.createElement(el);

        this._elem = $(elem);

        this._elem.addClass(klass);

        this._elem.css(cssopts);

        this._elem.attr(attrib);

        // avoid memory leak;

        elem = null;

        return this._elem;

    };

    $.jqplot.ElemContainer.prototype.getWidth = function() {

        if (this._elem) {

            return this._elem.outerWidth(true);

        }

        else {

            return null;

        }

    };

    $.jqplot.ElemContainer.prototype.getHeight = function() {

        if (this._elem) {

            return this._elem.outerHeight(true);

        }

        else {

            return null;

        }

    };

    $.jqplot.ElemContainer.prototype.getPosition = function() {

        if (this._elem) {

            return this._elem.position();

        }

        else {

            return {top:null, left:null, bottom:null, right:null};

        }

    };

    $.jqplot.ElemContainer.prototype.getTop = function() {

        return this.getPosition().top;

    };

    $.jqplot.ElemContainer.prototype.getLeft = function() {

        return this.getPosition().left;

    };

    $.jqplot.ElemContainer.prototype.getBottom = function() {

        return this._elem.css('bottom');

    };

    $.jqplot.ElemContainer.prototype.getRight = function() {

        return this._elem.css('right');

    };

    /**

     * Class: Axis

     * An individual axis object.  Cannot be instantiated directly, but created

     * by the Plot object.  Axis properties can be set or overridden by the

     * options passed in from the user.

     *

     */

    function Axis(name) {

        $.jqplot.ElemContainer.call(this);

        // Group: Properties

        //

        // Axes options are specified within an axes object at the top level of the

        // plot options like so:

        // > {

        // >    axes: {

        // >        xaxis: {min: 5},

        // >        yaxis: {min: 2, max: 8, numberTicks:4},

        // >        x2axis: {pad: 1.5},

        // >        y2axis: {ticks:[22, 44, 66, 88]}

        // >        }

        // > }

        // There are 2 x axes, 'xaxis' and 'x2axis', and

        // 9 yaxes, 'yaxis', 'y2axis'. 'y3axis', ...  Any or all of which may be specified.

        this.name = name;

        this._series = [];

        // prop: show

        // Wether to display the axis on the graph.

        this.show = false;

        // prop: tickRenderer

        // A class of a rendering engine for creating the ticks labels displayed on the plot,

        // See <$.jqplot.AxisTickRenderer>.

        this.tickRenderer = $.jqplot.AxisTickRenderer;

        // prop: tickOptions

        // Options that will be passed to the tickRenderer, see <$.jqplot.AxisTickRenderer> options.

        this.tickOptions = {};

        // prop: labelRenderer

        // A class of a rendering engine for creating an axis label.

        this.labelRenderer = $.jqplot.AxisLabelRenderer;

        // prop: labelOptions

        // Options passed to the label renderer.

        this.labelOptions = {};

        // prop: label

        // Label for the axis

        this.label = null;

        // prop: showLabel

        // true to show the axis label.

        this.showLabel = true;

        // prop: min

        // minimum value of the axis (in data units, not pixels).

        this.min = null;

        // prop: max

        // maximum value of the axis (in data units, not pixels).

        this.max = null;

        // prop: autoscale

        // DEPRECATED

        // the default scaling algorithm produces superior results.

        this.autoscale = false;

        // prop: pad

        // Padding to extend the range above and below the data bounds.

        // The data range is multiplied by this factor to determine minimum and maximum axis bounds.

        // A value of 0 will be interpreted to mean no padding, and pad will be set to 1.0.

        this.pad = 1.2;

        // prop: padMax

        // Padding to extend the range above data bounds.

        // The top of the data range is multiplied by this factor to determine maximum axis bounds.

        // A value of 0 will be interpreted to mean no padding, and padMax will be set to 1.0.

        this.padMax = null;

        // prop: padMin

        // Padding to extend the range below data bounds.

        // The bottom of the data range is multiplied by this factor to determine minimum axis bounds.

        // A value of 0 will be interpreted to mean no padding, and padMin will be set to 1.0.

        this.padMin = null;

        // prop: ticks

        // 1D [val, val, ...] or 2D [[val, label], [val, label], ...] array of ticks for the axis.

        // If no label is specified, the value is formatted into an appropriate label.

        this.ticks = [];

        // prop: numberTicks

        // Desired number of ticks.  Default is to compute automatically.

        this.numberTicks;

        // prop: tickInterval

        // number of units between ticks.  Mutually exclusive with numberTicks.

        this.tickInterval;

        // prop: renderer

        // A class of a rendering engine that handles tick generation,

        // scaling input data to pixel grid units and drawing the axis element.

        this.renderer = $.jqplot.LinearAxisRenderer;

        // prop: rendererOptions

        // renderer specific options.  See <$.jqplot.LinearAxisRenderer> for options.

        this.rendererOptions = {};

        // prop: showTicks

        // Wether to show the ticks (both marks and labels) or not.

        // Will not override showMark and showLabel options if specified on the ticks themselves.

        this.showTicks = true;

        // prop: showTickMarks

        // Wether to show the tick marks (line crossing grid) or not.

        // Overridden by showTicks and showMark option of tick itself.

        this.showTickMarks = true;

        // prop: showMinorTicks

        // Wether or not to show minor ticks.  This is renderer dependent.

        this.showMinorTicks = true;

        // prop: drawMajorGridlines

        // True to draw gridlines for major axis ticks.

        this.drawMajorGridlines = true;

        // prop: drawMinorGridlines

        // True to draw gridlines for minor ticks.

        this.drawMinorGridlines = false;

        // prop: drawMajorTickMarks

        // True to draw tick marks for major axis ticks.

        this.drawMajorTickMarks = true;

        // prop: drawMinorTickMarks

        // True to draw tick marks for minor ticks.  This is renderer dependent.

        this.drawMinorTickMarks = true;

        // prop: useSeriesColor

        // Use the color of the first series associated with this axis for the

        // tick marks and line bordering this axis.

        this.useSeriesColor = false;

        // prop: borderWidth

        // width of line stroked at the border of the axis.  Defaults

        // to the width of the grid boarder.

        this.borderWidth = null;

        // prop: borderColor

        // color of the border adjacent to the axis.  Defaults to grid border color.

        this.borderColor = null;

        // prop: scaleToHiddenSeries

        // True to include hidden series when computing axes bounds and scaling.

        this.scaleToHiddenSeries = false;

        // minimum and maximum values on the axis.

        this._dataBounds = {min:null, max:null};

        // statistics (min, max, mean) as well as actual data intervals for each series attached to axis.

        // holds collection of {intervals:[], min:, max:, mean: } objects for each series on axis.

        this._intervalStats = [];

        // pixel position from the top left of the min value and max value on the axis.

        this._offsets = {min:null, max:null};

        this._ticks=[];

        this._label = null;

        // prop: syncTicks

        // true to try and synchronize tick spacing across multiple axes so that ticks and

        // grid lines line up.  This has an impact on autoscaling algorithm, however.

        // In general, autoscaling an individual axis will work better if it does not

        // have to sync ticks.

        this.syncTicks = null;

        // prop: tickSpacing

        // Approximate pixel spacing between ticks on graph.  Used during autoscaling.

        // This number will be an upper bound, actual spacing will be less.

        this.tickSpacing = 75;

        // Properties to hold the original values for min, max, ticks, tickInterval and numberTicks

        // so they can be restored if altered by plugins.

        this._min = null;

        this._max = null;

        this._tickInterval = null;

        this._numberTicks = null;

        this.__ticks = null;

        // hold original user options.

        this._options = {};

    }

    Axis.prototype = new $.jqplot.ElemContainer();

    Axis.prototype.constructor = Axis;

    Axis.prototype.init = function() {

        if ($.isFunction(this.renderer)) {

            this.renderer = new this.renderer();

        }

        // set the axis name

        this.tickOptions.axis = this.name;

        // if showMark or showLabel tick options not specified, use value of axis option.

        // showTicks overrides showTickMarks.

        if (this.tickOptions.showMark == null) {

            this.tickOptions.showMark = this.showTicks;

        }

        if (this.tickOptions.showMark == null) {

            this.tickOptions.showMark = this.showTickMarks;

        }

        if (this.tickOptions.showLabel == null) {

            this.tickOptions.showLabel = this.showTicks;

        }

        if (this.label == null || this.label == '') {

            this.showLabel = false;

        }

        else {

            this.labelOptions.label = this.label;

        }

        if (this.showLabel == false) {

            this.labelOptions.show = false;

        }

        // set the default padMax, padMin if not specified

        // special check, if no padding desired, padding

        // should be set to 1.0

        if (this.pad == 0) {

            this.pad = 1.0;

        }

        if (this.padMax == 0) {

            this.padMax = 1.0;

        }

        if (this.padMin == 0) {

            this.padMin = 1.0;

        }

        if (this.padMax == null) {

            this.padMax = (this.pad-1)/2 + 1;

        }

        if (this.padMin == null) {

            this.padMin = (this.pad-1)/2 + 1;

        }

        // now that padMin and padMax are correctly set, reset pad in case user has supplied

        // padMin and/or padMax

        this.pad = this.padMax + this.padMin - 1;

        if (this.min != null || this.max != null) {

            this.autoscale = false;

        }

        // if not set, sync ticks for y axes but not x by default.

        if (this.syncTicks == null && this.name.indexOf('y') > -1) {

            this.syncTicks = true;

        }

        else if (this.syncTicks == null){

            this.syncTicks = false;

        }

        this.renderer.init.call(this, this.rendererOptions);

    };

    Axis.prototype.draw = function(ctx, plot) {

        // Memory Leaks patch

        if (this.__ticks) {

          this.__ticks = null;

        }

        return this.renderer.draw.call(this, ctx, plot);

    };

    Axis.prototype.set = function() {

        this.renderer.set.call(this);

    };

    Axis.prototype.pack = function(pos, offsets) {

        if (this.show) {

            this.renderer.pack.call(this, pos, offsets);

        }

        // these properties should all be available now.

        if (this._min == null) {

            this._min = this.min;

            this._max = this.max;

            this._tickInterval = this.tickInterval;

            this._numberTicks = this.numberTicks;

            this.__ticks = this._ticks;

        }

    };

    // reset the axis back to original values if it has been scaled, zoomed, etc.

    Axis.prototype.reset = function() {

        this.renderer.reset.call(this);

    };

    Axis.prototype.resetScale = function(opts) {

        $.extend(true, this, {min: null, max: null, numberTicks: null, tickInterval: null, _ticks: [], ticks: []}, opts);

        this.resetDataBounds();

    };

    Axis.prototype.resetDataBounds = function() {

        // Go through all the series attached to this axis and find

        // the min/max bounds for this axis.

        var db = this._dataBounds;

        db.min = null;

        db.max = null;

        var l, s, d;

        // check for when to force min 0 on bar series plots.

        var doforce = (this.show) ? true : false;

        for (var i=0; i<this._series.length; i++) {

            s = this._series[i];

            if (s.show || this.scaleToHiddenSeries) {

                d = s._plotData;

                if (s._type === 'line' && s.renderer.bands.show && this.name.charAt(0) !== 'x') {

                    d = [[0, s.renderer.bands._min], [1, s.renderer.bands._max]];

                }

                var minyidx = 1, maxyidx = 1;

                if (s._type != null && s._type == 'ohlc') {

                    minyidx = 3;

                    maxyidx = 2;

                }

                for (var j=0, l=d.length; j<l; j++) {

                    if (this.name == 'xaxis' || this.name == 'x2axis') {

                        if ((d[j][0] != null && d[j][0] < db.min) || db.min == null) {

                            db.min = d[j][0];

                        }

                        if ((d[j][0] != null && d[j][0] > db.max) || db.max == null) {

                            db.max = d[j][0];

                        }

                    }

                    else {

                        if ((d[j][minyidx] != null && d[j][minyidx] < db.min) || db.min == null) {

                            db.min = d[j][minyidx];

                        }

                        if ((d[j][maxyidx] != null && d[j][maxyidx] > db.max) || db.max == null) {

                            db.max = d[j][maxyidx];

                        }

                    }

                }

                // Hack to not pad out bottom of bar plots unless user has specified a padding.

                // every series will have a chance to set doforce to false.  once it is set to

                // false, it cannot be reset to true.

                // If any series attached to axis is not a bar, wont force 0.

                if (doforce && s.renderer.constructor !== $.jqplot.BarRenderer) {

                    doforce = false;

                }

                else if (doforce && this._options.hasOwnProperty('forceTickAt0') && this._options.forceTickAt0 == false) {

                    doforce = false;

                }

                else if (doforce && s.renderer.constructor === $.jqplot.BarRenderer) {

                    if (s.barDirection == 'vertical' && this.name != 'xaxis' && this.name != 'x2axis') {

                        if (this._options.pad != null || this._options.padMin != null) {

                            doforce = false;

                        }

                    }

                    else if (s.barDirection == 'horizontal' && (this.name == 'xaxis' || this.name == 'x2axis')) {

                        if (this._options.pad != null || this._options.padMin != null) {

                            doforce = false;

                        }

                    }

                }

            }

        }

        if (doforce && this.renderer.constructor === $.jqplot.LinearAxisRenderer && db.min >= 0) {

            this.padMin = 1.0;

            this.forceTickAt0 = true;

        }

    };

    /**

     * Class: Legend

     * Legend object.  Cannot be instantiated directly, but created

     * by the Plot object.  Legend properties can be set or overridden by the

     * options passed in from the user.

     */

    function Legend(options) {

        $.jqplot.ElemContainer.call(this);

        // Group: Properties

        // prop: show

        // Wether to display the legend on the graph.

        this.show = false;

        // prop: location

        // Placement of the legend.  one of the compass directions: nw, n, ne, e, se, s, sw, w

        this.location = 'ne';

        // prop: labels

        // Array of labels to use.  By default the renderer will look for labels on the series.

        // Labels specified in this array will override labels specified on the series.

        this.labels = [];

        // prop: showLabels

        // true to show the label text on the  legend.

        this.showLabels = true;

        // prop: showSwatch

        // true to show the color swatches on the legend.

        this.showSwatches = true;

        // prop: placement

        // "insideGrid" places legend inside the grid area of the plot.

        // "outsideGrid" places the legend outside the grid but inside the plot container,

        // shrinking the grid to accomodate the legend.

        // "inside" synonym for "insideGrid",

        // "outside" places the legend ouside the grid area, but does not shrink the grid which

        // can cause the legend to overflow the plot container.

        this.placement = "insideGrid";

        // prop: xoffset

        // DEPRECATED.  Set the margins on the legend using the marginTop, marginLeft, etc.

        // properties or via CSS margin styling of the .jqplot-table-legend class.

        this.xoffset = 0;

        // prop: yoffset

        // DEPRECATED.  Set the margins on the legend using the marginTop, marginLeft, etc.

        // properties or via CSS margin styling of the .jqplot-table-legend class.

        this.yoffset = 0;

        // prop: border

        // css spec for the border around the legend box.

        this.border;

        // prop: background

        // css spec for the background of the legend box.

        this.background;

        // prop: textColor

        // css color spec for the legend text.

        this.textColor;

        // prop: fontFamily

        // css font-family spec for the legend text.

        this.fontFamily;

        // prop: fontSize

        // css font-size spec for the legend text.

        this.fontSize ;

        // prop: rowSpacing

        // css padding-top spec for the rows in the legend.

        this.rowSpacing = '0.5em';

        // renderer

        // A class that will create a DOM object for the legend,

        // see <$.jqplot.TableLegendRenderer>.

        this.renderer = $.jqplot.TableLegendRenderer;

        // prop: rendererOptions

        // renderer specific options passed to the renderer.

        this.rendererOptions = {};

        // prop: predraw

        // Wether to draw the legend before the series or not.

        // Used with series specific legend renderers for pie, donut, mekko charts, etc.

        this.preDraw = false;

        // prop: marginTop

        // CSS margin for the legend DOM element. This will set an element

        // CSS style for the margin which will override any style sheet setting.

        // The default will be taken from the stylesheet.

        this.marginTop = null;

        // prop: marginRight

        // CSS margin for the legend DOM element. This will set an element

        // CSS style for the margin which will override any style sheet setting.

        // The default will be taken from the stylesheet.

        this.marginRight = null;

        // prop: marginBottom

        // CSS margin for the legend DOM element. This will set an element

        // CSS style for the margin which will override any style sheet setting.

        // The default will be taken from the stylesheet.

        this.marginBottom = null;

        // prop: marginLeft

        // CSS margin for the legend DOM element. This will set an element

        // CSS style for the margin which will override any style sheet setting.

        // The default will be taken from the stylesheet.

        this.marginLeft = null;

        // prop: escapeHtml

        // True to escape special characters with their html entity equivalents

        // in legend text.  "<" becomes &lt; and so on, so html tags are not rendered.

        this.escapeHtml = false;

        this._series = [];

        $.extend(true, this, options);

    }

    Legend.prototype = new $.jqplot.ElemContainer();

    Legend.prototype.constructor = Legend;

    Legend.prototype.setOptions = function(options) {

        $.extend(true, this, options);

        // Try to emulate deprecated behaviour

        // if user has specified xoffset or yoffset, copy these to

        // the margin properties.

        if (this.placement ==  'inside') {

            this.placement = 'insideGrid';

        }

        if (this.xoffset >0) {

            if (this.placement == 'insideGrid') {

                switch (this.location) {

                    case 'nw':

                    case 'w':

                    case 'sw':

                        if (this.marginLeft == null) {

                            this.marginLeft = this.xoffset + 'px';

                        }

                        this.marginRight = '0px';

                        break;

                    case 'ne':

                    case 'e':

                    case 'se':

                    default:

                        if (this.marginRight == null) {

                            this.marginRight = this.xoffset + 'px';

                        }

                        this.marginLeft = '0px';

                        break;

                }

            }

            else if (this.placement == 'outside') {

                switch (this.location) {

                    case 'nw':

                    case 'w':

                    case 'sw':

                        if (this.marginRight == null) {

                            this.marginRight = this.xoffset + 'px';

                        }

                        this.marginLeft = '0px';

                        break;

                    case 'ne':

                    case 'e':

                    case 'se':