/**

*

* jquery.sparkline.js

*

* v1.6

* (c) Splunk, Inc 

* Contact: Gareth Watts (gareth@splunk.com)

* http://omnipotent.net/jquery.sparkline/

*

* Generates inline sparkline charts from data supplied either to the method

* or inline in HTML

* 

* Compatible with Internet Explorer 6.0+ and modern browsers equipped with the canvas tag

* (Firefox 2.0+, Safari, Opera, etc)

*

* License: New BSD License

* 

* Copyright (c) 2010, Splunk Inc.

* All rights reserved.

* 

* Redistribution and use in source and binary forms, with or without modification, 

* are permitted provided that the following conditions are met:

* 

*     * Redistributions of source code must retain the above copyright notice, 

*       this list of conditions and the following disclaimer.

*     * Redistributions in binary form must reproduce the above copyright notice, 

*       this list of conditions and the following disclaimer in the documentation 

*       and/or other materials provided with the distribution.

*     * Neither the name of Splunk Inc nor the names of its contributors may 

*       be used to endorse or promote products derived from this software without 

*       specific prior written permission.

* 

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY 

* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 

* SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 

* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 

* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 

* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

* 

*

* Usage: 

*  $(selector).sparkline(values, options)

*

* If values is undefined or set to 'html' then the data values are read from the specified tag:

*   <p>Sparkline: <span class="sparkline">1,4,6,6,8,5,3,5</span></p>

*   $('.sparkline').sparkline();

* There must be no spaces in the enclosed data set

*

* Otherwise values must be an array of numbers or null values

*    <p>Sparkline: <span id="sparkline1">This text replaced if the browser is compatible</span></p>

*    $('#sparkline1').sparkline([1,4,6,6,8,5,3,5])

*    $('#sparkline2').sparkline([1,4,6,null,null,5,3,5])

*

* Values can also be specified in an HTML comment, or as a values attribute:

*    <p>Sparkline: <span class="sparkline"><!--1,4,6,6,8,5,3,5 --></span></p>

*    <p>Sparkline: <span class="sparkline" values="1,4,6,6,8,5,3,5"></span></p>

*    $('.sparkline').sparkline();

*

* For line charts, x values can also be specified:

*   <p>Sparkline: <span class="sparkline">1:1,2.7:4,3.4:6,5:6,6:8,8.7:5,9:3,10:5</span></p>

*    $('#sparkline1').sparkline([ [1,1], [2.7,4], [3.4,6], [5,6], [6,8], [8.7,5], [9,3], [10,5] ])

*

* By default, options should be passed in as teh second argument to the sparkline function:

*   $('.sparkline').sparkline([1,2,3,4], {type: 'bar'})

*

* Options can also be set by passing them on the tag itself.  This feature is disabled by default though

* as there's a slight performance overhead:

*   $('.sparkline').sparkline([1,2,3,4], {enableTagOptions: true})

*   <p>Sparkline: <span class="sparkline" sparkType="bar" sparkBarColor="red">loading</span></p>

* Prefix all options supplied as tag attribute with "spark" (configurable by setting tagOptionPrefix)

*

* Supported options:

*   lineColor - Color of the line used for the chart

*   fillColor - Color used to fill in the chart - Set to '' or false for a transparent chart

*   width - Width of the chart - Defaults to 3 times the number of values in pixels

*   height - Height of the chart - Defaults to the height of the containing element

*   chartRangeMin - Specify the minimum value to use for the Y range of the chart - Defaults to the minimum value supplied

*   chartRangeMax - Specify the maximum value to use for the Y range of the chart - Defaults to the maximum value supplied

*   chartRangeClip - Clip out of range values to the max/min specified by chartRangeMin and chartRangeMax

*   chartRangeMinX - Specify the minimum value to use for the X range of the chart - Defaults to the minimum value supplied

*   chartRangeMaxX - Specify the maximum value to use for the X range of the chart - Defaults to the maximum value supplied

*   composite - If true then don't erase any existing chart attached to the tag, but draw

*           another chart over the top - Note that width and height are ignored if an

*           existing chart is detected.

*   tagValuesAttribute - Name of tag attribute to check for data values - Defaults to 'values'

*   enableTagOptions - Whether to check tags for sparkline options 

*   tagOptionPrefix - Prefix used for options supplied as tag attributes - Defaults to 'spark'

*

* There are 7 types of sparkline, selected by supplying a "type" option of 'line' (default),

* 'bar', 'tristate', 'bullet', 'discrete', 'pie' or 'box'

*    line - Line chart.  Options:

*       spotColor - Set to '' to not end each line in a circular spot

*       minSpotColor - If set, color of spot at minimum value

*       maxSpotColor - If set, color of spot at maximum value

*       spotRadius - Radius in pixels

*       lineWidth - Width of line in pixels

*       normalRangeMin 

*       normalRangeMax - If set draws a filled horizontal bar between these two values marking the "normal"

*                      or expected range of values

*       normalRangeColor - Color to use for the above bar

*       drawNormalOnTop - Draw the normal range above the chart fill color if true

*       defaultPixelsPerValue - Defaults to 3 pixels of width for each value in the chart

*

*   bar - Bar chart.  Options:

*       barColor - Color of bars for postive values

*       negBarColor - Color of bars for negative values

*       zeroColor - Color of bars with zero values

*       nullColor - Color of bars with null values - Defaults to omitting the bar entirely

*       barWidth - Width of bars in pixels

*       colorMap - Optional mappnig of values to colors to override the *BarColor values above

*                  can be an Array of values to control the color of individual bars

*       barSpacing - Gap between bars in pixels

*       zeroAxis - Centers the y-axis around zero if true

*

*   tristate - Charts values of win (>0), lose (<0) or draw (=0)

*       posBarColor - Color of win values

*       negBarColor - Color of lose values

*       zeroBarColor - Color of draw values

*       barWidth - Width of bars in pixels

*       barSpacing - Gap between bars in pixels

*       colorMap - Optional mappnig of values to colors to override the *BarColor values above

*                  can be an Array of values to control the color of individual bars

*

*   discrete - Options:

*       lineHeight - Height of each line in pixels - Defaults to 30% of the graph height

*       thesholdValue - Values less than this value will be drawn using thresholdColor instead of lineColor

*       thresholdColor

*

*   bullet - Values for bullet graphs msut be in the order: target, performance, range1, range2, range3, ...

*       options:

*       targetColor - The color of the vertical target marker

*       targetWidth - The width of the target marker in pixels

*       performanceColor - The color of the performance measure horizontal bar

*       rangeColors - Colors to use for each qualitative range background color

*

*   pie - Pie chart. Options:

*       sliceColors - An array of colors to use for pie slices

*       offset - Angle in degrees to offset the first slice - Try -90 or +90

*

*   box - Box plot. Options:

*       raw - Set to true to supply pre-computed plot points as values

*             values should be: low_outlier, low_whisker, q1, median, q3, high_whisker, high_outlier

*             When set to false you can supply any number of values and the box plot will

*             be computed for you.  Default is false.

*       showOutliers - Set to true (default) to display outliers as circles

*       outlierIRQ - Interquartile range used to determine outliers.  Default 1.5

*       boxLineColor - Outline color of the box

*       boxFillColor - Fill color for the box

*       whiskerColor - Line color used for whiskers

*       outlierLineColor - Outline color of outlier circles

*       outlierFillColor - Fill color of the outlier circles

*       spotRadius - Radius of outlier circles

*       medianColor - Line color of the median line

*       target - Draw a target cross hair at the supplied value (default undefined)

*      

*   

*       

*   Examples:

*   $('#sparkline1').sparkline(myvalues, { lineColor: '#f00', fillColor: false });

*   $('.barsparks').sparkline('html', { type:'bar', height:'40px', barWidth:5 });

*   $('#tristate').sparkline([1,1,-1,1,0,0,-1], { type:'tristate' }):

*   $('#discrete').sparkline([1,3,4,5,5,3,4,5], { type:'discrete' });

*   $('#bullet').sparkline([10,12,12,9,7], { type:'bullet' });

*   $('#pie').sparkline([1,1,2], { type:'pie' });

*/

(function($) {

    /*

     * Default configuration settings

     */

    var defaults = {

        // Settings common to most/all chart types

        common: {

            type : 'line',

            lineColor : '#00f',

            fillColor : '#cdf',

            defaultPixelsPerValue : 3,

            width : 'auto', 

            height : 'auto',

            composite : false,

            tagValuesAttribute: 'values',

            tagOptionsPrefix: 'spark',

            enableTagOptions: false

        },

        // Defaults for line charts

        line: {

            spotColor : '#f80',

            spotRadius : 1.5,

            minSpotColor : '#f80',

            maxSpotColor : '#f80',

            lineWidth: 1, 

            normalRangeMin : undefined,

            normalRangeMax : undefined,

            normalRangeColor : '#ccc',

            drawNormalOnTop: false,

            chartRangeMin : undefined,

            chartRangeMax : undefined,

            chartRangeMinX : undefined,

            chartRangeMaxX : undefined

        },

        // Defaults for bar charts

        bar: {

            barColor : '#00f',

            negBarColor : '#f44',

            zeroColor: undefined,

            nullColor: undefined,

            zeroAxis : undefined,

            barWidth : 4,

            barSpacing : 1,

            chartRangeMax: undefined,

            chartRangeMin: undefined,

            chartRangeClip: false,

            colorMap : undefined

        },

        // Defaults for tristate charts

        tristate: {

            barWidth : 4,

            barSpacing : 1,

            posBarColor: '#6f6',

            negBarColor : '#f44',

            zeroBarColor : '#999',

            colorMap : {}

        },

        // Defaults for discrete charts

        discrete: {

            lineHeight: 'auto',

            thresholdColor: undefined,

            thresholdValue : 0,

            chartRangeMax: undefined,

            chartRangeMin: undefined,

            chartRangeClip: false

        },

        // Defaults for bullet charts

        bullet: {

            targetColor : 'red',

            targetWidth : 3, // width of the target bar in pixels

            performanceColor : 'blue',

            rangeColors : ['#D3DAFE', '#A8B6FF', '#7F94FF' ],

            base : undefined // set this to a number to change the base start number

        },

        // Defaults for pie charts

        pie: {

            sliceColors : ['#f00', '#0f0', '#00f']

        },

        // Defaults for box plots

        box: {

            raw: false,

            boxLineColor: 'black',

            boxFillColor: '#cdf',

            whiskerColor: 'black',

            outlierLineColor: '#333',

            outlierFillColor: 'white',

            medianColor: 'red',

            showOutliers: true,

            outlierIQR: 1.5,

            spotRadius: 1.5,

            target: undefined,

            targetColor: '#4a2',

            chartRangeMax: undefined,

            chartRangeMin: undefined

        }

    };

    // Provide a cross-browser interface to a few simple drawing primitives

    var VCanvas_base, VCanvas_canvas, VCanvas_vml;

    $.fn.simpledraw = function(width, height, use_existing) {

        if (use_existing && this[0].VCanvas) {

            return this[0].VCanvas;

        }

        if (width === undefined) { 

            width=$(this).innerWidth();

        }

        if (height === undefined) {

            height=$(this).innerHeight();

        }

        if ($.browser.hasCanvas) {

            return new VCanvas_canvas(width, height, this);

        } else if ($.browser.msie) {

            return new VCanvas_vml(width, height, this);

        } else {

            return false;

        }

    };

    var pending = [];

    $.fn.sparkline = function(uservalues, userOptions) {

        return this.each(function() {

            var options = new $.fn.sparkline.options(this, userOptions);

            var render = function() {

                var values, width, height;

                if (uservalues==='html' || uservalues===undefined) {

                    var vals = this.getAttribute(options.get('tagValuesAttribute'));

                    if (vals===undefined || vals===null) {

                        vals = $(this).html();

                    }

                    values = vals.replace(/(^\s*<!--)|(-->\s*$)|\s+/g, '').split(',');

                } else {

                    values = uservalues;

                }

                width = options.get('width')=='auto' ? values.length*options.get('defaultPixelsPerValue') : options.get('width');

                if (options.get('height') == 'auto') {

                    if (!options.get('composite') || !this.VCanvas) {

                        // must be a better way to get the line height

                        var tmp = document.createElement('span');

                        tmp.innerHTML = 'a';

                        $(this).html(tmp);

                        height = $(tmp).innerHeight();

                        $(tmp).remove();

                    }

                } else {

                    height = options.get('height');

                }

                $.fn.sparkline[options.get('type')].call(this, values, options, width, height);

            };

            // jQuery 1.3.0 completely changed the meaning of :hidden :-/

            if (($(this).html() && $(this).is(':hidden')) || ($.fn.jquery < "1.3.0" && $(this).parents().is(':hidden')) || !$(this).parents('body').length) {

                pending.push([this, render]);

            } else {

                render.call(this);

            }

        });

    };

    $.fn.sparkline.defaults = defaults;

    $.sparkline_display_visible = function() {

        for (var i=pending.length-1; i>=0; i--) {

            var el = pending[i][0];

            if ($(el).is(':visible') && !$(el).parents().is(':hidden')) {

                pending[i][1].call(el);

                pending.splice(i, 1);

            }

        }

    };

    /**

     * User option handler

     */

    var UNSET_OPTION = {};

    var normalizeValue = function(val) {

        switch(val) {

            case 'undefined':

                val = undefined;

                break;

            case 'null':

                val = null;

                break;

            case 'true':

                val = true;

                break;

            case 'false':

                val = false;

                break;

            default:

                var nf = parseFloat(val);

                if (val == nf) {

                    val = nf;

                }

        }

        return val;

    };

    $.fn.sparkline.options = function(tag, userOptions) {

        var extendedOptions;

        this.userOptions = userOptions = userOptions || {};

        this.tag = tag;

        this.tagValCache = {};

        var defaults = $.fn.sparkline.defaults;

        var base = defaults.common;

        this.tagOptionsPrefix = userOptions.enableTagOptions && (userOptions.tagOptionsPrefix || base.tagOptionsPrefix);

        var tagOptionType = this.getTagSetting('type');

        if (tagOptionType === UNSET_OPTION) {

            extendedOptions = defaults[userOptions.type || base.type];

        } else {

            extendedOptions = defaults[tagOptionType];

        }

        this.mergedOptions = $.extend({}, base, extendedOptions, userOptions);

    };

    $.fn.sparkline.options.prototype.getTagSetting = function(key) {

        var val, i, prefix = this.tagOptionsPrefix;

        if (prefix === false || prefix === undefined) {

            return UNSET_OPTION;

        }

        if (this.tagValCache.hasOwnProperty(key)) {

            val = this.tagValCache.key;

        } else {

            val = this.tag.getAttribute(prefix + key);

            if (val === undefined || val === null) {