| 提交 | 用户 | 时间 | ||
| 58d006 | 1 | /** |
| A | 2 | * |
| 3 | * jquery.sparkline.js | |
| 4 | * | |
| 5 | * v2.1.2 | |
| 6 | * (c) Splunk, Inc | |
| 7 | * Contact: Gareth Watts (gareth@splunk.com) | |
| 8 | * http://omnipotent.net/jquery.sparkline/ | |
| 9 | * | |
| 10 | * Generates inline sparkline charts from data supplied either to the method | |
| 11 | * or inline in HTML | |
| 12 | * | |
| 13 | * Compatible with Internet Explorer 6.0+ and modern browsers equipped with the canvas tag | |
| 14 | * (Firefox 2.0+, Safari, Opera, etc) | |
| 15 | * | |
| 16 | * License: New BSD License | |
| 17 | * | |
| 18 | * Copyright (c) 2012, Splunk Inc. | |
| 19 | * All rights reserved. | |
| 20 | * | |
| 21 | * Redistribution and use in source and binary forms, with or without modification, | |
| 22 | * are permitted provided that the following conditions are met: | |
| 23 | * | |
| 24 | * * Redistributions of source code must retain the above copyright notice, | |
| 25 | * this list of conditions and the following disclaimer. | |
| 26 | * * Redistributions in binary form must reproduce the above copyright notice, | |
| 27 | * this list of conditions and the following disclaimer in the documentation | |
| 28 | * and/or other materials provided with the distribution. | |
| 29 | * * Neither the name of Splunk Inc nor the names of its contributors may | |
| 30 | * be used to endorse or promote products derived from this software without | |
| 31 | * specific prior written permission. | |
| 32 | * | |
| 33 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY | |
| 34 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES | |
| 35 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT | |
| 36 | * SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
| 37 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT | |
| 38 | * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | |
| 39 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, | |
| 40 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
| 41 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 42 | * | |
| 43 | * | |
| 44 | * Usage: | |
| 45 | * $(selector).sparkline(values, options) | |
| 46 | * | |
| 47 | * If values is undefined or set to 'html' then the data values are read from the specified tag: | |
| 48 | * <p>Sparkline: <span class="sparkline">1,4,6,6,8,5,3,5</span></p> | |
| 49 | * $('.sparkline').sparkline(); | |
| 50 | * There must be no spaces in the enclosed data set | |
| 51 | * | |
| 52 | * Otherwise values must be an array of numbers or null values | |
| 53 | * <p>Sparkline: <span id="sparkline1">This text replaced if the browser is compatible</span></p> | |
| 54 | * $('#sparkline1').sparkline([1,4,6,6,8,5,3,5]) | |
| 55 | * $('#sparkline2').sparkline([1,4,6,null,null,5,3,5]) | |
| 56 | * | |
| 57 | * Values can also be specified in an HTML comment, or as a values attribute: | |
| 58 | * <p>Sparkline: <span class="sparkline"><!--1,4,6,6,8,5,3,5 --></span></p> | |
| 59 | * <p>Sparkline: <span class="sparkline" values="1,4,6,6,8,5,3,5"></span></p> | |
| 60 | * $('.sparkline').sparkline(); | |
| 61 | * | |
| 62 | * For line charts, x values can also be specified: | |
| 63 | * <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> | |
| 64 | * $('#sparkline1').sparkline([ [1,1], [2.7,4], [3.4,6], [5,6], [6,8], [8.7,5], [9,3], [10,5] ]) | |
| 65 | * | |
| 66 | * By default, options should be passed in as teh second argument to the sparkline function: | |
| 67 | * $('.sparkline').sparkline([1,2,3,4], {type: 'bar'}) | |
| 68 | * | |
| 69 | * Options can also be set by passing them on the tag itself. This feature is disabled by default though | |
| 70 | * as there's a slight performance overhead: | |
| 71 | * $('.sparkline').sparkline([1,2,3,4], {enableTagOptions: true}) | |
| 72 | * <p>Sparkline: <span class="sparkline" sparkType="bar" sparkBarColor="red">loading</span></p> | |
| 73 | * Prefix all options supplied as tag attribute with "spark" (configurable by setting tagOptionPrefix) | |
| 74 | * | |
| 75 | * Supported options: | |
| 76 | * lineColor - Color of the line used for the chart | |
| 77 | * fillColor - Color used to fill in the chart - Set to '' or false for a transparent chart | |
| 78 | * width - Width of the chart - Defaults to 3 times the number of values in pixels | |
| 79 | * height - Height of the chart - Defaults to the height of the containing element | |
| 80 | * chartRangeMin - Specify the minimum value to use for the Y range of the chart - Defaults to the minimum value supplied | |
| 81 | * chartRangeMax - Specify the maximum value to use for the Y range of the chart - Defaults to the maximum value supplied | |
| 82 | * chartRangeClip - Clip out of range values to the max/min specified by chartRangeMin and chartRangeMax | |
| 83 | * chartRangeMinX - Specify the minimum value to use for the X range of the chart - Defaults to the minimum value supplied | |
| 84 | * chartRangeMaxX - Specify the maximum value to use for the X range of the chart - Defaults to the maximum value supplied | |
| 85 | * composite - If true then don't erase any existing chart attached to the tag, but draw | |
| 86 | * another chart over the top - Note that width and height are ignored if an | |
| 87 | * existing chart is detected. | |
| 88 | * tagValuesAttribute - Name of tag attribute to check for data values - Defaults to 'values' | |
| 89 | * enableTagOptions - Whether to check tags for sparkline options | |
| 90 | * tagOptionPrefix - Prefix used for options supplied as tag attributes - Defaults to 'spark' | |
| 91 | * disableHiddenCheck - If set to true, then the plugin will assume that charts will never be drawn into a | |
| 92 | * hidden dom element, avoding a browser reflow | |
| 93 | * disableInteraction - If set to true then all mouseover/click interaction behaviour will be disabled, | |
| 94 | * making the plugin perform much like it did in 1.x | |
| 95 | * disableTooltips - If set to true then tooltips will be disabled - Defaults to false (tooltips enabled) | |
| 96 | * disableHighlight - If set to true then highlighting of selected chart elements on mouseover will be disabled | |
| 97 | * defaults to false (highlights enabled) | |
| 98 | * highlightLighten - Factor to lighten/darken highlighted chart values by - Defaults to 1.4 for a 40% increase | |
| 99 | * tooltipContainer - Specify which DOM element the tooltip should be rendered into - defaults to document.body | |
| 100 | * tooltipClassname - Optional CSS classname to apply to tooltips - If not specified then a default style will be applied | |
| 101 | * tooltipOffsetX - How many pixels away from the mouse pointer to render the tooltip on the X axis | |
| 102 | * tooltipOffsetY - How many pixels away from the mouse pointer to render the tooltip on the r axis | |
| 103 | * tooltipFormatter - Optional callback that allows you to override the HTML displayed in the tooltip | |
| 104 | * callback is given arguments of (sparkline, options, fields) | |
| 105 | * tooltipChartTitle - If specified then the tooltip uses the string specified by this setting as a title | |
| 106 | * tooltipFormat - A format string or SPFormat object (or an array thereof for multiple entries) | |
| 107 | * to control the format of the tooltip | |
| 108 | * tooltipPrefix - A string to prepend to each field displayed in a tooltip | |
| 109 | * tooltipSuffix - A string to append to each field displayed in a tooltip | |
| 110 | * tooltipSkipNull - If true then null values will not have a tooltip displayed (defaults to true) | |
| 111 | * tooltipValueLookups - An object or range map to map field values to tooltip strings | |
| 112 | * (eg. to map -1 to "Lost", 0 to "Draw", and 1 to "Win") | |
| 113 | * numberFormatter - Optional callback for formatting numbers in tooltips | |
| 114 | * numberDigitGroupSep - Character to use for group separator in numbers "1,234" - Defaults to "," | |
| 115 | * numberDecimalMark - Character to use for the decimal point when formatting numbers - Defaults to "." | |
| 116 | * numberDigitGroupCount - Number of digits between group separator - Defaults to 3 | |
| 117 | * | |
| 118 | * There are 7 types of sparkline, selected by supplying a "type" option of 'line' (default), | |
| 119 | * 'bar', 'tristate', 'bullet', 'discrete', 'pie' or 'box' | |
| 120 | * line - Line chart. Options: | |
| 121 | * spotColor - Set to '' to not end each line in a circular spot | |
| 122 | * minSpotColor - If set, color of spot at minimum value | |
| 123 | * maxSpotColor - If set, color of spot at maximum value | |
| 124 | * spotRadius - Radius in pixels | |
| 125 | * lineWidth - Width of line in pixels | |
| 126 | * normalRangeMin | |
| 127 | * normalRangeMax - If set draws a filled horizontal bar between these two values marking the "normal" | |
| 128 | * or expected range of values | |
| 129 | * normalRangeColor - Color to use for the above bar | |
| 130 | * drawNormalOnTop - Draw the normal range above the chart fill color if true | |
| 131 | * defaultPixelsPerValue - Defaults to 3 pixels of width for each value in the chart | |
| 132 | * highlightSpotColor - The color to use for drawing a highlight spot on mouseover - Set to null to disable | |
| 133 | * highlightLineColor - The color to use for drawing a highlight line on mouseover - Set to null to disable | |
| 134 | * valueSpots - Specify which points to draw spots on, and in which color. Accepts a range map | |
| 135 | * | |
| 136 | * bar - Bar chart. Options: | |
| 137 | * barColor - Color of bars for postive values | |
| 138 | * negBarColor - Color of bars for negative values | |
| 139 | * zeroColor - Color of bars with zero values | |
| 140 | * nullColor - Color of bars with null values - Defaults to omitting the bar entirely | |
| 141 | * barWidth - Width of bars in pixels | |
| 142 | * colorMap - Optional mappnig of values to colors to override the *BarColor values above | |
| 143 | * can be an Array of values to control the color of individual bars or a range map | |
| 144 | * to specify colors for individual ranges of values | |
| 145 | * barSpacing - Gap between bars in pixels | |
| 146 | * zeroAxis - Centers the y-axis around zero if true | |
| 147 | * | |
| 148 | * tristate - Charts values of win (>0), lose (<0) or draw (=0) | |
| 149 | * posBarColor - Color of win values | |
| 150 | * negBarColor - Color of lose values | |
| 151 | * zeroBarColor - Color of draw values | |
| 152 | * barWidth - Width of bars in pixels | |
| 153 | * barSpacing - Gap between bars in pixels | |
| 154 | * colorMap - Optional mappnig of values to colors to override the *BarColor values above | |
| 155 | * can be an Array of values to control the color of individual bars or a range map | |
| 156 | * to specify colors for individual ranges of values | |
| 157 | * | |
| 158 | * discrete - Options: | |
| 159 | * lineHeight - Height of each line in pixels - Defaults to 30% of the graph height | |
| 160 | * thesholdValue - Values less than this value will be drawn using thresholdColor instead of lineColor | |
| 161 | * thresholdColor | |
| 162 | * | |
| 163 | * bullet - Values for bullet graphs msut be in the order: target, performance, range1, range2, range3, ... | |
| 164 | * options: | |
| 165 | * targetColor - The color of the vertical target marker | |
| 166 | * targetWidth - The width of the target marker in pixels | |
| 167 | * performanceColor - The color of the performance measure horizontal bar | |
| 168 | * rangeColors - Colors to use for each qualitative range background color | |
| 169 | * | |
| 170 | * pie - Pie chart. Options: | |
| 171 | * sliceColors - An array of colors to use for pie slices | |
| 172 | * offset - Angle in degrees to offset the first slice - Try -90 or +90 | |
| 173 | * borderWidth - Width of border to draw around the pie chart, in pixels - Defaults to 0 (no border) | |
| 174 | * borderColor - Color to use for the pie chart border - Defaults to #000 | |
| 175 | * | |
| 176 | * box - Box plot. Options: | |
| 177 | * raw - Set to true to supply pre-computed plot points as values | |
| 178 | * values should be: low_outlier, low_whisker, q1, median, q3, high_whisker, high_outlier | |
| 179 | * When set to false you can supply any number of values and the box plot will | |
| 180 | * be computed for you. Default is false. | |
| 181 | * showOutliers - Set to true (default) to display outliers as circles | |
| 182 | * outlierIQR - Interquartile range used to determine outliers. Default 1.5 | |
| 183 | * boxLineColor - Outline color of the box | |
| 184 | * boxFillColor - Fill color for the box | |
| 185 | * whiskerColor - Line color used for whiskers | |
| 186 | * outlierLineColor - Outline color of outlier circles | |
| 187 | * outlierFillColor - Fill color of the outlier circles | |
| 188 | * spotRadius - Radius of outlier circles | |
| 189 | * medianColor - Line color of the median line | |
| 190 | * target - Draw a target cross hair at the supplied value (default undefined) | |
| 191 | * | |
| 192 | * | |
| 193 | * | |
| 194 | * Examples: | |
| 195 | * $('#sparkline1').sparkline(myvalues, { lineColor: '#f00', fillColor: false }); | |
| 196 | * $('.barsparks').sparkline('html', { type:'bar', height:'40px', barWidth:5 }); | |
| 197 | * $('#tristate').sparkline([1,1,-1,1,0,0,-1], { type:'tristate' }): | |
| 198 | * $('#discrete').sparkline([1,3,4,5,5,3,4,5], { type:'discrete' }); | |
| 199 | * $('#bullet').sparkline([10,12,12,9,7], { type:'bullet' }); | |
| 200 | * $('#pie').sparkline([1,1,2], { type:'pie' }); | |
| 201 | */ | |
| 202 | ||
| 203 | /*jslint regexp: true, browser: true, jquery: true, white: true, nomen: false, plusplus: false, maxerr: 500, indent: 4 */ | |
| 204 | ||
| 205 | (function(document, Math, undefined) { // performance/minified-size optimization | |
| 206 | (function(factory) { | |
| 207 | if(typeof define === 'function' && define.amd) { | |
| 208 | define(['jquery'], factory); | |
| 209 | } else if (jQuery && !jQuery.fn.sparkline) { | |
| 210 | factory(jQuery); | |
| 211 | } | |
| 212 | } | |
| 213 | (function($) { | |
| 214 | 'use strict'; | |
| 215 | ||
| 216 | var UNSET_OPTION = {}, | |
| 217 | getDefaults, createClass, SPFormat, clipval, quartile, normalizeValue, normalizeValues, | |
| 218 | remove, isNumber, all, sum, addCSS, ensureArray, formatNumber, RangeMap, | |
| 219 | MouseHandler, Tooltip, barHighlightMixin, | |
| 220 | line, bar, tristate, discrete, bullet, pie, box, defaultStyles, initStyles, | |
| 221 | VShape, VCanvas_base, VCanvas_canvas, VCanvas_vml, pending, shapeCount = 0; | |
| 222 | ||
| 223 | /** | |
| 224 | * Default configuration settings | |
| 225 | */ | |
| 226 | getDefaults = function () { | |
| 227 | return { | |
| 228 | // Settings common to most/all chart types | |
| 229 | common: { | |
| 230 | type: 'line', | |
| 231 | lineColor: '#00f', | |
| 232 | fillColor: '#cdf', | |
| 233 | defaultPixelsPerValue: 3, | |
| 234 | width: 'auto', | |
| 235 | height: 'auto', | |
| 236 | composite: false, | |
| 237 | tagValuesAttribute: 'values', | |
| 238 | tagOptionsPrefix: 'spark', | |
| 239 | enableTagOptions: false, | |
| 240 | enableHighlight: true, | |
| 241 | highlightLighten: 1.4, | |
| 242 | tooltipSkipNull: true, | |
| 243 | tooltipPrefix: '', | |
| 244 | tooltipSuffix: '', | |
| 245 | disableHiddenCheck: false, | |
| 246 | numberFormatter: false, | |
| 247 | numberDigitGroupCount: 3, | |
| 248 | numberDigitGroupSep: ',', | |
| 249 | numberDecimalMark: '.', | |
| 250 | disableTooltips: false, | |
| 251 | disableInteraction: false | |
| 252 | }, | |
| 253 | // Defaults for line charts | |
| 254 | line: { | |
| 255 | spotColor: '#f80', | |
| 256 | highlightSpotColor: '#5f5', | |
| 257 | highlightLineColor: '#f22', | |
| 258 | spotRadius: 1.5, | |
| 259 | minSpotColor: '#f80', | |
| 260 | maxSpotColor: '#f80', | |
| 261 | lineWidth: 1, | |
| 262 | normalRangeMin: undefined, | |
| 263 | normalRangeMax: undefined, | |
| 264 | normalRangeColor: '#ccc', | |
| 265 | drawNormalOnTop: false, | |
| 266 | chartRangeMin: undefined, | |
| 267 | chartRangeMax: undefined, | |
| 268 | chartRangeMinX: undefined, | |
| 269 | chartRangeMaxX: undefined, | |
| 270 | tooltipFormat: new SPFormat('<span style="color: {{color}}">●</span> {{prefix}}{{y}}{{suffix}}') | |
| 271 | }, | |
| 272 | // Defaults for bar charts | |
| 273 | bar: { | |
| 274 | barColor: '#3366cc', | |
| 275 | negBarColor: '#f44', | |
| 276 | stackedBarColor: ['#3366cc', '#dc3912', '#ff9900', '#109618', '#66aa00', | |
| 277 | '#dd4477', '#0099c6', '#990099'], | |
| 278 | zeroColor: undefined, | |
| 279 | nullColor: undefined, | |
| 280 | zeroAxis: true, | |
| 281 | barWidth: 4, | |
| 282 | barSpacing: 1, | |
| 283 | chartRangeMax: undefined, | |
| 284 | chartRangeMin: undefined, | |
| 285 | chartRangeClip: false, | |
| 286 | colorMap: undefined, | |
| 287 | tooltipFormat: new SPFormat('<span style="color: {{color}}">●</span> {{prefix}}{{value}}{{suffix}}') | |
| 288 | }, | |
| 289 | // Defaults for tristate charts | |
| 290 | tristate: { | |
| 291 | barWidth: 4, | |
| 292 | barSpacing: 1, | |
| 293 | posBarColor: '#6f6', | |
| 294 | negBarColor: '#f44', | |
| 295 | zeroBarColor: '#999', | |
| 296 | colorMap: {}, | |
| 297 | tooltipFormat: new SPFormat('<span style="color: {{color}}">●</span> {{value:map}}'), | |
| 298 | tooltipValueLookups: { map: { '-1': 'Loss', '0': 'Draw', '1': 'Win' } } | |
| 299 | }, | |
| 300 | // Defaults for discrete charts | |
| 301 | discrete: { | |
| 302 | lineHeight: 'auto', | |
| 303 | thresholdColor: undefined, | |
| 304 | thresholdValue: 0, | |
| 305 | chartRangeMax: undefined, | |
| 306 | chartRangeMin: undefined, | |
| 307 | chartRangeClip: false, | |
| 308 | tooltipFormat: new SPFormat('{{prefix}}{{value}}{{suffix}}') | |
| 309 | }, | |
| 310 | // Defaults for bullet charts | |
| 311 | bullet: { | |
| 312 | targetColor: '#f33', | |
| 313 | targetWidth: 3, // width of the target bar in pixels | |
| 314 | performanceColor: '#33f', | |
| 315 | rangeColors: ['#d3dafe', '#a8b6ff', '#7f94ff'], | |
| 316 | base: undefined, // set this to a number to change the base start number | |
| 317 | tooltipFormat: new SPFormat('{{fieldkey:fields}} - {{value}}'), | |
| 318 | tooltipValueLookups: { fields: {r: 'Range', p: 'Performance', t: 'Target'} } | |
| 319 | }, | |
| 320 | // Defaults for pie charts | |
| 321 | pie: { | |
| 322 | offset: 0, | |
| 323 | sliceColors: ['#3366cc', '#dc3912', '#ff9900', '#109618', '#66aa00', | |
| 324 | '#dd4477', '#0099c6', '#990099'], | |
| 325 | borderWidth: 0, | |
| 326 | borderColor: '#000', | |
| 327 | tooltipFormat: new SPFormat('<span style="color: {{color}}">●</span> {{value}} ({{percent.1}}%)') | |
| 328 | }, | |
| 329 | // Defaults for box plots | |
| 330 | box: { | |
| 331 | raw: false, | |
| 332 | boxLineColor: '#000', | |
| 333 | boxFillColor: '#cdf', | |
| 334 | whiskerColor: '#000', | |
| 335 | outlierLineColor: '#333', | |
| 336 | outlierFillColor: '#fff', | |
| 337 | medianColor: '#f00', | |
| 338 | showOutliers: true, | |
| 339 | outlierIQR: 1.5, | |
| 340 | spotRadius: 1.5, | |
| 341 | target: undefined, | |
| 342 | targetColor: '#4a2', | |
| 343 | chartRangeMax: undefined, | |
| 344 | chartRangeMin: undefined, | |
| 345 | tooltipFormat: new SPFormat('{{field:fields}}: {{value}}'), | |
| 346 | tooltipFormatFieldlistKey: 'field', | |
| 347 | tooltipValueLookups: { fields: { lq: 'Lower Quartile', med: 'Median', | |
| 348 | uq: 'Upper Quartile', lo: 'Left Outlier', ro: 'Right Outlier', | |
| 349 | lw: 'Left Whisker', rw: 'Right Whisker'} } | |
| 350 | } | |
| 351 | }; | |
| 352 | }; | |
| 353 | ||
| 354 | // You can have tooltips use a css class other than jqstooltip by specifying tooltipClassname | |
| 355 | defaultStyles = '.jqstooltip { ' + | |
| 356 | 'position: absolute;' + | |
| 357 | 'left: 0px;' + | |
| 358 | 'top: 0px;' + | |
| 359 | 'visibility: hidden;' + | |
| 360 | 'background: rgb(0, 0, 0) transparent;' + | |
| 361 | 'background-color: rgba(0,0,0,0.6);' + | |
| 362 | 'filter:progid:DXImageTransform.Microsoft.gradient(startColorstr=#99000000, endColorstr=#99000000);' + | |
| 363 | '-ms-filter: "progid:DXImageTransform.Microsoft.gradient(startColorstr=#99000000, endColorstr=#99000000)";' + | |
| 364 | 'color: white;' + | |
| 365 | 'font: 10px arial, san serif;' + | |
| 366 | 'text-align: left;' + | |
| 367 | 'white-space: nowrap;' + | |
| 368 | 'padding: 5px;' + | |
| 369 | 'border: 1px solid white;' + | |
| 370 | 'z-index: 10000;' + | |
| 371 | '}' + | |
| 372 | '.jqsfield { ' + | |
| 373 | 'color: white;' + | |
| 374 | 'font: 10px arial, san serif;' + | |
| 375 | 'text-align: left;' + | |
| 376 | '}'; | |
| 377 | ||
| 378 | /** | |
| 379 | * Utilities | |
| 380 | */ | |
| 381 | ||
| 382 | createClass = function (/* [baseclass, [mixin, ...]], definition */) { | |
| 383 | var Class, args; | |
| 384 | Class = function () { | |
| 385 | this.init.apply(this, arguments); | |
| 386 | }; | |
| 387 | if (arguments.length > 1) { | |
| 388 | if (arguments[0]) { | |
| 389 | Class.prototype = $.extend(new arguments[0](), arguments[arguments.length - 1]); | |
| 390 | Class._super = arguments[0].prototype; | |
| 391 | } else { | |
| 392 | Class.prototype = arguments[arguments.length - 1]; | |
| 393 | } | |
| 394 | if (arguments.length > 2) { | |
| 395 | args = Array.prototype.slice.call(arguments, 1, -1); | |
| 396 | args.unshift(Class.prototype); | |
| 397 | $.extend.apply($, args); | |
| 398 | } | |
| 399 | } else { | |
| 400 | Class.prototype = arguments[0]; | |
| 401 | } | |
| 402 | Class.prototype.cls = Class; | |
| 403 | return Class; | |
| 404 | }; | |
| 405 | ||
| 406 | /** | |
| 407 | * Wraps a format string for tooltips | |
| 408 | * {{x}} | |
| 409 | * {{x.2} | |
| 410 | * {{x:months}} | |
| 411 | */ | |
| 412 | $.SPFormatClass = SPFormat = createClass({ | |
| 413 | fre: /\{\{([\w.]+?)(:(.+?))?\}\}/g, | |
| 414 | precre: /(\w+)\.(\d+)/, | |
| 415 | ||
| 416 | init: function (format, fclass) { | |
| 417 | this.format = format; | |
| 418 | this.fclass = fclass; | |
| 419 | }, | |
| 420 | ||
| 421 | render: function (fieldset, lookups, options) { | |
| 422 | var self = this, | |
| 423 | fields = fieldset, | |
| 424 | match, token, lookupkey, fieldvalue, prec; | |
| 425 | return this.format.replace(this.fre, function () { | |
| 426 | var lookup; | |
| 427 | token = arguments[1]; | |
| 428 | lookupkey = arguments[3]; | |
| 429 | match = self.precre.exec(token); | |
| 430 | if (match) { | |
| 431 | prec = match[2]; | |
| 432 | token = match[1]; | |
| 433 | } else { | |
| 434 | prec = false; | |
| 435 | } | |
| 436 | fieldvalue = fields[token]; | |
| 437 | if (fieldvalue === undefined) { | |
| 438 | return ''; | |
| 439 | } | |
| 440 | if (lookupkey && lookups && lookups[lookupkey]) { | |
| 441 | lookup = lookups[lookupkey]; | |
| 442 | if (lookup.get) { // RangeMap | |
| 443 | return lookups[lookupkey].get(fieldvalue) || fieldvalue; | |
| 444 | } else { | |
| 445 | return lookups[lookupkey][fieldvalue] || fieldvalue; | |
| 446 | } | |
| 447 | } | |
| 448 | if (isNumber(fieldvalue)) { | |
| 449 | if (options.get('numberFormatter')) { | |
| 450 | fieldvalue = options.get('numberFormatter')(fieldvalue); | |
| 451 | } else { | |
| 452 | fieldvalue = formatNumber(fieldvalue, prec, | |
| 453 | options.get('numberDigitGroupCount'), | |
| 454 | options.get('numberDigitGroupSep'), | |
| 455 | options.get('numberDecimalMark')); | |
| 456 | } | |
| 457 | } | |
| 458 | return fieldvalue; | |
| 459 | }); | |
| 460 | } | |
| 461 | }); | |
| 462 | ||
| 463 | // convience method to avoid needing the new operator | |
| 464 | $.spformat = function(format, fclass) { | |
| 465 | return new SPFormat(format, fclass); | |
| 466 | }; | |
| 467 | ||
| 468 | clipval = function (val, min, max) { | |
| 469 | if (val < min) { | |
| 470 | return min; | |
| 471 | } | |
| 472 | if (val > max) { | |
| 473 | return max; | |
| 474 | } | |
| 475 | return val; | |
| 476 | }; | |
| 477 | ||
| 478 | quartile = function (values, q) { | |
| 479 | var vl; | |
| 480 | if (q === 2) { | |
| 481 | vl = Math.floor(values.length / 2); | |
| 482 | return values.length % 2 ? values[vl] : (values[vl-1] + values[vl]) / 2; | |
| 483 | } else { | |
| 484 | if (values.length % 2 ) { // odd | |
| 485 | vl = (values.length * q + q) / 4; | |
| 486 | return vl % 1 ? (values[Math.floor(vl)] + values[Math.floor(vl) - 1]) / 2 : values[vl-1]; | |
| 487 | } else { //even | |
| 488 | vl = (values.length * q + 2) / 4; | |
| 489 | return vl % 1 ? (values[Math.floor(vl)] + values[Math.floor(vl) - 1]) / 2 : values[vl-1]; | |
| 490 | ||
| 491 | } | |
| 492 | } | |
| 493 | }; | |
| 494 | ||
| 495 | normalizeValue = function (val) { | |
| 496 | var nf; | |
| 497 | switch (val) { | |
| 498 | case 'undefined': | |
| 499 | val = undefined; | |
| 500 | break; | |
| 501 | case 'null': | |
| 502 | val = null; | |
| 503 | break; | |
| 504 | case 'true': | |
| 505 | val = true; | |
| 506 | break; | |
| 507 | case 'false': | |
| 508 | val = false; | |
| 509 | break; | |
| 510 | default: | |
| 511 | nf = parseFloat(val); | |
| 512 | if (val == nf) { | |
| 513 | val = nf; | |
| 514 | } | |
| 515 | } | |
| 516 | return val; | |
| 517 | }; | |
| 518 | ||
| 519 | normalizeValues = function (vals) { | |
| 520 | var i, result = []; | |
| 521 | for (i = vals.length; i--;) { | |
| 522 | result[i] = normalizeValue(vals[i]); | |
| 523 | } | |
| 524 | return result; | |
| 525 | }; | |
| 526 | ||
| 527 | remove = function (vals, filter) { | |
| 528 | var i, vl, result = []; | |
| 529 | for (i = 0, vl = vals.length; i < vl; i++) { | |
| 530 | if (vals[i] !== filter) { | |
| 531 | result.push(vals[i]); | |
| 532 | } | |
| 533 | } | |
| 534 | return result; | |
| 535 | }; | |
| 536 | ||
| 537 | isNumber = function (num) { | |
| 538 | return !isNaN(parseFloat(num)) && isFinite(num); | |
| 539 | }; | |
| 540 | ||
| 541 | formatNumber = function (num, prec, groupsize, groupsep, decsep) { | |
| 542 | var p, i; | |
| 543 | num = (prec === false ? parseFloat(num).toString() : num.toFixed(prec)).split(''); | |
| 544 | p = (p = $.inArray('.', num)) < 0 ? num.length : p; | |
| 545 | if (p < num.length) { | |
| 546 | num[p] = decsep; | |
| 547 | } | |
| 548 | for (i = p - groupsize; i > 0; i -= groupsize) { | |
| 549 | num.splice(i, 0, groupsep); | |
| 550 | } | |
| 551 | return num.join(''); | |
| 552 | }; | |
| 553 | ||
| 554 | // determine if all values of an array match a value | |
| 555 | // returns true if the array is empty | |
| 556 | all = function (val, arr, ignoreNull) { | |
| 557 | var i; | |
| 558 | for (i = arr.length; i--; ) { | |
| 559 | if (ignoreNull && arr[i] === null) continue; | |
| 560 | if (arr[i] !== val) { | |
| 561 | return false; | |
| 562 | } | |
| 563 | } | |
| 564 | return true; | |
| 565 | }; | |
| 566 | ||
| 567 | // sums the numeric values in an array, ignoring other values | |
| 568 | sum = function (vals) { | |
| 569 | var total = 0, i; | |
| 570 | for (i = vals.length; i--;) { | |
| 571 | total += typeof vals[i] === 'number' ? vals[i] : 0; | |
| 572 | } | |
| 573 | return total; | |
| 574 | }; | |
| 575 | ||
| 576 | ensureArray = function (val) { | |
| 577 | return $.isArray(val) ? val : [val]; | |
| 578 | }; | |
| 579 | ||
| 580 | // http://paulirish.com/2008/bookmarklet-inject-new-css-rules/ | |
| 581 | addCSS = function(css) { | |
| 582 | var tag; | |
| 583 | //if ('\v' == 'v') /* ie only */ { | |
| 584 | if (document.createStyleSheet) { | |
| 585 | document.createStyleSheet().cssText = css; | |
| 586 | } else { | |
| 587 | tag = document.createElement('style'); | |
| 588 | tag.type = 'text/css'; | |
| 589 | document.getElementsByTagName('head')[0].appendChild(tag); | |
| 590 | tag[(typeof document.body.style.WebkitAppearance == 'string') /* webkit only */ ? 'innerText' : 'innerHTML'] = css; | |
| 591 | } | |
| 592 | }; | |
| 593 | ||
| 594 | // Provide a cross-browser interface to a few simple drawing primitives | |
| 595 | $.fn.simpledraw = function (width, height, useExisting, interact) { | |
| 596 | var target, mhandler; | |
| 597 | if (useExisting && (target = this.data('_jqs_vcanvas'))) { | |
| 598 | return target; | |
| 599 | } | |
| 600 | ||
| 601 | if ($.fn.sparkline.canvas === false) { | |
| 602 | // We've already determined that neither Canvas nor VML are available | |
| 603 | return false; | |
| 604 | ||
| 605 | } else if ($.fn.sparkline.canvas === undefined) { | |
| 606 | // No function defined yet -- need to see if we support Canvas or VML | |
| 607 | var el = document.createElement('canvas'); | |
| 608 | if (!!(el.getContext && el.getContext('2d'))) { | |
| 609 | // Canvas is available | |
| 610 | $.fn.sparkline.canvas = function(width, height, target, interact) { | |
| 611 | return new VCanvas_canvas(width, height, target, interact); | |
| 612 | }; | |
| 613 | } else if (document.namespaces && !document.namespaces.v) { | |
| 614 | // VML is available | |
| 615 | document.namespaces.add('v', 'urn:schemas-microsoft-com:vml', '#default#VML'); | |
| 616 | $.fn.sparkline.canvas = function(width, height, target, interact) { | |
| 617 | return new VCanvas_vml(width, height, target); | |
| 618 | }; | |
| 619 | } else { | |
| 620 | // Neither Canvas nor VML are available | |
| 621 | $.fn.sparkline.canvas = false; | |
| 622 | return false; | |
| 623 | } | |
| 624 | } | |
| 625 | ||
| 626 | if (width === undefined) { | |
| 627 | width = $(this).innerWidth(); | |
| 628 | } | |
| 629 | if (height === undefined) { | |
| 630 | height = $(this).innerHeight(); | |
| 631 | } | |
| 632 | ||
| 633 | target = $.fn.sparkline.canvas(width, height, this, interact); | |
| 634 | ||
| 635 | mhandler = $(this).data('_jqs_mhandler'); | |
| 636 | if (mhandler) { | |
| 637 | mhandler.registerCanvas(target); | |
| 638 | } | |
| 639 | return target; | |
| 640 | }; | |
| 641 | ||
| 642 | $.fn.cleardraw = function () { | |
| 643 | var target = this.data('_jqs_vcanvas'); | |
| 644 | if (target) { | |
| 645 | target.reset(); | |
| 646 | } | |
| 647 | }; | |
| 648 | ||
| 649 | $.RangeMapClass = RangeMap = createClass({ | |
| 650 | init: function (map) { | |
| 651 | var key, range, rangelist = []; | |
| 652 | for (key in map) { | |
| 653 | if (map.hasOwnProperty(key) && typeof key === 'string' && key.indexOf(':') > -1) { | |
| 654 | range = key.split(':'); | |
| 655 | range[0] = range[0].length === 0 ? -Infinity : parseFloat(range[0]); | |
| 656 | range[1] = range[1].length === 0 ? Infinity : parseFloat(range[1]); | |
| 657 | range[2] = map[key]; | |
| 658 | rangelist.push(range); | |
| 659 | } | |
| 660 | } | |
| 661 | this.map = map; | |
| 662 | this.rangelist = rangelist || false; | |
| 663 | }, | |
| 664 | ||
| 665 | get: function (value) { | |
| 666 | var rangelist = this.rangelist, | |
| 667 | i, range, result; | |
| 668 | if ((result = this.map[value]) !== undefined) { | |
| 669 | return result; | |
| 670 | } | |
| 671 | if (rangelist) { | |
| 672 | for (i = rangelist.length; i--;) { | |
| 673 | range = rangelist[i]; | |
| 674 | if (range[0] <= value && range[1] >= value) { | |
| 675 | return range[2]; | |
| 676 | } | |
| 677 | } | |
| 678 | } | |
| 679 | return undefined; | |
| 680 | } | |
| 681 | }); | |
| 682 | ||
| 683 | // Convenience function | |
| 684 | $.range_map = function(map) { | |
| 685 | return new RangeMap(map); | |
| 686 | }; | |
| 687 | ||
| 688 | MouseHandler = createClass({ | |
| 689 | init: function (el, options) { | |
| 690 | var $el = $(el); | |
| 691 | this.$el = $el; | |
| 692 | this.options = options; | |
| 693 | this.currentPageX = 0; | |
| 694 | this.currentPageY = 0; | |
| 695 | this.el = el; | |
| 696 | this.splist = []; | |
| 697 | this.tooltip = null; | |
| 698 | this.over = false; | |
| 699 | this.displayTooltips = !options.get('disableTooltips'); | |
| 700 | this.highlightEnabled = !options.get('disableHighlight'); | |
| 701 | }, | |
| 702 | ||
| 703 | registerSparkline: function (sp) { | |
| 704 | this.splist.push(sp); | |
| 705 | if (this.over) { | |
| 706 | this.updateDisplay(); | |
| 707 | } | |
| 708 | }, | |
| 709 | ||
| 710 | registerCanvas: function (canvas) { | |
| 711 | var $canvas = $(canvas.canvas); | |
| 712 | this.canvas = canvas; | |
| 713 | this.$canvas = $canvas; | |
| 714 | $canvas.mouseenter($.proxy(this.mouseenter, this)); | |
| 715 | $canvas.mouseleave($.proxy(this.mouseleave, this)); | |
| 716 | $canvas.click($.proxy(this.mouseclick, this)); | |
| 717 | }, | |
| 718 | ||
| 719 | reset: function (removeTooltip) { | |
| 720 | this.splist = []; | |
| 721 | if (this.tooltip && removeTooltip) { | |
| 722 | this.tooltip.remove(); | |
| 723 | this.tooltip = undefined; | |
| 724 | } | |
| 725 | }, | |
| 726 | ||
| 727 | mouseclick: function (e) { | |
| 728 | var clickEvent = $.Event('sparklineClick'); | |
| 729 | clickEvent.originalEvent = e; | |
| 730 | clickEvent.sparklines = this.splist; | |
| 731 | this.$el.trigger(clickEvent); | |
| 732 | }, | |
| 733 | ||
| 734 | mouseenter: function (e) { | |
| 735 | $(document.body).unbind('mousemove.jqs'); | |
| 736 | $(document.body).bind('mousemove.jqs', $.proxy(this.mousemove, this)); | |
| 737 | this.over = true; | |
| 738 | this.currentPageX = e.pageX; | |
| 739 | this.currentPageY = e.pageY; | |
| 740 | this.currentEl = e.target; | |
| 741 | if (!this.tooltip && this.displayTooltips) { | |
| 742 | this.tooltip = new Tooltip(this.options); | |
| 743 | this.tooltip.updatePosition(e.pageX, e.pageY); | |
| 744 | } | |
| 745 | this.updateDisplay(); | |
| 746 | }, | |
| 747 | ||
| 748 | mouseleave: function () { | |
| 749 | $(document.body).unbind('mousemove.jqs'); | |
| 750 | var splist = this.splist, | |
| 751 | spcount = splist.length, | |
| 752 | needsRefresh = false, | |
| 753 | sp, i; | |
| 754 | this.over = false; | |
| 755 | this.currentEl = null; | |
| 756 | ||
| 757 | if (this.tooltip) { | |
| 758 | this.tooltip.remove(); | |
| 759 | this.tooltip = null; | |
| 760 | } | |
| 761 | ||
| 762 | for (i = 0; i < spcount; i++) { | |
| 763 | sp = splist[i]; | |
| 764 | if (sp.clearRegionHighlight()) { | |
| 765 | needsRefresh = true; | |
| 766 | } | |
| 767 | } | |
| 768 | ||
| 769 | if (needsRefresh) { | |
| 770 | this.canvas.render(); | |
| 771 | } | |
| 772 | }, | |
| 773 | ||
| 774 | mousemove: function (e) { | |
| 775 | this.currentPageX = e.pageX; | |
| 776 | this.currentPageY = e.pageY; | |
| 777 | this.currentEl = e.target; | |
| 778 | if (this.tooltip) { | |
| 779 | this.tooltip.updatePosition(e.pageX, e.pageY); | |
| 780 | } | |
| 781 | this.updateDisplay(); | |
| 782 | }, | |
| 783 | ||
| 784 | updateDisplay: function () { | |
| 785 | var splist = this.splist, | |
| 786 | spcount = splist.length, | |
| 787 | needsRefresh = false, | |
| 788 | offset = this.$canvas.offset(), | |
| 789 | localX = this.currentPageX - offset.left, | |
| 790 | localY = this.currentPageY - offset.top, | |
| 791 | tooltiphtml, sp, i, result, changeEvent; | |
| 792 | if (!this.over) { | |
| 793 | return; | |
| 794 | } | |
| 795 | for (i = 0; i < spcount; i++) { | |
| 796 | sp = splist[i]; | |
| 797 | result = sp.setRegionHighlight(this.currentEl, localX, localY); | |
| 798 | if (result) { | |
| 799 | needsRefresh = true; | |
| 800 | } | |
| 801 | } | |
| 802 | if (needsRefresh) { | |
| 803 | changeEvent = $.Event('sparklineRegionChange'); | |
| 804 | changeEvent.sparklines = this.splist; | |
| 805 | this.$el.trigger(changeEvent); | |
| 806 | if (this.tooltip) { | |
| 807 | tooltiphtml = ''; | |
| 808 | for (i = 0; i < spcount; i++) { | |
| 809 | sp = splist[i]; | |
| 810 | tooltiphtml += sp.getCurrentRegionTooltip(); | |
| 811 | } | |
| 812 | this.tooltip.setContent(tooltiphtml); | |
| 813 | } | |
| 814 | if (!this.disableHighlight) { | |
| 815 | this.canvas.render(); | |
| 816 | } | |
| 817 | } | |
| 818 | if (result === null) { | |
| 819 | this.mouseleave(); | |
| 820 | } | |
| 821 | } | |
| 822 | }); | |
| 823 | ||
| 824 | ||
| 825 | Tooltip = createClass({ | |
| 826 | sizeStyle: 'position: static !important;' + | |
| 827 | 'display: block !important;' + | |
| 828 | 'visibility: hidden !important;' + | |
| 829 | 'float: left !important;', | |
| 830 | ||
| 831 | init: function (options) { | |
| 832 | var tooltipClassname = options.get('tooltipClassname', 'jqstooltip'), | |
| 833 | sizetipStyle = this.sizeStyle, | |
| 834 | offset; | |
| 835 | this.container = options.get('tooltipContainer') || document.body; | |
| 836 | this.tooltipOffsetX = options.get('tooltipOffsetX', 10); | |
| 837 | this.tooltipOffsetY = options.get('tooltipOffsetY', 12); | |
| 838 | // remove any previous lingering tooltip | |
| 839 | $('#jqssizetip').remove(); | |
| 840 | $('#jqstooltip').remove(); | |
| 841 | this.sizetip = $('<div/>', { | |
| 842 | id: 'jqssizetip', | |
| 843 | style: sizetipStyle, | |
| 844 | 'class': tooltipClassname | |
| 845 | }); | |
| 846 | this.tooltip = $('<div/>', { | |
| 847 | id: 'jqstooltip', | |
| 848 | 'class': tooltipClassname | |
| 849 | }).appendTo(this.container); | |
| 850 | // account for the container's location | |
| 851 | offset = this.tooltip.offset(); | |
| 852 | this.offsetLeft = offset.left; | |
| 853 | this.offsetTop = offset.top; | |
| 854 | this.hidden = true; | |
| 855 | $(window).unbind('resize.jqs scroll.jqs'); | |
| 856 | $(window).bind('resize.jqs scroll.jqs', $.proxy(this.updateWindowDims, this)); | |
| 857 | this.updateWindowDims(); | |
| 858 | }, | |
| 859 | ||
| 860 | updateWindowDims: function () { | |
| 861 | this.scrollTop = $(window).scrollTop(); | |
| 862 | this.scrollLeft = $(window).scrollLeft(); | |
| 863 | this.scrollRight = this.scrollLeft + $(window).width(); | |
| 864 | this.updatePosition(); | |
| 865 | }, | |
| 866 | ||
| 867 | getSize: function (content) { | |
| 868 | this.sizetip.html(content).appendTo(this.container); | |
| 869 | this.width = this.sizetip.width() + 1; | |
| 870 | this.height = this.sizetip.height(); | |
| 871 | this.sizetip.remove(); | |
| 872 | }, | |
| 873 | ||
| 874 | setContent: function (content) { | |
| 875 | if (!content) { | |
| 876 | this.tooltip.css('visibility', 'hidden'); | |
| 877 | this.hidden = true; | |
| 878 | return; | |
| 879 | } | |
| 880 | this.getSize(content); | |
| 881 | this.tooltip.html(content) | |
| 882 | .css({ | |
| 883 | 'width': this.width, | |
| 884 | 'height': this.height, | |
| 885 | 'visibility': 'visible' | |
| 886 | }); | |
| 887 | if (this.hidden) { | |
| 888 | this.hidden = false; | |
| 889 | this.updatePosition(); | |
| 890 | } | |
| 891 | }, | |
| 892 | ||
| 893 | updatePosition: function (x, y) { | |
| 894 | if (x === undefined) { | |
| 895 | if (this.mousex === undefined) { | |
| 896 | return; | |
| 897 | } | |
| 898 | x = this.mousex - this.offsetLeft; | |
| 899 | y = this.mousey - this.offsetTop; | |
| 900 | ||
| 901 | } else { | |
| 902 | this.mousex = x = x - this.offsetLeft; | |
| 903 | this.mousey = y = y - this.offsetTop; | |
| 904 | } | |
| 905 | if (!this.height || !this.width || this.hidden) { | |
| 906 | return; | |
| 907 | } | |
| 908 | ||
| 909 | y -= this.height + this.tooltipOffsetY; | |
| 910 | x += this.tooltipOffsetX; | |
| 911 | ||
| 912 | if (y < this.scrollTop) { | |
| 913 | y = this.scrollTop; | |
| 914 | } | |
| 915 | if (x < this.scrollLeft) { | |
| 916 | x = this.scrollLeft; | |
| 917 | } else if (x + this.width > this.scrollRight) { | |
| 918 | x = this.scrollRight - this.width; | |
| 919 | } | |
| 920 | ||
| 921 | this.tooltip.css({ | |
| 922 | 'left': x, | |
| 923 | 'top': y | |
| 924 | }); | |
| 925 | }, | |
| 926 | ||
| 927 | remove: function () { | |
| 928 | this.tooltip.remove(); | |
| 929 | this.sizetip.remove(); | |
| 930 | this.sizetip = this.tooltip = undefined; | |
| 931 | $(window).unbind('resize.jqs scroll.jqs'); | |
| 932 | } | |
| 933 | }); | |
| 934 | ||
| 935 | initStyles = function() { | |
| 936 | addCSS(defaultStyles); | |
| 937 | }; | |
| 938 | ||
| 939 | $(initStyles); | |
| 940 | ||
| 941 | pending = []; | |
| 942 | $.fn.sparkline = function (userValues, userOptions) { | |
| 943 | return this.each(function () { | |
| 944 | var options = new $.fn.sparkline.options(this, userOptions), | |
| 945 | $this = $(this), | |
| 946 | render, i; | |
| 947 | render = function () { | |
| 948 | var values, width, height, tmp, mhandler, sp, vals; | |
| 949 | if (userValues === 'html' || userValues === undefined) { | |
| 950 | vals = this.getAttribute(options.get('tagValuesAttribute')); | |
| 951 | if (vals === undefined || vals === null) { | |
| 952 | vals = $this.html(); | |
| 953 | } | |
| 954 | values = vals.replace(/(^\s*<!--)|(-->\s*$)|\s+/g, '').split(','); | |
| 955 | } else { | |
| 956 | values = userValues; | |
| 957 | } | |
| 958 | ||
| 959 | width = options.get('width') === 'auto' ? values.length * options.get('defaultPixelsPerValue') : options.get('width'); | |
| 960 | if (options.get('height') === 'auto') { | |
| 961 | if (!options.get('composite') || !$.data(this, '_jqs_vcanvas')) { | |
| 962 | // must be a better way to get the line height | |
| 963 | tmp = document.createElement('span'); | |
| 964 | tmp.innerHTML = 'a'; | |
| 965 | $this.html(tmp); | |
| 966 | height = $(tmp).innerHeight() || $(tmp).height(); | |
| 967 | $(tmp).remove(); | |
| 968 | tmp = null; | |
| 969 | } | |
| 970 | } else { | |
| 971 | height = options.get('height'); | |
| 972 | } | |
| 973 | ||
| 974 | if (!options.get('disableInteraction')) { | |
| 975 | mhandler = $.data(this, '_jqs_mhandler'); | |
| 976 | if (!mhandler) { | |
| 977 | mhandler = new MouseHandler(this, options); | |
| 978 | $.data(this, '_jqs_mhandler', mhandler); | |
| 979 | } else if (!options.get('composite')) { | |
| 980 | mhandler.reset(); | |
| 981 | } | |
| 982 | } else { | |
| 983 | mhandler = false; | |
| 984 | } | |
| 985 | ||
| 986 | if (options.get('composite') && !$.data(this, '_jqs_vcanvas')) { | |
| 987 | if (!$.data(this, '_jqs_errnotify')) { | |
| 988 | alert('Attempted to attach a composite sparkline to an element with no existing sparkline'); | |
| 989 | $.data(this, '_jqs_errnotify', true); | |
| 990 | } | |
| 991 | return; | |
| 992 | } | |
| 993 | ||
| 994 | sp = new $.fn.sparkline[options.get('type')](this, values, options, width, height); | |
| 995 | ||
| 996 | sp.render(); | |
| 997 | ||
| 998 | if (mhandler) { | |
| 999 | mhandler.registerSparkline(sp); | |
| 1000 | } | |
| 1001 | }; | |
| 1002 | if (($(this).html() && !options.get('disableHiddenCheck') && $(this).is(':hidden')) || !$(this).parents('body').length) { | |
| 1003 | if (!options.get('composite') && $.data(this, '_jqs_pending')) { | |
| 1004 | // remove any existing references to the element | |
| 1005 | for (i = pending.length; i; i--) { | |
| 1006 | if (pending[i - 1][0] == this) { | |
| 1007 | pending.splice(i - 1, 1); | |
| 1008 | } | |
| 1009 | } | |
| 1010 | } | |
| 1011 | pending.push([this, render]); | |
| 1012 | $.data(this, '_jqs_pending', true); | |
| 1013 | } else { | |
| 1014 | render.call(this); | |
| 1015 | } | |
| 1016 | }); | |
| 1017 | }; | |
| 1018 | ||
| 1019 | $.fn.sparkline.defaults = getDefaults(); | |
| 1020 | ||
| 1021 | ||
| 1022 | $.sparkline_display_visible = function () { | |
| 1023 | var el, i, pl; | |
| 1024 | var done = []; | |
| 1025 | for (i = 0, pl = pending.length; i < pl; i++) { | |
| 1026 | el = pending[i][0]; | |
| 1027 | if ($(el).is(':visible') && !$(el).parents().is(':hidden')) { | |
| 1028 | pending[i][1].call(el); | |
| 1029 | $.data(pending[i][0], '_jqs_pending', false); | |
| 1030 | done.push(i); | |
| 1031 | } else if (!$(el).closest('html').length && !$.data(el, '_jqs_pending')) { | |
| 1032 | // element has been inserted and removed from the DOM | |
| 1033 | // If it was not yet inserted into the dom then the .data request | |
| 1034 | // will return true. | |
| 1035 | // removing from the dom causes the data to be removed. | |
| 1036 | $.data(pending[i][0], '_jqs_pending', false); | |
| 1037 | done.push(i); | |
| 1038 | } | |
| 1039 | } | |
| 1040 | for (i = done.length; i; i--) { | |
| 1041 | pending.splice(done[i - 1], 1); | |
| 1042 | } | |
| 1043 | }; | |
| 1044 | ||
| 1045 | ||
| 1046 | /** | |
| 1047 | * User option handler | |
| 1048 | */ | |
| 1049 | $.fn.sparkline.options = createClass({ | |
| 1050 | init: function (tag, userOptions) { | |
| 1051 | var extendedOptions, defaults, base, tagOptionType; | |
| 1052 | this.userOptions = userOptions = userOptions || {}; | |
| 1053 | this.tag = tag; | |
| 1054 | this.tagValCache = {}; | |
| 1055 | defaults = $.fn.sparkline.defaults; | |
| 1056 | base = defaults.common; | |
| 1057 | this.tagOptionsPrefix = userOptions.enableTagOptions && (userOptions.tagOptionsPrefix || base.tagOptionsPrefix); | |
| 1058 | ||
| 1059 | tagOptionType = this.getTagSetting('type'); | |
| 1060 | if (tagOptionType === UNSET_OPTION) { | |
| 1061 | extendedOptions = defaults[userOptions.type || base.type]; | |
| 1062 | } else { | |
| 1063 | extendedOptions = defaults[tagOptionType]; | |
| 1064 | } | |
| 1065 | this.mergedOptions = $.extend({}, base, extendedOptions, userOptions); | |
| 1066 | }, | |
| 1067 | ||
| 1068 | ||
| 1069 | getTagSetting: function (key) { | |
| 1070 | var prefix = this.tagOptionsPrefix, | |
| 1071 | val, i, pairs, keyval; | |
| 1072 | if (prefix === false || prefix === undefined) { | |
| 1073 | return UNSET_OPTION; | |
| 1074 | } | |
| 1075 | if (this.tagValCache.hasOwnProperty(key)) { | |
| 1076 | val = this.tagValCache.key; | |
| 1077 | } else { | |
| 1078 | val = this.tag.getAttribute(prefix + key); | |
| 1079 | if (val === undefined || val === null) { | |
| 1080 | val = UNSET_OPTION; | |
| 1081 | } else if (val.substr(0, 1) === '[') { | |
| 1082 | val = val.substr(1, val.length - 2).split(','); | |
| 1083 | for (i = val.length; i--;) { | |
| 1084 | val[i] = normalizeValue(val[i].replace(/(^\s*)|(\s*$)/g, '')); | |
| 1085 | } | |
| 1086 | } else if (val.substr(0, 1) === '{') { | |
| 1087 | pairs = val.substr(1, val.length - 2).split(','); | |
| 1088 | val = {}; | |
| 1089 | for (i = pairs.length; i--;) { | |
| 1090 | keyval = pairs[i].split(':', 2); | |
| 1091 | val[keyval[0].replace(/(^\s*)|(\s*$)/g, '')] = normalizeValue(keyval[1].replace(/(^\s*)|(\s*$)/g, '')); | |
| 1092 | } | |
| 1093 | } else { | |
| 1094 | val = normalizeValue(val); | |
| 1095 | } | |
| 1096 | this.tagValCache.key = val; | |
| 1097 | } | |
| 1098 | return val; | |
| 1099 | }, | |
| 1100 | ||
| 1101 | get: function (key, defaultval) { | |
| 1102 | var tagOption = this.getTagSetting(key), | |
| 1103 | result; | |
| 1104 | if (tagOption !== UNSET_OPTION) { | |
| 1105 | return tagOption; | |
| 1106 | } | |
| 1107 | return (result = this.mergedOptions[key]) === undefined ? defaultval : result; | |
| 1108 | } | |
| 1109 | }); | |
| 1110 | ||
| 1111 | ||
| 1112 | $.fn.sparkline._base = createClass({ | |
| 1113 | disabled: false, | |
| 1114 | ||
| 1115 | init: function (el, values, options, width, height) { | |
| 1116 | this.el = el; | |
| 1117 | this.$el = $(el); | |
| 1118 | this.values = values; | |
| 1119 | this.options = options; | |
| 1120 | this.width = width; | |
| 1121 | this.height = height; | |
| 1122 | this.currentRegion = undefined; | |
| 1123 | }, | |
| 1124 | ||
| 1125 | /** | |
| 1126 | * Setup the canvas | |
| 1127 | */ | |
| 1128 | initTarget: function () { | |
| 1129 | var interactive = !this.options.get('disableInteraction'); | |
| 1130 | if (!(this.target = this.$el.simpledraw(this.width, this.height, this.options.get('composite'), interactive))) { | |
| 1131 | this.disabled = true; | |
| 1132 | } else { | |
| 1133 | this.canvasWidth = this.target.pixelWidth; | |
| 1134 | this.canvasHeight = this.target.pixelHeight; | |
| 1135 | } | |
| 1136 | }, | |
| 1137 | ||
| 1138 | /** | |
| 1139 | * Actually render the chart to the canvas | |
| 1140 | */ | |
| 1141 | render: function () { | |
| 1142 | if (this.disabled) { | |
| 1143 | this.el.innerHTML = ''; | |
| 1144 | return false; | |
| 1145 | } | |
| 1146 | return true; | |
| 1147 | }, | |
| 1148 | ||
| 1149 | /** | |
| 1150 | * Return a region id for a given x/y co-ordinate | |
| 1151 | */ | |
| 1152 | getRegion: function (x, y) { | |
| 1153 | }, | |
| 1154 | ||
| 1155 | /** | |
| 1156 | * Highlight an item based on the moused-over x,y co-ordinate | |
| 1157 | */ | |
| 1158 | setRegionHighlight: function (el, x, y) { | |
| 1159 | var currentRegion = this.currentRegion, | |
| 1160 | highlightEnabled = !this.options.get('disableHighlight'), | |
| 1161 | newRegion; | |
| 1162 | if (x > this.canvasWidth || y > this.canvasHeight || x < 0 || y < 0) { | |
| 1163 | return null; | |
| 1164 | } | |
| 1165 | newRegion = this.getRegion(el, x, y); | |
| 1166 | if (currentRegion !== newRegion) { | |
| 1167 | if (currentRegion !== undefined && highlightEnabled) { | |
| 1168 | this.removeHighlight(); | |
| 1169 | } | |
| 1170 | this.currentRegion = newRegion; | |
| 1171 | if (newRegion !== undefined && highlightEnabled) { | |
| 1172 | this.renderHighlight(); | |
| 1173 | } | |
| 1174 | return true; | |
| 1175 | } | |
| 1176 | return false; | |
| 1177 | }, | |
| 1178 | ||
| 1179 | /** | |
| 1180 | * Reset any currently highlighted item | |
| 1181 | */ | |
| 1182 | clearRegionHighlight: function () { | |
| 1183 | if (this.currentRegion !== undefined) { | |
| 1184 | this.removeHighlight(); | |
| 1185 | this.currentRegion = undefined; | |
| 1186 | return true; | |
| 1187 | } | |
| 1188 | return false; | |
| 1189 | }, | |
| 1190 | ||
| 1191 | renderHighlight: function () { | |
| 1192 | this.changeHighlight(true); | |
| 1193 | }, | |
| 1194 | ||
| 1195 | removeHighlight: function () { | |
| 1196 | this.changeHighlight(false); | |
| 1197 | }, | |
| 1198 | ||
| 1199 | changeHighlight: function (highlight) {}, | |
| 1200 | ||
| 1201 | /** | |
| 1202 | * Fetch the HTML to display as a tooltip | |
| 1203 | */ | |
| 1204 | getCurrentRegionTooltip: function () { | |
| 1205 | var options = this.options, | |
| 1206 | header = '', | |
| 1207 | entries = [], | |
| 1208 | fields, formats, formatlen, fclass, text, i, | |
| 1209 | showFields, showFieldsKey, newFields, fv, | |
| 1210 | formatter, format, fieldlen, j; | |
| 1211 | if (this.currentRegion === undefined) { | |
| 1212 | return ''; | |
| 1213 | } | |
| 1214 | fields = this.getCurrentRegionFields(); | |
| 1215 | formatter = options.get('tooltipFormatter'); | |
| 1216 | if (formatter) { | |
| 1217 | return formatter(this, options, fields); | |
| 1218 | } | |
| 1219 | if (options.get('tooltipChartTitle')) { | |
| 1220 | header += '<div class="jqs jqstitle">' + options.get('tooltipChartTitle') + '</div>\n'; | |
| 1221 | } | |
| 1222 | formats = this.options.get('tooltipFormat'); | |
| 1223 | if (!formats) { | |
| 1224 | return ''; | |
| 1225 | } | |
| 1226 | if (!$.isArray(formats)) { | |
| 1227 | formats = [formats]; | |
| 1228 | } | |
| 1229 | if (!$.isArray(fields)) { | |
| 1230 | fields = [fields]; | |
| 1231 | } | |
| 1232 | showFields = this.options.get('tooltipFormatFieldlist'); | |
| 1233 | showFieldsKey = this.options.get('tooltipFormatFieldlistKey'); | |
| 1234 | if (showFields && showFieldsKey) { | |
| 1235 | // user-selected ordering of fields | |
| 1236 | newFields = []; | |
| 1237 | for (i = fields.length; i--;) { | |
| 1238 | fv = fields[i][showFieldsKey]; | |
| 1239 | if ((j = $.inArray(fv, showFields)) != -1) { | |
| 1240 | newFields[j] = fields[i]; | |
| 1241 | } | |
| 1242 | } | |
| 1243 | fields = newFields; | |
| 1244 | } | |
| 1245 | formatlen = formats.length; | |
| 1246 | fieldlen = fields.length; | |
| 1247 | for (i = 0; i < formatlen; i++) { | |
| 1248 | format = formats[i]; | |
| 1249 | if (typeof format === 'string') { | |
| 1250 | format = new SPFormat(format); | |
| 1251 | } | |
| 1252 | fclass = format.fclass || 'jqsfield'; | |
| 1253 | for (j = 0; j < fieldlen; j++) { | |
| 1254 | if (!fields[j].isNull || !options.get('tooltipSkipNull')) { | |
| 1255 | $.extend(fields[j], { | |
| 1256 | prefix: options.get('tooltipPrefix'), | |
| 1257 | suffix: options.get('tooltipSuffix') | |
| 1258 | }); | |
| 1259 | text = format.render(fields[j], options.get('tooltipValueLookups'), options); | |
| 1260 | entries.push('<div class="' + fclass + '">' + text + '</div>'); | |
| 1261 | } | |
| 1262 | } | |
| 1263 | } | |
| 1264 | if (entries.length) { | |
| 1265 | return header + entries.join('\n'); | |
| 1266 | } | |
| 1267 | return ''; | |
| 1268 | }, | |
| 1269 | ||
| 1270 | getCurrentRegionFields: function () {}, | |
| 1271 | ||
| 1272 | calcHighlightColor: function (color, options) { | |
| 1273 | var highlightColor = options.get('highlightColor'), | |
| 1274 | lighten = options.get('highlightLighten'), | |
| 1275 | parse, mult, rgbnew, i; | |
| 1276 | if (highlightColor) { | |
| 1277 | return highlightColor; | |
| 1278 | } | |
| 1279 | if (lighten) { | |
| 1280 | // extract RGB values | |
| 1281 | parse = /^#([0-9a-f])([0-9a-f])([0-9a-f])$/i.exec(color) || /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(color); | |
| 1282 | if (parse) { | |
| 1283 | rgbnew = []; | |
| 1284 | mult = color.length === 4 ? 16 : 1; | |
| 1285 | for (i = 0; i < 3; i++) { | |
| 1286 | rgbnew[i] = clipval(Math.round(parseInt(parse[i + 1], 16) * mult * lighten), 0, 255); | |
| 1287 | } | |
| 1288 | return 'rgb(' + rgbnew.join(',') + ')'; | |
| 1289 | } | |
| 1290 | ||
| 1291 | } | |
| 1292 | return color; | |
| 1293 | } | |
| 1294 | ||
| 1295 | }); | |
| 1296 | ||
| 1297 | barHighlightMixin = { | |
| 1298 | changeHighlight: function (highlight) { | |
| 1299 | var currentRegion = this.currentRegion, | |
| 1300 | target = this.target, | |
| 1301 | shapeids = this.regionShapes[currentRegion], | |
| 1302 | newShapes; | |
| 1303 | // will be null if the region value was null | |
| 1304 | if (shapeids) { | |
| 1305 | newShapes = this.renderRegion(currentRegion, highlight); | |
| 1306 | if ($.isArray(newShapes) || $.isArray(shapeids)) { | |
| 1307 | target.replaceWithShapes(shapeids, newShapes); | |
| 1308 | this.regionShapes[currentRegion] = $.map(newShapes, function (newShape) { | |
| 1309 | return newShape.id; | |
| 1310 | }); | |
| 1311 | } else { | |
| 1312 | target.replaceWithShape(shapeids, newShapes); | |
| 1313 | this.regionShapes[currentRegion] = newShapes.id; | |
| 1314 | } | |
| 1315 | } | |
| 1316 | }, | |
| 1317 | ||
| 1318 | render: function () { | |
| 1319 | var values = this.values, | |
| 1320 | target = this.target, | |
| 1321 | regionShapes = this.regionShapes, | |
| 1322 | shapes, ids, i, j; | |
| 1323 | ||
| 1324 | if (!this.cls._super.render.call(this)) { | |
| 1325 | return; | |
| 1326 | } | |
| 1327 | for (i = values.length; i--;) { | |
| 1328 | shapes = this.renderRegion(i); | |
| 1329 | if (shapes) { | |
| 1330 | if ($.isArray(shapes)) { | |
| 1331 | ids = []; | |
| 1332 | for (j = shapes.length; j--;) { | |
| 1333 | shapes[j].append(); | |
| 1334 | ids.push(shapes[j].id); | |
| 1335 | } | |
| 1336 | regionShapes[i] = ids; | |
| 1337 | } else { | |
| 1338 | shapes.append(); | |
| 1339 | regionShapes[i] = shapes.id; // store just the shapeid | |
| 1340 | } | |
| 1341 | } else { | |
| 1342 | // null value | |
| 1343 | regionShapes[i] = null; | |
| 1344 | } | |
| 1345 | } | |
| 1346 | target.render(); | |
| 1347 | } | |
| 1348 | }; | |
| 1349 | ||
| 1350 | /** | |
| 1351 | * Line charts | |
| 1352 | */ | |
| 1353 | $.fn.sparkline.line = line = createClass($.fn.sparkline._base, { | |
| 1354 | type: 'line', | |
| 1355 | ||
| 1356 | init: function (el, values, options, width, height) { | |
| 1357 | line._super.init.call(this, el, values, options, width, height); | |
| 1358 | this.vertices = []; | |
| 1359 | this.regionMap = []; | |
| 1360 | this.xvalues = []; | |
| 1361 | this.yvalues = []; | |
| 1362 | this.yminmax = []; | |
| 1363 | this.hightlightSpotId = null; | |
| 1364 | this.lastShapeId = null; | |
| 1365 | this.initTarget(); | |
| 1366 | }, | |
| 1367 | ||
| 1368 | getRegion: function (el, x, y) { | |
| 1369 | var i, | |
| 1370 | regionMap = this.regionMap; // maps regions to value positions | |
| 1371 | for (i = regionMap.length; i--;) { | |
| 1372 | if (regionMap[i] !== null && x >= regionMap[i][0] && x <= regionMap[i][1]) { | |
| 1373 | return regionMap[i][2]; | |
| 1374 | } | |
| 1375 | } | |
| 1376 | return undefined; | |
| 1377 | }, | |
| 1378 | ||
| 1379 | getCurrentRegionFields: function () { | |
| 1380 | var currentRegion = this.currentRegion; | |
| 1381 | return { | |
| 1382 | isNull: this.yvalues[currentRegion] === null, | |
| 1383 | x: this.xvalues[currentRegion], | |
| 1384 | y: this.yvalues[currentRegion], | |
| 1385 | color: this.options.get('lineColor'), | |
| 1386 | fillColor: this.options.get('fillColor'), | |
| 1387 | offset: currentRegion | |
| 1388 | }; | |
| 1389 | }, | |
| 1390 | ||
| 1391 | renderHighlight: function () { | |
| 1392 | var currentRegion = this.currentRegion, | |
| 1393 | target = this.target, | |
| 1394 | vertex = this.vertices[currentRegion], | |
| 1395 | options = this.options, | |
| 1396 | spotRadius = options.get('spotRadius'), | |
| 1397 | highlightSpotColor = options.get('highlightSpotColor'), | |
| 1398 | highlightLineColor = options.get('highlightLineColor'), | |
| 1399 | highlightSpot, highlightLine; | |
| 1400 | ||
| 1401 | if (!vertex) { | |
| 1402 | return; | |
| 1403 | } | |
| 1404 | if (spotRadius && highlightSpotColor) { | |
| 1405 | highlightSpot = target.drawCircle(vertex[0], vertex[1], | |
| 1406 | spotRadius, undefined, highlightSpotColor); | |
| 1407 | this.highlightSpotId = highlightSpot.id; | |
| 1408 | target.insertAfterShape(this.lastShapeId, highlightSpot); | |
| 1409 | } | |
| 1410 | if (highlightLineColor) { | |
| 1411 | highlightLine = target.drawLine(vertex[0], this.canvasTop, vertex[0], | |
| 1412 | this.canvasTop + this.canvasHeight, highlightLineColor); | |
| 1413 | this.highlightLineId = highlightLine.id; | |
| 1414 | target.insertAfterShape(this.lastShapeId, highlightLine); | |
| 1415 | } | |
| 1416 | }, | |
| 1417 | ||
| 1418 | removeHighlight: function () { | |
| 1419 | var target = this.target; | |
| 1420 | if (this.highlightSpotId) { | |
| 1421 | target.removeShapeId(this.highlightSpotId); | |
| 1422 | this.highlightSpotId = null; | |
| 1423 | } | |
| 1424 | if (this.highlightLineId) { | |
| 1425 | target.removeShapeId(this.highlightLineId); | |
| 1426 | this.highlightLineId = null; | |
| 1427 | } | |
| 1428 | }, | |
| 1429 | ||
| 1430 | scanValues: function () { | |
| 1431 | var values = this.values, | |
| 1432 | valcount = values.length, | |
| 1433 | xvalues = this.xvalues, | |
| 1434 | yvalues = this.yvalues, | |
| 1435 | yminmax = this.yminmax, | |
| 1436 | i, val, isStr, isArray, sp; | |
| 1437 | for (i = 0; i < valcount; i++) { | |
| 1438 | val = values[i]; | |
| 1439 | isStr = typeof(values[i]) === 'string'; | |
| 1440 | isArray = typeof(values[i]) === 'object' && values[i] instanceof Array; | |
| 1441 | sp = isStr && values[i].split(':'); | |
| 1442 | if (isStr && sp.length === 2) { // x:y | |
| 1443 | xvalues.push(Number(sp[0])); | |
| 1444 | yvalues.push(Number(sp[1])); | |
| 1445 | yminmax.push(Number(sp[1])); | |
| 1446 | } else if (isArray) { | |
| 1447 | xvalues.push(val[0]); | |
| 1448 | yvalues.push(val[1]); | |
| 1449 | yminmax.push(val[1]); | |
| 1450 | } else { | |
| 1451 | xvalues.push(i); | |
| 1452 | if (values[i] === null || values[i] === 'null') { | |
| 1453 | yvalues.push(null); | |
| 1454 | } else { | |
| 1455 | yvalues.push(Number(val)); | |
| 1456 | yminmax.push(Number(val)); | |
| 1457 | } | |
| 1458 | } | |
| 1459 | } | |
| 1460 | if (this.options.get('xvalues')) { | |
| 1461 | xvalues = this.options.get('xvalues'); | |
| 1462 | } | |
| 1463 | ||
| 1464 | this.maxy = this.maxyorg = Math.max.apply(Math, yminmax); | |
| 1465 | this.miny = this.minyorg = Math.min.apply(Math, yminmax); | |
| 1466 | ||
| 1467 | this.maxx = Math.max.apply(Math, xvalues); | |
| 1468 | this.minx = Math.min.apply(Math, xvalues); | |
| 1469 | ||
| 1470 | this.xvalues = xvalues; | |
| 1471 | this.yvalues = yvalues; | |
| 1472 | this.yminmax = yminmax; | |
| 1473 | ||
| 1474 | }, | |
| 1475 | ||
| 1476 | processRangeOptions: function () { | |
| 1477 | var options = this.options, | |
| 1478 | normalRangeMin = options.get('normalRangeMin'), | |
| 1479 | normalRangeMax = options.get('normalRangeMax'); | |
| 1480 | ||
| 1481 | if (normalRangeMin !== undefined) { | |
| 1482 | if (normalRangeMin < this.miny) { | |
| 1483 | this.miny = normalRangeMin; | |
| 1484 | } | |
| 1485 | if (normalRangeMax > this.maxy) { | |
| 1486 | this.maxy = normalRangeMax; | |
| 1487 | } | |
| 1488 | } | |
| 1489 | if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < this.miny)) { | |
| 1490 | this.miny = options.get('chartRangeMin'); | |
| 1491 | } | |
| 1492 | if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > this.maxy)) { | |
| 1493 | this.maxy = options.get('chartRangeMax'); | |
| 1494 | } | |
| 1495 | if (options.get('chartRangeMinX') !== undefined && (options.get('chartRangeClipX') || options.get('chartRangeMinX') < this.minx)) { | |
| 1496 | this.minx = options.get('chartRangeMinX'); | |
| 1497 | } | |
| 1498 | if (options.get('chartRangeMaxX') !== undefined && (options.get('chartRangeClipX') || options.get('chartRangeMaxX') > this.maxx)) { | |
| 1499 | this.maxx = options.get('chartRangeMaxX'); | |
| 1500 | } | |
| 1501 | ||
| 1502 | }, | |
| 1503 | ||
| 1504 | drawNormalRange: function (canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey) { | |
| 1505 | var normalRangeMin = this.options.get('normalRangeMin'), | |
| 1506 | normalRangeMax = this.options.get('normalRangeMax'), | |
| 1507 | ytop = canvasTop + Math.round(canvasHeight - (canvasHeight * ((normalRangeMax - this.miny) / rangey))), | |
| 1508 | height = Math.round((canvasHeight * (normalRangeMax - normalRangeMin)) / rangey); | |
| 1509 | this.target.drawRect(canvasLeft, ytop, canvasWidth, height, undefined, this.options.get('normalRangeColor')).append(); | |
| 1510 | }, | |
| 1511 | ||
| 1512 | render: function () { | |
| 1513 | var options = this.options, | |
| 1514 | target = this.target, | |
| 1515 | canvasWidth = this.canvasWidth, | |
| 1516 | canvasHeight = this.canvasHeight, | |
| 1517 | vertices = this.vertices, | |
| 1518 | spotRadius = options.get('spotRadius'), | |
| 1519 | regionMap = this.regionMap, | |
| 1520 | rangex, rangey, yvallast, | |
| 1521 | canvasTop, canvasLeft, | |
| 1522 | vertex, path, paths, x, y, xnext, xpos, xposnext, | |
| 1523 | last, next, yvalcount, lineShapes, fillShapes, plen, | |
| 1524 | valueSpots, hlSpotsEnabled, color, xvalues, yvalues, i; | |
| 1525 | ||
| 1526 | if (!line._super.render.call(this)) { | |
| 1527 | return; | |
| 1528 | } | |
| 1529 | ||
| 1530 | this.scanValues(); | |
| 1531 | this.processRangeOptions(); | |
| 1532 | ||
| 1533 | xvalues = this.xvalues; | |
| 1534 | yvalues = this.yvalues; | |
| 1535 | ||
| 1536 | if (!this.yminmax.length || this.yvalues.length < 2) { | |
| 1537 | // empty or all null valuess | |
| 1538 | return; | |
| 1539 | } | |
| 1540 | ||
| 1541 | canvasTop = canvasLeft = 0; | |
| 1542 | ||
| 1543 | rangex = this.maxx - this.minx === 0 ? 1 : this.maxx - this.minx; | |
| 1544 | rangey = this.maxy - this.miny === 0 ? 1 : this.maxy - this.miny; | |
| 1545 | yvallast = this.yvalues.length - 1; | |
| 1546 | ||
| 1547 | if (spotRadius && (canvasWidth < (spotRadius * 4) || canvasHeight < (spotRadius * 4))) { | |
| 1548 | spotRadius = 0; | |
| 1549 | } | |
| 1550 | if (spotRadius) { | |
| 1551 | // adjust the canvas size as required so that spots will fit | |
| 1552 | hlSpotsEnabled = options.get('highlightSpotColor') && !options.get('disableInteraction'); | |
| 1553 | if (hlSpotsEnabled || options.get('minSpotColor') || (options.get('spotColor') && yvalues[yvallast] === this.miny)) { | |
| 1554 | canvasHeight -= Math.ceil(spotRadius); | |
| 1555 | } | |
| 1556 | if (hlSpotsEnabled || options.get('maxSpotColor') || (options.get('spotColor') && yvalues[yvallast] === this.maxy)) { | |
| 1557 | canvasHeight -= Math.ceil(spotRadius); | |
| 1558 | canvasTop += Math.ceil(spotRadius); | |
| 1559 | } | |
| 1560 | if (hlSpotsEnabled || | |
| 1561 | ((options.get('minSpotColor') || options.get('maxSpotColor')) && (yvalues[0] === this.miny || yvalues[0] === this.maxy))) { | |
| 1562 | canvasLeft += Math.ceil(spotRadius); | |
| 1563 | canvasWidth -= Math.ceil(spotRadius); | |
| 1564 | } | |
| 1565 | if (hlSpotsEnabled || options.get('spotColor') || | |
| 1566 | (options.get('minSpotColor') || options.get('maxSpotColor') && | |
| 1567 | (yvalues[yvallast] === this.miny || yvalues[yvallast] === this.maxy))) { | |
| 1568 | canvasWidth -= Math.ceil(spotRadius); | |
| 1569 | } | |
| 1570 | } | |
| 1571 | ||
| 1572 | ||
| 1573 | canvasHeight--; | |
| 1574 | ||
| 1575 | if (options.get('normalRangeMin') !== undefined && !options.get('drawNormalOnTop')) { | |
| 1576 | this.drawNormalRange(canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey); | |
| 1577 | } | |
| 1578 | ||
| 1579 | path = []; | |
| 1580 | paths = [path]; | |
| 1581 | last = next = null; | |
| 1582 | yvalcount = yvalues.length; | |
| 1583 | for (i = 0; i < yvalcount; i++) { | |
| 1584 | x = xvalues[i]; | |
| 1585 | xnext = xvalues[i + 1]; | |
| 1586 | y = yvalues[i]; | |
| 1587 | xpos = canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)); | |
| 1588 | xposnext = i < yvalcount - 1 ? canvasLeft + Math.round((xnext - this.minx) * (canvasWidth / rangex)) : canvasWidth; | |
| 1589 | next = xpos + ((xposnext - xpos) / 2); | |
| 1590 | regionMap[i] = [last || 0, next, i]; | |
| 1591 | last = next; | |
| 1592 | if (y === null) { | |
| 1593 | if (i) { | |
| 1594 | if (yvalues[i - 1] !== null) { | |
| 1595 | path = []; | |
| 1596 | paths.push(path); | |
| 1597 | } | |
| 1598 | vertices.push(null); | |
| 1599 | } | |
| 1600 | } else { | |
| 1601 | if (y < this.miny) { | |
| 1602 | y = this.miny; | |
| 1603 | } | |
| 1604 | if (y > this.maxy) { | |
| 1605 | y = this.maxy; | |
| 1606 | } | |
| 1607 | if (!path.length) { | |
| 1608 | // previous value was null | |
| 1609 | path.push([xpos, canvasTop + canvasHeight]); | |
| 1610 | } | |
| 1611 | vertex = [xpos, canvasTop + Math.round(canvasHeight - (canvasHeight * ((y - this.miny) / rangey)))]; | |
| 1612 | path.push(vertex); | |
| 1613 | vertices.push(vertex); | |
| 1614 | } | |
| 1615 | } | |
| 1616 | ||
| 1617 | lineShapes = []; | |
| 1618 | fillShapes = []; | |
| 1619 | plen = paths.length; | |
| 1620 | for (i = 0; i < plen; i++) { | |
| 1621 | path = paths[i]; | |
| 1622 | if (path.length) { | |
| 1623 | if (options.get('fillColor')) { | |
| 1624 | path.push([path[path.length - 1][0], (canvasTop + canvasHeight)]); | |
| 1625 | fillShapes.push(path.slice(0)); | |
| 1626 | path.pop(); | |
| 1627 | } | |
| 1628 | // if there's only a single point in this path, then we want to display it | |
| 1629 | // as a vertical line which means we keep path[0] as is | |
| 1630 | if (path.length > 2) { | |
| 1631 | // else we want the first value | |
| 1632 | path[0] = [path[0][0], path[1][1]]; | |
| 1633 | } | |
| 1634 | lineShapes.push(path); | |
| 1635 | } | |
| 1636 | } | |
| 1637 | ||
| 1638 | // draw the fill first, then optionally the normal range, then the line on top of that | |
| 1639 | plen = fillShapes.length; | |
| 1640 | for (i = 0; i < plen; i++) { | |
| 1641 | target.drawShape(fillShapes[i], | |
| 1642 | options.get('fillColor'), options.get('fillColor')).append(); | |
| 1643 | } | |
| 1644 | ||
| 1645 | if (options.get('normalRangeMin') !== undefined && options.get('drawNormalOnTop')) { | |
| 1646 | this.drawNormalRange(canvasLeft, canvasTop, canvasHeight, canvasWidth, rangey); | |
| 1647 | } | |
| 1648 | ||
| 1649 | plen = lineShapes.length; | |
| 1650 | for (i = 0; i < plen; i++) { | |
| 1651 | target.drawShape(lineShapes[i], options.get('lineColor'), undefined, | |
| 1652 | options.get('lineWidth')).append(); | |
| 1653 | } | |
| 1654 | ||
| 1655 | if (spotRadius && options.get('valueSpots')) { | |
| 1656 | valueSpots = options.get('valueSpots'); | |
| 1657 | if (valueSpots.get === undefined) { | |
| 1658 | valueSpots = new RangeMap(valueSpots); | |
| 1659 | } | |
| 1660 | for (i = 0; i < yvalcount; i++) { | |
| 1661 | color = valueSpots.get(yvalues[i]); | |
| 1662 | if (color) { | |
| 1663 | target.drawCircle(canvasLeft + Math.round((xvalues[i] - this.minx) * (canvasWidth / rangex)), | |
| 1664 | canvasTop + Math.round(canvasHeight - (canvasHeight * ((yvalues[i] - this.miny) / rangey))), | |
| 1665 | spotRadius, undefined, | |
| 1666 | color).append(); | |
| 1667 | } | |
| 1668 | } | |
| 1669 | ||
| 1670 | } | |
| 1671 | if (spotRadius && options.get('spotColor') && yvalues[yvallast] !== null) { | |
| 1672 | target.drawCircle(canvasLeft + Math.round((xvalues[xvalues.length - 1] - this.minx) * (canvasWidth / rangex)), | |
| 1673 | canvasTop + Math.round(canvasHeight - (canvasHeight * ((yvalues[yvallast] - this.miny) / rangey))), | |
| 1674 | spotRadius, undefined, | |
| 1675 | options.get('spotColor')).append(); | |
| 1676 | } | |
| 1677 | if (this.maxy !== this.minyorg) { | |
| 1678 | if (spotRadius && options.get('minSpotColor')) { | |
| 1679 | x = xvalues[$.inArray(this.minyorg, yvalues)]; | |
| 1680 | target.drawCircle(canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)), | |
| 1681 | canvasTop + Math.round(canvasHeight - (canvasHeight * ((this.minyorg - this.miny) / rangey))), | |
| 1682 | spotRadius, undefined, | |
| 1683 | options.get('minSpotColor')).append(); | |
| 1684 | } | |
| 1685 | if (spotRadius && options.get('maxSpotColor')) { | |
| 1686 | x = xvalues[$.inArray(this.maxyorg, yvalues)]; | |
| 1687 | target.drawCircle(canvasLeft + Math.round((x - this.minx) * (canvasWidth / rangex)), | |
| 1688 | canvasTop + Math.round(canvasHeight - (canvasHeight * ((this.maxyorg - this.miny) / rangey))), | |
| 1689 | spotRadius, undefined, | |
| 1690 | options.get('maxSpotColor')).append(); | |
| 1691 | } | |
| 1692 | } | |
| 1693 | ||
| 1694 | this.lastShapeId = target.getLastShapeId(); | |
| 1695 | this.canvasTop = canvasTop; | |
| 1696 | target.render(); | |
| 1697 | } | |
| 1698 | }); | |
| 1699 | ||
| 1700 | /** | |
| 1701 | * Bar charts | |
| 1702 | */ | |
| 1703 | $.fn.sparkline.bar = bar = createClass($.fn.sparkline._base, barHighlightMixin, { | |
| 1704 | type: 'bar', | |
| 1705 | ||
| 1706 | init: function (el, values, options, width, height) { | |
| 1707 | var barWidth = parseInt(options.get('barWidth'), 10), | |
| 1708 | barSpacing = parseInt(options.get('barSpacing'), 10), | |
| 1709 | chartRangeMin = options.get('chartRangeMin'), | |
| 1710 | chartRangeMax = options.get('chartRangeMax'), | |
| 1711 | chartRangeClip = options.get('chartRangeClip'), | |
| 1712 | stackMin = Infinity, | |
| 1713 | stackMax = -Infinity, | |
| 1714 | isStackString, groupMin, groupMax, stackRanges, | |
| 1715 | numValues, i, vlen, range, zeroAxis, xaxisOffset, min, max, clipMin, clipMax, | |
| 1716 | stacked, vlist, j, slen, svals, val, yoffset, yMaxCalc, canvasHeightEf; | |
| 1717 | bar._super.init.call(this, el, values, options, width, height); | |
| 1718 | ||
| 1719 | // scan values to determine whether to stack bars | |
| 1720 | for (i = 0, vlen = values.length; i < vlen; i++) { | |
| 1721 | val = values[i]; | |
| 1722 | isStackString = typeof(val) === 'string' && val.indexOf(':') > -1; | |
| 1723 | if (isStackString || $.isArray(val)) { | |
| 1724 | stacked = true; | |
| 1725 | if (isStackString) { | |
| 1726 | val = values[i] = normalizeValues(val.split(':')); | |
| 1727 | } | |
| 1728 | val = remove(val, null); // min/max will treat null as zero | |
| 1729 | groupMin = Math.min.apply(Math, val); | |
| 1730 | groupMax = Math.max.apply(Math, val); | |
| 1731 | if (groupMin < stackMin) { | |
| 1732 | stackMin = groupMin; | |
| 1733 | } | |
| 1734 | if (groupMax > stackMax) { | |
| 1735 | stackMax = groupMax; | |
| 1736 | } | |
| 1737 | } | |
| 1738 | } | |
| 1739 | ||
| 1740 | this.stacked = stacked; | |
| 1741 | this.regionShapes = {}; | |
| 1742 | this.barWidth = barWidth; | |
| 1743 | this.barSpacing = barSpacing; | |
| 1744 | this.totalBarWidth = barWidth + barSpacing; | |
| 1745 | this.width = width = (values.length * barWidth) + ((values.length - 1) * barSpacing); | |
| 1746 | ||
| 1747 | this.initTarget(); | |
| 1748 | ||
| 1749 | if (chartRangeClip) { | |
| 1750 | clipMin = chartRangeMin === undefined ? -Infinity : chartRangeMin; | |
| 1751 | clipMax = chartRangeMax === undefined ? Infinity : chartRangeMax; | |
| 1752 | } | |
| 1753 | ||
| 1754 | numValues = []; | |
| 1755 | stackRanges = stacked ? [] : numValues; | |
| 1756 | var stackTotals = []; | |
| 1757 | var stackRangesNeg = []; | |
| 1758 | for (i = 0, vlen = values.length; i < vlen; i++) { | |
| 1759 | if (stacked) { | |
| 1760 | vlist = values[i]; | |
| 1761 | values[i] = svals = []; | |
| 1762 | stackTotals[i] = 0; | |
| 1763 | stackRanges[i] = stackRangesNeg[i] = 0; | |
| 1764 | for (j = 0, slen = vlist.length; j < slen; j++) { | |
| 1765 | val = svals[j] = chartRangeClip ? clipval(vlist[j], clipMin, clipMax) : vlist[j]; | |
| 1766 | if (val !== null) { | |
| 1767 | if (val > 0) { | |
| 1768 | stackTotals[i] += val; | |
| 1769 | } | |
| 1770 | if (stackMin < 0 && stackMax > 0) { | |
| 1771 | if (val < 0) { | |
| 1772 | stackRangesNeg[i] += Math.abs(val); | |
| 1773 | } else { | |
| 1774 | stackRanges[i] += val; | |
| 1775 | } | |
| 1776 | } else { | |
| 1777 | stackRanges[i] += Math.abs(val - (val < 0 ? stackMax : stackMin)); | |
| 1778 | } | |
| 1779 | numValues.push(val); | |
| 1780 | } | |
| 1781 | } | |
| 1782 | } else { | |
| 1783 | val = chartRangeClip ? clipval(values[i], clipMin, clipMax) : values[i]; | |
| 1784 | val = values[i] = normalizeValue(val); | |
| 1785 | if (val !== null) { | |
| 1786 | numValues.push(val); | |
| 1787 | } | |
| 1788 | } | |
| 1789 | } | |
| 1790 | this.max = max = Math.max.apply(Math, numValues); | |
| 1791 | this.min = min = Math.min.apply(Math, numValues); | |
| 1792 | this.stackMax = stackMax = stacked ? Math.max.apply(Math, stackTotals) : max; | |
| 1793 | this.stackMin = stackMin = stacked ? Math.min.apply(Math, numValues) : min; | |
| 1794 | ||
| 1795 | if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < min)) { | |
| 1796 | min = options.get('chartRangeMin'); | |
| 1797 | } | |
| 1798 | if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > max)) { | |
| 1799 | max = options.get('chartRangeMax'); | |
| 1800 | } | |
| 1801 | ||
| 1802 | this.zeroAxis = zeroAxis = options.get('zeroAxis', true); | |
| 1803 | if (min <= 0 && max >= 0 && zeroAxis) { | |
| 1804 | xaxisOffset = 0; | |
| 1805 | } else if (zeroAxis == false) { | |
| 1806 | xaxisOffset = min; | |
| 1807 | } else if (min > 0) { | |
| 1808 | xaxisOffset = min; | |
| 1809 | } else { | |
| 1810 | xaxisOffset = max; | |
| 1811 | } | |
| 1812 | this.xaxisOffset = xaxisOffset; | |
| 1813 | ||
| 1814 | range = stacked ? (Math.max.apply(Math, stackRanges) + Math.max.apply(Math, stackRangesNeg)) : max - min; | |
| 1815 | ||
| 1816 | // as we plot zero/min values a single pixel line, we add a pixel to all other | |
| 1817 | // values - Reduce the effective canvas size to suit | |
| 1818 | this.canvasHeightEf = (zeroAxis && min < 0) ? this.canvasHeight - 2 : this.canvasHeight - 1; | |
| 1819 | ||
| 1820 | if (min < xaxisOffset) { | |
| 1821 | yMaxCalc = (stacked && max >= 0) ? stackMax : max; | |
| 1822 | yoffset = (yMaxCalc - xaxisOffset) / range * this.canvasHeight; | |
| 1823 | if (yoffset !== Math.ceil(yoffset)) { | |
| 1824 | this.canvasHeightEf -= 2; | |
| 1825 | yoffset = Math.ceil(yoffset); | |
| 1826 | } | |
| 1827 | } else { | |
| 1828 | yoffset = this.canvasHeight; | |
| 1829 | } | |
| 1830 | this.yoffset = yoffset; | |
| 1831 | ||
| 1832 | if ($.isArray(options.get('colorMap'))) { | |
| 1833 | this.colorMapByIndex = options.get('colorMap'); | |
| 1834 | this.colorMapByValue = null; | |
| 1835 | } else { | |
| 1836 | this.colorMapByIndex = null; | |
| 1837 | this.colorMapByValue = options.get('colorMap'); | |
| 1838 | if (this.colorMapByValue && this.colorMapByValue.get === undefined) { | |
| 1839 | this.colorMapByValue = new RangeMap(this.colorMapByValue); | |
| 1840 | } | |
| 1841 | } | |
| 1842 | ||
| 1843 | this.range = range; | |
| 1844 | }, | |
| 1845 | ||
| 1846 | getRegion: function (el, x, y) { | |
| 1847 | var result = Math.floor(x / this.totalBarWidth); | |
| 1848 | return (result < 0 || result >= this.values.length) ? undefined : result; | |
| 1849 | }, | |
| 1850 | ||
| 1851 | getCurrentRegionFields: function () { | |
| 1852 | var currentRegion = this.currentRegion, | |
| 1853 | values = ensureArray(this.values[currentRegion]), | |
| 1854 | result = [], | |
| 1855 | value, i; | |
| 1856 | for (i = values.length; i--;) { | |
| 1857 | value = values[i]; | |
| 1858 | result.push({ | |
| 1859 | isNull: value === null, | |
| 1860 | value: value, | |
| 1861 | color: this.calcColor(i, value, currentRegion), | |
| 1862 | offset: currentRegion | |
| 1863 | }); | |
| 1864 | } | |
| 1865 | return result; | |
| 1866 | }, | |
| 1867 | ||
| 1868 | calcColor: function (stacknum, value, valuenum) { | |
| 1869 | var colorMapByIndex = this.colorMapByIndex, | |
| 1870 | colorMapByValue = this.colorMapByValue, | |
| 1871 | options = this.options, | |
| 1872 | color, newColor; | |
| 1873 | if (this.stacked) { | |
| 1874 | color = options.get('stackedBarColor'); | |
| 1875 | } else { | |
| 1876 | color = (value < 0) ? options.get('negBarColor') : options.get('barColor'); | |
| 1877 | } | |
| 1878 | if (value === 0 && options.get('zeroColor') !== undefined) { | |
| 1879 | color = options.get('zeroColor'); | |
| 1880 | } | |
| 1881 | if (colorMapByValue && (newColor = colorMapByValue.get(value))) { | |
| 1882 | color = newColor; | |
| 1883 | } else if (colorMapByIndex && colorMapByIndex.length > valuenum) { | |
| 1884 | color = colorMapByIndex[valuenum]; | |
| 1885 | } | |
| 1886 | return $.isArray(color) ? color[stacknum % color.length] : color; | |
| 1887 | }, | |
| 1888 | ||
| 1889 | /** | |
| 1890 | * Render bar(s) for a region | |
| 1891 | */ | |
| 1892 | renderRegion: function (valuenum, highlight) { | |
| 1893 | var vals = this.values[valuenum], | |
| 1894 | options = this.options, | |
| 1895 | xaxisOffset = this.xaxisOffset, | |
| 1896 | result = [], | |
| 1897 | range = this.range, | |
| 1898 | stacked = this.stacked, | |
| 1899 | target = this.target, | |
| 1900 | x = valuenum * this.totalBarWidth, | |
| 1901 | canvasHeightEf = this.canvasHeightEf, | |
| 1902 | yoffset = this.yoffset, | |
| 1903 | y, height, color, isNull, yoffsetNeg, i, valcount, val, minPlotted, allMin; | |
| 1904 | ||
| 1905 | vals = $.isArray(vals) ? vals : [vals]; | |
| 1906 | valcount = vals.length; | |
| 1907 | val = vals[0]; | |
| 1908 | isNull = all(null, vals); | |
| 1909 | allMin = all(xaxisOffset, vals, true); | |
| 1910 | ||
| 1911 | if (isNull) { | |
| 1912 | if (options.get('nullColor')) { | |
| 1913 | color = highlight ? options.get('nullColor') : this.calcHighlightColor(options.get('nullColor'), options); | |
| 1914 | y = (yoffset > 0) ? yoffset - 1 : yoffset; | |
| 1915 | return target.drawRect(x, y, this.barWidth - 1, 0, color, color); | |
| 1916 | } else { | |
| 1917 | return undefined; | |
| 1918 | } | |
| 1919 | } | |
| 1920 | yoffsetNeg = yoffset; | |
| 1921 | for (i = 0; i < valcount; i++) { | |
| 1922 | val = vals[i]; | |
| 1923 | ||
| 1924 | if (stacked && val === xaxisOffset) { | |
| 1925 | if (!allMin || minPlotted) { | |
| 1926 | continue; | |
| 1927 | } | |
| 1928 | minPlotted = true; | |
| 1929 | } | |
| 1930 | ||
| 1931 | if (range > 0) { | |
| 1932 | height = Math.floor(canvasHeightEf * ((Math.abs(val - xaxisOffset) / range))) + 1; | |
| 1933 | } else { | |
| 1934 | height = 1; | |
| 1935 | } | |
| 1936 | if (val < xaxisOffset || (val === xaxisOffset && yoffset === 0)) { | |
| 1937 | y = yoffsetNeg; | |
| 1938 | yoffsetNeg += height; | |
| 1939 | } else { | |
| 1940 | y = yoffset - height; | |
| 1941 | yoffset -= height; | |
| 1942 | } | |
| 1943 | color = this.calcColor(i, val, valuenum); | |
| 1944 | if (highlight) { | |
| 1945 | color = this.calcHighlightColor(color, options); | |
| 1946 | } | |
| 1947 | result.push(target.drawRect(x, y, this.barWidth - 1, height - 1, color, color)); | |
| 1948 | } | |
| 1949 | if (result.length === 1) { | |
| 1950 | return result[0]; | |
| 1951 | } | |
| 1952 | return result; | |
| 1953 | } | |
| 1954 | }); | |
| 1955 | ||
| 1956 | /** | |
| 1957 | * Tristate charts | |
| 1958 | */ | |
| 1959 | $.fn.sparkline.tristate = tristate = createClass($.fn.sparkline._base, barHighlightMixin, { | |
| 1960 | type: 'tristate', | |
| 1961 | ||
| 1962 | init: function (el, values, options, width, height) { | |
| 1963 | var barWidth = parseInt(options.get('barWidth'), 10), | |
| 1964 | barSpacing = parseInt(options.get('barSpacing'), 10); | |
| 1965 | tristate._super.init.call(this, el, values, options, width, height); | |
| 1966 | ||
| 1967 | this.regionShapes = {}; | |
| 1968 | this.barWidth = barWidth; | |
| 1969 | this.barSpacing = barSpacing; | |
| 1970 | this.totalBarWidth = barWidth + barSpacing; | |
| 1971 | this.values = $.map(values, Number); | |
| 1972 | this.width = width = (values.length * barWidth) + ((values.length - 1) * barSpacing); | |
| 1973 | ||
| 1974 | if ($.isArray(options.get('colorMap'))) { | |
| 1975 | this.colorMapByIndex = options.get('colorMap'); | |
| 1976 | this.colorMapByValue = null; | |
| 1977 | } else { | |
| 1978 | this.colorMapByIndex = null; | |
| 1979 | this.colorMapByValue = options.get('colorMap'); | |
| 1980 | if (this.colorMapByValue && this.colorMapByValue.get === undefined) { | |
| 1981 | this.colorMapByValue = new RangeMap(this.colorMapByValue); | |
| 1982 | } | |
| 1983 | } | |
| 1984 | this.initTarget(); | |
| 1985 | }, | |
| 1986 | ||
| 1987 | getRegion: function (el, x, y) { | |
| 1988 | return Math.floor(x / this.totalBarWidth); | |
| 1989 | }, | |
| 1990 | ||
| 1991 | getCurrentRegionFields: function () { | |
| 1992 | var currentRegion = this.currentRegion; | |
| 1993 | return { | |
| 1994 | isNull: this.values[currentRegion] === undefined, | |
| 1995 | value: this.values[currentRegion], | |
| 1996 | color: this.calcColor(this.values[currentRegion], currentRegion), | |
| 1997 | offset: currentRegion | |
| 1998 | }; | |
| 1999 | }, | |
| 2000 | ||
| 2001 | calcColor: function (value, valuenum) { | |
| 2002 | var values = this.values, | |
| 2003 | options = this.options, | |
| 2004 | colorMapByIndex = this.colorMapByIndex, | |
| 2005 | colorMapByValue = this.colorMapByValue, | |
| 2006 | color, newColor; | |
| 2007 | ||
| 2008 | if (colorMapByValue && (newColor = colorMapByValue.get(value))) { | |
| 2009 | color = newColor; | |
| 2010 | } else if (colorMapByIndex && colorMapByIndex.length > valuenum) { | |
| 2011 | color = colorMapByIndex[valuenum]; | |
| 2012 | } else if (values[valuenum] < 0) { | |
| 2013 | color = options.get('negBarColor'); | |
| 2014 | } else if (values[valuenum] > 0) { | |
| 2015 | color = options.get('posBarColor'); | |
| 2016 | } else { | |
| 2017 | color = options.get('zeroBarColor'); | |
| 2018 | } | |
| 2019 | return color; | |
| 2020 | }, | |
| 2021 | ||
| 2022 | renderRegion: function (valuenum, highlight) { | |
| 2023 | var values = this.values, | |
| 2024 | options = this.options, | |
| 2025 | target = this.target, | |
| 2026 | canvasHeight, height, halfHeight, | |
| 2027 | x, y, color; | |
| 2028 | ||
| 2029 | canvasHeight = target.pixelHeight; | |
| 2030 | halfHeight = Math.round(canvasHeight / 2); | |
| 2031 | ||
| 2032 | x = valuenum * this.totalBarWidth; | |
| 2033 | if (values[valuenum] < 0) { | |
| 2034 | y = halfHeight; | |
| 2035 | height = halfHeight - 1; | |
| 2036 | } else if (values[valuenum] > 0) { | |
| 2037 | y = 0; | |
| 2038 | height = halfHeight - 1; | |
| 2039 | } else { | |
| 2040 | y = halfHeight - 1; | |
| 2041 | height = 2; | |
| 2042 | } | |
| 2043 | color = this.calcColor(values[valuenum], valuenum); | |
| 2044 | if (color === null) { | |
| 2045 | return; | |
| 2046 | } | |
| 2047 | if (highlight) { | |
| 2048 | color = this.calcHighlightColor(color, options); | |
| 2049 | } | |
| 2050 | return target.drawRect(x, y, this.barWidth - 1, height - 1, color, color); | |
| 2051 | } | |
| 2052 | }); | |
| 2053 | ||
| 2054 | /** | |
| 2055 | * Discrete charts | |
| 2056 | */ | |
| 2057 | $.fn.sparkline.discrete = discrete = createClass($.fn.sparkline._base, barHighlightMixin, { | |
| 2058 | type: 'discrete', | |
| 2059 | ||
| 2060 | init: function (el, values, options, width, height) { | |
| 2061 | discrete._super.init.call(this, el, values, options, width, height); | |
| 2062 | ||
| 2063 | this.regionShapes = {}; | |
| 2064 | this.values = values = $.map(values, Number); | |
| 2065 | this.min = Math.min.apply(Math, values); | |
| 2066 | this.max = Math.max.apply(Math, values); | |
| 2067 | this.range = this.max - this.min; | |
| 2068 | this.width = width = options.get('width') === 'auto' ? values.length * 2 : this.width; | |
| 2069 | this.interval = Math.floor(width / values.length); | |
| 2070 | this.itemWidth = width / values.length; | |
| 2071 | if (options.get('chartRangeMin') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMin') < this.min)) { | |
| 2072 | this.min = options.get('chartRangeMin'); | |
| 2073 | } | |
| 2074 | if (options.get('chartRangeMax') !== undefined && (options.get('chartRangeClip') || options.get('chartRangeMax') > this.max)) { | |
| 2075 | this.max = options.get('chartRangeMax'); | |
| 2076 | } | |
| 2077 | this.initTarget(); | |
| 2078 | if (this.target) { | |
| 2079 | this.lineHeight = options.get('lineHeight') === 'auto' ? Math.round(this.canvasHeight * 0.3) : options.get('lineHeight'); | |
| 2080 | } | |
| 2081 | }, | |
| 2082 | ||
| 2083 | getRegion: function (el, x, y) { | |
| 2084 | return Math.floor(x / this.itemWidth); | |
| 2085 | }, | |
| 2086 | ||
| 2087 | getCurrentRegionFields: function () { | |
| 2088 | var currentRegion = this.currentRegion; | |
| 2089 | return { | |
| 2090 | isNull: this.values[currentRegion] === undefined, | |
| 2091 | value: this.values[currentRegion], | |
| 2092 | offset: currentRegion | |
| 2093 | }; | |
| 2094 | }, | |
| 2095 | ||
| 2096 | renderRegion: function (valuenum, highlight) { | |
| 2097 | var values = this.values, | |
| 2098 | options = this.options, | |
| 2099 | min = this.min, | |
| 2100 | max = this.max, | |
| 2101 | range = this.range, | |
| 2102 | interval = this.interval, | |
| 2103 | target = this.target, | |
| 2104 | canvasHeight = this.canvasHeight, | |
| 2105 | lineHeight = this.lineHeight, | |
| 2106 | pheight = canvasHeight - lineHeight, | |
| 2107 | ytop, val, color, x; | |
| 2108 | ||
| 2109 | val = clipval(values[valuenum], min, max); | |
| 2110 | x = valuenum * interval; | |
| 2111 | ytop = Math.round(pheight - pheight * ((val - min) / range)); | |
| 2112 | color = (options.get('thresholdColor') && val < options.get('thresholdValue')) ? options.get('thresholdColor') : options.get('lineColor'); | |
| 2113 | if (highlight) { | |
| 2114 | color = this.calcHighlightColor(color, options); | |
| 2115 | } | |
| 2116 | return target.drawLine(x, ytop, x, ytop + lineHeight, color); | |
| 2117 | } | |
| 2118 | }); | |
| 2119 | ||
| 2120 | /** | |
| 2121 | * Bullet charts | |
| 2122 | */ | |
| 2123 | $.fn.sparkline.bullet = bullet = createClass($.fn.sparkline._base, { | |
| 2124 | type: 'bullet', | |
| 2125 | ||
| 2126 | init: function (el, values, options, width, height) { | |
| 2127 | var min, max, vals; | |
| 2128 | bullet._super.init.call(this, el, values, options, width, height); | |
| 2129 | ||
| 2130 | // values: target, performance, range1, range2, range3 | |
| 2131 | this.values = values = normalizeValues(values); | |
| 2132 | // target or performance could be null | |
| 2133 | vals = values.slice(); | |
| 2134 | vals[0] = vals[0] === null ? vals[2] : vals[0]; | |
| 2135 | vals[1] = values[1] === null ? vals[2] : vals[1]; | |
| 2136 | min = Math.min.apply(Math, values); | |
| 2137 | max = Math.max.apply(Math, values); | |
| 2138 | if (options.get('base') === undefined) { | |
| 2139 | min = min < 0 ? min : 0; | |
| 2140 | } else { | |
| 2141 | min = options.get('base'); | |
| 2142 | } | |
| 2143 | this.min = min; | |
| 2144 | this.max = max; | |
| 2145 | this.range = max - min; | |
| 2146 | this.shapes = {}; | |
| 2147 | this.valueShapes = {}; | |
| 2148 | this.regiondata = {}; | |
| 2149 | this.width = width = options.get('width') === 'auto' ? '4.0em' : width; | |
| 2150 | this.target = this.$el.simpledraw(width, height, options.get('composite')); | |
| 2151 | if (!values.length) { | |
| 2152 | this.disabled = true; | |
| 2153 | } | |
| 2154 | this.initTarget(); | |
| 2155 | }, | |
| 2156 | ||
| 2157 | getRegion: function (el, x, y) { | |
| 2158 | var shapeid = this.target.getShapeAt(el, x, y); | |
| 2159 | return (shapeid !== undefined && this.shapes[shapeid] !== undefined) ? this.shapes[shapeid] : undefined; | |
| 2160 | }, | |
| 2161 | ||
| 2162 | getCurrentRegionFields: function () { | |
| 2163 | var currentRegion = this.currentRegion; | |
| 2164 | return { | |
| 2165 | fieldkey: currentRegion.substr(0, 1), | |
| 2166 | value: this.values[currentRegion.substr(1)], | |
| 2167 | region: currentRegion | |
| 2168 | }; | |
| 2169 | }, | |
| 2170 | ||
| 2171 | changeHighlight: function (highlight) { | |
| 2172 | var currentRegion = this.currentRegion, | |
| 2173 | shapeid = this.valueShapes[currentRegion], | |
| 2174 | shape; | |
| 2175 | delete this.shapes[shapeid]; | |
| 2176 | switch (currentRegion.substr(0, 1)) { | |
| 2177 | case 'r': | |
| 2178 | shape = this.renderRange(currentRegion.substr(1), highlight); | |
| 2179 | break; | |
| 2180 | case 'p': | |
| 2181 | shape = this.renderPerformance(highlight); | |
| 2182 | break; | |
| 2183 | case 't': | |
| 2184 | shape = this.renderTarget(highlight); | |
| 2185 | break; | |
| 2186 | } | |
| 2187 | this.valueShapes[currentRegion] = shape.id; | |
| 2188 | this.shapes[shape.id] = currentRegion; | |
| 2189 | this.target.replaceWithShape(shapeid, shape); | |
| 2190 | }, | |
| 2191 | ||
| 2192 | renderRange: function (rn, highlight) { | |
| 2193 | var rangeval = this.values[rn], | |
| 2194 | rangewidth = Math.round(this.canvasWidth * ((rangeval - this.min) / this.range)), | |
| 2195 | color = this.options.get('rangeColors')[rn - 2]; | |
| 2196 | if (highlight) { | |
| 2197 | color = this.calcHighlightColor(color, this.options); | |
| 2198 | } | |
| 2199 | return this.target.drawRect(0, 0, rangewidth - 1, this.canvasHeight - 1, color, color); | |
| 2200 | }, | |
| 2201 | ||
| 2202 | renderPerformance: function (highlight) { | |
| 2203 | var perfval = this.values[1], | |
| 2204 | perfwidth = Math.round(this.canvasWidth * ((perfval - this.min) / this.range)), | |
| 2205 | color = this.options.get('performanceColor'); | |
| 2206 | if (highlight) { | |
| 2207 | color = this.calcHighlightColor(color, this.options); | |
| 2208 | } | |
| 2209 | return this.target.drawRect(0, Math.round(this.canvasHeight * 0.3), perfwidth - 1, | |
| 2210 | Math.round(this.canvasHeight * 0.4) - 1, color, color); | |
| 2211 | }, | |
| 2212 | ||
| 2213 | renderTarget: function (highlight) { | |
| 2214 | var targetval = this.values[0], | |
| 2215 | x = Math.round(this.canvasWidth * ((targetval - this.min) / this.range) - (this.options.get('targetWidth') / 2)), | |
| 2216 | targettop = Math.round(this.canvasHeight * 0.10), | |
| 2217 | targetheight = this.canvasHeight - (targettop * 2), | |
| 2218 | color = this.options.get('targetColor'); | |
| 2219 | if (highlight) { | |
| 2220 | color = this.calcHighlightColor(color, this.options); | |
| 2221 | } | |
| 2222 | return this.target.drawRect(x, targettop, this.options.get('targetWidth') - 1, targetheight - 1, color, color); | |
| 2223 | }, | |
| 2224 | ||
| 2225 | render: function () { | |
| 2226 | var vlen = this.values.length, | |
| 2227 | target = this.target, | |
| 2228 | i, shape; | |
| 2229 | if (!bullet._super.render.call(this)) { | |
| 2230 | return; | |
| 2231 | } | |
| 2232 | for (i = 2; i < vlen; i++) { | |
| 2233 | shape = this.renderRange(i).append(); | |
| 2234 | this.shapes[shape.id] = 'r' + i; | |
| 2235 | this.valueShapes['r' + i] = shape.id; | |
| 2236 | } | |
| 2237 | if (this.values[1] !== null) { | |
| 2238 | shape = this.renderPerformance().append(); | |
| 2239 | this.shapes[shape.id] = 'p1'; | |
| 2240 | this.valueShapes.p1 = shape.id; | |
| 2241 | } | |
| 2242 | if (this.values[0] !== null) { | |
| 2243 | shape = this.renderTarget().append(); | |
| 2244 | this.shapes[shape.id] = 't0'; | |
| 2245 | this.valueShapes.t0 = shape.id; | |
| 2246 | } | |
| 2247 | target.render(); | |
| 2248 | } | |
| 2249 | }); | |
| 2250 | ||
| 2251 | /** | |
| 2252 | * Pie charts | |
| 2253 | */ | |
| 2254 | $.fn.sparkline.pie = pie = createClass($.fn.sparkline._base, { | |
| 2255 | type: 'pie', | |
| 2256 | ||
| 2257 | init: function (el, values, options, width, height) { | |
| 2258 | var total = 0, i; | |
| 2259 | ||
| 2260 | pie._super.init.call(this, el, values, options, width, height); | |
| 2261 | ||
| 2262 | this.shapes = {}; // map shape ids to value offsets | |
| 2263 | this.valueShapes = {}; // maps value offsets to shape ids | |
| 2264 | this.values = values = $.map(values, Number); | |
| 2265 | ||
| 2266 | if (options.get('width') === 'auto') { | |
| 2267 | this.width = this.height; | |
| 2268 | } | |
| 2269 | ||
| 2270 | if (values.length > 0) { | |
| 2271 | for (i = values.length; i--;) { | |
| 2272 | total += values[i]; | |
| 2273 | } | |
| 2274 | } | |
| 2275 | this.total = total; | |
| 2276 | this.initTarget(); | |
| 2277 | this.radius = Math.floor(Math.min(this.canvasWidth, this.canvasHeight) / 2); | |
| 2278 | }, | |
| 2279 | ||
| 2280 | getRegion: function (el, x, y) { | |
| 2281 | var shapeid = this.target.getShapeAt(el, x, y); | |
| 2282 | return (shapeid !== undefined && this.shapes[shapeid] !== undefined) ? this.shapes[shapeid] : undefined; | |
| 2283 | }, | |
| 2284 | ||
| 2285 | getCurrentRegionFields: function () { | |
| 2286 | var currentRegion = this.currentRegion; | |
| 2287 | return { | |
| 2288 | isNull: this.values[currentRegion] === undefined, | |
| 2289 | value: this.values[currentRegion], | |
| 2290 | percent: this.values[currentRegion] / this.total * 100, | |
| 2291 | color: this.options.get('sliceColors')[currentRegion % this.options.get('sliceColors').length], | |
| 2292 | offset: currentRegion | |
| 2293 | }; | |
| 2294 | }, | |
| 2295 | ||
| 2296 | changeHighlight: function (highlight) { | |
| 2297 | var currentRegion = this.currentRegion, | |
| 2298 | newslice = this.renderSlice(currentRegion, highlight), | |
| 2299 | shapeid = this.valueShapes[currentRegion]; | |
| 2300 | delete this.shapes[shapeid]; | |
| 2301 | this.target.replaceWithShape(shapeid, newslice); | |
| 2302 | this.valueShapes[currentRegion] = newslice.id; | |
| 2303 | this.shapes[newslice.id] = currentRegion; | |
| 2304 | }, | |
| 2305 | ||
| 2306 | renderSlice: function (valuenum, highlight) { | |
| 2307 | var target = this.target, | |
| 2308 | options = this.options, | |
| 2309 | radius = this.radius, | |
| 2310 | borderWidth = options.get('borderWidth'), | |
| 2311 | offset = options.get('offset'), | |
| 2312 | circle = 2 * Math.PI, | |
| 2313 | values = this.values, | |
| 2314 | total = this.total, | |
| 2315 | next = offset ? (2*Math.PI)*(offset/360) : 0, | |
| 2316 | start, end, i, vlen, color; | |
| 2317 | ||
| 2318 | vlen = values.length; | |
| 2319 | for (i = 0; i < vlen; i++) { | |
| 2320 | start = next; | |
| 2321 | end = next; | |
| 2322 | if (total > 0) { // avoid divide by zero | |
| 2323 | end = next + (circle * (values[i] / total)); | |
| 2324 | } | |
| 2325 | if (valuenum === i) { | |
| 2326 | color = options.get('sliceColors')[i % options.get('sliceColors').length]; | |
| 2327 | if (highlight) { | |
| 2328 | color = this.calcHighlightColor(color, options); | |
| 2329 | } | |
| 2330 | ||
| 2331 | return target.drawPieSlice(radius, radius, radius - borderWidth, start, end, undefined, color); | |
| 2332 | } | |
| 2333 | next = end; | |
| 2334 | } | |
| 2335 | }, | |
| 2336 | ||
| 2337 | render: function () { | |
| 2338 | var target = this.target, | |
| 2339 | values = this.values, | |
| 2340 | options = this.options, | |
| 2341 | radius = this.radius, | |
| 2342 | borderWidth = options.get('borderWidth'), | |
| 2343 | shape, i; | |
| 2344 | ||
| 2345 | if (!pie._super.render.call(this)) { | |
| 2346 | return; | |
| 2347 | } | |
| 2348 | if (borderWidth) { | |
| 2349 | target.drawCircle(radius, radius, Math.floor(radius - (borderWidth / 2)), | |
| 2350 | options.get('borderColor'), undefined, borderWidth).append(); | |
| 2351 | } | |
| 2352 | for (i = values.length; i--;) { | |
| 2353 | if (values[i]) { // don't render zero values | |
| 2354 | shape = this.renderSlice(i).append(); | |
| 2355 | this.valueShapes[i] = shape.id; // store just the shapeid | |
| 2356 | this.shapes[shape.id] = i; | |
| 2357 | } | |
| 2358 | } | |
| 2359 | target.render(); | |
| 2360 | } | |
| 2361 | }); | |
| 2362 | ||
| 2363 | /** | |
| 2364 | * Box plots | |
| 2365 | */ | |
| 2366 | $.fn.sparkline.box = box = createClass($.fn.sparkline._base, { | |
| 2367 | type: 'box', | |
| 2368 | ||
| 2369 | init: function (el, values, options, width, height) { | |
| 2370 | box._super.init.call(this, el, values, options, width, height); | |
| 2371 | this.values = $.map(values, Number); | |
| 2372 | this.width = options.get('width') === 'auto' ? '4.0em' : width; | |
| 2373 | this.initTarget(); | |
| 2374 | if (!this.values.length) { | |
| 2375 | this.disabled = 1; | |
| 2376 | } | |
| 2377 | }, | |
| 2378 | ||
| 2379 | /** | |
| 2380 | * Simulate a single region | |
| 2381 | */ | |
| 2382 | getRegion: function () { | |
| 2383 | return 1; | |
| 2384 | }, | |
| 2385 | ||
| 2386 | getCurrentRegionFields: function () { | |
| 2387 | var result = [ | |
| 2388 | { field: 'lq', value: this.quartiles[0] }, | |
| 2389 | { field: 'med', value: this.quartiles[1] }, | |
| 2390 | { field: 'uq', value: this.quartiles[2] } | |
| 2391 | ]; | |
| 2392 | if (this.loutlier !== undefined) { | |
| 2393 | result.push({ field: 'lo', value: this.loutlier}); | |
| 2394 | } | |
| 2395 | if (this.routlier !== undefined) { | |
| 2396 | result.push({ field: 'ro', value: this.routlier}); | |
| 2397 | } | |
| 2398 | if (this.lwhisker !== undefined) { | |
| 2399 | result.push({ field: 'lw', value: this.lwhisker}); | |
| 2400 | } | |
| 2401 | if (this.rwhisker !== undefined) { | |
| 2402 | result.push({ field: 'rw', value: this.rwhisker}); | |
| 2403 | } | |
| 2404 | return result; | |
| 2405 | }, | |
| 2406 | ||
| 2407 | render: function () { | |
| 2408 | var target = this.target, | |
| 2409 | values = this.values, | |
| 2410 | vlen = values.length, | |
| 2411 | options = this.options, | |
| 2412 | canvasWidth = this.canvasWidth, | |
| 2413 | canvasHeight = this.canvasHeight, | |
| 2414 | minValue = options.get('chartRangeMin') === undefined ? Math.min.apply(Math, values) : options.get('chartRangeMin'), | |
| 2415 | maxValue = options.get('chartRangeMax') === undefined ? Math.max.apply(Math, values) : options.get('chartRangeMax'), | |
| 2416 | canvasLeft = 0, | |
| 2417 | lwhisker, loutlier, iqr, q1, q2, q3, rwhisker, routlier, i, | |
| 2418 | size, unitSize; | |
| 2419 | ||
| 2420 | if (!box._super.render.call(this)) { | |
| 2421 | return; | |
| 2422 | } | |
| 2423 | ||
| 2424 | if (options.get('raw')) { | |
| 2425 | if (options.get('showOutliers') && values.length > 5) { | |
| 2426 | loutlier = values[0]; | |
| 2427 | lwhisker = values[1]; | |
| 2428 | q1 = values[2]; | |
| 2429 | q2 = values[3]; | |
| 2430 | q3 = values[4]; | |
| 2431 | rwhisker = values[5]; | |
| 2432 | routlier = values[6]; | |
| 2433 | } else { | |
| 2434 | lwhisker = values[0]; | |
| 2435 | q1 = values[1]; | |
| 2436 | q2 = values[2]; | |
| 2437 | q3 = values[3]; | |
| 2438 | rwhisker = values[4]; | |
| 2439 | } | |
| 2440 | } else { | |
| 2441 | values.sort(function (a, b) { return a - b; }); | |
| 2442 | q1 = quartile(values, 1); | |
| 2443 | q2 = quartile(values, 2); | |
| 2444 | q3 = quartile(values, 3); | |
| 2445 | iqr = q3 - q1; | |
| 2446 | if (options.get('showOutliers')) { | |
| 2447 | lwhisker = rwhisker = undefined; | |
| 2448 | for (i = 0; i < vlen; i++) { | |
| 2449 | if (lwhisker === undefined && values[i] > q1 - (iqr * options.get('outlierIQR'))) { | |
| 2450 | lwhisker = values[i]; | |
| 2451 | } | |
| 2452 | if (values[i] < q3 + (iqr * options.get('outlierIQR'))) { | |
| 2453 | rwhisker = values[i]; | |
| 2454 | } | |
| 2455 | } | |
| 2456 | loutlier = values[0]; | |
| 2457 | routlier = values[vlen - 1]; | |
| 2458 | } else { | |
| 2459 | lwhisker = values[0]; | |
| 2460 | rwhisker = values[vlen - 1]; | |
| 2461 | } | |
| 2462 | } | |
| 2463 | this.quartiles = [q1, q2, q3]; | |
| 2464 | this.lwhisker = lwhisker; | |
| 2465 | this.rwhisker = rwhisker; | |
| 2466 | this.loutlier = loutlier; | |
| 2467 | this.routlier = routlier; | |
| 2468 | ||
| 2469 | unitSize = canvasWidth / (maxValue - minValue + 1); | |
| 2470 | if (options.get('showOutliers')) { | |
| 2471 | canvasLeft = Math.ceil(options.get('spotRadius')); | |
| 2472 | canvasWidth -= 2 * Math.ceil(options.get('spotRadius')); | |
| 2473 | unitSize = canvasWidth / (maxValue - minValue + 1); | |
| 2474 | if (loutlier < lwhisker) { | |
| 2475 | target.drawCircle((loutlier - minValue) * unitSize + canvasLeft, | |
| 2476 | canvasHeight / 2, | |
| 2477 | options.get('spotRadius'), | |
| 2478 | options.get('outlierLineColor'), | |
| 2479 | options.get('outlierFillColor')).append(); | |
| 2480 | } | |
| 2481 | if (routlier > rwhisker) { | |
| 2482 | target.drawCircle((routlier - minValue) * unitSize + canvasLeft, | |
| 2483 | canvasHeight / 2, | |
| 2484 | options.get('spotRadius'), | |
| 2485 | options.get('outlierLineColor'), | |
| 2486 | options.get('outlierFillColor')).append(); | |
| 2487 | } | |
| 2488 | } | |
| 2489 | ||
| 2490 | // box | |
| 2491 | target.drawRect( | |
| 2492 | Math.round((q1 - minValue) * unitSize + canvasLeft), | |
| 2493 | Math.round(canvasHeight * 0.1), | |
| 2494 | Math.round((q3 - q1) * unitSize), | |
| 2495 | Math.round(canvasHeight * 0.8), | |
| 2496 | options.get('boxLineColor'), | |
| 2497 | options.get('boxFillColor')).append(); | |
| 2498 | // left whisker | |
| 2499 | target.drawLine( | |
| 2500 | Math.round((lwhisker - minValue) * unitSize + canvasLeft), | |
| 2501 | Math.round(canvasHeight / 2), | |
| 2502 | Math.round((q1 - minValue) * unitSize + canvasLeft), | |
| 2503 | Math.round(canvasHeight / 2), | |
| 2504 | options.get('lineColor')).append(); | |
| 2505 | target.drawLine( | |
| 2506 | Math.round((lwhisker - minValue) * unitSize + canvasLeft), | |
| 2507 | Math.round(canvasHeight / 4), | |
| 2508 | Math.round((lwhisker - minValue) * unitSize + canvasLeft), | |
| 2509 | Math.round(canvasHeight - canvasHeight / 4), | |
| 2510 | options.get('whiskerColor')).append(); | |
| 2511 | // right whisker | |
| 2512 | target.drawLine(Math.round((rwhisker - minValue) * unitSize + canvasLeft), | |
| 2513 | Math.round(canvasHeight / 2), | |
| 2514 | Math.round((q3 - minValue) * unitSize + canvasLeft), | |
| 2515 | Math.round(canvasHeight / 2), | |
| 2516 | options.get('lineColor')).append(); | |
| 2517 | target.drawLine( | |
| 2518 | Math.round((rwhisker - minValue) * unitSize + canvasLeft), | |
| 2519 | Math.round(canvasHeight / 4), | |
| 2520 | Math.round((rwhisker - minValue) * unitSize + canvasLeft), | |
| 2521 | Math.round(canvasHeight - canvasHeight / 4), | |
| 2522 | options.get('whiskerColor')).append(); | |
| 2523 | // median line | |
| 2524 | target.drawLine( | |
| 2525 | Math.round((q2 - minValue) * unitSize + canvasLeft), | |
| 2526 | Math.round(canvasHeight * 0.1), | |
| 2527 | Math.round((q2 - minValue) * unitSize + canvasLeft), | |
| 2528 | Math.round(canvasHeight * 0.9), | |
| 2529 | options.get('medianColor')).append(); | |
| 2530 | if (options.get('target')) { | |
| 2531 | size = Math.ceil(options.get('spotRadius')); | |
| 2532 | target.drawLine( | |
| 2533 | Math.round((options.get('target') - minValue) * unitSize + canvasLeft), | |
| 2534 | Math.round((canvasHeight / 2) - size), | |
| 2535 | Math.round((options.get('target') - minValue) * unitSize + canvasLeft), | |
| 2536 | Math.round((canvasHeight / 2) + size), | |
| 2537 | options.get('targetColor')).append(); | |
| 2538 | target.drawLine( | |
| 2539 | Math.round((options.get('target') - minValue) * unitSize + canvasLeft - size), | |
| 2540 | Math.round(canvasHeight / 2), | |
| 2541 | Math.round((options.get('target') - minValue) * unitSize + canvasLeft + size), | |
| 2542 | Math.round(canvasHeight / 2), | |
| 2543 | options.get('targetColor')).append(); | |
| 2544 | } | |
| 2545 | target.render(); | |
| 2546 | } | |
| 2547 | }); | |
| 2548 | ||
| 2549 | // Setup a very simple "virtual canvas" to make drawing the few shapes we need easier | |
| 2550 | // This is accessible as $(foo).simpledraw() | |
| 2551 | ||
| 2552 | VShape = createClass({ | |
| 2553 | init: function (target, id, type, args) { | |
| 2554 | this.target = target; | |
| 2555 | this.id = id; | |
| 2556 | this.type = type; | |
| 2557 | this.args = args; | |
| 2558 | }, | |
| 2559 | append: function () { | |
| 2560 | this.target.appendShape(this); | |
| 2561 | return this; | |
| 2562 | } | |
| 2563 | }); | |
| 2564 | ||
| 2565 | VCanvas_base = createClass({ | |
| 2566 | _pxregex: /(\d+)(px)?\s*$/i, | |
| 2567 | ||
| 2568 | init: function (width, height, target) { | |
| 2569 | if (!width) { | |
| 2570 | return; | |
| 2571 | } | |
| 2572 | this.width = width; | |
| 2573 | this.height = height; | |
| 2574 | this.target = target; | |
| 2575 | this.lastShapeId = null; | |
| 2576 | if (target[0]) { | |
| 2577 | target = target[0]; | |
| 2578 | } | |
| 2579 | $.data(target, '_jqs_vcanvas', this); | |
| 2580 | }, | |
| 2581 | ||
| 2582 | drawLine: function (x1, y1, x2, y2, lineColor, lineWidth) { | |
| 2583 | return this.drawShape([[x1, y1], [x2, y2]], lineColor, lineWidth); | |
| 2584 | }, | |
| 2585 | ||
| 2586 | drawShape: function (path, lineColor, fillColor, lineWidth) { | |
| 2587 | return this._genShape('Shape', [path, lineColor, fillColor, lineWidth]); | |
| 2588 | }, | |
| 2589 | ||
| 2590 | drawCircle: function (x, y, radius, lineColor, fillColor, lineWidth) { | |
| 2591 | return this._genShape('Circle', [x, y, radius, lineColor, fillColor, lineWidth]); | |
| 2592 | }, | |
| 2593 | ||
| 2594 | drawPieSlice: function (x, y, radius, startAngle, endAngle, lineColor, fillColor) { | |
| 2595 | return this._genShape('PieSlice', [x, y, radius, startAngle, endAngle, lineColor, fillColor]); | |
| 2596 | }, | |
| 2597 | ||
| 2598 | drawRect: function (x, y, width, height, lineColor, fillColor) { | |
| 2599 | return this._genShape('Rect', [x, y, width, height, lineColor, fillColor]); | |
| 2600 | }, | |
| 2601 | ||
| 2602 | getElement: function () { | |
| 2603 | return this.canvas; | |
| 2604 | }, | |
| 2605 | ||
| 2606 | /** | |
| 2607 | * Return the most recently inserted shape id | |
| 2608 | */ | |
| 2609 | getLastShapeId: function () { | |
| 2610 | return this.lastShapeId; | |
| 2611 | }, | |
| 2612 | ||
| 2613 | /** | |
| 2614 | * Clear and reset the canvas | |
| 2615 | */ | |
| 2616 | reset: function () { | |
| 2617 | alert('reset not implemented'); | |
| 2618 | }, | |
| 2619 | ||
| 2620 | _insert: function (el, target) { | |
| 2621 | $(target).html(el); | |
| 2622 | }, | |
| 2623 | ||
| 2624 | /** | |
| 2625 | * Calculate the pixel dimensions of the canvas | |
| 2626 | */ | |
| 2627 | _calculatePixelDims: function (width, height, canvas) { | |
| 2628 | // XXX This should probably be a configurable option | |
| 2629 | var match; | |
| 2630 | match = this._pxregex.exec(height); | |
| 2631 | if (match) { | |
| 2632 | this.pixelHeight = match[1]; | |
| 2633 | } else { | |
| 2634 | this.pixelHeight = $(canvas).height(); | |
| 2635 | } | |
| 2636 | match = this._pxregex.exec(width); | |
| 2637 | if (match) { | |
| 2638 | this.pixelWidth = match[1]; | |
| 2639 | } else { | |
| 2640 | this.pixelWidth = $(canvas).width(); | |
| 2641 | } | |
| 2642 | }, | |
| 2643 | ||
| 2644 | /** | |
| 2645 | * Generate a shape object and id for later rendering | |
| 2646 | */ | |
| 2647 | _genShape: function (shapetype, shapeargs) { | |
| 2648 | var id = shapeCount++; | |
| 2649 | shapeargs.unshift(id); | |
| 2650 | return new VShape(this, id, shapetype, shapeargs); | |
| 2651 | }, | |
| 2652 | ||
| 2653 | /** | |
| 2654 | * Add a shape to the end of the render queue | |
| 2655 | */ | |
| 2656 | appendShape: function (shape) { | |
| 2657 | alert('appendShape not implemented'); | |
| 2658 | }, | |
| 2659 | ||
| 2660 | /** | |
| 2661 | * Replace one shape with another | |
| 2662 | */ | |
| 2663 | replaceWithShape: function (shapeid, shape) { | |
| 2664 | alert('replaceWithShape not implemented'); | |
| 2665 | }, | |
| 2666 | ||
| 2667 | /** | |
| 2668 | * Insert one shape after another in the render queue | |
| 2669 | */ | |
| 2670 | insertAfterShape: function (shapeid, shape) { | |
| 2671 | alert('insertAfterShape not implemented'); | |
| 2672 | }, | |
| 2673 | ||
| 2674 | /** | |
| 2675 | * Remove a shape from the queue | |
| 2676 | */ | |
| 2677 | removeShapeId: function (shapeid) { | |
| 2678 | alert('removeShapeId not implemented'); | |
| 2679 | }, | |
| 2680 | ||
| 2681 | /** | |
| 2682 | * Find a shape at the specified x/y co-ordinates | |
| 2683 | */ | |
| 2684 | getShapeAt: function (el, x, y) { | |
| 2685 | alert('getShapeAt not implemented'); | |
| 2686 | }, | |
| 2687 | ||
| 2688 | /** | |
| 2689 | * Render all queued shapes onto the canvas | |
| 2690 | */ | |
| 2691 | render: function () { | |
| 2692 | alert('render not implemented'); | |
| 2693 | } | |
| 2694 | }); | |
| 2695 | ||
| 2696 | VCanvas_canvas = createClass(VCanvas_base, { | |
| 2697 | init: function (width, height, target, interact) { | |
| 2698 | VCanvas_canvas._super.init.call(this, width, height, target); | |
| 2699 | this.canvas = document.createElement('canvas'); | |
| 2700 | if (target[0]) { | |
| 2701 | target = target[0]; | |
| 2702 | } | |
| 2703 | $.data(target, '_jqs_vcanvas', this); | |
| 2704 | $(this.canvas).css({ display: 'inline-block', width: width, height: height, verticalAlign: 'top' }); | |
| 2705 | this._insert(this.canvas, target); | |
| 2706 | this._calculatePixelDims(width, height, this.canvas); | |
| 2707 | this.canvas.width = this.pixelWidth; | |
| 2708 | this.canvas.height = this.pixelHeight; | |
| 2709 | this.interact = interact; | |
| 2710 | this.shapes = {}; | |
| 2711 | this.shapeseq = []; | |
| 2712 | this.currentTargetShapeId = undefined; | |
| 2713 | $(this.canvas).css({width: this.pixelWidth, height: this.pixelHeight}); | |
| 2714 | }, | |
| 2715 | ||
| 2716 | _getContext: function (lineColor, fillColor, lineWidth) { | |
| 2717 | var context = this.canvas.getContext('2d'); | |
| 2718 | if (lineColor !== undefined) { | |
| 2719 | context.strokeStyle = lineColor; | |
| 2720 | } | |
| 2721 | context.lineWidth = lineWidth === undefined ? 1 : lineWidth; | |
| 2722 | if (fillColor !== undefined) { | |
| 2723 | context.fillStyle = fillColor; | |
| 2724 | } | |
| 2725 | return context; | |
| 2726 | }, | |
| 2727 | ||
| 2728 | reset: function () { | |
| 2729 | var context = this._getContext(); | |
| 2730 | context.clearRect(0, 0, this.pixelWidth, this.pixelHeight); | |
| 2731 | this.shapes = {}; | |
| 2732 | this.shapeseq = []; | |
| 2733 | this.currentTargetShapeId = undefined; | |
| 2734 | }, | |
| 2735 | ||
| 2736 | _drawShape: function (shapeid, path, lineColor, fillColor, lineWidth) { | |
| 2737 | var context = this._getContext(lineColor, fillColor, lineWidth), | |
| 2738 | i, plen; | |
| 2739 | context.beginPath(); | |
| 2740 | context.moveTo(path[0][0] + 0.5, path[0][1] + 0.5); | |
| 2741 | for (i = 1, plen = path.length; i < plen; i++) { | |
| 2742 | context.lineTo(path[i][0] + 0.5, path[i][1] + 0.5); // the 0.5 offset gives us crisp pixel-width lines | |
| 2743 | } | |
| 2744 | if (lineColor !== undefined) { | |
| 2745 | context.stroke(); | |
| 2746 | } | |
| 2747 | if (fillColor !== undefined) { | |
| 2748 | context.fill(); | |
| 2749 | } | |
| 2750 | if (this.targetX !== undefined && this.targetY !== undefined && | |
| 2751 | context.isPointInPath(this.targetX, this.targetY)) { | |
| 2752 | this.currentTargetShapeId = shapeid; | |
| 2753 | } | |
| 2754 | }, | |
| 2755 | ||
| 2756 | _drawCircle: function (shapeid, x, y, radius, lineColor, fillColor, lineWidth) { | |
| 2757 | var context = this._getContext(lineColor, fillColor, lineWidth); | |
| 2758 | context.beginPath(); | |
| 2759 | context.arc(x, y, radius, 0, 2 * Math.PI, false); | |
| 2760 | if (this.targetX !== undefined && this.targetY !== undefined && | |
| 2761 | context.isPointInPath(this.targetX, this.targetY)) { | |
| 2762 | this.currentTargetShapeId = shapeid; | |
| 2763 | } | |
| 2764 | if (lineColor !== undefined) { | |
| 2765 | context.stroke(); | |
| 2766 | } | |
| 2767 | if (fillColor !== undefined) { | |
| 2768 | context.fill(); | |
| 2769 | } | |
| 2770 | }, | |
| 2771 | ||
| 2772 | _drawPieSlice: function (shapeid, x, y, radius, startAngle, endAngle, lineColor, fillColor) { | |
| 2773 | var context = this._getContext(lineColor, fillColor); | |
| 2774 | context.beginPath(); | |
| 2775 | context.moveTo(x, y); | |
| 2776 | context.arc(x, y, radius, startAngle, endAngle, false); | |
| 2777 | context.lineTo(x, y); | |
| 2778 | context.closePath(); | |
| 2779 | if (lineColor !== undefined) { | |
| 2780 | context.stroke(); | |
| 2781 | } | |
| 2782 | if (fillColor) { | |
| 2783 | context.fill(); | |
| 2784 | } | |
| 2785 | if (this.targetX !== undefined && this.targetY !== undefined && | |
| 2786 | context.isPointInPath(this.targetX, this.targetY)) { | |
| 2787 | this.currentTargetShapeId = shapeid; | |
| 2788 | } | |
| 2789 | }, | |
| 2790 | ||
| 2791 | _drawRect: function (shapeid, x, y, width, height, lineColor, fillColor) { | |
| 2792 | return this._drawShape(shapeid, [[x, y], [x + width, y], [x + width, y + height], [x, y + height], [x, y]], lineColor, fillColor); | |
| 2793 | }, | |
| 2794 | ||
| 2795 | appendShape: function (shape) { | |
| 2796 | this.shapes[shape.id] = shape; | |
| 2797 | this.shapeseq.push(shape.id); | |
| 2798 | this.lastShapeId = shape.id; | |
| 2799 | return shape.id; | |
| 2800 | }, | |
| 2801 | ||
| 2802 | replaceWithShape: function (shapeid, shape) { | |
| 2803 | var shapeseq = this.shapeseq, | |
| 2804 | i; | |
| 2805 | this.shapes[shape.id] = shape; | |
| 2806 | for (i = shapeseq.length; i--;) { | |
| 2807 | if (shapeseq[i] == shapeid) { | |
| 2808 | shapeseq[i] = shape.id; | |
| 2809 | } | |
| 2810 | } | |
| 2811 | delete this.shapes[shapeid]; | |
| 2812 | }, | |
| 2813 | ||
| 2814 | replaceWithShapes: function (shapeids, shapes) { | |
| 2815 | var shapeseq = this.shapeseq, | |
| 2816 | shapemap = {}, | |
| 2817 | sid, i, first; | |
| 2818 | ||
| 2819 | for (i = shapeids.length; i--;) { | |
| 2820 | shapemap[shapeids[i]] = true; | |
| 2821 | } | |
| 2822 | for (i = shapeseq.length; i--;) { | |
| 2823 | sid = shapeseq[i]; | |
| 2824 | if (shapemap[sid]) { | |
| 2825 | shapeseq.splice(i, 1); | |
| 2826 | delete this.shapes[sid]; | |
| 2827 | first = i; | |
| 2828 | } | |
| 2829 | } | |
| 2830 | for (i = shapes.length; i--;) { | |
| 2831 | shapeseq.splice(first, 0, shapes[i].id); | |
| 2832 | this.shapes[shapes[i].id] = shapes[i]; | |
| 2833 | } | |
| 2834 | ||
| 2835 | }, | |
| 2836 | ||
| 2837 | insertAfterShape: function (shapeid, shape) { | |
| 2838 | var shapeseq = this.shapeseq, | |
| 2839 | i; | |
| 2840 | for (i = shapeseq.length; i--;) { | |
| 2841 | if (shapeseq[i] === shapeid) { | |
| 2842 | shapeseq.splice(i + 1, 0, shape.id); | |
| 2843 | this.shapes[shape.id] = shape; | |
| 2844 | return; | |
| 2845 | } | |
| 2846 | } | |
| 2847 | }, | |
| 2848 | ||
| 2849 | removeShapeId: function (shapeid) { | |
| 2850 | var shapeseq = this.shapeseq, | |
| 2851 | i; | |
| 2852 | for (i = shapeseq.length; i--;) { | |
| 2853 | if (shapeseq[i] === shapeid) { | |
| 2854 | shapeseq.splice(i, 1); | |
| 2855 | break; | |
| 2856 | } | |
| 2857 | } | |
| 2858 | delete this.shapes[shapeid]; | |
| 2859 | }, | |
| 2860 | ||
| 2861 | getShapeAt: function (el, x, y) { | |
| 2862 | this.targetX = x; | |
| 2863 | this.targetY = y; | |
| 2864 | this.render(); | |
| 2865 | return this.currentTargetShapeId; | |
| 2866 | }, | |
| 2867 | ||
| 2868 | render: function () { | |
| 2869 | var shapeseq = this.shapeseq, | |
| 2870 | shapes = this.shapes, | |
| 2871 | shapeCount = shapeseq.length, | |
| 2872 | context = this._getContext(), | |
| 2873 | shapeid, shape, i; | |
| 2874 | context.clearRect(0, 0, this.pixelWidth, this.pixelHeight); | |
| 2875 | for (i = 0; i < shapeCount; i++) { | |
| 2876 | shapeid = shapeseq[i]; | |
| 2877 | shape = shapes[shapeid]; | |
| 2878 | this['_draw' + shape.type].apply(this, shape.args); | |
| 2879 | } | |
| 2880 | if (!this.interact) { | |
| 2881 | // not interactive so no need to keep the shapes array | |
| 2882 | this.shapes = {}; | |
| 2883 | this.shapeseq = []; | |
| 2884 | } | |
| 2885 | } | |
| 2886 | ||
| 2887 | }); | |
| 2888 | ||
| 2889 | VCanvas_vml = createClass(VCanvas_base, { | |
| 2890 | init: function (width, height, target) { | |
| 2891 | var groupel; | |
| 2892 | VCanvas_vml._super.init.call(this, width, height, target); | |
| 2893 | if (target[0]) { | |
| 2894 | target = target[0]; | |
| 2895 | } | |
| 2896 | $.data(target, '_jqs_vcanvas', this); | |
| 2897 | this.canvas = document.createElement('span'); | |
| 2898 | $(this.canvas).css({ display: 'inline-block', position: 'relative', overflow: 'hidden', width: width, height: height, margin: '0px', padding: '0px', verticalAlign: 'top'}); | |
| 2899 | this._insert(this.canvas, target); | |
| 2900 | this._calculatePixelDims(width, height, this.canvas); | |
| 2901 | this.canvas.width = this.pixelWidth; | |
| 2902 | this.canvas.height = this.pixelHeight; | |
| 2903 | groupel = '<v:group coordorigin="0 0" coordsize="' + this.pixelWidth + ' ' + this.pixelHeight + '"' + | |
| 2904 | ' style="position:absolute;top:0;left:0;width:' + this.pixelWidth + 'px;height=' + this.pixelHeight + 'px;"></v:group>'; | |
| 2905 | this.canvas.insertAdjacentHTML('beforeEnd', groupel); | |
| 2906 | this.group = $(this.canvas).children()[0]; | |
| 2907 | this.rendered = false; | |
| 2908 | this.prerender = ''; | |
| 2909 | }, | |
| 2910 | ||
| 2911 | _drawShape: function (shapeid, path, lineColor, fillColor, lineWidth) { | |
| 2912 | var vpath = [], | |
| 2913 | initial, stroke, fill, closed, vel, plen, i; | |
| 2914 | for (i = 0, plen = path.length; i < plen; i++) { | |
| 2915 | vpath[i] = '' + (path[i][0]) + ',' + (path[i][1]); | |
| 2916 | } | |
| 2917 | initial = vpath.splice(0, 1); | |
| 2918 | lineWidth = lineWidth === undefined ? 1 : lineWidth; | |
| 2919 | stroke = lineColor === undefined ? ' stroked="false" ' : ' strokeWeight="' + lineWidth + 'px" strokeColor="' + lineColor + '" '; | |
| 2920 | fill = fillColor === undefined ? ' filled="false"' : ' fillColor="' + fillColor + '" filled="true" '; | |
| 2921 | closed = vpath[0] === vpath[vpath.length - 1] ? 'x ' : ''; | |
| 2922 | vel = '<v:shape coordorigin="0 0" coordsize="' + this.pixelWidth + ' ' + this.pixelHeight + '" ' + | |
| 2923 | ' id="jqsshape' + shapeid + '" ' + | |
| 2924 | stroke + | |
| 2925 | fill + | |
| 2926 | ' style="position:absolute;left:0px;top:0px;height:' + this.pixelHeight + 'px;width:' + this.pixelWidth + 'px;padding:0px;margin:0px;" ' + | |
| 2927 | ' path="m ' + initial + ' l ' + vpath.join(', ') + ' ' + closed + 'e">' + | |
| 2928 | ' </v:shape>'; | |
| 2929 | return vel; | |
| 2930 | }, | |
| 2931 | ||
| 2932 | _drawCircle: function (shapeid, x, y, radius, lineColor, fillColor, lineWidth) { | |
| 2933 | var stroke, fill, vel; | |
| 2934 | x -= radius; | |
| 2935 | y -= radius; | |
| 2936 | stroke = lineColor === undefined ? ' stroked="false" ' : ' strokeWeight="' + lineWidth + 'px" strokeColor="' + lineColor + '" '; | |
| 2937 | fill = fillColor === undefined ? ' filled="false"' : ' fillColor="' + fillColor + '" filled="true" '; | |
| 2938 | vel = '<v:oval ' + | |
| 2939 | ' id="jqsshape' + shapeid + '" ' + | |
| 2940 | stroke + | |
| 2941 | fill + | |
| 2942 | ' style="position:absolute;top:' + y + 'px; left:' + x + 'px; width:' + (radius * 2) + 'px; height:' + (radius * 2) + 'px"></v:oval>'; | |
| 2943 | return vel; | |
| 2944 | ||
| 2945 | }, | |
| 2946 | ||
| 2947 | _drawPieSlice: function (shapeid, x, y, radius, startAngle, endAngle, lineColor, fillColor) { | |
| 2948 | var vpath, startx, starty, endx, endy, stroke, fill, vel; | |
| 2949 | if (startAngle === endAngle) { | |
| 2950 | return ''; // VML seems to have problem when start angle equals end angle. | |
| 2951 | } | |
| 2952 | if ((endAngle - startAngle) === (2 * Math.PI)) { | |
| 2953 | startAngle = 0.0; // VML seems to have a problem when drawing a full circle that doesn't start 0 | |
| 2954 | endAngle = (2 * Math.PI); | |
| 2955 | } | |
| 2956 | ||
| 2957 | startx = x + Math.round(Math.cos(startAngle) * radius); | |
| 2958 | starty = y + Math.round(Math.sin(startAngle) * radius); | |
| 2959 | endx = x + Math.round(Math.cos(endAngle) * radius); | |
| 2960 | endy = y + Math.round(Math.sin(endAngle) * radius); | |
| 2961 | ||
| 2962 | if (startx === endx && starty === endy) { | |
| 2963 | if ((endAngle - startAngle) < Math.PI) { | |
| 2964 | // Prevent very small slices from being mistaken as a whole pie | |
| 2965 | return ''; | |
| 2966 | } | |
| 2967 | // essentially going to be the entire circle, so ignore startAngle | |
| 2968 | startx = endx = x + radius; | |
| 2969 | starty = endy = y; | |
| 2970 | } | |
| 2971 | ||
| 2972 | if (startx === endx && starty === endy && (endAngle - startAngle) < Math.PI) { | |
| 2973 | return ''; | |
| 2974 | } | |
| 2975 | ||
| 2976 | vpath = [x - radius, y - radius, x + radius, y + radius, startx, starty, endx, endy]; | |
| 2977 | stroke = lineColor === undefined ? ' stroked="false" ' : ' strokeWeight="1px" strokeColor="' + lineColor + '" '; | |
| 2978 | fill = fillColor === undefined ? ' filled="false"' : ' fillColor="' + fillColor + '" filled="true" '; | |
| 2979 | vel = '<v:shape coordorigin="0 0" coordsize="' + this.pixelWidth + ' ' + this.pixelHeight + '" ' + | |
| 2980 | ' id="jqsshape' + shapeid + '" ' + | |
| 2981 | stroke + | |
| 2982 | fill + | |
| 2983 | ' style="position:absolute;left:0px;top:0px;height:' + this.pixelHeight + 'px;width:' + this.pixelWidth + 'px;padding:0px;margin:0px;" ' + | |
| 2984 | ' path="m ' + x + ',' + y + ' wa ' + vpath.join(', ') + ' x e">' + | |
| 2985 | ' </v:shape>'; | |
| 2986 | return vel; | |
| 2987 | }, | |
| 2988 | ||
| 2989 | _drawRect: function (shapeid, x, y, width, height, lineColor, fillColor) { | |
| 2990 | return this._drawShape(shapeid, [[x, y], [x, y + height], [x + width, y + height], [x + width, y], [x, y]], lineColor, fillColor); | |
| 2991 | }, | |
| 2992 | ||
| 2993 | reset: function () { | |
| 2994 | this.group.innerHTML = ''; | |
| 2995 | }, | |
| 2996 | ||
| 2997 | appendShape: function (shape) { | |
| 2998 | var vel = this['_draw' + shape.type].apply(this, shape.args); | |
| 2999 | if (this.rendered) { | |
| 3000 | this.group.insertAdjacentHTML('beforeEnd', vel); | |
| 3001 | } else { | |
| 3002 | this.prerender += vel; | |
| 3003 | } | |
| 3004 | this.lastShapeId = shape.id; | |
| 3005 | return shape.id; | |
| 3006 | }, | |
| 3007 | ||
| 3008 | replaceWithShape: function (shapeid, shape) { | |
| 3009 | var existing = $('#jqsshape' + shapeid), | |
| 3010 | vel = this['_draw' + shape.type].apply(this, shape.args); | |
| 3011 | existing[0].outerHTML = vel; | |
| 3012 | }, | |
| 3013 | ||
| 3014 | replaceWithShapes: function (shapeids, shapes) { | |
| 3015 | // replace the first shapeid with all the new shapes then toast the remaining old shapes | |
| 3016 | var existing = $('#jqsshape' + shapeids[0]), | |
| 3017 | replace = '', | |
| 3018 | slen = shapes.length, | |
| 3019 | i; | |
| 3020 | for (i = 0; i < slen; i++) { | |
| 3021 | replace += this['_draw' + shapes[i].type].apply(this, shapes[i].args); | |
| 3022 | } | |
| 3023 | existing[0].outerHTML = replace; | |
| 3024 | for (i = 1; i < shapeids.length; i++) { | |
| 3025 | $('#jqsshape' + shapeids[i]).remove(); | |
| 3026 | } | |
| 3027 | }, | |
| 3028 | ||
| 3029 | insertAfterShape: function (shapeid, shape) { | |
| 3030 | var existing = $('#jqsshape' + shapeid), | |
| 3031 | vel = this['_draw' + shape.type].apply(this, shape.args); | |
| 3032 | existing[0].insertAdjacentHTML('afterEnd', vel); | |
| 3033 | }, | |
| 3034 | ||
| 3035 | removeShapeId: function (shapeid) { | |
| 3036 | var existing = $('#jqsshape' + shapeid); | |
| 3037 | this.group.removeChild(existing[0]); | |
| 3038 | }, | |
| 3039 | ||
| 3040 | getShapeAt: function (el, x, y) { | |
| 3041 | var shapeid = el.id.substr(8); | |
| 3042 | return shapeid; | |
| 3043 | }, | |
| 3044 | ||
| 3045 | render: function () { | |
| 3046 | if (!this.rendered) { | |
| 3047 | // batch the intial render into a single repaint | |
| 3048 | this.group.innerHTML = this.prerender; | |
| 3049 | this.rendered = true; | |
| 3050 | } | |
| 3051 | } | |
| 3052 | }); | |
| 3053 | ||
| 3054 | }))}(document, Math)); | |
