1 // Copyright 2006 Dan Vanderkam (danvdk@gmail.com)
2 // All Rights Reserved.
5 * @fileoverview Creates an interactive, zoomable graph based on a CSV file or
6 * string. Dygraph can handle multiple series with or without error bars. The
7 * date/value ranges will be automatically set. Dygraph uses the
8 * <canvas> tag, so it only works in FF1.5+.
9 * @author danvdk@gmail.com (Dan Vanderkam)
12 <div id="graphdiv" style="width:800px; height:500px;"></div>
13 <script type="text/javascript">
14 new Dygraph(document.getElementById("graphdiv"),
15 "datafile.csv", // CSV file with headers
19 The CSV file is of the form
21 Date,SeriesA,SeriesB,SeriesC
25 If the 'errorBars' option is set in the constructor, the input should be of
27 Date,SeriesA,SeriesB,...
28 YYYYMMDD,A1,sigmaA1,B1,sigmaB1,...
29 YYYYMMDD,A2,sigmaA2,B2,sigmaB2,...
31 If the 'fractions' option is set, the input should be of the form:
33 Date,SeriesA,SeriesB,...
34 YYYYMMDD,A1/B1,A2/B2,...
35 YYYYMMDD,A1/B1,A2/B2,...
37 And error bars will be calculated automatically using a binomial distribution.
39 For further documentation and examples, see http://dygraphs.com/
44 * An interactive, zoomable graph
45 * @param {String | Function} file A file containing CSV data or a function that
46 * returns this data. The expected format for each line is
47 * YYYYMMDD,val1,val2,... or, if attrs.errorBars is set,
48 * YYYYMMDD,val1,stddev1,val2,stddev2,...
49 * @param {Object} attrs Various other attributes, e.g. errorBars determines
50 * whether the input data contains error ranges.
52 Dygraph
= function(div
, data
, opts
) {
53 if (arguments
.length
> 0) {
54 if (arguments
.length
== 4) {
55 // Old versions of dygraphs took in the series labels as a constructor
56 // parameter. This doesn't make sense anymore, but it's easy to continue
57 // to support this usage.
58 this.warn("Using deprecated four-argument dygraph constructor");
59 this.__old_init__(div
, data
, arguments
[2], arguments
[3]);
61 this.__init__(div
, data
, opts
);
66 Dygraph
.NAME
= "Dygraph";
67 Dygraph
.VERSION
= "1.2";
68 Dygraph
.__repr__
= function() {
69 return "[" + this.NAME
+ " " + this.VERSION
+ "]";
71 Dygraph
.toString
= function() {
72 return this.__repr__();
75 // Various default values
76 Dygraph
.DEFAULT_ROLL_PERIOD
= 1;
77 Dygraph
.DEFAULT_WIDTH
= 480;
78 Dygraph
.DEFAULT_HEIGHT
= 320;
79 Dygraph
.AXIS_LINE_WIDTH
= 0.3;
81 Dygraph
.LOG_SCALE
= 10;
82 Dygraph
.LN_TEN
= Math
.log(Dygraph
.LOG_SCALE
);
83 Dygraph
.log10
= function(x
) {
84 return Math
.log(x
) / Dygraph
.LN_TEN
;
87 // Default attribute values.
88 Dygraph
.DEFAULT_ATTRS
= {
89 highlightCircleSize
: 3,
95 // TODO(danvk): move defaults from createStatusMessage_ here.
97 labelsSeparateLines
: false,
98 labelsShowZeroValues
: true,
101 showLabelsOnHighlight
: true,
103 yValueFormatter
: function(a
,b
) { return Dygraph
.numberFormatter(a
,b
); },
104 digitsAfterDecimal
: 2,
111 axisLabelFontSize
: 14,
114 xAxisLabelFormatter
: Dygraph
.dateAxisFormatter
,
118 xValueFormatter
: Dygraph
.dateString_
,
119 xValueParser
: Dygraph
.dateParser
,
120 xTicker
: Dygraph
.dateTicker
,
127 wilsonInterval
: true, // only relevant if fractions is true
131 connectSeparatedPoints
: false,
134 hideOverlayOnMouseOut
: true,
136 // TODO(danvk): support 'onmouseover' and 'never', and remove synonyms.
137 legend
: 'onmouseover', // the only relevant value at the moment is 'always'.
142 // Sizes of the various chart labels.
147 interactionModel
: null // will be set to Dygraph.defaultInteractionModel.
150 // Various logging levels.
156 // Directions for panning and zooming. Use bit operations when combined
157 // values are possible.
158 Dygraph
.HORIZONTAL
= 1;
159 Dygraph
.VERTICAL
= 2;
161 // Used for initializing annotation CSS rules only once.
162 Dygraph
.addedAnnotationCSS
= false;
165 * Return the 2d context for a dygraph canvas.
167 * This method is only exposed for the sake of replacing the function in
168 * automated tests, e.g.
170 * var oldFunc = Dygraph.getContext();
171 * Dygraph.getContext = function(canvas) {
172 * var realContext = oldFunc(canvas);
173 * return new Proxy(realContext);
176 Dygraph
.getContext
= function(canvas
) {
177 return canvas
.getContext("2d");
180 Dygraph
.prototype.__old_init__
= function(div
, file
, labels
, attrs
) {
181 // Labels is no longer a constructor parameter, since it's typically set
182 // directly from the data source. It also conains a name for the x-axis,
183 // which the previous constructor form did not.
184 if (labels
!= null) {
185 var new_labels
= ["Date"];
186 for (var i
= 0; i
< labels
.length
; i
++) new_labels
.push(labels
[i
]);
187 Dygraph
.update(attrs
, { 'labels': new_labels
});
189 this.__init__(div
, file
, attrs
);
193 * Initializes the Dygraph. This creates a new DIV and constructs the PlotKit
194 * and context <canvas> inside of it. See the constructor for details.
196 * @param {Element} div the Element to render the graph into.
197 * @param {String | Function} file Source data
198 * @param {Object} attrs Miscellaneous other options
201 Dygraph
.prototype.__init__
= function(div
, file
, attrs
) {
202 // Hack for IE: if we're using excanvas and the document hasn't finished
203 // loading yet (and hence may not have initialized whatever it needs to
204 // initialize), then keep calling this routine periodically until it has.
205 if (/MSIE/.test(navigator
.userAgent
) && !window
.opera
&&
206 typeof(G_vmlCanvasManager
) != 'undefined' &&
207 document
.readyState
!= 'complete') {
209 setTimeout(function() { self
.__init__(div
, file
, attrs
) }, 100);
212 // Support two-argument constructor
213 if (attrs
== null) { attrs
= {}; }
215 // Copy the important bits into the object
216 // TODO(danvk): most of these should just stay in the attrs_ dictionary.
219 this.rollPeriod_
= attrs
.rollPeriod
|| Dygraph
.DEFAULT_ROLL_PERIOD
;
220 this.previousVerticalX_
= -1;
221 this.fractions_
= attrs
.fractions
|| false;
222 this.dateWindow_
= attrs
.dateWindow
|| null;
224 this.wilsonInterval_
= attrs
.wilsonInterval
|| true;
225 this.is_initial_draw_
= true;
226 this.annotations_
= [];
228 // Zoomed indicators - These indicate when the graph has been zoomed and on what axis.
229 this.zoomed_x_
= false;
230 this.zoomed_y_
= false;
232 // Clear the div. This ensure that, if multiple dygraphs are passed the same
233 // div, then only one will be drawn.
236 // If the div isn't already sized then inherit from our attrs or
237 // give it a default size.
238 if (div
.style
.width
== '') {
239 div
.style
.width
= (attrs
.width
|| Dygraph
.DEFAULT_WIDTH
) + "px";
241 if (div
.style
.height
== '') {
242 div
.style
.height
= (attrs
.height
|| Dygraph
.DEFAULT_HEIGHT
) + "px";
244 this.width_
= parseInt(div
.style
.width
, 10);
245 this.height_
= parseInt(div
.style
.height
, 10);
246 // The div might have been specified as percent of the current window size,
247 // convert that to an appropriate number of pixels.
248 if (div
.style
.width
.indexOf("%") == div
.style
.width
.length
- 1) {
249 this.width_
= div
.offsetWidth
;
251 if (div
.style
.height
.indexOf("%") == div
.style
.height
.length
- 1) {
252 this.height_
= div
.offsetHeight
;
255 if (this.width_
== 0) {
256 this.error("dygraph has zero width. Please specify a width in pixels.");
258 if (this.height_
== 0) {
259 this.error("dygraph has zero height. Please specify a height in pixels.");
262 // TODO(danvk): set fillGraph to be part of attrs_ here, not user_attrs_.
263 if (attrs
['stackedGraph']) {
264 attrs
['fillGraph'] = true;
265 // TODO(nikhilk): Add any other stackedGraph checks here.
268 // Dygraphs has many options, some of which interact with one another.
269 // To keep track of everything, we maintain two sets of options:
271 // this.user_attrs_ only options explicitly set by the user.
272 // this.attrs_ defaults, options derived from user_attrs_, data.
274 // Options are then accessed this.attr_('attr'), which first looks at
275 // user_attrs_ and then computed attrs_. This way Dygraphs can set intelligent
276 // defaults without overriding behavior that the user specifically asks for.
277 this.user_attrs_
= {};
278 Dygraph
.update(this.user_attrs_
, attrs
);
281 Dygraph
.update(this.attrs_
, Dygraph
.DEFAULT_ATTRS
);
283 this.boundaryIds_
= [];
285 // Make a note of whether labels will be pulled from the CSV file.
286 this.labelsFromCSV_
= (this.attr_("labels") == null);
288 // Create the containing DIV and other interactive elements
289 this.createInterface_();
295 * Returns the zoomed status of the chart for one or both axes.
297 * Axis is an optional parameter. Can be set to 'x' or 'y'.
299 * The zoomed status for an axis is set whenever a user zooms using the mouse
300 * or when the dateWindow or valueRange are updated (unless the isZoomedIgnoreProgrammaticZoom
301 * option is also specified).
303 Dygraph
.prototype.isZoomed
= function(axis
) {
304 if (axis
== null) return this.zoomed_x_
|| this.zoomed_y_
;
305 if (axis
== 'x') return this.zoomed_x_
;
306 if (axis
== 'y') return this.zoomed_y_
;
307 throw "axis parameter to Dygraph.isZoomed must be missing, 'x' or 'y'.";
310 Dygraph
.prototype.toString
= function() {
311 var maindiv
= this.maindiv_
;
312 var id
= (maindiv
&& maindiv
.id
) ? maindiv
.id
: maindiv
313 return "[Dygraph " + id
+ "]";
316 Dygraph
.prototype.attr_
= function(name
, seriesName
) {
317 // <REMOVE_FOR_COMBINED>
318 if (typeof(Dygraph
.OPTIONS_REFERENCE
) === 'undefined') {
319 this.error('Must include options reference JS for testing');
320 } else if (!Dygraph
.OPTIONS_REFERENCE
.hasOwnProperty(name
)) {
321 this.error('Dygraphs is using property ' + name
+ ', which has no entry ' +
322 'in the Dygraphs.OPTIONS_REFERENCE listing.');
323 // Only log this error once.
324 Dygraph
.OPTIONS_REFERENCE
[name
] = true;
326 // </REMOVE_FOR_COMBINED
>
328 typeof(this.user_attrs_
[seriesName
]) != 'undefined' &&
329 this.user_attrs_
[seriesName
] != null &&
330 typeof(this.user_attrs_
[seriesName
][name
]) != 'undefined') {
331 return this.user_attrs_
[seriesName
][name
];
332 } else if (typeof(this.user_attrs_
[name
]) != 'undefined') {
333 return this.user_attrs_
[name
];
334 } else if (typeof(this.attrs_
[name
]) != 'undefined') {
335 return this.attrs_
[name
];
341 // TODO(danvk): any way I can get the line numbers to be this.warn call?
342 Dygraph
.prototype.log
= function(severity
, message
) {
343 if (typeof(console
) != 'undefined') {
346 console
.debug('dygraphs: ' + message
);
349 console
.info('dygraphs: ' + message
);
351 case Dygraph
.WARNING
:
352 console
.warn('dygraphs: ' + message
);
355 console
.error('dygraphs: ' + message
);
360 Dygraph
.prototype.info
= function(message
) {
361 this.log(Dygraph
.INFO
, message
);
363 Dygraph
.prototype.warn
= function(message
) {
364 this.log(Dygraph
.WARNING
, message
);
366 Dygraph
.prototype.error
= function(message
) {
367 this.log(Dygraph
.ERROR
, message
);
371 * Returns the current rolling period, as set by the user or an option.
372 * @return {Number} The number of points in the rolling window
374 Dygraph
.prototype.rollPeriod
= function() {
375 return this.rollPeriod_
;
379 * Returns the currently-visible x-range. This can be affected by zooming,
380 * panning or a call to updateOptions.
381 * Returns a two-element array: [left, right].
382 * If the Dygraph has dates on the x-axis, these will be millis since epoch.
384 Dygraph
.prototype.xAxisRange
= function() {
385 return this.dateWindow_
? this.dateWindow_
: this.xAxisExtremes();
389 * Returns the lower- and upper-bound x-axis values of the
392 Dygraph
.prototype.xAxisExtremes
= function() {
393 var left
= this.rawData_
[0][0];
394 var right
= this.rawData_
[this.rawData_
.length
- 1][0];
395 return [left
, right
];
399 * Returns the currently-visible y-range for an axis. This can be affected by
400 * zooming, panning or a call to updateOptions. Axis indices are zero-based. If
401 * called with no arguments, returns the range of the first axis.
402 * Returns a two-element array: [bottom, top].
404 Dygraph
.prototype.yAxisRange
= function(idx
) {
405 if (typeof(idx
) == "undefined") idx
= 0;
406 if (idx
< 0 || idx
>= this.axes_
.length
) return null;
407 return [ this.axes_
[idx
].computedValueRange
[0],
408 this.axes_
[idx
].computedValueRange
[1] ];
412 * Returns the currently-visible y-ranges for each axis. This can be affected by
413 * zooming, panning, calls to updateOptions, etc.
414 * Returns an array of [bottom, top] pairs, one for each y-axis.
416 Dygraph
.prototype.yAxisRanges
= function() {
418 for (var i
= 0; i
< this.axes_
.length
; i
++) {
419 ret
.push(this.yAxisRange(i
));
424 // TODO(danvk): use these functions throughout dygraphs.
426 * Convert from data coordinates to canvas/div X/Y coordinates.
427 * If specified, do this conversion for the coordinate system of a particular
428 * axis. Uses the first axis by default.
429 * Returns a two-element array: [X, Y]
431 * Note: use toDomXCoord instead of toDomCoords(x, null) and use toDomYCoord
432 * instead of toDomCoords(null, y, axis).
434 Dygraph
.prototype.toDomCoords
= function(x
, y
, axis
) {
435 return [ this.toDomXCoord(x
), this.toDomYCoord(y
, axis
) ];
439 * Convert from data x coordinates to canvas/div X coordinate.
440 * If specified, do this conversion for the coordinate system of a particular
442 * Returns a single value or null if x is null.
444 Dygraph
.prototype.toDomXCoord
= function(x
) {
449 var area
= this.plotter_
.area
;
450 var xRange
= this.xAxisRange();
451 return area
.x
+ (x
- xRange
[0]) / (xRange
[1] - xRange
[0]) * area
.w
;
455 * Convert from data x coordinates to canvas/div Y coordinate and optional
456 * axis. Uses the first axis by default.
458 * returns a single value or null if y is null.
460 Dygraph
.prototype.toDomYCoord
= function(y
, axis
) {
461 var pct
= this.toPercentYCoord(y
, axis
);
466 var area
= this.plotter_
.area
;
467 return area
.y
+ pct
* area
.h
;
471 * Convert from canvas/div coords to data coordinates.
472 * If specified, do this conversion for the coordinate system of a particular
473 * axis. Uses the first axis by default.
474 * Returns a two-element array: [X, Y].
476 * Note: use toDataXCoord instead of toDataCoords(x, null) and use toDataYCoord
477 * instead of toDataCoords(null, y, axis).
479 Dygraph
.prototype.toDataCoords
= function(x
, y
, axis
) {
480 return [ this.toDataXCoord(x
), this.toDataYCoord(y
, axis
) ];
484 * Convert from canvas/div x coordinate to data coordinate.
486 * If x is null, this returns null.
488 Dygraph
.prototype.toDataXCoord
= function(x
) {
493 var area
= this.plotter_
.area
;
494 var xRange
= this.xAxisRange();
495 return xRange
[0] + (x
- area
.x
) / area
.w
* (xRange
[1] - xRange
[0]);
499 * Convert from canvas/div y coord to value.
501 * If y is null, this returns null.
502 * if axis is null, this uses the first axis.
504 Dygraph
.prototype.toDataYCoord
= function(y
, axis
) {
509 var area
= this.plotter_
.area
;
510 var yRange
= this.yAxisRange(axis
);
512 if (typeof(axis
) == "undefined") axis
= 0;
513 if (!this.axes_
[axis
].logscale
) {
514 return yRange
[0] + (area
.h
- y
) / area
.h
* (yRange
[1] - yRange
[0]);
516 // Computing the inverse of toDomCoord.
517 var pct
= (y
- area
.y
) / area
.h
519 // Computing the inverse of toPercentYCoord. The function was arrived at with
520 // the following steps:
522 // Original calcuation:
523 // pct = (logr1 - Dygraph.log10(y)) / (logr1
- Dygraph
.log10(yRange
[0]));
525 // Move denominator to both sides:
526 // pct * (logr1 - Dygraph.log10(yRange[0])) = logr1 - Dygraph.log10(y);
528 // subtract logr1, and take the negative value.
529 // logr1 - (pct * (logr1 - Dygraph.log10(yRange[0]))) = Dygraph.log10(y);
531 // Swap both sides of the equation, and we can compute the log of the
532 // return value. Which means we just need to use that as the exponent in
534 // Dygraph.log10(y) = logr1 - (pct * (logr1 - Dygraph.log10(yRange[0])));
536 var logr1
= Dygraph
.log10(yRange
[1]);
537 var exponent
= logr1
- (pct
* (logr1
- Dygraph
.log10(yRange
[0])));
538 var value
= Math
.pow(Dygraph
.LOG_SCALE
, exponent
);
544 * Converts a y for an axis to a percentage from the top to the
545 * bottom of the drawing area.
547 * If the coordinate represents a value visible on the canvas, then
548 * the value will be between 0 and 1, where 0 is the top of the canvas.
549 * However, this method will return values outside the range, as
550 * values can fall outside the canvas.
552 * If y is null, this returns null.
553 * if axis is null, this uses the first axis.
555 Dygraph
.prototype.toPercentYCoord
= function(y
, axis
) {
559 if (typeof(axis
) == "undefined") axis
= 0;
561 var area
= this.plotter_
.area
;
562 var yRange
= this.yAxisRange(axis
);
565 if (!this.axes_
[axis
].logscale
) {
566 // yRange[1] - y is unit distance from the bottom.
567 // yRange[1] - yRange[0] is the scale of the range.
568 // (yRange[1] - y) / (yRange
[1] - yRange
[0]) is the
% from the bottom
.
569 pct
= (yRange
[1] - y
) / (yRange
[1] - yRange
[0]);
571 var logr1
= Dygraph
.log10(yRange
[1]);
572 pct
= (logr1
- Dygraph
.log10(y
)) / (logr1
- Dygraph
.log10(yRange
[0]));
578 * Converts an x value to a percentage from the left to the right of
581 * If the coordinate represents a value visible on the canvas, then
582 * the value will be between 0 and 1, where 0 is the left of the canvas.
583 * However, this method will return values outside the range, as
584 * values can fall outside the canvas.
586 * If x is null, this returns null.
588 Dygraph
.prototype.toPercentXCoord
= function(x
) {
593 var xRange
= this.xAxisRange();
594 return (x
- xRange
[0]) / (xRange
[1] - xRange
[0]);
598 * Returns the number of columns (including the independent variable).
600 Dygraph
.prototype.numColumns
= function() {
601 return this.rawData_
[0].length
;
605 * Returns the number of rows (excluding any header/label row).
607 Dygraph
.prototype.numRows
= function() {
608 return this.rawData_
.length
;
612 * Returns the value in the given row and column. If the row and column exceed
613 * the bounds on the data, returns null. Also returns null if the value is
616 Dygraph
.prototype.getValue
= function(row
, col
) {
617 if (row
< 0 || row
> this.rawData_
.length
) return null;
618 if (col
< 0 || col
> this.rawData_
[row
].length
) return null;
620 return this.rawData_
[row
][col
];
623 Dygraph
.addEvent
= function(el
, evt
, fn
) {
624 var normed_fn
= function(e
) {
625 if (!e
) var e
= window
.event
;
628 if (window
.addEventListener
) { // Mozilla, Netscape, Firefox
629 el
.addEventListener(evt
, normed_fn
, false);
631 el
.attachEvent('on' + evt
, normed_fn
);
636 // Based on the article at
637 // http://www.switchonthecode.com/tutorials
/javascript
-tutorial
-the
-scroll
-wheel
638 Dygraph
.cancelEvent
= function(e
) {
639 e
= e
? e
: window
.event
;
640 if (e
.stopPropagation
) {
643 if (e
.preventDefault
) {
646 e
.cancelBubble
= true;
648 e
.returnValue
= false;
654 * Generates interface elements for the Dygraph: a containing div, a div to
655 * display the current point, and a textbox to adjust the rolling average
656 * period. Also creates the Renderer/Layout elements.
659 Dygraph
.prototype.createInterface_
= function() {
660 // Create the all-enclosing graph div
661 var enclosing
= this.maindiv_
;
663 this.graphDiv
= document
.createElement("div");
664 this.graphDiv
.style
.width
= this.width_
+ "px";
665 this.graphDiv
.style
.height
= this.height_
+ "px";
666 enclosing
.appendChild(this.graphDiv
);
668 // Create the canvas for interactive parts of the chart.
669 this.canvas_
= Dygraph
.createCanvas();
670 this.canvas_
.style
.position
= "absolute";
671 this.canvas_
.width
= this.width_
;
672 this.canvas_
.height
= this.height_
;
673 this.canvas_
.style
.width
= this.width_
+ "px"; // for IE
674 this.canvas_
.style
.height
= this.height_
+ "px"; // for IE
676 this.canvas_ctx_
= Dygraph
.getContext(this.canvas_
);
678 // ... and for static parts of the chart.
679 this.hidden_
= this.createPlotKitCanvas_(this.canvas_
);
680 this.hidden_ctx_
= Dygraph
.getContext(this.hidden_
);
682 // The interactive parts of the graph are drawn on top of the chart.
683 this.graphDiv
.appendChild(this.hidden_
);
684 this.graphDiv
.appendChild(this.canvas_
);
685 this.mouseEventElement_
= this.canvas_
;
688 Dygraph
.addEvent(this.mouseEventElement_
, 'mousemove', function(e
) {
689 dygraph
.mouseMove_(e
);
691 Dygraph
.addEvent(this.mouseEventElement_
, 'mouseout', function(e
) {
692 dygraph
.mouseOut_(e
);
695 // Create the grapher
696 // TODO(danvk): why does the Layout need its own set of options?
697 this.layoutOptions_
= { 'xOriginIsZero': false };
698 Dygraph
.update(this.layoutOptions_
, this.attrs_
);
699 Dygraph
.update(this.layoutOptions_
, this.user_attrs_
);
700 Dygraph
.update(this.layoutOptions_
, {
701 'errorBars': (this.attr_("errorBars") || this.attr_("customBars")) });
703 this.layout_
= new DygraphLayout(this, this.layoutOptions_
);
705 // TODO(danvk): why does the Renderer need its own set of options?
706 this.renderOptions_
= { colorScheme
: this.colors_
,
708 axisLineWidth
: Dygraph
.AXIS_LINE_WIDTH
};
709 Dygraph
.update(this.renderOptions_
, this.attrs_
);
710 Dygraph
.update(this.renderOptions_
, this.user_attrs_
);
712 this.createStatusMessage_();
713 this.createDragInterface_();
717 * Detach DOM elements in the dygraph and null out all data references.
718 * Calling this when you're done with a dygraph can dramatically reduce memory
719 * usage. See, e.g., the tests/perf.html example.
721 Dygraph
.prototype.destroy
= function() {
722 var removeRecursive
= function(node
) {
723 while (node
.hasChildNodes()) {
724 removeRecursive(node
.firstChild
);
725 node
.removeChild(node
.firstChild
);
728 removeRecursive(this.maindiv_
);
730 var nullOut
= function(obj
) {
732 if (typeof(obj
[n
]) === 'object') {
738 // These may not all be necessary, but it can't hurt...
739 nullOut(this.layout_
);
740 nullOut(this.plotter_
);
745 * Creates the canvas containing the PlotKit graph. Only plotkit ever draws on
746 * this particular canvas. All Dygraph work is done on this.canvas_.
747 * @param {Object} canvas The Dygraph canvas over which to overlay the plot
748 * @return {Object} The newly-created canvas
751 Dygraph
.prototype.createPlotKitCanvas_
= function(canvas
) {
752 var h
= Dygraph
.createCanvas();
753 h
.style
.position
= "absolute";
754 // TODO(danvk): h should be offset from canvas. canvas needs to include
755 // some extra area to make it easier to zoom in on the far left and far
756 // right. h needs to be precisely the plot area, so that clipping occurs.
757 h
.style
.top
= canvas
.style
.top
;
758 h
.style
.left
= canvas
.style
.left
;
759 h
.width
= this.width_
;
760 h
.height
= this.height_
;
761 h
.style
.width
= this.width_
+ "px"; // for IE
762 h
.style
.height
= this.height_
+ "px"; // for IE
766 // Taken from MochiKit.Color
767 Dygraph
.hsvToRGB
= function (hue
, saturation
, value
) {
771 if (saturation
=== 0) {
776 var i
= Math
.floor(hue
* 6);
777 var f
= (hue
* 6) - i
;
778 var p
= value
* (1 - saturation
);
779 var q
= value
* (1 - (saturation
* f
));
780 var t
= value
* (1 - (saturation
* (1 - f
)));
782 case 1: red
= q
; green
= value
; blue
= p
; break;
783 case 2: red
= p
; green
= value
; blue
= t
; break;
784 case 3: red
= p
; green
= q
; blue
= value
; break;
785 case 4: red
= t
; green
= p
; blue
= value
; break;
786 case 5: red
= value
; green
= p
; blue
= q
; break;
787 case 6: // fall through
788 case 0: red
= value
; green
= t
; blue
= p
; break;
791 red
= Math
.floor(255 * red
+ 0.5);
792 green
= Math
.floor(255 * green
+ 0.5);
793 blue
= Math
.floor(255 * blue
+ 0.5);
794 return 'rgb(' + red
+ ',' + green
+ ',' + blue
+ ')';
799 * Generate a set of distinct colors for the data series. This is done with a
800 * color wheel. Saturation/Value are customizable, and the hue is
801 * equally-spaced around the color wheel. If a custom set of colors is
802 * specified, that is used instead.
805 Dygraph
.prototype.setColors_
= function() {
806 // TODO(danvk): compute this directly into this.attrs_['colorScheme'] and do
807 // away with this.renderOptions_.
808 var num
= this.attr_("labels").length
- 1;
810 var colors
= this.attr_('colors');
812 var sat
= this.attr_('colorSaturation') || 1.0;
813 var val
= this.attr_('colorValue') || 0.5;
814 var half
= Math
.ceil(num
/ 2);
815 for (var i
= 1; i
<= num
; i
++) {
816 if (!this.visibility()[i
-1]) continue;
817 // alternate colors for high contrast.
818 var idx
= i
% 2 ? Math
.ceil(i
/ 2) : (half + i / 2);
819 var hue
= (1.0 * idx
/ (1 + num
));
820 this.colors_
.push(Dygraph
.hsvToRGB(hue
, sat
, val
));
823 for (var i
= 0; i
< num
; i
++) {
824 if (!this.visibility()[i
]) continue;
825 var colorStr
= colors
[i
% colors
.length
];
826 this.colors_
.push(colorStr
);
830 // TODO(danvk): update this w/r
/t/ the
new options system
.
831 this.renderOptions_
.colorScheme
= this.colors_
;
832 Dygraph
.update(this.plotter_
.options
, this.renderOptions_
);
833 Dygraph
.update(this.layoutOptions_
, this.user_attrs_
);
834 Dygraph
.update(this.layoutOptions_
, this.attrs_
);
838 * Return the list of colors. This is either the list of colors passed in the
839 * attributes, or the autogenerated list of rgb(r,g,b) strings.
840 * @return {Array<string>} The list of colors.
842 Dygraph
.prototype.getColors
= function() {
846 // The following functions are from quirksmode.org with a modification for Safari from
847 // http://blog.firetree.net/2005/07/04/javascript-find-position/
848 // http://www.quirksmode.org/js
/findpos
.html
849 Dygraph
.findPosX
= function(obj
) {
854 curleft
+= obj
.offsetLeft
;
855 if(!obj
.offsetParent
)
857 obj
= obj
.offsetParent
;
864 Dygraph
.findPosY
= function(obj
) {
869 curtop
+= obj
.offsetTop
;
870 if(!obj
.offsetParent
)
872 obj
= obj
.offsetParent
;
882 * Create the div that contains information on the selected point(s)
883 * This goes in the top right of the canvas, unless an external div has already
887 Dygraph
.prototype.createStatusMessage_
= function() {
888 var userLabelsDiv
= this.user_attrs_
["labelsDiv"];
889 if (userLabelsDiv
&& null != userLabelsDiv
890 && (typeof(userLabelsDiv
) == "string" || userLabelsDiv
instanceof String
)) {
891 this.user_attrs_
["labelsDiv"] = document
.getElementById(userLabelsDiv
);
893 if (!this.attr_("labelsDiv")) {
894 var divWidth
= this.attr_('labelsDivWidth');
896 "position": "absolute",
899 "width": divWidth
+ "px",
901 "left": (this.width_
- divWidth
- 2) + "px",
902 "background": "white",
904 "overflow": "hidden"};
905 Dygraph
.update(messagestyle
, this.attr_('labelsDivStyles'));
906 var div
= document
.createElement("div");
907 for (var name
in messagestyle
) {
908 if (messagestyle
.hasOwnProperty(name
)) {
909 div
.style
[name
] = messagestyle
[name
];
912 this.graphDiv
.appendChild(div
);
913 this.attrs_
.labelsDiv
= div
;
918 * Position the labels div so that:
919 * - its right edge is flush with the right edge of the charting area
920 * - its top edge is flush with the top edge of the charting area
922 Dygraph
.prototype.positionLabelsDiv_
= function() {
923 // Don't touch a user-specified labelsDiv.
924 if (this.user_attrs_
.hasOwnProperty("labelsDiv")) return;
926 var area
= this.plotter_
.area
;
927 var div
= this.attr_("labelsDiv");
928 div
.style
.left
= area
.x
+ area
.w
- this.attr_("labelsDivWidth") - 1 + "px";
929 div
.style
.top
= area
.y
+ "px";
933 * Create the text box to adjust the averaging period
936 Dygraph
.prototype.createRollInterface_
= function() {
937 // Create a roller if one doesn't exist already.
939 this.roller_
= document
.createElement("input");
940 this.roller_
.type
= "text";
941 this.roller_
.style
.display
= "none";
942 this.graphDiv
.appendChild(this.roller_
);
945 var display
= this.attr_('showRoller') ? 'block' : 'none';
947 var area
= this.plotter_
.area
;
948 var textAttr
= { "position": "absolute",
950 "top": (area
.y
+ area
.h
- 25) + "px",
951 "left": (area
.x
+ 1) + "px",
954 this.roller_
.size
= "2";
955 this.roller_
.value
= this.rollPeriod_
;
956 for (var name
in textAttr
) {
957 if (textAttr
.hasOwnProperty(name
)) {
958 this.roller_
.style
[name
] = textAttr
[name
];
963 this.roller_
.onchange
= function() { dygraph
.adjustRoll(dygraph
.roller_
.value
); };
966 // These functions are taken from MochiKit.Signal
967 Dygraph
.pageX
= function(e
) {
969 return (!e
.pageX
|| e
.pageX
< 0) ? 0 : e
.pageX
;
972 var b
= document
.body
;
974 (de
.scrollLeft
|| b
.scrollLeft
) -
975 (de
.clientLeft
|| 0);
979 Dygraph
.pageY
= function(e
) {
981 return (!e
.pageY
|| e
.pageY
< 0) ? 0 : e
.pageY
;
984 var b
= document
.body
;
986 (de
.scrollTop
|| b
.scrollTop
) -
991 Dygraph
.prototype.dragGetX_
= function(e
, context
) {
992 return Dygraph
.pageX(e
) - context
.px
995 Dygraph
.prototype.dragGetY_
= function(e
, context
) {
996 return Dygraph
.pageY(e
) - context
.py
999 // Called in response to an interaction model operation that
1000 // should start the default panning behavior.
1002 // It's used in the default callback for "mousedown" operations.
1003 // Custom interaction model builders can use it to provide the default
1004 // panning behavior.
1006 Dygraph
.startPan
= function(event
, g
, context
) {
1007 context
.isPanning
= true;
1008 var xRange
= g
.xAxisRange();
1009 context
.dateRange
= xRange
[1] - xRange
[0];
1010 context
.initialLeftmostDate
= xRange
[0];
1011 context
.xUnitsPerPixel
= context
.dateRange
/ (g
.plotter_
.area
.w
- 1);
1013 if (g
.attr_("panEdgeFraction")) {
1014 var maxXPixelsToDraw
= g
.width_
* g
.attr_("panEdgeFraction");
1015 var xExtremes
= g
.xAxisExtremes(); // I REALLY WANT TO CALL THIS xTremes!
1017 var boundedLeftX
= g
.toDomXCoord(xExtremes
[0]) - maxXPixelsToDraw
;
1018 var boundedRightX
= g
.toDomXCoord(xExtremes
[1]) + maxXPixelsToDraw
;
1020 var boundedLeftDate
= g
.toDataXCoord(boundedLeftX
);
1021 var boundedRightDate
= g
.toDataXCoord(boundedRightX
);
1022 context
.boundedDates
= [boundedLeftDate
, boundedRightDate
];
1024 var boundedValues
= [];
1025 var maxYPixelsToDraw
= g
.height_
* g
.attr_("panEdgeFraction");
1027 for (var i
= 0; i
< g
.axes_
.length
; i
++) {
1028 var axis
= g
.axes_
[i
];
1029 var yExtremes
= axis
.extremeRange
;
1031 var boundedTopY
= g
.toDomYCoord(yExtremes
[0], i
) + maxYPixelsToDraw
;
1032 var boundedBottomY
= g
.toDomYCoord(yExtremes
[1], i
) - maxYPixelsToDraw
;
1034 var boundedTopValue
= g
.toDataYCoord(boundedTopY
);
1035 var boundedBottomValue
= g
.toDataYCoord(boundedBottomY
);
1037 boundedValues
[i
] = [boundedTopValue
, boundedBottomValue
];
1039 context
.boundedValues
= boundedValues
;
1042 // Record the range of each y-axis at the start of the drag.
1043 // If any axis has a valueRange or valueWindow, then we want a 2D pan.
1044 context
.is2DPan
= false;
1045 for (var i
= 0; i
< g
.axes_
.length
; i
++) {
1046 var axis
= g
.axes_
[i
];
1047 var yRange
= g
.yAxisRange(i
);
1048 // TODO(konigsberg): These values should be in |context|.
1049 // In log scale, initialTopValue, dragValueRange and unitsPerPixel are log scale.
1050 if (axis
.logscale
) {
1051 axis
.initialTopValue
= Dygraph
.log10(yRange
[1]);
1052 axis
.dragValueRange
= Dygraph
.log10(yRange
[1]) - Dygraph
.log10(yRange
[0]);
1054 axis
.initialTopValue
= yRange
[1];
1055 axis
.dragValueRange
= yRange
[1] - yRange
[0];
1057 axis
.unitsPerPixel
= axis
.dragValueRange
/ (g
.plotter_
.area
.h
- 1);
1059 // While calculating axes, set 2dpan.
1060 if (axis
.valueWindow
|| axis
.valueRange
) context
.is2DPan
= true;
1064 // Called in response to an interaction model operation that
1065 // responds to an event that pans the view.
1067 // It's used in the default callback for "mousemove" operations.
1068 // Custom interaction model builders can use it to provide the default
1069 // panning behavior.
1071 Dygraph
.movePan
= function(event
, g
, context
) {
1072 context
.dragEndX
= g
.dragGetX_(event
, context
);
1073 context
.dragEndY
= g
.dragGetY_(event
, context
);
1075 var minDate
= context
.initialLeftmostDate
-
1076 (context
.dragEndX
- context
.dragStartX
) * context
.xUnitsPerPixel
;
1077 if (context
.boundedDates
) {
1078 minDate
= Math
.max(minDate
, context
.boundedDates
[0]);
1080 var maxDate
= minDate
+ context
.dateRange
;
1081 if (context
.boundedDates
) {
1082 if (maxDate
> context
.boundedDates
[1]) {
1083 // Adjust minDate, and recompute maxDate.
1084 minDate
= minDate
- (maxDate
- context
.boundedDates
[1]);
1085 maxDate
= minDate
+ context
.dateRange
;
1089 g
.dateWindow_
= [minDate
, maxDate
];
1091 // y-axis scaling is automatic unless this is a full 2D pan.
1092 if (context
.is2DPan
) {
1093 // Adjust each axis appropriately.
1094 for (var i
= 0; i
< g
.axes_
.length
; i
++) {
1095 var axis
= g
.axes_
[i
];
1097 var pixelsDragged
= context
.dragEndY
- context
.dragStartY
;
1098 var unitsDragged
= pixelsDragged
* axis
.unitsPerPixel
;
1100 var boundedValue
= context
.boundedValues
? context
.boundedValues
[i
] : null;
1102 // In log scale, maxValue and minValue are the logs of those values.
1103 var maxValue
= axis
.initialTopValue
+ unitsDragged
;
1105 maxValue
= Math
.min(maxValue
, boundedValue
[1]);
1107 var minValue
= maxValue
- axis
.dragValueRange
;
1109 if (minValue
< boundedValue
[0]) {
1110 // Adjust maxValue, and recompute minValue.
1111 maxValue
= maxValue
- (minValue
- boundedValue
[0]);
1112 minValue
= maxValue
- axis
.dragValueRange
;
1115 if (axis
.logscale
) {
1116 axis
.valueWindow
= [ Math
.pow(Dygraph
.LOG_SCALE
, minValue
),
1117 Math
.pow(Dygraph
.LOG_SCALE
, maxValue
) ];
1119 axis
.valueWindow
= [ minValue
, maxValue
];
1127 // Called in response to an interaction model operation that
1128 // responds to an event that ends panning.
1130 // It's used in the default callback for "mouseup" operations.
1131 // Custom interaction model builders can use it to provide the default
1132 // panning behavior.
1134 Dygraph
.endPan
= function(event
, g
, context
) {
1135 // TODO(konigsberg): Clear the context data from the axis.
1136 // TODO(konigsberg): mouseup should just delete the
1137 // context object, and mousedown should create a new one.
1138 context
.isPanning
= false;
1139 context
.is2DPan
= false;
1140 context
.initialLeftmostDate
= null;
1141 context
.dateRange
= null;
1142 context
.valueRange
= null;
1143 context
.boundedDates
= null;
1144 context
.boundedValues
= null;
1147 // Called in response to an interaction model operation that
1148 // responds to an event that starts zooming.
1150 // It's used in the default callback for "mousedown" operations.
1151 // Custom interaction model builders can use it to provide the default
1152 // zooming behavior.
1154 Dygraph
.startZoom
= function(event
, g
, context
) {
1155 context
.isZooming
= true;
1158 // Called in response to an interaction model operation that
1159 // responds to an event that defines zoom boundaries.
1161 // It's used in the default callback for "mousemove" operations.
1162 // Custom interaction model builders can use it to provide the default
1163 // zooming behavior.
1165 Dygraph
.moveZoom
= function(event
, g
, context
) {
1166 context
.dragEndX
= g
.dragGetX_(event
, context
);
1167 context
.dragEndY
= g
.dragGetY_(event
, context
);
1169 var xDelta
= Math
.abs(context
.dragStartX
- context
.dragEndX
);
1170 var yDelta
= Math
.abs(context
.dragStartY
- context
.dragEndY
);
1172 // drag direction threshold for y axis is twice as large as x axis
1173 context
.dragDirection
= (xDelta
< yDelta
/ 2) ? Dygraph
.VERTICAL
: Dygraph
.HORIZONTAL
;
1176 context
.dragDirection
,
1181 context
.prevDragDirection
,
1185 context
.prevEndX
= context
.dragEndX
;
1186 context
.prevEndY
= context
.dragEndY
;
1187 context
.prevDragDirection
= context
.dragDirection
;
1190 // Called in response to an interaction model operation that
1191 // responds to an event that performs a zoom based on previously defined
1194 // It's used in the default callback for "mouseup" operations.
1195 // Custom interaction model builders can use it to provide the default
1196 // zooming behavior.
1198 Dygraph
.endZoom
= function(event
, g
, context
) {
1199 context
.isZooming
= false;
1200 context
.dragEndX
= g
.dragGetX_(event
, context
);
1201 context
.dragEndY
= g
.dragGetY_(event
, context
);
1202 var regionWidth
= Math
.abs(context
.dragEndX
- context
.dragStartX
);
1203 var regionHeight
= Math
.abs(context
.dragEndY
- context
.dragStartY
);
1205 if (regionWidth
< 2 && regionHeight
< 2 &&
1206 g
.lastx_
!= undefined
&& g
.lastx_
!= -1) {
1207 // TODO(danvk): pass along more info about the points, e.g. 'x'
1208 if (g
.attr_('clickCallback') != null) {
1209 g
.attr_('clickCallback')(event
, g
.lastx_
, g
.selPoints_
);
1211 if (g
.attr_('pointClickCallback')) {
1212 // check if the click was on a particular point.
1213 var closestIdx
= -1;
1214 var closestDistance
= 0;
1215 for (var i
= 0; i
< g
.selPoints_
.length
; i
++) {
1216 var p
= g
.selPoints_
[i
];
1217 var distance
= Math
.pow(p
.canvasx
- context
.dragEndX
, 2) +
1218 Math
.pow(p
.canvasy
- context
.dragEndY
, 2);
1219 if (closestIdx
== -1 || distance
< closestDistance
) {
1220 closestDistance
= distance
;
1225 // Allow any click within two pixels of the dot.
1226 var radius
= g
.attr_('highlightCircleSize') + 2;
1227 if (closestDistance
<= 5 * 5) {
1228 g
.attr_('pointClickCallback')(event
, g
.selPoints_
[closestIdx
]);
1233 if (regionWidth
>= 10 && context
.dragDirection
== Dygraph
.HORIZONTAL
) {
1234 g
.doZoomX_(Math
.min(context
.dragStartX
, context
.dragEndX
),
1235 Math
.max(context
.dragStartX
, context
.dragEndX
));
1236 } else if (regionHeight
>= 10 && context
.dragDirection
== Dygraph
.VERTICAL
) {
1237 g
.doZoomY_(Math
.min(context
.dragStartY
, context
.dragEndY
),
1238 Math
.max(context
.dragStartY
, context
.dragEndY
));
1240 g
.canvas_ctx_
.clearRect(0, 0, g
.canvas_
.width
, g
.canvas_
.height
);
1242 context
.dragStartX
= null;
1243 context
.dragStartY
= null;
1246 Dygraph
.defaultInteractionModel
= {
1247 // Track the beginning of drag events
1248 mousedown
: function(event
, g
, context
) {
1249 context
.initializeMouseDown(event
, g
, context
);
1251 if (event
.altKey
|| event
.shiftKey
) {
1252 Dygraph
.startPan(event
, g
, context
);
1254 Dygraph
.startZoom(event
, g
, context
);
1258 // Draw zoom rectangles when the mouse is down and the user moves around
1259 mousemove
: function(event
, g
, context
) {
1260 if (context
.isZooming
) {
1261 Dygraph
.moveZoom(event
, g
, context
);
1262 } else if (context
.isPanning
) {
1263 Dygraph
.movePan(event
, g
, context
);
1267 mouseup
: function(event
, g
, context
) {
1268 if (context
.isZooming
) {
1269 Dygraph
.endZoom(event
, g
, context
);
1270 } else if (context
.isPanning
) {
1271 Dygraph
.endPan(event
, g
, context
);
1275 // Temporarily cancel the dragging event when the mouse leaves the graph
1276 mouseout
: function(event
, g
, context
) {
1277 if (context
.isZooming
) {
1278 context
.dragEndX
= null;
1279 context
.dragEndY
= null;
1283 // Disable zooming out if panning.
1284 dblclick
: function(event
, g
, context
) {
1285 if (event
.altKey
|| event
.shiftKey
) {
1288 // TODO(konigsberg): replace g.doUnzoom()_ with something that is
1289 // friendlier to public use.
1294 Dygraph
.DEFAULT_ATTRS
.interactionModel
= Dygraph
.defaultInteractionModel
;
1297 * Set up all the mouse handlers needed to capture dragging behavior for zoom
1301 Dygraph
.prototype.createDragInterface_
= function() {
1303 // Tracks whether the mouse is down right now
1305 isPanning
: false, // is this drag part of a pan?
1306 is2DPan
: false, // if so, is that pan 1- or 2-dimensional?
1311 dragDirection
: null,
1314 prevDragDirection
: null,
1316 // The value on the left side of the graph when a pan operation starts.
1317 initialLeftmostDate
: null,
1319 // The number of units each pixel spans. (This won't be valid for log
1321 xUnitsPerPixel
: null,
1323 // TODO(danvk): update this comment
1324 // The range in second/value units that the viewport encompasses during a
1325 // panning operation.
1328 // Utility function to convert page-wide coordinates to canvas coords
1332 // Values for use with panEdgeFraction, which limit how far outside the
1333 // graph's data boundaries it can be panned.
1334 boundedDates
: null, // [minDate, maxDate]
1335 boundedValues
: null, // [[minValue, maxValue] ...]
1337 initializeMouseDown
: function(event
, g
, context
) {
1338 // prevents mouse drags from selecting page text.
1339 if (event
.preventDefault
) {
1340 event
.preventDefault(); // Firefox, Chrome, etc.
1342 event
.returnValue
= false; // IE
1343 event
.cancelBubble
= true;
1346 context
.px
= Dygraph
.findPosX(g
.canvas_
);
1347 context
.py
= Dygraph
.findPosY(g
.canvas_
);
1348 context
.dragStartX
= g
.dragGetX_(event
, context
);
1349 context
.dragStartY
= g
.dragGetY_(event
, context
);
1353 var interactionModel
= this.attr_("interactionModel");
1355 // Self is the graph.
1358 // Function that binds the graph and context to the handler.
1359 var bindHandler
= function(handler
) {
1360 return function(event
) {
1361 handler(event
, self
, context
);
1365 for (var eventName
in interactionModel
) {
1366 if (!interactionModel
.hasOwnProperty(eventName
)) continue;
1367 Dygraph
.addEvent(this.mouseEventElement_
, eventName
,
1368 bindHandler(interactionModel
[eventName
]));
1371 // If the user releases the mouse button during a drag, but not over the
1372 // canvas, then it doesn't count as a zooming action.
1373 Dygraph
.addEvent(document
, 'mouseup', function(event
) {
1374 if (context
.isZooming
|| context
.isPanning
) {
1375 context
.isZooming
= false;
1376 context
.dragStartX
= null;
1377 context
.dragStartY
= null;
1380 if (context
.isPanning
) {
1381 context
.isPanning
= false;
1382 context
.draggingDate
= null;
1383 context
.dateRange
= null;
1384 for (var i
= 0; i
< self
.axes_
.length
; i
++) {
1385 delete self
.axes_
[i
].draggingValue
;
1386 delete self
.axes_
[i
].dragValueRange
;
1394 * Draw a gray zoom rectangle over the desired area of the canvas. Also clears
1395 * up any previous zoom rectangles that were drawn. This could be optimized to
1396 * avoid extra redrawing, but it's tricky to avoid interactions with the status
1399 * @param {Number} direction the direction of the zoom rectangle. Acceptable
1400 * values are Dygraph.HORIZONTAL and Dygraph.VERTICAL.
1401 * @param {Number} startX The X position where the drag started, in canvas
1403 * @param {Number} endX The current X position of the drag, in canvas coords.
1404 * @param {Number} startY The Y position where the drag started, in canvas
1406 * @param {Number} endY The current Y position of the drag, in canvas coords.
1407 * @param {Number} prevDirection the value of direction on the previous call to
1408 * this function. Used to avoid excess redrawing
1409 * @param {Number} prevEndX The value of endX on the previous call to this
1410 * function. Used to avoid excess redrawing
1411 * @param {Number} prevEndY The value of endY on the previous call to this
1412 * function. Used to avoid excess redrawing
1415 Dygraph
.prototype.drawZoomRect_
= function(direction
, startX
, endX
, startY
,
1416 endY
, prevDirection
, prevEndX
,
1418 var ctx
= this.canvas_ctx_
;
1420 // Clean up from the previous rect if necessary
1421 if (prevDirection
== Dygraph
.HORIZONTAL
) {
1422 ctx
.clearRect(Math
.min(startX
, prevEndX
), 0,
1423 Math
.abs(startX
- prevEndX
), this.height_
);
1424 } else if (prevDirection
== Dygraph
.VERTICAL
){
1425 ctx
.clearRect(0, Math
.min(startY
, prevEndY
),
1426 this.width_
, Math
.abs(startY
- prevEndY
));
1429 // Draw a light-grey rectangle to show the new viewing area
1430 if (direction
== Dygraph
.HORIZONTAL
) {
1431 if (endX
&& startX
) {
1432 ctx
.fillStyle
= "rgba(128,128,128,0.33)";
1433 ctx
.fillRect(Math
.min(startX
, endX
), 0,
1434 Math
.abs(endX
- startX
), this.height_
);
1437 if (direction
== Dygraph
.VERTICAL
) {
1438 if (endY
&& startY
) {
1439 ctx
.fillStyle
= "rgba(128,128,128,0.33)";
1440 ctx
.fillRect(0, Math
.min(startY
, endY
),
1441 this.width_
, Math
.abs(endY
- startY
));
1447 * Zoom to something containing [lowX, highX]. These are pixel coordinates in
1448 * the canvas. The exact zoom window may be slightly larger if there are no data
1449 * points near lowX or highX. Don't confuse this function with doZoomXDates,
1450 * which accepts dates that match the raw data. This function redraws the graph.
1452 * @param {Number} lowX The leftmost pixel value that should be visible.
1453 * @param {Number} highX The rightmost pixel value that should be visible.
1456 Dygraph
.prototype.doZoomX_
= function(lowX
, highX
) {
1457 // Find the earliest and latest dates contained in this canvasx range.
1458 // Convert the call to date ranges of the raw data.
1459 var minDate
= this.toDataXCoord(lowX
);
1460 var maxDate
= this.toDataXCoord(highX
);
1461 this.doZoomXDates_(minDate
, maxDate
);
1465 * Zoom to something containing [minDate, maxDate] values. Don't confuse this
1466 * method with doZoomX which accepts pixel coordinates. This function redraws
1469 * @param {Number} minDate The minimum date that should be visible.
1470 * @param {Number} maxDate The maximum date that should be visible.
1473 Dygraph
.prototype.doZoomXDates_
= function(minDate
, maxDate
) {
1474 this.dateWindow_
= [minDate
, maxDate
];
1475 this.zoomed_x_
= true;
1477 if (this.attr_("zoomCallback")) {
1478 this.attr_("zoomCallback")(minDate
, maxDate
, this.yAxisRanges());
1483 * Zoom to something containing [lowY, highY]. These are pixel coordinates in
1484 * the canvas. This function redraws the graph.
1486 * @param {Number} lowY The topmost pixel value that should be visible.
1487 * @param {Number} highY The lowest pixel value that should be visible.
1490 Dygraph
.prototype.doZoomY_
= function(lowY
, highY
) {
1491 // Find the highest and lowest values in pixel range for each axis.
1492 // Note that lowY (in pixels) corresponds to the max Value (in data coords).
1493 // This is because pixels increase as you go down on the screen, whereas data
1494 // coordinates increase as you go up the screen.
1495 var valueRanges
= [];
1496 for (var i
= 0; i
< this.axes_
.length
; i
++) {
1497 var hi
= this.toDataYCoord(lowY
, i
);
1498 var low
= this.toDataYCoord(highY
, i
);
1499 this.axes_
[i
].valueWindow
= [low
, hi
];
1500 valueRanges
.push([low
, hi
]);
1503 this.zoomed_y_
= true;
1505 if (this.attr_("zoomCallback")) {
1506 var xRange
= this.xAxisRange();
1507 var yRange
= this.yAxisRange();
1508 this.attr_("zoomCallback")(xRange
[0], xRange
[1], this.yAxisRanges());
1513 * Reset the zoom to the original view coordinates. This is the same as
1514 * double-clicking on the graph.
1518 Dygraph
.prototype.doUnzoom_
= function() {
1520 if (this.dateWindow_
!= null) {
1522 this.dateWindow_
= null;
1525 for (var i
= 0; i
< this.axes_
.length
; i
++) {
1526 if (this.axes_
[i
].valueWindow
!= null) {
1528 delete this.axes_
[i
].valueWindow
;
1533 // Putting the drawing operation before the callback because it resets
1535 this.zoomed_x_
= false;
1536 this.zoomed_y_
= false;
1538 if (this.attr_("zoomCallback")) {
1539 var minDate
= this.rawData_
[0][0];
1540 var maxDate
= this.rawData_
[this.rawData_
.length
- 1][0];
1541 this.attr_("zoomCallback")(minDate
, maxDate
, this.yAxisRanges());
1547 * When the mouse moves in the canvas, display information about a nearby data
1548 * point and draw dots over those points in the data series. This function
1549 * takes care of cleanup of previously-drawn dots.
1550 * @param {Object} event The mousemove event from the browser.
1553 Dygraph
.prototype.mouseMove_
= function(event
) {
1554 // This prevents JS errors when mousing over the canvas before data loads.
1555 var points
= this.layout_
.points
;
1556 if (points
=== undefined
) return;
1558 var canvasx
= Dygraph
.pageX(event
) - Dygraph
.findPosX(this.mouseEventElement_
);
1563 // Loop through all the points and find the date nearest to our current
1565 var minDist
= 1e+100;
1567 for (var i
= 0; i
< points
.length
; i
++) {
1568 var point
= points
[i
];
1569 if (point
== null) continue;
1570 var dist
= Math
.abs(point
.canvasx
- canvasx
);
1571 if (dist
> minDist
) continue;
1575 if (idx
>= 0) lastx
= points
[idx
].xval
;
1577 // Extract the points we've selected
1578 this.selPoints_
= [];
1579 var l
= points
.length
;
1580 if (!this.attr_("stackedGraph")) {
1581 for (var i
= 0; i
< l
; i
++) {
1582 if (points
[i
].xval
== lastx
) {
1583 this.selPoints_
.push(points
[i
]);
1587 // Need to 'unstack' points starting from the bottom
1588 var cumulative_sum
= 0;
1589 for (var i
= l
- 1; i
>= 0; i
--) {
1590 if (points
[i
].xval
== lastx
) {
1591 var p
= {}; // Clone the point since we modify it
1592 for (var k
in points
[i
]) {
1593 p
[k
] = points
[i
][k
];
1595 p
.yval
-= cumulative_sum
;
1596 cumulative_sum
+= p
.yval
;
1597 this.selPoints_
.push(p
);
1600 this.selPoints_
.reverse();
1603 if (this.attr_("highlightCallback")) {
1604 var px
= this.lastx_
;
1605 if (px
!== null && lastx
!= px
) {
1606 // only fire if the selected point has changed.
1607 this.attr_("highlightCallback")(event
, lastx
, this.selPoints_
, this.idxToRow_(idx
));
1611 // Save last x position for callbacks.
1612 this.lastx_
= lastx
;
1614 this.updateSelection_();
1618 * Transforms layout_.points index into data row number.
1619 * @param int layout_.points index
1620 * @return int row number, or -1 if none could be found.
1623 Dygraph
.prototype.idxToRow_
= function(idx
) {
1624 if (idx
< 0) return -1;
1626 for (var i
in this.layout_
.datasets
) {
1627 if (idx
< this.layout_
.datasets
[i
].length
) {
1628 return this.boundaryIds_
[0][0]+idx
;
1630 idx
-= this.layout_
.datasets
[i
].length
;
1635 // TODO(danvk): rename this function to something like 'isNonZeroNan'.
1636 Dygraph
.isOK
= function(x
) {
1637 return x
&& !isNaN(x
);
1640 Dygraph
.prototype.generateLegendHTML_
= function(x
, sel_points
) {
1641 // If no points are selected, we display a default legend. Traditionally,
1642 // this has been blank. But a better default would be a conventional legend,
1643 // which provides essential information for a non-interactive chart.
1644 if (typeof(x
) === 'undefined') {
1645 if (this.attr_('legend') != 'always') return '';
1647 var sepLines
= this.attr_('labelsSeparateLines');
1648 var labels
= this.attr_('labels');
1650 for (var i
= 1; i
< labels
.length
; i
++) {
1651 if (!this.visibility()[i
- 1]) continue;
1652 var c
= this.plotter_
.colors
[labels
[i
]];
1653 if (html
!= '') html
+= (sepLines
? '<br/>' : ' ');
1654 html
+= "<b><span style='color: " + c
+ ";'>—" + labels
[i
] +
1660 var html
= this.attr_('xValueFormatter')(x
) + ":";
1662 var fmtFunc
= this.attr_('yValueFormatter');
1663 var showZeros
= this.attr_("labelsShowZeroValues");
1664 var sepLines
= this.attr_("labelsSeparateLines");
1665 for (var i
= 0; i
< this.selPoints_
.length
; i
++) {
1666 var pt
= this.selPoints_
[i
];
1667 if (pt
.yval
== 0 && !showZeros
) continue;
1668 if (!Dygraph
.isOK(pt
.canvasy
)) continue;
1669 if (sepLines
) html
+= "<br/>";
1671 var c
= this.plotter_
.colors
[pt
.name
];
1672 var yval
= fmtFunc(pt
.yval
, this);
1673 // TODO(danvk): use a template string here and make it an attribute.
1674 html
+= " <b><span style='color: " + c
+ ";'>"
1675 + pt
.name
+ "</span></b>:"
1681 Dygraph
.prototype.setLegendHTML_
= function(x
, sel_points
) {
1682 var html
= this.generateLegendHTML_(x
, sel_points
);
1683 var labelsDiv
= this.attr_("labelsDiv");
1684 if (labelsDiv
!== null) {
1685 labelsDiv
.innerHTML
= html
;
1687 if (typeof(this.shown_legend_error_
) == 'undefined') {
1688 this.error('labelsDiv is set to something nonexistent; legend will not be shown.');
1689 this.shown_legend_error_
= true;
1695 * Draw dots over the selectied points in the data series. This function
1696 * takes care of cleanup of previously-drawn dots.
1699 Dygraph
.prototype.updateSelection_
= function() {
1700 // Clear the previously drawn vertical, if there is one
1701 var ctx
= this.canvas_ctx_
;
1702 if (this.previousVerticalX_
>= 0) {
1703 // Determine the maximum highlight circle size.
1704 var maxCircleSize
= 0;
1705 var labels
= this.attr_('labels');
1706 for (var i
= 1; i
< labels
.length
; i
++) {
1707 var r
= this.attr_('highlightCircleSize', labels
[i
]);
1708 if (r
> maxCircleSize
) maxCircleSize
= r
;
1710 var px
= this.previousVerticalX_
;
1711 ctx
.clearRect(px
- maxCircleSize
- 1, 0,
1712 2 * maxCircleSize
+ 2, this.height_
);
1715 if (this.selPoints_
.length
> 0) {
1716 // Set the status message to indicate the selected point(s)
1717 if (this.attr_('showLabelsOnHighlight')) {
1718 this.setLegendHTML_(this.lastx_
, this.selPoints_
);
1721 // Draw colored circles over the center of each selected point
1722 var canvasx
= this.selPoints_
[0].canvasx
;
1724 for (var i
= 0; i
< this.selPoints_
.length
; i
++) {
1725 var pt
= this.selPoints_
[i
];
1726 if (!Dygraph
.isOK(pt
.canvasy
)) continue;
1728 var circleSize
= this.attr_('highlightCircleSize', pt
.name
);
1730 ctx
.fillStyle
= this.plotter_
.colors
[pt
.name
];
1731 ctx
.arc(canvasx
, pt
.canvasy
, circleSize
, 0, 2 * Math
.PI
, false);
1736 this.previousVerticalX_
= canvasx
;
1741 * Set manually set selected dots, and display information about them
1742 * @param int row number that should by highlighted
1743 * false value clears the selection
1746 Dygraph
.prototype.setSelection
= function(row
) {
1747 // Extract the points we've selected
1748 this.selPoints_
= [];
1751 if (row
!== false) {
1752 row
= row
-this.boundaryIds_
[0][0];
1755 if (row
!== false && row
>= 0) {
1756 for (var i
in this.layout_
.datasets
) {
1757 if (row
< this.layout_
.datasets
[i
].length
) {
1758 var point
= this.layout_
.points
[pos
+row
];
1760 if (this.attr_("stackedGraph")) {
1761 point
= this.layout_
.unstackPointAtIndex(pos
+row
);
1764 this.selPoints_
.push(point
);
1766 pos
+= this.layout_
.datasets
[i
].length
;
1770 if (this.selPoints_
.length
) {
1771 this.lastx_
= this.selPoints_
[0].xval
;
1772 this.updateSelection_();
1774 this.clearSelection();
1780 * The mouse has left the canvas. Clear out whatever artifacts remain
1781 * @param {Object} event the mouseout event from the browser.
1784 Dygraph
.prototype.mouseOut_
= function(event
) {
1785 if (this.attr_("unhighlightCallback")) {
1786 this.attr_("unhighlightCallback")(event
);
1789 if (this.attr_("hideOverlayOnMouseOut")) {
1790 this.clearSelection();
1795 * Remove all selection from the canvas
1798 Dygraph
.prototype.clearSelection
= function() {
1799 // Get rid of the overlay data
1800 this.canvas_ctx_
.clearRect(0, 0, this.width_
, this.height_
);
1801 this.setLegendHTML_();
1802 this.selPoints_
= [];
1807 * Returns the number of the currently selected row
1808 * @return int row number, of -1 if nothing is selected
1811 Dygraph
.prototype.getSelection
= function() {
1812 if (!this.selPoints_
|| this.selPoints_
.length
< 1) {
1816 for (var row
=0; row
<this.layout_
.points
.length
; row
++ ) {
1817 if (this.layout_
.points
[row
].x
== this.selPoints_
[0].x
) {
1818 return row
+ this.boundaryIds_
[0][0];
1825 * Number formatting function which mimicks the behavior of %g in printf, i.e.
1826 * either exponential or fixed format (without trailing 0s) is used depending on
1827 * the length of the generated string. The advantage of this format is that
1828 * there is a predictable upper bound on the resulting string length,
1829 * significant figures are not dropped, and normal numbers are not displayed in
1830 * exponential notation.
1832 * NOTE: JavaScript's native toPrecision() is NOT a drop-in replacement for %g.
1833 * It creates strings which are too long for absolute values between 10^-4 and
1834 * 10^-6, e.g. '0.00001' instead of '1e-5'. See tests/number-format.html for
1837 * @param {Number} x The number to format
1838 * @param {Number} opt_precision The precision to use, default 2.
1839 * @return {String} A string formatted like %g in printf. The max generated
1840 * string length should be precision + 6 (e.g 1.123e+300).
1842 Dygraph
.floatFormat
= function(x
, opt_precision
) {
1843 // Avoid invalid precision values; [1, 21] is the valid range.
1844 var p
= Math
.min(Math
.max(1, opt_precision
|| 2), 21);
1846 // This is deceptively simple. The actual algorithm comes from:
1848 // Max allowed length = p + 4
1849 // where 4 comes from 'e+n' and '.'.
1851 // Length of fixed format = 2 + y + p
1852 // where 2 comes from '0.' and y = # of leading zeroes.
1854 // Equating the two and solving for y yields y = 2, or 0.00xxxx which is
1857 // Since the behavior of toPrecision() is identical for larger numbers, we
1858 // don't have to worry about the other bound.
1860 // Finally, the argument for toExponential() is the number of trailing digits,
1861 // so we take off 1 for the value before the '.'.
1862 return (Math
.abs(x
) < 1.0e-3 && x
!= 0.0) ?
1863 x
.toExponential(p
- 1) : x
.toPrecision(p
);
1867 * Return a string version of a number. This respects the digitsAfterDecimal
1868 * and maxNumberWidth options.
1869 * @param {Number} x The number to be formatted
1870 * @param {Dygraph} g The dygraph object
1872 Dygraph
.numberFormatter
= function(x
, g
) {
1873 var sigFigs
= g
.attr_('sigFigs');
1875 if (sigFigs
!== null) {
1876 // User has opted for a fixed number of significant figures.
1877 return Dygraph
.floatFormat(x
, sigFigs
);
1880 var digits
= g
.attr_('digitsAfterDecimal');
1881 var maxNumberWidth
= g
.attr_('maxNumberWidth');
1883 // switch to scientific notation if we underflow or overflow fixed display.
1885 (Math
.abs(x
) >= Math
.pow(10, maxNumberWidth
) ||
1886 Math
.abs(x
) < Math
.pow(10, -digits
))) {
1887 return x
.toExponential(digits
);
1889 return '' + Dygraph
.round_(x
, digits
);
1893 Dygraph
.zeropad
= function(x
) {
1894 if (x
< 10) return "0" + x
; else return "" + x
;
1898 * Return a string version of the hours, minutes and seconds portion of a date.
1899 * @param {Number} date The JavaScript date (ms since epoch)
1900 * @return {String} A time of the form "HH:MM:SS"
1903 Dygraph
.hmsString_
= function(date
) {
1904 var zeropad
= Dygraph
.zeropad
;
1905 var d
= new Date(date
);
1906 if (d
.getSeconds()) {
1907 return zeropad(d
.getHours()) + ":" +
1908 zeropad(d
.getMinutes()) + ":" +
1909 zeropad(d
.getSeconds());
1911 return zeropad(d
.getHours()) + ":" + zeropad(d
.getMinutes());
1916 * Convert a JS date to a string appropriate to display on an axis that
1917 * is displaying values at the stated granularity.
1918 * @param {Date} date The date to format
1919 * @param {Number} granularity One of the Dygraph granularity constants
1920 * @return {String} The formatted date
1923 Dygraph
.dateAxisFormatter
= function(date
, granularity
) {
1924 if (granularity
>= Dygraph
.DECADAL
) {
1925 return date
.strftime('%Y');
1926 } else if (granularity
>= Dygraph
.MONTHLY
) {
1927 return date
.strftime('%b %y');
1929 var frac
= date
.getHours() * 3600 + date
.getMinutes() * 60 + date
.getSeconds() + date
.getMilliseconds();
1930 if (frac
== 0 || granularity
>= Dygraph
.DAILY
) {
1931 return new Date(date
.getTime() + 3600*1000).strftime('%d%b');
1933 return Dygraph
.hmsString_(date
.getTime());
1939 * Convert a JS date (millis since epoch) to YYYY/MM/DD
1940 * @param {Number} date The JavaScript date (ms since epoch)
1941 * @return {String} A date of the form "YYYY/MM/DD"
1944 Dygraph
.dateString_
= function(date
) {
1945 var zeropad
= Dygraph
.zeropad
;
1946 var d
= new Date(date
);
1949 var year
= "" + d
.getFullYear();
1950 // Get a 0 padded month string
1951 var month
= zeropad(d
.getMonth() + 1); //months are 0-offset, sigh
1952 // Get a 0 padded day string
1953 var day
= zeropad(d
.getDate());
1956 var frac
= d
.getHours() * 3600 + d
.getMinutes() * 60 + d
.getSeconds();
1957 if (frac
) ret
= " " + Dygraph
.hmsString_(date
);
1959 return year
+ "/" + month + "/" + day
+ ret
;
1963 * Round a number to the specified number of digits past the decimal point.
1964 * @param {Number} num The number to round
1965 * @param {Number} places The number of decimals to which to round
1966 * @return {Number} The rounded number
1969 Dygraph
.round_
= function(num
, places
) {
1970 var shift
= Math
.pow(10, places
);
1971 return Math
.round(num
* shift
)/shift
;
1975 * Fires when there's data available to be graphed.
1976 * @param {String} data Raw CSV data to be plotted
1979 Dygraph
.prototype.loadedEvent_
= function(data
) {
1980 this.rawData_
= this.parseCSV_(data
);
1984 Dygraph
.prototype.months
= ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
1985 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
1986 Dygraph
.prototype.quarters
= ["Jan", "Apr", "Jul", "Oct"];
1989 * Add ticks on the x-axis representing years, months, quarters, weeks, or days
1992 Dygraph
.prototype.addXTicks_
= function() {
1993 // Determine the correct ticks scale on the x-axis: quarterly, monthly, ...
1995 if (this.dateWindow_
) {
1996 range
= [this.dateWindow_
[0], this.dateWindow_
[1]];
1998 range
= [this.rawData_
[0][0], this.rawData_
[this.rawData_
.length
- 1][0]];
2001 var xTicks
= this.attr_('xTicker')(range
[0], range
[1], this);
2002 this.layout_
.updateOptions({xTicks
: xTicks
});
2005 // Time granularity enumeration
2006 Dygraph
.SECONDLY
= 0;
2007 Dygraph
.TWO_SECONDLY
= 1;
2008 Dygraph
.FIVE_SECONDLY
= 2;
2009 Dygraph
.TEN_SECONDLY
= 3;
2010 Dygraph
.THIRTY_SECONDLY
= 4;
2011 Dygraph
.MINUTELY
= 5;
2012 Dygraph
.TWO_MINUTELY
= 6;
2013 Dygraph
.FIVE_MINUTELY
= 7;
2014 Dygraph
.TEN_MINUTELY
= 8;
2015 Dygraph
.THIRTY_MINUTELY
= 9;
2016 Dygraph
.HOURLY
= 10;
2017 Dygraph
.TWO_HOURLY
= 11;
2018 Dygraph
.SIX_HOURLY
= 12;
2020 Dygraph
.WEEKLY
= 14;
2021 Dygraph
.MONTHLY
= 15;
2022 Dygraph
.QUARTERLY
= 16;
2023 Dygraph
.BIANNUAL
= 17;
2024 Dygraph
.ANNUAL
= 18;
2025 Dygraph
.DECADAL
= 19;
2026 Dygraph
.CENTENNIAL
= 20;
2027 Dygraph
.NUM_GRANULARITIES
= 21;
2029 Dygraph
.SHORT_SPACINGS
= [];
2030 Dygraph
.SHORT_SPACINGS
[Dygraph
.SECONDLY
] = 1000 * 1;
2031 Dygraph
.SHORT_SPACINGS
[Dygraph
.TWO_SECONDLY
] = 1000 * 2;
2032 Dygraph
.SHORT_SPACINGS
[Dygraph
.FIVE_SECONDLY
] = 1000 * 5;
2033 Dygraph
.SHORT_SPACINGS
[Dygraph
.TEN_SECONDLY
] = 1000 * 10;
2034 Dygraph
.SHORT_SPACINGS
[Dygraph
.THIRTY_SECONDLY
] = 1000 * 30;
2035 Dygraph
.SHORT_SPACINGS
[Dygraph
.MINUTELY
] = 1000 * 60;
2036 Dygraph
.SHORT_SPACINGS
[Dygraph
.TWO_MINUTELY
] = 1000 * 60 * 2;
2037 Dygraph
.SHORT_SPACINGS
[Dygraph
.FIVE_MINUTELY
] = 1000 * 60 * 5;
2038 Dygraph
.SHORT_SPACINGS
[Dygraph
.TEN_MINUTELY
] = 1000 * 60 * 10;
2039 Dygraph
.SHORT_SPACINGS
[Dygraph
.THIRTY_MINUTELY
] = 1000 * 60 * 30;
2040 Dygraph
.SHORT_SPACINGS
[Dygraph
.HOURLY
] = 1000 * 3600;
2041 Dygraph
.SHORT_SPACINGS
[Dygraph
.TWO_HOURLY
] = 1000 * 3600 * 2;
2042 Dygraph
.SHORT_SPACINGS
[Dygraph
.SIX_HOURLY
] = 1000 * 3600 * 6;
2043 Dygraph
.SHORT_SPACINGS
[Dygraph
.DAILY
] = 1000 * 86400;
2044 Dygraph
.SHORT_SPACINGS
[Dygraph
.WEEKLY
] = 1000 * 604800;
2048 // If we used this time granularity, how many ticks would there be?
2049 // This is only an approximation, but it's generally good enough.
2051 Dygraph
.prototype.NumXTicks
= function(start_time
, end_time
, granularity
) {
2052 if (granularity
< Dygraph
.MONTHLY
) {
2053 // Generate one tick mark for every fixed interval of time.
2054 var spacing
= Dygraph
.SHORT_SPACINGS
[granularity
];
2055 return Math
.floor(0.5 + 1.0 * (end_time
- start_time
) / spacing
);
2057 var year_mod
= 1; // e.g. to only print one point every 10 years.
2058 var num_months
= 12;
2059 if (granularity
== Dygraph
.QUARTERLY
) num_months
= 3;
2060 if (granularity
== Dygraph
.BIANNUAL
) num_months
= 2;
2061 if (granularity
== Dygraph
.ANNUAL
) num_months
= 1;
2062 if (granularity
== Dygraph
.DECADAL
) { num_months
= 1; year_mod
= 10; }
2063 if (granularity
== Dygraph
.CENTENNIAL
) { num_months
= 1; year_mod
= 100; }
2065 var msInYear
= 365.2524 * 24 * 3600 * 1000;
2066 var num_years
= 1.0 * (end_time
- start_time
) / msInYear
;
2067 return Math
.floor(0.5 + 1.0 * num_years
* num_months
/ year_mod
);
2073 // Construct an x-axis of nicely-formatted times on meaningful boundaries
2074 // (e.g. 'Jan 09' rather than 'Jan 22, 2009').
2076 // Returns an array containing {v: millis, label: label} dictionaries.
2078 Dygraph
.prototype.GetXAxis
= function(start_time
, end_time
, granularity
) {
2079 var formatter
= this.attr_("xAxisLabelFormatter");
2081 if (granularity
< Dygraph
.MONTHLY
) {
2082 // Generate one tick mark for every fixed interval of time.
2083 var spacing
= Dygraph
.SHORT_SPACINGS
[granularity
];
2084 var format
= '%d%b'; // e.g. "1Jan"
2086 // Find a time less than start_time which occurs on a "nice" time boundary
2087 // for this granularity.
2088 var g
= spacing
/ 1000;
2089 var d
= new Date(start_time
);
2090 if (g
<= 60) { // seconds
2091 var x
= d
.getSeconds(); d
.setSeconds(x
- x
% g
);
2095 if (g
<= 60) { // minutes
2096 var x
= d
.getMinutes(); d
.setMinutes(x
- x
% g
);
2101 if (g
<= 24) { // days
2102 var x
= d
.getHours(); d
.setHours(x
- x
% g
);
2107 if (g
== 7) { // one week
2108 d
.setDate(d
.getDate() - d
.getDay());
2113 start_time
= d
.getTime();
2115 for (var t
= start_time
; t
<= end_time
; t
+= spacing
) {
2116 ticks
.push({ v
:t
, label
: formatter(new Date(t
), granularity
) });
2119 // Display a tick mark on the first of a set of months of each year.
2120 // Years get a tick mark iff y % year_mod == 0. This is useful for
2121 // displaying a tick mark once every 10 years, say, on long time scales.
2123 var year_mod
= 1; // e.g. to only print one point every 10 years.
2125 if (granularity
== Dygraph
.MONTHLY
) {
2126 months
= [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ];
2127 } else if (granularity
== Dygraph
.QUARTERLY
) {
2128 months
= [ 0, 3, 6, 9 ];
2129 } else if (granularity
== Dygraph
.BIANNUAL
) {
2131 } else if (granularity
== Dygraph
.ANNUAL
) {
2133 } else if (granularity
== Dygraph
.DECADAL
) {
2136 } else if (granularity
== Dygraph
.CENTENNIAL
) {
2140 this.warn("Span of dates is too long");
2143 var start_year
= new Date(start_time
).getFullYear();
2144 var end_year
= new Date(end_time
).getFullYear();
2145 var zeropad
= Dygraph
.zeropad
;
2146 for (var i
= start_year
; i
<= end_year
; i
++) {
2147 if (i
% year_mod
!= 0) continue;
2148 for (var j
= 0; j
< months
.length
; j
++) {
2149 var date_str
= i
+ "/" + zeropad(1 + months[j]) + "/01";
2150 var t
= Dygraph
.dateStrToMillis(date_str
);
2151 if (t
< start_time
|| t
> end_time
) continue;
2152 ticks
.push({ v
:t
, label
: formatter(new Date(t
), granularity
) });
2162 * Add ticks to the x-axis based on a date range.
2163 * @param {Number} startDate Start of the date window (millis since epoch)
2164 * @param {Number} endDate End of the date window (millis since epoch)
2165 * @return {Array.<Object>} Array of {label, value} tuples.
2168 Dygraph
.dateTicker
= function(startDate
, endDate
, self
) {
2170 for (var i
= 0; i
< Dygraph
.NUM_GRANULARITIES
; i
++) {
2171 var num_ticks
= self
.NumXTicks(startDate
, endDate
, i
);
2172 if (self
.width_
/ num_ticks
>= self
.attr_('pixelsPerXLabel')) {
2179 return self
.GetXAxis(startDate
, endDate
, chosen
);
2181 // TODO(danvk): signal error.
2185 // This is a list of human-friendly values at which to show tick marks on a log
2186 // scale. It is k * 10^n, where k=1..9 and n=-39..+39, so:
2187 // ..., 1, 2, 3, 4, 5, ..., 9, 10, 20, 30, ..., 90, 100, 200, 300, ...
2188 // NOTE: this assumes that Dygraph.LOG_SCALE = 10.
2189 Dygraph
.PREFERRED_LOG_TICK_VALUES
= function() {
2191 for (var power
= -39; power
<= 39; power
++) {
2192 var range
= Math
.pow(10, power
);
2193 for (var mult
= 1; mult
<= 9; mult
++) {
2194 var val
= range
* mult
;
2201 // val is the value to search for
2202 // arry is the value over which to search
2203 // if abs > 0, find the lowest entry greater than val
2204 // if abs < 0, find the highest entry less than val
2205 // if abs == 0, find the entry that equals val.
2206 // Currently does not work when val is outside the range of arry's values.
2207 Dygraph
.binarySearch
= function(val
, arry
, abs
, low
, high
) {
2208 if (low
== null || high
== null) {
2210 high
= arry
.length
- 1;
2218 var validIndex
= function(idx
) {
2219 return idx
>= 0 && idx
< arry
.length
;
2221 var mid
= parseInt((low
+ high
) / 2);
2222 var element
= arry
[mid
];
2223 if (element
== val
) {
2226 if (element
> val
) {
2228 // Accept if element > val, but also if prior element < val.
2230 if (validIndex(idx
) && arry
[idx
] < val
) {
2234 return Dygraph
.binarySearch(val
, arry
, abs
, low
, mid
- 1);
2236 if (element
< val
) {
2238 // Accept if element < val, but also if prior element > val.
2240 if (validIndex(idx
) && arry
[idx
] > val
) {
2244 return Dygraph
.binarySearch(val
, arry
, abs
, mid
+ 1, high
);
2249 * Add ticks when the x axis has numbers on it (instead of dates)
2250 * TODO(konigsberg): Update comment.
2252 * @param {Number} minV minimum value
2253 * @param {Number} maxV maximum value
2255 * @param {function} attribute accessor function.
2256 * @return {Array.<Object>} Array of {label, value} tuples.
2259 Dygraph
.numericTicks
= function(minV
, maxV
, self
, axis_props
, vals
) {
2260 var attr
= function(k
) {
2261 if (axis_props
&& axis_props
.hasOwnProperty(k
)) return axis_props
[k
];
2262 return self
.attr_(k
);
2267 for (var i
= 0; i
< vals
.length
; i
++) {
2268 ticks
.push({v
: vals
[i
]});
2271 if (axis_props
&& attr("logscale")) {
2272 var pixelsPerTick
= attr('pixelsPerYLabel');
2273 // NOTE(konigsberg): Dan, should self.height_ be self.plotter_.area.h?
2274 var nTicks
= Math
.floor(self
.height_
/ pixelsPerTick
);
2275 var minIdx
= Dygraph
.binarySearch(minV
, Dygraph
.PREFERRED_LOG_TICK_VALUES
, 1);
2276 var maxIdx
= Dygraph
.binarySearch(maxV
, Dygraph
.PREFERRED_LOG_TICK_VALUES
, -1);
2281 maxIdx
= Dygraph
.PREFERRED_LOG_TICK_VALUES
.length
- 1;
2283 // Count the number of tick values would appear, if we can get at least
2284 // nTicks / 4 accept them
.
2285 var lastDisplayed
= null;
2286 if (maxIdx
- minIdx
>= nTicks
/ 4) {
2287 var axisId
= axis_props
.yAxisId
;
2288 for (var idx
= maxIdx
; idx
>= minIdx
; idx
--) {
2289 var tickValue
= Dygraph
.PREFERRED_LOG_TICK_VALUES
[idx
];
2290 var domCoord
= axis_props
.g
.toDomYCoord(tickValue
, axisId
);
2291 var tick
= { v
: tickValue
};
2292 if (lastDisplayed
== null) {
2294 tickValue
: tickValue
,
2298 if (domCoord
- lastDisplayed
.domCoord
>= pixelsPerTick
) {
2300 tickValue
: tickValue
,
2309 // Since we went in backwards order.
2314 // ticks.length won't be 0 if the log scale function finds values to insert.
2315 if (ticks
.length
== 0) {
2317 // Try labels every 1, 2, 5, 10, 20, 50, 100, etc.
2318 // Calculate the resulting tick spacing (i.e. this.height_ / nTicks
).
2319 // The first spacing greater than pixelsPerYLabel is what we use.
2320 // TODO(danvk): version that works on a log scale.
2321 if (attr("labelsKMG2")) {
2322 var mults
= [1, 2, 4, 8];
2324 var mults
= [1, 2, 5];
2326 var scale
, low_val
, high_val
, nTicks
;
2327 // TODO(danvk): make it possible to set this for x- and y-axes independently.
2328 var pixelsPerTick
= attr('pixelsPerYLabel');
2329 for (var i
= -10; i
< 50; i
++) {
2330 if (attr("labelsKMG2")) {
2331 var base_scale
= Math
.pow(16, i
);
2333 var base_scale
= Math
.pow(10, i
);
2335 for (var j
= 0; j
< mults
.length
; j
++) {
2336 scale
= base_scale
* mults
[j
];
2337 low_val
= Math
.floor(minV
/ scale
) * scale
;
2338 high_val
= Math
.ceil(maxV
/ scale
) * scale
;
2339 nTicks
= Math
.abs(high_val
- low_val
) / scale
;
2340 var spacing
= self
.height_
/ nTicks
;
2341 // wish I could break out of both loops at once...
2342 if (spacing
> pixelsPerTick
) break;
2344 if (spacing
> pixelsPerTick
) break;
2347 // Construct the set of ticks.
2348 // Allow reverse y-axis if it's explicitly requested.
2349 if (low_val
> high_val
) scale
*= -1;
2350 for (var i
= 0; i
< nTicks
; i
++) {
2351 var tickV
= low_val
+ i
* scale
;
2352 ticks
.push( {v
: tickV
} );
2357 // Add formatted labels to the ticks.
2360 if (attr("labelsKMB")) {
2362 k_labels
= [ "K", "M", "B", "T" ];
2364 if (attr("labelsKMG2")) {
2365 if (k
) self
.warn("Setting both labelsKMB and labelsKMG2. Pick one!");
2367 k_labels
= [ "k", "M", "G", "T" ];
2369 var formatter
= attr('yAxisLabelFormatter') ?
2370 attr('yAxisLabelFormatter') : attr('yValueFormatter');
2372 // Add labels to the ticks.
2373 for (var i
= 0; i
< ticks
.length
; i
++) {
2374 if (ticks
[i
].label
!== undefined
) continue; // Use current label.
2375 var tickV
= ticks
[i
].v
;
2376 var absTickV
= Math
.abs(tickV
);
2377 var label
= formatter(tickV
, self
);
2378 if (k_labels
.length
> 0) {
2379 // Round up to an appropriate unit.
2381 for (var j
= 3; j
>= 0; j
--, n
/= k
) {
2382 if (absTickV
>= n
) {
2383 label
= Dygraph
.round_(tickV
/ n
, attr('digitsAfterDecimal')) + k_labels
[j
];
2388 ticks
[i
].label
= label
;
2394 // Computes the range of the data series (including confidence intervals).
2395 // series is either [ [x1, y1], [x2, y2], ... ] or
2396 // [ [x1, [y1, dev_low, dev_high]], [x2, [y2, dev_low, dev_high]], ...
2397 // Returns [low, high]
2398 Dygraph
.prototype.extremeValues_
= function(series
) {
2399 var minY
= null, maxY
= null;
2401 var bars
= this.attr_("errorBars") || this.attr_("customBars");
2403 // With custom bars, maxY is the max of the high values.
2404 for (var j
= 0; j
< series
.length
; j
++) {
2405 var y
= series
[j
][1][0];
2407 var low
= y
- series
[j
][1][1];
2408 var high
= y
+ series
[j
][1][2];
2409 if (low
> y
) low
= y
; // this can happen with custom bars,
2410 if (high
< y
) high
= y
; // e.g. in tests/custom-bars
.html
2411 if (maxY
== null || high
> maxY
) {
2414 if (minY
== null || low
< minY
) {
2419 for (var j
= 0; j
< series
.length
; j
++) {
2420 var y
= series
[j
][1];
2421 if (y
=== null || isNaN(y
)) continue;
2422 if (maxY
== null || y
> maxY
) {
2425 if (minY
== null || y
< minY
) {
2431 return [minY
, maxY
];
2435 * This function is called once when the chart's data is changed or the options
2436 * dictionary is updated. It is _not_ called when the user pans or zooms. The
2437 * idea is that values derived from the chart's data can be computed here,
2438 * rather than every time the chart is drawn. This includes things like the
2439 * number of axes, rolling averages, etc.
2441 Dygraph
.prototype.predraw_
= function() {
2442 // TODO(danvk): move more computations out of drawGraph_ and into here.
2443 this.computeYAxes_();
2445 // Create a new plotter.
2446 if (this.plotter_
) this.plotter_
.clear();
2447 this.plotter_
= new DygraphCanvasRenderer(this,
2451 this.renderOptions_
);
2453 // The roller sits in the bottom left corner of the chart. We don't know where
2454 // this will be until the options are available, so it's positioned here.
2455 this.createRollInterface_();
2457 // Same thing applies for the labelsDiv. It's right edge should be flush with
2458 // the right edge of the charting area (which may not be the same as the right
2459 // edge of the div, if we have two y-axes.
2460 this.positionLabelsDiv_();
2462 // If the data or options have changed, then we'd better redraw.
2467 * Update the graph with new data. This method is called when the viewing area
2468 * has changed. If the underlying data or options have changed, predraw_ will
2469 * be called before drawGraph_ is called.
2472 Dygraph
.prototype.drawGraph_
= function() {
2473 var data
= this.rawData_
;
2475 // This is used to set the second parameter to drawCallback, below.
2476 var is_initial_draw
= this.is_initial_draw_
;
2477 this.is_initial_draw_
= false;
2479 var minY
= null, maxY
= null;
2480 this.layout_
.removeAllDatasets();
2482 this.attrs_
['pointSize'] = 0.5 * this.attr_('highlightCircleSize');
2484 // Loop over the fields (series). Go from the last to the first,
2485 // because if they're stacked that's how we accumulate the values.
2487 var cumulative_y
= []; // For stacked series.
2490 var extremes
= {}; // series name -> [low, high]
2492 // Loop over all fields and create datasets
2493 for (var i
= data
[0].length
- 1; i
>= 1; i
--) {
2494 if (!this.visibility()[i
- 1]) continue;
2496 var seriesName
= this.attr_("labels")[i
];
2497 var connectSeparatedPoints
= this.attr_('connectSeparatedPoints', i
);
2498 var logScale
= this.attr_('logscale', i
);
2501 for (var j
= 0; j
< data
.length
; j
++) {
2502 var date
= data
[j
][0];
2503 var point
= data
[j
][i
];
2505 // On the log scale, points less than zero do not exist.
2506 // This will create a gap in the chart. Note that this ignores
2507 // connectSeparatedPoints.
2511 series
.push([date
, point
]);
2513 if (point
!= null || !connectSeparatedPoints
) {
2514 series
.push([date
, point
]);
2519 // TODO(danvk): move this into predraw_. It's insane to do it here.
2520 series
= this.rollingAverage(series
, this.rollPeriod_
);
2522 // Prune down to the desired range, if necessary (for zooming)
2523 // Because there can be lines going to points outside of the visible area,
2524 // we actually prune to visible points, plus one on either side.
2525 var bars
= this.attr_("errorBars") || this.attr_("customBars");
2526 if (this.dateWindow_
) {
2527 var low
= this.dateWindow_
[0];
2528 var high
= this.dateWindow_
[1];
2530 // TODO(danvk): do binary search instead of linear search.
2531 // TODO(danvk): pass firstIdx and lastIdx directly to the renderer.
2532 var firstIdx
= null, lastIdx
= null;
2533 for (var k
= 0; k
< series
.length
; k
++) {
2534 if (series
[k
][0] >= low
&& firstIdx
=== null) {
2537 if (series
[k
][0] <= high
) {
2541 if (firstIdx
=== null) firstIdx
= 0;
2542 if (firstIdx
> 0) firstIdx
--;
2543 if (lastIdx
=== null) lastIdx
= series
.length
- 1;
2544 if (lastIdx
< series
.length
- 1) lastIdx
++;
2545 this.boundaryIds_
[i
-1] = [firstIdx
, lastIdx
];
2546 for (var k
= firstIdx
; k
<= lastIdx
; k
++) {
2547 pruned
.push(series
[k
]);
2551 this.boundaryIds_
[i
-1] = [0, series
.length
-1];
2554 var seriesExtremes
= this.extremeValues_(series
);
2557 for (var j
=0; j
<series
.length
; j
++) {
2558 val
= [series
[j
][0], series
[j
][1][0], series
[j
][1][1], series
[j
][1][2]];
2561 } else if (this.attr_("stackedGraph")) {
2562 var l
= series
.length
;
2564 for (var j
= 0; j
< l
; j
++) {
2565 // If one data set has a NaN, let all subsequent stacked
2566 // sets inherit the NaN -- only start at 0 for the first set.
2567 var x
= series
[j
][0];
2568 if (cumulative_y
[x
] === undefined
) {
2569 cumulative_y
[x
] = 0;
2572 actual_y
= series
[j
][1];
2573 cumulative_y
[x
] += actual_y
;
2575 series
[j
] = [x
, cumulative_y
[x
]]
2577 if (cumulative_y
[x
] > seriesExtremes
[1]) {
2578 seriesExtremes
[1] = cumulative_y
[x
];
2580 if (cumulative_y
[x
] < seriesExtremes
[0]) {
2581 seriesExtremes
[0] = cumulative_y
[x
];
2585 extremes
[seriesName
] = seriesExtremes
;
2587 datasets
[i
] = series
;
2590 for (var i
= 1; i
< datasets
.length
; i
++) {
2591 if (!this.visibility()[i
- 1]) continue;
2592 this.layout_
.addDataset(this.attr_("labels")[i
], datasets
[i
]);
2595 this.computeYAxisRanges_(extremes
);
2596 this.layout_
.updateOptions( { yAxes
: this.axes_
,
2597 seriesToAxisMap
: this.seriesToAxisMap_
2601 // Save the X axis zoomed status as the updateOptions call will tend to set it errorneously
2602 var tmp_zoomed_x
= this.zoomed_x_
;
2603 // Tell PlotKit to use this new data and render itself
2604 this.layout_
.updateOptions({dateWindow
: this.dateWindow_
});
2605 this.zoomed_x_
= tmp_zoomed_x
;
2606 this.layout_
.evaluateWithError();
2607 this.plotter_
.clear();
2608 this.plotter_
.render();
2609 this.canvas_
.getContext('2d').clearRect(0, 0, this.canvas_
.width
,
2610 this.canvas_
.height
);
2612 if (is_initial_draw
) {
2613 // Generate a static legend before any particular point is selected.
2614 this.setLegendHTML_();
2616 if (typeof(this.selPoints_
) !== 'undefined' && this.selPoints_
.length
) {
2617 this.lastx_
= this.selPoints_
[0].xval
;
2618 this.updateSelection_();
2620 this.clearSelection();
2624 if (this.attr_("drawCallback") !== null) {
2625 this.attr_("drawCallback")(this, is_initial_draw
);
2630 * Determine properties of the y-axes which are independent of the data
2631 * currently being displayed. This includes things like the number of axes and
2632 * the style of the axes. It does not include the range of each axis and its
2634 * This fills in this.axes_ and this.seriesToAxisMap_.
2635 * axes_ = [ { options } ]
2636 * seriesToAxisMap_ = { seriesName: 0, seriesName2: 1, ... }
2637 * indices are into the axes_ array.
2639 Dygraph
.prototype.computeYAxes_
= function() {
2641 if (this.axes_
!= undefined
) {
2642 // Preserve valueWindow settings.
2644 for (var index
= 0; index
< this.axes_
.length
; index
++) {
2645 valueWindows
.push(this.axes_
[index
].valueWindow
);
2649 this.axes_
= [{ yAxisId
: 0, g
: this }]; // always have at least one y-axis.
2650 this.seriesToAxisMap_
= {};
2652 // Get a list of series names.
2653 var labels
= this.attr_("labels");
2655 for (var i
= 1; i
< labels
.length
; i
++) series
[labels
[i
]] = (i
- 1);
2657 // all options which could be applied per-axis:
2665 'axisLabelFontSize',
2670 // Copy global axis options over to the first axis.
2671 for (var i
= 0; i
< axisOptions
.length
; i
++) {
2672 var k
= axisOptions
[i
];
2673 var v
= this.attr_(k
);
2674 if (v
) this.axes_
[0][k
] = v
;
2677 // Go through once and add all the axes.
2678 for (var seriesName
in series
) {
2679 if (!series
.hasOwnProperty(seriesName
)) continue;
2680 var axis
= this.attr_("axis", seriesName
);
2682 this.seriesToAxisMap_
[seriesName
] = 0;
2685 if (typeof(axis
) == 'object') {
2686 // Add a new axis, making a copy of its per-axis options.
2688 Dygraph
.update(opts
, this.axes_
[0]);
2689 Dygraph
.update(opts
, { valueRange
: null }); // shouldn't inherit this.
2690 var yAxisId
= this.axes_
.length
;
2691 opts
.yAxisId
= yAxisId
;
2693 Dygraph
.update(opts
, axis
);
2694 this.axes_
.push(opts
);
2695 this.seriesToAxisMap_
[seriesName
] = yAxisId
;
2699 // Go through one more time and assign series to an axis defined by another
2700 // series, e.g. { 'Y1: { axis: {} }, 'Y2': { axis: 'Y1' } }
2701 for (var seriesName
in series
) {
2702 if (!series
.hasOwnProperty(seriesName
)) continue;
2703 var axis
= this.attr_("axis", seriesName
);
2704 if (typeof(axis
) == 'string') {
2705 if (!this.seriesToAxisMap_
.hasOwnProperty(axis
)) {
2706 this.error("Series " + seriesName
+ " wants to share a y-axis with " +
2707 "series " + axis
+ ", which does not define its own axis.");
2710 var idx
= this.seriesToAxisMap_
[axis
];
2711 this.seriesToAxisMap_
[seriesName
] = idx
;
2715 // Now we remove series from seriesToAxisMap_ which are not visible. We do
2716 // this last so that hiding the first series doesn't destroy the axis
2717 // properties of the primary axis.
2718 var seriesToAxisFiltered
= {};
2719 var vis
= this.visibility();
2720 for (var i
= 1; i
< labels
.length
; i
++) {
2722 if (vis
[i
- 1]) seriesToAxisFiltered
[s
] = this.seriesToAxisMap_
[s
];
2724 this.seriesToAxisMap_
= seriesToAxisFiltered
;
2726 if (valueWindows
!= undefined
) {
2727 // Restore valueWindow settings.
2728 for (var index
= 0; index
< valueWindows
.length
; index
++) {
2729 this.axes_
[index
].valueWindow
= valueWindows
[index
];
2735 * Returns the number of y-axes on the chart.
2736 * @return {Number} the number of axes.
2738 Dygraph
.prototype.numAxes
= function() {
2740 for (var series
in this.seriesToAxisMap_
) {
2741 if (!this.seriesToAxisMap_
.hasOwnProperty(series
)) continue;
2742 var idx
= this.seriesToAxisMap_
[series
];
2743 if (idx
> last_axis
) last_axis
= idx
;
2745 return 1 + last_axis
;
2749 * Determine the value range and tick marks for each axis.
2750 * @param {Object} extremes A mapping from seriesName -> [low, high]
2751 * This fills in the valueRange and ticks fields in each entry of this.axes_.
2753 Dygraph
.prototype.computeYAxisRanges_
= function(extremes
) {
2754 // Build a map from axis number -> [list of series names]
2755 var seriesForAxis
= [];
2756 for (var series
in this.seriesToAxisMap_
) {
2757 if (!this.seriesToAxisMap_
.hasOwnProperty(series
)) continue;
2758 var idx
= this.seriesToAxisMap_
[series
];
2759 while (seriesForAxis
.length
<= idx
) seriesForAxis
.push([]);
2760 seriesForAxis
[idx
].push(series
);
2763 // Compute extreme values, a span and tick marks for each axis.
2764 for (var i
= 0; i
< this.axes_
.length
; i
++) {
2765 var axis
= this.axes_
[i
];
2767 if (!seriesForAxis
[i
]) {
2768 // If no series are defined or visible then use a reasonable default
2769 axis
.extremeRange
= [0, 1];
2771 // Calculate the extremes of extremes.
2772 var series
= seriesForAxis
[i
];
2773 var minY
= Infinity
; // extremes[series[0]][0];
2774 var maxY
= -Infinity
; // extremes[series[0]][1];
2775 var extremeMinY
, extremeMaxY
;
2776 for (var j
= 0; j
< series
.length
; j
++) {
2777 // Only use valid extremes to stop null data series' from corrupting the scale.
2778 extremeMinY
= extremes
[series
[j
]][0];
2779 if (extremeMinY
!= null) {
2780 minY
= Math
.min(extremeMinY
, minY
);
2782 extremeMaxY
= extremes
[series
[j
]][1];
2783 if (extremeMaxY
!= null) {
2784 maxY
= Math
.max(extremeMaxY
, maxY
);
2787 if (axis
.includeZero
&& minY
> 0) minY
= 0;
2789 // Ensure we have a valid scale, otherwise defualt to zero for safety.
2790 if (minY
== Infinity
) minY
= 0;
2791 if (maxY
== -Infinity
) maxY
= 0;
2793 // Add some padding and round up to an integer to be human-friendly.
2794 var span
= maxY
- minY
;
2795 // special case: if we have no sense of scale, use +/-10% of the sole value
.
2796 if (span
== 0) { span
= maxY
; }
2800 if (axis
.logscale
) {
2801 var maxAxisY
= maxY
+ 0.1 * span
;
2802 var minAxisY
= minY
;
2804 var maxAxisY
= maxY
+ 0.1 * span
;
2805 var minAxisY
= minY
- 0.1 * span
;
2807 // Try to include zero and make it minAxisY (or maxAxisY) if it makes sense.
2808 if (!this.attr_("avoidMinZero")) {
2809 if (minAxisY
< 0 && minY
>= 0) minAxisY
= 0;
2810 if (maxAxisY
> 0 && maxY
<= 0) maxAxisY
= 0;
2813 if (this.attr_("includeZero")) {
2814 if (maxY
< 0) maxAxisY
= 0;
2815 if (minY
> 0) minAxisY
= 0;
2818 axis
.extremeRange
= [minAxisY
, maxAxisY
];
2820 if (axis
.valueWindow
) {
2821 // This is only set if the user has zoomed on the y-axis. It is never set
2822 // by a user. It takes precedence over axis.valueRange because, if you set
2823 // valueRange, you'd still expect to be able to pan.
2824 axis
.computedValueRange
= [axis
.valueWindow
[0], axis
.valueWindow
[1]];
2825 } else if (axis
.valueRange
) {
2826 // This is a user-set value range for this axis.
2827 axis
.computedValueRange
= [axis
.valueRange
[0], axis
.valueRange
[1]];
2829 axis
.computedValueRange
= axis
.extremeRange
;
2832 // Add ticks. By default, all axes inherit the tick positions of the
2833 // primary axis. However, if an axis is specifically marked as having
2834 // independent ticks, then that is permissible as well.
2835 if (i
== 0 || axis
.independentTicks
) {
2837 Dygraph
.numericTicks(axis
.computedValueRange
[0],
2838 axis
.computedValueRange
[1],
2842 var p_axis
= this.axes_
[0];
2843 var p_ticks
= p_axis
.ticks
;
2844 var p_scale
= p_axis
.computedValueRange
[1] - p_axis
.computedValueRange
[0];
2845 var scale
= axis
.computedValueRange
[1] - axis
.computedValueRange
[0];
2846 var tick_values
= [];
2847 for (var i
= 0; i
< p_ticks
.length
; i
++) {
2848 var y_frac
= (p_ticks
[i
].v
- p_axis
.computedValueRange
[0]) / p_scale
;
2849 var y_val
= axis
.computedValueRange
[0] + y_frac
* scale
;
2850 tick_values
.push(y_val
);
2854 Dygraph
.numericTicks(axis
.computedValueRange
[0],
2855 axis
.computedValueRange
[1],
2856 this, axis
, tick_values
);
2862 * Calculates the rolling average of a data set.
2863 * If originalData is [label, val], rolls the average of those.
2864 * If originalData is [label, [, it's interpreted as [value, stddev]
2865 * and the roll is returned in the same form, with appropriately reduced
2866 * stddev for each value.
2867 * Note that this is where fractional input (i.e. '5/10') is converted into
2869 * @param {Array} originalData The data in the appropriate format (see above)
2870 * @param {Number} rollPeriod The number of points over which to average the
2873 Dygraph
.prototype.rollingAverage
= function(originalData
, rollPeriod
) {
2874 if (originalData
.length
< 2)
2875 return originalData
;
2876 var rollPeriod
= Math
.min(rollPeriod
, originalData
.length
- 1);
2877 var rollingData
= [];
2878 var sigma
= this.attr_("sigma");
2880 if (this.fractions_
) {
2882 var den
= 0; // numerator/denominator
2884 for (var i
= 0; i
< originalData
.length
; i
++) {
2885 num
+= originalData
[i
][1][0];
2886 den
+= originalData
[i
][1][1];
2887 if (i
- rollPeriod
>= 0) {
2888 num
-= originalData
[i
- rollPeriod
][1][0];
2889 den
-= originalData
[i
- rollPeriod
][1][1];
2892 var date
= originalData
[i
][0];
2893 var value
= den
? num
/ den
: 0.0;
2894 if (this.attr_("errorBars")) {
2895 if (this.wilsonInterval_
) {
2896 // For more details on this confidence interval, see:
2897 // http://en.wikipedia.org/wiki
/Binomial_confidence_interval
2899 var p
= value
< 0 ? 0 : value
, n
= den
;
2900 var pm
= sigma
* Math
.sqrt(p
*(1-p
)/n + sigma*sigma/(4*n
*n
));
2901 var denom
= 1 + sigma
* sigma
/ den
;
2902 var low
= (p
+ sigma
* sigma
/ (2 * den) - pm) / denom
;
2903 var high
= (p
+ sigma
* sigma
/ (2 * den) + pm) / denom
;
2904 rollingData
[i
] = [date
,
2905 [p
* mult
, (p
- low
) * mult
, (high
- p
) * mult
]];
2907 rollingData
[i
] = [date
, [0, 0, 0]];
2910 var stddev
= den
? sigma
* Math
.sqrt(value
* (1 - value
) / den
) : 1.0;
2911 rollingData
[i
] = [date
, [mult
* value
, mult
* stddev
, mult
* stddev
]];
2914 rollingData
[i
] = [date
, mult
* value
];
2917 } else if (this.attr_("customBars")) {
2922 for (var i
= 0; i
< originalData
.length
; i
++) {
2923 var data
= originalData
[i
][1];
2925 rollingData
[i
] = [originalData
[i
][0], [y
, y
- data
[0], data
[2] - y
]];
2927 if (y
!= null && !isNaN(y
)) {
2933 if (i
- rollPeriod
>= 0) {
2934 var prev
= originalData
[i
- rollPeriod
];
2935 if (prev
[1][1] != null && !isNaN(prev
[1][1])) {
2942 rollingData
[i
] = [originalData
[i
][0], [ 1.0 * mid
/ count
,
2943 1.0 * (mid
- low
) / count
,
2944 1.0 * (high
- mid
) / count
]];
2947 // Calculate the rolling average for the first rollPeriod - 1 points where
2948 // there is not enough data to roll over the full number of points
2949 var num_init_points
= Math
.min(rollPeriod
- 1, originalData
.length
- 2);
2950 if (!this.attr_("errorBars")){
2951 if (rollPeriod
== 1) {
2952 return originalData
;
2955 for (var i
= 0; i
< originalData
.length
; i
++) {
2958 for (var j
= Math
.max(0, i
- rollPeriod
+ 1); j
< i
+ 1; j
++) {
2959 var y
= originalData
[j
][1];
2960 if (y
== null || isNaN(y
)) continue;
2962 sum
+= originalData
[j
][1];
2965 rollingData
[i
] = [originalData
[i
][0], sum
/ num_ok
];
2967 rollingData
[i
] = [originalData
[i
][0], null];
2972 for (var i
= 0; i
< originalData
.length
; i
++) {
2976 for (var j
= Math
.max(0, i
- rollPeriod
+ 1); j
< i
+ 1; j
++) {
2977 var y
= originalData
[j
][1][0];
2978 if (y
== null || isNaN(y
)) continue;
2980 sum
+= originalData
[j
][1][0];
2981 variance
+= Math
.pow(originalData
[j
][1][1], 2);
2984 var stddev
= Math
.sqrt(variance
) / num_ok
;
2985 rollingData
[i
] = [originalData
[i
][0],
2986 [sum
/ num_ok
, sigma
* stddev
, sigma
* stddev
]];
2988 rollingData
[i
] = [originalData
[i
][0], [null, null, null]];
2998 * Parses a date, returning the number of milliseconds since epoch. This can be
2999 * passed in as an xValueParser in the Dygraph constructor.
3000 * TODO(danvk): enumerate formats that this understands.
3001 * @param {String} A date in YYYYMMDD format.
3002 * @return {Number} Milliseconds since epoch.
3005 Dygraph
.dateParser
= function(dateStr
, self
) {
3008 if (dateStr
.search("-") != -1) { // e.g. '2009-7-12' or '2009-07-12'
3009 dateStrSlashed
= dateStr
.replace("-", "/", "g");
3010 while (dateStrSlashed
.search("-") != -1) {
3011 dateStrSlashed
= dateStrSlashed
.replace("-", "/");
3013 d
= Dygraph
.dateStrToMillis(dateStrSlashed
);
3014 } else if (dateStr
.length
== 8) { // e.g. '20090712'
3015 // TODO(danvk): remove support for this format. It's confusing.
3016 dateStrSlashed
= dateStr
.substr(0,4) + "/" + dateStr
.substr(4,2)
3017 + "/" + dateStr
.substr(6,2);
3018 d
= Dygraph
.dateStrToMillis(dateStrSlashed
);
3020 // Any format that Date.parse will accept, e.g. "2009/07/12" or
3021 // "2009/07/12 12:34:56"
3022 d
= Dygraph
.dateStrToMillis(dateStr
);
3025 if (!d
|| isNaN(d
)) {
3026 self
.error("Couldn't parse " + dateStr
+ " as a date");
3032 * Detects the type of the str (date or numeric) and sets the various
3033 * formatting attributes in this.attrs_ based on this type.
3034 * @param {String} str An x value.
3037 Dygraph
.prototype.detectTypeFromString_
= function(str
) {
3039 if (str
.indexOf('-') > 0 ||
3040 str
.indexOf('/') >= 0 ||
3041 isNaN(parseFloat(str
))) {
3043 } else if (str
.length
== 8 && str
> '19700101' && str
< '20371231') {
3044 // TODO(danvk): remove support for this format.
3049 this.attrs_
.xValueFormatter
= Dygraph
.dateString_
;
3050 this.attrs_
.xValueParser
= Dygraph
.dateParser
;
3051 this.attrs_
.xTicker
= Dygraph
.dateTicker
;
3052 this.attrs_
.xAxisLabelFormatter
= Dygraph
.dateAxisFormatter
;
3054 // TODO(danvk): use Dygraph.numberFormatter here?
3055 this.attrs_
.xValueFormatter
= function(x
) { return x
; };
3056 this.attrs_
.xValueParser
= function(x
) { return parseFloat(x
); };
3057 this.attrs_
.xTicker
= Dygraph
.numericTicks
;
3058 this.attrs_
.xAxisLabelFormatter
= this.attrs_
.xValueFormatter
;
3063 * Parses the value as a floating point number. This is like the parseFloat()
3064 * built-in, but with a few differences:
3065 * - the empty string is parsed as null, rather than NaN.
3066 * - if the string cannot be parsed at all, an error is logged.
3067 * If the string can't be parsed, this method returns null.
3068 * @param {String} x The string to be parsed
3069 * @param {Number} opt_line_no The line number from which the string comes.
3070 * @param {String} opt_line The text of the line from which the string comes.
3074 // Parse the x as a float or return null if it's not a number.
3075 Dygraph
.prototype.parseFloat_
= function(x
, opt_line_no
, opt_line
) {
3076 var val
= parseFloat(x
);
3077 if (!isNaN(val
)) return val
;
3079 // Try to figure out what happeend.
3080 // If the value is the empty string, parse it as null.
3081 if (/^ *$/.test(x
)) return null;
3083 // If it was actually "NaN", return it as NaN.
3084 if (/^ *nan *$/i.test(x
)) return NaN
;
3086 // Looks like a parsing error.
3087 var msg
= "Unable to parse '" + x
+ "' as a number";
3088 if (opt_line
!== null && opt_line_no
!== null) {
3089 msg
+= " on line " + (1+opt_line_no
) + " ('" + opt_line
+ "') of CSV.";
3097 * Parses a string in a special csv format. We expect a csv file where each
3098 * line is a date point, and the first field in each line is the date string.
3099 * We also expect that all remaining fields represent series.
3100 * if the errorBars attribute is set, then interpret the fields as:
3101 * date, series1, stddev1, series2, stddev2, ...
3102 * @param {Array.<Object>} data See above.
3105 * @return Array.<Object> An array with one entry for each row. These entries
3106 * are an array of cells in that row. The first entry is the parsed x-value for
3107 * the row. The second, third, etc. are the y-values. These can take on one of
3108 * three forms, depending on the CSV and constructor parameters:
3110 * 2. [ value, stddev ]
3111 * 3. [ low value, center value, high value ]
3113 Dygraph
.prototype.parseCSV_
= function(data
) {
3115 var lines
= data
.split("\n");
3117 // Use the default delimiter or fall back to a tab if that makes sense.
3118 var delim
= this.attr_('delimiter');
3119 if (lines
[0].indexOf(delim
) == -1 && lines
[0].indexOf('\t') >= 0) {
3124 if (this.labelsFromCSV_
) {
3126 this.attrs_
.labels
= lines
[0].split(delim
);
3131 var defaultParserSet
= false; // attempt to auto-detect x value type
3132 var expectedCols
= this.attr_("labels").length
;
3133 var outOfOrder
= false;
3134 for (var i
= start
; i
< lines
.length
; i
++) {
3135 var line
= lines
[i
];
3137 if (line
.length
== 0) continue; // skip blank lines
3138 if (line
[0] == '#') continue; // skip comment lines
3139 var inFields
= line
.split(delim
);
3140 if (inFields
.length
< 2) continue;
3143 if (!defaultParserSet
) {
3144 this.detectTypeFromString_(inFields
[0]);
3145 xParser
= this.attr_("xValueParser");
3146 defaultParserSet
= true;
3148 fields
[0] = xParser(inFields
[0], this);
3150 // If fractions are expected, parse the numbers as "A/B
"
3151 if (this.fractions_) {
3152 for (var j = 1; j < inFields.length; j++) {
3153 // TODO(danvk): figure out an appropriate way to flag parse errors.
3154 var vals = inFields[j].split("/");
3155 if (vals.length != 2) {
3156 this.error('Expected fractional "num
/den
" values in CSV data ' +
3157 "but found a value
'" + inFields[j] + "' on line
" +
3158 (1 + i) + " ('" + line + "') which is not of
this form
.");
3161 fields[j] = [this.parseFloat_(vals[0], i, line),
3162 this.parseFloat_(vals[1], i, line)];
3165 } else if (this.attr_("errorBars
")) {
3166 // If there are error bars, values are (value, stddev) pairs
3167 if (inFields.length % 2 != 1) {
3168 this.error('Expected alternating (value, stdev.) pairs in CSV data ' +
3169 'but line ' + (1 + i) + ' has an odd number of values (' +
3170 (inFields.length - 1) + "): '" + line + "'");
3172 for (var j = 1; j < inFields.length; j += 2) {
3173 fields[(j + 1) / 2] = [this.parseFloat_(inFields[j], i, line),
3174 this.parseFloat_(inFields[j + 1], i, line)];
3176 } else if (this.attr_("customBars
")) {
3177 // Bars are a low;center;high tuple
3178 for (var j = 1; j < inFields.length; j++) {
3179 var val = inFields[j];
3180 if (/^ *$/.test(val)) {
3181 fields[j] = [null, null, null];
3183 var vals = val.split(";");
3184 if (vals.length == 3) {
3185 fields[j] = [ this.parseFloat_(vals[0], i, line),
3186 this.parseFloat_(vals[1], i, line),
3187 this.parseFloat_(vals[2], i, line) ];
3189 this.warning('When using customBars, values must be either blank ' +
3190 'or "low
;center
;high
" tuples (got "' + val +
3191 '" on line ' + (1+i));
3196 // Values are just numbers
3197 for (var j = 1; j < inFields.length; j++) {
3198 fields[j] = this.parseFloat_(inFields[j], i, line);
3201 if (ret.length > 0 && fields[0] < ret[ret.length - 1][0]) {
3205 if (fields.length != expectedCols) {
3206 this.error("Number of columns
in line
" + i + " (" + fields.length +
3207 ") does not agree
with number of
labels (" + expectedCols +
3211 // If the user specified the 'labels' option and none of the cells of the
3212 // first row parsed correctly, then they probably double-specified the
3213 // labels. We go with the values set in the option, discard this row and
3214 // log a warning to the JS console.
3215 if (i == 0 && this.attr_('labels')) {
3216 var all_null = true;
3217 for (var j = 0; all_null && j < fields.length; j++) {
3218 if (fields[j]) all_null = false;
3221 this.warn("The dygraphs
'labels' option is set
, but the first row of
" +
3222 "CSV
data ('" + line + "') appears to also contain labels
. " +
3223 "Will drop the CSV labels and
use the option labels
.");
3231 this.warn("CSV is out of order
; order it correctly to speed loading
.");
3232 ret.sort(function(a,b) { return a[0] - b[0] });
3239 * The user has provided their data as a pre-packaged JS array. If the x values
3240 * are numeric, this is the same as dygraphs' internal format. If the x values
3241 * are dates, we need to convert them from Date objects to ms since epoch.
3242 * @param {Array.<Object>} data
3243 * @return {Array.<Object>} data with numeric x values.
3245 Dygraph.prototype.parseArray_ = function(data) {
3246 // Peek at the first x value to see if it's numeric.
3247 if (data.length == 0) {
3248 this.error("Can
't plot empty data set");
3251 if (data[0].length == 0) {
3252 this.error("Data set cannot contain an empty row");
3256 if (this.attr_("labels") == null) {
3257 this.warn("Using default labels. Set labels explicitly via 'labels
' " +
3258 "in the options parameter");
3259 this.attrs_.labels = [ "X" ];
3260 for (var i = 1; i < data[0].length; i++) {
3261 this.attrs_.labels.push("Y" + i);
3265 if (Dygraph.isDateLike(data[0][0])) {
3266 // Some intelligent defaults for a date x-axis.
3267 this.attrs_.xValueFormatter = Dygraph.dateString_;
3268 this.attrs_.xAxisLabelFormatter = Dygraph.dateAxisFormatter;
3269 this.attrs_.xTicker = Dygraph.dateTicker;
3271 // Assume they're all dates
.
3272 var parsedData
= Dygraph
.clone(data
);
3273 for (var i
= 0; i
< data
.length
; i
++) {
3274 if (parsedData
[i
].length
== 0) {
3275 this.error("Row " + (1 + i
) + " of data is empty");
3278 if (parsedData
[i
][0] == null
3279 || typeof(parsedData
[i
][0].getTime
) != 'function'
3280 || isNaN(parsedData
[i
][0].getTime())) {
3281 this.error("x value in row " + (1 + i
) + " is not a Date");
3284 parsedData
[i
][0] = parsedData
[i
][0].getTime();
3288 // Some intelligent defaults for a numeric x-axis.
3289 this.attrs_
.xValueFormatter
= function(x
) { return x
; };
3290 this.attrs_
.xTicker
= Dygraph
.numericTicks
;
3296 * Parses a DataTable object from gviz.
3297 * The data is expected to have a first column that is either a date or a
3298 * number. All subsequent columns must be numbers. If there is a clear mismatch
3299 * between this.xValueParser_ and the type of the first column, it will be
3300 * fixed. Fills out rawData_.
3301 * @param {Array.<Object>} data See above.
3304 Dygraph
.prototype.parseDataTable_
= function(data
) {
3305 var cols
= data
.getNumberOfColumns();
3306 var rows
= data
.getNumberOfRows();
3308 var indepType
= data
.getColumnType(0);
3309 if (indepType
== 'date' || indepType
== 'datetime') {
3310 this.attrs_
.xValueFormatter
= Dygraph
.dateString_
;
3311 this.attrs_
.xValueParser
= Dygraph
.dateParser
;
3312 this.attrs_
.xTicker
= Dygraph
.dateTicker
;
3313 this.attrs_
.xAxisLabelFormatter
= Dygraph
.dateAxisFormatter
;
3314 } else if (indepType
== 'number') {
3315 this.attrs_
.xValueFormatter
= function(x
) { return x
; };
3316 this.attrs_
.xValueParser
= function(x
) { return parseFloat(x
); };
3317 this.attrs_
.xTicker
= Dygraph
.numericTicks
;
3318 this.attrs_
.xAxisLabelFormatter
= this.attrs_
.xValueFormatter
;
3320 this.error("only 'date', 'datetime' and 'number' types are supported for " +
3321 "column 1 of DataTable input (Got '" + indepType
+ "')");
3325 // Array of the column indices which contain data (and not annotations).
3327 var annotationCols
= {}; // data index -> [annotation cols]
3328 var hasAnnotations
= false;
3329 for (var i
= 1; i
< cols
; i
++) {
3330 var type
= data
.getColumnType(i
);
3331 if (type
== 'number') {
3333 } else if (type
== 'string' && this.attr_('displayAnnotations')) {
3334 // This is OK -- it's an annotation column.
3335 var dataIdx
= colIdx
[colIdx
.length
- 1];
3336 if (!annotationCols
.hasOwnProperty(dataIdx
)) {
3337 annotationCols
[dataIdx
] = [i
];
3339 annotationCols
[dataIdx
].push(i
);
3341 hasAnnotations
= true;
3343 this.error("Only 'number' is supported as a dependent type with Gviz." +
3344 " 'string' is only supported if displayAnnotations is true");
3348 // Read column labels
3349 // TODO(danvk): add support back for errorBars
3350 var labels
= [data
.getColumnLabel(0)];
3351 for (var i
= 0; i
< colIdx
.length
; i
++) {
3352 labels
.push(data
.getColumnLabel(colIdx
[i
]));
3353 if (this.attr_("errorBars")) i
+= 1;
3355 this.attrs_
.labels
= labels
;
3356 cols
= labels
.length
;
3359 var outOfOrder
= false;
3360 var annotations
= [];
3361 for (var i
= 0; i
< rows
; i
++) {
3363 if (typeof(data
.getValue(i
, 0)) === 'undefined' ||
3364 data
.getValue(i
, 0) === null) {
3365 this.warn("Ignoring row " + i
+
3366 " of DataTable because of undefined or null first column.");
3370 if (indepType
== 'date' || indepType
== 'datetime') {
3371 row
.push(data
.getValue(i
, 0).getTime());
3373 row
.push(data
.getValue(i
, 0));
3375 if (!this.attr_("errorBars")) {
3376 for (var j
= 0; j
< colIdx
.length
; j
++) {
3377 var col
= colIdx
[j
];
3378 row
.push(data
.getValue(i
, col
));
3379 if (hasAnnotations
&&
3380 annotationCols
.hasOwnProperty(col
) &&
3381 data
.getValue(i
, annotationCols
[col
][0]) != null) {
3383 ann
.series
= data
.getColumnLabel(col
);
3385 ann
.shortText
= String
.fromCharCode(65 /* A */ + annotations
.length
)
3387 for (var k
= 0; k
< annotationCols
[col
].length
; k
++) {
3388 if (k
) ann
.text
+= "\n";
3389 ann
.text
+= data
.getValue(i
, annotationCols
[col
][k
]);
3391 annotations
.push(ann
);
3395 // Strip out infinities, which give dygraphs problems later on.
3396 for (var j
= 0; j
< row
.length
; j
++) {
3397 if (!isFinite(row
[j
])) row
[j
] = null;
3400 for (var j
= 0; j
< cols
- 1; j
++) {
3401 row
.push([ data
.getValue(i
, 1 + 2 * j
), data
.getValue(i
, 2 + 2 * j
) ]);
3404 if (ret
.length
> 0 && row
[0] < ret
[ret
.length
- 1][0]) {
3411 this.warn("DataTable is out of order; order it correctly to speed loading.");
3412 ret
.sort(function(a
,b
) { return a
[0] - b
[0] });
3414 this.rawData_
= ret
;
3416 if (annotations
.length
> 0) {
3417 this.setAnnotations(annotations
, true);
3421 // This is identical to JavaScript's built-in Date.parse() method, except that
3422 // it doesn't get replaced with an incompatible method by aggressive JS
3423 // libraries like MooTools or Joomla.
3424 Dygraph
.dateStrToMillis
= function(str
) {
3425 return new Date(str
).getTime();
3428 // These functions are all based on MochiKit.
3429 Dygraph
.update
= function (self
, o
) {
3430 if (typeof(o
) != 'undefined' && o
!== null) {
3432 if (o
.hasOwnProperty(k
)) {
3440 Dygraph
.isArrayLike
= function (o
) {
3441 var typ
= typeof(o
);
3443 (typ
!= 'object' && !(typ
== 'function' &&
3444 typeof(o
.item
) == 'function')) ||
3446 typeof(o
.length
) != 'number' ||
3454 Dygraph
.isDateLike
= function (o
) {
3455 if (typeof(o
) != "object" || o
=== null ||
3456 typeof(o
.getTime
) != 'function') {
3462 Dygraph
.clone
= function(o
) {
3463 // TODO(danvk): figure out how MochiKit's version works
3465 for (var i
= 0; i
< o
.length
; i
++) {
3466 if (Dygraph
.isArrayLike(o
[i
])) {
3467 r
.push(Dygraph
.clone(o
[i
]));
3477 * Get the CSV data. If it's in a function, call that function. If it's in a
3478 * file, do an XMLHttpRequest to get it.
3481 Dygraph
.prototype.start_
= function() {
3482 if (typeof this.file_
== 'function') {
3483 // CSV string. Pretend we got it via XHR.
3484 this.loadedEvent_(this.file_());
3485 } else if (Dygraph
.isArrayLike(this.file_
)) {
3486 this.rawData_
= this.parseArray_(this.file_
);
3488 } else if (typeof this.file_
== 'object' &&
3489 typeof this.file_
.getColumnRange
== 'function') {
3490 // must be a DataTable from gviz.
3491 this.parseDataTable_(this.file_
);
3493 } else if (typeof this.file_
== 'string') {
3494 // Heuristic: a newline means it's CSV data. Otherwise it's an URL.
3495 if (this.file_
.indexOf('\n') >= 0) {
3496 this.loadedEvent_(this.file_
);
3498 var req
= new XMLHttpRequest();
3500 req
.onreadystatechange
= function () {
3501 if (req
.readyState
== 4) {
3502 if (req
.status
== 200) {
3503 caller
.loadedEvent_(req
.responseText
);
3508 req
.open("GET", this.file_
, true);
3512 this.error("Unknown data format: " + (typeof this.file_
));
3517 * Changes various properties of the graph. These can include:
3519 * <li>file: changes the source data for the graph</li>
3520 * <li>errorBars: changes whether the data contains stddev</li>
3523 * @param {Object} attrs The new properties and values
3525 Dygraph
.prototype.updateOptions
= function(attrs
) {
3526 // TODO(danvk): this is a mess. Rethink this function.
3527 if ('rollPeriod' in attrs
) {
3528 this.rollPeriod_
= attrs
.rollPeriod
;
3530 if ('dateWindow' in attrs
) {
3531 this.dateWindow_
= attrs
.dateWindow
;
3532 if (!('isZoomedIgnoreProgrammaticZoom' in attrs
)) {
3533 this.zoomed_x_
= attrs
.dateWindow
!= null;
3536 if ('valueRange' in attrs
&& !('isZoomedIgnoreProgrammaticZoom' in attrs
)) {
3537 this.zoomed_y_
= attrs
.valueRange
!= null;
3540 // TODO(danvk): validate per-series options.
3545 // highlightCircleSize
3547 Dygraph
.update(this.user_attrs_
, attrs
);
3548 Dygraph
.update(this.renderOptions_
, attrs
);
3550 this.labelsFromCSV_
= (this.attr_("labels") == null);
3552 // TODO(danvk): this doesn't match the constructor logic
3553 this.layout_
.updateOptions({ 'errorBars': this.attr_("errorBars") });
3554 if (attrs
['file']) {
3555 this.file_
= attrs
['file'];
3563 * Resizes the dygraph. If no parameters are specified, resizes to fill the
3564 * containing div (which has presumably changed size since the dygraph was
3565 * instantiated. If the width/height are specified, the div will be resized.
3567 * This is far more efficient than destroying and re-instantiating a
3568 * Dygraph, since it doesn't have to reparse the underlying data.
3570 * @param {Number} width Width (in pixels)
3571 * @param {Number} height Height (in pixels)
3573 Dygraph
.prototype.resize
= function(width
, height
) {
3574 if (this.resize_lock
) {
3577 this.resize_lock
= true;
3579 if ((width
=== null) != (height
=== null)) {
3580 this.warn("Dygraph.resize() should be called with zero parameters or " +
3581 "two non-NULL parameters. Pretending it was zero.");
3582 width
= height
= null;
3585 // TODO(danvk): there should be a clear() method.
3586 this.maindiv_
.innerHTML
= "";
3587 this.attrs_
.labelsDiv
= null;
3590 this.maindiv_
.style
.width
= width
+ "px";
3591 this.maindiv_
.style
.height
= height
+ "px";
3592 this.width_
= width
;
3593 this.height_
= height
;
3595 this.width_
= this.maindiv_
.offsetWidth
;
3596 this.height_
= this.maindiv_
.offsetHeight
;
3599 this.createInterface_();
3602 this.resize_lock
= false;
3606 * Adjusts the number of points in the rolling average. Updates the graph to
3607 * reflect the new averaging period.
3608 * @param {Number} length Number of points over which to average the data.
3610 Dygraph
.prototype.adjustRoll
= function(length
) {
3611 this.rollPeriod_
= length
;
3616 * Returns a boolean array of visibility statuses.
3618 Dygraph
.prototype.visibility
= function() {
3619 // Do lazy-initialization, so that this happens after we know the number of
3621 if (!this.attr_("visibility")) {
3622 this.attrs_
["visibility"] = [];
3624 while (this.attr_("visibility").length
< this.rawData_
[0].length
- 1) {
3625 this.attr_("visibility").push(true);
3627 return this.attr_("visibility");
3631 * Changes the visiblity of a series.
3633 Dygraph
.prototype.setVisibility
= function(num
, value
) {
3634 var x
= this.visibility();
3635 if (num
< 0 || num
>= x
.length
) {
3636 this.warn("invalid series number in setVisibility: " + num
);
3644 * Update the list of annotations and redraw the chart.
3646 Dygraph
.prototype.setAnnotations
= function(ann
, suppressDraw
) {
3647 // Only add the annotation CSS rule once we know it will be used.
3648 Dygraph
.addAnnotationRule();
3649 this.annotations_
= ann
;
3650 this.layout_
.setAnnotations(this.annotations_
);
3651 if (!suppressDraw
) {
3657 * Return the list of annotations.
3659 Dygraph
.prototype.annotations
= function() {
3660 return this.annotations_
;
3664 * Get the index of a series (column) given its name. The first column is the
3665 * x-axis, so the data series start with index 1.
3667 Dygraph
.prototype.indexFromSetName
= function(name
) {
3668 var labels
= this.attr_("labels");
3669 for (var i
= 0; i
< labels
.length
; i
++) {
3670 if (labels
[i
] == name
) return i
;
3675 Dygraph
.addAnnotationRule
= function() {
3676 if (Dygraph
.addedAnnotationCSS
) return;
3678 var rule
= "border: 1px solid black; " +
3679 "background-color: white; " +
3680 "text-align: center;";
3682 var styleSheetElement
= document
.createElement("style");
3683 styleSheetElement
.type
= "text/css";
3684 document
.getElementsByTagName("head")[0].appendChild(styleSheetElement
);
3686 // Find the first style sheet that we can access.
3687 // We may not add a rule to a style sheet from another domain for security
3688 // reasons. This sometimes comes up when using gviz, since the Google gviz JS
3689 // adds its own style sheets from google.com.
3690 for (var i
= 0; i
< document
.styleSheets
.length
; i
++) {
3691 if (document
.styleSheets
[i
].disabled
) continue;
3692 var mysheet
= document
.styleSheets
[i
];
3694 if (mysheet
.insertRule
) { // Firefox
3695 var idx
= mysheet
.cssRules
? mysheet
.cssRules
.length
: 0;
3696 mysheet
.insertRule(".dygraphDefaultAnnotation { " + rule
+ " }", idx
);
3697 } else if (mysheet
.addRule
) { // IE
3698 mysheet
.addRule(".dygraphDefaultAnnotation", rule
);
3700 Dygraph
.addedAnnotationCSS
= true;
3703 // Was likely a security exception.
3707 this.warn("Unable to add default annotation CSS rule; display may be off.");
3711 * Create a new canvas element. This is more complex than a simple
3712 * document.createElement("canvas") because of IE and excanvas.
3714 Dygraph
.createCanvas
= function() {
3715 var canvas
= document
.createElement("canvas");
3717 isIE
= (/MSIE/.test(navigator
.userAgent
) && !window
.opera
);
3718 if (isIE
&& (typeof(G_vmlCanvasManager
) != 'undefined')) {
3719 canvas
= G_vmlCanvasManager
.initElement(canvas
);
3727 * A wrapper around Dygraph that implements the gviz API.
3728 * @param {Object} container The DOM object the visualization should live in.
3730 Dygraph
.GVizChart
= function(container
) {
3731 this.container
= container
;
3734 Dygraph
.GVizChart
.prototype.draw
= function(data
, options
) {
3735 // Clear out any existing dygraph.
3736 // TODO(danvk): would it make more sense to simply redraw using the current
3737 // date_graph object?
3738 this.container
.innerHTML
= '';
3739 if (typeof(this.date_graph
) != 'undefined') {
3740 this.date_graph
.destroy();
3743 this.date_graph
= new Dygraph(this.container
, data
, options
);
3747 * Google charts compatible setSelection
3748 * Only row selection is supported, all points in the row will be highlighted
3749 * @param {Array} array of the selected cells
3752 Dygraph
.GVizChart
.prototype.setSelection
= function(selection_array
) {
3754 if (selection_array
.length
) {
3755 row
= selection_array
[0].row
;
3757 this.date_graph
.setSelection(row
);
3761 * Google charts compatible getSelection implementation
3762 * @return {Array} array of the selected cells
3765 Dygraph
.GVizChart
.prototype.getSelection
= function() {
3768 var row
= this.date_graph
.getSelection();
3770 if (row
< 0) return selection
;
3773 for (var i
in this.date_graph
.layout_
.datasets
) {
3774 selection
.push({row
: row
, column
: col
});
3781 // Older pages may still use this name.
3782 DateGraph
= Dygraph
;
3784 // <REMOVE_FOR_COMBINED>
3785 Dygraph
.OPTIONS_REFERENCE
= // <JSON>
3788 "default": "parseFloat() or Date.parse()*",
3789 "labels": ["CSV parsing"],
3790 "type": "function(str) -> number",
3791 "description": "A function which parses x-values (i.e. the dependent series). Must return a number, even when the values are dates. In this case, millis since epoch are used. This is used primarily for parsing CSV data. *=Dygraphs is slightly more accepting in the dates which it will parse. See code for details."
3795 "labels": ["Data Line display"],
3797 "description": "If set, stack series on top of one another rather than drawing them independently."
3801 "labels": ["Data Line display"],
3803 "description": "The size of the dot to draw on each point in pixels (see drawPoints). A dot is always drawn when a point is \"isolated\", i.e. there is a missing point on either side of it. This also controls the size of those dots."
3805 "labelsDivStyles": {
3807 "labels": ["Legend"],
3809 "description": "Additional styles to apply to the currently-highlighted points div. For example, { 'font-weight': 'bold' } will make the labels bold."
3813 "labels": ["Data Line display"],
3815 "description": "Draw a small dot at each point, in addition to a line going through the point. This makes the individual data points easier to see, but can increase visual clutter in the chart."
3819 "labels": ["Overall display"],
3821 "description": "Height, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
3825 "labels": ["Callbacks"],
3826 "type": "function(minDate, maxDate, yRanges)",
3827 "description": "A function to call when the zoom window is changed (either by zooming in or out). minDate and maxDate are milliseconds since epoch. yRanges is an array of [bottom, top] pairs, one for each y-axis."
3829 "pointClickCallback": {
3831 "labels": ["Callbacks", "Interactive Elements"],
3836 "default": "(see description)",
3837 "labels": ["Data Series Colors"],
3838 "type": "array<string>",
3839 "example": "['red', '#00FF00']",
3840 "description": "List of colors for the data series. These can be of the form \"#AABBCC\" or \"rgb(255,100,200)\" or \"yellow\", etc. If not specified, equally-spaced points around a color wheel are used."
3842 "connectSeparatedPoints": {
3844 "labels": ["Data Line display"],
3846 "description": "Usually, when Dygraphs encounters a missing value in a data series, it interprets this as a gap and draws it as such. If, instead, the missing values represents an x-value for which only a different series has data, then you'll want to connect the dots by setting this to true. To explicitly include a gap with this option set, use a value of NaN."
3848 "highlightCallback": {
3850 "labels": ["Callbacks"],
3851 "type": "function(event, x, points,row)",
3852 "description": "When set, this callback gets called every time a new point is highlighted. The parameters are the JavaScript mousemove event, the x-coordinate of the highlighted points and an array of highlighted points: <code>[ {name: 'series', yval: y-value}, … ]</code>"
3856 "labels": ["Axis display"],
3858 "description": "Usually, dygraphs will use the range of the data plus some padding to set the range of the y-axis. If this option is set, the y-axis will always include zero, typically as the lowest value. This can be used to avoid exaggerating the variance in the data"
3862 "labels": ["Error Bars", "Rolling Averages"],
3863 "type": "integer >= 1",
3864 "description": "Number of days over which to average data. Discussed extensively above."
3866 "unhighlightCallback": {
3868 "labels": ["Callbacks"],
3869 "type": "function(event)",
3870 "description": "When set, this callback gets called every time the user stops highlighting any point by mousing out of the graph. The parameter is the mouseout event."
3874 "labels": ["Axis display"],
3876 "description": "The size of the line to display next to each tick mark on x- or y-axes."
3878 "labelsSeparateLines": {
3880 "labels": ["Legend"],
3882 "description": "Put <code><br/></code> between lines in the label string. Often used in conjunction with <strong>labelsDiv</strong>."
3884 "xValueFormatter": {
3885 "default": "(Round to 2 decimal places)",
3886 "labels": ["Axis display"],
3887 "type": "function(x)",
3888 "description": "Function to provide a custom display format for the X value for mouseover."
3890 "pixelsPerYLabel": {
3892 "labels": ["Axis display", "Grid"],
3894 "description": "Number of pixels to require between each x- and y-label. Larger values will yield a sparser axis with fewer ticks."
3896 "annotationMouseOverHandler": {
3898 "labels": ["Annotations"],
3899 "type": "function(annotation, point, dygraph, event)",
3900 "description": "If provided, this function is called whenever the user mouses over an annotation."
3902 "annotationMouseOutHandler": {
3904 "labels": ["Annotations"],
3905 "type": "function(annotation, point, dygraph, event)",
3906 "description": "If provided, this function is called whenever the user mouses out of an annotation."
3908 "annotationClickHandler": {
3910 "labels": ["Annotations"],
3911 "type": "function(annotation, point, dygraph, event)",
3912 "description": "If provided, this function is called whenever the user clicks on an annotation."
3914 "annotationDblClickHandler": {
3916 "labels": ["Annotations"],
3917 "type": "function(annotation, point, dygraph, event)",
3918 "description": "If provided, this function is called whenever the user double-clicks on an annotation."
3922 "labels": ["Callbacks"],
3923 "type": "function(dygraph, is_initial)",
3924 "description": "When set, this callback gets called every time the dygraph is drawn. This includes the initial draw, after zooming and repeatedly while panning. The first parameter is the dygraph being drawn. The second is a boolean value indicating whether this is the initial draw."
3928 "labels": ["Value display/formatting"],
3930 "description": "Show k/M/G for kilo/Mega/Giga on y-axis. This is different than <code>labelsKMB</code> in that it uses base 2, not 10."
3934 "labels": ["CSV parsing"],
3936 "description": "The delimiter to look for when separating fields of a CSV file. Setting this to a tab is not usually necessary, since tab-delimited data is auto-detected."
3938 "axisLabelFontSize": {
3940 "labels": ["Axis display"],
3942 "description": "Size of the font (in pixels) to use in the axis labels, both x- and y-axis."
3944 "underlayCallback": {
3946 "labels": ["Callbacks"],
3947 "type": "function(canvas, area, dygraph)",
3948 "description": "When set, this callback gets called before the chart is drawn. It details on how to use this."
3952 "labels": ["Overall display"],
3954 "description": "Width, in pixels, of the chart. If the container div has been explicitly sized, this will be ignored."
3956 "interactionModel": {
3958 "labels": ["Interactive Elements"],
3960 "description": "TODO(konigsberg): document this"
3963 "default": "Dygraph.dateTicker or Dygraph.numericTicks",
3964 "labels": ["Axis display"],
3965 "type": "function(min, max, dygraph) -> [{v: ..., label: ...}, ...]",
3966 "description": "This lets you specify an arbitrary function to generate tick marks on an axis. The tick marks are an array of (value, label) pairs. The built-in functions go to great lengths to choose good tick marks so, if you set this option, you'll most likely want to call one of them and modify the result."
3968 "xAxisLabelWidth": {
3970 "labels": ["Axis display"],
3972 "description": "Width, in pixels, of the x-axis labels."
3974 "showLabelsOnHighlight": {
3976 "labels": ["Interactive Elements", "Legend"],
3978 "description": "Whether to show the legend upon mouseover."
3981 "default": "(none)",
3982 "labels": ["Axis display"],
3983 "type": "string or object",
3984 "description": "Set to either an object ({}) filled with options for this axis or to the name of an existing data series with its own axis to re-use that axis. See tests for usage."
3986 "pixelsPerXLabel": {
3988 "labels": ["Axis display", "Grid"],
3990 "description": "Number of pixels to require between each x- and y-label. Larger values will yield a sparser axis with fewer ticks."
3994 "labels": ["Legend"],
3995 "type": "DOM element or string",
3996 "example": "<code style='font-size: small'>document.getElementById('foo')</code>or<code>'foo'",
3997 "description": "Show data labels in an external div, rather than on the graph. This value can either be a div element or a div id."
4001 "labels": ["CSV parsing", "Error Bars"],
4003 "description": "When set, attempt to parse each cell in the CSV file as \"a/b\", where a and b are integers. The ratio will be plotted. This allows computation of Wilson confidence intervals (see below)."
4007 "labels": ["Axis display"],
4009 "description": "When set for a y-axis, the graph shows that axis in log scale. Any values less than or equal to zero are not displayed.\n\nNot compatible with showZero, and ignores connectSeparatedPoints. Also, showing log scale with valueRanges that are less than zero will result in an unviewable graph."
4013 "labels": ["Data Line display"],
4015 "example": "0.5, 2.0",
4016 "description": "The width of the lines connecting data points. This can be used to increase the contrast or some graphs."
4020 "labels": ["Error Bars"],
4022 "description": "Use in conjunction with the \"fractions\" option. Instead of plotting +/- N standard deviations, dygraphs will compute a Wilson confidence interval and plot that. This has more reasonable behavior for ratios close to 0 or 1."
4026 "labels": ["Data Line display"],
4028 "description": "Should the area underneath the graph be filled? This option is not compatible with error bars."
4030 "highlightCircleSize": {
4032 "labels": ["Interactive Elements"],
4034 "description": "The size in pixels of the dot drawn over highlighted points."
4037 "default": "rgb(128,128,128)",
4039 "type": "red, blue",
4040 "description": "The color of the gridlines."
4043 "default": "[true, true, ...]",
4044 "labels": ["Data Line display"],
4045 "type": "Array of booleans",
4046 "description": "Which series should initially be visible? Once the Dygraph has been constructed, you can access and modify the visibility of each series using the <code>visibility</code> and <code>setVisibility</code> methods."
4049 "default": "Full range of the input is shown",
4050 "labels": ["Axis display"],
4051 "type": "Array of two numbers",
4052 "example": "[10, 110]",
4053 "description": "Explicitly set the vertical range of the graph to [low, high]."
4057 "labels": ["Legend"],
4059 "description": "Width (in pixels) of the div which shows information on the currently-highlighted points."
4061 "colorSaturation": {
4063 "labels": ["Data Series Colors"],
4064 "type": "0.0 - 1.0",
4065 "description": "If <strong>colors</strong> is not specified, saturation of the automatically-generated data series colors."
4067 "yAxisLabelWidth": {
4069 "labels": ["Axis display"],
4071 "description": "Width, in pixels, of the y-axis labels."
4073 "hideOverlayOnMouseOut": {
4075 "labels": ["Interactive Elements", "Legend"],
4077 "description": "Whether to hide the legend when the mouse leaves the chart area."
4079 "yValueFormatter": {
4080 "default": "(Round to 2 decimal places)",
4081 "labels": ["Axis display"],
4082 "type": "function(x)",
4083 "description": "Function to provide a custom display format for the Y value for mouseover."
4086 "default": "onmouseover",
4087 "labels": ["Legend"],
4089 "description": "When to display the legend. By default, it only appears when a user mouses over the chart. Set it to \"always\" to always display a legend of some sort."
4091 "labelsShowZeroValues": {
4093 "labels": ["Legend"],
4095 "description": "Show zero value labels in the labelsDiv."
4099 "labels": ["Data Line display"],
4101 "description": "When set, display the graph as a step plot instead of a line plot."
4105 "labels": ["Value display/formatting"],
4107 "description": "Show K/M/B for thousands/millions/billions on y-axis."
4111 "labels": ["Overall display"],
4113 "description": "Number of pixels to leave blank at the right edge of the Dygraph. This makes it easier to highlight the right-most data point."
4117 "labels": ["Axis display"],
4119 "description": "When set, the heuristic that fixes the Y axis at zero for a data set with the minimum Y value of zero is disabled. \nThis is particularly useful for data sets that contain many zero values, especially for step plots which may otherwise have lines not visible running along the bottom axis."
4121 "xAxisLabelFormatter": {
4122 "default": "Dygraph.dateAxisFormatter",
4123 "labels": ["Axis display", "Value display/formatting"],
4124 "type": "function(date, granularity)",
4125 "description": "Function to call to format values along the x axis."
4128 "snippet": "function(e, date){<br> alert(date);<br>}",
4130 "labels": ["Callbacks"],
4131 "type": "function(e, date)",
4132 "description": "A function to call when a data point is clicked. The function should take two arguments, the event object for the click and the date that was clicked."
4134 "yAxisLabelFormatter": {
4135 "default": "yValueFormatter",
4136 "labels": ["Axis display", "Value display/formatting"],
4137 "type": "function(x)",
4138 "description": "Function used to format values along the Y axis. By default it uses the same as the <code>yValueFormatter</code> unless specified."
4141 "default": "[\"X\", \"Y1\", \"Y2\", ...]*",
4142 "labels": ["Legend"],
4143 "type": "array<string>",
4144 "description": "A name for each data series, including the independent (X) series. For CSV files and DataTable objections, this is determined by context. For raw data, this must be specified. If it is not, default values are supplied and a warning is logged."
4147 "default": "Full range of the input is shown",
4148 "labels": ["Axis display"],
4149 "type": "Array of two Dates or numbers",
4150 "example": "[<br> Date.parse('2006-01-01'),<br> (new Date()).valueOf()<br>]",
4151 "description": "Initially zoom in on a section of the graph. Is of the form [earliest, latest], where earliest/latest are milliseconds since epoch. If the data for the x-axis is numeric, the values in dateWindow must also be numbers."
4155 "labels": ["Interactive Elements", "Rolling Averages"],
4157 "description": "If the rolling average period text box should be shown."
4161 "labels": ["Error Bars"],
4163 "description": "When errorBars is set, shade this many standard deviations above/below each point."
4167 "labels": ["CSV parsing", "Error Bars"],
4169 "description": "When set, parse each CSV cell as \"low;middle;high\". Error bars will be drawn for each point between low and high, with the series itself going through middle."
4173 "labels": ["Data Series Colors"],
4174 "type": "float (0.0 - 1.0)",
4175 "description": "If colors is not specified, value of the data series colors, as in hue/saturation/value. (0.0-1.0, default 0.5)"
4179 "labels": ["CSV parsing", "Error Bars"],
4181 "description": "Does the data contain standard deviations? Setting this to true alters the input format (see above)."
4183 "displayAnnotations": {
4185 "labels": ["Annotations"],
4187 "description": "Only applies when Dygraphs is used as a GViz chart. Causes string columns following a data series to be interpreted as annotations on points in that series. This is the same format used by Google's AnnotatedTimeLine chart."
4189 "panEdgeFraction": {
4191 "labels": ["Axis Display", "Interactive Elements"],
4194 "description": "A value representing the farthest a graph may be panned, in percent of the display. For example, a value of 0.1 means that the graph can only be panned 10% pased the edges of the displayed values. null means no bounds."
4197 "labels": ["Chart labels"],
4200 "description": "Text to display above the chart. You can supply any HTML for this value, not just text. If you wish to style it using CSS, use the 'dygraph-label' or 'dygraph-title' classes."
4204 "labels": ["Chart labels"],
4206 "description": "Height of the chart title, in pixels. This also controls the default font size of the title. If you style the title on your own, this controls how much space is set aside above the chart for the title's div."
4209 "labels": ["Chart labels"],
4212 "description": "Text to display below the chart's x-axis. You can supply any HTML for this value, not just text. If you wish to style it using CSS, use the 'dygraph-label' or 'dygraph-xlabel' classes."
4215 "labels": ["Chart labels"],
4218 "description": "Height of the x-axis label, in pixels. This also controls the default font size of the x-axis label. If you style the label on your own, this controls how much space is set aside below the chart for the x-axis label's div."
4221 "labels": ["Chart labels"],
4224 "description": "Text to display to the left of the chart's y-axis. You can supply any HTML for this value, not just text. If you wish to style it using CSS, use the 'dygraph-label' or 'dygraph-ylabel' classes. The text will be rotated 90 degrees by default, so CSS rules may behave in unintuitive ways. No additional space is set aside for a y-axis label. If you need more space, increase the width of the y-axis tick labels using the yAxisLabelWidth option. If you need a wider div for the y-axis label, either style it that way with CSS (but remember that it's rotated, so width is controlled by the 'height' property) or set the yLabelWidth option."
4227 "labels": ["Chart labels"],
4230 "description": "Width of the div which contains the y-axis label. Since the y-axis label appears rotated 90 degrees, this actually affects the height of its div."
4232 "isZoomedIgnoreProgrammaticZoom" : {
4234 "labels": ["Zooming"],
4236 "description" : "When this option is passed to updateOptions() along with either the <code>dateWindow</code> or <code>valueRange</code> options, the zoom flags are not changed to reflect a zoomed state. This is primarily useful for when the display area of a chart is changed programmatically and also where manual zooming is allowed and use is made of the <code>isZoomed</code> method to determine this."
4240 "labels": ["Value display/formatting"],
4242 "description": "By default, dygraphs displays numbers with a fixed number of digits after the decimal point. If you'd prefer to have a fixed number of significant figures, set this option to that number of sig figs. A value of 2, for instance, would cause 1 to be display as 1.0 and 1234 to be displayed as 1.23e+3."
4244 "digitsAfterDecimal" : {
4246 "labels": ["Value display/formatting"],
4248 "description": "Unless it's run in scientific mode (see the <code>sigFigs</code> option), dygraphs displays numbers with <code>digitsAfterDecimal</code> digits after the decimal point. Trailing zeros are not displayed, so with a value of 2 you'll get '0', '0.1', '0.12', '123.45' but not '123.456' (it will be rounded to '123.46'). Numbers with absolute value less than 0.1^digitsAfterDecimal (i.e. those which would show up as '0.00') will be displayed in scientific notation."
4250 "maxNumberWidth" : {
4252 "labels": ["Value display/formatting"],
4254 "description": "When displaying numbers in normal (not scientific) mode, large numbers will be displayed with many trailing zeros (e.g. 100000000 instead of 1e9). This can lead to unwieldy y-axis labels. If there are more than <code>maxNumberWidth</code> digits to the left of the decimal in a number, dygraphs will switch to scientific notation, even when not operating in scientific mode. If you'd like to see all those digits, set this to something large, like 20 or 30."
4258 // NOTE: in addition to parsing as JS, this snippet is expected to be valid
4259 // JSON. This assumption cannot be checked in JS, but it will be checked when
4260 // documentation is generated by the generate-documentation.py script. For the
4261 // most part, this just means that you should always use double quotes.
4263 // Do a quick sanity check on the options reference.
4265 var warn
= function(msg
) { if (console
) console
.warn(msg
); };
4266 var flds
= ['type', 'default', 'description'];
4273 'Data Line display',
4274 'Data Series Colors',
4277 'Interactive Elements',
4281 'Value display/formatting',
4285 for (var i
= 0; i
< valid_cats
.length
; i
++) cats
[valid_cats
[i
]] = true;
4287 for (var k
in Dygraph
.OPTIONS_REFERENCE
) {
4288 if (!Dygraph
.OPTIONS_REFERENCE
.hasOwnProperty(k
)) continue;
4289 var op
= Dygraph
.OPTIONS_REFERENCE
[k
];
4290 for (var i
= 0; i
< flds
.length
; i
++) {
4291 if (!op
.hasOwnProperty(flds
[i
])) {
4292 warn('Option ' + k
+ ' missing "' + flds
[i
] + '" property');
4293 } else if (typeof(op
[flds
[i
]]) != 'string') {
4294 warn(k
+ '.' + flds
[i
] + ' must be of type string');
4297 var labels
= op
['labels'];
4298 if (typeof(labels
) !== 'object') {
4299 warn('Option "' + k
+ '" is missing a "labels": [...] option');
4300 for (var i
= 0; i
< labels
.length
; i
++) {
4301 if (!cats
.hasOwnProperty(labels
[i
])) {
4302 warn('Option "' + k
+ '" has label "' + labels
[i
] +
4303 '", which is invalid.');
4309 // </REMOVE_FOR_COMBINED
>