require({cache:{
'dojox/charting/widget/Chart':function(){
define(["dojo/_base/kernel", "dojo/_base/lang", "dojo/_base/array","dojo/dom-attr","dojo/_base/declare", "dojo/query",
"dijit/_WidgetBase", "../Chart", "dojo/has", "dojo/has!dojo-bidi?../bidi/widget/Chart",
"dojox/lang/utils", "dojox/lang/functional","dojox/lang/functional/lambda"],
function(kernel, lang, arr, domAttr, declare, query, _WidgetBase, ChartBase, has, BidiChart, du, df, dfl){
var collectParams, collectAxisParams, collectPlotParams,
collectActionParams, collectDataParams,
notNull = function(o){ return o; },
dc = lang.getObject("dojox.charting");
collectParams = function(node, type, kw){
var dp = eval("(" + type + ".prototype.defaultParams)");
var x, attr;
for(x in dp){
if(x in kw){ continue; }
attr = node.getAttribute(x);
kw[x] = du.coerceType(dp[x], attr == null || typeof attr == "undefined" ? dp[x] : attr);
}
var op = eval("(" + type + ".prototype.optionalParams)");
for(x in op){
if(x in kw){ continue; }
attr = node.getAttribute(x);
if(attr != null){
kw[x] = du.coerceType(op[x], attr);
}
}
};
collectAxisParams = function(node){
var name = node.getAttribute("name"), type = node.getAttribute("type");
if(!name){ return null; }
var o = {name: name, kwArgs: {}}, kw = o.kwArgs;
if(type){
if(dc.axis2d[type]){
type = kernel._scopeName + "x.charting.axis2d." + type;
}
var axis = eval("(" + type + ")");
if(axis){ kw.type = axis; }
}else{
type = kernel._scopeName + "x.charting.axis2d.Default";
}
collectParams(node, type, kw);
// compatibility conversions
if(kw.font || kw.fontColor){
if(!kw.tick){
kw.tick = {};
}
if(kw.font){
kw.tick.font = kw.font;
}
if(kw.fontColor){
kw.tick.fontColor = kw.fontColor;
}
}
return o;
};
collectPlotParams = function(node){
// var name = d.attr(node, "name"), type = d.attr(node, "type");
var name = node.getAttribute("name"), type = node.getAttribute("type");
if(!name){ return null; }
var o = {name: name, kwArgs: {}}, kw = o.kwArgs;
if(type){
if(dc.plot2d && dc.plot2d[type]){
type = kernel._scopeName + "x.charting.plot2d." + type;
}
var plot = eval("(" + type + ")");
if(plot){ kw.type = plot; }
}else{
type = kernel._scopeName + "x.charting.plot2d.Default";
}
collectParams(node, type, kw);
// TODO
// we have factorized axis & label management in CartesianBase and thus is is not anymore
// accessible to the default collect mechanism. Longer term we must get rid of that
// and leverage dojo/parser
var dp = eval("(" + type + ".prototype.baseParams)");
var x, attr;
for(x in dp){
if(x in kw){ continue; }
attr = node.getAttribute(x);
kw[x] = du.coerceType(dp[x], attr == null || typeof attr == "undefined" ? dp[x] : attr);
}
return o;
};
collectActionParams = function(node){
// var plot = d.attr(node, "plot"), type = d.attr(node, "type");
var plot = node.getAttribute("plot"), type = node.getAttribute("type");
if(!plot){ plot = "default"; }
var o = {plot: plot, kwArgs: {}}, kw = o.kwArgs;
if(type){
if(dc.action2d[type]){
type = kernel._scopeName + "x.charting.action2d." + type;
}
var action = eval("(" + type + ")");
if(!action){ return null; }
o.action = action;
}else{
return null;
}
collectParams(node, type, kw);
return o;
};
collectDataParams = function(node){
var ga = lang.partial(domAttr.get, node);
var name = ga("name");
if(!name){ return null; }
var o = { name: name, kwArgs: {} }, kw = o.kwArgs, t;
t = ga("plot");
if(t != null){ kw.plot = t; }
t = ga("marker");
if(t != null){ kw.marker = t; }
t = ga("stroke");
if(t != null){ kw.stroke = eval("(" + t + ")"); }
t = ga("outline");
if(t != null){ kw.outline = eval("(" + t + ")"); }
t = ga("shadow");
if(t != null){ kw.shadow = eval("(" + t + ")"); }
t = ga("fill");
if(t != null){ kw.fill = eval("(" + t + ")"); }
t = ga("font");
if(t != null){ kw.font = t; }
t = ga("fontColor");
if(t != null){ kw.fontColor = eval("(" + t + ")"); }
t = ga("legend");
if(t != null){ kw.legend = t; }
t = ga("data");
if(t != null){
o.type = "data";
o.data = t ? arr.map(String(t).split(','), Number) : [];
return o;
}
t = ga("array");
if(t != null){
o.type = "data";
o.data = eval("(" + t + ")");
return o;
}
t = ga("store");
if(t != null){
o.type = "store";
o.data = eval("(" + t + ")");
t = ga("field");
o.field = t != null ? t : "value";
t = ga("query");
if(!!t){ kw.query = t; }
t = ga("queryOptions");
if(!!t){ kw.queryOptions = eval("(" + t + ")"); }
t = ga("start");
if(!!t){ kw.start = Number(t); }
t = ga("count");
if(!!t){ kw.count = Number(t); }
t = ga("sort");
if(!!t){ kw.sort = eval("("+t+")"); }
t = ga("valueFn");
if(!!t){ kw.valueFn = dfl.lambda(t); }
return o;
}
return null;
};
var Chart = declare(has("dojo-bidi")? "dojox.charting.widget.NonBidiChart" : "dojox.charting.widget.Chart", _WidgetBase, {
// summary:
// A chart widget. This is leveraging dojox/charting/Chart as a Dijit widget.
// parameters for the markup
// theme: dojox/charting/SimpleTheme?
// An optional theme to use for styling the chart.
theme: null,
// margins: Object?
// The margins around the chart. Default is { l:10, t:10, r:10, b:10 }.
margins: null,
// chart area, define them as undefined to:
// allow the parser to take them into account
// but make sure they have no defined value to not override theme
// stroke: dojox.gfx.Stroke?
// The outline of the chart (stroke in vector graphics terms).
stroke: undefined,
// fill: dojox.gfx.Fill?
// The color for the chart.
fill: undefined,
// methods
buildRendering: function(){
this.inherited(arguments);
var n = this.domNode;
// collect chart parameters
var axes = query("> .axis", n).map(collectAxisParams).filter(notNull),
plots = query("> .plot", n).map(collectPlotParams).filter(notNull),
actions = query("> .action", n).map(collectActionParams).filter(notNull),
series = query("> .series", n).map(collectDataParams).filter(notNull);
// build the chart
n.innerHTML = "";
var c = this.chart = new ChartBase(n, {
margins: this.margins,
stroke: this.stroke,
fill: this.fill,
textDir: this.textDir
});
// add collected parameters
if(this.theme){
c.setTheme(this.theme);
}
axes.forEach(function(axis){
c.addAxis(axis.name, axis.kwArgs);
});
plots.forEach(function(plot){
c.addPlot(plot.name, plot.kwArgs);
});
this.actions = actions.map(function(action){
return new action.action(c, action.plot, action.kwArgs);
});
var render = df.foldl(series, function(render, series){
if(series.type == "data"){
c.addSeries(series.name, series.data, series.kwArgs);
render = true;
}else{
c.addSeries(series.name, [0], series.kwArgs);
var kw = {};
du.updateWithPattern(
kw,
series.kwArgs,
{
"query": "",
"queryOptions": null,
"start": 0,
"count": 1 //,
// "sort": []
},
true
);
if(series.kwArgs.sort){
// sort is a complex object type and doesn't survive coercian
kw.sort = lang.clone(series.kwArgs.sort);
}
lang.mixin(kw, {
onComplete: function(data){
var values;
if("valueFn" in series.kwArgs){
var fn = series.kwArgs.valueFn;
values = arr.map(data, function(x){
return fn(series.data.getValue(x, series.field, 0));
});
}else{
values = arr.map(data, function(x){
return series.data.getValue(x, series.field, 0);
});
}
c.addSeries(series.name, values, series.kwArgs).render();
}
});
series.data.fetch(kw);
}
return render;
}, false);
if(render){ c.render(); }
},
destroy: function(){
// summary:
// properly destroy the widget
this.chart.destroy();
this.inherited(arguments);
},
resize: function(box){
// summary:
// Resize the widget.
// description:
// Resize the domNode and the widget surface to the dimensions of a box of the following form:
// `{ l: 50, t: 200, w: 300: h: 150 }`
// If no box is provided, resize the surface to the marginBox of the domNode.
// box:
// If passed, denotes the new size of the widget.
this.chart.resize.apply(this.chart, arguments);
}
});
return has("dojo-bidi")? declare("dojox.charting.widget.Chart", [Chart, BidiChart]) : Chart;
});
},
'dijit/_WidgetBase':function(){
define([
"require", // require.toUrl
"dojo/_base/array", // array.forEach array.map
"dojo/aspect",
"dojo/_base/config", // config.blankGif
"dojo/_base/connect", // connect.connect
"dojo/_base/declare", // declare
"dojo/dom", // dom.byId
"dojo/dom-attr", // domAttr.set domAttr.remove
"dojo/dom-class", // domClass.add domClass.replace
"dojo/dom-construct", // domConstruct.destroy domConstruct.place
"dojo/dom-geometry", // isBodyLtr
"dojo/dom-style", // domStyle.set, domStyle.get
"dojo/has",
"dojo/_base/kernel",
"dojo/_base/lang", // mixin(), isArray(), etc.
"dojo/on",
"dojo/ready",
"dojo/Stateful", // Stateful
"dojo/topic",
"dojo/_base/window", // win.body()
"./Destroyable",
"dojo/has!dojo-bidi?./_BidiMixin",
"./registry" // registry.getUniqueId(), registry.findWidgets()
], function(require, array, aspect, config, connect, declare,
dom, domAttr, domClass, domConstruct, domGeometry, domStyle, has, kernel,
lang, on, ready, Stateful, topic, win, Destroyable, _BidiMixin, registry){
// module:
// dijit/_WidgetBase
// Flag to make dijit load modules the app didn't explicitly request, for backwards compatibility
has.add("dijit-legacy-requires", !kernel.isAsync);
// Flag to enable support for textdir attribute
has.add("dojo-bidi", false);
// For back-compat, remove in 2.0.
if(has("dijit-legacy-requires")){
ready(0, function(){
var requires = ["dijit/_base/manager"];
require(requires); // use indirection so modules not rolled into a build
});
}
// Nested hash listing attributes for each tag, all strings in lowercase.
// ex: {"div": {"style": true, "tabindex" true}, "form": { ...
var tagAttrs = {};
function getAttrs(obj){
var ret = {};
for(var attr in obj){
ret[attr.toLowerCase()] = true;
}
return ret;
}
function nonEmptyAttrToDom(attr){
// summary:
// Returns a setter function that copies the attribute to this.domNode,
// or removes the attribute from this.domNode, depending on whether the
// value is defined or not.
return function(val){
domAttr[val ? "set" : "remove"](this.domNode, attr, val);
this._set(attr, val);
};
}
function isEqual(a, b){
// summary:
// Function that determines whether two values are identical,
// taking into account that NaN is not normally equal to itself
// in JS.
return a === b || (/* a is NaN */ a !== a && /* b is NaN */ b !== b);
}
var _WidgetBase = declare("dijit._WidgetBase", [Stateful, Destroyable], {
// summary:
// Future base class for all Dijit widgets.
// description:
// Future base class for all Dijit widgets.
// _Widget extends this class adding support for various features needed by desktop.
//
// Provides stubs for widget lifecycle methods for subclasses to extend, like postMixInProperties(), buildRendering(),
// postCreate(), startup(), and destroy(), and also public API methods like set(), get(), and watch().
//
// Widgets can provide custom setters/getters for widget attributes, which are called automatically by set(name, value).
// For an attribute XXX, define methods _setXXXAttr() and/or _getXXXAttr().
//
// _setXXXAttr can also be a string/hash/array mapping from a widget attribute XXX to the widget's DOMNodes:
//
// - DOM node attribute
// | _setFocusAttr: {node: "focusNode", type: "attribute"}
// | _setFocusAttr: "focusNode" (shorthand)
// | _setFocusAttr: "" (shorthand, maps to this.domNode)
// Maps this.focus to this.focusNode.focus, or (last example) this.domNode.focus
//
// - DOM node innerHTML
// | _setTitleAttr: { node: "titleNode", type: "innerHTML" }
// Maps this.title to this.titleNode.innerHTML
//
// - DOM node innerText
// | _setTitleAttr: { node: "titleNode", type: "innerText" }
// Maps this.title to this.titleNode.innerText
//
// - DOM node CSS class
// | _setMyClassAttr: { node: "domNode", type: "class" }
// Maps this.myClass to this.domNode.className
//
// - Toggle DOM node CSS class
// | _setMyClassAttr: { node: "domNode", type: "toggleClass" }
// Toggles myClass on this.domNode by this.myClass
//
// If the value of _setXXXAttr is an array, then each element in the array matches one of the
// formats of the above list.
//
// If the custom setter is null, no action is performed other than saving the new value
// in the widget (in this).
//
// If no custom setter is defined for an attribute, then it will be copied
// to this.focusNode (if the widget defines a focusNode), or this.domNode otherwise.
// That's only done though for attributes that match DOMNode attributes (title,
// alt, aria-labelledby, etc.)
// id: [const] String
// A unique, opaque ID string that can be assigned by users or by the
// system. If the developer passes an ID which is known not to be
// unique, the specified ID is ignored and the system-generated ID is
// used instead.
id: "",
_setIdAttr: "domNode", // to copy to this.domNode even for auto-generated id's
// lang: [const] String
// Rarely used. Overrides the default Dojo locale used to render this widget,
// as defined by the [HTML LANG](http://www.w3.org/TR/html401/struct/dirlang.html#adef-lang) attribute.
// Value must be among the list of locales specified during by the Dojo bootstrap,
// formatted according to [RFC 3066](http://www.ietf.org/rfc/rfc3066.txt) (like en-us).
lang: "",
// set on domNode even when there's a focus node. but don't set lang="", since that's invalid.
_setLangAttr: nonEmptyAttrToDom("lang"),
// dir: [const] String
// Bi-directional support, as defined by the [HTML DIR](http://www.w3.org/TR/html401/struct/dirlang.html#adef-dir)
// attribute. Either left-to-right "ltr" or right-to-left "rtl". If undefined, widgets renders in page's
// default direction.
dir: "",
// set on domNode even when there's a focus node. but don't set dir="", since that's invalid.
_setDirAttr: nonEmptyAttrToDom("dir"), // to set on domNode even when there's a focus node
// class: String
// HTML class attribute
"class": "",
_setClassAttr: { node: "domNode", type: "class" },
// Override automatic assigning type --> focusNode, it causes exception on IE6-8.
// Instead, type must be specified as ${type} in the template, as part of the original DOM.
_setTypeAttr: null,
// style: String||Object
// HTML style attributes as cssText string or name/value hash
style: "",
// title: String
// HTML title attribute.
//
// For form widgets this specifies a tooltip to display when hovering over
// the widget (just like the native HTML title attribute).
//
// For TitlePane or for when this widget is a child of a TabContainer, AccordionContainer,
// etc., it's used to specify the tab label, accordion pane title, etc. In this case it's
// interpreted as HTML.
title: "",
// tooltip: String
// When this widget's title attribute is used to for a tab label, accordion pane title, etc.,
// this specifies the tooltip to appear when the mouse is hovered over that text.
tooltip: "",
// baseClass: [protected] String
// Root CSS class of the widget (ex: dijitTextBox), used to construct CSS classes to indicate
// widget state.
baseClass: "",
// srcNodeRef: [readonly] DomNode
// pointer to original DOM node
srcNodeRef: null,
// domNode: [readonly] DomNode
// This is our visible representation of the widget! Other DOM
// Nodes may by assigned to other properties, usually through the
// template system's data-dojo-attach-point syntax, but the domNode
// property is the canonical "top level" node in widget UI.
domNode: null,
// containerNode: [readonly] DomNode
// Designates where children of the source DOM node will be placed.
// "Children" in this case refers to both DOM nodes and widgets.
// For example, for myWidget:
//
// |
// | here's a plain DOM node
// | and a widget
// | and another plain DOM node
// |
//
// containerNode would point to:
//
// | here's a plain DOM node
// | and a widget
// | and another plain DOM node
//
// In templated widgets, "containerNode" is set via a
// data-dojo-attach-point assignment.
//
// containerNode must be defined for any widget that accepts innerHTML
// (like ContentPane or BorderContainer or even Button), and conversely
// is null for widgets that don't, like TextBox.
containerNode: null,
// ownerDocument: [const] Document?
// The document this widget belongs to. If not specified to constructor, will default to
// srcNodeRef.ownerDocument, or if no sourceRef specified, then to the document global
ownerDocument: null,
_setOwnerDocumentAttr: function(val){
// this setter is merely to avoid automatically trying to set this.domNode.ownerDocument
this._set("ownerDocument", val);
},
/*=====
// _started: [readonly] Boolean
// startup() has completed.
_started: false,
=====*/
// attributeMap: [protected] Object
// Deprecated. Instead of attributeMap, widget should have a _setXXXAttr attribute
// for each XXX attribute to be mapped to the DOM.
//
// attributeMap sets up a "binding" between attributes (aka properties)
// of the widget and the widget's DOM.
// Changes to widget attributes listed in attributeMap will be
// reflected into the DOM.
//
// For example, calling set('title', 'hello')
// on a TitlePane will automatically cause the TitlePane's DOM to update
// with the new title.
//
// attributeMap is a hash where the key is an attribute of the widget,
// and the value reflects a binding to a:
//
// - DOM node attribute
// | focus: {node: "focusNode", type: "attribute"}
// Maps this.focus to this.focusNode.focus
//
// - DOM node innerHTML
// | title: { node: "titleNode", type: "innerHTML" }
// Maps this.title to this.titleNode.innerHTML
//
// - DOM node innerText
// | title: { node: "titleNode", type: "innerText" }
// Maps this.title to this.titleNode.innerText
//
// - DOM node CSS class
// | myClass: { node: "domNode", type: "class" }
// Maps this.myClass to this.domNode.className
//
// If the value is an array, then each element in the array matches one of the
// formats of the above list.
//
// There are also some shorthands for backwards compatibility:
//
// - string --> { node: string, type: "attribute" }, for example:
//
// | "focusNode" ---> { node: "focusNode", type: "attribute" }
//
// - "" --> { node: "domNode", type: "attribute" }
attributeMap: {},
// _blankGif: [protected] String
// Path to a blank 1x1 image.
// Used by `` nodes in templates that really get their image via CSS background-image.
_blankGif: config.blankGif || require.toUrl("dojo/resources/blank.gif"),
// textDir: String
// Bi-directional support, the main variable which is responsible for the direction of the text.
// The text direction can be different than the GUI direction by using this parameter in creation
// of a widget.
//
// This property is only effective when `has("dojo-bidi")` is defined to be true.
//
// Allowed values:
//
// 1. "" - default value; text is same direction as widget
// 2. "ltr"
// 3. "rtl"
// 4. "auto" - contextual the direction of a text defined by first strong letter.
textDir: "",
//////////// INITIALIZATION METHODS ///////////////////////////////////////
/*=====
constructor: function(params, srcNodeRef){
// summary:
// Create the widget.
// params: Object|null
// Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
// and functions, typically callbacks like onClick.
// The hash can contain any of the widget's properties, excluding read-only properties.
// srcNodeRef: DOMNode|String?
// If a srcNodeRef (DOM node) is specified:
//
// - use srcNodeRef.innerHTML as my contents
// - if this is a behavioral widget then apply behavior to that srcNodeRef
// - otherwise, replace srcNodeRef with my generated DOM tree
},
=====*/
_introspect: function(){
// summary:
// Collect metadata about this widget (only once per class, not once per instance):
//
// - list of attributes with custom setters, storing in this.constructor._setterAttrs
// - generate this.constructor._onMap, mapping names like "mousedown" to functions like onMouseDown
var ctor = this.constructor;
if(!ctor._setterAttrs){
var proto = ctor.prototype,
attrs = ctor._setterAttrs = [], // attributes with custom setters
onMap = (ctor._onMap = {});
// Items in this.attributeMap are like custom setters. For back-compat, remove for 2.0.
for(var name in proto.attributeMap){
attrs.push(name);
}
// Loop over widget properties, collecting properties with custom setters and filling in ctor._onMap.
for(name in proto){
if(/^on/.test(name)){
onMap[name.substring(2).toLowerCase()] = name;
}
if(/^_set[A-Z](.*)Attr$/.test(name)){
name = name.charAt(4).toLowerCase() + name.substr(5, name.length - 9);
if(!proto.attributeMap || !(name in proto.attributeMap)){
attrs.push(name);
}
}
}
// Note: this isn't picking up info on properties like aria-label and role, that don't have custom setters
// but that set() maps to attributes on this.domNode or this.focusNode
}
},
postscript: function(/*Object?*/params, /*DomNode|String*/srcNodeRef){
// summary:
// Kicks off widget instantiation. See create() for details.
// tags:
// private
// Note that we skip calling this.inherited(), i.e. dojo/Stateful::postscript(), because 1.x widgets don't
// expect their custom setters to get called until after buildRendering(). Consider changing for 2.0.
this.create(params, srcNodeRef);
},
create: function(params, srcNodeRef){
// summary:
// Kick off the life-cycle of a widget
// description:
// Create calls a number of widget methods (postMixInProperties, buildRendering, postCreate,
// etc.), some of which of you'll want to override. See http://dojotoolkit.org/reference-guide/dijit/_WidgetBase.html
// for a discussion of the widget creation lifecycle.
//
// Of course, adventurous developers could override create entirely, but this should
// only be done as a last resort.
// params: Object|null
// Hash of initialization parameters for widget, including scalar values (like title, duration etc.)
// and functions, typically callbacks like onClick.
// The hash can contain any of the widget's properties, excluding read-only properties.
// srcNodeRef: DOMNode|String?
// If a srcNodeRef (DOM node) is specified:
//
// - use srcNodeRef.innerHTML as my contents
// - if this is a behavioral widget then apply behavior to that srcNodeRef
// - otherwise, replace srcNodeRef with my generated DOM tree
// tags:
// private
// First time widget is instantiated, scan prototype to figure out info about custom setters etc.
this._introspect();
// store pointer to original DOM tree
this.srcNodeRef = dom.byId(srcNodeRef);
// No longer used, remove for 2.0.
this._connects = [];
this._supportingWidgets = [];
// this is here for back-compat, remove in 2.0 (but check NodeList-instantiate.html test)
if(this.srcNodeRef && this.srcNodeRef.id && (typeof this.srcNodeRef.id == "string")){
this.id = this.srcNodeRef.id;
}
// mix in our passed parameters
if(params){
this.params = params;
lang.mixin(this, params);
}
this.postMixInProperties();
// Generate an id for the widget if one wasn't specified, or it was specified as id: undefined.
// Do this before buildRendering() because it might expect the id to be there.
if(!this.id){
this.id = registry.getUniqueId(this.declaredClass.replace(/\./g, "_"));
if(this.params){
// if params contains {id: undefined}, prevent _applyAttributes() from processing it
delete this.params.id;
}
}
// The document and node this widget is associated with
this.ownerDocument = this.ownerDocument || (this.srcNodeRef ? this.srcNodeRef.ownerDocument : document);
this.ownerDocumentBody = win.body(this.ownerDocument);
registry.add(this);
this.buildRendering();
var deleteSrcNodeRef;
if(this.domNode){
// Copy attributes listed in attributeMap into the [newly created] DOM for the widget.
// Also calls custom setters for all attributes with custom setters.
this._applyAttributes();
// If srcNodeRef was specified, then swap out original srcNode for this widget's DOM tree.
// For 2.0, move this after postCreate(). postCreate() shouldn't depend on the
// widget being attached to the DOM since it isn't when a widget is created programmatically like
// new MyWidget({}). See #11635.
var source = this.srcNodeRef;
if(source && source.parentNode && this.domNode !== source){
source.parentNode.replaceChild(this.domNode, source);
deleteSrcNodeRef = true;
}
// Note: for 2.0 may want to rename widgetId to dojo._scopeName + "_widgetId",
// assuming that dojo._scopeName even exists in 2.0
this.domNode.setAttribute("widgetId", this.id);
}
this.postCreate();
// If srcNodeRef has been processed and removed from the DOM (e.g. TemplatedWidget) then delete it to allow GC.
// I think for back-compatibility it isn't deleting srcNodeRef until after postCreate() has run.
if(deleteSrcNodeRef){
delete this.srcNodeRef;
}
this._created = true;
},
_applyAttributes: function(){
// summary:
// Step during widget creation to copy widget attributes to the
// DOM according to attributeMap and _setXXXAttr objects, and also to call
// custom _setXXXAttr() methods.
//
// Skips over blank/false attribute values, unless they were explicitly specified
// as parameters to the widget, since those are the default anyway,
// and setting tabIndex="" is different than not setting tabIndex at all.
//
// For backwards-compatibility reasons attributeMap overrides _setXXXAttr when
// _setXXXAttr is a hash/string/array, but _setXXXAttr as a functions override attributeMap.
// tags:
// private
// Call this.set() for each property that was either specified as parameter to constructor,
// or is in the list found above. For correlated properties like value and displayedValue, the one
// specified as a parameter should take precedence.
// Particularly important for new DateTextBox({displayedValue: ...}) since DateTextBox's default value is
// NaN and thus is not ignored like a default value of "".
// Step 1: Save the current values of the widget properties that were specified as parameters to the constructor.
// Generally this.foo == this.params.foo, except if postMixInProperties() changed the value of this.foo.
var params = {};
for(var key in this.params || {}){
params[key] = this._get(key);
}
// Step 2: Call set() for each property with a non-falsy value that wasn't passed as a parameter to the constructor
array.forEach(this.constructor._setterAttrs, function(key){
if(!(key in params)){
var val = this._get(key);
if(val){
this.set(key, val);
}
}
}, this);
// Step 3: Call set() for each property that was specified as parameter to constructor.
// Use params hash created above to ignore side effects from step #2 above.
for(key in params){
this.set(key, params[key]);
}
},
postMixInProperties: function(){
// summary:
// Called after the parameters to the widget have been read-in,
// but before the widget template is instantiated. Especially
// useful to set properties that are referenced in the widget
// template.
// tags:
// protected
},
buildRendering: function(){
// summary:
// Construct the UI for this widget, setting this.domNode.
// Most widgets will mixin `dijit._TemplatedMixin`, which implements this method.
// tags:
// protected
if(!this.domNode){
// Create root node if it wasn't created by _TemplatedMixin
this.domNode = this.srcNodeRef || this.ownerDocument.createElement("div");
}
// baseClass is a single class name or occasionally a space-separated list of names.
// Add those classes to the DOMNode. If RTL mode then also add with Rtl suffix.
// TODO: make baseClass custom setter
if(this.baseClass){
var classes = this.baseClass.split(" ");
if(!this.isLeftToRight()){
classes = classes.concat(array.map(classes, function(name){
return name + "Rtl";
}));
}
domClass.add(this.domNode, classes);
}
},
postCreate: function(){
// summary:
// Processing after the DOM fragment is created
// description:
// Called after the DOM fragment has been created, but not necessarily
// added to the document. Do not include any operations which rely on
// node dimensions or placement.
// tags:
// protected
},
startup: function(){
// summary:
// Processing after the DOM fragment is added to the document
// description:
// Called after a widget and its children have been created and added to the page,
// and all related widgets have finished their create() cycle, up through postCreate().
//
// Note that startup() may be called while the widget is still hidden, for example if the widget is
// inside a hidden dijit/Dialog or an unselected tab of a dijit/layout/TabContainer.
// For widgets that need to do layout, it's best to put that layout code inside resize(), and then
// extend dijit/layout/_LayoutWidget so that resize() is called when the widget is visible.
if(this._started){
return;
}
this._started = true;
array.forEach(this.getChildren(), function(obj){
if(!obj._started && !obj._destroyed && lang.isFunction(obj.startup)){
obj.startup();
obj._started = true;
}
});
},
//////////// DESTROY FUNCTIONS ////////////////////////////////
destroyRecursive: function(/*Boolean?*/ preserveDom){
// summary:
// Destroy this widget and its descendants
// description:
// This is the generic "destructor" function that all widget users
// should call to cleanly discard with a widget. Once a widget is
// destroyed, it is removed from the manager object.
// preserveDom:
// If true, this method will leave the original DOM structure
// alone of descendant Widgets. Note: This will NOT work with
// dijit._TemplatedMixin widgets.
this._beingDestroyed = true;
this.destroyDescendants(preserveDom);
this.destroy(preserveDom);
},
destroy: function(/*Boolean*/ preserveDom){
// summary:
// Destroy this widget, but not its descendants. Descendants means widgets inside of
// this.containerNode. Will also destroy any resources (including widgets) registered via this.own().
//
// This method will also destroy internal widgets such as those created from a template,
// assuming those widgets exist inside of this.domNode but outside of this.containerNode.
//
// For 2.0 it's planned that this method will also destroy descendant widgets, so apps should not
// depend on the current ability to destroy a widget without destroying its descendants. Generally
// they should use destroyRecursive() for widgets with children.
// preserveDom: Boolean
// If true, this method will leave the original DOM structure alone.
// Note: This will not yet work with _TemplatedMixin widgets
this._beingDestroyed = true;
this.uninitialize();
function destroy(w){
if(w.destroyRecursive){
w.destroyRecursive(preserveDom);
}else if(w.destroy){
w.destroy(preserveDom);
}
}
// Back-compat, remove for 2.0
array.forEach(this._connects, lang.hitch(this, "disconnect"));
array.forEach(this._supportingWidgets, destroy);
// Destroy supporting widgets, but not child widgets under this.containerNode (for 2.0, destroy child widgets
// here too). if() statement is to guard against exception if destroy() called multiple times (see #15815).
if(this.domNode){
array.forEach(registry.findWidgets(this.domNode, this.containerNode), destroy);
}
this.destroyRendering(preserveDom);
registry.remove(this.id);
this._destroyed = true;
},
destroyRendering: function(/*Boolean?*/ preserveDom){
// summary:
// Destroys the DOM nodes associated with this widget.
// preserveDom:
// If true, this method will leave the original DOM structure alone
// during tear-down. Note: this will not work with _Templated
// widgets yet.
// tags:
// protected
if(this.bgIframe){
this.bgIframe.destroy(preserveDom);
delete this.bgIframe;
}
if(this.domNode){
if(preserveDom){
domAttr.remove(this.domNode, "widgetId");
}else{
domConstruct.destroy(this.domNode);
}
delete this.domNode;
}
if(this.srcNodeRef){
if(!preserveDom){
domConstruct.destroy(this.srcNodeRef);
}
delete this.srcNodeRef;
}
},
destroyDescendants: function(/*Boolean?*/ preserveDom){
// summary:
// Recursively destroy the children of this widget and their
// descendants.
// preserveDom:
// If true, the preserveDom attribute is passed to all descendant
// widget's .destroy() method. Not for use with _Templated
// widgets.
// get all direct descendants and destroy them recursively
array.forEach(this.getChildren(), function(widget){
if(widget.destroyRecursive){
widget.destroyRecursive(preserveDom);
}
});
},
uninitialize: function(){
// summary:
// Deprecated. Override destroy() instead to implement custom widget tear-down
// behavior.
// tags:
// protected
return false;
},
////////////////// GET/SET, CUSTOM SETTERS, ETC. ///////////////////
_setStyleAttr: function(/*String||Object*/ value){
// summary:
// Sets the style attribute of the widget according to value,
// which is either a hash like {height: "5px", width: "3px"}
// or a plain string
// description:
// Determines which node to set the style on based on style setting
// in attributeMap.
// tags:
// protected
var mapNode = this.domNode;
// Note: technically we should revert any style setting made in a previous call
// to his method, but that's difficult to keep track of.
if(lang.isObject(value)){
domStyle.set(mapNode, value);
}else{
if(mapNode.style.cssText){
mapNode.style.cssText += "; " + value;
}else{
mapNode.style.cssText = value;
}
}
this._set("style", value);
},
_attrToDom: function(/*String*/ attr, /*String*/ value, /*Object?*/ commands){
// summary:
// Reflect a widget attribute (title, tabIndex, duration etc.) to
// the widget DOM, as specified by commands parameter.
// If commands isn't specified then it's looked up from attributeMap.
// Note some attributes like "type"
// cannot be processed this way as they are not mutable.
// attr:
// Name of member variable (ex: "focusNode" maps to this.focusNode) pointing
// to DOMNode inside the widget, or alternately pointing to a subwidget
// tags:
// private
commands = arguments.length >= 3 ? commands : this.attributeMap[attr];
array.forEach(lang.isArray(commands) ? commands : [commands], function(command){
// Get target node and what we are doing to that node
var mapNode = this[command.node || command || "domNode"]; // DOM node
var type = command.type || "attribute"; // class, innerHTML, innerText, or attribute
switch(type){
case "attribute":
if(lang.isFunction(value)){ // functions execute in the context of the widget
value = lang.hitch(this, value);
}
// Get the name of the DOM node attribute; usually it's the same
// as the name of the attribute in the widget (attr), but can be overridden.
// Also maps handler names to lowercase, like onSubmit --> onsubmit
var attrName = command.attribute ? command.attribute :
(/^on[A-Z][a-zA-Z]*$/.test(attr) ? attr.toLowerCase() : attr);
if(mapNode.tagName){
// Normal case, mapping to a DOMNode. Note that modern browsers will have a mapNode.set()
// method, but for consistency we still call domAttr
domAttr.set(mapNode, attrName, value);
}else{
// mapping to a sub-widget
mapNode.set(attrName, value);
}
break;
case "innerText":
mapNode.innerHTML = "";
mapNode.appendChild(this.ownerDocument.createTextNode(value));
break;
case "innerHTML":
mapNode.innerHTML = value;
break;
case "class":
domClass.replace(mapNode, value, this[attr]);
break;
case "toggleClass":
domClass.toggle(mapNode, command.className || attr, value);
break;
}
}, this);
},
get: function(name){
// summary:
// Get a property from a widget.
// name:
// The property to get.
// description:
// Get a named property from a widget. The property may
// potentially be retrieved via a getter method. If no getter is defined, this
// just retrieves the object's property.
//
// For example, if the widget has properties `foo` and `bar`
// and a method named `_getFooAttr()`, calling:
// `myWidget.get("foo")` would be equivalent to calling
// `widget._getFooAttr()` and `myWidget.get("bar")`
// would be equivalent to the expression
// `widget.bar2`
var names = this._getAttrNames(name);
return this[names.g] ? this[names.g]() : this._get(name);
},
set: function(name, value){
// summary:
// Set a property on a widget
// name:
// The property to set.
// value:
// The value to set in the property.
// description:
// Sets named properties on a widget which may potentially be handled by a
// setter in the widget.
//
// For example, if the widget has properties `foo` and `bar`
// and a method named `_setFooAttr()`, calling
// `myWidget.set("foo", "Howdy!")` would be equivalent to calling
// `widget._setFooAttr("Howdy!")` and `myWidget.set("bar", 3)`
// would be equivalent to the statement `widget.bar = 3;`
//
// set() may also be called with a hash of name/value pairs, ex:
//
// | myWidget.set({
// | foo: "Howdy",
// | bar: 3
// | });
//
// This is equivalent to calling `set(foo, "Howdy")` and `set(bar, 3)`
if(typeof name === "object"){
for(var x in name){
this.set(x, name[x]);
}
return this;
}
var names = this._getAttrNames(name),
setter = this[names.s];
if(lang.isFunction(setter)){
// use the explicit setter
var result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
}else{
// Mapping from widget attribute to DOMNode/subwidget attribute/value/etc.
// Map according to:
// 1. attributeMap setting, if one exists (TODO: attributeMap deprecated, remove in 2.0)
// 2. _setFooAttr: {...} type attribute in the widget (if one exists)
// 3. apply to focusNode or domNode if standard attribute name, excluding funcs like onClick.
// Checks if an attribute is a "standard attribute" by whether the DOMNode JS object has a similar
// attribute name (ex: accept-charset attribute matches jsObject.acceptCharset).
// Note also that Tree.focusNode() is a function not a DOMNode, so test for that.
var defaultNode = this.focusNode && !lang.isFunction(this.focusNode) ? "focusNode" : "domNode",
tag = this[defaultNode] && this[defaultNode].tagName,
attrsForTag = tag && (tagAttrs[tag] || (tagAttrs[tag] = getAttrs(this[defaultNode]))),
map = name in this.attributeMap ? this.attributeMap[name] :
names.s in this ? this[names.s] :
((attrsForTag && names.l in attrsForTag && typeof value != "function") ||
/^aria-|^data-|^role$/.test(name)) ? defaultNode : null;
if(map != null){
this._attrToDom(name, value, map);
}
this._set(name, value);
}
return result || this;
},
_attrPairNames: {}, // shared between all widgets
_getAttrNames: function(name){
// summary:
// Helper function for get() and set().
// Caches attribute name values so we don't do the string ops every time.
// tags:
// private
var apn = this._attrPairNames;
if(apn[name]){
return apn[name];
}
var uc = name.replace(/^[a-z]|-[a-zA-Z]/g, function(c){
return c.charAt(c.length - 1).toUpperCase();
});
return (apn[name] = {
n: name + "Node",
s: "_set" + uc + "Attr", // converts dashes to camel case, ex: accept-charset --> _setAcceptCharsetAttr
g: "_get" + uc + "Attr",
l: uc.toLowerCase() // lowercase name w/out dashes, ex: acceptcharset
});
},
_set: function(/*String*/ name, /*anything*/ value){
// summary:
// Helper function to set new value for specified property, and call handlers
// registered with watch() if the value has changed.
var oldValue = this[name];
this[name] = value;
if(this._created && !isEqual(oldValue, value)){
if(this._watchCallbacks){
this._watchCallbacks(name, oldValue, value);
}
this.emit("attrmodified-" + name, {
detail: {
prevValue: oldValue,
newValue: value
}
});
}
},
_get: function(/*String*/ name){
// summary:
// Helper function to get value for specified property stored by this._set(),
// i.e. for properties with custom setters. Used mainly by custom getters.
//
// For example, CheckBox._getValueAttr() calls this._get("value").
// future: return name in this.props ? this.props[name] : this[name];
return this[name];
},
emit: function(/*String*/ type, /*Object?*/ eventObj, /*Array?*/ callbackArgs){
// summary:
// Used by widgets to signal that a synthetic event occurred, ex:
// | myWidget.emit("attrmodified-selectedChildWidget", {}).
//
// Emits an event on this.domNode named type.toLowerCase(), based on eventObj.
// Also calls onType() method, if present, and returns value from that method.
// By default passes eventObj to callback, but will pass callbackArgs instead, if specified.
// Modifies eventObj by adding missing parameters (bubbles, cancelable, widget).
// tags:
// protected
// Specify fallback values for bubbles, cancelable in case they are not set in eventObj.
// Also set pointer to widget, although since we can't add a pointer to the widget for native events
// (see #14729), maybe we shouldn't do it here?
eventObj = eventObj || {};
if(eventObj.bubbles === undefined){
eventObj.bubbles = true;
}
if(eventObj.cancelable === undefined){
eventObj.cancelable = true;
}
if(!eventObj.detail){
eventObj.detail = {};
}
eventObj.detail.widget = this;
var ret, callback = this["on" + type];
if(callback){
ret = callback.apply(this, callbackArgs ? callbackArgs : [eventObj]);
}
// Emit event, but avoid spurious emit()'s as parent sets properties on child during startup/destroy
if(this._started && !this._beingDestroyed){
on.emit(this.domNode, type.toLowerCase(), eventObj);
}
return ret;
},
on: function(/*String|Function*/ type, /*Function*/ func){
// summary:
// Call specified function when event occurs, ex: myWidget.on("click", function(){ ... }).
// type:
// Name of event (ex: "click") or extension event like touch.press.
// description:
// Call specified function when event `type` occurs, ex: `myWidget.on("click", function(){ ... })`.
// Note that the function is not run in any particular scope, so if (for example) you want it to run in the
// widget's scope you must do `myWidget.on("click", lang.hitch(myWidget, func))`.
// For backwards compatibility, if there's an onType() method in the widget then connect to that.
// Remove in 2.0.
var widgetMethod = this._onMap(type);
if(widgetMethod){
return aspect.after(this, widgetMethod, func, true);
}
// Otherwise, just listen for the event on this.domNode.
return this.own(on(this.domNode, type, func))[0];
},
_onMap: function(/*String|Function*/ type){
// summary:
// Maps on() type parameter (ex: "mousemove") to method name (ex: "onMouseMove").
// If type is a synthetic event like touch.press then returns undefined.
var ctor = this.constructor, map = ctor._onMap;
if(!map){
map = (ctor._onMap = {});
for(var attr in ctor.prototype){
if(/^on/.test(attr)){
map[attr.replace(/^on/, "").toLowerCase()] = attr;
}
}
}
return map[typeof type == "string" && type.toLowerCase()]; // String
},
toString: function(){
// summary:
// Returns a string that represents the widget.
// description:
// When a widget is cast to a string, this method will be used to generate the
// output. Currently, it does not implement any sort of reversible
// serialization.
return '[Widget ' + this.declaredClass + ', ' + (this.id || 'NO ID') + ']'; // String
},
getChildren: function(){
// summary:
// Returns all direct children of this widget, i.e. all widgets underneath this.containerNode whose parent
// is this widget. Note that it does not return all descendants, but rather just direct children.
// Analogous to [Node.childNodes](https://developer.mozilla.org/en-US/docs/DOM/Node.childNodes),
// except containing widgets rather than DOMNodes.
//
// The result intentionally excludes internally created widgets (a.k.a. supporting widgets)
// outside of this.containerNode.
//
// Note that the array returned is a simple array. Application code should not assume
// existence of methods like forEach().
return this.containerNode ? registry.findWidgets(this.containerNode) : []; // dijit/_WidgetBase[]
},
getParent: function(){
// summary:
// Returns the parent widget of this widget.
return registry.getEnclosingWidget(this.domNode.parentNode);
},
connect: function(/*Object|null*/ obj, /*String|Function*/ event, /*String|Function*/ method){
// summary:
// Deprecated, will be removed in 2.0, use this.own(on(...)) or this.own(aspect.after(...)) instead.
//
// Connects specified obj/event to specified method of this object
// and registers for disconnect() on widget destroy.
//
// Provide widget-specific analog to dojo.connect, except with the
// implicit use of this widget as the target object.
// Events connected with `this.connect` are disconnected upon
// destruction.
// returns:
// A handle that can be passed to `disconnect` in order to disconnect before
// the widget is destroyed.
// example:
// | var btn = new Button();
// | // when foo.bar() is called, call the listener we're going to
// | // provide in the scope of btn
// | btn.connect(foo, "bar", function(){
// | console.debug(this.toString());
// | });
// tags:
// protected
return this.own(connect.connect(obj, event, this, method))[0]; // handle
},
disconnect: function(handle){
// summary:
// Deprecated, will be removed in 2.0, use handle.remove() instead.
//
// Disconnects handle created by `connect`.
// tags:
// protected
handle.remove();
},
subscribe: function(t, method){
// summary:
// Deprecated, will be removed in 2.0, use this.own(topic.subscribe()) instead.
//
// Subscribes to the specified topic and calls the specified method
// of this object and registers for unsubscribe() on widget destroy.
//
// Provide widget-specific analog to dojo.subscribe, except with the
// implicit use of this widget as the target object.
// t: String
// The topic
// method: Function
// The callback
// example:
// | var btn = new Button();
// | // when /my/topic is published, this button changes its label to
// | // be the parameter of the topic.
// | btn.subscribe("/my/topic", function(v){
// | this.set("label", v);
// | });
// tags:
// protected
return this.own(topic.subscribe(t, lang.hitch(this, method)))[0]; // handle
},
unsubscribe: function(/*Object*/ handle){
// summary:
// Deprecated, will be removed in 2.0, use handle.remove() instead.
//
// Unsubscribes handle created by this.subscribe.
// Also removes handle from this widget's list of subscriptions
// tags:
// protected
handle.remove();
},
isLeftToRight: function(){
// summary:
// Return this widget's explicit or implicit orientation (true for LTR, false for RTL)
// tags:
// protected
return this.dir ? (this.dir.toLowerCase() == "ltr") : domGeometry.isBodyLtr(this.ownerDocument); //Boolean
},
isFocusable: function(){
// summary:
// Return true if this widget can currently be focused
// and false if not
return this.focus && (domStyle.get(this.domNode, "display") != "none");
},
placeAt: function(/*String|DomNode|DocumentFragment|dijit/_WidgetBase*/ reference, /*String|Int?*/ position){
// summary:
// Place this widget somewhere in the DOM based
// on standard domConstruct.place() conventions.
// description:
// A convenience function provided in all _Widgets, providing a simple
// shorthand mechanism to put an existing (or newly created) Widget
// somewhere in the dom, and allow chaining.
// reference:
// Widget, DOMNode, DocumentFragment, or id of widget or DOMNode
// position:
// If reference is a widget (or id of widget), and that widget has an ".addChild" method,
// it will be called passing this widget instance into that method, supplying the optional
// position index passed. In this case position (if specified) should be an integer.
//
// If reference is a DOMNode (or id matching a DOMNode but not a widget),
// the position argument can be a numeric index or a string
// "first", "last", "before", or "after", same as dojo/dom-construct::place().
// returns: dijit/_WidgetBase
// Provides a useful return of the newly created dijit._Widget instance so you
// can "chain" this function by instantiating, placing, then saving the return value
// to a variable.
// example:
// | // create a Button with no srcNodeRef, and place it in the body:
// | var button = new Button({ label:"click" }).placeAt(win.body());
// | // now, 'button' is still the widget reference to the newly created button
// | button.on("click", function(e){ console.log('click'); }));
// example:
// | // create a button out of a node with id="src" and append it to id="wrapper":
// | var button = new Button({},"src").placeAt("wrapper");
// example:
// | // place a new button as the first element of some div
// | var button = new Button({ label:"click" }).placeAt("wrapper","first");
// example:
// | // create a contentpane and add it to a TabContainer
// | var tc = dijit.byId("myTabs");
// | new ContentPane({ href:"foo.html", title:"Wow!" }).placeAt(tc)
var refWidget = !reference.tagName && registry.byId(reference);
if(refWidget && refWidget.addChild && (!position || typeof position === "number")){
// Adding this to refWidget and can use refWidget.addChild() to handle everything.
refWidget.addChild(this, position);
}else{
// "reference" is a plain DOMNode, or we can't use refWidget.addChild(). Use domConstruct.place() and
// target refWidget.containerNode for nested placement (position==number, "first", "last", "only"), and
// refWidget.domNode otherwise ("after"/"before"/"replace"). (But not supported officially, see #14946.)
var ref = refWidget && ("domNode" in refWidget) ?
(refWidget.containerNode && !/after|before|replace/.test(position || "") ?
refWidget.containerNode : refWidget.domNode) : dom.byId(reference, this.ownerDocument);
domConstruct.place(this.domNode, ref, position);
// Start this iff it has a parent widget that's already started.
// TODO: for 2.0 maybe it should also start the widget when this.getParent() returns null??
if(!this._started && (this.getParent() || {})._started){
this.startup();
}
}
return this;
},
defer: function(fcn, delay){
// summary:
// Wrapper to setTimeout to avoid deferred functions executing
// after the originating widget has been destroyed.
// Returns an object handle with a remove method (that returns null) (replaces clearTimeout).
// fcn: Function
// Function reference.
// delay: Number?
// Delay, defaults to 0.
// tags:
// protected
var timer = setTimeout(lang.hitch(this,
function(){
if(!timer){
return;
}
timer = null;
if(!this._destroyed){
lang.hitch(this, fcn)();
}
}),
delay || 0
);
return {
remove: function(){
if(timer){
clearTimeout(timer);
timer = null;
}
return null; // so this works well: handle = handle.remove();
}
};
}
});
if(has("dojo-bidi")){
_WidgetBase.extend(_BidiMixin);
}
return _WidgetBase;
});
},
'dojo/Stateful':function(){
define(["./_base/declare", "./_base/lang", "./_base/array", "./when"], function(declare, lang, array, when){
// module:
// dojo/Stateful
return declare("dojo.Stateful", null, {
// summary:
// Base class for objects that provide named properties with optional getter/setter
// control and the ability to watch for property changes
//
// The class also provides the functionality to auto-magically manage getters
// and setters for object attributes/properties.
//
// Getters and Setters should follow the format of _xxxGetter or _xxxSetter where
// the xxx is a name of the attribute to handle. So an attribute of "foo"
// would have a custom getter of _fooGetter and a custom setter of _fooSetter.
//
// example:
// | require(["dojo/Stateful", function(Stateful) {
// | var obj = new Stateful();
// | obj.watch("foo", function(){
// | console.log("foo changed to " + this.get("foo"));
// | });
// | obj.set("foo","bar");
// | });
// _attrPairNames: Hash
// Used across all instances a hash to cache attribute names and their getter
// and setter names.
_attrPairNames: {},
_getAttrNames: function(name){
// summary:
// Helper function for get() and set().
// Caches attribute name values so we don't do the string ops every time.
// tags:
// private
var apn = this._attrPairNames;
if(apn[name]){ return apn[name]; }
return (apn[name] = {
s: "_" + name + "Setter",
g: "_" + name + "Getter"
});
},
postscript: function(/*Object?*/ params){
// Automatic setting of params during construction
if (params){ this.set(params); }
},
_get: function(name, names){
// summary:
// Private function that does a get based off a hash of names
// names:
// Hash of names of custom attributes
return typeof this[names.g] === "function" ? this[names.g]() : this[name];
},
get: function(/*String*/name){
// summary:
// Get a property on a Stateful instance.
// name:
// The property to get.
// returns:
// The property value on this Stateful instance.
// description:
// Get a named property on a Stateful object. The property may
// potentially be retrieved via a getter method in subclasses. In the base class
// this just retrieves the object's property.
// example:
// | require(["dojo/Stateful", function(Stateful) {
// | var stateful = new Stateful({foo: 3});
// | stateful.get("foo") // returns 3
// | stateful.foo // returns 3
// | });
return this._get(name, this._getAttrNames(name)); //Any
},
set: function(/*String*/name, /*Object*/value){
// summary:
// Set a property on a Stateful instance
// name:
// The property to set.
// value:
// The value to set in the property.
// returns:
// The function returns this dojo.Stateful instance.
// description:
// Sets named properties on a stateful object and notifies any watchers of
// the property. A programmatic setter may be defined in subclasses.
// example:
// | require(["dojo/Stateful", function(Stateful) {
// | var stateful = new Stateful();
// | stateful.watch(function(name, oldValue, value){
// | // this will be called on the set below
// | }
// | stateful.set(foo, 5);
// set() may also be called with a hash of name/value pairs, ex:
// | stateful.set({
// | foo: "Howdy",
// | bar: 3
// | });
// | });
// This is equivalent to calling set(foo, "Howdy") and set(bar, 3)
// If an object is used, iterate through object
if(typeof name === "object"){
for(var x in name){
if(name.hasOwnProperty(x) && x !="_watchCallbacks"){
this.set(x, name[x]);
}
}
return this;
}
var names = this._getAttrNames(name),
oldValue = this._get(name, names),
setter = this[names.s],
result;
if(typeof setter === "function"){
// use the explicit setter
result = setter.apply(this, Array.prototype.slice.call(arguments, 1));
}else{
// no setter so set attribute directly
this[name] = value;
}
if(this._watchCallbacks){
var self = this;
// If setter returned a promise, wait for it to complete, otherwise call watches immediately
when(result, function(){
self._watchCallbacks(name, oldValue, value);
});
}
return this; // dojo/Stateful
},
_changeAttrValue: function(name, value){
// summary:
// Internal helper for directly changing an attribute value.
//
// name: String
// The property to set.
// value: Mixed
// The value to set in the property.
//
// description:
// Directly change the value of an attribute on an object, bypassing any
// accessor setter. Also handles the calling of watch and emitting events.
// It is designed to be used by descendant class when there are two values
// of attributes that are linked, but calling .set() is not appropriate.
var oldValue = this.get(name);
this[name] = value;
if(this._watchCallbacks){
this._watchCallbacks(name, oldValue, value);
}
return this; // dojo/Stateful
},
watch: function(/*String?*/name, /*Function*/callback){
// summary:
// Watches a property for changes
// name:
// Indicates the property to watch. This is optional (the callback may be the
// only parameter), and if omitted, all the properties will be watched
// returns:
// An object handle for the watch. The unwatch method of this object
// can be used to discontinue watching this property:
// | var watchHandle = obj.watch("foo", callback);
// | watchHandle.unwatch(); // callback won't be called now
// callback:
// The function to execute when the property changes. This will be called after
// the property has been changed. The callback will be called with the |this|
// set to the instance, the first argument as the name of the property, the
// second argument as the old value and the third argument as the new value.
var callbacks = this._watchCallbacks;
if(!callbacks){
var self = this;
callbacks = this._watchCallbacks = function(name, oldValue, value, ignoreCatchall){
var notify = function(propertyCallbacks){
if(propertyCallbacks){
propertyCallbacks = propertyCallbacks.slice();
for(var i = 0, l = propertyCallbacks.length; i < l; i++){
propertyCallbacks[i].call(self, name, oldValue, value);
}
}
};
notify(callbacks['_' + name]);
if(!ignoreCatchall){
notify(callbacks["*"]); // the catch-all
}
}; // we use a function instead of an object so it will be ignored by JSON conversion
}
if(!callback && typeof name === "function"){
callback = name;
name = "*";
}else{
// prepend with dash to prevent name conflicts with function (like "name" property)
name = '_' + name;
}
var propertyCallbacks = callbacks[name];
if(typeof propertyCallbacks !== "object"){
propertyCallbacks = callbacks[name] = [];
}
propertyCallbacks.push(callback);
// TODO: Remove unwatch in 2.0
var handle = {};
handle.unwatch = handle.remove = function(){
var index = array.indexOf(propertyCallbacks, callback);
if(index > -1){
propertyCallbacks.splice(index, 1);
}
};
return handle; //Object
}
});
});
},
'dijit/Destroyable':function(){
define([
"dojo/_base/array", // array.forEach array.map
"dojo/aspect",
"dojo/_base/declare"
], function(array, aspect, declare){
// module:
// dijit/Destroyable
return declare("dijit.Destroyable", null, {
// summary:
// Mixin to track handles and release them when instance is destroyed.
// description:
// Call this.own(...) on list of handles (returned from dojo/aspect, dojo/on,
// dojo/Stateful::watch, or any class (including widgets) with a destroyRecursive() or destroy() method.
// Then call destroy() later to destroy this instance and release the resources.
destroy: function(/*Boolean*/ preserveDom){
// summary:
// Destroy this class, releasing any resources registered via own().
this._destroyed = true;
},
own: function(){
// summary:
// Track specified handles and remove/destroy them when this instance is destroyed, unless they were
// already removed/destroyed manually.
// tags:
// protected
// returns:
// The array of specified handles, so you can do for example:
// | var handle = this.own(on(...))[0];
var cleanupMethods = [
"destroyRecursive",
"destroy",
"remove"
];
array.forEach(arguments, function(handle){
// When this.destroy() is called, destroy handle. Since I'm using aspect.before(),
// the handle will be destroyed before a subclass's destroy() method starts running, before it calls
// this.inherited() or even if it doesn't call this.inherited() at all. If that's an issue, make an
// onDestroy() method and connect to that instead.
var destroyMethodName;
var odh = aspect.before(this, "destroy", function (preserveDom){
handle[destroyMethodName](preserveDom);
});
// Callback for when handle is manually destroyed.
var hdhs = [];
function onManualDestroy(){
odh.remove();
array.forEach(hdhs, function(hdh){
hdh.remove();
});
}
// Setup listeners for manual destroy of handle.
// Also computes destroyMethodName, used in listener above.
if(handle.then){
// Special path for Promises. Detect when Promise is resolved, rejected, or
// canceled (nb: cancelling a Promise causes it to be rejected).
destroyMethodName = "cancel";
handle.then(onManualDestroy, onManualDestroy);
}else{
// Path for other handles. Just use AOP to detect when handle is manually destroyed.
array.forEach(cleanupMethods, function(cleanupMethod){
if(typeof handle[cleanupMethod] === "function"){
if(!destroyMethodName){
// Use first matching method name in above listener (prefer destroyRecursive() to destroy())
destroyMethodName = cleanupMethod;
}
hdhs.push(aspect.after(handle, cleanupMethod, onManualDestroy, true));
}
});
}
}, this);
return arguments; // handle
}
});
});
},
'dijit/registry':function(){
define([
"dojo/_base/array", // array.forEach array.map
"dojo/_base/window", // win.body
"./main" // dijit._scopeName
], function(array, win, dijit){
// module:
// dijit/registry
var _widgetTypeCtr = {}, hash = {};
var registry = {
// summary:
// Registry of existing widget on page, plus some utility methods.
// length: Number
// Number of registered widgets
length: 0,
add: function(widget){
// summary:
// Add a widget to the registry. If a duplicate ID is detected, a error is thrown.
// widget: dijit/_WidgetBase
// Any dijit/_WidgetBase subclass.
if(hash[widget.id]){
throw new Error("Tried to register widget with id==" + widget.id + " but that id is already registered");
}
hash[widget.id] = widget;
this.length++;
},
remove: function(/*String*/ id){
// summary:
// Remove a widget from the registry. Does not destroy the widget; simply
// removes the reference.
if(hash[id]){
delete hash[id];
this.length--;
}
},
byId: function(/*String|Widget*/ id){
// summary:
// Find a widget by it's id.
// If passed a widget then just returns the widget.
return typeof id == "string" ? hash[id] : id; // dijit/_WidgetBase
},
byNode: function(/*DOMNode*/ node){
// summary:
// Returns the widget corresponding to the given DOMNode
return hash[node.getAttribute("widgetId")]; // dijit/_WidgetBase
},
toArray: function(){
// summary:
// Convert registry into a true Array
//
// example:
// Work with the widget .domNodes in a real Array
// | array.map(registry.toArray(), function(w){ return w.domNode; });
var ar = [];
for(var id in hash){
ar.push(hash[id]);
}
return ar; // dijit/_WidgetBase[]
},
getUniqueId: function(/*String*/widgetType){
// summary:
// Generates a unique id for a given widgetType
var id;
do{
id = widgetType + "_" +
(widgetType in _widgetTypeCtr ?
++_widgetTypeCtr[widgetType] : _widgetTypeCtr[widgetType] = 0);
}while(hash[id]);
return dijit._scopeName == "dijit" ? id : dijit._scopeName + "_" + id; // String
},
findWidgets: function(root, skipNode){
// summary:
// Search subtree under root returning widgets found.
// Doesn't search for nested widgets (ie, widgets inside other widgets).
// root: DOMNode
// Node to search under.
// skipNode: DOMNode
// If specified, don't search beneath this node (usually containerNode).
var outAry = [];
function getChildrenHelper(root){
for(var node = root.firstChild; node; node = node.nextSibling){
if(node.nodeType == 1){
var widgetId = node.getAttribute("widgetId");
if(widgetId){
var widget = hash[widgetId];
if(widget){ // may be null on page w/multiple dojo's loaded
outAry.push(widget);
}
}else if(node !== skipNode){
getChildrenHelper(node);
}
}
}
}
getChildrenHelper(root);
return outAry;
},
_destroyAll: function(){
// summary:
// Code to destroy all widgets and do other cleanup on page unload
// Clean up focus manager lingering references to widgets and nodes
dijit._curFocus = null;
dijit._prevFocus = null;
dijit._activeStack = [];
// Destroy all the widgets, top down
array.forEach(registry.findWidgets(win.body()), function(widget){
// Avoid double destroy of widgets like Menu that are attached to
// even though they are logically children of other widgets.
if(!widget._destroyed){
if(widget.destroyRecursive){
widget.destroyRecursive();
}else if(widget.destroy){
widget.destroy();
}
}
});
},
getEnclosingWidget: function(/*DOMNode*/ node){
// summary:
// Returns the widget whose DOM tree contains the specified DOMNode, or null if
// the node is not contained within the DOM tree of any widget
while(node){
var id = node.nodeType == 1 && node.getAttribute("widgetId");
if(id){
return hash[id];
}
node = node.parentNode;
}
return null;
},
// In case someone needs to access hash.
// Actually, this is accessed from WidgetSet back-compatibility code
_hash: hash
};
dijit.registry = registry;
return registry;
});
},
'dijit/main':function(){
define([
"dojo/_base/kernel"
], function(dojo){
// module:
// dijit/main
/*=====
return {
// summary:
// The dijit package main module.
// Deprecated. Users should access individual modules (ex: dijit/registry) directly.
};
=====*/
return dojo.dijit;
});
},
'dojox/charting/Chart':function(){
define(["../main", "dojo/_base/lang", "dojo/_base/array","dojo/_base/declare", "dojo/dom-style",
"dojo/dom", "dojo/dom-geometry", "dojo/dom-construct","dojo/_base/Color", "dojo/sniff",
"./Element", "./SimpleTheme", "./Series", "./axis2d/common", "./plot2d/common", "dojox/gfx/shape",
"dojox/gfx", "dojo/has!dojo-bidi?./bidi/Chart", "dojox/lang/functional", "dojox/lang/functional/fold", "dojox/lang/functional/reversed"],
function(dojox, lang, arr, declare, domStyle,
dom, domGeom, domConstruct, Color, has,
Element, SimpleTheme, Series, common, plot2dCommon, shape,
g, BidiChart, func){
/*=====
var __ChartCtorArgs = {
// summary:
// The keyword arguments that can be passed in a Chart constructor.
// margins: Object?
// Optional margins for the chart, in the form of { l, t, r, b}.
// stroke: dojox.gfx.Stroke?
// An optional outline/stroke for the chart.
// fill: dojox.gfx.Fill?
// An optional fill for the chart.
// delayInMs: Number
// Delay in ms for delayedRender(). Default: 200.
};
=====*/
/*=====
var __SeriesCtorArgs = {
// summary:
// An optional arguments object that can be used in the Series constructor.
// plot: String?
// The plot (by name) that this series belongs to.
};
=====*/
/*=====
var __BaseAxisCtorArgs = {
// summary:
// Optional arguments used in the definition of an invisible axis.
// vertical: Boolean?
// A flag that says whether an axis is vertical (i.e. y axis) or horizontal. Default is false (horizontal).
// min: Number?
// The smallest value on an axis. Default is 0.
// max: Number?
// The largest value on an axis. Default is 1.
};
=====*/
var dc = lang.getObject("charting", true, dojox),
defaultMargins = {l: 10, t: 10, r: 10, b: 10};
function clear (item) {
return item.clear();
}
function destroy (item) {
return item.destroy();
}
function makeClean (item) {
item.dirty = false;
return false;
}
function makeDirty (item) {
item.dirty = true;
return true;
}
function getName (item) {
return item.name;
}
var Chart = declare(has("dojo-bidi")? "dojox.charting.NonBidiChart" : "dojox.charting.Chart", null, {
// summary:
// The main chart object in dojox.charting. This will create a two dimensional
// chart based on dojox.gfx.
//
// description:
// dojox.charting.Chart is the primary object used for any kind of charts. It
// is simple to create--just pass it a node reference, which is used as the
// container for the chart--and a set of optional keyword arguments and go.
//
// Note that like most of dojox.gfx, most of dojox.charting.Chart's methods are
// designed to return a reference to the chart itself, to allow for functional
// chaining. This makes defining everything on a Chart very easy to do.
//
// example:
// Create an area chart, with smoothing.
// | require(["dojox/charting/Chart", "dojox/charting/themes/Shrooms", "dojox/charting/plot2d/Areas", ...],
// | function(Chart, Shrooms, Areas, ...){
// | new Chart(node)
// | .addPlot("default", { type: Areas, tension: "X" })
// | .setTheme(Shrooms)
// | .addSeries("Series A", [1, 2, 0.5, 1.5, 1, 2.8, 0.4])
// | .addSeries("Series B", [2.6, 1.8, 2, 1, 1.4, 0.7, 2])
// | .addSeries("Series C", [6.3, 1.8, 3, 0.5, 4.4, 2.7, 2])
// | .render();
// | });
//
// example:
// The form of data in a data series can take a number of forms: a simple array,
// an array of objects {x,y}, or something custom (as determined by the plot).
// Here's an example of a Candlestick chart, which expects an object of
// { open, high, low, close }.
// | require(["dojox/charting/Chart", "dojox/charting/plot2d/Candlesticks", ...],
// | function(Chart, Candlesticks, ...){
// | new Chart(node)
// | .addPlot("default", {type: Candlesticks, gap: 1})
// | .addAxis("x", {fixLower: "major", fixUpper: "major", includeZero: true})
// | .addAxis("y", {vertical: true, fixLower: "major", fixUpper: "major", natural: true})
// | .addSeries("Series A", [
// | { open: 20, close: 16, high: 22, low: 8 },
// | { open: 16, close: 22, high: 26, low: 6, mid: 18 },
// | { open: 22, close: 18, high: 22, low: 11, mid: 21 },
// | { open: 18, close: 29, high: 32, low: 14, mid: 27 },
// | { open: 29, close: 24, high: 29, low: 13, mid: 27 },
// | { open: 24, close: 8, high: 24, low: 5 },
// | { open: 8, close: 16, high: 22, low: 2 },
// | { open: 16, close: 12, high: 19, low: 7 },
// | { open: 12, close: 20, high: 22, low: 8 },
// | { open: 20, close: 16, high: 22, low: 8 },
// | { open: 16, close: 22, high: 26, low: 6, mid: 18 },
// | { open: 22, close: 18, high: 22, low: 11, mid: 21 },
// | { open: 18, close: 29, high: 32, low: 14, mid: 27 },
// | { open: 29, close: 24, high: 29, low: 13, mid: 27 },
// | { open: 24, close: 8, high: 24, low: 5 },
// | { open: 8, close: 16, high: 22, low: 2 },
// | { open: 16, close: 12, high: 19, low: 7 },
// | { open: 12, close: 20, high: 22, low: 8 },
// | { open: 20, close: 16, high: 22, low: 8 },
// | { open: 16, close: 22, high: 26, low: 6 },
// | { open: 22, close: 18, high: 22, low: 11 },
// | { open: 18, close: 29, high: 32, low: 14 },
// | { open: 29, close: 24, high: 29, low: 13 },
// | { open: 24, close: 8, high: 24, low: 5 },
// | { open: 8, close: 16, high: 22, low: 2 },
// | { open: 16, close: 12, high: 19, low: 7 },
// | { open: 12, close: 20, high: 22, low: 8 },
// | { open: 20, close: 16, high: 22, low: 8 }
// | ],
// | { stroke: { color: "green" }, fill: "lightgreen" }
// | )
// | .render();
// | });
// theme: dojox/charting/SimpleTheme?
// An optional theme to use for styling the chart.
// axes: dojox/charting/axis2d/Base{}?
// A map of axes for use in plotting a chart.
// stack: dojox/charting/plot2d/Base[]
// A stack of plotters.
// plots: dojox/charting/plot2d/Base{}
// A map of plotter indices
// series: dojox/charting/Series[]
// The stack of data runs used to create plots.
// runs: dojox/charting/Series{}
// A map of series indices
// margins: Object?
// The margins around the chart. Default is { l:10, t:10, r:10, b:10 }.
// stroke: dojox.gfx.Stroke?
// The outline of the chart (stroke in vector graphics terms).
// fill: dojox.gfx.Fill?
// The color for the chart.
// node: DOMNode
// The container node passed to the constructor.
// surface: dojox/gfx/shape.Surface
// The main graphics surface upon which a chart is drawn.
// dirty: Boolean
// A boolean flag indicating whether or not the chart needs to be updated/re-rendered.
// htmlLabels: Boolean
// A boolean flag indicating whether or not it should try to use HTML-based labels for the title or not.
// The default is true. The only caveat is IE and Opera browsers will always use GFX-based labels.
constructor: function(/* DOMNode */node, /* __ChartCtorArgs? */kwArgs){
// summary:
// The constructor for a new Chart. Initializes all parameters used for a chart.
// returns: dojox/charting/Chart
// The newly created chart.
// initialize parameters
if(!kwArgs){ kwArgs = {}; }
this.margins = kwArgs.margins || defaultMargins;
this._customMargins = !!kwArgs.margins;
this.stroke = kwArgs.stroke;
this.fill = kwArgs.fill;
this.delayInMs = kwArgs.delayInMs || 200;
this.title = kwArgs.title;
this.titleGap = kwArgs.titleGap;
this.titlePos = kwArgs.titlePos;
this.titleFont = kwArgs.titleFont;
this.titleFontColor = kwArgs.titleFontColor;
this.titleAlign = kwArgs.titleAlign; // This can be middle, left, right, or edge
// edge is left or right aligned with chart plot edge depending on bidi.
this.chartTitle = null;
this.htmlLabels = true;
if("htmlLabels" in kwArgs){
this.htmlLabels = kwArgs.htmlLabels;
}
// default initialization
this.theme = null;
this.axes = {}; // map of axes
this.stack = []; // stack of plotters
this.plots = {}; // map of plotter indices
this.series = []; // stack of data runs
this.runs = {}; // map of data run indices
this.dirty = true;
// create a surface
this.node = dom.byId(node);
var box = domGeom.getMarginBox(node);
this.surface = g.createSurface(this.node, box.w || 400, box.h || 300);
if(this.surface.declaredClass.indexOf("vml") == -1){
// except if vml use native clipping
this._nativeClip = true;
}
},
destroy: function(){
// summary:
// Cleanup when a chart is to be destroyed.
// returns: void
arr.forEach(this.series, destroy);
arr.forEach(this.stack, destroy);
func.forIn(this.axes, destroy);
this.surface.destroy();
if(this.chartTitle && this.chartTitle.tagName){
// destroy title if it is a DOM node
domConstruct.destroy(this.chartTitle);
}
},
getCoords: function(){
// summary:
// Get the coordinates and dimensions of the containing DOMNode, as
// returned by dojo.coords.
// returns: Object
// The resulting coordinates of the chart. See dojo.coords for details.
var node = this.node;
var s = domStyle.getComputedStyle(node), coords = domGeom.getMarginBox(node, s);
var abs = domGeom.position(node, true);
coords.x = abs.x;
coords.y = abs.y;
return coords; // Object
},
setTheme: function(theme){
// summary:
// Set a theme of the chart.
// theme: dojox/charting/SimpleTheme
// The theme to be used for visual rendering.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
this.theme = theme.clone();
if(!this._customMargins){
this.margins = this.theme.chart.margins || defaultMargins;
}
this.dirty = true;
return this; // dojox/charting/Chart
},
addAxis: function(name, kwArgs){
// summary:
// Add an axis to the chart, for rendering.
// name: String
// The name of the axis.
// kwArgs: __BaseAxisCtorArgs?
// An optional keyword arguments object for use in defining details of an axis.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
var axis, axisType = kwArgs && kwArgs.type || "Default";
if(typeof axisType == "string"){
if(!dc.axis2d || !dc.axis2d[axisType]){
throw Error("Can't find axis: " + axisType + " - Check " + "require() dependencies.");
}
axis = new dc.axis2d[axisType](this, kwArgs);
}else{
axis = new axisType(this, kwArgs);
}
axis.name = name;
axis.dirty = true;
if(name in this.axes){
this.axes[name].destroy();
}
this.axes[name] = axis;
this.dirty = true;
return this; // dojox/charting/Chart
},
getAxis: function(name){
// summary:
// Get the given axis, by name.
// name: String
// The name the axis was defined by.
// returns: dojox/charting/axis2d/Default
// The axis as stored in the chart's axis map.
return this.axes[name]; // dojox/charting/axis2d/Default
},
removeAxis: function(name){
// summary:
// Remove the axis that was defined using name.
// name: String
// The axis name, as defined in addAxis.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.axes){
// destroy the axis
this.axes[name].destroy();
delete this.axes[name];
// mark the chart as dirty
this.dirty = true;
}
return this; // dojox/charting/Chart
},
addPlot: function(name, kwArgs){
// summary:
// Add a new plot to the chart, defined by name and using the optional keyword arguments object.
// Note that dojox.charting assumes the main plot to be called "default"; if you do not have
// a plot called "default" and attempt to add data series to the chart without specifying the
// plot to be rendered on, you WILL get errors.
// name: String
// The name of the plot to be added to the chart. If you only plan on using one plot, call it "default".
// kwArgs: dojox.charting.plot2d.__PlotCtorArgs
// An object with optional parameters for the plot in question.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
var plot, plotType = kwArgs && kwArgs.type || "Default";
if(typeof plotType == "string"){
if(!dc.plot2d || !dc.plot2d[plotType]){
throw Error("Can't find plot: " + plotType + " - didn't you forget to dojo" + ".require() it?");
}
plot = new dc.plot2d[plotType](this, kwArgs);
}else{
plot = new plotType(this, kwArgs);
}
plot.name = name;
plot.dirty = true;
if(name in this.plots){
this.stack[this.plots[name]].destroy();
this.stack[this.plots[name]] = plot;
}else{
this.plots[name] = this.stack.length;
this.stack.push(plot);
}
this.dirty = true;
return this; // dojox/charting/Chart
},
getPlot: function(name){
// summary:
// Get the given plot, by name.
// name: String
// The name the plot was defined by.
// returns: dojox/charting/plot2d/Base
// The plot.
return this.stack[this.plots[name]];
},
removePlot: function(name){
// summary:
// Remove the plot defined using name from the chart's plot stack.
// name: String
// The name of the plot as defined using addPlot.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.plots){
// get the index and remove the name
var index = this.plots[name];
delete this.plots[name];
// destroy the plot
this.stack[index].destroy();
// remove the plot from the stack
this.stack.splice(index, 1);
// update indices to reflect the shift
func.forIn(this.plots, function(idx, name, plots){
if(idx > index){
plots[name] = idx - 1;
}
});
// remove all related series
var ns = arr.filter(this.series, function(run){ return run.plot != name; });
if(ns.length < this.series.length){
// kill all removed series
arr.forEach(this.series, function(run){
if(run.plot == name){
run.destroy();
}
});
// rebuild all necessary data structures
this.runs = {};
arr.forEach(ns, function(run, index){
this.runs[run.plot] = index;
}, this);
this.series = ns;
}
// mark the chart as dirty
this.dirty = true;
}
return this; // dojox/charting/Chart
},
getPlotOrder: function(){
// summary:
// Returns an array of plot names in the current order
// (the top-most plot is the first).
// returns: Array
return func.map(this.stack, getName); // Array
},
setPlotOrder: function(newOrder){
// summary:
// Sets new order of plots. newOrder cannot add or remove
// plots. Wrong names, or dups are ignored.
// newOrder: Array
// Array of plot names compatible with getPlotOrder().
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
var names = {},
order = func.filter(newOrder, function(name){
if(!(name in this.plots) || (name in names)){
return false;
}
names[name] = 1;
return true;
}, this);
if(order.length < this.stack.length){
func.forEach(this.stack, function(plot){
var name = plot.name;
if(!(name in names)){
order.push(name);
}
});
}
var newStack = func.map(order, function(name){
return this.stack[this.plots[name]];
}, this);
func.forEach(newStack, function(plot, i){
this.plots[plot.name] = i;
}, this);
this.stack = newStack;
this.dirty = true;
return this; // dojox/charting/Chart
},
movePlotToFront: function(name){
// summary:
// Moves a given plot to front.
// name: String
// Plot's name to move.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.plots){
var index = this.plots[name];
if(index){
var newOrder = this.getPlotOrder();
newOrder.splice(index, 1);
newOrder.unshift(name);
return this.setPlotOrder(newOrder); // dojox/charting/Chart
}
}
return this; // dojox/charting/Chart
},
movePlotToBack: function(name){
// summary:
// Moves a given plot to back.
// name: String
// Plot's name to move.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.plots){
var index = this.plots[name];
if(index < this.stack.length - 1){
var newOrder = this.getPlotOrder();
newOrder.splice(index, 1);
newOrder.push(name);
return this.setPlotOrder(newOrder); // dojox/charting/Chart
}
}
return this; // dojox/charting/Chart
},
addSeries: function(name, data, kwArgs){
// summary:
// Add a data series to the chart for rendering.
// name: String
// The name of the data series to be plotted.
// data: Array|Object
// The array of data points (either numbers or objects) that
// represents the data to be drawn. Or it can be an object. In
// the latter case, it should have a property "data" (an array),
// destroy(), and setSeriesObject().
// kwArgs: __SeriesCtorArgs?
// An optional keyword arguments object that will be mixed into
// the resultant series object.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
var run = new Series(this, data, kwArgs);
run.name = name;
if(name in this.runs){
this.series[this.runs[name]].destroy();
this.series[this.runs[name]] = run;
}else{
this.runs[name] = this.series.length;
this.series.push(run);
}
this.dirty = true;
// fix min/max
if(!("ymin" in run) && "min" in run){ run.ymin = run.min; }
if(!("ymax" in run) && "max" in run){ run.ymax = run.max; }
return this; // dojox/charting/Chart
},
getSeries: function(name){
// summary:
// Get the given series, by name.
// name: String
// The name the series was defined by.
// returns: dojox/charting/Series
// The series.
return this.series[this.runs[name]];
},
removeSeries: function(name){
// summary:
// Remove the series defined by name from the chart.
// name: String
// The name of the series as defined by addSeries.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.runs){
// get the index and remove the name
var index = this.runs[name];
delete this.runs[name];
// destroy the run
this.series[index].destroy();
// remove the run from the stack of series
this.series.splice(index, 1);
// update indices to reflect the shift
func.forIn(this.runs, function(idx, name, runs){
if(idx > index){
runs[name] = idx - 1;
}
});
this.dirty = true;
}
return this; // dojox/charting/Chart
},
updateSeries: function(name, data, offsets){
// summary:
// Update the given series with a new set of data points.
// name: String
// The name of the series as defined in addSeries.
// data: Array|Object
// The array of data points (either numbers or objects) that
// represents the data to be drawn. Or it can be an object. In
// the latter case, it should have a property "data" (an array),
// destroy(), and setSeriesObject().
// offsets: Boolean?
// If true recomputes the offsets of the chart based on the new
// data. This is useful if the range of data is drastically changing
// and offsets need to be recomputed.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.runs){
var run = this.series[this.runs[name]];
run.update(data);
if(offsets){
this.dirty = true;
}else{
this._invalidateDependentPlots(run.plot, false);
this._invalidateDependentPlots(run.plot, true);
}
}
return this; // dojox/charting/Chart
},
getSeriesOrder: function(plotName){
// summary:
// Returns an array of series names in the current order
// (the top-most series is the first) within a plot.
// plotName: String
// Plot's name.
// returns: Array
return func.map(func.filter(this.series, function(run){
return run.plot == plotName;
}), getName);
},
setSeriesOrder: function(newOrder){
// summary:
// Sets new order of series within a plot. newOrder cannot add
// or remove series. Wrong names, or dups are ignored.
// newOrder: Array
// Array of series names compatible with getPlotOrder(). All
// series should belong to the same plot.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
var plotName, names = {},
order = func.filter(newOrder, function(name){
if(!(name in this.runs) || (name in names)){
return false;
}
var run = this.series[this.runs[name]];
if(plotName){
if(run.plot != plotName){
return false;
}
}else{
plotName = run.plot;
}
names[name] = 1;
return true;
}, this);
func.forEach(this.series, function(run){
var name = run.name;
if(!(name in names) && run.plot == plotName){
order.push(name);
}
});
var newSeries = func.map(order, function(name){
return this.series[this.runs[name]];
}, this);
this.series = newSeries.concat(func.filter(this.series, function(run){
return run.plot != plotName;
}));
func.forEach(this.series, function(run, i){
this.runs[run.name] = i;
}, this);
this.dirty = true;
return this; // dojox/charting/Chart
},
moveSeriesToFront: function(name){
// summary:
// Moves a given series to front of a plot.
// name: String
// Series' name to move.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.runs){
var index = this.runs[name],
newOrder = this.getSeriesOrder(this.series[index].plot);
if(name != newOrder[0]){
newOrder.splice(index, 1);
newOrder.unshift(name);
return this.setSeriesOrder(newOrder); // dojox/charting/Chart
}
}
return this; // dojox/charting/Chart
},
moveSeriesToBack: function(name){
// summary:
// Moves a given series to back of a plot.
// name: String
// Series' name to move.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(name in this.runs){
var index = this.runs[name],
newOrder = this.getSeriesOrder(this.series[index].plot);
if(name != newOrder[newOrder.length - 1]){
newOrder.splice(index, 1);
newOrder.push(name);
return this.setSeriesOrder(newOrder); // dojox/charting/Chart
}
}
return this; // dojox/charting/Chart
},
resize: function(width, height){
// summary:
// Resize the chart to the dimensions of width and height.
// description:
// Resize the chart and its surface to the width and height dimensions.
// If a single argument of the form {w: value1, h: value2} is provided take that argument as the dimensions to use.
// Finally if no argument is provided, resize the surface to the marginBox of the chart.
// width: Number|Object?
// The new width of the chart or the box definition.
// height: Number?
// The new height of the chart.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
switch(arguments.length){
// case 0, do not resize the div, just the surface
case 1:
// argument, override node box
domGeom.setMarginBox(this.node, width);
break;
case 2:
// argument, override node box
domGeom.setMarginBox(this.node, {w: width, h: height});
break;
}
// in all cases take back the computed box
var box = domGeom.getMarginBox(this.node);
var d = this.surface.getDimensions();
if(d.width != box.w || d.height != box.h){
// and set it on the surface
this.surface.setDimensions(box.w, box.h);
this.dirty = true;
return this.render(); // dojox/charting/Chart
}else{
return this;
}
},
getGeometry: function(){
// summary:
// Returns a map of information about all axes in a chart and what they represent
// in terms of scaling (see dojox.charting.axis2d.Default.getScaler).
// returns: Object
// An map of geometry objects, a one-to-one mapping of axes.
var ret = {};
func.forIn(this.axes, function(axis){
if(axis.initialized()){
ret[axis.name] = {
name: axis.name,
vertical: axis.vertical,
scaler: axis.scaler,
ticks: axis.ticks
};
}
});
return ret; // Object
},
setAxisWindow: function(name, scale, offset, zoom){
// summary:
// Zooms an axis and all dependent plots. Can be used to zoom in 1D.
// name: String
// The name of the axis as defined by addAxis.
// scale: Number
// The scale on the target axis.
// offset: Number
// Any offest, as measured by axis tick
// zoom: Boolean|Object?
// The chart zooming animation trigger. This is null by default,
// e.g. {duration: 1200}, or just set true.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
var axis = this.axes[name];
if(axis){
axis.setWindow(scale, offset);
arr.forEach(this.stack,function(plot){
if(plot.hAxis == name || plot.vAxis == name){
plot.zoom = zoom;
}
});
}
return this; // dojox/charting/Chart
},
setWindow: function(sx, sy, dx, dy, zoom){
// summary:
// Zooms in or out any plots in two dimensions.
// sx: Number
// The scale for the x axis.
// sy: Number
// The scale for the y axis.
// dx: Number
// The pixel offset on the x axis.
// dy: Number
// The pixel offset on the y axis.
// zoom: Boolean|Object?
// The chart zooming animation trigger. This is null by default,
// e.g. {duration: 1200}, or just set true.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(!("plotArea" in this)){
this.calculateGeometry();
}
func.forIn(this.axes, function(axis){
var scale, offset, bounds = axis.getScaler().bounds,
s = bounds.span / (bounds.upper - bounds.lower);
if(axis.vertical){
scale = sy;
offset = dy / s / scale;
}else{
scale = sx;
offset = dx / s / scale;
}
axis.setWindow(scale, offset);
});
arr.forEach(this.stack, function(plot){ plot.zoom = zoom; });
return this; // dojox/charting/Chart
},
zoomIn: function(name, range, delayed){
// summary:
// Zoom the chart to a specific range on one axis. This calls render()
// directly as a convenience method.
// name: String
// The name of the axis as defined by addAxis.
// range: Array
// The end points of the zoom range, measured in axis ticks.
var axis = this.axes[name];
if(axis){
var scale, offset, bounds = axis.getScaler().bounds;
var lower = Math.min(range[0],range[1]);
var upper = Math.max(range[0],range[1]);
lower = range[0] < bounds.lower ? bounds.lower : lower;
upper = range[1] > bounds.upper ? bounds.upper : upper;
scale = (bounds.upper - bounds.lower) / (upper - lower);
offset = lower - bounds.lower;
this.setAxisWindow(name, scale, offset);
if(delayed){
this.delayedRender();
}else{
this.render();
}
}
},
calculateGeometry: function(){
// summary:
// Calculate the geometry of the chart based on the defined axes of
// a chart.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(this.dirty){
return this.fullGeometry();
}
// calculate geometry
var dirty = arr.filter(this.stack, function(plot){
return plot.dirty ||
(plot.hAxis && this.axes[plot.hAxis].dirty) ||
(plot.vAxis && this.axes[plot.vAxis].dirty);
}, this);
calculateAxes(dirty, this.plotArea);
return this; // dojox/charting/Chart
},
fullGeometry: function(){
// summary:
// Calculate the full geometry of the chart. This includes passing
// over all major elements of a chart (plots, axes, series, container)
// in order to ensure proper rendering.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
this._makeDirty();
// clear old values
arr.forEach(this.stack, clear);
// rebuild new connections, and add defaults
// set up a theme
if(!this.theme){
this.setTheme(new SimpleTheme());
}
// assign series
arr.forEach(this.series, function(run){
if(!(run.plot in this.plots)){
// TODO remove auto-assignment
if(!dc.plot2d || !dc.plot2d.Default){
throw Error("Can't find plot: Default - didn't you forget to dojo" + ".require() it?");
}
var plot = new dc.plot2d.Default(this, {});
plot.name = run.plot;
this.plots[run.plot] = this.stack.length;
this.stack.push(plot);
}
this.stack[this.plots[run.plot]].addSeries(run);
}, this);
// assign axes
arr.forEach(this.stack, function(plot){
if(plot.assignAxes){
plot.assignAxes(this.axes);
}
}, this);
// calculate geometry
// 1st pass
var dim = this.dim = this.surface.getDimensions();
dim.width = g.normalizedLength(dim.width);
dim.height = g.normalizedLength(dim.height);
func.forIn(this.axes, clear);
calculateAxes(this.stack, dim);
// assumption: we don't have stacked axes yet
var offsets = this.offsets = {l: 0, r: 0, t: 0, b: 0};
// chart mirroring starts
var self = this;
func.forIn(this.axes, function(axis){
if(has("dojo-bidi")){
self._resetLeftBottom(axis);
}
func.forIn(axis.getOffsets(), function(o, i){ offsets[i] = Math.max(o, offsets[i]); });
});
// chart mirroring ends
// add title area
if(this.title){
this.titleGap = (this.titleGap==0) ? 0 : this.titleGap || this.theme.chart.titleGap || 20;
this.titlePos = this.titlePos || this.theme.chart.titlePos || "top";
this.titleFont = this.titleFont || this.theme.chart.titleFont;
this.titleFontColor = this.titleFontColor || this.theme.chart.titleFontColor || "black";
this.titleAlign = this.titleAlign || this.theme && this.theme.chart && this.theme.chart.titleAlign || "middle";
var tsize = g.normalizedLength(g.splitFontString(this.titleFont).size);
offsets[this.titlePos == "top" ? "t" : "b"] += (tsize + this.titleGap);
}
// add margins
func.forIn(this.margins, function(o, i){ offsets[i] += o; });
// 2nd pass with realistic dimensions
this.plotArea = {
width: dim.width - offsets.l - offsets.r,
height: dim.height - offsets.t - offsets.b
};
func.forIn(this.axes, clear);
calculateAxes(this.stack, this.plotArea);
return this; // dojox/charting/Chart
},
render: function(){
// summary:
// Render the chart according to the current information defined. This should
// be the last call made when defining/creating a chart, or if data within the
// chart has been changed.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
// do we have a delayed renderer pending? If yes we need to clear it
if(this._delayedRenderHandle){
clearTimeout(this._delayedRenderHandle);
this._delayedRenderHandle = null;
}
if(this.theme){
this.theme.clear();
}
if(this.dirty){
return this.fullRender();
}
this.calculateGeometry();
// go over the stack backwards
func.forEachRev(this.stack, function(plot){ plot.render(this.dim, this.offsets); }, this);
// go over axes
func.forIn(this.axes, function(axis){ axis.render(this.dim, this.offsets); }, this);
this._makeClean();
return this; // dojox/charting/Chart
},
fullRender: function(){
// summary:
// Force a full rendering of the chart, including full resets on the chart itself.
// You should not call this method directly unless absolutely necessary.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
// calculate geometry
this.fullGeometry();
var offsets = this.offsets, dim = this.dim;
var w = Math.max(0, dim.width - offsets.l - offsets.r),
h = Math.max(0, dim.height - offsets.t - offsets.b);
// get required colors
//var requiredColors = func.foldl(this.stack, "z + plot.getRequiredColors()", 0);
//this.theme.defineColors({num: requiredColors, cache: false});
// clear old shapes
arr.forEach(this.series, plot2dCommon.purgeGroup);
func.forIn(this.axes, plot2dCommon.purgeGroup);
arr.forEach(this.stack, plot2dCommon.purgeGroup);
var children = this.surface.children;
// starting with 1.9 the registry is optional and thus dispose is
if(shape.dispose){
for(var i = 0; i < children.length;++i){
shape.dispose(children[i]);
}
}
if(this.chartTitle && this.chartTitle.tagName){
// destroy title if it is a DOM node
domConstruct.destroy(this.chartTitle);
}
this.surface.clear();
this.chartTitle = null;
this._renderChartBackground(dim, offsets);
if(this._nativeClip){
this._renderPlotBackground(dim, offsets, w, h);
}else{
// VML
this._renderPlotBackground(dim, offsets, w, h);
}
// go over the stack backwards
func.foldr(this.stack, function(z, plot){ return plot.render(dim, offsets), 0; }, 0);
if(!this._nativeClip){
// VML, matting-clipping
this._renderChartBackground(dim, offsets);
}
//create title: Whether to make chart title as a widget which extends dojox.charting.Element?
if(this.title){
this._renderTitle(dim, offsets);
}
// go over axes
func.forIn(this.axes, function(axis){ axis.render(dim, offsets); });
this._makeClean();
return this; // dojox/charting/Chart
},
_renderTitle: function(dim, offsets){
// summary:
// Internal function to render the chart title.
// dim:
// The dimension object of the chart
// tags:
// private
var forceHtmlLabels = (g.renderer == "canvas") && this.htmlLabels,
labelType = forceHtmlLabels || !has("ie") && !has("opera") && this.htmlLabels ? "html" : "gfx",
tsize = g.normalizedLength(g.splitFontString(this.titleFont).size),
tBox = g._base._getTextBox(this.title,{ font: this.titleFont });
var titleAlign = this.titleAlign;
var isRtl = has("dojo-bidi") && this.isRightToLeft();
var posX = dim.width/2; // Default is middle.
if(titleAlign === "edge"){
titleAlign = "left";
if(isRtl){
posX = dim.width - (offsets.r + tBox.w);
}else {
posX = offsets.l;
}
}else if(titleAlign != "middle"){
if(isRtl){
// We're in BIDI mode, reverse the alignment.
titleAlign = titleAlign === "left" ? "right" : "left";
}
if(titleAlign === "left"){
posX = this.margins.l;
}else if(titleAlign === "right"){
titleAlign = "left";
posX = dim.width - (this.margins.l + tBox.w);
}
}
this.chartTitle = common.createText[labelType](
this,
this.surface,
posX,
this.titlePos=="top" ? tsize + this.margins.t : dim.height - this.margins.b,
titleAlign,
this.title,
this.titleFont,
this.titleFontColor
);
},
_renderChartBackground: function(dim, offsets){
var t = this.theme, rect;
// chart background
var fill = this.fill !== undefined ? this.fill : (t.chart && t.chart.fill);
var stroke = this.stroke !== undefined ? this.stroke : (t.chart && t.chart.stroke);
// TRT: support for "inherit" as a named value in a theme.
if(fill == "inherit"){
// find the background color of the nearest ancestor node, and use that explicitly.
var node = this.node;
fill = new Color(domStyle.get(node, "backgroundColor"));
while(fill.a==0 && node!=document.documentElement){
fill = new Color(domStyle.get(node, "backgroundColor"));
node = node.parentNode;
}
}
if(fill){
if(this._nativeClip){
fill = Element.prototype._shapeFill(Element.prototype._plotFill(fill, dim),
{ x:0, y: 0, width: dim.width + 1, height: dim.height + 1 });
this.surface.createRect({ width: dim.width + 1, height: dim.height + 1 }).setFill(fill);
}else{
// VML
fill = Element.prototype._plotFill(fill, dim, offsets);
if(offsets.l){ // left
rect = {
x: 0,
y: 0,
width: offsets.l,
height: dim.height + 1
};
this.surface.createRect(rect).setFill(Element.prototype._shapeFill(fill, rect));
}
if(offsets.r){ // right
rect = {
x: dim.width - offsets.r,
y: 0,
width: offsets.r + 1,
height: dim.height + 2
};
this.surface.createRect(rect).setFill(Element.prototype._shapeFill(fill, rect));
}
if(offsets.t){ // top
rect = {
x: 0,
y: 0,
width: dim.width + 1,
height: offsets.t
};
this.surface.createRect(rect).setFill(Element.prototype._shapeFill(fill, rect));
}
if(offsets.b){ // bottom
rect = {
x: 0,
y: dim.height - offsets.b,
width: dim.width + 1,
height: offsets.b + 2
};
this.surface.createRect(rect).setFill(Element.prototype._shapeFill(fill, rect));
}
}
}
if(stroke){
this.surface.createRect({
width: dim.width - 1,
height: dim.height - 1
}).setStroke(stroke);
}
},
_renderPlotBackground: function(dim, offsets, w, h){
var t = this.theme;
// draw a plot background
var fill = t.plotarea && t.plotarea.fill;
var stroke = t.plotarea && t.plotarea.stroke;
// size might be neg if offsets are bigger that chart size this happens quite often at
// initialization time if the chart widget is used in a BorderContainer
// this will fail on IE/VML
var rect = {
x: offsets.l - 1, y: offsets.t - 1,
width: w + 2,
height: h + 2
};
if(fill){
fill = Element.prototype._shapeFill(Element.prototype._plotFill(fill, dim, offsets), rect);
this.surface.createRect(rect).setFill(fill);
}
if(stroke){
this.surface.createRect({
x: offsets.l, y: offsets.t,
width: w + 1,
height: h + 1
}).setStroke(stroke);
}
},
delayedRender: function(){
// summary:
// Delayed render, which is used to collect multiple updates
// within a delayInMs time window.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(!this._delayedRenderHandle){
this._delayedRenderHandle = setTimeout(
lang.hitch(this, function(){
this.render();
}),
this.delayInMs
);
}
return this; // dojox/charting/Chart
},
connectToPlot: function(name, object, method){
// summary:
// A convenience method to connect a function to a plot.
// name: String
// The name of the plot as defined by addPlot.
// object: Object
// The object to be connected.
// method: Function
// The function to be executed.
// returns: Array
// A handle to the connection, as defined by dojo.connect (see dojo.connect).
return name in this.plots ? this.stack[this.plots[name]].connect(object, method) : null; // Array
},
fireEvent: function(seriesName, eventName, index){
// summary:
// Fires a synthetic event for a series item.
// seriesName: String
// Series name.
// eventName: String
// Event name to simulate: onmouseover, onmouseout, onclick.
// index: Number
// Valid data value index for the event.
// returns: dojox/charting/Chart
// A reference to the current chart for functional chaining.
if(seriesName in this.runs){
var plotName = this.series[this.runs[seriesName]].plot;
if(plotName in this.plots){
var plot = this.stack[this.plots[plotName]];
if(plot){
plot.fireEvent(seriesName, eventName, index);
}
}
}
return this; // dojox/charting/Chart
},
_makeClean: function(){
// reset dirty flags
arr.forEach(this.axes, makeClean);
arr.forEach(this.stack, makeClean);
arr.forEach(this.series, makeClean);
this.dirty = false;
},
_makeDirty: function(){
// reset dirty flags
arr.forEach(this.axes, makeDirty);
arr.forEach(this.stack, makeDirty);
arr.forEach(this.series, makeDirty);
this.dirty = true;
},
_invalidateDependentPlots: function(plotName, /* Boolean */ verticalAxis){
if(plotName in this.plots){
var plot = this.stack[this.plots[plotName]], axis,
axisName = verticalAxis ? "vAxis" : "hAxis";
if(plot[axisName]){
axis = this.axes[plot[axisName]];
if(axis && axis.dependOnData()){
axis.dirty = true;
// find all plots and mark them dirty
arr.forEach(this.stack, function(p){
if(p[axisName] && p[axisName] == plot[axisName]){
p.dirty = true;
}
});
}
}else{
plot.dirty = true;
}
}
},
setDir : function(dir){
return this;
},
_resetLeftBottom: function(axis){
},
formatTruncatedLabel: function(element, label, labelType){
}
});
function hSection(stats){
return {min: stats.hmin, max: stats.hmax};
}
function vSection(stats){
return {min: stats.vmin, max: stats.vmax};
}
function hReplace(stats, h){
stats.hmin = h.min;
stats.hmax = h.max;
}
function vReplace(stats, v){
stats.vmin = v.min;
stats.vmax = v.max;
}
function combineStats(target, source){
if(target && source){
target.min = Math.min(target.min, source.min);
target.max = Math.max(target.max, source.max);
}
return target || source;
}
function calculateAxes(stack, plotArea){
var plots = {}, axes = {};
arr.forEach(stack, function(plot){
var stats = plots[plot.name] = plot.getSeriesStats();
if(plot.hAxis){
axes[plot.hAxis] = combineStats(axes[plot.hAxis], hSection(stats));
}
if(plot.vAxis){
axes[plot.vAxis] = combineStats(axes[plot.vAxis], vSection(stats));
}
});
arr.forEach(stack, function(plot){
var stats = plots[plot.name];
if(plot.hAxis){
hReplace(stats, axes[plot.hAxis]);
}
if(plot.vAxis){
vReplace(stats, axes[plot.vAxis]);
}
plot.initializeScalers(plotArea, stats);
});
}
return has("dojo-bidi")? declare("dojox.charting.Chart", [Chart, BidiChart]) : Chart;
});
},
'dojox/main':function(){
define(["dojo/_base/kernel"], function(dojo) {
// module:
// dojox/main
/*=====
return {
// summary:
// The dojox package main module; dojox package is somewhat unusual in that the main module currently just provides an empty object.
// Apps should require modules from the dojox packages directly, rather than loading this module.
};
=====*/
return dojo.dojox;
});
},
'dojox/charting/Element':function(){
define(["dojo/_base/array", "dojo/dom-construct","dojo/_base/declare", "dojox/gfx", "dojox/gfx/shape"],
function(arr, domConstruct, declare, gfx, shape){
return declare("dojox.charting.Element", null, {
// summary:
// A base class that is used to build other elements of a chart, such as
// a series.
// chart: dojox/charting/Chart
// The parent chart for this element.
// group: dojox/gfx/shape.Group
// The visual GFX group representing this element.
// htmlElement: Array
// Any DOMNodes used as a part of this element (such as HTML-based labels).
// dirty: Boolean
// A flag indicating whether or not this element needs to be rendered.
chart: null,
group: null,
htmlElements: null,
dirty: true,
renderingOptions: null,
constructor: function(chart, kwArgs){
// summary:
// Creates a new charting element.
// chart: dojox/charting/Chart
// The chart that this element belongs to.
this.chart = chart;
this.group = null;
this.htmlElements = [];
this.dirty = true;
this.trailingSymbol = "...";
this._events = [];
if (kwArgs && kwArgs.renderingOptions) {
this.renderingOptions = kwArgs.renderingOptions;
}
},
purgeGroup: function(){
// summary:
// Clear any elements out of our group, and destroy the group.
// returns: dojox/charting/Element
// A reference to this object for functional chaining.
this.destroyHtmlElements();
if(this.group){
// since 1.7.x we need dispose shape otherwise there is a memoryleak
this.getGroup().removeShape();
var children = this.getGroup().children;
// starting with 1.9 the registry is optional and thus dispose is
if(shape.dispose){
for(var i = 0; i < children.length;++i){
shape.dispose(children[i], true);
}
}
if(this.getGroup().rawNode){
domConstruct.empty(this.getGroup().rawNode);
}
this.getGroup().clear();
// starting with 1.9 the registry is optional and thus dispose is
if(shape.dispose){
shape.dispose(this.getGroup(), true);
}
if(this.getGroup() != this.group){
// we do have an intermediary clipping group (see CartesianBase)
if(this.group.rawNode){
domConstruct.empty(this.group.rawNode);
}
this.group.clear();
// starting with 1.9 the registry is optional and thus dispose is
if(shape.dispose){
shape.dispose(this.group, true);
}
}
this.group = null;
}
this.dirty = true;
if(this._events.length){
arr.forEach(this._events, function(item){
item.shape.disconnect(item.handle);
});
this._events = [];
}
return this; // dojox.charting.Element
},
cleanGroup: function(creator){
// summary:
// Clean any elements (HTML or GFX-based) out of our group, and create a new one.
// creator: dojox/gfx/shape.Surface?
// An optional surface to work with.
// returns: dojox/charting/Element
// A reference to this object for functional chaining.
this.destroyHtmlElements();
if(!creator){ creator = this.chart.surface; }
if(this.group){
var bgnode;
var children = this.getGroup().children;
// starting with 1.9 the registry is optional and thus dispose is
if(shape.dispose){
for(var i = 0; i < children.length;++i){
shape.dispose(children[i], true);
}
}
if(this.getGroup().rawNode){
bgnode = this.getGroup().bgNode;
domConstruct.empty(this.getGroup().rawNode);
}
this.getGroup().clear();
if(bgnode){
this.getGroup().rawNode.appendChild(bgnode);
}
}else{
this.group = creator.createGroup();
// in some cases we have a rawNode but this is not an actual DOM element (CanvasWithEvents) so check
// the actual rawNode type.
if (this.renderingOptions && this.group.rawNode &&
this.group.rawNode.namespaceURI == "http://www.w3.org/2000/svg") {
for (var key in this.renderingOptions) {
this.group.rawNode.setAttribute(key, this.renderingOptions[key]);
}
}
}
this.dirty = true;
return this; // dojox.charting.Element
},
getGroup: function(){
return this.group;
},
destroyHtmlElements: function(){
// summary:
// Destroy any DOMNodes that may have been created as a part of this element.
if(this.htmlElements.length){
arr.forEach(this.htmlElements, domConstruct.destroy);
this.htmlElements = [];
}
},
destroy: function(){
// summary:
// API addition to conform to the rest of the Dojo Toolkit's standard.
this.purgeGroup();
},
overrideShape: function(shape, params){
// summary:
// Extension point for overriding the charting shape
},
//text utilities
getTextWidth: function(s, font){
return gfx._base._getTextBox(s, {font: font}).w || 0;
},
getTextWithLimitLength: function(s, font, limitWidth, truncated){
// summary:
// Get the truncated string based on the limited width in px(dichotomy algorithm)
// s: String?
// candidate text.
// font: String?
// text's font style.
// limitWidth: Number?
// text limited width in px.
// truncated: Boolean?
// whether the input text(s) has already been truncated.
// returns: Object
// | {
// | text: processed text, maybe truncated or not,
// | truncated: whether text has been truncated
// | }
if(!s || s.length <= 0){
return {
text: "",
truncated: truncated || false
};
}
if(!limitWidth || limitWidth <= 0){
return {
text: s,
truncated: truncated || false
};
}
var delta = 2,
//golden section for dichotomy algorithm
trucPercentage = 0.618,
minStr = s.substring(0,1) + this.trailingSymbol,
minWidth = this.getTextWidth(minStr, font);
if(limitWidth <= minWidth){
return {
text: minStr,
truncated: true
};
}
var width = this.getTextWidth(s, font);
if(width <= limitWidth){
return {
text: s,
truncated: truncated || false
};
}else{
var begin = 0,
end = s.length;
while(begin < end){
if(end - begin <= delta ){
while (this.getTextWidth(s.substring(0, begin) + this.trailingSymbol, font) > limitWidth) {
begin -= 1;
}
return {
text: (s.substring(0,begin) + this.trailingSymbol),
truncated: true
};
}
var index = begin + Math.round((end - begin) * trucPercentage),
widthIntercepted = this.getTextWidth(s.substring(0, index), font);
if(widthIntercepted < limitWidth){
begin = index;
end = end;
}else{
begin = begin;
end = index;
}
}
}
},
getTextWithLimitCharCount: function(s, font, wcLimit, truncated){
// summary:
// Get the truncated string based on the limited character count(dichotomy algorithm)
// s: String?
// candidate text.
// font: String?
// text's font style.
// wcLimit: Number?
// text limited character count.
// truncated: Boolean?
// whether the input text(s) has already been truncated.
// returns: Object
// | {
// | text: processed text, maybe truncated or not,
// | truncated: whether text has been truncated
// | }
if (!s || s.length <= 0) {
return {
text: "",
truncated: truncated || false
};
}
if(!wcLimit || wcLimit <= 0 || s.length <= wcLimit){
return {
text: s,
truncated: truncated || false
};
}
return {
text: s.substring(0, wcLimit) + this.trailingSymbol,
truncated: true
};
},
// fill utilities
_plotFill: function(fill, dim, offsets){
// process a plot-wide fill
if(!fill || !fill.type || !fill.space){
return fill;
}
var space = fill.space, span;
switch(fill.type){
case "linear":
if(space === "plot" || space === "shapeX" || space === "shapeY"){
// clone a fill so we can modify properly directly
fill = gfx.makeParameters(gfx.defaultLinearGradient, fill);
fill.space = space;
// process dimensions
if(space === "plot" || space === "shapeX"){
// process Y
span = dim.height - offsets.t - offsets.b;
fill.y1 = offsets.t + span * fill.y1 / 100;
fill.y2 = offsets.t + span * fill.y2 / 100;
}
if(space === "plot" || space === "shapeY"){
// process X
span = dim.width - offsets.l - offsets.r;
fill.x1 = offsets.l + span * fill.x1 / 100;
fill.x2 = offsets.l + span * fill.x2 / 100;
}
}
break;
case "radial":
if(space === "plot"){
// this one is used exclusively for scatter charts
// clone a fill so we can modify properly directly
fill = gfx.makeParameters(gfx.defaultRadialGradient, fill);
fill.space = space;
// process both dimensions
var spanX = dim.width - offsets.l - offsets.r,
spanY = dim.height - offsets.t - offsets.b;
fill.cx = offsets.l + spanX * fill.cx / 100;
fill.cy = offsets.t + spanY * fill.cy / 100;
fill.r = fill.r * Math.sqrt(spanX * spanX + spanY * spanY) / 200;
}
break;
case "pattern":
if(space === "plot" || space === "shapeX" || space === "shapeY"){
// clone a fill so we can modify properly directly
fill = gfx.makeParameters(gfx.defaultPattern, fill);
fill.space = space;
// process dimensions
if(space === "plot" || space === "shapeX"){
// process Y
span = dim.height - offsets.t - offsets.b;
fill.y = offsets.t + span * fill.y / 100;
fill.height = span * fill.height / 100;
}
if(space === "plot" || space === "shapeY"){
// process X
span = dim.width - offsets.l - offsets.r;
fill.x = offsets.l + span * fill.x / 100;
fill.width = span * fill.width / 100;
}
}
break;
}
return fill;
},
_shapeFill: function(fill, bbox){
// process shape-specific fill
if(!fill || !fill.space){
return fill;
}
var space = fill.space, span;
switch(fill.type){
case "linear":
if(space === "shape" || space === "shapeX" || space === "shapeY"){
// clone a fill so we can modify properly directly
fill = gfx.makeParameters(gfx.defaultLinearGradient, fill);
fill.space = space;
// process dimensions
if(space === "shape" || space === "shapeX"){
// process X
span = bbox.width;
fill.x1 = bbox.x + span * fill.x1 / 100;
fill.x2 = bbox.x + span * fill.x2 / 100;
}
if(space === "shape" || space === "shapeY"){
// process Y
span = bbox.height;
fill.y1 = bbox.y + span * fill.y1 / 100;
fill.y2 = bbox.y + span * fill.y2 / 100;
}
}
break;
case "radial":
if(space === "shape"){
// this one is used exclusively for bubble charts and pie charts
// clone a fill so we can modify properly directly
fill = gfx.makeParameters(gfx.defaultRadialGradient, fill);
fill.space = space;
// process both dimensions
fill.cx = bbox.x + bbox.width / 2;
fill.cy = bbox.y + bbox.height / 2;
fill.r = fill.r * bbox.width / 200;
}
break;
case "pattern":
if(space === "shape" || space === "shapeX" || space === "shapeY"){
// clone a fill so we can modify properly directly
fill = gfx.makeParameters(gfx.defaultPattern, fill);
fill.space = space;
// process dimensions
if(space === "shape" || space === "shapeX"){
// process X
span = bbox.width;
fill.x = bbox.x + span * fill.x / 100;
fill.width = span * fill.width / 100;
}
if(space === "shape" || space === "shapeY"){
// process Y
span = bbox.height;
fill.y = bbox.y + span * fill.y / 100;
fill.height = span * fill.height / 100;
}
}
break;
}
return fill;
},
_pseudoRadialFill: function(fill, center, radius, start, end){
// process pseudo-radial fills
if(!fill || fill.type !== "radial" || fill.space !== "shape"){
return fill;
}
// clone and normalize fill
var space = fill.space;
fill = gfx.makeParameters(gfx.defaultRadialGradient, fill);
fill.space = space;
if(arguments.length < 4){
// process both dimensions
fill.cx = center.x;
fill.cy = center.y;
fill.r = fill.r * radius / 100;
return fill;
}
// convert to a linear gradient
var angle = arguments.length < 5 ? start : (end + start) / 2;
return {
type: "linear",
x1: center.x,
y1: center.y,
x2: center.x + fill.r * radius * Math.cos(angle) / 100,
y2: center.y + fill.r * radius * Math.sin(angle) / 100,
colors: fill.colors
};
}
});
});
},
'dojox/gfx':function(){
define(["dojo/_base/lang", "./gfx/_base", "./gfx/renderer!"],
function(lang, gfxBase, renderer){
// module:
// dojox/gfx
// summary:
// This the root of the Dojo Graphics package
gfxBase.switchTo(renderer);
return gfxBase;
});
},
'dojox/gfx/_base':function(){
define(["dojo/_base/kernel", "dojo/_base/lang", "dojo/_base/Color", "dojo/_base/sniff", "dojo/_base/window",
"dojo/_base/array","dojo/dom", "dojo/dom-construct","dojo/dom-geometry"],
function(kernel, lang, Color, has, win, arr, dom, domConstruct, domGeom){
// module:
// dojox/gfx
// summary:
// This module contains common core Graphics API used by different graphics renderers.
var g = lang.getObject("dojox.gfx", true),
b = g._base = {};
// candidates for dojox.style (work on VML and SVG nodes)
g._hasClass = function(/*DomNode*/node, /*String*/classStr){
// summary:
// Returns whether or not the specified classes are a portion of the
// class list currently applied to the node.
// return (new RegExp('(^|\\s+)'+classStr+'(\\s+|$)')).test(node.className) // Boolean
var cls = node.getAttribute("className");
return cls && (" " + cls + " ").indexOf(" " + classStr + " ") >= 0; // Boolean
};
g._addClass = function(/*DomNode*/node, /*String*/classStr){
// summary:
// Adds the specified classes to the end of the class list on the
// passed node.
var cls = node.getAttribute("className") || "";
if(!cls || (" " + cls + " ").indexOf(" " + classStr + " ") < 0){
node.setAttribute("className", cls + (cls ? " " : "") + classStr);
}
};
g._removeClass = function(/*DomNode*/node, /*String*/classStr){
// summary:
// Removes classes from node.
var cls = node.getAttribute("className");
if(cls){
node.setAttribute(
"className",
cls.replace(new RegExp('(^|\\s+)' + classStr + '(\\s+|$)'), "$1$2")
);
}
};
// candidate for dojox.html.metrics (dynamic font resize handler is not implemented here)
// derived from Morris John's emResized measurer
b._getFontMeasurements = function(){
// summary:
// Returns an object that has pixel equivilents of standard font
// size values.
var heights = {
'1em': 0, '1ex': 0, '100%': 0, '12pt': 0, '16px': 0, 'xx-small': 0,
'x-small': 0, 'small': 0, 'medium': 0, 'large': 0, 'x-large': 0,
'xx-large': 0
};
var p, oldStyle;
if(has("ie")){
// We do a font-size fix if and only if one isn't applied already.
// NOTE: If someone set the fontSize on the HTML Element, this will kill it.
oldStyle = win.doc.documentElement.style.fontSize || "";
if(!oldStyle){
win.doc.documentElement.style.fontSize="100%";
}
}
// set up the measuring node.
var div = domConstruct.create("div", {style: {
position: "absolute",
left: "0",
top: "-100px",
width: "30px",
height: "1000em",
borderWidth: "0",
margin: "0",
padding: "0",
outline: "none",
lineHeight: "1",
overflow: "hidden"
}}, win.body());
// do the measurements.
for(p in heights){
div.style.fontSize = p;
heights[p] = Math.round(div.offsetHeight * 12/16) * 16/12 / 1000;
}
if(has("ie")){
// Restore the font to its old style.
win.doc.documentElement.style.fontSize = oldStyle;
}
win.body().removeChild(div);
return heights; //object
};
var fontMeasurements = null;
b._getCachedFontMeasurements = function(recalculate){
if(recalculate || !fontMeasurements){
fontMeasurements = b._getFontMeasurements();
}
return fontMeasurements;
};
// candidate for dojox.html.metrics
var measuringNode = null, empty = {};
b._getTextBox = function( /*String*/ text,
/*Object*/ style,
/*String?*/ className){
var m, s, al = arguments.length;
var i, box;
if(!measuringNode){
measuringNode = domConstruct.create("div", {style: {
position: "absolute",
top: "-10000px",
left: "0",
visibility: "hidden"
}}, win.body());
}
m = measuringNode;
// reset styles
m.className = "";
s = m.style;
s.borderWidth = "0";
s.margin = "0";
s.padding = "0";
s.outline = "0";
// set new style
if(al > 1 && style){
for(i in style){
if(i in empty){ continue; }
s[i] = style[i];
}
}
// set classes
if(al > 2 && className){
m.className = className;
}
// take a measure
m.innerHTML = text;
if(m.getBoundingClientRect){
var bcr = m.getBoundingClientRect();
box = {l: bcr.left, t: bcr.top, w: bcr.width || (bcr.right - bcr.left), h: bcr.height || (bcr.bottom - bcr.top)};
}else{
box = domGeom.getMarginBox(m);
}
m.innerHTML = "";
return box;
};
b._computeTextLocation = function(/*g.defaultTextShape*/textShape, /*Number*/width, /*Number*/height, /*Boolean*/fixHeight) {
var loc = {}, align = textShape.align;
switch (align) {
case 'end':
loc.x = textShape.x - width;
break;
case 'middle':
loc.x = textShape.x - width / 2;
break;
default:
loc.x = textShape.x;
break;
}
var c = fixHeight ? 0.75 : 1;
loc.y = textShape.y - height*c; // **rough** approximation of the ascent...
return loc;
};
b._computeTextBoundingBox = function(/*shape.Text*/s){
// summary:
// Compute the bbox of the given shape.Text instance. Note that this method returns an
// approximation of the bbox, and should be used when the underlying renderer cannot provide precise metrics.
if(!g._base._isRendered(s)){
return {x:0, y:0, width:0, height:0};
}
var loc, textShape = s.getShape(),
font = s.getFont() || g.defaultFont,
w = s.getTextWidth(),
h = g.normalizedLength(font.size);
loc = b._computeTextLocation(textShape, w, h, true);
return {
x: loc.x,
y: loc.y,
width: w,
height: h
};
};
b._isRendered = function(/*Shape*/s){
var p = s.parent;
while(p && p.getParent){
p = p.parent;
}
return p !== null;
};
// candidate for dojo.dom
var uniqueId = 0;
b._getUniqueId = function(){
// summary:
// returns a unique string for use with any DOM element
var id;
do{
id = kernel._scopeName + "xUnique" + (++uniqueId);
}while(dom.byId(id));
return id;
};
// IE10
var touchActionProp = has("pointer-events") ? "touchAction" : has("MSPointer") ? "msTouchAction" : null;
b._fixMsTouchAction = touchActionProp ? function(/*dojox/gfx/shape.Surface*/surface){
surface.rawNode.style[touchActionProp] = "none";
} : function() {};
/*=====
g.Stroke = {
// summary:
// A stroke defines stylistic properties that are used when drawing a path.
// color: String
// The color of the stroke, default value 'black'.
color: "black",
// style: String
// The style of the stroke, one of 'solid', ... . Default value 'solid'.
style: "solid",
// width: Number
// The width of a stroke, default value 1.
width: 1,
// cap: String
// The endcap style of the path. One of 'butt', 'round', ... . Default value 'butt'.
cap: "butt",
// join: Number
// The join style to use when combining path segments. Default value 4.
join: 4
};
g.Fill = {
// summary:
// Defines how to fill a shape. Four types of fills can be used: solid, linear gradient, radial gradient and pattern.
// See dojox/gfx.LinearGradient, dojox/gfx.RadialGradient and dojox/gfx.Pattern respectively for more information about the properties supported by each type.
// type: String?
// The type of fill. One of 'linear', 'radial', 'pattern' or undefined. If not specified, a solid fill is assumed.
type:"",
// color: String|dojo/Color?
// The color of a solid fill type.
color:null,
};
g.LinearGradient = {
// summary:
// An object defining the default stylistic properties used for Linear Gradient fills.
// Linear gradients are drawn along a virtual line, which results in appearance of a rotated pattern in a given direction/orientation.
// type: String
// Specifies this object is a Linear Gradient, value 'linear'
type: "linear",
// x1: Number
// The X coordinate of the start of the virtual line along which the gradient is drawn, default value 0.
x1: 0,
// y1: Number
// The Y coordinate of the start of the virtual line along which the gradient is drawn, default value 0.
y1: 0,
// x2: Number
// The X coordinate of the end of the virtual line along which the gradient is drawn, default value 100.
x2: 100,
// y2: Number
// The Y coordinate of the end of the virtual line along which the gradient is drawn, default value 100.
y2: 100,
// colors: Array
// An array of colors at given offsets (from the start of the line). The start of the line is
// defined at offest 0 with the end of the line at offset 1.
// Default value, [{ offset: 0, color: 'black'},{offset: 1, color: 'white'}], is a gradient from black to white.
colors: []
};
g.RadialGradient = {
// summary:
// Specifies the properties for RadialGradients using in fills patterns.
// type: String
// Specifies this is a RadialGradient, value 'radial'
type: "radial",
// cx: Number
// The X coordinate of the center of the radial gradient, default value 0.
cx: 0,
// cy: Number
// The Y coordinate of the center of the radial gradient, default value 0.
cy: 0,
// r: Number
// The radius to the end of the radial gradient, default value 100.
r: 100,
// colors: Array
// An array of colors at given offsets (from the center of the radial gradient).
// The center is defined at offest 0 with the outer edge of the gradient at offset 1.
// Default value, [{ offset: 0, color: 'black'},{offset: 1, color: 'white'}], is a gradient from black to white.
colors: []
};
g.Pattern = {
// summary:
// An object specifying the default properties for a Pattern using in fill operations.
// type: String
// Specifies this object is a Pattern, value 'pattern'.
type: "pattern",
// x: Number
// The X coordinate of the position of the pattern, default value is 0.
x: 0,
// y: Number
// The Y coordinate of the position of the pattern, default value is 0.
y: 0,
// width: Number
// The width of the pattern image, default value is 0.
width: 0,
// height: Number
// The height of the pattern image, default value is 0.
height: 0,
// src: String
// A url specifying the image to use for the pattern.
src: ""
};
g.Text = {
// summary:
// A keyword argument object defining both the text to be rendered in a VectorText shape,
// and specifying position, alignment, and fitting.
// text: String
// The text to be rendered.
// x: Number?
// The left coordinate for the text's bounding box.
// y: Number?
// The top coordinate for the text's bounding box.
// width: Number?
// The width of the text's bounding box.
// height: Number?
// The height of the text's bounding box.
// align: String?
// The alignment of the text, as defined in SVG. Can be "start", "end" or "middle".
// fitting: Number?
// How the text is to be fitted to the bounding box. Can be 0 (no fitting), 1 (fitting based on
// passed width of the bounding box and the size of the font), or 2 (fit text to the bounding box,
// and ignore any size parameters).
// leading: Number?
// The leading to be used between lines in the text.
// decoration: String?
// Any text decoration to be used.
};
g.Font = {
// summary:
// An object specifying the properties for a Font used in text operations.
// type: String
// Specifies this object is a Font, value 'font'.
type: "font",
// style: String
// The font style, one of 'normal', 'bold', default value 'normal'.
style: "normal",
// variant: String
// The font variant, one of 'normal', ... , default value 'normal'.
variant: "normal",
// weight: String
// The font weight, one of 'normal', ..., default value 'normal'.
weight: "normal",
// size: String
// The font size (including units), default value '10pt'.
size: "10pt",
// family: String
// The font family, one of 'serif', 'sanserif', ..., default value 'serif'.
family: "serif"
};
=====*/
lang.mixin(g, {
// summary:
// defines constants, prototypes, and utility functions for the core Graphics API
// default shapes, which are used to fill in missing parameters
defaultPath: {
// summary:
// Defines the default Path prototype object.
// type: String
// Specifies this object is a Path, default value 'path'.
type: "path",
// path: String
// The path commands. See W32C SVG 1.0 specification.
// Defaults to empty string value.
path: ""
},
defaultPolyline: {
// summary:
// Defines the default PolyLine prototype.
// type: String
// Specifies this object is a PolyLine, default value 'polyline'.
type: "polyline",
// points: Array
// An array of point objects [{x:0,y:0},...] defining the default polyline's line segments. Value is an empty array [].
points: []
},
defaultRect: {
// summary:
// Defines the default Rect prototype.
// type: String
// Specifies this default object is a type of Rect. Value is 'rect'
type: "rect",
// x: Number
// The X coordinate of the default rectangles position, value 0.
x: 0,
// y: Number
// The Y coordinate of the default rectangle's position, value 0.
y: 0,
// width: Number
// The width of the default rectangle, value 100.
width: 100,
// height: Number
// The height of the default rectangle, value 100.
height: 100,
// r: Number
// The corner radius for the default rectangle, value 0.
r: 0
},
defaultEllipse: {
// summary:
// Defines the default Ellipse prototype.
// type: String
// Specifies that this object is a type of Ellipse, value is 'ellipse'
type: "ellipse",
// cx: Number
// The X coordinate of the center of the ellipse, default value 0.
cx: 0,
// cy: Number
// The Y coordinate of the center of the ellipse, default value 0.
cy: 0,
// rx: Number
// The radius of the ellipse in the X direction, default value 200.
rx: 200,
// ry: Number
// The radius of the ellipse in the Y direction, default value 200.
ry: 100
},
defaultCircle: {
// summary:
// An object defining the default Circle prototype.
// type: String
// Specifies this object is a circle, value 'circle'
type: "circle",
// cx: Number
// The X coordinate of the center of the circle, default value 0.
cx: 0,
// cy: Number
// The Y coordinate of the center of the circle, default value 0.
cy: 0,
// r: Number
// The radius, default value 100.
r: 100
},
defaultLine: {
// summary:
// An object defining the default Line prototype.
// type: String
// Specifies this is a Line, value 'line'
type: "line",
// x1: Number
// The X coordinate of the start of the line, default value 0.
x1: 0,
// y1: Number
// The Y coordinate of the start of the line, default value 0.
y1: 0,
// x2: Number
// The X coordinate of the end of the line, default value 100.
x2: 100,
// y2: Number
// The Y coordinate of the end of the line, default value 100.
y2: 100
},
defaultImage: {
// summary:
// Defines the default Image prototype.
// type: String
// Specifies this object is an image, value 'image'.
type: "image",
// x: Number
// The X coordinate of the image's position, default value 0.
x: 0,
// y: Number
// The Y coordinate of the image's position, default value 0.
y: 0,
// width: Number
// The width of the image, default value 0.
width: 0,
// height: Number
// The height of the image, default value 0.
height: 0,
// src: String
// The src url of the image, defaults to empty string.
src: ""
},
defaultText: {
// summary:
// Defines the default Text prototype.
// type: String
// Specifies this is a Text shape, value 'text'.
type: "text",
// x: Number
// The X coordinate of the text position, default value 0.
x: 0,
// y: Number
// The Y coordinate of the text position, default value 0.
y: 0,
// text: String
// The text to be displayed, default value empty string.
text: "",
// align: String
// The horizontal text alignment, one of 'start', 'end', 'center'. Default value 'start'.
align: "start",
// decoration: String
// The text decoration , one of 'none', ... . Default value 'none'.
decoration: "none",
// rotated: Boolean
// Whether the text is rotated, boolean default value false.
rotated: false,
// kerning: Boolean
// Whether kerning is used on the text, boolean default value true.
kerning: true
},
defaultTextPath: {
// summary:
// Defines the default TextPath prototype.
// type: String
// Specifies this is a TextPath, value 'textpath'.
type: "textpath",
// text: String
// The text to be displayed, default value empty string.
text: "",
// align: String
// The horizontal text alignment, one of 'start', 'end', 'center'. Default value 'start'.
align: "start",
// decoration: String
// The text decoration , one of 'none', ... . Default value 'none'.
decoration: "none",
// rotated: Boolean
// Whether the text is rotated, boolean default value false.
rotated: false,
// kerning: Boolean
// Whether kerning is used on the text, boolean default value true.
kerning: true
},
// default stylistic attributes
defaultStroke: {
// summary:
// A stroke defines stylistic properties that are used when drawing a path.
// This object defines the default Stroke prototype.
// type: String
// Specifies this object is a type of Stroke, value 'stroke'.
type: "stroke",
// color: String
// The color of the stroke, default value 'black'.
color: "black",
// style: String
// The style of the stroke, one of 'solid', ... . Default value 'solid'.
style: "solid",
// width: Number
// The width of a stroke, default value 1.
width: 1,
// cap: String
// The endcap style of the path. One of 'butt', 'round', ... . Default value 'butt'.
cap: "butt",
// join: Number
// The join style to use when combining path segments. Default value 4.
join: 4
},
defaultLinearGradient: {
// summary:
// An object defining the default stylistic properties used for Linear Gradient fills.
// Linear gradients are drawn along a virtual line, which results in appearance of a rotated pattern in a given direction/orientation.
// type: String
// Specifies this object is a Linear Gradient, value 'linear'
type: "linear",
// x1: Number
// The X coordinate of the start of the virtual line along which the gradient is drawn, default value 0.
x1: 0,
// y1: Number
// The Y coordinate of the start of the virtual line along which the gradient is drawn, default value 0.
y1: 0,
// x2: Number
// The X coordinate of the end of the virtual line along which the gradient is drawn, default value 100.
x2: 100,
// y2: Number
// The Y coordinate of the end of the virtual line along which the gradient is drawn, default value 100.
y2: 100,
// colors: Array
// An array of colors at given offsets (from the start of the line). The start of the line is
// defined at offest 0 with the end of the line at offset 1.
// Default value, [{ offset: 0, color: 'black'},{offset: 1, color: 'white'}], is a gradient from black to white.
colors: [
{ offset: 0, color: "black" }, { offset: 1, color: "white" }
]
},
defaultRadialGradient: {
// summary:
// An object specifying the default properties for RadialGradients using in fills patterns.
// type: String
// Specifies this is a RadialGradient, value 'radial'
type: "radial",
// cx: Number
// The X coordinate of the center of the radial gradient, default value 0.
cx: 0,
// cy: Number
// The Y coordinate of the center of the radial gradient, default value 0.
cy: 0,
// r: Number
// The radius to the end of the radial gradient, default value 100.
r: 100,
// colors: Array
// An array of colors at given offsets (from the center of the radial gradient).
// The center is defined at offest 0 with the outer edge of the gradient at offset 1.
// Default value, [{ offset: 0, color: 'black'},{offset: 1, color: 'white'}], is a gradient from black to white.
colors: [
{ offset: 0, color: "black" }, { offset: 1, color: "white" }
]
},
defaultPattern: {
// summary:
// An object specifying the default properties for a Pattern using in fill operations.
// type: String
// Specifies this object is a Pattern, value 'pattern'.
type: "pattern",
// x: Number
// The X coordinate of the position of the pattern, default value is 0.
x: 0,
// y: Number
// The Y coordinate of the position of the pattern, default value is 0.
y: 0,
// width: Number
// The width of the pattern image, default value is 0.
width: 0,
// height: Number
// The height of the pattern image, default value is 0.
height: 0,
// src: String
// A url specifying the image to use for the pattern.
src: ""
},
defaultFont: {
// summary:
// An object specifying the default properties for a Font used in text operations.
// type: String
// Specifies this object is a Font, value 'font'.
type: "font",
// style: String
// The font style, one of 'normal', 'bold', default value 'normal'.
style: "normal",
// variant: String
// The font variant, one of 'normal', ... , default value 'normal'.
variant: "normal",
// weight: String
// The font weight, one of 'normal', ..., default value 'normal'.
weight: "normal",
// size: String
// The font size (including units), default value '10pt'.
size: "10pt",
// family: String
// The font family, one of 'serif', 'sanserif', ..., default value 'serif'.
family: "serif"
},
getDefault: (function(){
// summary:
// Returns a function used to access default memoized prototype objects (see them defined above).
var typeCtorCache = {};
// a memoized delegate()
return function(/*String*/ type){
var t = typeCtorCache[type];
if(t){
return new t();
}
t = typeCtorCache[type] = function () {};
t.prototype = g[ "default" + type ];
return new t();
}
})(),
normalizeColor: function(/*dojo/Color|Array|string|Object*/ color){
// summary:
// converts any legal color representation to normalized
// dojo/Color object
// color:
// A color representation.
return (color instanceof Color) ? color : new Color(color); // dojo/Color
},
normalizeParameters: function(existed, update){
// summary:
// updates an existing object with properties from an 'update'
// object
// existed: Object
// the target object to be updated
// update: Object
// the 'update' object, whose properties will be used to update
// the existed object
var x;
if(update){
var empty = {};
for(x in existed){
if(x in update && !(x in empty)){
existed[x] = update[x];
}
}
}
return existed; // Object
},
makeParameters: function(defaults, update){
// summary:
// copies the original object, and all copied properties from the
// 'update' object
// defaults: Object
// the object to be cloned before updating
// update: Object
// the object, which properties are to be cloned during updating
// returns: Object
// new object with new and default properties
var i = null;
if(!update){
// return dojo.clone(defaults);
return lang.delegate(defaults);
}
var result = {};
for(i in defaults){
if(!(i in result)){
result[i] = lang.clone((i in update) ? update[i] : defaults[i]);
}
}
return result; // Object
},
formatNumber: function(x, addSpace){
// summary:
// converts a number to a string using a fixed notation
// x: Number
// number to be converted
// addSpace: Boolean
// whether to add a space before a positive number
// returns: String
// the formatted value
var val = x.toString();
if(val.indexOf("e") >= 0){
val = x.toFixed(4);
}else{
var point = val.indexOf(".");
if(point >= 0 && val.length - point > 5){
val = x.toFixed(4);
}
}
if(x < 0){
return val; // String
}
return addSpace ? " " + val : val; // String
},
// font operations
makeFontString: function(font){
// summary:
// converts a font object to a CSS font string
// font: Object
// font object (see dojox/gfx.defaultFont)
return font.style + " " + font.variant + " " + font.weight + " " + font.size + " " + font.family; // Object
},
splitFontString: function(str){
// summary:
// converts a CSS font string to a font object
// description:
// Converts a CSS font string to a gfx font object. The CSS font
// string components should follow the W3C specified order
// (see http://www.w3.org/TR/CSS2/fonts.html#font-shorthand):
// style, variant, weight, size, optional line height (will be
// ignored), and family. Note that the Font.size attribute is limited to numeric CSS length.
// str: String
// a CSS font string.
// returns: Object
// object in dojox/gfx.defaultFont format
var font = g.getDefault("Font");
var t = str.split(/\s+/);
do{
if(t.length < 5){ break; }
font.style = t[0];
font.variant = t[1];
font.weight = t[2];
var i = t[3].indexOf("/");
font.size = i < 0 ? t[3] : t[3].substring(0, i);
var j = 4;
if(i < 0){
if(t[4] == "/"){
j = 6;
}else if(t[4].charAt(0) == "/"){
j = 5;
}
}
if(j < t.length){
font.family = t.slice(j).join(" ");
}
}while(false);
return font; // Object
},
// length operations
// cm_in_pt: Number
// points per centimeter (constant)
cm_in_pt: 72 / 2.54,
// mm_in_pt: Number
// points per millimeter (constant)
mm_in_pt: 7.2 / 2.54,
px_in_pt: function(){
// summary:
// returns the current number of pixels per point.
return g._base._getCachedFontMeasurements()["12pt"] / 12; // Number
},
pt2px: function(len){
// summary:
// converts points to pixels
// len: Number
// a value in points
return len * g.px_in_pt(); // Number
},
px2pt: function(len){
// summary:
// converts pixels to points
// len: Number
// a value in pixels
return len / g.px_in_pt(); // Number
},
normalizedLength: function(len) {
// summary:
// converts any length value to pixels
// len: String
// a length, e.g., '12pc'
// returns: Number
// pixels
if(len.length === 0){ return 0; }
if(len.length > 2){
var px_in_pt = g.px_in_pt();
var val = parseFloat(len);
switch(len.slice(-2)){
case "px": return val;
case "pt": return val * px_in_pt;
case "in": return val * 72 * px_in_pt;
case "pc": return val * 12 * px_in_pt;
case "mm": return val * g.mm_in_pt * px_in_pt;
case "cm": return val * g.cm_in_pt * px_in_pt;
}
}
return parseFloat(len); // Number
},
// pathVmlRegExp: RegExp
// a constant regular expression used to split a SVG/VML path into primitive components
// tags:
// private
pathVmlRegExp: /([A-Za-z]+)|(\d+(\.\d+)?)|(\.\d+)|(-\d+(\.\d+)?)|(-\.\d+)/g,
// pathVmlRegExp: RegExp
// a constant regular expression used to split a SVG/VML path into primitive components
// tags:
// private
pathSvgRegExp: /([A-DF-Za-df-z])|([-+]?\d*[.]?\d+(?:[eE][-+]?\d+)?)/g,
equalSources: function(a, b){
// summary:
// compares event sources, returns true if they are equal
// a: Object
// first event source
// b: Object
// event source to compare against a
// returns: Boolean
// true, if objects are truthy and the same
return a && b && a === b;
},
switchTo: function(/*String|Object*/ renderer){
// summary:
// switch the graphics implementation to the specified renderer.
// renderer:
// Either the string name of a renderer (eg. 'canvas', 'svg, ...) or the renderer
// object to switch to.
var ns = typeof renderer == "string" ? g[renderer] : renderer;
if(ns){
// If more options are added, update the docblock at the end of shape.js!
arr.forEach(["Group", "Rect", "Ellipse", "Circle", "Line",
"Polyline", "Image", "Text", "Path", "TextPath",
"Surface", "createSurface", "fixTarget"], function(name){
g[name] = ns[name];
});
if(typeof renderer == "string"){
g.renderer = renderer;
}else{
arr.some(["svg","vml","canvas","canvasWithEvents","silverlight"], function(r){
return (g.renderer = g[r] && g[r].Surface === g.Surface ? r : null);
});
}
}
}
});
/*=====
g.createSurface = function(parentNode, width, height){
// summary:
// creates a surface
// parentNode: Node
// a parent node
// width: String|Number
// width of surface, e.g., "100px" or 100
// height: String|Number
// height of surface, e.g., "100px" or 100
// returns: dojox/gfx.Surface
// newly created surface
};
g.fixTarget = function(){
// tags:
// private
};
=====*/
return g; // defaults object api
});
},
'dojox/gfx/renderer':function(){
define(["./_base","dojo/_base/lang", "dojo/_base/sniff", "dojo/_base/window", "dojo/_base/config"],
function(g, lang, has, win, config){
//>> noBuildResolver
var currentRenderer = null;
has.add("vml", function(global, document, element){
element.innerHTML = "";
var supported = ("adj" in element.firstChild);
element.innerHTML = "";
return supported;
});
return {
// summary:
// This module is an AMD loader plugin that loads the appropriate graphics renderer
// implementation based on detected environment and current configuration settings.
load: function(id, require, load){
// tags:
// private
if(currentRenderer && id != "force"){
load(currentRenderer);
return;
}
var renderer = config.forceGfxRenderer,
renderers = !renderer && (lang.isString(config.gfxRenderer) ?
config.gfxRenderer : "svg,vml,canvas,silverlight").split(","),
silverlightObject, silverlightFlag;
while(!renderer && renderers.length){
switch(renderers.shift()){
case "svg":
// the next test is from https://github.com/phiggins42/has.js
if("SVGAngle" in win.global){
renderer = "svg";
}
break;
case "vml":
if(has("vml")){
renderer = "vml";
}
break;
case "silverlight":
try{
if(has("ie")){
silverlightObject = new ActiveXObject("AgControl.AgControl");
if(silverlightObject && silverlightObject.IsVersionSupported("1.0")){
silverlightFlag = true;
}
}else{
if(navigator.plugins["Silverlight Plug-In"]){
silverlightFlag = true;
}
}
}catch(e){
silverlightFlag = false;
}finally{
silverlightObject = null;
}
if(silverlightFlag){
renderer = "silverlight";
}
break;
case "canvas":
if(win.global.CanvasRenderingContext2D){
renderer = "canvas";
}
break;
}
}
if (renderer === 'canvas' && config.canvasEvents !== false) {
renderer = "canvasWithEvents";
}
if(config.isDebug){
console.log("gfx renderer = " + renderer);
}
function loadRenderer(){
require(["dojox/gfx/" + renderer], function(module){
g.renderer = renderer;
// memorize the renderer module
currentRenderer = module;
// now load it
load(module);
});
}
if(renderer == "svg" && typeof window.svgweb != "undefined"){
window.svgweb.addOnLoad(loadRenderer);
}else{
loadRenderer();
}
}
};
});
},
'dojox/gfx/shape':function(){
define(["./_base", "dojo/_base/lang", "dojo/_base/declare", "dojo/_base/kernel", "dojo/_base/sniff",
"dojo/on", "dojo/_base/array", "dojo/dom-construct", "dojo/_base/Color", "./matrix" ],
function(g, lang, declare, kernel, has, on, arr, domConstruct, Color, matrixLib){
function removeItemAt(a, index) {
var len = (a.length - 1);
while (index < len) {
a[index] = a[++index];
}
a.length = len;
}
var shape = g.shape = {
// summary:
// This module contains the core graphics Shape API.
// Different graphics renderer implementation modules (svg, canvas, vml, silverlight, etc.) extend this
// basic api to provide renderer-specific implementations for each shape.
};
shape.Shape = declare("dojox.gfx.shape.Shape", null, {
// summary:
// a Shape object, which knows how to apply
// graphical attributes and transformations
constructor: function(){
// rawNode: Node
// underlying graphics-renderer-specific implementation object (if applicable)
this.rawNode = null;
// shape: Object
// an abstract shape object
// (see dojox/gfx.defaultPath,
// dojox/gfx.defaultPolyline,
// dojox/gfx.defaultRect,
// dojox/gfx.defaultEllipse,
// dojox/gfx.defaultCircle,
// dojox/gfx.defaultLine,
// or dojox/gfx.defaultImage)
this.shape = null;
// matrix: dojox/gfx/matrix.Matrix2D
// a transformation matrix
this.matrix = null;
// fillStyle: dojox/gfx.Fill
// a fill object
// (see dojox/gfx.defaultLinearGradient,
// dojox/gfx.defaultRadialGradient,
// dojox/gfx.defaultPattern,
// or dojo/Color)
this.fillStyle = null;
// strokeStyle: dojox/gfx.Stroke
// a stroke object
// (see dojox/gfx.defaultStroke)
this.strokeStyle = null;
// bbox: dojox/gfx.Rectangle
// a bounding box of this shape
// (see dojox/gfx.defaultRect)
this.bbox = null;
// virtual group structure
// parent: Object
// a parent or null
// (see dojox/gfx/shape.Surface,
// or dojox/gfx.Group)
this.parent = null;
// parentMatrix: dojox/gfx/matrix.Matrix2D
// a transformation matrix inherited from the parent
this.parentMatrix = null;
if(has("gfxRegistry")){
var uid = shape.register(this);
this.getUID = function(){
return uid;
}
}
},
destroy: function(){
// summary:
// Releases all internal resources owned by this shape. Once this method has been called,
// the instance is considered destroyed and should not be used anymore.
if(has("gfxRegistry")){
shape.dispose(this);
}
if(this.rawNode && "__gfxObject__" in this.rawNode){
this.rawNode.__gfxObject__ = null;
}
this.rawNode = null;
},
// trivial getters
getNode: function(){
// summary:
// Different graphics rendering subsystems implement shapes in different ways. This
// method provides access to the underlying graphics subsystem object. Clients calling this
// method and using the return value must be careful not to try sharing or using the underlying node
// in a general way across renderer implementation.
// Returns the underlying graphics Node, or null if no underlying graphics node is used by this shape.
return this.rawNode; // Node
},
getShape: function(){
// summary:
// returns the current Shape object or null
// (see dojox/gfx.defaultPath,
// dojox/gfx.defaultPolyline,
// dojox/gfx.defaultRect,
// dojox/gfx.defaultEllipse,
// dojox/gfx.defaultCircle,
// dojox/gfx.defaultLine,
// or dojox/gfx.defaultImage)
return this.shape; // Object
},
getTransform: function(){
// summary:
// Returns the current transformation matrix applied to this Shape or null
return this.matrix; // dojox/gfx/matrix.Matrix2D
},
getFill: function(){
// summary:
// Returns the current fill object or null
// (see dojox/gfx.defaultLinearGradient,
// dojox/gfx.defaultRadialGradient,
// dojox/gfx.defaultPattern,
// or dojo/Color)
return this.fillStyle; // Object
},
getStroke: function(){
// summary:
// Returns the current stroke object or null
// (see dojox/gfx.defaultStroke)
return this.strokeStyle; // Object
},
getParent: function(){
// summary:
// Returns the parent Shape, Group or null if this Shape is unparented.
// (see dojox/gfx/shape.Surface,
// or dojox/gfx.Group)
return this.parent; // Object
},
getBoundingBox: function(){
// summary:
// Returns the bounding box Rectangle for this shape or null if a BoundingBox cannot be
// calculated for the shape on the current renderer or for shapes with no geometric area (points).
// A bounding box is a rectangular geometric region
// defining the X and Y extent of the shape.
// (see dojox/gfx.defaultRect)
// Note that this method returns a direct reference to the attribute of this instance. Therefore you should
// not modify its value directly but clone it instead.
return this.bbox; // dojox/gfx.Rectangle
},
getTransformedBoundingBox: function(){
// summary:
// returns an array of four points or null
// four points represent four corners of the untransformed bounding box
var b = this.getBoundingBox();
if(!b){
return null; // null
}
var m = this._getRealMatrix(),
gm = matrixLib;
return [ // Array
gm.multiplyPoint(m, b.x, b.y),
gm.multiplyPoint(m, b.x + b.width, b.y),
gm.multiplyPoint(m, b.x + b.width, b.y + b.height),
gm.multiplyPoint(m, b.x, b.y + b.height)
];
},
getEventSource: function(){
// summary:
// returns a Node, which is used as
// a source of events for this shape
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
return this.rawNode; // Node
},
// empty settings
setClip: function(clip){
// summary:
// sets the clipping area of this shape.
// description:
// The clipping area defines the shape area that will be effectively visible. Everything that
// would be drawn outside of the clipping area will not be rendered.
// The possible clipping area types are rectangle, ellipse, polyline and path, but all are not
// supported by all the renderers. vml only supports rectangle clipping, while the gfx silverlight renderer does not
// support path clipping.
// The clip parameter defines the clipping area geometry, and should be an object with the following properties:
//
// - {x:Number, y:Number, width:Number, height:Number} for rectangular clip
// - {cx:Number, cy:Number, rx:Number, ry:Number} for ellipse clip
// - {points:Array} for polyline clip
// - {d:String} for a path clip.
//
// The clip geometry coordinates are expressed in the coordinate system used to draw the shape. In other
// words, the clipping area is defined in the shape parent coordinate system and the shape transform is automatically applied.
// example:
// The following example shows how to clip a gfx image with all the possible clip geometry: a rectangle,
// an ellipse, a circle (using the ellipse geometry), a polyline and a path:
//
// | surface.createImage({src:img, width:200,height:200}).setClip({x:10,y:10,width:50,height:50});
// | surface.createImage({src:img, x:100,y:50,width:200,height:200}).setClip({cx:200,cy:100,rx:20,ry:30});
// | surface.createImage({src:img, x:0,y:350,width:200,height:200}).setClip({cx:100,cy:425,rx:60,ry:60});
// | surface.createImage({src:img, x:300,y:0,width:200,height:200}).setClip({points:[350,0,450,50,380,130,300,110]});
// | surface.createImage({src:img, x:300,y:350,width:200,height:200}).setClip({d:"M 350,350 C314,414 317,557 373,450.0000 z"});
// clip: Object
// an object that defines the clipping geometry, or null to remove clip.
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
this.clip = clip;
},
getClip: function(){
return this.clip;
},
setShape: function(shape){
// summary:
// sets a shape object
// (the default implementation simply ignores it)
// shape: Object
// a shape object
// (see dojox/gfx.defaultPath,
// dojox/gfx.defaultPolyline,
// dojox/gfx.defaultRect,
// dojox/gfx.defaultEllipse,
// dojox/gfx.defaultCircle,
// dojox/gfx.defaultLine,
// or dojox/gfx.defaultImage)
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
this.shape = g.makeParameters(this.shape, shape);
this.bbox = null;
return this; // self
},
setFill: function(fill){
// summary:
// sets a fill object
// (the default implementation simply ignores it)
// fill: Object
// a fill object
// (see dojox/gfx.defaultLinearGradient,
// dojox/gfx.defaultRadialGradient,
// dojox/gfx.defaultPattern,
// or dojo/_base/Color)
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
if(!fill){
// don't fill
this.fillStyle = null;
return this; // self
}
var f = null;
if(typeof(fill) == "object" && "type" in fill){
// gradient or pattern
switch(fill.type){
case "linear":
f = g.makeParameters(g.defaultLinearGradient, fill);
break;
case "radial":
f = g.makeParameters(g.defaultRadialGradient, fill);
break;
case "pattern":
f = g.makeParameters(g.defaultPattern, fill);
break;
}
}else{
// color object
f = g.normalizeColor(fill);
}
this.fillStyle = f;
return this; // self
},
setStroke: function(stroke){
// summary:
// sets a stroke object
// (the default implementation simply ignores it)
// stroke: Object
// a stroke object
// (see dojox/gfx.defaultStroke)
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
if(!stroke){
// don't stroke
this.strokeStyle = null;
return this; // self
}
// normalize the stroke
if(typeof stroke == "string" || lang.isArray(stroke) || stroke instanceof Color){
stroke = {color: stroke};
}
var s = this.strokeStyle = g.makeParameters(g.defaultStroke, stroke);
s.color = g.normalizeColor(s.color);
return this; // self
},
setTransform: function(matrix){
// summary:
// sets a transformation matrix
// matrix: dojox/gfx/matrix.Matrix2D
// a matrix or a matrix-like object
// (see an argument of dojox/gfx/matrix.Matrix2D
// constructor for a list of acceptable arguments)
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
this.matrix = matrixLib.clone(matrix ? matrixLib.normalize(matrix) : matrixLib.identity);
return this._applyTransform(); // self
},
_applyTransform: function(){
// summary:
// physically sets a matrix
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
return this; // self
},
// z-index
moveToFront: function(){
// summary:
// moves a shape to front of its parent's list of shapes
var p = this.getParent();
if(p){
p._moveChildToFront(this);
this._moveToFront(); // execute renderer-specific action
}
return this; // self
},
moveToBack: function(){
// summary:
// moves a shape to back of its parent's list of shapes
var p = this.getParent();
if(p){
p._moveChildToBack(this);
this._moveToBack(); // execute renderer-specific action
}
return this;
},
_moveToFront: function(){
// summary:
// renderer-specific hook, see dojox/gfx/shape.Shape.moveToFront()
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
},
_moveToBack: function(){
// summary:
// renderer-specific hook, see dojox/gfx/shape.Shape.moveToFront()
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
},
// apply left & right transformation
applyRightTransform: function(matrix){
// summary:
// multiplies the existing matrix with an argument on right side
// (this.matrix * matrix)
// matrix: dojox/gfx/matrix.Matrix2D
// a matrix or a matrix-like object
// (see an argument of dojox/gfx/matrix.Matrix2D
// constructor for a list of acceptable arguments)
return matrix ? this.setTransform([this.matrix, matrix]) : this; // self
},
applyLeftTransform: function(matrix){
// summary:
// multiplies the existing matrix with an argument on left side
// (matrix * this.matrix)
// matrix: dojox/gfx/matrix.Matrix2D
// a matrix or a matrix-like object
// (see an argument of dojox/gfx/matrix.Matrix2D
// constructor for a list of acceptable arguments)
return matrix ? this.setTransform([matrix, this.matrix]) : this; // self
},
applyTransform: function(matrix){
// summary:
// a shortcut for dojox/gfx/shape.Shape.applyRightTransform
// matrix: dojox/gfx/matrix.Matrix2D
// a matrix or a matrix-like object
// (see an argument of dojox/gfx/matrix.Matrix2D
// constructor for a list of acceptable arguments)
return matrix ? this.setTransform([this.matrix, matrix]) : this; // self
},
// virtual group methods
removeShape: function(silently){
// summary:
// removes the shape from its parent's list of shapes
// silently: Boolean
// if true, do not redraw a picture yet
if(this.parent){
this.parent.remove(this, silently);
}
return this; // self
},
_setParent: function(parent, matrix){
// summary:
// sets a parent
// parent: Object
// a parent or null
// (see dojox/gfx/shape.Surface,
// or dojox/gfx.Group)
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix or a matrix-like object
this.parent = parent;
return this._updateParentMatrix(matrix); // self
},
_updateParentMatrix: function(matrix){
// summary:
// updates the parent matrix with new matrix
// matrix: dojox/gfx/Matrix2D
// a 2D matrix or a matrix-like object
this.parentMatrix = matrix ? matrixLib.clone(matrix) : null;
return this._applyTransform(); // self
},
_getRealMatrix: function(){
// summary:
// returns the cumulative ('real') transformation matrix
// by combining the shape's matrix with its parent's matrix
var m = this.matrix;
var p = this.parent;
while(p){
if(p.matrix){
m = matrixLib.multiply(p.matrix, m);
}
p = p.parent;
}
return m; // dojox/gfx/matrix.Matrix2D
}
});
shape._eventsProcessing = {
on: function(type, listener){
// summary:
// Connects an event to this shape.
return on(this.getEventSource(), type, shape.fixCallback(this, g.fixTarget, listener));
},
connect: function(name, object, method){
// summary:
// connects a handler to an event on this shape
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
// redirect to fixCallback to normalize events and add the gfxTarget to the event. The latter
// is done by dojox/gfx.fixTarget which is defined by each renderer
if(name.substring(0, 2) == "on"){
name = name.substring(2);
}
return this.on(name, method ? lang.hitch(object, method) : object);
},
disconnect: function(token){
// summary:
// connects a handler by token from an event on this shape
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
return token.remove();
}
};
shape.fixCallback = function(gfxElement, fixFunction, scope, method){
// summary:
// Wraps the callback to allow for tests and event normalization
// before it gets invoked. This is where 'fixTarget' is invoked.
// tags:
// private
// gfxElement: Object
// The GFX object that triggers the action (ex.:
// dojox/gfx.Surface and dojox/gfx/shape.Shape). A new event property
// 'gfxTarget' is added to the event to reference this object.
// for easy manipulation of GFX objects by the event handlers.
// fixFunction: Function
// The function that implements the logic to set the 'gfxTarget'
// property to the event. It should be 'dojox/gfx.fixTarget' for
// most of the cases
// scope: Object
// Optional. The scope to be used when invoking 'method'. If
// omitted, a global scope is used.
// method: Function|String
// The original callback to be invoked.
if(!method){
method = scope;
scope = null;
}
if(lang.isString(method)){
scope = scope || kernel.global;
if(!scope[method]){ throw(['dojox.gfx.shape.fixCallback: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
return function(e){
return fixFunction(e,gfxElement) ? scope[method].apply(scope, arguments || []) : undefined; }; // Function
}
return !scope
? function(e){
return fixFunction(e,gfxElement) ? method.apply(scope, arguments) : undefined; }
: function(e){
return fixFunction(e,gfxElement) ? method.apply(scope, arguments || []) : undefined; }; // Function
};
lang.extend(shape.Shape, shape._eventsProcessing);
shape.Container = {
// summary:
// a container of shapes, which can be used
// as a foundation for renderer-specific groups, or as a way
// to logically group shapes (e.g, to propagate matricies)
_init: function() {
// children: Array
// a list of children
this.children = [];
this._batch = 0;
},
// group management
openBatch: function() {
// summary:
// starts a new batch, subsequent new child shapes will be held in
// the batch instead of appending to the container directly.
// description:
// Because the canvas renderer has no DOM hierarchy, the canvas implementation differs
// such that it suspends the repaint requests for this container until the current batch is closed by a call to closeBatch().
return this;
},
closeBatch: function() {
// summary:
// submits the current batch, append all pending child shapes to DOM
// description:
// On canvas, this method flushes the pending redraws queue.
return this;
},
add: function(shape){
// summary:
// adds a shape to the list
// shape: dojox/gfx/shape.Shape
// the shape to add to the list
var oldParent = shape.getParent();
if(oldParent){
oldParent.remove(shape, true);
}
this.children.push(shape);
return shape._setParent(this, this._getRealMatrix()); // self
},
remove: function(shape, silently){
// summary:
// removes a shape from the list
// shape: dojox/gfx/shape.Shape
// the shape to remove
// silently: Boolean
// if true, do not redraw a picture yet
for(var i = 0; i < this.children.length; ++i){
if(this.children[i] == shape){
if(silently){
// skip for now
}else{
shape.parent = null;
shape.parentMatrix = null;
}
removeItemAt(this.children, i);
break;
}
}
return this; // self
},
clear: function(/*Boolean?*/ destroy){
// summary:
// removes all shapes from a group/surface.
// destroy: Boolean
// Indicates whether the children should be destroyed. Optional.
var shape;
for(var i = 0; i < this.children.length;++i){
shape = this.children[i];
shape.parent = null;
shape.parentMatrix = null;
if(destroy){
shape.destroy();
}
}
this.children = [];
return this; // self
},
getBoundingBox: function(){
// summary:
// Returns the bounding box Rectangle for this shape.
if(this.children){
// if this is a composite shape, then sum up all the children
var result = null;
arr.forEach(this.children, function(shape){
var bb = shape.getBoundingBox();
if(bb){
var ct = shape.getTransform();
if(ct){
bb = matrixLib.multiplyRectangle(ct, bb);
}
if(result){
// merge two bbox
result.x = Math.min(result.x, bb.x);
result.y = Math.min(result.y, bb.y);
result.endX = Math.max(result.endX, bb.x + bb.width);
result.endY = Math.max(result.endY, bb.y + bb.height);
}else{
// first bbox
result = {
x: bb.x,
y: bb.y,
endX: bb.x + bb.width,
endY: bb.y + bb.height
};
}
}
});
if(result){
result.width = result.endX - result.x;
result.height = result.endY - result.y;
}
return result; // dojox/gfx.Rectangle
}
// unknown/empty bounding box, subclass shall override this impl
return null;
},
// moving child nodes
_moveChildToFront: function(shape){
// summary:
// moves a shape to front of the list of shapes
// shape: dojox/gfx/shape.Shape
// one of the child shapes to move to the front
for(var i = 0; i < this.children.length; ++i){
if(this.children[i] == shape){
removeItemAt(this.children, i);
this.children.push(shape);
break;
}
}
return this; // self
},
_moveChildToBack: function(shape){
// summary:
// moves a shape to back of the list of shapes
// shape: dojox/gfx/shape.Shape
// one of the child shapes to move to the front
for(var i = 0; i < this.children.length; ++i){
if(this.children[i] == shape){
removeItemAt(this.children, i);
this.children.unshift(shape);
break;
}
}
return this; // self
}
};
shape.Surface = declare("dojox.gfx.shape.Surface", null, {
// summary:
// a surface object to be used for drawings
constructor: function(){
// underlying node
this.rawNode = null;
// the parent node
this._parent = null;
// the list of DOM nodes to be deleted in the case of destruction
this._nodes = [];
// the list of events to be detached in the case of destruction
this._events = [];
},
destroy: function(){
// summary:
// destroy all relevant external resources and release all
// external references to make this object garbage-collectible
arr.forEach(this._nodes, domConstruct.destroy);
this._nodes = [];
arr.forEach(this._events, function(h){ if(h){ h.remove(); } });
this._events = [];
this.rawNode = null; // recycle it in _nodes, if it needs to be recycled
if(has("ie")){
while(this._parent.lastChild){
domConstruct.destroy(this._parent.lastChild);
}
}else{
this._parent.innerHTML = "";
}
this._parent = null;
},
getEventSource: function(){
// summary:
// returns a node, which can be used to attach event listeners
return this.rawNode; // Node
},
_getRealMatrix: function(){
// summary:
// always returns the identity matrix
return null; // dojox/gfx/Matrix2D
},
/*=====
setDimensions: function(width, height){
// summary:
// sets the width and height of the rawNode
// width: String
// width of surface, e.g., "100px"
// height: String
// height of surface, e.g., "100px"
return this; // self
},
getDimensions: function(){
// summary:
// gets current width and height in pixels
// returns: Object
// object with properties "width" and "height"
},
=====*/
isLoaded: true,
onLoad: function(/*dojox/gfx/shape.Surface*/ surface){
// summary:
// local event, fired once when the surface is created
// asynchronously, used only when isLoaded is false, required
// only for Silverlight.
},
whenLoaded: function(/*Object|Null*/ context, /*Function|String*/ method){
var f = lang.hitch(context, method);
if(this.isLoaded){
f(this);
}else{
on.once(this, "load", function(surface){
f(surface);
});
}
}
});
lang.extend(shape.Surface, shape._eventsProcessing);
/*=====
g.Point = declare("dojox/gfx.Point", null, {
// summary:
// 2D point for drawings - {x, y}
// description:
// Do not use this object directly!
// Use the naked object instead: {x: 1, y: 2}.
});
g.Rectangle = declare("dojox.gfx.Rectangle", null, {
// summary:
// rectangle - {x, y, width, height}
// description:
// Do not use this object directly!
// Use the naked object instead: {x: 1, y: 2, width: 100, height: 200}.
});
=====*/
shape.Rect = declare("dojox.gfx.shape.Rect", shape.Shape, {
// summary:
// a generic rectangle
constructor: function(rawNode){
// rawNode: Node
// The underlying graphics system object (typically a DOM Node)
this.shape = g.getDefault("Rect");
this.rawNode = rawNode;
},
getBoundingBox: function(){
// summary:
// returns the bounding box (its shape in this case)
return this.shape; // dojox/gfx.Rectangle
}
});
shape.Ellipse = declare("dojox.gfx.shape.Ellipse", shape.Shape, {
// summary:
// a generic ellipse
constructor: function(rawNode){
// rawNode: Node
// a DOM Node
this.shape = g.getDefault("Ellipse");
this.rawNode = rawNode;
},
getBoundingBox: function(){
// summary:
// returns the bounding box
if(!this.bbox){
var shape = this.shape;
this.bbox = {x: shape.cx - shape.rx, y: shape.cy - shape.ry,
width: 2 * shape.rx, height: 2 * shape.ry};
}
return this.bbox; // dojox/gfx.Rectangle
}
});
shape.Circle = declare("dojox.gfx.shape.Circle", shape.Shape, {
// summary:
// a generic circle
constructor: function(rawNode){
// rawNode: Node
// a DOM Node
this.shape = g.getDefault("Circle");
this.rawNode = rawNode;
},
getBoundingBox: function(){
// summary:
// returns the bounding box
if(!this.bbox){
var shape = this.shape;
this.bbox = {x: shape.cx - shape.r, y: shape.cy - shape.r,
width: 2 * shape.r, height: 2 * shape.r};
}
return this.bbox; // dojox/gfx.Rectangle
}
});
shape.Line = declare("dojox.gfx.shape.Line", shape.Shape, {
// summary:
// a generic line (do not instantiate it directly)
constructor: function(rawNode){
// rawNode: Node
// a DOM Node
this.shape = g.getDefault("Line");
this.rawNode = rawNode;
},
getBoundingBox: function(){
// summary:
// returns the bounding box
if(!this.bbox){
var shape = this.shape;
this.bbox = {
x: Math.min(shape.x1, shape.x2),
y: Math.min(shape.y1, shape.y2),
width: Math.abs(shape.x2 - shape.x1),
height: Math.abs(shape.y2 - shape.y1)
};
}
return this.bbox; // dojox/gfx.Rectangle
}
});
shape.Polyline = declare("dojox.gfx.shape.Polyline", shape.Shape, {
// summary:
// a generic polyline/polygon (do not instantiate it directly)
constructor: function(rawNode){
// rawNode: Node
// a DOM Node
this.shape = g.getDefault("Polyline");
this.rawNode = rawNode;
},
setShape: function(points, closed){
// summary:
// sets a polyline/polygon shape object
// points: Object|Array
// a polyline/polygon shape object, or an array of points
// closed: Boolean
// close the polyline to make a polygon
if(points && points instanceof Array){
this.inherited(arguments, [{points: points}]);
if(closed && this.shape.points.length){
this.shape.points.push(this.shape.points[0]);
}
}else{
this.inherited(arguments, [points]);
}
return this; // self
},
_normalizePoints: function(){
// summary:
// normalize points to array of {x:number, y:number}
var p = this.shape.points, l = p && p.length;
if(l && typeof p[0] == "number"){
var points = [];
for(var i = 0; i < l; i += 2){
points.push({x: p[i], y: p[i + 1]});
}
this.shape.points = points;
}
},
getBoundingBox: function(){
// summary:
// returns the bounding box
if(!this.bbox && this.shape.points.length){
var p = this.shape.points;
var l = p.length;
var t = p[0];
var bbox = {l: t.x, t: t.y, r: t.x, b: t.y};
for(var i = 1; i < l; ++i){
t = p[i];
if(bbox.l > t.x) bbox.l = t.x;
if(bbox.r < t.x) bbox.r = t.x;
if(bbox.t > t.y) bbox.t = t.y;
if(bbox.b < t.y) bbox.b = t.y;
}
this.bbox = {
x: bbox.l,
y: bbox.t,
width: bbox.r - bbox.l,
height: bbox.b - bbox.t
};
}
return this.bbox; // dojox/gfx.Rectangle
}
});
shape.Image = declare("dojox.gfx.shape.Image", shape.Shape, {
// summary:
// a generic image (do not instantiate it directly)
constructor: function(rawNode){
// rawNode: Node
// a DOM Node
this.shape = g.getDefault("Image");
this.rawNode = rawNode;
},
getBoundingBox: function(){
// summary:
// returns the bounding box (its shape in this case)
return this.shape; // dojox/gfx.Rectangle
},
setStroke: function(){
// summary:
// ignore setting a stroke style
return this; // self
},
setFill: function(){
// summary:
// ignore setting a fill style
return this; // self
}
});
shape.Text = declare(shape.Shape, {
// summary:
// a generic text (do not instantiate it directly)
constructor: function(rawNode){
// rawNode: Node
// a DOM Node
this.fontStyle = null;
this.shape = g.getDefault("Text");
this.rawNode = rawNode;
},
getFont: function(){
// summary:
// returns the current font object or null
return this.fontStyle; // Object
},
setFont: function(newFont){
// summary:
// sets a font for text
// newFont: Object
// a font object (see dojox/gfx.defaultFont) or a font string
this.fontStyle = typeof newFont == "string" ? g.splitFontString(newFont) :
g.makeParameters(g.defaultFont, newFont);
this._setFont();
return this; // self
},
getBoundingBox: function(){
var bbox = null, s = this.getShape();
if(s.text){
bbox = g._base._computeTextBoundingBox(this);
}
return bbox;
}
});
shape.Creator = {
// summary:
// shape creators
createShape: function(shape){
// summary:
// creates a shape object based on its type; it is meant to be used
// by group-like objects
// shape: Object
// a shape descriptor object
// returns: dojox/gfx/shape.Shape | Null
// a fully instantiated surface-specific Shape object
switch(shape.type){
case g.defaultPath.type: return this.createPath(shape);
case g.defaultRect.type: return this.createRect(shape);
case g.defaultCircle.type: return this.createCircle(shape);
case g.defaultEllipse.type: return this.createEllipse(shape);
case g.defaultLine.type: return this.createLine(shape);
case g.defaultPolyline.type: return this.createPolyline(shape);
case g.defaultImage.type: return this.createImage(shape);
case g.defaultText.type: return this.createText(shape);
case g.defaultTextPath.type: return this.createTextPath(shape);
}
return null;
},
createGroup: function(){
// summary:
// creates a group shape
return this.createObject(g.Group); // dojox/gfx/Group
},
createRect: function(rect){
// summary:
// creates a rectangle shape
// rect: Object
// a path object (see dojox/gfx.defaultRect)
return this.createObject(g.Rect, rect); // dojox/gfx/shape.Rect
},
createEllipse: function(ellipse){
// summary:
// creates an ellipse shape
// ellipse: Object
// an ellipse object (see dojox/gfx.defaultEllipse)
return this.createObject(g.Ellipse, ellipse); // dojox/gfx/shape.Ellipse
},
createCircle: function(circle){
// summary:
// creates a circle shape
// circle: Object
// a circle object (see dojox/gfx.defaultCircle)
return this.createObject(g.Circle, circle); // dojox/gfx/shape.Circle
},
createLine: function(line){
// summary:
// creates a line shape
// line: Object
// a line object (see dojox/gfx.defaultLine)
return this.createObject(g.Line, line); // dojox/gfx/shape.Line
},
createPolyline: function(points){
// summary:
// creates a polyline/polygon shape
// points: Object
// a points object (see dojox/gfx.defaultPolyline)
// or an Array of points
return this.createObject(g.Polyline, points); // dojox/gfx/shape.Polyline
},
createImage: function(image){
// summary:
// creates a image shape
// image: Object
// an image object (see dojox/gfx.defaultImage)
return this.createObject(g.Image, image); // dojox/gfx/shape.Image
},
createText: function(text){
// summary:
// creates a text shape
// text: Object
// a text object (see dojox/gfx.defaultText)
return this.createObject(g.Text, text); // dojox/gfx/shape.Text
},
createPath: function(path){
// summary:
// creates a path shape
// path: Object
// a path object (see dojox/gfx.defaultPath)
return this.createObject(g.Path, path); // dojox/gfx/shape.Path
},
createTextPath: function(text){
// summary:
// creates a text shape
// text: Object
// a textpath object (see dojox/gfx.defaultTextPath)
return this.createObject(g.TextPath, {}).setText(text); // dojox/gfx/shape.TextPath
},
createObject: function(shapeType, rawShape){
// summary:
// creates an instance of the passed shapeType class
// shapeType: Function
// a class constructor to create an instance of
// rawShape: Object
// properties to be passed in to the classes 'setShape' method
// SHOULD BE RE-IMPLEMENTED BY THE RENDERER!
return null; // dojox/gfx/shape.Shape
}
};
/*=====
lang.extend(shape.Surface, shape.Container);
lang.extend(shape.Surface, shape.Creator);
g.Group = declare(shape.Shape, {
// summary:
// a group shape, which can be used
// to logically group shapes (e.g, to propagate matricies)
});
lang.extend(g.Group, shape.Container);
lang.extend(g.Group, shape.Creator);
g.Rect = shape.Rect;
g.Circle = shape.Circle;
g.Ellipse = shape.Ellipse;
g.Line = shape.Line;
g.Polyline = shape.Polyline;
g.Text = shape.Text;
g.Surface = shape.Surface;
=====*/
return shape;
});
},
'dojox/gfx/matrix':function(){
define(["./_base","dojo/_base/lang"],
function(g, lang){
var m = g.matrix = {};
// candidates for dojox.math:
var _degToRadCache = {};
m._degToRad = function(degree){
return _degToRadCache[degree] || (_degToRadCache[degree] = (Math.PI * degree / 180));
};
m._radToDeg = function(radian){ return radian / Math.PI * 180; };
m.Matrix2D = function(arg){
// summary:
// a 2D matrix object
// description:
// Normalizes a 2D matrix-like object. If arrays is passed,
// all objects of the array are normalized and multiplied sequentially.
// arg: Object
// a 2D matrix-like object, a number, or an array of such objects
if(arg){
if(typeof arg == "number"){
this.xx = this.yy = arg;
}else if(arg instanceof Array){
if(arg.length > 0){
var matrix = m.normalize(arg[0]);
// combine matrices
for(var i = 1; i < arg.length; ++i){
var l = matrix, r = m.normalize(arg[i]);
matrix = new m.Matrix2D();
matrix.xx = l.xx * r.xx + l.xy * r.yx;
matrix.xy = l.xx * r.xy + l.xy * r.yy;
matrix.yx = l.yx * r.xx + l.yy * r.yx;
matrix.yy = l.yx * r.xy + l.yy * r.yy;
matrix.dx = l.xx * r.dx + l.xy * r.dy + l.dx;
matrix.dy = l.yx * r.dx + l.yy * r.dy + l.dy;
}
lang.mixin(this, matrix);
}
}else{
lang.mixin(this, arg);
}
}
};
// the default (identity) matrix, which is used to fill in missing values
lang.extend(m.Matrix2D, {xx: 1, xy: 0, yx: 0, yy: 1, dx: 0, dy: 0});
lang.mixin(m, {
// summary:
// class constants, and methods of dojox/gfx/matrix
// matrix constants
// identity: dojox/gfx/matrix.Matrix2D
// an identity matrix constant: identity * (x, y) == (x, y)
identity: new m.Matrix2D(),
// flipX: dojox/gfx/matrix.Matrix2D
// a matrix, which reflects points at x = 0 line: flipX * (x, y) == (-x, y)
flipX: new m.Matrix2D({xx: -1}),
// flipY: dojox/gfx/matrix.Matrix2D
// a matrix, which reflects points at y = 0 line: flipY * (x, y) == (x, -y)
flipY: new m.Matrix2D({yy: -1}),
// flipXY: dojox/gfx/matrix.Matrix2D
// a matrix, which reflects points at the origin of coordinates: flipXY * (x, y) == (-x, -y)
flipXY: new m.Matrix2D({xx: -1, yy: -1}),
// matrix creators
translate: function(a, b){
// summary:
// forms a translation matrix
// description:
// The resulting matrix is used to translate (move) points by specified offsets.
// a: Number|dojox/gfx.Point
// an x coordinate value, or a point-like object, which specifies offsets for both dimensions
// b: Number?
// a y coordinate value
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 1){
return new m.Matrix2D({dx: a, dy: b}); // dojox/gfx/matrix.Matrix2D
}
// branch
return new m.Matrix2D({dx: a.x, dy: a.y}); // dojox/gfx/matrix.Matrix2D
},
scale: function(a, b){
// summary:
// forms a scaling matrix
// description:
// The resulting matrix is used to scale (magnify) points by specified offsets.
// a: Number|dojox/gfx.Point
// a scaling factor used for the x coordinate, or
// a uniform scaling factor used for the both coordinates, or
// a point-like object, which specifies scale factors for both dimensions
// b: Number?
// a scaling factor used for the y coordinate
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 1){
return new m.Matrix2D({xx: a, yy: b}); // dojox/gfx/matrix.Matrix2D
}
if(typeof a == "number"){
return new m.Matrix2D({xx: a, yy: a}); // dojox/gfx/matrix.Matrix2D
}
return new m.Matrix2D({xx: a.x, yy: a.y}); // dojox/gfx/matrix.Matrix2D
},
rotate: function(angle){
// summary:
// forms a rotating matrix
// description:
// The resulting matrix is used to rotate points
// around the origin of coordinates (0, 0) by specified angle.
// angle: Number
// an angle of rotation in radians (>0 for CW)
// returns: dojox/gfx/matrix.Matrix2D
var c = Math.cos(angle);
var s = Math.sin(angle);
return new m.Matrix2D({xx: c, xy: -s, yx: s, yy: c}); // dojox/gfx/matrix.Matrix2D
},
rotateg: function(degree){
// summary:
// forms a rotating matrix
// description:
// The resulting matrix is used to rotate points
// around the origin of coordinates (0, 0) by specified degree.
// See dojox/gfx/matrix.rotate() for comparison.
// degree: Number
// an angle of rotation in degrees (>0 for CW)
// returns: dojox/gfx/matrix.Matrix2D
return m.rotate(m._degToRad(degree)); // dojox/gfx/matrix.Matrix2D
},
skewX: function(angle) {
// summary:
// forms an x skewing matrix
// description:
// The resulting matrix is used to skew points in the x dimension
// around the origin of coordinates (0, 0) by specified angle.
// angle: Number
// a skewing angle in radians
// returns: dojox/gfx/matrix.Matrix2D
return new m.Matrix2D({xy: Math.tan(angle)}); // dojox/gfx/matrix.Matrix2D
},
skewXg: function(degree){
// summary:
// forms an x skewing matrix
// description:
// The resulting matrix is used to skew points in the x dimension
// around the origin of coordinates (0, 0) by specified degree.
// See dojox/gfx/matrix.skewX() for comparison.
// degree: Number
// a skewing angle in degrees
// returns: dojox/gfx/matrix.Matrix2D
return m.skewX(m._degToRad(degree)); // dojox/gfx/matrix.Matrix2D
},
skewY: function(angle){
// summary:
// forms a y skewing matrix
// description:
// The resulting matrix is used to skew points in the y dimension
// around the origin of coordinates (0, 0) by specified angle.
// angle: Number
// a skewing angle in radians
// returns: dojox/gfx/matrix.Matrix2D
return new m.Matrix2D({yx: Math.tan(angle)}); // dojox/gfx/matrix.Matrix2D
},
skewYg: function(degree){
// summary:
// forms a y skewing matrix
// description:
// The resulting matrix is used to skew points in the y dimension
// around the origin of coordinates (0, 0) by specified degree.
// See dojox/gfx/matrix.skewY() for comparison.
// degree: Number
// a skewing angle in degrees
// returns: dojox/gfx/matrix.Matrix2D
return m.skewY(m._degToRad(degree)); // dojox/gfx/matrix.Matrix2D
},
reflect: function(a, b){
// summary:
// forms a reflection matrix
// description:
// The resulting matrix is used to reflect points around a vector,
// which goes through the origin.
// a: dojox/gfx.Point|Number
// a point-like object, which specifies a vector of reflection, or an X value
// b: Number?
// a Y value
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length == 1){
b = a.y;
a = a.x;
}
// make a unit vector
var a2 = a * a, b2 = b * b, n2 = a2 + b2, xy = 2 * a * b / n2;
return new m.Matrix2D({xx: 2 * a2 / n2 - 1, xy: xy, yx: xy, yy: 2 * b2 / n2 - 1}); // dojox/gfx/matrix.Matrix2D
},
project: function(a, b){
// summary:
// forms an orthogonal projection matrix
// description:
// The resulting matrix is used to project points orthogonally on a vector,
// which goes through the origin.
// a: dojox/gfx.Point|Number
// a point-like object, which specifies a vector of projection, or
// an x coordinate value
// b: Number?
// a y coordinate value
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length == 1){
b = a.y;
a = a.x;
}
// make a unit vector
var a2 = a * a, b2 = b * b, n2 = a2 + b2, xy = a * b / n2;
return new m.Matrix2D({xx: a2 / n2, xy: xy, yx: xy, yy: b2 / n2}); // dojox/gfx/matrix.Matrix2D
},
// ensure matrix 2D conformance
normalize: function(matrix){
// summary:
// converts an object to a matrix, if necessary
// description:
// Converts any 2D matrix-like object or an array of
// such objects to a valid dojox/gfx/matrix.Matrix2D object.
// matrix: Object
// an object, which is converted to a matrix, if necessary
// returns: dojox/gfx/matrix.Matrix2D
return (matrix instanceof m.Matrix2D) ? matrix : new m.Matrix2D(matrix); // dojox/gfx/matrix.Matrix2D
},
// common operations
isIdentity: function(matrix){
// summary:
// returns whether the specified matrix is the identity.
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix object to be tested
// returns: Boolean
return matrix.xx == 1 && matrix.xy == 0 && matrix.yx == 0 && matrix.yy == 1 && matrix.dx == 0 && matrix.dy == 0; // Boolean
},
clone: function(matrix){
// summary:
// creates a copy of a 2D matrix
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix-like object to be cloned
// returns: dojox/gfx/matrix.Matrix2D
var obj = new m.Matrix2D();
for(var i in matrix){
if(typeof(matrix[i]) == "number" && typeof(obj[i]) == "number" && obj[i] != matrix[i]) obj[i] = matrix[i];
}
return obj; // dojox/gfx/matrix.Matrix2D
},
invert: function(matrix){
// summary:
// inverts a 2D matrix
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix-like object to be inverted
// returns: dojox/gfx/matrix.Matrix2D
var M = m.normalize(matrix),
D = M.xx * M.yy - M.xy * M.yx;
M = new m.Matrix2D({
xx: M.yy/D, xy: -M.xy/D,
yx: -M.yx/D, yy: M.xx/D,
dx: (M.xy * M.dy - M.yy * M.dx) / D,
dy: (M.yx * M.dx - M.xx * M.dy) / D
});
return M; // dojox/gfx/matrix.Matrix2D
},
_multiplyPoint: function(matrix, x, y){
// summary:
// applies a matrix to a point
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix object to be applied
// x: Number
// an x coordinate of a point
// y: Number
// a y coordinate of a point
// returns: dojox/gfx.Point
return {x: matrix.xx * x + matrix.xy * y + matrix.dx, y: matrix.yx * x + matrix.yy * y + matrix.dy}; // dojox/gfx.Point
},
multiplyPoint: function(matrix, /* Number||Point */ a, /* Number? */ b){
// summary:
// applies a matrix to a point
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix object to be applied
// a: Number|dojox/gfx.Point
// an x coordinate of a point, or a point
// b: Number?
// a y coordinate of a point
// returns: dojox/gfx.Point
var M = m.normalize(matrix);
if(typeof a == "number" && typeof b == "number"){
return m._multiplyPoint(M, a, b); // dojox/gfx.Point
}
return m._multiplyPoint(M, a.x, a.y); // dojox/gfx.Point
},
multiplyRectangle: function(matrix, /*Rectangle*/ rect){
// summary:
// Applies a matrix to a rectangle.
// description:
// The method applies the transformation on all corners of the
// rectangle and returns the smallest rectangle enclosing the 4 transformed
// points.
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix object to be applied.
// rect: Rectangle
// the rectangle to transform.
// returns: dojox/gfx.Rectangle
var M = m.normalize(matrix);
rect = rect || {x:0, y:0, width:0, height:0};
if(m.isIdentity(M))
return {x: rect.x, y: rect.y, width: rect.width, height: rect.height}; // dojo/gfx.Rectangle
var p0 = m.multiplyPoint(M, rect.x, rect.y),
p1 = m.multiplyPoint(M, rect.x, rect.y + rect.height),
p2 = m.multiplyPoint(M, rect.x + rect.width, rect.y),
p3 = m.multiplyPoint(M, rect.x + rect.width, rect.y + rect.height),
minx = Math.min(p0.x, p1.x, p2.x, p3.x),
miny = Math.min(p0.y, p1.y, p2.y, p3.y),
maxx = Math.max(p0.x, p1.x, p2.x, p3.x),
maxy = Math.max(p0.y, p1.y, p2.y, p3.y);
return{ // dojo/gfx.Rectangle
x: minx,
y: miny,
width: maxx - minx,
height: maxy - miny
};
},
multiply: function(matrix){
// summary:
// combines matrices by multiplying them sequentially in the given order
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix-like object,
// all subsequent arguments are matrix-like objects too
var M = m.normalize(matrix);
// combine matrices
for(var i = 1; i < arguments.length; ++i){
var l = M, r = m.normalize(arguments[i]);
M = new m.Matrix2D();
M.xx = l.xx * r.xx + l.xy * r.yx;
M.xy = l.xx * r.xy + l.xy * r.yy;
M.yx = l.yx * r.xx + l.yy * r.yx;
M.yy = l.yx * r.xy + l.yy * r.yy;
M.dx = l.xx * r.dx + l.xy * r.dy + l.dx;
M.dy = l.yx * r.dx + l.yy * r.dy + l.dy;
}
return M; // dojox/gfx/matrix.Matrix2D
},
// high level operations
_sandwich: function(matrix, x, y){
// summary:
// applies a matrix at a central point
// matrix: dojox/gfx/matrix.Matrix2D
// a 2D matrix-like object, which is applied at a central point
// x: Number
// an x component of the central point
// y: Number
// a y component of the central point
return m.multiply(m.translate(x, y), matrix, m.translate(-x, -y)); // dojox/gfx/matrix.Matrix2D
},
scaleAt: function(a, b, c, d){
// summary:
// scales a picture using a specified point as a center of scaling
// description:
// Compare with dojox/gfx/matrix.scale().
// a: Number
// a scaling factor used for the x coordinate, or a uniform scaling factor used for both coordinates
// b: Number?
// a scaling factor used for the y coordinate
// c: Number|Point
// an x component of a central point, or a central point
// d: Number
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
switch(arguments.length){
case 4:
// a and b are scale factor components, c and d are components of a point
return m._sandwich(m.scale(a, b), c, d); // dojox/gfx/matrix.Matrix2D
case 3:
if(typeof c == "number"){
return m._sandwich(m.scale(a), b, c); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.scale(a, b), c.x, c.y); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.scale(a), b.x, b.y); // dojox/gfx/matrix.Matrix2D
},
rotateAt: function(angle, a, b){
// summary:
// rotates a picture using a specified point as a center of rotation
// description:
// Compare with dojox/gfx/matrix.rotate().
// angle: Number
// an angle of rotation in radians (>0 for CW)
// a: Number|dojox/gfx.Point
// an x component of a central point, or a central point
// b: Number?
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 2){
return m._sandwich(m.rotate(angle), a, b); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.rotate(angle), a.x, a.y); // dojox/gfx/matrix.Matrix2D
},
rotategAt: function(degree, a, b){
// summary:
// rotates a picture using a specified point as a center of rotation
// description:
// Compare with dojox/gfx/matrix.rotateg().
// degree: Number
// an angle of rotation in degrees (>0 for CW)
// a: Number|dojox/gfx.Point
// an x component of a central point, or a central point
// b: Number?
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 2){
return m._sandwich(m.rotateg(degree), a, b); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.rotateg(degree), a.x, a.y); // dojox/gfx/matrix.Matrix2D
},
skewXAt: function(angle, a, b){
// summary:
// skews a picture along the x axis using a specified point as a center of skewing
// description:
// Compare with dojox/gfx/matrix.skewX().
// angle: Number
// a skewing angle in radians
// a: Number|dojox/gfx.Point
// an x component of a central point, or a central point
// b: Number?
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 2){
return m._sandwich(m.skewX(angle), a, b); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.skewX(angle), a.x, a.y); // dojox/gfx/matrix.Matrix2D
},
skewXgAt: function(degree, a, b){
// summary:
// skews a picture along the x axis using a specified point as a center of skewing
// description:
// Compare with dojox/gfx/matrix.skewXg().
// degree: Number
// a skewing angle in degrees
// a: Number|dojox/gfx.Point
// an x component of a central point, or a central point
// b: Number?
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 2){
return m._sandwich(m.skewXg(degree), a, b); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.skewXg(degree), a.x, a.y); // dojox/gfx/matrix.Matrix2D
},
skewYAt: function(angle, a, b){
// summary:
// skews a picture along the y axis using a specified point as a center of skewing
// description:
// Compare with dojox/gfx/matrix.skewY().
// angle: Number
// a skewing angle in radians
// a: Number|dojox/gfx.Point
// an x component of a central point, or a central point
// b: Number?
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 2){
return m._sandwich(m.skewY(angle), a, b); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.skewY(angle), a.x, a.y); // dojox/gfx/matrix.Matrix2D
},
skewYgAt: function(/* Number */ degree, /* Number||Point */ a, /* Number? */ b){
// summary:
// skews a picture along the y axis using a specified point as a center of skewing
// description:
// Compare with dojox/gfx/matrix.skewYg().
// degree: Number
// a skewing angle in degrees
// a: Number|dojox/gfx.Point
// an x component of a central point, or a central point
// b: Number?
// a y component of a central point
// returns: dojox/gfx/matrix.Matrix2D
if(arguments.length > 2){
return m._sandwich(m.skewYg(degree), a, b); // dojox/gfx/matrix.Matrix2D
}
return m._sandwich(m.skewYg(degree), a.x, a.y); // dojox/gfx/matrix.Matrix2D
}
//TODO: rect-to-rect mapping, scale-to-fit (isotropic and anisotropic versions)
});
// propagate Matrix2D up
g.Matrix2D = m.Matrix2D;
return m;
});
},
'dojox/charting/SimpleTheme':function(){
define(["dojo/_base/lang", "dojo/_base/array","dojo/_base/declare","dojo/_base/Color", "dojox/lang/utils", "dojox/gfx/gradutils"],
function(lang, arr, declare, Color, dlu, dgg){
var SimpleTheme = declare("dojox.charting.SimpleTheme", null, {
// summary:
// A SimpleTheme or Theme is a pre-defined object, primarily JSON-based, that makes up the definitions to
// style a chart.
//
// description:
// While you can set up style definitions on a chart directly (usually through the various add methods
// on a dojox.charting.Chart object), a Theme simplifies this manual setup by allowing you to
// pre-define all of the various visual parameters of each element in a chart.
//
// Most of the properties of a Theme are straight-forward; if something is line-based (such as
// an axis or the ticks on an axis), they will be defined using basic stroke parameters. Likewise,
// if an element is primarily block-based (such as the background of a chart), it will be primarily
// fill-based.
//
// In addition (for convenience), a Theme definition does not have to contain the entire JSON-based
// structure. Each theme is built on top of a default theme (which serves as the basis for the theme
// "GreySkies"), and is mixed into the default theme object. This allows you to create a theme based,
// say, solely on colors for data series.
//
// Defining a new theme is relatively easy; see any of the themes in dojox.charting.themes for examples
// on how to define your own.
//
// When you set a theme on a chart, the theme itself is deep-cloned. This means that you cannot alter
// the theme itself after setting the theme value on a chart, and expect it to change your chart. If you
// are looking to make alterations to a theme for a chart, the suggestion would be to create your own
// theme, based on the one you want to use, that makes those alterations before it is applied to a chart.
//
// Finally, a Theme contains a number of functions to facilitate rendering operations on a chart--the main
// helper of which is the ~next~ method, in which a chart asks for the information for the next data series
// to be rendered.
//
// A note on colors:
// A theme palette is usually comprised of 5 different color definitions, and
// no more. If you have a need to render a chart with more than 5 data elements, you can simply "push"
// new color definitions into the theme's .color array. Make sure that you do that with the actual
// theme object from a Chart, and not in the theme itself (i.e. either do that before using .setTheme
// on a chart).
//
// example:
// The default theme (and structure) looks like so:
// | // all objects are structs used directly in dojox.gfx
// | chart:{
// | margins: {l: 10, t: 10, r: 10, b: 10},
// | stroke: null,
// | fill: "white",
// | pageStyle: null // suggested page style as an object suitable for dojo.style()
// | },
// | plotarea:{
// | stroke: null,
// | fill: "white"
// | },
// | axis:{
// | stroke: { // the axis itself
// | color: "#333",
// | width: 1
// | },
// | tick: { // used as a foundation for all ticks
// | color: "#666",
// | position: "center",
// | font: "normal normal normal 7pt Tahoma", // labels on axis
// | fontColor: "#333" // color of labels
// | },
// | majorTick: { // major ticks on axis, and used for major gridlines
// | width: 1,
// | length: 6
// | },
// | minorTick: { // minor ticks on axis, and used for minor gridlines
// | width: 0.8,
// | length: 3
// | },
// | microTick: { // minor ticks on axis, and used for minor gridlines
// | width: 0.5,
// | length: 1
// | },
// | title: {
// | gap: 15,
// | font: "normal normal normal 11pt Tahoma", // title font
// | fontColor: "#333", // title font color
// | orientation: "axis" // "axis": facing the axis, "away": facing away
// | }
// | },
// | series: {
// | stroke: {width: 1.5, color: "#333"}, // line
// | outline: {width: 0.1, color: "#ccc"}, // outline
// | //shadow: {dx: 1, dy: 1, width: 2, color: [0, 0, 0, 0.3]},
// | shadow: null, // no shadow
// | //filter: dojox/gfx/filters.createFilter(),
// | filter: null, // no filter, to use a filter you must use gfx SVG render and require dojox/gfx/svgext
// | fill: "#ccc", // fill, if appropriate
// | font: "normal normal normal 8pt Tahoma", // if there's a label
// | fontColor: "#000" // color of labels
// | labelWiring: {width: 1, color: "#ccc"}, // connect marker and target data item(slice, column, bar...)
// | },
// | marker: { // any markers on a series
// | symbol: "m-3,3 l3,-6 3,6 z", // symbol
// | stroke: {width: 1.5, color: "#333"}, // stroke
// | outline: {width: 0.1, color: "#ccc"}, // outline
// | shadow: null, // no shadow
// | fill: "#ccc", // fill if needed
// | font: "normal normal normal 8pt Tahoma", // label
// | fontColor: "#000"
// | },
// | grid: { // grid, when not present axis tick strokes are used instead
// | majorLine: { // major grid line
// | color: "#666",
// | width: 1,
// | length: 6
// | },
// | minorLine: { // minor grid line
// | color: "#666",
// | width: 0.8,
// | length: 3
// | },
// | fill: "grey", // every other stripe
// | alternateFill: "grey" // alternate stripe
// | },
// | indicator: {
// | lineStroke: {width: 1.5, color: "#333"}, // line
// | lineOutline: {width: 0.1, color: "#ccc"}, // line outline
// | lineShadow: null, // no line shadow
// | lineFill: null, // fill between lines for dual indicators
// | stroke: {width: 1.5, color: "#333"}, // label background stroke
// | outline: {width: 0.1, color: "#ccc"}, // label background outline
// | shadow: null, // no label background shadow
// | fill: "#ccc", // label background fill
// | radius: 3, // radius of the label background
// | font: "normal normal normal 10pt Tahoma", // label font
// | fontColor: "#000" // label color
// | markerFill: "#ccc", // marker fill
// | markerSymbol: "m-3,0 c0,-4 6,-4 6,0 m-6,0 c0,4 6,4 6,0", // marker symbol
// | markerStroke: {width: 1.5, color: "#333"}, // marker stroke
// | markerOutline: {width: 0.1, color: "#ccc"}, // marker outline
// | markerShadow: null // no marker shadow
// | },
// | pieInnerRadius: 33
//
// example:
// Defining a new theme is pretty simple:
// | var Grasslands = new SimpleTheme({
// | colors: [ "#70803a", "#dde574", "#788062", "#b1cc5d", "#eff2c2" ],
// | pieInnerRadius: 15
// | });
// |
// | myChart.setTheme(Grasslands);
shapeSpaces: {shape: 1, shapeX: 1, shapeY: 1},
constructor: function(kwArgs){
// summary:
// Initialize a theme using the keyword arguments. Note that the arguments
// look like the example (above), and may include a few more parameters.
kwArgs = kwArgs || {};
// populate theme with defaults updating them if needed
var def = SimpleTheme.defaultTheme;
arr.forEach(["chart", "plotarea", "axis", "grid", "series", "marker", "indicator"], function(name){
this[name] = lang.delegate(def[name], kwArgs[name]);
}, this);
// personalize theme
if(kwArgs.seriesThemes && kwArgs.seriesThemes.length){
this.colors = null;
this.seriesThemes = kwArgs.seriesThemes.slice(0);
}else{
this.seriesThemes = null;
this.colors = (kwArgs.colors || SimpleTheme.defaultColors).slice(0);
}
this.markerThemes = null;
if(kwArgs.markerThemes && kwArgs.markerThemes.length){
this.markerThemes = kwArgs.markerThemes.slice(0);
}
this.markers = kwArgs.markers ? lang.clone(kwArgs.markers) : lang.delegate(SimpleTheme.defaultMarkers);
// set flags
this.noGradConv = kwArgs.noGradConv;
this.noRadialConv = kwArgs.noRadialConv;
if(kwArgs.reverseFills){
this.reverseFills();
}
// private housekeeping
this._current = 0;
this._buildMarkerArray();
},
clone: function(){
// summary:
// Clone the current theme.
// returns: dojox.charting.SimpleTheme
// The cloned theme; any alterations made will not affect the original.
var theme = new this.constructor({
// theme components
chart: this.chart,
plotarea: this.plotarea,
axis: this.axis,
grid: this.grid,
series: this.series,
marker: this.marker,
// individual arrays
colors: this.colors,
markers: this.markers,
indicator: this.indicator,
seriesThemes: this.seriesThemes,
markerThemes: this.markerThemes,
// flags
noGradConv: this.noGradConv,
noRadialConv: this.noRadialConv,
pieInnerRadius: this.pieInnerRadius
});
// copy custom methods
arr.forEach(
["clone", "clear", "next", "skip", "addMixin", "post", "getTick"],
function(name){
if(this.hasOwnProperty(name)){
theme[name] = this[name];
}
},
this
);
return theme; // dojox.charting.SimpleTheme
},
clear: function(){
// summary:
// Clear and reset the internal pointer to start fresh.
this._current = 0;
},
next: function(elementType, mixin, doPost){
// summary:
// Get the next color or series theme.
// elementType: String?
// An optional element type (for use with series themes)
// mixin: Object?
// An optional object to mix into the theme.
// doPost: Boolean?
// A flag to post-process the results.
// returns: Object
// An object of the structure { series, marker, symbol }
var merge = dlu.merge, series, marker;
if(this.colors){
series = lang.delegate(this.series);
marker = lang.delegate(this.marker);
var color = new Color(this.colors[this._current % this.colors.length]), old;
// modify the stroke
if(series.stroke && series.stroke.color){
series.stroke = lang.delegate(series.stroke);
old = new Color(series.stroke.color);
series.stroke.color = new Color(color);
series.stroke.color.a = old.a;
}else{
series.stroke = {color: color};
}
if(marker.stroke && marker.stroke.color){
marker.stroke = lang.delegate(marker.stroke);
old = new Color(marker.stroke.color);
marker.stroke.color = new Color(color);
marker.stroke.color.a = old.a;
}else{
marker.stroke = {color: color};
}
// modify the fill
if(!series.fill || series.fill.type){
series.fill = color;
}else{
old = new Color(series.fill);
series.fill = new Color(color);
series.fill.a = old.a;
}
if(!marker.fill || marker.fill.type){
marker.fill = color;
}else{
old = new Color(marker.fill);
marker.fill = new Color(color);
marker.fill.a = old.a;
}
}else{
series = this.seriesThemes ?
merge(this.series, this.seriesThemes[this._current % this.seriesThemes.length]) :
this.series;
marker = this.markerThemes ?
merge(this.marker, this.markerThemes[this._current % this.markerThemes.length]) :
series;
}
var symbol = marker && marker.symbol || this._markers[this._current % this._markers.length];
var theme = {series: series, marker: marker, symbol: symbol};
// advance the counter
++this._current;
if(mixin){
theme = this.addMixin(theme, elementType, mixin);
}
if(doPost){
theme = this.post(theme, elementType);
}
return theme; // Object
},
skip: function(){
// summary:
// Skip the next internal color.
++this._current;
},
addMixin: function(theme, elementType, mixin, doPost){
// summary:
// Add a mixin object to the passed theme and process.
// theme: dojox/charting/SimpleTheme
// The theme to mixin to.
// elementType: String
// The type of element in question. Can be "line", "bar" or "circle"
// mixin: Object|Array
// The object or objects to mix into the theme.
// doPost: Boolean
// If true, run the new theme through the post-processor.
// returns: dojox/charting/SimpleTheme
// The new theme.
if(lang.isArray(mixin)){
arr.forEach(mixin, function(m){
theme = this.addMixin(theme, elementType, m);
}, this);
}else{
var t = {};
if("color" in mixin){
if(elementType == "line" || elementType == "area"){
lang.setObject("series.stroke.color", mixin.color, t);
lang.setObject("marker.stroke.color", mixin.color, t);
}else{
lang.setObject("series.fill", mixin.color, t);
}
}
arr.forEach(["stroke", "outline", "shadow", "fill", "filter", "font", "fontColor", "labelWiring"], function(name){
var markerName = "marker" + name.charAt(0).toUpperCase() + name.substr(1),
b = markerName in mixin;
if(name in mixin){
lang.setObject("series." + name, mixin[name], t);
if(!b){
lang.setObject("marker." + name, mixin[name], t);
}
}
if(b){
lang.setObject("marker." + name, mixin[markerName], t);
}
});
if("marker" in mixin){
t.symbol = mixin.marker;
t.symbol = mixin.marker;
}
theme = dlu.merge(theme, t);
}
if(doPost){
theme = this.post(theme, elementType);
}
return theme; // dojox/charting/SimpleTheme
},
post: function(theme, elementType){
// summary:
// Process any post-shape fills.
// theme: dojox/charting/SimpleTheme
// The theme to post process with.
// elementType: String
// The type of element being filled. Can be "bar" or "circle".
// returns: dojox/charting/SimpleTheme
// The post-processed theme.
var fill = theme.series.fill, t;
if(!this.noGradConv && this.shapeSpaces[fill.space] && fill.type == "linear"){
if(elementType == "bar"){
// transpose start and end points
t = {
x1: fill.y1,
y1: fill.x1,
x2: fill.y2,
y2: fill.x2
};
}else if(!this.noRadialConv && fill.space == "shape" && (elementType == "slice" || elementType == "circle")){
// switch to radial
t = {
type: "radial",
cx: 0,
cy: 0,
r: 100
};
}
if(t){
return dlu.merge(theme, {series: {fill: t}});
}
}
return theme; // dojox/charting/SimpleTheme
},
getTick: function(name, mixin){
// summary:
// Calculates and merges tick parameters.
// name: String
// Tick name, can be "major", "minor", or "micro".
// mixin: Object?
// Optional object to mix in to the tick.
var tick = this.axis.tick, tickName = name + "Tick",
merge = dlu.merge;
if(tick){
if(this.axis[tickName]){
tick = merge(tick, this.axis[tickName]);
}
}else{
tick = this.axis[tickName];
}
if(mixin){
if(tick){
if(mixin[tickName]){
tick = merge(tick, mixin[tickName]);
}
}else{
tick = mixin[tickName];
}
}
return tick; // Object
},
inspectObjects: function(f){
arr.forEach(["chart", "plotarea", "axis", "grid", "series", "marker", "indicator"], function(name){
f(this[name]);
}, this);
if(this.seriesThemes){
arr.forEach(this.seriesThemes, f);
}
if(this.markerThemes){
arr.forEach(this.markerThemes, f);
}
},
reverseFills: function(){
this.inspectObjects(function(o){
if(o && o.fill){
o.fill = dgg.reverse(o.fill);
}
});
},
addMarker:function(/*String*/ name, /*String*/ segment){
// summary:
// Add a custom marker to this theme.
// example:
// | myTheme.addMarker("Ellipse", foo);
this.markers[name] = segment;
this._buildMarkerArray();
},
setMarkers:function(/*Object*/ obj){
// summary:
// Set all the markers of this theme at once. obj should be a
// dictionary of keys and path segments.
//
// example:
// | myTheme.setMarkers({ "CIRCLE": foo });
this.markers = obj;
this._buildMarkerArray();
},
_buildMarkerArray: function(){
this._markers = [];
for(var p in this.markers){
this._markers.push(this.markers[p]);
}
}
});
lang.mixin(SimpleTheme, {
defaultMarkers: {
CIRCLE: "m-3,0 c0,-4 6,-4 6,0 m-6,0 c0,4 6,4 6,0",
SQUARE: "m-3,-3 l0,6 6,0 0,-6 z",
DIAMOND: "m0,-3 l3,3 -3,3 -3,-3 z",
CROSS: "m0,-3 l0,6 m-3,-3 l6,0",
X: "m-3,-3 l6,6 m0,-6 l-6,6",
TRIANGLE: "m-3,3 l3,-6 3,6 z",
TRIANGLE_INVERTED: "m-3,-3 l3,6 3,-6 z"
},
defaultColors:[
// gray skies
"#54544c", "#858e94", "#6e767a", "#948585", "#474747"
],
defaultTheme: {
// all objects are structs used directly in dojox.gfx
chart:{
stroke: null,
fill: "white",
pageStyle: null,
titleGap: 20,
titlePos: "top",
titleFont: "normal normal bold 14pt Tahoma", // chart title
titleFontColor: "#333",
titleAlign: "middle"
},
plotarea:{
stroke: null,
fill: "white"
},
// TODO: label rotation on axis
axis:{
stroke: { // the axis itself
color: "#333",
width: 1
},
tick: { // used as a foundation for all ticks
color: "#666",
position: "center",
font: "normal normal normal 7pt Tahoma", // labels on axis
fontColor: "#333", // color of labels
labelGap: 4 // gap between a tick and its label in pixels
},
majorTick: { // major ticks on axis, and used for major gridlines
width: 1,
length: 6
},
minorTick: { // minor ticks on axis, and used for minor gridlines
width: 0.8,
length: 3
},
microTick: { // minor ticks on axis, and used for minor gridlines
width: 0.5,
length: 1
},
title: {
gap: 15,
font: "normal normal normal 11pt Tahoma", // title font
fontColor: "#333", // title font color
orientation: "axis" // "axis": facing the axis, "away": facing away
}
},
series: {
// used as a "main" theme for series, sThemes augment it
stroke: {width: 1.5, color: "#333"}, // line
outline: {width: 0.1, color: "#ccc"}, // outline
//shadow: {dx: 1, dy: 1, width: 2, color: [0, 0, 0, 0.3]},
shadow: null, // no shadow
fill: "#ccc", // fill, if appropriate
font: "normal normal normal 8pt Tahoma", // if there's a label
fontColor: "#000", // color of labels
labelWiring: {width: 1, color: "#ccc"} // connect marker and target data item(slice, column, bar...)
},
marker: { // any markers on a series
stroke: {width: 1.5, color: "#333"}, // stroke
outline: {width: 0.1, color: "#ccc"}, // outline
//shadow: {dx: 1, dy: 1, width: 2, color: [0, 0, 0, 0.3]},
shadow: null, // no shadow
fill: "#ccc", // fill if needed
font: "normal normal normal 8pt Tahoma", // label
fontColor: "#000"
},
indicator: {
lineStroke: {width: 1.5, color: "#333"},
lineOutline: {width: 0.1, color: "#ccc"},
lineShadow: null,
lineFill: null,
stroke: {width: 1.5, color: "#333"},
outline: {width: 0.1, color: "#ccc"},
shadow: null,
fill : "#ccc",
radius: 3,
font: "normal normal normal 10pt Tahoma",
fontColor: "#000",
markerFill: "#ccc",
markerSymbol: "m-3,0 c0,-4 6,-4 6,0 m-6,0 c0,4 6,4 6,0",
markerStroke: {width: 1.5, color: "#333"},
markerOutline: {width: 0.1, color: "#ccc"},
markerShadow: null
}
}
});
return SimpleTheme;
});
},
'dojox/lang/utils':function(){
define(["..", "dojo/_base/lang"],
function(dojox, lang){
var du = lang.getObject("lang.utils", true, dojox);
var empty = {}, opts = Object.prototype.toString;
var clone = function(o){
if(o){
switch(opts.call(o)){
case "[object Array]":
return o.slice(0);
case "[object Object]":
return lang.delegate(o);
}
}
return o;
}
lang.mixin(du, {
coerceType: function(target, source){
// summary:
// Coerces one object to the type of another.
// target: Object
// object, which typeof result is used to coerce "source" object.
// source: Object
// object, which will be forced to change type.
switch(typeof target){
case "number": return Number(eval("(" + source + ")"));
case "string": return String(source);
case "boolean": return Boolean(eval("(" + source + ")"));
}
return eval("(" + source + ")");
},
updateWithObject: function(target, source, conv){
// summary:
// Updates an existing object in place with properties from an "source" object.
// target: Object
// the "target" object to be updated
// source: Object
// the "source" object, whose properties will be used to source the existed object.
// conv: Boolean?
// force conversion to the original type
if(!source){ return target; }
for(var x in target){
if(x in source && !(x in empty)){
var t = target[x];
if(t && typeof t == "object"){
du.updateWithObject(t, source[x], conv);
}else{
target[x] = conv ? du.coerceType(t, source[x]) : clone(source[x]);
}
}
}
return target; // Object
},
updateWithPattern: function(target, source, pattern, conv){
// summary:
// Updates an existing object in place with properties from an "source" object.
// target: Object
// the "target" object to be updated
// source: Object
// the "source" object, whose properties will be used to source the existed object.
// pattern: Object
// object, whose properties will be used to pull values from the "source"
// conv: Boolean?
// force conversion to the original type
if(!source || !pattern){ return target; }
for(var x in pattern){
if(x in source && !(x in empty)){
target[x] = conv ? du.coerceType(pattern[x], source[x]) : clone(source[x]);
}
}
return target; // Object
},
merge: function(object, mixin){
// summary:
// Merge two objects structurally, mixin properties will override object's properties.
// object: Object
// original object.
// mixin: Object
// additional object, which properties will override object's properties.
if(mixin){
var otype = opts.call(object), mtype = opts.call(mixin), t, i, l, m;
switch(mtype){
case "[object Array]":
if(mtype == otype){
t = new Array(Math.max(object.length, mixin.length));
for(i = 0, l = t.length; i < l; ++i){
t[i] = du.merge(object[i], mixin[i]);
}
return t;
}
return mixin.slice(0);
case "[object Object]":
if(mtype == otype && object){
t = lang.delegate(object);
for(i in mixin){
if(i in object){
l = object[i];
m = mixin[i];
if(m !== l){
t[i] = du.merge(l, m);
}
}else{
t[i] = lang.clone(mixin[i]);
}
}
return t;
}
return lang.clone(mixin);
}
}
return mixin;
}
});
return du;
});
},
'dojox/gfx/gradutils':function(){
// Various generic utilities to deal with a linear gradient
define(["./_base", "dojo/_base/lang", "./matrix", "dojo/_base/Color"],
function(g, lang, m, Color){
var gradutils = g.gradutils = {};
function findColor(o, c){
if(o <= 0){
return c[0].color;
}
var len = c.length;
if(o >= 1){
return c[len - 1].color;
}
//TODO: use binary search
for(var i = 0; i < len; ++i){
var stop = c[i];
if(stop.offset >= o){
if(i){
var prev = c[i - 1];
return Color.blendColors(new Color(prev.color), new Color(stop.color),
(o - prev.offset) / (stop.offset - prev.offset));
}
return stop.color;
}
}
return c[len - 1].color;
}
gradutils.getColor = function(fill, pt){
// summary:
// sample a color from a gradient using a point
// fill: Object
// fill object
// pt: dojox/gfx.Point
// point where to sample a color
var o;
if(fill){
switch(fill.type){
case "linear":
var angle = Math.atan2(fill.y2 - fill.y1, fill.x2 - fill.x1),
rotation = m.rotate(-angle),
projection = m.project(fill.x2 - fill.x1, fill.y2 - fill.y1),
p = m.multiplyPoint(projection, pt),
pf1 = m.multiplyPoint(projection, fill.x1, fill.y1),
pf2 = m.multiplyPoint(projection, fill.x2, fill.y2),
scale = m.multiplyPoint(rotation, pf2.x - pf1.x, pf2.y - pf1.y).x;
o = m.multiplyPoint(rotation, p.x - pf1.x, p.y - pf1.y).x / scale;
break;
case "radial":
var dx = pt.x - fill.cx, dy = pt.y - fill.cy;
o = Math.sqrt(dx * dx + dy * dy) / fill.r;
break;
}
return findColor(o, fill.colors); // dojo/_base/Color
}
// simple color
return new Color(fill || [0, 0, 0, 0]); // dojo/_base/Color
};
gradutils.reverse = function(fill){
// summary:
// reverses a gradient
// fill: Object
// fill object
if(fill){
switch(fill.type){
case "linear":
case "radial":
fill = lang.delegate(fill);
if(fill.colors){
var c = fill.colors, l = c.length, i = 0, stop,
n = fill.colors = new Array(c.length);
for(; i < l; ++i){
stop = c[i];
n[i] = {
offset: 1 - stop.offset,
color: stop.color
};
}
n.sort(function(a, b){ return a.offset - b.offset; });
}
break;
}
}
return fill; // Object
};
return gradutils;
});
},
'dojox/charting/Series':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "./Element"],
function(lang, declare, Element){
/*=====
var __SeriesCtorArgs = {
// summary:
// An optional arguments object that can be used in the Series constructor.
// plot: String?
// The plot (by name) that this series belongs to.
};
=====*/
return declare("dojox.charting.Series", Element, {
// summary:
// An object representing a series of data for plotting on a chart.
constructor: function(chart, data, kwArgs){
// summary:
// Create a new data series object for use within charting.
// chart: dojox/charting/Chart
// The chart that this series belongs to.
// data: Array|Object
// The array of data points (either numbers or objects) that
// represents the data to be drawn. Or it can be an object. In
// the latter case, it should have a property "data" (an array),
// destroy(), and setSeriesObject().
// kwArgs: __SeriesCtorArgs?
// An optional keyword arguments object to set details for this series.
lang.mixin(this, kwArgs);
if(typeof this.plot != "string"){ this.plot = "default"; }
this.update(data);
},
clear: function(){
// summary:
// Clear the calculated additional parameters set on this series.
this.dyn = {};
},
update: function(data){
// summary:
// Set data and make this object dirty, so it can be redrawn.
// data: Array|Object
// The array of data points (either numbers or objects) that
// represents the data to be drawn. Or it can be an object. In
// the latter case, it should have a property "data" (an array),
// destroy(), and setSeriesObject().
if(lang.isArray(data)){
this.data = data;
}else{
this.source = data;
this.data = this.source.data;
if(this.source.setSeriesObject){
this.source.setSeriesObject(this);
}
}
this.dirty = true;
this.clear();
}
});
});
},
'dojox/charting/axis2d/common':function(){
define(["dojo/_base/lang", "dojo/_base/window", "dojo/dom-geometry", "dojox/gfx", "dojo/has"],
function(lang, win, domGeom, g, has){
var common = lang.getObject("dojox.charting.axis2d.common", true);
var clearNode = function(s){
s.marginLeft = "0px";
s.marginTop = "0px";
s.marginRight = "0px";
s.marginBottom = "0px";
s.paddingLeft = "0px";
s.paddingTop = "0px";
s.paddingRight = "0px";
s.paddingBottom = "0px";
s.borderLeftWidth = "0px";
s.borderTopWidth = "0px";
s.borderRightWidth = "0px";
s.borderBottomWidth = "0px";
};
var getBoxWidth = function(n){
// marginBox is incredibly slow, so avoid it if we can
if(n["getBoundingClientRect"]){
var bcr = n.getBoundingClientRect();
return bcr.width || (bcr.right - bcr.left);
}else{
return domGeom.getMarginBox(n).w;
}
};
return lang.mixin(common, {
// summary:
// Common methods to be used by any axis. This is considered "static".
createText: {
gfx: function(chart, creator, x, y, align, text, font, fontColor){
// summary:
// Use dojox.gfx to create any text.
// chart: dojox.charting.Chart
// The chart to create the text into.
// creator: dojox.gfx.Surface
// The graphics surface to use for creating the text.
// x: Number
// Where to create the text along the x axis (CSS left).
// y: Number
// Where to create the text along the y axis (CSS top).
// align: String
// How to align the text. Can be "left", "right", "center".
// text: String
// The text to render.
// font: String
// The font definition, a la CSS "font".
// fontColor: String|dojo.Color
// The color of the resultant text.
// returns: dojox.gfx.Text
// The resultant GFX object.
return creator.createText({
x: x, y: y, text: text, align: align
}).setFont(font).setFill(fontColor); // dojox.gfx.Text
},
html: function(chart, creator, x, y, align, text, font, fontColor, labelWidth){
// summary:
// Use the HTML DOM to create any text.
// chart: dojox.charting.Chart
// The chart to create the text into.
// creator: dojox.gfx.Surface
// The graphics surface to use for creating the text.
// x: Number
// Where to create the text along the x axis (CSS left).
// y: Number
// Where to create the text along the y axis (CSS top).
// align: String
// How to align the text. Can be "left", "right", "center".
// text: String
// The text to render.
// font: String
// The font definition, a la CSS "font".
// fontColor: String|dojo.Color
// The color of the resultant text.
// labelWidth: Number?
// The maximum width of the resultant DOM node.
// returns: DOMNode
// The resultant DOMNode (a "div" element).
// setup the text node
var p = win.doc.createElement("div"), s = p.style, boxWidth;
// bidi support, if this function exists the module was loaded
if(chart.getTextDir){
p.dir = chart.getTextDir(text);
}
clearNode(s);
s.font = font;
p.innerHTML = String(text).replace(/\s/g, " ");
s.color = fontColor;
// measure the size
s.position = "absolute";
s.left = "-10000px";
win.body().appendChild(p);
var size = g.normalizedLength(g.splitFontString(font).size);
// do we need to calculate the label width?
if(!labelWidth){
boxWidth = getBoxWidth(p);
}
// when the textDir is rtl, but the UI ltr needs
// to recalculate the starting point
if(p.dir == "rtl"){
x += labelWidth ? labelWidth : boxWidth;
}
// new settings for the text node
win.body().removeChild(p);
s.position = "relative";
if(labelWidth){
s.width = labelWidth + "px";
// s.border = "1px dotted grey";
switch(align){
case "middle":
s.textAlign = "center";
s.left = (x - labelWidth / 2) + "px";
break;
case "end":
s.textAlign = "right";
s.left = (x - labelWidth) + "px";
break;
default:
s.left = x + "px";
s.textAlign = "left";
break;
}
}else{
switch(align){
case "middle":
s.left = Math.floor(x - boxWidth / 2) + "px";
// s.left = Math.floor(x - p.offsetWidth / 2) + "px";
break;
case "end":
s.left = Math.floor(x - boxWidth) + "px";
// s.left = Math.floor(x - p.offsetWidth) + "px";
break;
//case "start":
default:
s.left = Math.floor(x) + "px";
break;
}
}
s.top = Math.floor(y - size) + "px";
s.whiteSpace = "nowrap"; // hack for WebKit
// setup the wrapper node
var wrap = win.doc.createElement("div"), w = wrap.style;
clearNode(w);
w.width = "0px";
w.height = "0px";
// insert nodes
wrap.appendChild(p);
chart.node.insertBefore(wrap, chart.node.firstChild);
if(has("dojo-bidi")){
chart.htmlElementsRegistry.push([wrap, x, y, align, text, font, fontColor]);
}
return wrap; // DOMNode
}
}
});
});
},
'dojox/charting/plot2d/common':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/Color",
"dojox/gfx", "dojox/lang/functional", "../scaler/common"],
function(lang, arr, Color, g, df, sc){
var common = lang.getObject("dojox.charting.plot2d.common", true);
return lang.mixin(common, {
doIfLoaded: sc.doIfLoaded,
makeStroke: function(stroke){
if(!stroke){ return stroke; }
if(typeof stroke == "string" || stroke instanceof Color){
stroke = {color: stroke};
}
return g.makeParameters(g.defaultStroke, stroke);
},
augmentColor: function(target, color){
var t = new Color(target),
c = new Color(color);
c.a = t.a;
return c;
},
augmentStroke: function(stroke, color){
var s = common.makeStroke(stroke);
if(s){
s.color = common.augmentColor(s.color, color);
}
return s;
},
augmentFill: function(fill, color){
var fc, c = new Color(color);
if(typeof fill == "string" || fill instanceof Color){
return common.augmentColor(fill, color);
}
return fill;
},
defaultStats: {
vmin: Number.POSITIVE_INFINITY, vmax: Number.NEGATIVE_INFINITY,
hmin: Number.POSITIVE_INFINITY, hmax: Number.NEGATIVE_INFINITY
},
collectSimpleStats: function(series, isNullValue){
var stats = lang.delegate(common.defaultStats);
for(var i = 0; i < series.length; ++i){
var run = series[i];
for(var j = 0; j < run.data.length; j++){
if(!isNullValue(run.data[j])){
if(typeof run.data[j] == "number"){
// 1D case
var old_vmin = stats.vmin, old_vmax = stats.vmax;
arr.forEach(run.data, function(val, i){
if(!isNullValue(val)){
var x = i + 1, y = val;
if(isNaN(y)){ y = 0; }
stats.hmin = Math.min(stats.hmin, x);
stats.hmax = Math.max(stats.hmax, x);
stats.vmin = Math.min(stats.vmin, y);
stats.vmax = Math.max(stats.vmax, y);
}
});
if("ymin" in run){ stats.vmin = Math.min(old_vmin, run.ymin); }
if("ymax" in run){ stats.vmax = Math.max(old_vmax, run.ymax); }
}else{
// 2D case
var old_hmin = stats.hmin, old_hmax = stats.hmax,
old_vmin = stats.vmin, old_vmax = stats.vmax;
if(!("xmin" in run) || !("xmax" in run) || !("ymin" in run) || !("ymax" in run)){
arr.forEach(run.data, function(val, i){
if(!isNullValue(val)){
var x = "x" in val ? val.x : i + 1, y = val.y;
if(isNaN(x)){ x = 0; }
if(isNaN(y)){ y = 0; }
stats.hmin = Math.min(stats.hmin, x);
stats.hmax = Math.max(stats.hmax, x);
stats.vmin = Math.min(stats.vmin, y);
stats.vmax = Math.max(stats.vmax, y);
}
});
}
if("xmin" in run){ stats.hmin = Math.min(old_hmin, run.xmin); }
if("xmax" in run){ stats.hmax = Math.max(old_hmax, run.xmax); }
if("ymin" in run){ stats.vmin = Math.min(old_vmin, run.ymin); }
if("ymax" in run){ stats.vmax = Math.max(old_vmax, run.ymax); }
}
break;
}
}
}
return stats;
},
calculateBarSize: function(/* Number */ availableSize, /* Object */ opt, /* Number? */ clusterSize){
if(!clusterSize){
clusterSize = 1;
}
var gap = opt.gap, size = (availableSize - 2 * gap) / clusterSize;
if("minBarSize" in opt){
size = Math.max(size, opt.minBarSize);
}
if("maxBarSize" in opt){
size = Math.min(size, opt.maxBarSize);
}
size = Math.max(size, 1);
gap = (availableSize - size * clusterSize) / 2;
return {size: size, gap: gap}; // Object
},
collectStackedStats: function(series){
// collect statistics
var stats = lang.clone(common.defaultStats);
if(series.length){
// 1st pass: find the maximal length of runs
stats.hmin = Math.min(stats.hmin, 1);
stats.hmax = df.foldl(series, "seed, run -> Math.max(seed, run.data.length)", stats.hmax);
// 2nd pass: stack values
for(var i = 0; i < stats.hmax; ++i){
var v = series[0].data[i];
v = v && (typeof v == "number" ? v : v.y);
if(isNaN(v)){ v = 0; }
stats.vmin = Math.min(stats.vmin, v);
for(var j = 1; j < series.length; ++j){
var t = series[j].data[i];
t = t && (typeof t == "number" ? t : t.y);
if(isNaN(t)){ t = 0; }
v += t;
}
stats.vmax = Math.max(stats.vmax, v);
}
}
return stats;
},
curve: function(/* Number[] */a, /* Number|String */tension){
// FIX for #7235, submitted by Enzo Michelangeli.
// Emulates the smoothing algorithms used in a famous, unnamed spreadsheet
// program ;)
var array = a.slice(0);
if(tension == "x") {
array[array.length] = array[0]; // add a last element equal to the first, closing the loop
}
var p=arr.map(array, function(item, i){
if(i==0){ return "M" + item.x + "," + item.y; }
if(!isNaN(tension)) { // use standard Dojo smoothing in tension is numeric
var dx=item.x-array[i-1].x, dy=array[i-1].y;
return "C"+(item.x-(tension-1)*(dx/tension))+","+dy+" "+(item.x-(dx/tension))+","+item.y+" "+item.x+","+item.y;
} else if(tension == "X" || tension == "x" || tension == "S") {
// use Excel "line smoothing" algorithm (http://xlrotor.com/resources/files.shtml)
var p0, p1 = array[i-1], p2 = array[i], p3;
var bz1x, bz1y, bz2x, bz2y;
var f = 1/6;
if(i==1) {
if(tension == "x") {
p0 = array[array.length-2];
} else { // "tension == X || tension == "S"
p0 = p1;
}
f = 1/3;
} else {
p0 = array[i-2];
}
if(i==(array.length-1)) {
if(tension == "x") {
p3 = array[1];
} else { // "tension == X || tension == "S"
p3 = p2;
}
f = 1/3;
} else {
p3 = array[i+1];
}
var p1p2 = Math.sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));
var p0p2 = Math.sqrt((p2.x-p0.x)*(p2.x-p0.x)+(p2.y-p0.y)*(p2.y-p0.y));
var p1p3 = Math.sqrt((p3.x-p1.x)*(p3.x-p1.x)+(p3.y-p1.y)*(p3.y-p1.y));
var p0p2f = p0p2 * f;
var p1p3f = p1p3 * f;
if(p0p2f > p1p2/2 && p1p3f > p1p2/2) {
p0p2f = p1p2/2;
p1p3f = p1p2/2;
} else if(p0p2f > p1p2/2) {
p0p2f = p1p2/2;
p1p3f = p1p2/2 * p1p3/p0p2;
} else if(p1p3f > p1p2/2) {
p1p3f = p1p2/2;
p0p2f = p1p2/2 * p0p2/p1p3;
}
if(tension == "S") {
if(p0 == p1) { p0p2f = 0; }
if(p2 == p3) { p1p3f = 0; }
}
bz1x = p1.x + p0p2f*(p2.x - p0.x)/p0p2;
bz1y = p1.y + p0p2f*(p2.y - p0.y)/p0p2;
bz2x = p2.x - p1p3f*(p3.x - p1.x)/p1p3;
bz2y = p2.y - p1p3f*(p3.y - p1.y)/p1p3;
}
return "C"+(bz1x+","+bz1y+" "+bz2x+","+bz2y+" "+p2.x+","+p2.y);
});
return p.join(" ");
},
getLabel: function(/*Number*/number, /*Boolean*/fixed, /*Number*/precision){
return sc.doIfLoaded("dojo/number", function(numberLib){
return (fixed ? numberLib.format(number, {places : precision}) :
numberLib.format(number)) || "";
}, function(){
return fixed ? number.toFixed(precision) : number.toString();
});
},
purgeGroup: function (item) {
return item.purgeGroup();
}
});
});
},
'dojox/lang/functional':function(){
define(["./functional/lambda", "./functional/array", "./functional/object"], function(df){
return df;
});
},
'dojox/lang/functional/lambda':function(){
define(["../..", "dojo/_base/lang", "dojo/_base/array"], function(dojox, lang, arr){
var df = lang.getObject("lang.functional", true, dojox);
// This module adds high-level functions and related constructs:
// - anonymous functions built from the string
// Acknowledgements:
// - lambda() is based on work by Oliver Steele
// (http://osteele.com/sources/javascript/functional/functional.js)
// which was published under MIT License
// Notes:
// - lambda() produces functions, which after the compilation step are
// as fast as regular JS functions (at least theoretically).
// Lambda input values:
// - returns functions unchanged
// - converts strings to functions
// - converts arrays to a functional composition
var lcache = {};
// split() is augmented on IE6 to ensure the uniform behavior
var split = "ab".split(/a*/).length > 1 ? String.prototype.split :
function(sep){
var r = this.split.call(this, sep),
m = sep.exec(this);
if(m && m.index == 0){ r.unshift(""); }
return r;
};
var lambda = function(/*String*/ s){
var args = [], sects = split.call(s, /\s*->\s*/m);
if(sects.length > 1){
while(sects.length){
s = sects.pop();
args = sects.pop().split(/\s*,\s*|\s+/m);
if(sects.length){ sects.push("(function(" + args.join(", ") + "){ return (" + s + "); })"); }
}
}else if(s.match(/\b_\b/)){
args = ["_"];
}else{
var l = s.match(/^\s*(?:[+*\/%&|\^\.=<>]|!=)/m),
r = s.match(/[+\-*\/%&|\^\.=<>!]\s*$/m);
if(l || r){
if(l){
args.push("$1");
s = "$1" + s;
}
if(r){
args.push("$2");
s = s + "$2";
}
}else{
// the point of the long regex below is to exclude all well-known
// lower-case words from the list of potential arguments
var vars = s.
replace(/(?:\b[A-Z]|\.[a-zA-Z_$])[a-zA-Z_$\d]*|[a-zA-Z_$][a-zA-Z_$\d]*:|this|true|false|null|undefined|typeof|instanceof|in|delete|new|void|arguments|decodeURI|decodeURIComponent|encodeURI|encodeURIComponent|escape|eval|isFinite|isNaN|parseFloat|parseInt|unescape|dojo|dijit|dojox|window|document|'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"/g, "").
match(/([a-z_$][a-z_$\d]*)/gi) || [], t = {};
arr.forEach(vars, function(v){
if(!t.hasOwnProperty(v)){
args.push(v);
t[v] = 1;
}
});
}
}
return {args: args, body: s}; // Object
};
var compose = function(/*Array*/ a){
return a.length ?
function(){
var i = a.length - 1, x = df.lambda(a[i]).apply(this, arguments);
for(--i; i >= 0; --i){ x = df.lambda(a[i]).call(this, x); }
return x;
}
:
// identity
function(x){ return x; };
};
lang.mixin(df, {
// lambda
rawLambda: function(/*String*/ s){
// summary:
// builds a function from a snippet, or array (composing),
// returns an object describing the function; functions are
// passed through unmodified.
// description:
// This method is to normalize a functional representation (a
// text snippet) to an object that contains an array of
// arguments, and a body , which is used to calculate the
// returning value.
return lambda(s); // Object
},
buildLambda: function(/*String*/ s){
// summary:
// builds a function from a snippet, returns a string, which
// represents the function.
// description:
// This method returns a textual representation of a function
// built from the snippet. It is meant to be evaled in the
// proper context, so local variables can be pulled from the
// environment.
var l = lambda(s);
return "function(" + l.args.join(",") + "){return (" + l.body + ");}"; // String
},
lambda: function(/*Function|String|Array*/ s){
// summary:
// builds a function from a snippet, or array (composing),
// returns a function object; functions are passed through
// unmodified.
// description:
// This method is used to normalize a functional
// representation (a text snippet, an array, or a function) to
// a function object.
if(typeof s == "function"){ return s; }
if(s instanceof Array){ return compose(s); }
if(lcache.hasOwnProperty(s)){ return lcache[s]; }
var l = lambda(s);
return lcache[s] = new Function(l.args, "return (" + l.body + ");"); // Function
},
clearLambdaCache: function(){
// summary:
// clears internal cache of lambdas
lcache = {};
}
});
return df;
});
},
'dojox/lang/functional/array':function(){
define(["dojo/_base/kernel", "dojo/_base/lang", "dojo/_base/array", "./lambda"],
function(kernel, lang, arr, df){
// This module adds high-level functions and related constructs:
// - array-processing functions similar to standard JS functions
// Notes:
// - this module provides JS standard methods similar to high-level functions in dojo/_base/array.js:
// forEach, map, filter, every, some
// Defined methods:
// - take any valid lambda argument as the functional argument
// - operate on dense arrays
// - take a string as the array argument
// - take an iterator objects as the array argument
var empty = {};
lang.mixin(df, {
// JS 1.6 standard array functions, which can take a lambda as a parameter.
// Consider using dojo._base.array functions, if you don't need the lambda support.
filter: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// creates a new array with all elements that pass the test
// implemented by the provided function.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var t = [], v, i, n;
if(lang.isArray(a)){
// array
for(i = 0, n = a.length; i < n; ++i){
v = a[i];
if(f.call(o, v, i, a)){ t.push(v); }
}
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
for(i = 0; a.hasNext();){
v = a.next();
if(f.call(o, v, i++, a)){ t.push(v); }
}
}else{
// object/dictionary
for(i in a){
if(!(i in empty)){
v = a[i];
if(f.call(o, v, i, a)){ t.push(v); }
}
}
}
return t; // Array
},
forEach: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// executes a provided function once per array element.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var i, n;
if(lang.isArray(a)){
// array
for(i = 0, n = a.length; i < n; f.call(o, a[i], i, a), ++i);
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
for(i = 0; a.hasNext(); f.call(o, a.next(), i++, a));
}else{
// object/dictionary
for(i in a){
if(!(i in empty)){
f.call(o, a[i], i, a);
}
}
}
return o; // Object
},
map: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// creates a new array with the results of calling
// a provided function on every element in this array.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var t, n, i;
if(lang.isArray(a)){
// array
t = new Array(n = a.length);
for(i = 0; i < n; t[i] = f.call(o, a[i], i, a), ++i);
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
t = [];
for(i = 0; a.hasNext(); t.push(f.call(o, a.next(), i++, a)));
}else{
// object/dictionary
t = [];
for(i in a){
if(!(i in empty)){
t.push(f.call(o, a[i], i, a));
}
}
}
return t; // Array
},
every: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// tests whether all elements in the array pass the test
// implemented by the provided function.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var i, n;
if(lang.isArray(a)){
// array
for(i = 0, n = a.length; i < n; ++i){
if(!f.call(o, a[i], i, a)){
return false; // Boolean
}
}
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
for(i = 0; a.hasNext();){
if(!f.call(o, a.next(), i++, a)){
return false; // Boolean
}
}
}else{
// object/dictionary
for(i in a){
if(!(i in empty)){
if(!f.call(o, a[i], i, a)){
return false; // Boolean
}
}
}
}
return true; // Boolean
},
some: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// tests whether some element in the array passes the test
// implemented by the provided function.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var i, n;
if(lang.isArray(a)){
// array
for(i = 0, n = a.length; i < n; ++i){
if(f.call(o, a[i], i, a)){
return true; // Boolean
}
}
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
for(i = 0; a.hasNext();){
if(f.call(o, a.next(), i++, a)){
return true; // Boolean
}
}
}else{
// object/dictionary
for(i in a){
if(!(i in empty)){
if(f.call(o, a[i], i, a)){
return true; // Boolean
}
}
}
}
return false; // Boolean
}
});
return df;
});
},
'dojox/lang/functional/object':function(){
define(["dojo/_base/kernel", "dojo/_base/lang", "./lambda"], function(kernel, lang, df){
// This module adds high-level functions and related constructs:
// - object/dictionary helpers
// Defined methods:
// - take any valid lambda argument as the functional argument
// - skip all attributes that are present in the empty object
// (IE and/or 3rd-party libraries).
var empty = {};
lang.mixin(df, {
// object helpers
keys: function(/*Object*/ obj){
// summary:
// returns an array of all keys in the object
var t = [];
for(var i in obj){
if(!(i in empty)){
t.push(i);
}
}
return t; // Array
},
values: function(/*Object*/ obj){
// summary:
// returns an array of all values in the object
var t = [];
for(var i in obj){
if(!(i in empty)){
t.push(obj[i]);
}
}
return t; // Array
},
filterIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// creates new object with all attributes that pass the test
// implemented by the provided function.
o = o || kernel.global; f = df.lambda(f);
var t = {}, v, i;
for(i in obj){
if(!(i in empty)){
v = obj[i];
if(f.call(o, v, i, obj)){ t[i] = v; }
}
}
return t; // Object
},
forIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// iterates over all object attributes.
o = o || kernel.global; f = df.lambda(f);
for(var i in obj){
if(!(i in empty)){
f.call(o, obj[i], i, obj);
}
}
return o; // Object
},
mapIn: function(/*Object*/ obj, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// creates new object with the results of calling
// a provided function on every attribute in this object.
o = o || kernel.global; f = df.lambda(f);
var t = {}, i;
for(i in obj){
if(!(i in empty)){
t[i] = f.call(o, obj[i], i, obj);
}
}
return t; // Object
}
});
return df;
});
},
'dojox/charting/scaler/common':function(){
define(["dojo/_base/lang"], function(lang){
var eq = function(/*Number*/ a, /*Number*/ b){
// summary:
// compare two FP numbers for equality
return Math.abs(a - b) <= 1e-6 * (Math.abs(a) + Math.abs(b)); // Boolean
};
var common = lang.getObject("dojox.charting.scaler.common", true);
var testedModules = {};
return lang.mixin(common, {
doIfLoaded: function(moduleName, ifloaded, ifnotloaded){
if(testedModules[moduleName] === undefined){
try{
testedModules[moduleName] = require(moduleName);
}catch(e){
testedModules[moduleName] = null;
}
}
if(testedModules[moduleName]){
return ifloaded(testedModules[moduleName]);
}else{
return ifnotloaded();
}
},
getNumericLabel: function(/*Number*/ number, /*Number*/ precision, /*Object*/ kwArgs){
var def = "";
common.doIfLoaded("dojo/number", function(numberLib){
def = (kwArgs.fixed ? numberLib.format(number, {places : precision < 0 ? -precision : 0}) :
numberLib.format(number)) || "";
}, function(){
def = kwArgs.fixed ? number.toFixed(precision < 0 ? -precision : 0) : number.toString();
});
if(kwArgs.labelFunc){
var r = kwArgs.labelFunc(def, number, precision);
if(r){ return r; }
// else fall through to the regular labels search
}
if(kwArgs.labels){
// classic binary search
// TODO: working only if the array is sorted per value should be better documented or sorted automatically
var l = kwArgs.labels, lo = 0, hi = l.length;
while(lo < hi){
var mid = Math.floor((lo + hi) / 2), val = l[mid].value;
if(val < number){
lo = mid + 1;
}else{
hi = mid;
}
}
// lets take into account FP errors
if(lo < l.length && eq(l[lo].value, number)){
return l[lo].text;
}
--lo;
if(lo >= 0 && lo < l.length && eq(l[lo].value, number)){
return l[lo].text;
}
lo += 2;
if(lo < l.length && eq(l[lo].value, number)){
return l[lo].text;
}
// otherwise we will produce a number
}
return def;
}
});
});
},
'dojox/lang/functional/fold':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/kernel", "./lambda"],
function(lang, arr, kernel, df){
// This module adds high-level functions and related constructs:
// - "fold" family of functions
// Notes:
// - missing high-level functions are provided with the compatible API:
// foldl, foldl1, foldr, foldr1
// - missing JS standard functions are provided with the compatible API:
// reduce, reduceRight
// - the fold's counterpart: unfold
// Defined methods:
// - take any valid lambda argument as the functional argument
// - operate on dense arrays
// - take a string as the array argument
// - take an iterator objects as the array argument (only foldl, foldl1, and reduce)
var empty = {};
lang.mixin(df, {
// classic reduce-class functions
foldl: function(/*Array|String|Object*/ a, /*Function*/ f, /*Object*/ z, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from left
// to right using a seed value as a starting point; returns the final
// value.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var i, n;
if(lang.isArray(a)){
// array
for(i = 0, n = a.length; i < n; z = f.call(o, z, a[i], i, a), ++i);
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
for(i = 0; a.hasNext(); z = f.call(o, z, a.next(), i++, a));
}else{
// object/dictionary
for(i in a){
if(!(i in empty)){
z = f.call(o, z, a[i], i, a);
}
}
}
return z; // Object
},
foldl1: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from left
// to right; returns the final value.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var z, i, n;
if(lang.isArray(a)){
// array
z = a[0];
for(i = 1, n = a.length; i < n; z = f.call(o, z, a[i], i, a), ++i);
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
if(a.hasNext()){
z = a.next();
for(i = 1; a.hasNext(); z = f.call(o, z, a.next(), i++, a));
}
}else{
// object/dictionary
var first = true;
for(i in a){
if(!(i in empty)){
if(first){
z = a[i];
first = false;
}else{
z = f.call(o, z, a[i], i, a);
}
}
}
}
return z; // Object
},
foldr: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from right
// to left using a seed value as a starting point; returns the final
// value.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
for(var i = a.length; i > 0; --i, z = f.call(o, z, a[i], i, a));
return z; // Object
},
foldr1: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from right
// to left; returns the final value.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var n = a.length, z = a[n - 1], i = n - 1;
for(; i > 0; --i, z = f.call(o, z, a[i], i, a));
return z; // Object
},
// JS 1.8 standard array functions, which can take a lambda as a parameter.
reduce: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ z){
// summary:
// apply a function simultaneously against two values of the array
// (from left-to-right) as to reduce it to a single value.
return arguments.length < 3 ? df.foldl1(a, f) : df.foldl(a, f, z); // Object
},
reduceRight: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ z){
// summary:
// apply a function simultaneously against two values of the array
// (from right-to-left) as to reduce it to a single value.
return arguments.length < 3 ? df.foldr1(a, f) : df.foldr(a, f, z); // Object
},
// the fold's counterpart: unfold
unfold: function(/*Function|String|Array*/ pr, /*Function|String|Array*/ f,
/*Function|String|Array*/ g, /*Object*/ z, /*Object?*/ o){
// summary:
// builds an array by unfolding a value
o = o || kernel.global; f = df.lambda(f); g = df.lambda(g); pr = df.lambda(pr);
var t = [];
for(; !pr.call(o, z); t.push(f.call(o, z)), z = g.call(o, z));
return t; // Array
}
});
});
},
'dojox/lang/functional/reversed':function(){
define(["dojo/_base/lang", "dojo/_base/kernel" ,"./lambda"],
function(lang, kernel, df){
// This module adds high-level functions and related constructs:
// - reversed versions of array-processing functions similar to standard JS functions
// Notes:
// - this module provides reversed versions of standard array-processing functions:
// forEachRev, mapRev, filterRev
// Defined methods:
// - take any valid lambda argument as the functional argument
// - operate on dense arrays
// - take a string as the array argument
lang.mixin(df, {
// JS 1.6 standard array functions, which can take a lambda as a parameter.
// Consider using dojo._base.array functions, if you don't need the lambda support.
filterRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// creates a new array with all elements that pass the test
// implemented by the provided function.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var t = [], v, i = a.length - 1;
for(; i >= 0; --i){
v = a[i];
if(f.call(o, v, i, a)){ t.push(v); }
}
return t; // Array
},
forEachRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// executes a provided function once per array element.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
for(var i = a.length - 1; i >= 0; f.call(o, a[i], i, a), --i);
},
mapRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// creates a new array with the results of calling
// a provided function on every element in this array.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var n = a.length, t = new Array(n), i = n - 1, j = 0;
for(; i >= 0; t[j++] = f.call(o, a[i], i, a), --i);
return t; // Array
},
everyRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// tests whether all elements in the array pass the test
// implemented by the provided function.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
for(var i = a.length - 1; i >= 0; --i){
if(!f.call(o, a[i], i, a)){
return false; // Boolean
}
}
return true; // Boolean
},
someRev: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// tests whether some element in the array passes the test
// implemented by the provided function.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
for(var i = a.length - 1; i >= 0; --i){
if(f.call(o, a[i], i, a)){
return true; // Boolean
}
}
return false; // Boolean
}
});
return df;
});
},
'dojox/charting/Chart2D':function(){
define(["dojo/_base/kernel", "dojo/_base/lang", "..", "./Chart",
"./axis2d/Default", "./axis2d/Invisible", "./plot2d/Default", "./plot2d/Lines", "./plot2d/Areas",
"./plot2d/Markers", "./plot2d/MarkersOnly", "./plot2d/Scatter", "./plot2d/Stacked", "./plot2d/StackedLines",
"./plot2d/StackedAreas", "./plot2d/Columns", "./plot2d/StackedColumns", "./plot2d/ClusteredColumns",
"./plot2d/Bars", "./plot2d/StackedBars", "./plot2d/ClusteredBars", "./plot2d/Grid", "./plot2d/Pie",
"./plot2d/Bubble", "./plot2d/Candlesticks", "./plot2d/OHLC", "./plot2d/Spider"],
function(kernel, lang, dojox, Chart){
kernel.deprecated("dojox.charting.Chart2D", "Use dojox.charting.Chart instead and require all other components explicitly", "2.0");
// module:
// dojox/charting/Chart2D
// summary:
// This is a compatibility module which loads all charting modules that used to be automatically
// loaded in versions prior to 1.6. It is highly recommended for performance reasons that
// this module no longer be referenced by applications. Instead, use dojox/charting/Chart.
return lang.setObject("dojox.charting.Chart2D", Chart);
});
},
'dojox/charting/axis2d/Default':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/sniff", "dojo/_base/declare",
"dojo/_base/connect", "dojo/dom-geometry", "./Invisible",
"../scaler/linear", "./common", "dojox/gfx", "dojox/lang/utils", "dojox/lang/functional",
"dojo/has!dojo-bidi?../bidi/axis2d/Default"],
function(lang, arr, has, declare, connect, domGeom, Invisible,
lin, acommon, g, du, df, BidiDefault){
/*=====
var __AxisCtorArgs = {
// summary:
// Optional arguments used in the definition of an axis.
// vertical: Boolean?
// A flag that says whether an axis is vertical (i.e. y axis) or horizontal. Default is false (horizontal).
// fixUpper: String?
// Align the greatest value on the axis with the specified tick level. Options are "major", "minor", "micro", or "none". Defaults to "none".
// fixLower: String?
// Align the smallest value on the axis with the specified tick level. Options are "major", "minor", "micro", or "none". Defaults to "none".
// natural: Boolean?
// Ensure tick marks are made on "natural" numbers. Defaults to false.
// leftBottom: Boolean?
// Deprecated: use position instead. The position of a vertical axis; if true, will be placed against the left-bottom corner of the chart. Defaults to true.
// includeZero: Boolean?
// Include 0 on the axis rendering. Default is false.
// fixed: Boolean?
// Force all axis labels to be fixed numbers. Default is true.
// majorLabels: Boolean?
// Flag to draw labels at major ticks. Default is true.
// minorTicks: Boolean?
// Flag to draw minor ticks on an axis. Default is true.
// minorLabels: Boolean?
// Flag to labels on minor ticks when there is enough space. Default is true.
// microTicks: Boolean?
// Flag to draw micro ticks on an axis. Default is false.
// htmlLabels: Boolean?
// Flag to use HTML (as opposed to the native vector graphics engine) to draw labels. Default is true.
// min: Number?
// The smallest value on an axis. Default is 0.
// max: Number?
// The largest value on an axis. Default is 1.
// from: Number?
// Force the chart to render data visible from this value. Default is 0.
// to: Number?
// Force the chart to render data visible to this value. Default is 1.
// majorTickStep: Number?
// The amount to skip before a major tick is drawn. When not set the major ticks step is computed from
// the data range.
// minorTickStep: Number?
// The amount to skip before a minor tick is drawn. When not set the minor ticks step is computed from
// the data range.
// microTickStep: Number?
// The amount to skip before a micro tick is drawn. When not set the micro ticks step is computed from
// labels: Object[]?
// An array of labels for major ticks, with corresponding numeric values, ordered by value.
// labelFunc: Function?
// An optional function to use to compute label text. It takes precedence over
// the default text when available. The function must be of the following form:
// | function labelFunc(text, value, precision) {}
// `text` is the already pre-formatted text. Pre-formatting is done using `dojo/number` is available, `Date.toFixed` otherwise.
// `value` is the raw axis value.
// `precision` is the requested precision to be applied.
// maxLabelSize: Number?
// The maximum size, in pixels, for a label. To be used with the optional label function.
// stroke: dojox.gfx.Stroke?
// An optional stroke to be used for drawing an axis.
// majorTick: Object?
// An object containing a dojox.gfx.Stroke, and a length (number) for a major tick.
// minorTick: Object?
// An object containing a dojox.gfx.Stroke, and a length (number) for a minor tick.
// microTick: Object?
// An object containing a dojox.gfx.Stroke, and a length (number) for a micro tick.
// tick: Object?
// An object containing a dojox.gfx.Stroke, and a length (number) for a tick.
// font: String?
// An optional font definition (as used in the CSS font property) for labels.
// fontColor: String|dojo.Color?
// An optional color to be used in drawing labels.
// titleGap: Number?
// An optional grap between axis title and axis label
// titleFont: String?
// An optional font definition for axis title
// titleFontColor: String?
// An optional axis title color
// titleOrientation: String?
// An optional orientation for axis title. "axis" means the title facing the axis, "away" means facing away.
// If no value is set "axis" is used.
// enableCache: Boolean?
// Whether the ticks and labels are cached from one rendering to another. This improves the rendering performance of
// successive rendering but penalize the first rendering. For labels it is only working with gfx labels
// not html ones. Default false.
// dropLabels: Boolean?
// Whether the axis automatically drops labels at regular interval or not to avoid labels overlapping.
// This gives better results but require more computations. You can disable it to save computation
// time when you know your labels won't overlap. Default is true.
// labelSizeChange: Boolean?
// Indicates to the axis whether the axis labels are changing their size on zoom. If false this allows to
// optimize the axis by avoiding recomputing labels maximum size on zoom actions. Default is false.
// position: String?
// The position of the axis. Values: "leftOrBottom", "center" or "rightOrTop". Default is "leftOrBottom".
};
=====*/
var centerAnchorLimit = 45; // in degrees
var Default = declare(has("dojo-bidi")? "dojox.charting.axis2d.NonBidiDefault" : "dojox.charting.axis2d.Default", Invisible, {
// summary:
// The default axis object used in dojox.charting. See dojox.charting.Chart.addAxis for details.
// defaultParams: Object
// The default parameters used to define any axis.
// optionalParams: Object
// Any optional parameters needed to define an axis.
/*=====
// TODO: the documentation tools need these to be pre-defined in order to pick them up
// correctly, but the code here is partially predicated on whether or not the properties
// actually exist. For now, we will leave these undocumented but in the code for later. -- TRT
// opt: Object
// The actual options used to define this axis, created at initialization.
// scaler: Object
// The calculated helper object to tell charts how to draw an axis and any data.
// ticks: Object
// The calculated tick object that helps a chart draw the scaling on an axis.
// dirty: Boolean
// The state of the axis (whether it needs to be redrawn or not)
// scale: Number
// The current scale of the axis.
// offset: Number
// The current offset of the axis.
opt: null,
scaler: null,
ticks: null,
dirty: true,
scale: 1,
offset: 0,
=====*/
defaultParams: {
vertical: false, // true for vertical axis
fixUpper: "none", // align the upper on ticks: "major", "minor", "micro", "none"
fixLower: "none", // align the lower on ticks: "major", "minor", "micro", "none"
natural: false, // all tick marks should be made on natural numbers
leftBottom: true, // position of the axis, used with "vertical" - deprecated: use position instead
includeZero: false, // 0 should be included
fixed: true, // all labels are fixed numbers
majorLabels: true, // draw major labels
minorTicks: true, // draw minor ticks
minorLabels: true, // draw minor labels
microTicks: false, // draw micro ticks
rotation: 0, // label rotation angle in degrees
htmlLabels: true, // use HTML to draw labels
enableCache: false, // whether we cache or not
dropLabels: true, // whether we automatically drop overlapping labels or not
labelSizeChange: false, // whether the labels size change on zoom
position: "leftOrBottom" // position of the axis: "leftOrBottom" (default), "center" or "rightOrTop"
},
optionalParams: {
min: 0, // minimal value on this axis
max: 1, // maximal value on this axis
from: 0, // visible from this value
to: 1, // visible to this value
majorTickStep: 4, // major tick step
minorTickStep: 2, // minor tick step
microTickStep: 1, // micro tick step
labels: [], // array of labels for major ticks
// with corresponding numeric values
// ordered by values
labelFunc: null, // function to compute label values
maxLabelSize: 0, // size in px. For use with labelFunc
maxLabelCharCount: 0, // size in word count.
trailingSymbol: null,
// TODO: add support for minRange!
// minRange: 1, // smallest distance from min allowed on the axis
// theme components
stroke: {}, // stroke for an axis
majorTick: {}, // stroke + length for a tick
minorTick: {}, // stroke + length for a tick
microTick: {}, // stroke + length for a tick
tick: {}, // stroke + length for a tick
font: "", // font for labels
fontColor: "", // color for labels as a string
title: "", // axis title
titleGap: 0, // gap between axis title and axis label
titleFont: "", // axis title font
titleFontColor: "", // axis title font color
titleOrientation: "" // "axis" means the title facing the axis, "away" means facing away
},
constructor: function(chart, kwArgs){
// summary:
// The constructor for an axis.
// chart: dojox/charting/Chart
// The chart the axis belongs to.
// kwArgs: __AxisCtorArgs?
// Any optional keyword arguments to be used to define this axis.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
if(this.opt.enableCache){
this._textFreePool = [];
this._lineFreePool = [];
this._textUsePool = [];
this._lineUsePool = [];
}
this._invalidMaxLabelSize = true;
// replace deprecated leftBotton to position
if(!(kwArgs && ('position' in kwArgs))){
this.opt.position = this.opt.leftBottom ? "leftOrBottom" : "rightOrTop";
}
this.renderingOptions = { "shape-rendering": "crispEdges" };
},
setWindow: function(scale, offset){
// summary:
// Set the drawing "window" for the axis.
// scale: Number
// The new scale for the axis.
// offset: Number
// The new offset for the axis.
// returns: dojox/charting/axis2d/Default
// The reference to the axis for functional chaining.
if(scale != this.scale){
// if scale changed we need to recompute new max label size
this._invalidMaxLabelSize = true;
}
return this.inherited(arguments);
},
_groupLabelWidth: function(labels, font, wcLimit){
if(!labels.length){
return 0;
}
if(labels.length > 50){
// let's avoid degenerated cases
labels.length = 50;
}
if(lang.isObject(labels[0])){
labels = df.map(labels, function(label){ return label.text; });
}
if(wcLimit){
labels = df.map(labels, function(label){
return lang.trim(label).length == 0 ? "" : label.substring(0, wcLimit) + this.trailingSymbol;
}, this);
}
var s = labels.join(" ");
return g._base._getTextBox(s, {font: font}).w || 0;
},
_getMaxLabelSize: function(min, max, span, rotation, font, size){
if(this._maxLabelSize == null && arguments.length == 6){
var o = this.opt;
// everything might have changed, reset the minMinorStep value
this.scaler.minMinorStep = this._prevMinMinorStep = 0;
var ob = lang.clone(o);
delete ob.to;
delete ob.from;
// build all the ticks from min, to max not from to to _but_ using the step
// that would be used if we where just displaying from to to from.
var sb = lin.buildScaler(min, max, span, ob, o.to - o.from);
sb.minMinorStep = 0;
this._majorStart = sb.major.start;
// we build all the ticks not only the ones we need to draw in order to get
// a correct drop rate computation that works for any offset of this scale
var tb = lin.buildTicks(sb, o);
// if there is not tick at all tb is null
if(size && tb){
var majLabelW = 0, minLabelW = 0; // non rotated versions
// we first collect all labels when needed
var tickLabelFunc = function(tick){
if(tick.label){
this.push(tick.label);
}
};
var labels = [];
if(this.opt.majorLabels){
arr.forEach(tb.major, tickLabelFunc, labels);
majLabelW = this._groupLabelWidth(labels, font, ob.maxLabelCharCount);
if(ob.maxLabelSize){
majLabelW = Math.min(ob.maxLabelSize, majLabelW);
}
}
// do the minor labels computation only if dropLabels is set
labels = [];
if(this.opt.dropLabels && this.opt.minorLabels){
arr.forEach(tb.minor, tickLabelFunc, labels);
minLabelW = this._groupLabelWidth(labels, font, ob.maxLabelCharCount);
if(ob.maxLabelSize){
minLabelW = Math.min(ob.maxLabelSize, minLabelW);
}
}
this._maxLabelSize = {
majLabelW: majLabelW, minLabelW: minLabelW,
majLabelH: size, minLabelH: size
};
}else{
this._maxLabelSize = null;
}
}
return this._maxLabelSize;
},
calculate: function(min, max, span){
this.inherited(arguments);
// when the scale has not changed there is no reason for minMinorStep to change
this.scaler.minMinorStep = this._prevMinMinorStep;
// we want to recompute the dropping mechanism only when the scale or the size of the axis is changing
// not when for example when we scroll (otherwise effect would be weird)
if((this._invalidMaxLabelSize || span != this._oldSpan) && (min != Infinity && max != -Infinity)){
this._invalidMaxLabelSize = false;
if(this.opt.labelSizeChange){
this._maxLabelSize = null;
}
this._oldSpan = span;
var o = this.opt;
var ta = this.chart.theme.axis, rotation = o.rotation % 360,
labelGap = this.chart.theme.axis.tick.labelGap,
// TODO: we use one font --- of major tick, we need to use major and minor fonts
font = o.font || (ta.majorTick && ta.majorTick.font) || (ta.tick && ta.tick.font),
size = font ? g.normalizedLength(g.splitFontString(font).size) : 0,
// even if we don't drop label we need to compute max size for offsets
labelW = this._getMaxLabelSize(min, max, span, rotation, font, size);
if(typeof labelGap != "number"){
labelGap = 4; // in pixels
}
if(labelW && o.dropLabels){
var cosr = Math.abs(Math.cos(rotation * Math.PI / 180)),
sinr = Math.abs(Math.sin(rotation * Math.PI / 180));
var majLabelW, minLabelW;
if(rotation < 0){
rotation += 360;
}
switch(rotation){
case 0:
case 180:
// trivial cases: horizontal labels
if(this.vertical){
majLabelW = minLabelW = size;
}else{
majLabelW = labelW.majLabelW;
minLabelW = labelW.minLabelW;
}
break;
case 90:
case 270:
// trivial cases: vertical
if(this.vertical){
majLabelW = labelW.majLabelW;
minLabelW = labelW.minLabelW;
}else{
majLabelW = minLabelW = size;
}
break;
default:
// all major labels are parallel they can't collapse except if the two ticks are
// closer than the height of the text * cos(90-rotation)
majLabelW = this.vertical ? Math.min(labelW.majLabelW, size / cosr) : Math.min(labelW.majLabelW, size / sinr);
// for minor labels we need to rotated them
var gap1 = Math.sqrt(labelW.minLabelW * labelW.minLabelW + size * size),
gap2 = this.vertical ? size * cosr + labelW.minLabelW * sinr : labelW.minLabelW * cosr + size * sinr;
minLabelW = Math.min(gap1, gap2);
break;
}
// we need to check both minor and major labels fit a minor step
this.scaler.minMinorStep = this._prevMinMinorStep = Math.max(majLabelW, minLabelW) + labelGap;
var canMinorLabel = this.scaler.minMinorStep <= this.scaler.minor.tick * this.scaler.bounds.scale;
if(!canMinorLabel){
// we can't place minor labels, let's see if we can place major ones
// in a major step and if not which skip interval we must follow
this._skipInterval = Math.floor((majLabelW + labelGap) / (this.scaler.major.tick * this.scaler.bounds.scale));
}else{
// everything fit well
this._skipInterval = 0;
}
}else{
// drop label disabled
this._skipInterval = 0;
}
}
// computes the tick subset we need for that scale/offset
this.ticks = lin.buildTicks(this.scaler, this.opt);
return this;
},
getOffsets: function(){
// summary:
// Get the physical offset values for this axis (used in drawing data series). This method is not
// supposed to be called by the users but internally.
// returns: Object
// The calculated offsets in the form of { l, r, t, b } (left, right, top, bottom).
var s = this.scaler, offsets = { l: 0, r: 0, t: 0, b: 0 };
if(!s){
return offsets;
}
var o = this.opt,
ta = this.chart.theme.axis,
labelGap = this.chart.theme.axis.tick.labelGap,
// TODO: we use one font --- of major tick, we need to use major and minor fonts
taTitleFont = o.titleFont || (ta.title && ta.title.font),
taTitleGap = (o.titleGap==0) ? 0 : o.titleGap || (ta.title && ta.title.gap),
taMajorTick = this.chart.theme.getTick("major", o),
taMinorTick = this.chart.theme.getTick("minor", o),
tsize = taTitleFont ? g.normalizedLength(g.splitFontString(taTitleFont).size) : 0,
rotation = o.rotation % 360, position = o.position,
leftBottom = position !== "rightOrTop",
cosr = Math.abs(Math.cos(rotation * Math.PI / 180)),
sinr = Math.abs(Math.sin(rotation * Math.PI / 180));
this.trailingSymbol = (o.trailingSymbol === undefined || o.trailingSymbol === null) ?
this.trailingSymbol : o.trailingSymbol;
if(typeof labelGap != "number"){
labelGap = 4; // in pixels
}
if(rotation < 0){
rotation += 360;
}
var maxLabelSize = this._getMaxLabelSize(); // don't need parameters, calculate has been called before => we use cached value
if(maxLabelSize){
var side;
var labelWidth = Math.ceil(Math.max(maxLabelSize.majLabelW, maxLabelSize.minLabelW)) + 1,
size = Math.ceil(Math.max(maxLabelSize.majLabelH, maxLabelSize.minLabelH)) + 1;
if(this.vertical){
side = leftBottom ? "l" : "r";
switch(rotation){
case 0:
case 180:
offsets[side] = position === "center" ? 0 : labelWidth;
offsets.t = offsets.b = size / 2;
break;
case 90:
case 270:
offsets[side] = size;
offsets.t = offsets.b = labelWidth / 2;
break;
default:
if(rotation <= centerAnchorLimit || (180 < rotation && rotation <= (180 + centerAnchorLimit))){
offsets[side] = size * sinr / 2 + labelWidth * cosr;
offsets[leftBottom ? "t" : "b"] = size * cosr / 2 + labelWidth * sinr;
offsets[leftBottom ? "b" : "t"] = size * cosr / 2;
}else if(rotation > (360 - centerAnchorLimit) || (180 > rotation && rotation > (180 - centerAnchorLimit))){
offsets[side] = size * sinr / 2 + labelWidth * cosr;
offsets[leftBottom ? "b" : "t"] = size * cosr / 2 + labelWidth * sinr;
offsets[leftBottom ? "t" : "b"] = size * cosr / 2;
}else if(rotation < 90 || (180 < rotation && rotation < 270)){
offsets[side] = size * sinr + labelWidth * cosr;
offsets[leftBottom ? "t" : "b"] = size * cosr + labelWidth * sinr;
}else{
offsets[side] = size * sinr + labelWidth * cosr;
offsets[leftBottom ? "b" : "t"] = size * cosr + labelWidth * sinr;
}
break;
}
if(position === "center"){
offsets[side] = 0;
}
else{
offsets[side] += labelGap + Math.max(taMajorTick.length > 0?taMajorTick.length:0,
taMinorTick.length > 0?taMinorTick.length:0) + (o.title ? (tsize + taTitleGap) : 0);
}
}else{
side = leftBottom ? "b" : "t";
switch(rotation){
case 0:
case 180:
offsets[side] = position === "center" ? 0 : size;
offsets.l = offsets.r = labelWidth / 2;
break;
case 90:
case 270:
offsets[side] = labelWidth;
offsets.l = offsets.r = size / 2;
break;
default:
if((90 - centerAnchorLimit) <= rotation && rotation <= 90 || (270 - centerAnchorLimit) <= rotation && rotation <= 270){
offsets[side] = size * cosr / 2 + labelWidth * sinr;
offsets[leftBottom ? "r" : "l"] = size * sinr / 2 + labelWidth * cosr;
offsets[leftBottom ? "l" : "r"] = size * sinr / 2;
}else if(90 <= rotation && rotation <= (90 + centerAnchorLimit) || 270 <= rotation && rotation <= (270 + centerAnchorLimit)){
offsets[side] = size * cosr / 2 + labelWidth * sinr;
offsets[leftBottom ? "l" : "r"] = size * sinr / 2 + labelWidth * cosr;
offsets[leftBottom ? "r" : "l"] = size * sinr / 2;
}else if(rotation < centerAnchorLimit || (180 < rotation && rotation < (180 + centerAnchorLimit))){
offsets[side] = size * cosr + labelWidth * sinr;
offsets[leftBottom ? "r" : "l"] = size * sinr + labelWidth * cosr;
}else{
offsets[side] = size * cosr + labelWidth * sinr;
offsets[leftBottom ? "l" : "r"] = size * sinr + labelWidth * cosr;
}
break;
}
if(position === "center"){
offsets[side] = 0;
}
else{
offsets[side] += labelGap + Math.max(taMajorTick.length > 0?taMajorTick.length:0,
taMinorTick.length > 0?taMinorTick.length:0) + (o.title ? (tsize + taTitleGap) : 0);
}
}
}
return offsets; // Object
},
cleanGroup: function(creator){
if(this.opt.enableCache && this.group){
this._lineFreePool = this._lineFreePool.concat(this._lineUsePool);
this._lineUsePool = [];
this._textFreePool = this._textFreePool.concat(this._textUsePool);
this._textUsePool = [];
}
this.inherited(arguments);
},
createText: function(labelType, creator, x, y, align, textContent, font, fontColor, labelWidth){
if(!this.opt.enableCache || labelType=="html"){
return acommon.createText[labelType](
this.chart,
creator,
x,
y,
align,
textContent,
font,
fontColor,
labelWidth
);
}
var text;
if(this._textFreePool.length > 0){
text = this._textFreePool.pop();
text.setShape({x: x, y: y, text: textContent, align: align});
// For now all items share the same font, no need to re-set it
//.setFont(font).setFill(fontColor);
// was cleared, add it back
creator.add(text);
}else{
text = acommon.createText[labelType](
this.chart,
creator,
x,
y,
align,
textContent,
font,
fontColor
);
}
this._textUsePool.push(text);
return text;
},
createLine: function(creator, params){
var line;
if(this.opt.enableCache && this._lineFreePool.length > 0){
line = this._lineFreePool.pop();
line.setShape(params);
// was cleared, add it back
creator.add(line);
}else{
line = creator.createLine(params);
}
if(this.opt.enableCache){
this._lineUsePool.push(line);
}
return line;
},
render: function(dim, offsets){
// summary:
// Render/draw the axis.
// dim: Object
// An object of the form { width, height}.
// offsets: Object
// An object of the form { l, r, t, b }.
// returns: dojox/charting/axis2d/Default
// The reference to the axis for functional chaining.
var isRtl = this._isRtl(); // chart mirroring
if(!this.dirty || !this.scaler){
return this; // dojox/charting/axis2d/Default
}
// prepare variable
var o = this.opt, ta = this.chart.theme.axis, position = o.position,
leftBottom = position !== "rightOrTop", rotation = o.rotation % 360,
start, stop, titlePos, titleRotation=0, titleOffset, axisVector, tickVector, anchorOffset, labelOffset, labelAlign,
labelGap = this.chart.theme.axis.tick.labelGap,
// TODO: we use one font --- of major tick, we need to use major and minor fonts
taFont = o.font || (ta.majorTick && ta.majorTick.font) || (ta.tick && ta.tick.font),
taTitleFont = o.titleFont || (ta.title && ta.title.font),
// TODO: we use one font color --- we need to use different colors
taFontColor = o.fontColor || (ta.majorTick && ta.majorTick.fontColor) || (ta.tick && ta.tick.fontColor) || "black",
taTitleFontColor = o.titleFontColor || (ta.title && ta.title.fontColor) || "black",
taTitleGap = (o.titleGap==0) ? 0 : o.titleGap || (ta.title && ta.title.gap) || 15,
taTitleOrientation = o.titleOrientation || (ta.title && ta.title.orientation) || "axis",
taMajorTick = this.chart.theme.getTick("major", o),
taMinorTick = this.chart.theme.getTick("minor", o),
taMicroTick = this.chart.theme.getTick("micro", o),
taStroke = "stroke" in o ? o.stroke : ta.stroke,
size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0,
cosr = Math.abs(Math.cos(rotation * Math.PI / 180)),
sinr = Math.abs(Math.sin(rotation * Math.PI / 180)),
tsize = taTitleFont ? g.normalizedLength(g.splitFontString(taTitleFont).size) : 0;
if(typeof labelGap != "number"){
labelGap = 4; // in pixels
}
if(rotation < 0){
rotation += 360;
}
var cachedLabelW = this._getMaxLabelSize();
cachedLabelW = cachedLabelW && cachedLabelW.majLabelW;
if(this.vertical){
start = {y: dim.height - offsets.b};
stop = {y: offsets.t};
titlePos = {y: (dim.height - offsets.b + offsets.t)/2};
titleOffset = size * sinr + (cachedLabelW || 0) * cosr + labelGap + Math.max(taMajorTick.length > 0?taMajorTick.length:0,
taMinorTick.length > 0?taMinorTick.length:0) +
tsize + taTitleGap;
axisVector = {x: 0, y: -1};
labelOffset = {x: 0, y: 0};
tickVector = {x: 1, y: 0};
anchorOffset = {x: labelGap, y: 0};
switch(rotation){
case 0:
labelAlign = "end";
labelOffset.y = size * 0.4;
break;
case 90:
labelAlign = "middle";
labelOffset.x = -size;
break;
case 180:
labelAlign = "start";
labelOffset.y = -size * 0.4;
break;
case 270:
labelAlign = "middle";
break;
default:
if(rotation < centerAnchorLimit){
labelAlign = "end";
labelOffset.y = size * 0.4;
}else if(rotation < 90){
labelAlign = "end";
labelOffset.y = size * 0.4;
}else if(rotation < (180 - centerAnchorLimit)){
labelAlign = "start";
}else if(rotation < (180 + centerAnchorLimit)){
labelAlign = "start";
labelOffset.y = -size * 0.4;
}else if(rotation < 270){
labelAlign = "start";
labelOffset.x = leftBottom ? 0 : size * 0.4;
}else if(rotation < (360 - centerAnchorLimit)){
labelAlign = "end";
labelOffset.x = leftBottom ? 0 : size * 0.4;
}else{
labelAlign = "end";
labelOffset.y = size * 0.4;
}
}
if(leftBottom){
start.x = stop.x = position === "center" ? dim.width/2 : offsets.l;
titleRotation = (taTitleOrientation && taTitleOrientation == "away") ? 90 : 270;
titlePos.x = offsets.l - titleOffset + (titleRotation == 270 ? tsize : 0);
tickVector.x = -1;
anchorOffset.x = -anchorOffset.x;
}else{
start.x = stop.x = dim.width - offsets.r;
titleRotation = (taTitleOrientation && taTitleOrientation == "axis") ? 90 : 270;
titlePos.x = dim.width - offsets.r + titleOffset - (titleRotation == 270 ? 0 : tsize);
switch(labelAlign){
case "start":
labelAlign = "end";
break;
case "end":
labelAlign = "start";
break;
case "middle":
labelOffset.x += size;
break;
}
}
}else{
start = {x: offsets.l};
stop = {x: dim.width - offsets.r};
titlePos = {x: (dim.width - offsets.r + offsets.l)/2};
titleOffset = size * cosr + (cachedLabelW || 0) * sinr + labelGap + Math.max(taMajorTick.length > 0?taMajorTick.length:0,
taMinorTick.length > 0?taMinorTick.length:0) +
tsize + taTitleGap;
axisVector = {x: isRtl ? -1 : 1, y: 0}; // chart mirroring
labelOffset = {x: 0, y: 0};
tickVector = {x: 0, y: 1};
anchorOffset = {x: 0, y: labelGap};
switch(rotation){
case 0:
labelAlign = "middle";
labelOffset.y = size;
break;
case 90:
labelAlign = "start";
labelOffset.x = -size * 0.4;
break;
case 180:
labelAlign = "middle";
break;
case 270:
labelAlign = "end";
labelOffset.x = size * 0.4;
break;
default:
if(rotation < (90 - centerAnchorLimit)){
labelAlign = "start";
labelOffset.y = leftBottom ? size : 0;
}else if(rotation < (90 + centerAnchorLimit)){
labelAlign = "start";
labelOffset.x = -size * 0.4;
}else if(rotation < 180){
labelAlign = "start";
labelOffset.y = leftBottom ? 0 : -size;
}else if(rotation < (270 - centerAnchorLimit)){
labelAlign = "end";
labelOffset.y = leftBottom ? 0 : -size;
}else if(rotation < (270 + centerAnchorLimit)){
labelAlign = "end";
labelOffset.y = leftBottom ? size * 0.4 : 0;
}else{
labelAlign = "end";
labelOffset.y = leftBottom ? size : 0;
}
}
if(leftBottom){
start.y = stop.y = position === "center" ? dim.height/2 : dim.height - offsets.b;
titleRotation = (taTitleOrientation && taTitleOrientation == "axis") ? 180 : 0;
titlePos.y = dim.height - offsets.b + titleOffset - (titleRotation ? tsize : 0);
}else{
start.y = stop.y = offsets.t;
titleRotation = (taTitleOrientation && taTitleOrientation == "away") ? 180 : 0;
titlePos.y = offsets.t - titleOffset + (titleRotation ? 0 : tsize);
tickVector.y = -1;
anchorOffset.y = -anchorOffset.y;
switch(labelAlign){
case "start":
labelAlign = "end";
break;
case "end":
labelAlign = "start";
break;
case "middle":
labelOffset.y -= size;
break;
}
}
}
// render shapes
this.cleanGroup();
var s = this.group,
c = this.scaler,
t = this.ticks,
f = lin.getTransformerFromModel(this.scaler),
// GFX Canvas now supports labels, so let's _not_ fallback to HTML anymore on canvas, just use
// HTML labels if explicitly asked + no rotation + no IE + no Opera
labelType = (!o.title || !titleRotation) && !rotation && this.opt.htmlLabels && !has("ie") && !has("opera") ? "html" : "gfx",
dx = tickVector.x * taMajorTick.length,
dy = tickVector.y * taMajorTick.length,
skip = this._skipInterval;
s.createLine({
x1: start.x,
y1: start.y,
x2: stop.x,
y2: stop.y
}).setStroke(taStroke);
//create axis title
if(o.title){
var axisTitle = acommon.createText[labelType](
this.chart,
s,
titlePos.x,
titlePos.y,
"middle",
o.title,
taTitleFont,
taTitleFontColor
);
if(labelType == "html"){
this.htmlElements.push(axisTitle);
}else{
//as soon as rotation is provided, labelType won't be "html"
//rotate gfx labels
axisTitle.setTransform(g.matrix.rotategAt(titleRotation, titlePos.x, titlePos.y));
}
}
// go out nicely instead of try/catch
if(t == null){
this.dirty = false;
return this;
}
var rel = (t.major.length > 0)?(t.major[0].value - this._majorStart) / c.major.tick:0;
var canLabel = this.opt.majorLabels;
arr.forEach(t.major, function(tick, i){
var offset = f(tick.value), elem,
x = (isRtl ? stop.x : start.x) + axisVector.x * offset, // chart mirroring
y = start.y + axisVector.y * offset;
i += rel;
this.createLine(s, {
x1: x, y1: y,
x2: x + dx,
y2: y + dy
}).setStroke(taMajorTick);
if(tick.label && (!skip || (i - (1 + skip)) % (1 + skip) == 0)){
var label = o.maxLabelCharCount ? this.getTextWithLimitCharCount(tick.label, taFont, o.maxLabelCharCount) : {
text: tick.label,
truncated: false
};
label = o.maxLabelSize ? this.getTextWithLimitLength(label.text, taFont, o.maxLabelSize, label.truncated) : label;
elem = this.createText(labelType,
s,
x + (taMajorTick.length > 0 ? dx : 0) + anchorOffset.x + (rotation ? 0 : labelOffset.x),
y + (taMajorTick.length > 0 ? dy : 0) + anchorOffset.y + (rotation ? 0 : labelOffset.y),
labelAlign,
label.text,
taFont,
taFontColor
//cachedLabelW
);
// if bidi support was required, the textDir is "auto" and truncation
// took place, we need to update the dir of the element for cases as:
// Fool label: 111111W (W for bidi character)
// truncated label: 11...
// in this case for auto textDir the dir will be "ltr" which is wrong.
if(label.truncated){
this.chart.formatTruncatedLabel(elem, tick.label, labelType);
}
label.truncated && this.labelTooltip(elem, this.chart, tick.label, label.text, taFont, labelType);
if(labelType == "html"){
this.htmlElements.push(elem);
}else if(rotation){
elem.setTransform([
{dx: labelOffset.x, dy: labelOffset.y},
g.matrix.rotategAt(
rotation,
x + (taMajorTick.length > 0 ? dx : 0) + anchorOffset.x,
y + (taMajorTick.length > 0 ? dy : 0) + anchorOffset.y
)
]);
}
}
}, this);
dx = tickVector.x * taMinorTick.length;
dy = tickVector.y * taMinorTick.length;
canLabel = this.opt.minorLabels && c.minMinorStep <= c.minor.tick * c.bounds.scale;
arr.forEach(t.minor, function(tick){
var offset = f(tick.value), elem,
x = (isRtl ? stop.x : start.x) + axisVector.x * offset,
y = start.y + axisVector.y * offset; // chart mirroring
this.createLine(s, {
x1: x, y1: y,
x2: x + dx,
y2: y + dy
}).setStroke(taMinorTick);
if(canLabel && tick.label){
var label = o.maxLabelCharCount ? this.getTextWithLimitCharCount(tick.label, taFont, o.maxLabelCharCount) : {
text: tick.label,
truncated: false
};
label = o.maxLabelSize ? this.getTextWithLimitLength(label.text, taFont, o.maxLabelSize, label.truncated) : label;
elem = this.createText(labelType,
s,
x + (taMinorTick.length > 0 ? dx : 0) + anchorOffset.x + (rotation ? 0 : labelOffset.x),
y + (taMinorTick.length > 0 ? dy : 0) + anchorOffset.y + (rotation ? 0 : labelOffset.y),
labelAlign,
label.text,
taFont,
taFontColor
//cachedLabelW
);
// if bidi support was required, the textDir is "auto" and truncation
// took place, we need to update the dir of the element for cases as:
// Fool label: 111111W (W for bidi character)
// truncated label: 11...
// in this case for auto textDir the dir will be "ltr" which is wrong.
if(label.truncated){
this.chart.formatTruncatedLabel(elem, tick.label, labelType);
}
label.truncated && this.labelTooltip(elem, this.chart, tick.label, label.text, taFont, labelType);
if(labelType == "html"){
this.htmlElements.push(elem);
}else if(rotation){
elem.setTransform([
{dx: labelOffset.x, dy: labelOffset.y},
g.matrix.rotategAt(
rotation,
x + (taMinorTick.length > 0 ? dx : 0) + anchorOffset.x,
y + (taMinorTick.length > 0 ? dy : 0) + anchorOffset.y
)
]);
}
}
}, this);
dx = tickVector.x * taMicroTick.length;
dy = tickVector.y * taMicroTick.length;
arr.forEach(t.micro, function(tick){
var offset = f(tick.value),
x = start.x + axisVector.x * offset,
y = start.y + axisVector.y * offset;
this.createLine(s, {
x1: x, y1: y,
x2: x + dx,
y2: y + dy
}).setStroke(taMicroTick);
}, this);
this.dirty = false;
return this; // dojox/charting/axis2d/Default
},
labelTooltip: function(elem, chart, label, truncatedLabel, font, elemType){
var modules = ["dijit/Tooltip"];
var aroundRect = {type: "rect"}, position = ["above", "below"],
fontWidth = g._base._getTextBox(truncatedLabel, {font: font}).w || 0,
fontHeight = font ? g.normalizedLength(g.splitFontString(font).size) : 0;
if(elemType == "html"){
lang.mixin(aroundRect, domGeom.position(elem.firstChild, true));
aroundRect.width = Math.ceil(fontWidth);
aroundRect.height = Math.ceil(fontHeight);
this._events.push({
shape: dojo,
handle: connect.connect(elem.firstChild, "onmouseover", this, function(e){
require(modules, function(Tooltip){
Tooltip.show(label, aroundRect, position);
});
})
});
this._events.push({
shape: dojo,
handle: connect.connect(elem.firstChild, "onmouseout", this, function(e){
require(modules, function(Tooltip){
Tooltip.hide(aroundRect);
});
})
});
}else{
var shp = elem.getShape(),
lt = chart.getCoords();
aroundRect = lang.mixin(aroundRect, {
x: shp.x - fontWidth / 2,
y: shp.y
});
aroundRect.x += lt.x;
aroundRect.y += lt.y;
aroundRect.x = Math.round(aroundRect.x);
aroundRect.y = Math.round(aroundRect.y);
aroundRect.width = Math.ceil(fontWidth);
aroundRect.height = Math.ceil(fontHeight);
this._events.push({
shape: elem,
handle: elem.connect("onmouseenter", this, function(e){
require(modules, function(Tooltip){
Tooltip.show(label, aroundRect, position);
});
})
});
this._events.push({
shape: elem,
handle: elem.connect("onmouseleave", this, function(e){
require(modules, function(Tooltip){
Tooltip.hide(aroundRect);
});
})
});
}
},
_isRtl: function(){
return false;
}
});
return has("dojo-bidi")? declare("dojox.charting.axis2d.Default", [Default, BidiDefault]) : Default;
});
},
'dojox/charting/axis2d/Invisible':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "./Base", "../scaler/linear",
"dojox/lang/utils"],
function(lang, declare, Base, lin, du){
/*=====
var __InvisibleAxisCtorArgs = {
// summary:
// Optional arguments used in the definition of an invisible axis.
// vertical: Boolean?
// A flag that says whether an axis is vertical (i.e. y axis) or horizontal. Default is false (horizontal).
// fixUpper: String?
// Align the greatest value on the axis with the specified tick level. Options are "major", "minor", "micro", or "none". Defaults to "none".
// fixLower: String?
// Align the smallest value on the axis with the specified tick level. Options are "major", "minor", "micro", or "none". Defaults to "none".
// natural: Boolean?
// Ensure tick marks are made on "natural" numbers. Defaults to false.
// leftBottom: Boolean?
// The position of a vertical axis; if true, will be placed against the left-bottom corner of the chart. Defaults to true.
// includeZero: Boolean?
// Include 0 on the axis rendering. Default is false.
// fixed: Boolean?
// Force all axis labels to be fixed numbers. Default is true.
// min: Number?
// The smallest value on an axis. Default is 0.
// max: Number?
// The largest value on an axis. Default is 1.
// from: Number?
// Force the chart to render data visible from this value. Default is 0.
// to: Number?
// Force the chart to render data visible to this value. Default is 1.
// majorTickStep: Number?
// The amount to skip before a major tick is drawn. When not set the major ticks step is computed from
// the data range.
// minorTickStep: Number?
// The amount to skip before a minor tick is drawn. When not set the minor ticks step is computed from
// the data range.
// microTickStep: Number?
// The amount to skip before a micro tick is drawn. When not set the micro ticks step is computed from
};
=====*/
return declare("dojox.charting.axis2d.Invisible", Base, {
// summary:
// A axis object used in dojox.charting. You can use that axis if you want the axis to be invisible.
// See dojox.charting.Chart.addAxis for details.
//
// defaultParams: Object
// The default parameters used to define any axis.
// optionalParams: Object
// Any optional parameters needed to define an axis.
/*
// TODO: the documentation tools need these to be pre-defined in order to pick them up
// correctly, but the code here is partially predicated on whether or not the properties
// actually exist. For now, we will leave these undocumented but in the code for later. -- TRT
// opt: Object
// The actual options used to define this axis, created at initialization.
// scaler: Object
// The calculated helper object to tell charts how to draw an axis and any data.
// ticks: Object
// The calculated tick object that helps a chart draw the scaling on an axis.
// dirty: Boolean
// The state of the axis (whether it needs to be redrawn or not)
// scale: Number
// The current scale of the axis.
// offset: Number
// The current offset of the axis.
opt: null,
scaler: null,
ticks: null,
dirty: true,
scale: 1,
offset: 0,
*/
defaultParams: {
vertical: false, // true for vertical axis
fixUpper: "none", // align the upper on ticks: "major", "minor", "micro", "none"
fixLower: "none", // align the lower on ticks: "major", "minor", "micro", "none"
natural: false, // all tick marks should be made on natural numbers
leftBottom: true, // position of the axis, used with "vertical"
includeZero: false, // 0 should be included
fixed: true // all labels are fixed numbers
},
optionalParams: {
min: 0, // minimal value on this axis
max: 1, // maximal value on this axis
from: 0, // visible from this value
to: 1, // visible to this value
majorTickStep: 4, // major tick step
minorTickStep: 2, // minor tick step
microTickStep: 1 // micro tick step
},
constructor: function(chart, kwArgs){
// summary:
// The constructor for an invisible axis.
// chart: dojox/charting/Chart
// The chart the axis belongs to.
// kwArgs: __InvisibleAxisCtorArgs?
// Any optional keyword arguments to be used to define this axis.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
},
dependOnData: function(){
// summary:
// Find out whether or not the axis options depend on the data in the axis.
return !("min" in this.opt) || !("max" in this.opt); // Boolean
},
clear: function(){
// summary:
// Clear out all calculated properties on this axis;
// returns: dojox/charting/axis2d/Invisible
// The reference to the axis for functional chaining.
delete this.scaler;
delete this.ticks;
this.dirty = true;
return this; // dojox/charting/axis2d/Invisible
},
initialized: function(){
// summary:
// Finds out if this axis has been initialized or not.
// returns: Boolean
// Whether a scaler has been calculated and if the axis is not dirty.
return "scaler" in this && !(this.dirty && this.dependOnData());
},
setWindow: function(scale, offset){
// summary:
// Set the drawing "window" for the axis.
// scale: Number
// The new scale for the axis.
// offset: Number
// The new offset for the axis.
// returns: dojox/charting/axis2d/Invisible
// The reference to the axis for functional chaining.
this.scale = scale;
this.offset = offset;
return this.clear(); // dojox/charting/axis2d/Invisible
},
getWindowScale: function(){
// summary:
// Get the current windowing scale of the axis.
return "scale" in this ? this.scale : 1; // Number
},
getWindowOffset: function(){
// summary:
// Get the current windowing offset for the axis.
return "offset" in this ? this.offset : 0; // Number
},
calculate: function(min, max, span, scalerType){
// summary:
// Perform all calculations needed to render this axis.
// min: Number
// The smallest value represented on this axis.
// max: Number
// The largest value represented on this axis.
// span: Number
// The span in pixels over which axis calculations are made.
// scalerType: Object
// An optional scaler type object.
// returns: dojox/charting/axis2d/Invisible
// The reference to the axis for functional chaining.
if(this.initialized()){
return this;
}
var o = this.opt;
// we used to have a 4th function parameter to reach labels but
// nobody was calling it with 4 parameters.
this.labels = o.labels;
this.scaler = (scalerType || lin).buildScaler(min, max, span, o);
// store the absolute major tick start, this will be useful when dropping a label every n labels
// TODO: if o.lower then it does not work
var tsb = this.scaler.bounds;
if("scale" in this){
// calculate new range
o.from = tsb.lower + this.offset;
o.to = (tsb.upper - tsb.lower) / this.scale + o.from;
// make sure that bounds are correct
if( !isFinite(o.from) ||
isNaN(o.from) ||
!isFinite(o.to) ||
isNaN(o.to) ||
o.to - o.from >= tsb.upper - tsb.lower
){
// any error --- remove from/to bounds
delete o.from;
delete o.to;
delete this.scale;
delete this.offset;
}else{
// shift the window, if we are out of bounds
if(o.from < tsb.lower){
o.to += tsb.lower - o.from;
o.from = tsb.lower;
}else if(o.to > tsb.upper){
o.from += tsb.upper - o.to;
o.to = tsb.upper;
}
// update the offset
this.offset = o.from - tsb.lower;
}
// re-calculate the scaler
this.scaler = (scalerType || lin).buildScaler(min, max, span, o);
tsb = this.scaler.bounds;
// cleanup
if(this.scale == 1 && this.offset == 0){
delete this.scale;
delete this.offset;
}
}
return this; // dojox/charting/axis2d/Invisible
},
getScaler: function(){
// summary:
// Get the pre-calculated scaler object.
return this.scaler; // Object
},
getTicks: function(){
// summary:
// Get the pre-calculated ticks object.
return this.ticks; // Object
}
});
});
},
'dojox/charting/axis2d/Base':function(){
define(["dojo/_base/declare", "../Element"],
function(declare, Element){
/*=====
var __BaseAxisCtorArgs = {
// summary:
// Optional arguments used in the definition of an invisible axis.
// vertical: Boolean?
// A flag that says whether an axis is vertical (i.e. y axis) or horizontal. Default is false (horizontal).
// min: Number?
// The smallest value on an axis. Default is 0.
// max: Number?
// The largest value on an axis. Default is 1.
};
=====*/
return declare("dojox.charting.axis2d.Base", Element, {
// summary:
// The base class for any axis. This is more of an interface/API
// definition than anything else; see dojox.charting.axis2d.Default
// for more details.
constructor: function(chart, kwArgs){
// summary:
// Return a new base axis.
// chart: dojox/charting/Chart
// The chart this axis belongs to.
// kwArgs: __BaseAxisCtorArgs?
// An optional arguments object to define the axis parameters.
this.vertical = kwArgs && kwArgs.vertical;
this.opt = {};
this.opt.min = kwArgs && kwArgs.min;
this.opt.max = kwArgs && kwArgs.max;
},
clear: function(){
// summary:
// Stub function for clearing the axis.
// returns: dojox/charting/axis2d/Base
// A reference to the axis for functional chaining.
return this; // dojox/charting/axis2d/Base
},
initialized: function(){
// summary:
// Return a flag as to whether or not this axis has been initialized.
// returns: Boolean
// If the axis is initialized or not.
return false; // Boolean
},
calculate: function(min, max, span){
// summary:
// Stub function to run the calculations needed for drawing this axis.
// returns: dojox/charting/axis2d/Base
// A reference to the axis for functional chaining.
return this; // dojox/charting/axis2d/Base
},
getScaler: function(){
// summary:
// A stub function to return the scaler object created during calculate.
// returns: Object
// The scaler object (see dojox.charting.scaler.linear for more information)
return null; // Object
},
getTicks: function(){
// summary:
// A stub function to return the object that helps define how ticks are rendered.
// returns: Object
// The ticks object.
return null; // Object
},
getOffsets: function(){
// summary:
// A stub function to return any offsets needed for axis and series rendering.
// returns: Object
// An object of the form { l, r, t, b }.
return {l: 0, r: 0, t: 0, b: 0}; // Object
},
render: function(dim, offsets){
// summary:
// Stub function to render this axis.
// returns: dojox/charting/axis2d/Base
// A reference to the axis for functional chaining.
this.dirty = false;
return this; // dojox/charting/axis2d/Base
},
isNullValue: function(value){
// summary:
// A stub function to determine a data value
// that should be ignored.
// value: Number|Null|Object
// A data value to be inspected.
// returns: Boolean
// If the value makes sense for this axis or not.
return false;
},
naturalBaseline: 0
});
});
},
'dojox/charting/scaler/linear':function(){
define(["dojo/_base/lang", "./common"],
function(lang, common){
var linear = lang.getObject("dojox.charting.scaler.linear", true);
var deltaLimit = 3, // pixels
getLabel = common.getNumericLabel;
function findString(/*String*/ val, /*Array*/ text){
val = val.toLowerCase();
for(var i = text.length - 1; i >= 0; --i){
if(val === text[i]){
return true;
}
}
return false;
}
var calcTicks = function(min, max, kwArgs, majorTick, minorTick, microTick, span){
kwArgs = lang.delegate(kwArgs);
if(!majorTick){
if(kwArgs.fixUpper == "major"){ kwArgs.fixUpper = "minor"; }
if(kwArgs.fixLower == "major"){ kwArgs.fixLower = "minor"; }
}
if(!minorTick){
if(kwArgs.fixUpper == "minor"){ kwArgs.fixUpper = "micro"; }
if(kwArgs.fixLower == "minor"){ kwArgs.fixLower = "micro"; }
}
if(!microTick){
if(kwArgs.fixUpper == "micro"){ kwArgs.fixUpper = "none"; }
if(kwArgs.fixLower == "micro"){ kwArgs.fixLower = "none"; }
}
var lowerBound = findString(kwArgs.fixLower, ["major"]) ?
Math.floor(kwArgs.min / majorTick) * majorTick :
findString(kwArgs.fixLower, ["minor"]) ?
Math.floor(kwArgs.min / minorTick) * minorTick :
findString(kwArgs.fixLower, ["micro"]) ?
Math.floor(kwArgs.min / microTick) * microTick : kwArgs.min,
upperBound = findString(kwArgs.fixUpper, ["major"]) ?
Math.ceil(kwArgs.max / majorTick) * majorTick :
findString(kwArgs.fixUpper, ["minor"]) ?
Math.ceil(kwArgs.max / minorTick) * minorTick :
findString(kwArgs.fixUpper, ["micro"]) ?
Math.ceil(kwArgs.max / microTick) * microTick : kwArgs.max;
if(kwArgs.useMin){ min = lowerBound; }
if(kwArgs.useMax){ max = upperBound; }
var majorStart = (!majorTick || kwArgs.useMin && findString(kwArgs.fixLower, ["major"])) ?
min : Math.ceil(min / majorTick) * majorTick,
minorStart = (!minorTick || kwArgs.useMin && findString(kwArgs.fixLower, ["major", "minor"])) ?
min : Math.ceil(min / minorTick) * minorTick,
microStart = (! microTick || kwArgs.useMin && findString(kwArgs.fixLower, ["major", "minor", "micro"])) ?
min : Math.ceil(min / microTick) * microTick,
majorCount = !majorTick ? 0 : (kwArgs.useMax && findString(kwArgs.fixUpper, ["major"]) ?
Math.round((max - majorStart) / majorTick) :
Math.floor((max - majorStart) / majorTick)) + 1,
minorCount = !minorTick ? 0 : (kwArgs.useMax && findString(kwArgs.fixUpper, ["major", "minor"]) ?
Math.round((max - minorStart) / minorTick) :
Math.floor((max - minorStart) / minorTick)) + 1,
microCount = !microTick ? 0 : (kwArgs.useMax && findString(kwArgs.fixUpper, ["major", "minor", "micro"]) ?
Math.round((max - microStart) / microTick) :
Math.floor((max - microStart) / microTick)) + 1,
minorPerMajor = minorTick ? Math.round(majorTick / minorTick) : 0,
microPerMinor = microTick ? Math.round(minorTick / microTick) : 0,
majorPrecision = majorTick ? Math.floor(Math.log(majorTick) / Math.LN10) : 0,
minorPrecision = minorTick ? Math.floor(Math.log(minorTick) / Math.LN10) : 0,
scale = span / (max - min);
if(!isFinite(scale)){ scale = 1; }
return {
bounds: {
lower: lowerBound,
upper: upperBound,
from: min,
to: max,
scale: scale,
span: span
},
major: {
tick: majorTick,
start: majorStart,
count: majorCount,
prec: majorPrecision
},
minor: {
tick: minorTick,
start: minorStart,
count: minorCount,
prec: minorPrecision
},
micro: {
tick: microTick,
start: microStart,
count: microCount,
prec: 0
},
minorPerMajor: minorPerMajor,
microPerMinor: microPerMinor,
scaler: linear
};
};
return lang.mixin(linear, {
buildScaler: function(/*Number*/ min, /*Number*/ max, /*Number*/ span, /*Object*/ kwArgs, /*Number?*/ delta, /*Number?*/ minorDelta){
var h = {fixUpper: "none", fixLower: "none", natural: false};
if(kwArgs){
if("fixUpper" in kwArgs){ h.fixUpper = String(kwArgs.fixUpper); }
if("fixLower" in kwArgs){ h.fixLower = String(kwArgs.fixLower); }
if("natural" in kwArgs){ h.natural = Boolean(kwArgs.natural); }
}
minorDelta = !minorDelta || minorDelta < deltaLimit ? deltaLimit : minorDelta;
// update bounds
if("min" in kwArgs){ min = kwArgs.min; }
if("max" in kwArgs){ max = kwArgs.max; }
if(kwArgs.includeZero){
if(min > 0){ min = 0; }
if(max < 0){ max = 0; }
}
h.min = min;
h.useMin = true;
h.max = max;
h.useMax = true;
if("from" in kwArgs){
min = kwArgs.from;
h.useMin = false;
}
if("to" in kwArgs){
max = kwArgs.to;
h.useMax = false;
}
// check for erroneous condition
if(max <= min){
return calcTicks(min, max, h, 0, 0, 0, span); // Object
}
if(!delta){
delta = max - min;
}
var mag = Math.floor(Math.log(delta) / Math.LN10),
major = kwArgs && ("majorTickStep" in kwArgs) ? kwArgs.majorTickStep : Math.pow(10, mag),
minor = 0, micro = 0, ticks;
// calculate minor ticks
if(kwArgs && ("minorTickStep" in kwArgs)){
minor = kwArgs.minorTickStep;
}else{
do{
minor = major / 10;
if(!h.natural || minor > 0.9){
ticks = calcTicks(min, max, h, major, minor, 0, span);
if(ticks.bounds.scale * ticks.minor.tick > minorDelta){ break; }
}
minor = major / 5;
if(!h.natural || minor > 0.9){
ticks = calcTicks(min, max, h, major, minor, 0, span);
if(ticks.bounds.scale * ticks.minor.tick > minorDelta){ break; }
}
minor = major / 2;
if(!h.natural || minor > 0.9){
ticks = calcTicks(min, max, h, major, minor, 0, span);
if(ticks.bounds.scale * ticks.minor.tick > minorDelta){ break; }
}
return calcTicks(min, max, h, major, 0, 0, span); // Object
}while(false);
}
// calculate micro ticks
if(kwArgs && ("microTickStep" in kwArgs)){
micro = kwArgs.microTickStep;
ticks = calcTicks(min, max, h, major, minor, micro, span);
}else{
do{
micro = minor / 10;
if(!h.natural || micro > 0.9){
ticks = calcTicks(min, max, h, major, minor, micro, span);
if(ticks.bounds.scale * ticks.micro.tick > deltaLimit){ break; }
}
micro = minor / 5;
if(!h.natural || micro > 0.9){
ticks = calcTicks(min, max, h, major, minor, micro, span);
if(ticks.bounds.scale * ticks.micro.tick > deltaLimit){ break; }
}
micro = minor / 2;
if(!h.natural || micro > 0.9){
ticks = calcTicks(min, max, h, major, minor, micro, span);
if(ticks.bounds.scale * ticks.micro.tick > deltaLimit){ break; }
}
micro = 0;
}while(false);
}
return micro ? ticks : calcTicks(min, max, h, major, minor, 0, span); // Object
},
buildTicks: function(/*Object*/ scaler, /*Object*/ kwArgs){
var step, next, tick,
nextMajor = scaler.major.start,
nextMinor = scaler.minor.start,
nextMicro = scaler.micro.start;
if(kwArgs.microTicks && scaler.micro.tick){
step = scaler.micro.tick, next = nextMicro;
}else if(kwArgs.minorTicks && scaler.minor.tick){
step = scaler.minor.tick, next = nextMinor;
}else if(scaler.major.tick){
step = scaler.major.tick, next = nextMajor;
}else{
// no ticks
return null;
}
// make sure that we have finite bounds
var revScale = 1 / scaler.bounds.scale;
if(scaler.bounds.to <= scaler.bounds.from || isNaN(revScale) || !isFinite(revScale) ||
step <= 0 || isNaN(step) || !isFinite(step)){
// no ticks
return null;
}
// loop over all ticks
var majorTicks = [], minorTicks = [], microTicks = [];
while(next <= scaler.bounds.to + revScale){
if(Math.abs(nextMajor - next) < step / 2){
// major tick
tick = {value: nextMajor};
if(kwArgs.majorLabels){
tick.label = getLabel(nextMajor, scaler.major.prec, kwArgs);
}
majorTicks.push(tick);
nextMajor += scaler.major.tick;
nextMinor += scaler.minor.tick;
nextMicro += scaler.micro.tick;
}else if(Math.abs(nextMinor - next) < step / 2){
// minor tick
if(kwArgs.minorTicks){
tick = {value: nextMinor};
if(kwArgs.minorLabels && (scaler.minMinorStep <= scaler.minor.tick * scaler.bounds.scale)){
tick.label = getLabel(nextMinor, scaler.minor.prec, kwArgs);
}
minorTicks.push(tick);
}
nextMinor += scaler.minor.tick;
nextMicro += scaler.micro.tick;
}else{
// micro tick
if(kwArgs.microTicks){
microTicks.push({value: nextMicro});
}
nextMicro += scaler.micro.tick;
}
next += step;
}
return {major: majorTicks, minor: minorTicks, micro: microTicks}; // Object
},
getTransformerFromModel: function(/*Object*/ scaler){
var offset = scaler.bounds.from, scale = scaler.bounds.scale;
return function(x){ return (x - offset) * scale; }; // Function
},
getTransformerFromPlot: function(/*Object*/ scaler){
var offset = scaler.bounds.from, scale = scaler.bounds.scale;
return function(x){ return x / scale + offset; }; // Function
}
});
});
},
'dojox/charting/plot2d/Default':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/array", "dojo/has",
"./CartesianBase", "./_PlotEvents", "./common", "dojox/lang/functional", "dojox/lang/utils", "dojox/gfx/fx"],
function(lang, declare, arr, has, CartesianBase, _PlotEvents, dc, df, du, fx){
/*=====
declare("dojox.charting.plot2d.__DefaultCtorArgs", dojox.charting.plot2d.__CartesianCtorArgs, {
// summary:
// The arguments used for any/most plots.
// lines: Boolean?
// Whether or not to draw lines on this plot. Defaults to true.
lines: true,
// areas: Boolean?
// Whether or not to draw areas on this plot. Defaults to false.
areas: false,
// markers: Boolean?
// Whether or not to draw markers at data points on this plot. Default is false.
markers: false,
// tension: Number|String?
// Whether or not to apply 'tensioning' to the lines on this chart.
// Options include a number, "X", "x", or "S"; if a number is used, the
// simpler bezier curve calculations are used to draw the lines. If X, x or S
// is used, the more accurate smoothing algorithm is used.
tension: "",
// animate: Boolean?|Number?
// Whether or not to animate the chart to place. When a Number it specifies the duration of the animation.
// Default is false.
animate: false,
// stroke: dojox.gfx.Stroke?
// An optional stroke to use for any series on the plot.
stroke: {},
// outline: dojox.gfx.Stroke?
// An optional stroke used to outline any series on the plot.
outline: {},
// shadow: dojox.gfx.Stroke?
// An optional stroke to use to draw any shadows for a series on a plot.
shadow: {},
// fill: dojox.gfx.Fill?
// Any fill to be used for elements on the plot (such as areas).
fill: {},
// filter: dojox.gfx.Filter?
// An SVG filter to be used for elements on the plot. gfx SVG renderer must be used and dojox/gfx/svgext must
// be required for this to work.
filter: {},
// styleFunc: Function?
// A function that returns a styling object for the a given data item.
styleFunc: null,
// font: String?
// A font definition to be used for labels and other text-based elements on the plot.
font: "",
// fontColor: String|dojo.Color?
// The color to be used for any text-based elements on the plot.
fontColor: "",
// markerStroke: dojo.gfx.Stroke?
// An optional stroke to use for any markers on the plot.
markerStroke: {},
// markerOutline: dojo.gfx.Stroke?
// An optional outline to use for any markers on the plot.
markerOutline: {},
// markerShadow: dojo.gfx.Stroke?
// An optional shadow to use for any markers on the plot.
markerShadow: {},
// markerFill: dojo.gfx.Fill?
// An optional fill to use for any markers on the plot.
markerFill: {},
// markerFont: String?
// An optional font definition to use for any markers on the plot.
markerFont: "",
// markerFontColor: String|dojo.Color?
// An optional color to use for any marker text on the plot.
markerFontColor: "",
// enableCache: Boolean?
// Whether the markers are cached from one rendering to another. This improves the rendering performance of
// successive rendering but penalize the first rendering. Default false.
enableCache: false,
// interpolate: Boolean?
// Whether when there is a null data point in the data the plot interpolates it or if the lines is split at that
// point. Default false.
interpolate: false,
// zeroLine: Number?
// Zero line for an area fill. Should be a numeric value in user coordinates.
// Default: the lowest value on a vertical axis.
zeroLine: 0
});
=====*/
var DEFAULT_ANIMATION_LENGTH = 1200; // in ms
return declare("dojox.charting.plot2d.Default", [CartesianBase, _PlotEvents], {
// defaultParams:
// The default parameters of this plot.
defaultParams: {
lines: true, // draw lines
areas: false, // draw areas
markers: false, // draw markers
tension: "", // draw curved lines (tension is "X", "x", or "S")
animate: false, // animate chart to place
enableCache: false,
interpolate: false
},
// optionalParams:
// The optional parameters of this plot.
optionalParams: {
// theme component
stroke: {},
outline: {},
shadow: {},
fill: {},
filter: {},
styleFunc: null,
font: "",
fontColor: "",
marker: "",
markerStroke: {},
markerOutline: {},
markerShadow: {},
markerFill: {},
markerFont: "",
markerFontColor: "",
zeroLine: 0
},
constructor: function(chart, kwArgs){
// summary:
// Return a new plot.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__DefaultCtorArgs?
// An optional arguments object to help define this plot.
this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
// animation properties
this.animate = this.opt.animate;
},
createPath: function(run, creator, params){
var path;
if(this.opt.enableCache && run._pathFreePool.length > 0){
path = run._pathFreePool.pop();
path.setShape(params);
// was cleared, add it back
creator.add(path);
}else{
path = creator.createPath(params);
}
if(this.opt.enableCache){
run._pathUsePool.push(path);
}
return path;
},
buildSegments: function(i, indexed){
var run = this.series[i],
min = indexed?Math.max(0, Math.floor(this._hScaler.bounds.from - 1)):0,
max = indexed?Math.min(run.data.length, Math.ceil(this._hScaler.bounds.to)):run.data.length,
rseg = null, segments = [];
// split the run data into dense segments (each containing no nulls)
// except if interpolates is false in which case ignore null between valid data
for(var j = min; j < max; j++){
if(!this.isNullValue(run.data[j])){
if(!rseg){
rseg = [];
segments.push({index: j, rseg: rseg});
}
rseg.push((indexed && run.data[j].hasOwnProperty("y"))?run.data[j].y:run.data[j]);
}else{
if(!this.opt.interpolate || indexed){
// we break the line only if not interpolating or if we have indexed data
rseg = null;
}
}
}
return segments;
},
render: function(dim, offsets){
// summary:
// Render/draw everything on this plot.
// dim: Object
// An object of the form { width, height }
// offsets: Object
// An object of the form { l, r, t, b }
// returns: dojox/charting/plot2d/Default
// A reference to this plot for functional chaining.
// make sure all the series is not modified
if(this.zoom && !this.isDataDirty()){
return this.performZoom(dim, offsets);
}
this.resetEvents();
this.dirty = this.isDirty();
var s;
if(this.dirty){
arr.forEach(this.series, dc.purgeGroup);
this._eventSeries = {};
this.cleanGroup();
this.getGroup().setTransform(null);
s = this.getGroup();
df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
}
var t = this.chart.theme, stroke, outline, events = this.events();
for(var i = 0; i < this.series.length; i++){
var run = this.series[i];
if(!this.dirty && !run.dirty){
t.skip();
this._reconnectEvents(run.name);
continue;
}
run.cleanGroup();
if(this.opt.enableCache){
run._pathFreePool = (run._pathFreePool?run._pathFreePool:[]).concat(run._pathUsePool?run._pathUsePool:[]);
run._pathUsePool = [];
}
if(!run.data.length){
run.dirty = false;
t.skip();
continue;
}
var theme = t.next(this.opt.areas ? "area" : "line", [this.opt, run], true),
lpoly,
ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
eventSeries = this._eventSeries[run.name] = new Array(run.data.length);
s = run.group;
if(run.hidden){
if(this.opt.lines){
run.dyn.stroke = theme.series.stroke;
}
if (run.markers || (run.markers === undefined && this.opt.markers)) {
run.dyn.markerFill = theme.marker.fill;
run.dyn.markerStroke = theme.marker.stroke;
run.dyn.marker = theme.symbol;
}
if(this.opt.areas){
run.dyn.fill = theme.series.fill;
}
continue;
}
// optim works only for index based case
var indexed = arr.some(run.data, function(item){
return typeof item == "number" || (item && !item.hasOwnProperty("x"));
});
var rsegments = this.buildSegments(i, indexed);
for(var seg = 0; seg < rsegments.length; seg++){
var rsegment = rsegments[seg];
if(indexed){
lpoly = arr.map(rsegment.rseg, function(v, i){
return {
x: ht(i + rsegment.index + 1) + offsets.l,
y: dim.height - offsets.b - vt(v),
data: v
};
}, this);
}else{
lpoly = arr.map(rsegment.rseg, function(v){
return {
x: ht(v.x) + offsets.l,
y: dim.height - offsets.b - vt(v.y),
data: v
};
}, this);
}
// if we are indexed & we interpolate we need to put all the segments as a single one now
if(indexed && this.opt.interpolate){
while(seg < rsegments.length) {
seg++;
rsegment = rsegments[seg];
if(rsegment){
lpoly = lpoly.concat(arr.map(rsegment.rseg, function(v, i){
return {
x: ht(i + rsegment.index + 1) + offsets.l,
y: dim.height - offsets.b - vt(v),
data: v
};
}, this));
}
}
}
var lpath = this.opt.tension ? dc.curve(lpoly, this.opt.tension) : "";
if(this.opt.areas && lpoly.length > 1){
var fill = this._plotFill(theme.series.fill, dim, offsets), apoly = lang.clone(lpoly),
zeroLine = dim.height - offsets.b;
if(!isNaN(this.opt.zeroLine)){
zeroLine = Math.max(offsets.t, Math.min(dim.height - offsets.b - vt(this.opt.zeroLine), zeroLine));
}
if(this.opt.tension){
var apath = "L" + apoly[apoly.length-1].x + "," + zeroLine +
" L" + apoly[0].x + "," + zeroLine +
" L" + apoly[0].x + "," + apoly[0].y;
run.dyn.fill = s.createPath(lpath + " " + apath).setFill(fill).getFill();
} else {
apoly.push({x: lpoly[lpoly.length - 1].x, y: zeroLine});
apoly.push({x: lpoly[0].x, y: zeroLine});
apoly.push(lpoly[0]);
run.dyn.fill = s.createPolyline(apoly).setFill(fill).getFill();
}
}
if(this.opt.lines || this.opt.markers){
// need a stroke
stroke = theme.series.stroke;
if(theme.series.outline){
outline = run.dyn.outline = dc.makeStroke(theme.series.outline);
outline.width = 2 * outline.width + (stroke && stroke.width || 0);
}
}
if(this.opt.markers){
run.dyn.marker = theme.symbol;
}
var frontMarkers = null, outlineMarkers = null, shadowMarkers = null;
if(stroke && theme.series.shadow && lpoly.length > 1){
var shadow = theme.series.shadow,
spoly = arr.map(lpoly, function(c){
return {x: c.x + shadow.dx, y: c.y + shadow.dy};
});
if(this.opt.lines){
if(this.opt.tension){
run.dyn.shadow = s.createPath(dc.curve(spoly, this.opt.tension)).setStroke(shadow).getStroke();
} else {
run.dyn.shadow = s.createPolyline(spoly).setStroke(shadow).getStroke();
}
}
if(this.opt.markers && theme.marker.shadow){
shadow = theme.marker.shadow;
shadowMarkers = arr.map(spoly, function(c){
return this.createPath(run, s, "M" + c.x + " " + c.y + " " + theme.symbol).
setStroke(shadow).setFill(shadow.color);
}, this);
}
}
if(this.opt.lines && lpoly.length > 1){
var shape;
if(outline){
if(this.opt.tension){
run.dyn.outline = s.createPath(lpath).setStroke(outline).getStroke();
} else {
run.dyn.outline = s.createPolyline(lpoly).setStroke(outline).getStroke();
}
}
if(this.opt.tension){
run.dyn.stroke = (shape = s.createPath(lpath)).setStroke(stroke).getStroke();
} else {
run.dyn.stroke = (shape = s.createPolyline(lpoly)).setStroke(stroke).getStroke();
}
if(shape.setFilter && theme.series.filter){
shape.setFilter(theme.series.filter);
}
}
var markerBox = null;
if(this.opt.markers){
var markerTheme = theme;
frontMarkers = new Array(lpoly.length);
outlineMarkers = new Array(lpoly.length);
outline = null;
if(markerTheme.marker.outline){
outline = dc.makeStroke(markerTheme.marker.outline);
outline.width = 2 * outline.width + (markerTheme.marker.stroke ? markerTheme.marker.stroke.width : 0);
}
arr.forEach(lpoly, function(c, i){
if(this.opt.styleFunc || typeof c.data != "number"){
var tMixin = typeof c.data != "number" ? [c.data] : [];
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(c.data));
}
markerTheme = t.addMixin(theme, "marker", tMixin, true);
}else{
markerTheme = t.post(theme, "marker");
}
var path = "M" + c.x + " " + c.y + " " + markerTheme.symbol;
if(outline){
outlineMarkers[i] = this.createPath(run, s, path).setStroke(outline);
}
frontMarkers[i] = this.createPath(run, s, path).setStroke(markerTheme.marker.stroke).setFill(markerTheme.marker.fill);
}, this);
run.dyn.markerFill = markerTheme.marker.fill;
run.dyn.markerStroke = markerTheme.marker.stroke;
if(!markerBox && this.opt.labels){
markerBox = frontMarkers[0].getBoundingBox();
}
if(events){
arr.forEach(frontMarkers, function(s, i){
var o = {
element: "marker",
index: i + rsegment.index,
run: run,
shape: s,
outline: outlineMarkers[i] || null,
shadow: shadowMarkers && shadowMarkers[i] || null,
cx: lpoly[i].x,
cy: lpoly[i].y
};
if(indexed){
o.x = i + rsegment.index + 1;
o.y = run.data[i + rsegment.index];
}else{
o.x = rsegment.rseg[i].x;
o.y = run.data[i + rsegment.index].y;
}
this._connectEvents(o);
eventSeries[i + rsegment.index] = o;
}, this);
}else{
delete this._eventSeries[run.name];
}
}
if(this.opt.labels){
var labelBoxW = markerBox?markerBox.width:2;
var labelBoxH = markerBox?markerBox.height:2;
arr.forEach(lpoly, function(c, i){
if(this.opt.styleFunc || typeof c.data != "number"){
var tMixin = typeof c.data != "number" ? [c.data] : [];
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(c.data));
}
markerTheme = t.addMixin(theme, "marker", tMixin, true);
}else{
markerTheme = t.post(theme, "marker");
}
this.createLabel(s, rsegment.rseg[i], { x: c.x - labelBoxW / 2, y: c.y - labelBoxH / 2,
width: labelBoxW , height: labelBoxH }, markerTheme);
}, this);
}
}
run.dirty = false;
}
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
if(this.animate){
// grow from the bottom
var plotGroup = this.getGroup();
fx.animateTransform(lang.delegate({
shape: plotGroup,
duration: DEFAULT_ANIMATION_LENGTH,
transform:[
{name:"translate", start: [0, dim.height - offsets.b], end: [0, 0]},
{name:"scale", start: [1, 0], end:[1, 1]},
{name:"original"}
]
}, this.animate)).play();
}
this.dirty = false;
return this; // dojox/charting/plot2d/Default
}
});
});
},
'dojox/charting/plot2d/CartesianBase':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/connect", "dojo/has",
"./Base", "../scaler/primitive", "dojox/gfx", "dojox/gfx/fx", "dojox/lang/utils"],
function(lang, declare, hub, has, Base, primitive, gfx, fx, du){
/*=====
declare("dojox.charting.plot2d.__CartesianCtorArgs", dojox.charting.plot2d.__PlotCtorArgs, {
// hAxis: String?
// The horizontal axis name.
hAxis: "x",
// vAxis: String?
// The vertical axis name
vAxis: "y",
// labels: Boolean?
// For plots that support labels, whether or not to draw labels for each data item. Default is false.
labels: false,
// fixed: Boolean?
// Whether a fixed precision must be applied to data values for display. Default is true.
fixed: true,
// precision: Number?
// The precision at which to round data values for display. Default is 0.
precision: 1,
// labelOffset: Number?
// The amount in pixels by which to offset labels when using "outside" labelStyle. Default is 10.
labelOffset: 10,
// labelStyle: String?
// Options as to where to draw labels. This must be either "inside" or "outside". By default
// the labels are drawn "inside" the shape representing the data point (a column rectangle for a Columns plot
// or a marker for a Line plot for instance). When "outside" is used the labels are drawn above the data point shape.
labelStyle: "inside",
// htmlLabels: Boolean?
// Whether or not to use HTML to render slice labels. Default is true.
htmlLabels: true,
// omitLabels: Boolean?
// Whether labels that do not fit in an item render are omitted or not. This applies only when labelStyle
// is "inside". Default is false.
omitLabels: true,
// labelFunc: Function?
// An optional function to use to compute label text. It takes precedence over
// the default text when available.
// | function labelFunc(value, fixed, precision) {}
// `value` is the data value to display
// `fixed` is true if fixed precision must be applied.
// `precision` is the requested precision to be applied.
labelFunc: null
});
=====*/
var alwaysFalse = function(){ return false; }
return declare("dojox.charting.plot2d.CartesianBase", Base, {
baseParams: {
hAxis: "x",
vAxis: "y",
labels: false,
labelOffset: 10,
fixed: true,
precision: 1,
labelStyle: "inside",
htmlLabels: true, // use HTML to draw labels
omitLabels: true,
labelFunc: null
},
// summary:
// Base class for cartesian plot types.
constructor: function(chart, kwArgs){
// summary:
// Create a cartesian base plot for cartesian charts.
// chart: dojox/chart/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__CartesianCtorArgs?
// An optional arguments object to help define the plot.
this.axes = ["hAxis", "vAxis"];
this.zoom = null;
this.zoomQueue = []; // zooming action task queue
this.lastWindow = {vscale: 1, hscale: 1, xoffset: 0, yoffset: 0};
this.hAxis = (kwArgs && kwArgs.hAxis) || "x";
this.vAxis = (kwArgs && kwArgs.vAxis) || "y";
this.series = [];
this.opt = lang.clone(this.baseParams);
du.updateWithObject(this.opt, kwArgs);
},
clear: function(){
// summary:
// Clear out all of the information tied to this plot.
// returns: dojox/charting/plot2d/CartesianBase
// A reference to this plot for functional chaining.
this.inherited(arguments);
this._hAxis = null;
this._vAxis = null;
return this; // dojox/charting/plot2d/CartesianBase
},
cleanGroup: function(creator, noClip){
this.inherited(arguments);
if(!noClip && this.chart._nativeClip){
var offsets = this.chart.offsets, dim = this.chart.dim;
var w = Math.max(0, dim.width - offsets.l - offsets.r),
h = Math.max(0, dim.height - offsets.t - offsets.b);
this.group.setClip({ x: offsets.l, y: offsets.t, width: w, height: h });
if(!this._clippedGroup){
this._clippedGroup = this.group.createGroup();
}
}
},
purgeGroup: function(){
this.inherited(arguments);
this._clippedGroup = null;
},
getGroup: function(){
return this._clippedGroup || this.group;
},
setAxis: function(axis){
// summary:
// Set an axis for this plot.
// axis: dojox/charting/axis2d/Base
// The axis to set.
// returns: dojox/charting/plot2d/CartesianBase
// A reference to this plot for functional chaining.
if(axis){
this[axis.vertical ? "_vAxis" : "_hAxis"] = axis;
}
return this; // dojox/charting/plot2d/CartesianBase
},
toPage: function(coord){
// summary:
// Compute page coordinates from plot axis data coordinates.
// coord: Object?
// The coordinates in plot axis data coordinate space. For cartesian charts that is of the following form:
// `{ hAxisName: 50, vAxisName: 200 }`
// If not provided return the transform method instead of the result of the transformation.
// returns: Object
// The resulting page pixel coordinates. That is of the following form:
// `{ x: 50, y: 200 }`
var ah = this._hAxis, av = this._vAxis,
sh = ah.getScaler(), sv = av.getScaler(),
th = sh.scaler.getTransformerFromModel(sh),
tv = sv.scaler.getTransformerFromModel(sv),
c = this.chart.getCoords(),
o = this.chart.offsets, dim = this.chart.dim;
var t = function(coord){
var r = {};
r.x = th(coord[ah.name]) + c.x + o.l;
r.y = c.y + dim.height - o.b - tv(coord[av.name]);
return r;
};
// if no coord return the function so that we can capture the current transforms
// and reuse them later on
return coord?t(coord):t; // Object
},
toData: function(coord){
// summary:
// Compute plot axis data coordinates from page coordinates.
// coord: Object
// The pixel coordinate in page coordinate space. That is of the following form:
// `{ x: 50, y: 200 }`
// If not provided return the tranform method instead of the result of the transformation.
// returns: Object
// The resulting plot axis data coordinates. For cartesian charts that is of the following form:
// `{ hAxisName: 50, vAxisName: 200 }`
var ah = this._hAxis, av = this._vAxis,
sh = ah.getScaler(), sv = av.getScaler(),
th = sh.scaler.getTransformerFromPlot(sh),
tv = sv.scaler.getTransformerFromPlot(sv),
c = this.chart.getCoords(),
o = this.chart.offsets, dim = this.chart.dim;
var t = function(coord){
var r = {};
r[ah.name] = th(coord.x - c.x - o.l);
r[av.name] = tv(c.y + dim.height - coord.y - o.b);
return r;
};
// if no coord return the function so that we can capture the current transforms
// and reuse them later on
return coord?t(coord):t; // Object
},
isDirty: function(){
// summary:
// Returns whether or not this plot needs to be rendered.
// returns: Boolean
// The state of the plot.
return this.dirty || this._hAxis && this._hAxis.dirty || this._vAxis && this._vAxis.dirty; // Boolean
},
createLabel: function(group, value, bbox, theme){
if(this.opt.labels){
var x, y, label = this.opt.labelFunc?this.opt.labelFunc.apply(this, [value, this.opt.fixed, this.opt.precision]):
this._getLabel(isNaN(value.y)?value:value.y);
if(this.opt.labelStyle == "inside"){
var lbox = gfx._base._getTextBox(label, { font: theme.series.font } );
x = bbox.x + bbox.width / 2;
y = bbox.y + bbox.height / 2 + lbox.h / 4;
if(lbox.w > bbox.width || lbox.h > bbox.height){
return;
}
}else{
x = bbox.x + bbox.width / 2;
y = bbox.y - this.opt.labelOffset;
}
this.renderLabel(group, x, y, label, theme, this.opt.labelStyle == "inside");
}
},
performZoom: function(dim, offsets){
// summary:
// Create/alter any zooming windows on this plot.
// dim: Object
// An object of the form { width, height }.
// offsets: Object
// An object of the form { l, r, t, b }.
// returns: dojox/charting/plot2d/CartesianBase
// A reference to this plot for functional chaining.
// get current zooming various
var vs = this._vAxis.scale || 1,
hs = this._hAxis.scale || 1,
vOffset = dim.height - offsets.b,
hBounds = this._hScaler.bounds,
xOffset = (hBounds.from - hBounds.lower) * hBounds.scale,
vBounds = this._vScaler.bounds,
yOffset = (vBounds.from - vBounds.lower) * vBounds.scale,
// get incremental zooming various
rVScale = vs / this.lastWindow.vscale,
rHScale = hs / this.lastWindow.hscale,
rXOffset = (this.lastWindow.xoffset - xOffset)/
((this.lastWindow.hscale == 1)? hs : this.lastWindow.hscale),
rYOffset = (yOffset - this.lastWindow.yoffset)/
((this.lastWindow.vscale == 1)? vs : this.lastWindow.vscale),
shape = this.getGroup(),
anim = fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform:[
{name:"translate", start:[0, 0], end: [offsets.l * (1 - rHScale), vOffset * (1 - rVScale)]},
{name:"scale", start:[1, 1], end: [rHScale, rVScale]},
{name:"original"},
{name:"translate", start: [0, 0], end: [rXOffset, rYOffset]}
]}, this.zoom));
lang.mixin(this.lastWindow, {vscale: vs, hscale: hs, xoffset: xOffset, yoffset: yOffset});
//add anim to zooming action queue,
//in order to avoid several zooming action happened at the same time
this.zoomQueue.push(anim);
//perform each anim one by one in zoomQueue
hub.connect(anim, "onEnd", this, function(){
this.zoom = null;
this.zoomQueue.shift();
if(this.zoomQueue.length > 0){
this.zoomQueue[0].play();
}
});
if(this.zoomQueue.length == 1){
this.zoomQueue[0].play();
}
return this; // dojox/charting/plot2d/CartesianBase
},
initializeScalers: function(dim, stats){
// summary:
// Initializes scalers using attached axes.
// dim: Object
// Size of a plot area in pixels as {width, height}.
// stats: Object
// Min/max of data in both directions as {hmin, hmax, vmin, vmax}.
// returns: dojox/charting/plot2d/CartesianBase
// A reference to this plot for functional chaining.
if(this._hAxis){
if(!this._hAxis.initialized()){
this._hAxis.calculate(stats.hmin, stats.hmax, dim.width);
}
this._hScaler = this._hAxis.getScaler();
}else{
this._hScaler = primitive.buildScaler(stats.hmin, stats.hmax, dim.width);
}
if(this._vAxis){
if(!this._vAxis.initialized()){
this._vAxis.calculate(stats.vmin, stats.vmax, dim.height);
}
this._vScaler = this._vAxis.getScaler();
}else{
this._vScaler = primitive.buildScaler(stats.vmin, stats.vmax, dim.height);
}
return this; // dojox/charting/plot2d/CartesianBase
},
isNullValue: function(value){
if(value === null || typeof value == "undefined"){
return true;
}
var h = this._hAxis ? this._hAxis.isNullValue : alwaysFalse,
v = this._vAxis ? this._vAxis.isNullValue : alwaysFalse;
if(typeof value == "number"){
return h(1) || v(value);
}
return h(isNaN(value.x) ? 1 : value.x) || value.y === null || v(value.y);
}
});
});
},
'dojox/charting/plot2d/Base':function(){
define(["dojo/_base/declare", "dojo/_base/array", "dojo/_base/lang", "dojox/gfx",
"../Element", "./common", "../axis2d/common", "dojo/has"],
function(declare, arr, lang, gfx, Element, common, ac, has){
/*=====
dojox.charting.plot2d.__PlotCtorArgs = {
// summary:
// The base keyword arguments object for plot constructors.
// Note that the parameters for this may change based on the
// specific plot type (see the corresponding plot type for
// details).
// tooltipFunc: Function?
// An optional function used to compute tooltip text for this plot. It takes precedence over
// the default function when available.
// | function tooltipFunc(o) { return "text"; }
// `o`is the event object that triggered the tooltip.
tooltipFunc: null
};
=====*/
var Base = declare("dojox.charting.plot2d.Base", Element, {
// summary:
// Base class for all plot types.
constructor: function(chart, kwArgs){
// summary:
// Create a base plot for charting.
// chart: dojox/chart/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__PlotCtorArgs?
// An optional arguments object to help define the plot.
// TODO does not work in markup
if(kwArgs && kwArgs.tooltipFunc){
this.tooltipFunc = kwArgs.tooltipFunc;
}
},
clear: function(){
// summary:
// Clear out all of the information tied to this plot.
// returns: dojox.charting.plot2d.Base
// A reference to this plot for functional chaining.
this.series = [];
this.dirty = true;
return this; // dojox/charting/plot2d/Base
},
setAxis: function(axis){
// summary:
// Set an axis for this plot.
// axis: dojox.charting.axis2d.Base
// The axis to set.
// returns: dojox/charting/plot2d/Base
// A reference to this plot for functional chaining.
return this; // dojox/charting/plot2d/Base
},
assignAxes: function(axes){
// summary:
// From an array of axes pick the ones that correspond to this plot and
// assign them to the plot using setAxis method.
// axes: Array
// An array of dojox/charting/axis2d/Base
// tags:
// protected
arr.forEach(this.axes, function(axis){
if(this[axis]){
this.setAxis(axes[this[axis]]);
}
}, this);
},
addSeries: function(run){
// summary:
// Add a data series to this plot.
// run: dojox.charting.Series
// The series to be added.
// returns: dojox/charting/plot2d/Base
// A reference to this plot for functional chaining.
this.series.push(run);
return this; // dojox/charting/plot2d/Base
},
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
return common.collectSimpleStats(this.series, lang.hitch(this, "isNullValue"));
},
calculateAxes: function(dim){
// summary:
// Stub function for running the axis calculations (deprecated).
// dim: Object
// An object of the form { width, height }
// returns: dojox/charting/plot2d/Base
// A reference to this plot for functional chaining.
this.initializeScalers(dim, this.getSeriesStats());
return this; // dojox/charting/plot2d/Base
},
initializeScalers: function(){
// summary:
// Does nothing.
return this;
},
isDataDirty: function(){
// summary:
// Returns whether or not any of this plot's data series need to be rendered.
// returns: Boolean
// Flag indicating if any of this plot's series are invalid and need rendering.
return arr.some(this.series, function(item){ return item.dirty; }); // Boolean
},
render: function(dim, offsets){
// summary:
// Render the plot on the chart.
// dim: Object
// An object of the form { width, height }.
// offsets: Object
// An object of the form { l, r, t, b }.
// returns: dojox/charting/plot2d/Base
// A reference to this plot for functional chaining.
return this; // dojox/charting/plot2d/Base
},
renderLabel: function(group, x, y, label, theme, block, align){
var elem = ac.createText[this.opt.htmlLabels && gfx.renderer != "vml" ? "html" : "gfx"]
(this.chart, group, x, y, align?align:"middle", label, theme.series.font, theme.series.fontColor);
// if the label is inside we need to avoid catching events on it this would prevent action on
// chart elements
if(block){
// TODO this won't work in IE neither in VML nor in HTML
// a solution would be to catch the event on the label and refire it to the element
// possibly using elementFromPoint or having it already available
if(this.opt.htmlLabels && gfx.renderer != "vml"){
// we have HTML labels, let's use pointEvents on the HTML node
elem.style.pointerEvents = "none";
}else if(elem.rawNode){
// we have SVG labels, let's use pointerEvents on the SVG or VML node
elem.rawNode.style.pointerEvents = "none";
}
// else we have Canvas, we need do nothing, as Canvas text won't catch events
}
if(this.opt.htmlLabels && gfx.renderer != "vml"){
this.htmlElements.push(elem);
}
return elem;
},
getRequiredColors: function(){
// summary:
// Get how many data series we have, so we know how many colors to use.
// returns: Number
// The number of colors needed.
return this.series.length; // Number
},
_getLabel: function(number){
return common.getLabel(number, this.opt.fixed, this.opt.precision);
}
});
if(has("dojo-bidi")){
Base.extend({
_checkOrientation: function(group, dim, offsets){
this.chart.applyMirroring(this.group, dim, offsets);
}
});
}
return Base;
});
},
'dojox/charting/scaler/primitive':function(){
define(["dojo/_base/lang"],
function(lang){
var primitive = lang.getObject("dojox.charting.scaler.primitive", true);
return lang.mixin(primitive, {
buildScaler: function(/*Number*/ min, /*Number*/ max, /*Number*/ span, /*Object*/ kwArgs){
if(min == max){
// artificially extend bounds
min -= 0.5;
max += 0.5;
// now the line will be centered
}
return {
bounds: {
lower: min,
upper: max,
from: min,
to: max,
scale: span / (max - min),
span: span
},
scaler: primitive
};
},
buildTicks: function(/*Object*/ scaler, /*Object*/ kwArgs){
return {major: [], minor: [], micro: []}; // Object
},
getTransformerFromModel: function(/*Object*/ scaler){
var offset = scaler.bounds.from, scale = scaler.bounds.scale;
return function(x){ return (x - offset) * scale; }; // Function
},
getTransformerFromPlot: function(/*Object*/ scaler){
var offset = scaler.bounds.from, scale = scaler.bounds.scale;
return function(x){ return x / scale + offset; }; // Function
}
});
});
},
'dojox/gfx/fx':function(){
define(["dojo/_base/lang", "./_base", "./matrix", "dojo/_base/Color", "dojo/_base/array", "dojo/_base/fx", "dojo/_base/connect", "dojo/sniff"],
function(lang, g, m, Color, arr, fx, Hub, has){
var fxg = g.fx = {};
// Generic interpolators. Should they be moved to dojox.fx?
function InterpolNumber(start, end){
this.start = start, this.end = end;
}
InterpolNumber.prototype.getValue = function(r){
return (this.end - this.start) * r + this.start;
};
function InterpolUnit(start, end, units){
this.start = start, this.end = end;
this.units = units;
}
InterpolUnit.prototype.getValue = function(r){
return (this.end - this.start) * r + this.start + this.units;
};
function InterpolColor(start, end){
this.start = start, this.end = end;
this.temp = new Color();
}
InterpolColor.prototype.getValue = function(r){
return Color.blendColors(this.start, this.end, r, this.temp);
};
function InterpolValues(values){
this.values = values;
this.length = values.length;
}
InterpolValues.prototype.getValue = function(r){
return this.values[Math.min(Math.floor(r * this.length), this.length - 1)];
};
function InterpolObject(values, def){
this.values = values;
this.def = def ? def : {};
}
InterpolObject.prototype.getValue = function(r){
var ret = lang.clone(this.def);
for(var i in this.values){
ret[i] = this.values[i].getValue(r);
}
return ret;
};
function InterpolTransform(stack, original){
this.stack = stack;
this.original = original;
}
InterpolTransform.prototype.getValue = function(r){
var ret = [];
arr.forEach(this.stack, function(t){
if(t instanceof m.Matrix2D){
ret.push(t);
return;
}
if(t.name == "original" && this.original){
ret.push(this.original);
return;
}
// Adding support for custom matrices
if(t.name == "matrix"){
if((t.start instanceof m.Matrix2D) && (t.end instanceof m.Matrix2D)){
var transfMatrix = new m.Matrix2D();
for(var p in t.start) {
transfMatrix[p] = (t.end[p] - t.start[p])*r + t.start[p];
}
ret.push(transfMatrix);
}
return;
}
if(!(t.name in m)){ return; }
var f = m[t.name];
if(typeof f != "function"){
// constant
ret.push(f);
return;
}
var val = arr.map(t.start, function(v, i){
return (t.end[i] - v) * r + v;
}),
matrix = f.apply(m, val);
if(matrix instanceof m.Matrix2D){
ret.push(matrix);
}
}, this);
return ret;
};
var transparent = new Color(0, 0, 0, 0);
function getColorInterpol(prop, obj, name, def){
if(prop.values){
return new InterpolValues(prop.values);
}
var value, start, end;
if(prop.start){
start = g.normalizeColor(prop.start);
}else{
start = value = obj ? (name ? obj[name] : obj) : def;
}
if(prop.end){
end = g.normalizeColor(prop.end);
}else{
if(!value){
value = obj ? (name ? obj[name] : obj) : def;
}
end = value;
}
return new InterpolColor(start, end);
}
function getNumberInterpol(prop, obj, name, def){
if(prop.values){
return new InterpolValues(prop.values);
}
var value, start, end;
if(prop.start){
start = prop.start;
}else{
start = value = obj ? obj[name] : def;
}
if(prop.end){
end = prop.end;
}else{
if(typeof value != "number"){
value = obj ? obj[name] : def;
}
end = value;
}
return new InterpolNumber(start, end);
}
fxg.animateStroke = function(/*Object*/ args){
// summary:
// Returns an animation which will change stroke properties over time.
// args:
// an object defining the animation setting.
// example:
// | fxg.animateStroke{{
// | shape: shape,
// | duration: 500,
// | color: {start: "red", end: "green"},
// | width: {end: 15},
// | join: {values: ["miter", "bevel", "round"]}
// | }).play();
if(!args.easing){ args.easing = fx._defaultEasing; }
var anim = new fx.Animation(args), shape = args.shape, stroke;
Hub.connect(anim, "beforeBegin", anim, function(){
stroke = shape.getStroke();
var prop = args.color, values = {}, value, start, end;
if(prop){
values.color = getColorInterpol(prop, stroke, "color", transparent);
}
prop = args.style;
if(prop && prop.values){
values.style = new InterpolValues(prop.values);
}
prop = args.width;
if(prop){
values.width = getNumberInterpol(prop, stroke, "width", 1);
}
prop = args.cap;
if(prop && prop.values){
values.cap = new InterpolValues(prop.values);
}
prop = args.join;
if(prop){
if(prop.values){
values.join = new InterpolValues(prop.values);
}else{
start = prop.start ? prop.start : (stroke && stroke.join || 0);
end = prop.end ? prop.end : (stroke && stroke.join || 0);
if(typeof start == "number" && typeof end == "number"){
values.join = new InterpolNumber(start, end);
}
}
}
this.curve = new InterpolObject(values, stroke);
});
Hub.connect(anim, "onAnimate", shape, "setStroke");
return anim; // dojo.Animation
};
fxg.animateFill = function(/*Object*/ args){
// summary:
// Returns an animation which will change fill color over time.
// Only solid fill color is supported at the moment
// args:
// an object defining the animation setting.
// example:
// | gfx.animateFill{{
// | shape: shape,
// | duration: 500,
// | color: {start: "red", end: "green"}
// | }).play();
if(!args.easing){ args.easing = fx._defaultEasing; }
var anim = new fx.Animation(args), shape = args.shape, fill;
Hub.connect(anim, "beforeBegin", anim, function(){
fill = shape.getFill();
var prop = args.color, values = {};
if(prop){
this.curve = getColorInterpol(prop, fill, "", transparent);
}
});
Hub.connect(anim, "onAnimate", shape, "setFill");
return anim; // dojo.Animation
};
fxg.animateFont = function(/*Object*/ args){
// summary:
// Returns an animation which will change font properties over time.
// args:
// an object defining the animation setting.
// example:
// | gfx.animateFont{{
// | shape: shape,
// | duration: 500,
// | variant: {values: ["normal", "small-caps"]},
// | size: {end: 10, units: "pt"}
// | }).play();
if(!args.easing){ args.easing = fx._defaultEasing; }
var anim = new fx.Animation(args), shape = args.shape, font;
Hub.connect(anim, "beforeBegin", anim, function(){
font = shape.getFont();
var prop = args.style, values = {}, value, start, end;
if(prop && prop.values){
values.style = new InterpolValues(prop.values);
}
prop = args.variant;
if(prop && prop.values){
values.variant = new InterpolValues(prop.values);
}
prop = args.weight;
if(prop && prop.values){
values.weight = new InterpolValues(prop.values);
}
prop = args.family;
if(prop && prop.values){
values.family = new InterpolValues(prop.values);
}
prop = args.size;
if(prop && prop.units){
start = parseFloat(prop.start ? prop.start : (shape.font && shape.font.size || "0"));
end = parseFloat(prop.end ? prop.end : (shape.font && shape.font.size || "0"));
values.size = new InterpolUnit(start, end, prop.units);
}
this.curve = new InterpolObject(values, font);
});
Hub.connect(anim, "onAnimate", shape, "setFont");
return anim; // dojo.Animation
};
fxg.animateTransform = function(/*Object*/ args){
// summary:
// Returns an animation which will change transformation over time.
// args:
// an object defining the animation setting.
// example:
// | gfx.animateTransform{{
// | shape: shape,
// | duration: 500,
// | transform: [
// | {name: "translate", start: [0, 0], end: [200, 200]},
// | {name: "original"}
// | ]
// | }).play();
if(!args.easing){ args.easing = fx._defaultEasing; }
var anim = new fx.Animation(args), shape = args.shape, original;
Hub.connect(anim, "beforeBegin", anim, function(){
original = shape.getTransform();
this.curve = new InterpolTransform(args.transform, original);
});
Hub.connect(anim, "onAnimate", shape, "setTransform");
if(g.renderer === "svg" && (has("ie") >= 9 || has("ff"))){
// fix http://bugs.dojotoolkit.org/ticket/16879
var handlers = [
Hub.connect(anim, "onBegin", anim, function(){
var parent = shape.getParent();
while(parent && parent.getParent){
parent = parent.getParent();
}
if(parent){
shape.__svgContainer = parent.rawNode.parentNode;
shape.__svgRoot = parent.rawNode;
if(shape.__svgRoot && shape.__svgRoot.getAttribute){
shape.__svgWidth = parseInt(shape.__svgRoot.getAttribute("width"), 10);
if(isNaN(shape.__svgWidth)){
delete shape.__svgWidth;
}
}
}
}),
Hub.connect(anim, "onAnimate", anim, function(){
try{
if(shape.__svgContainer){
var ov = shape.__svgContainer.style.visibility;
shape.__svgContainer.style.visibility = "visible";
var pokeNode = shape.__svgContainer.offsetHeight;
shape.__svgContainer.style.visibility = ov;
var width = shape.__svgWidth;
if(!isNaN(width)){
try{
shape.__svgRoot.setAttribute("width", width - 0.000005);
shape.__svgRoot.setAttribute("width", width);
}catch(ignore){}
}
}
}catch(e){}
}),
Hub.connect(anim, "onEnd", anim, function(){
arr.forEach(handlers, Hub.disconnect);
if(shape.__svgContainer){
var sn = shape.__svgContainer;
if(sn.getAttribute("__gotVis") == null){
sn.setAttribute("__gotVis", true);
var ov = shape.__svgContainer.style.visibility;
var root = shape.__svgRoot;
var width = shape.__svgWidth;
sn.style.visibility = "visible";
setTimeout(function(){
try{
sn.style.visibility = ov;
sn.removeAttribute("__gotVis");
sn = null;
try{
if(!isNaN(width)){
root.setAttribute("width", width - 0.000005);
root.setAttribute("width", width);
}
}catch(ignore){}
}catch(e){}
},100);
}
}
delete shape.__svgContainer;
delete shape.__svgRoot;
delete shape.__svgWidth;
})
];
}
return anim; // dojo.Animation
};
return fxg;
});
},
'dojox/charting/plot2d/_PlotEvents':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/_base/connect"],
function(lang, arr, declare, hub){
return declare("dojox.charting.plot2d._PlotEvents", null, {
constructor: function(){
this._shapeEvents = [];
this._eventSeries = {};
},
destroy: function(){
// summary:
// Destroy any internal elements and event handlers.
this.resetEvents();
this.inherited(arguments);
},
plotEvent: function(o){
// summary:
// Stub function for use by specific plots.
// o: Object
// An object intended to represent event parameters.
},
raiseEvent: function(o){
// summary:
// Raises events in predefined order
// o: Object
// An object intended to represent event parameters.
this.plotEvent(o);
var t = lang.delegate(o);
t.originalEvent = o.type;
t.originalPlot = o.plot;
t.type = "onindirect";
arr.forEach(this.chart.stack, function(plot){
if(plot !== this && plot.plotEvent){
t.plot = plot;
plot.plotEvent(t);
}
}, this);
},
connect: function(object, method){
// summary:
// Helper function to connect any object's method to our plotEvent.
// object: Object
// The object to connect to.
// method: String|Function
// The method to fire when our plotEvent is fired.
// returns: Array
// The handle as returned from dojo.connect (see dojo.connect).
this.dirty = true;
return hub.connect(this, "plotEvent", object, method); // Array
},
events: function(){
// summary:
// Find out if any event handlers have been connected to our plotEvent.
// returns: Boolean
// A flag indicating that there are handlers attached.
return !!this.plotEvent.after;
},
resetEvents: function(){
// summary:
// Reset all events attached to our plotEvent (i.e. disconnect).
if(this._shapeEvents.length){
arr.forEach(this._shapeEvents, function(item){
item.shape.disconnect(item.handle);
});
this._shapeEvents = [];
}
this.raiseEvent({type: "onplotreset", plot: this});
},
_connectSingleEvent: function(o, eventName){
this._shapeEvents.push({
shape: o.eventMask,
handle: o.eventMask.connect(eventName, this, function(e){
o.type = eventName;
o.event = e;
this.raiseEvent(o);
o.event = null;
})
});
},
_connectEvents: function(o){
if(o){
o.chart = this.chart;
o.plot = this;
o.hAxis = this.hAxis || null;
o.vAxis = this.vAxis || null;
o.eventMask = o.eventMask || o.shape;
this._connectSingleEvent(o, "onmouseover");
this._connectSingleEvent(o, "onmouseout");
this._connectSingleEvent(o, "onclick");
}
},
_reconnectEvents: function(seriesName){
var a = this._eventSeries[seriesName];
if(a){
arr.forEach(a, this._connectEvents, this);
}
},
fireEvent: function(seriesName, eventName, index, eventObject){
// summary:
// Emulates firing an event for a given data value (specified by
// an index) of a given series.
// seriesName: String
// Series name.
// eventName: String
// Event name to emulate.
// index: Number
// Valid data value index used to raise an event.
// eventObject: Object?
// Optional event object. Especially useful for synthetic events.
// Default: null.
var s = this._eventSeries[seriesName];
if(s && s.length && index < s.length){
var o = s[index];
o.type = eventName;
o.event = eventObject || null;
this.raiseEvent(o);
o.event = null;
}
}
});
});
},
'dojox/charting/plot2d/Lines':function(){
define(["dojo/_base/declare", "./Default"], function(declare, Default){
return declare("dojox.charting.plot2d.Lines", Default, {
// summary:
// A convenience constructor to create a typical line chart.
constructor: function(){
// summary:
// Preset our default plot to be line-based.
this.opt.lines = true;
}
});
});
},
'dojox/charting/plot2d/Areas':function(){
define(["dojo/_base/declare", "./Default"],
function(declare, Default){
return declare("dojox.charting.plot2d.Areas", Default, {
// summary:
// Represents an area chart. See dojox/charting/plot2d/Default for details.
constructor: function(){
// summary:
// The constructor for an Area chart.
this.opt.lines = true;
this.opt.areas = true;
}
});
});
},
'dojox/charting/plot2d/Markers':function(){
define(["dojo/_base/declare", "./Default"], function(declare, Default){
return declare("dojox.charting.plot2d.Markers", Default, {
// summary:
// A convenience plot to draw a line chart with markers.
constructor: function(){
// summary:
// Set up the plot for lines and markers.
this.opt.markers = true;
}
});
});
},
'dojox/charting/plot2d/MarkersOnly':function(){
define(["dojo/_base/declare", "./Default"], function(declare, Default){
return declare("dojox.charting.plot2d.MarkersOnly", Default, {
// summary:
// A convenience object to draw only markers (like a scatter but not quite).
constructor: function(){
// summary:
// Set up our default plot to only have markers and no lines.
this.opt.lines = false;
this.opt.markers = true;
}
});
});
},
'dojox/charting/plot2d/Scatter':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
"dojox/lang/functional", "dojox/lang/utils", "dojox/gfx/fx", "dojox/gfx/gradutils"],
function(lang, arr, declare, has, CartesianBase, _PlotEvents, dc, df, du, fx, gradutils){
return declare("dojox.charting.plot2d.Scatter", [CartesianBase, _PlotEvents], {
// summary:
// A plot object representing a typical scatter chart.
defaultParams: {
shadows: null, // draw shadows
animate: null // animate chart to place
},
optionalParams: {
// theme component
markerStroke: {},
markerOutline: {},
markerShadow: {},
markerFill: {},
markerFont: "",
markerFontColor: "",
styleFunc: null
},
constructor: function(chart, kwArgs){
// summary:
// Create the scatter plot.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__DefaultCtorArgs?
// An optional keyword arguments object to help define this plot's parameters.
this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.animate = this.opt.animate;
},
render: function(dim, offsets){
// summary:
// Run the calculations for any axes for this plot.
// dim: Object
// An object in the form of { width, height }
// offsets: Object
// An object of the form { l, r, t, b}.
// returns: dojox/charting/plot2d/Scatter
// A reference to this plot for functional chaining.
if(this.zoom && !this.isDataDirty()){
return this.performZoom(dim, offsets);
}
this.resetEvents();
this.dirty = this.isDirty();
var s;
if(this.dirty){
arr.forEach(this.series, dc.purgeGroup);
this._eventSeries = {};
this.cleanGroup();
s = this.getGroup();
df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
}
var t = this.chart.theme, events = this.events();
for(var i = 0; i < this.series.length; i++){
var run = this.series[i];
if(!this.dirty && !run.dirty){
t.skip();
this._reconnectEvents(run.name);
continue;
}
run.cleanGroup();
if(!run.data.length){
run.dirty = false;
t.skip();
continue;
}
var theme = t.next("marker", [this.opt, run]), lpoly,
ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler);
if(run.hidden){
run.dyn.marker = theme.symbol;
run.dyn.markerFill = theme.marker.fill;
run.dyn.markerStroke = theme.marker.stroke;
continue;
}
s = run.group;
if(typeof run.data[0] == "number"){
lpoly = arr.map(run.data, function(v, i){
return {
x: ht(i + 1) + offsets.l,
y: dim.height - offsets.b - vt(v)
};
}, this);
}else{
lpoly = arr.map(run.data, function(v, i){
return {
x: ht(v.x) + offsets.l,
y: dim.height - offsets.b - vt(v.y)
};
}, this);
}
var shadowMarkers = new Array(lpoly.length),
frontMarkers = new Array(lpoly.length),
outlineMarkers = new Array(lpoly.length);
arr.forEach(lpoly, function(c, i){
var value = run.data[i], finalTheme;
if(this.opt.styleFunc || typeof value != "number"){
var tMixin = typeof value != "number" ? [value] : [];
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(value));
}
finalTheme = t.addMixin(theme, "marker", tMixin, true);
}else{
finalTheme = t.post(theme, "marker");
}
var path = "M" + c.x + " " + c.y + " " + finalTheme.symbol;
if(finalTheme.marker.shadow){
shadowMarkers[i] = s.createPath("M" + (c.x + finalTheme.marker.shadow.dx) + " " +
(c.y + finalTheme.marker.shadow.dy) + " " + finalTheme.symbol).
setStroke(finalTheme.marker.shadow).setFill(finalTheme.marker.shadow.color);
if(this.animate){
this._animateScatter(shadowMarkers[i], dim.height - offsets.b);
}
}
if(finalTheme.marker.outline){
var outline = dc.makeStroke(finalTheme.marker.outline);
outline.width = 2 * outline.width + (finalTheme.marker.stroke && finalTheme.marker.stroke.width || 0);
outlineMarkers[i] = s.createPath(path).setStroke(outline);
if(this.animate){
this._animateScatter(outlineMarkers[i], dim.height - offsets.b);
}
}
var stroke = dc.makeStroke(finalTheme.marker.stroke),
fill = this._plotFill(finalTheme.marker.fill, dim, offsets);
if(fill && (fill.type === "linear" || fill.type == "radial")){
var color = gradutils.getColor(fill, {x: c.x, y: c.y});
if(stroke){
stroke.color = color;
}
frontMarkers[i] = s.createPath(path).setStroke(stroke).setFill(color);
}else{
frontMarkers[i] = s.createPath(path).setStroke(stroke).setFill(fill);
}
if(this.opt.labels){
var markerBox = frontMarkers[i].getBoundingBox();
this.createLabel(s, value, markerBox, finalTheme);
}
if(this.animate){
this._animateScatter(frontMarkers[i], dim.height - offsets.b);
}
}, this);
if(frontMarkers.length){
run.dyn.marker = theme.symbol;
run.dyn.markerStroke = frontMarkers[frontMarkers.length - 1].getStroke();
run.dyn.markerFill = frontMarkers[frontMarkers.length - 1].getFill();
}
if(events){
var eventSeries = new Array(frontMarkers.length);
arr.forEach(frontMarkers, function(s, i){
var o = {
element: "marker",
index: i,
run: run,
shape: s,
outline: outlineMarkers && outlineMarkers[i] || null,
shadow: shadowMarkers && shadowMarkers[i] || null,
cx: lpoly[i].x,
cy: lpoly[i].y
};
if(typeof run.data[0] == "number"){
o.x = i + 1;
o.y = run.data[i];
}else{
o.x = run.data[i].x;
o.y = run.data[i].y;
}
this._connectEvents(o);
eventSeries[i] = o;
}, this);
this._eventSeries[run.name] = eventSeries;
}else{
delete this._eventSeries[run.name];
}
run.dirty = false;
}
this.dirty = false;
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
return this; // dojox/charting/plot2d/Scatter
},
_animateScatter: function(shape, offset){
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: [0, offset], end: [0, 0]},
{name: "scale", start: [0, 0], end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/Stacked':function(){
define(["dojo/_base/declare", "dojo/_base/lang", "./Default", "./commonStacked"],
function(declare, lang, Default, commonStacked){
return declare("dojox.charting.plot2d.Stacked", Default, {
// summary:
// Like the default plot, Stacked sets up lines, areas and markers
// in a stacked fashion (values on the y axis added to each other)
// as opposed to a direct one.
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
var stats = commonStacked.collectStats(this.series, lang.hitch(this, "isNullValue"));
return stats; // Object
},
buildSegments: function(i, indexed){
var run = this.series[i],
min = indexed?Math.max(0, Math.floor(this._hScaler.bounds.from - 1)):0,
max = indexed?Math.min(run.data.length-1, Math.ceil(this._hScaler.bounds.to)):run.data.length-1,
rseg = null, segments = [], isNullValue = lang.hitch(this, "isNullValue");
// split the run data into dense segments (each containing no nulls)
// except if interpolates is false in which case ignore null between valid data
for(var j = min; j <= max; j++){
var value = indexed ? commonStacked.getIndexValue(this.series, i, j, isNullValue) : commonStacked.getValue(this.series, i, run.data[j] ?run.data[j].x: null, isNullValue);
if(!isNullValue(value[0]) && (indexed || value[0].y != null)){
if(!rseg){
rseg = [];
segments.push({index: j, rseg: rseg});
}
rseg.push(value[0]);
}else{
if(!this.opt.interpolate || indexed){
// we break the line only if not interpolating or if we have indexed data
rseg = null;
}
}
}
return segments;
}
});
});
},
'dojox/charting/plot2d/commonStacked':function(){
define([
"dojo/_base/lang",
"dojox/lang/functional",
"./common"
], function(lang, df, common){
var commonStacked = lang.getObject("dojox.charting.plot2d.commonStacked", true);
return lang.mixin(commonStacked, {
collectStats: function(series, isNullValue){
var stats = lang.delegate(common.defaultStats);
for(var i = 0; i < series.length; ++i){
var run = series[i];
for(var j = 0; j < run.data.length; j++){
var x, y;
if(run.data[j] !== null){
if(typeof run.data[j] == "number" || !run.data[j].hasOwnProperty("x")){
y = commonStacked.getIndexValue(series, i, j, isNullValue)[0];
x = j+1;
}else{
x = run.data[j].x;
if(x !== null){
y = commonStacked.getValue(series, i, x, isNullValue)[0];
y = y != null && y.y ? y.y:null;
}
}
stats.hmin = Math.min(stats.hmin, x);
stats.hmax = Math.max(stats.hmax, x);
stats.vmin = Math.min(stats.vmin, y);
stats.vmax = Math.max(stats.vmax, y);
}
}
}
return stats;
},
rearrangeValues: function(values, transform, baseline){
// collect references to non-empty sets
var sets = df.filter(values, "x"), n = sets.length;
if(!n){
// nothing to do at all
return values;
}
// stack values
var previousSet = {};
for(var i = 0; i < n; ++i){
var extractedSet = sets[i];
for(var j = extractedSet.min, k = extractedSet.max; j < k; ++j){
extractedSet[j] = (extractedSet[j] || 0) + (previousSet[j] || 0);
}
previousSet = extractedSet;
}
// transform to pixels
for(i = 0; i < n; ++i){
extractedSet = sets[i];
for(j = extractedSet.min, k = extractedSet.max; j < k; ++j){
extractedSet[j] = this.isNullValue(extractedSet[j]) ? 0 :
transform(extractedSet[j]) - baseline;
}
}
// correct the minimal width
if(this.opt.minWidth){
var minWidth = this.opt.minWidth;
// unstack
for(i = n - 1; i; --i){
extractedSet = sets[i];
previousSet = sets[i - 1];
for(j = extractedSet.min, k = extractedSet.max; j < k; ++j){
extractedSet[j] = extractedSet[j] - previousSet[j];
}
}
// now let's go over all values and correct them, if needed
var min = extractedSet.min, max = extractedSet.max;
for(var j = min; j < max; ++j){
// find a total length of stack
var sum = 0, counter = 0;
for(i = 0; i < n; ++i){
var value = sets[i][j];
if(value > 0){
sum += value;
++counter;
}
}
if(sum <= counter * minWidth){
// the corner case: all values are very small
for(i = 0; i < n; ++i){
value = sets[i][j];
if(value > 0){
sets[i][j] = minWidth;
}
}
continue; // next stack
}
// distributing overflow up
var overflow = 0;
for(i = 0; i < n; ++i){
extractedSet = sets[i];
value = extractedSet[j];
if(value > 0){
if(value < minWidth){
overflow += minWidth - value;
extractedSet[j] = minWidth;
}else if(overflow > 0){
// calculate available space
var available = extractedSet[j] - minWidth;
if(available >= overflow){
extractedSet[j] -= overflow;
overflow = 0;
}else if(available > 0){
extractedSet[j] = minWidth;
overflow -= available;
}
}
}
}
// distributing overflow down, if any
if(overflow > 0){
for(i = n - 1; i >= 0; --i){
extractedSet = sets[i];
value = extractedSet[j];
if(value > 0){
// calculate available space
available = extractedSet[j] - minWidth;
if(available >= overflow){
extractedSet[j] -= overflow;
break;
}else if(available > 0){
extractedSet[j] = minWidth;
overflow -= available;
}
}
}
}
}
// stack
for(i = 1; i < n; ++i){
extractedSet = sets[i];
previousSet = sets[i - 1];
for(j = extractedSet.min, k = extractedSet.max; j < k; ++j){
extractedSet[j] = extractedSet[j] + previousSet[j];
}
}
}
return values;
},
getIndexValue: function(series, i, index, isNullValue){
var value = 0, v, j, pvalue;
for(j = 0; j <= i; ++j){
if(series[j].hidden){
continue;
}
pvalue = value;
v = series[j].data[index];
if(!isNullValue(v)){
if(isNaN(v)){ v = v.y || 0; }
value += v;
}
}
return [value , pvalue];
},
getValue: function(series, i, x, isNullValue){
var value = null, j, z, v, pvalue;
for(j = 0; j <= i; ++j){
if(series[j].hidden){
continue;
}
for(z = 0; z < series[j].data.length; z++){
pvalue = value;
v = series[j].data[z];
if(!isNullValue(v)){
if(v.x == x){
if(!value){
value = {x: x};
}
if(v.y != null){
if(value.y == null){
value.y = 0;
}
value.y += v.y;
}
break;
}else if(v.x > x){break;}
}
}
}
return [value, pvalue];
}
});
});
},
'dojox/charting/plot2d/StackedLines':function(){
define(["dojo/_base/declare", "./Stacked"], function(declare, Stacked){
return declare("dojox.charting.plot2d.StackedLines", Stacked, {
// summary:
// A convenience object to create a stacked line chart.
constructor: function(){
// summary:
// Force our Stacked base to be lines only.
this.opt.lines = true;
}
});
});
},
'dojox/charting/plot2d/StackedAreas':function(){
define(["dojo/_base/declare", "./Stacked"], function(declare, Stacked){
return declare("dojox.charting.plot2d.StackedAreas", Stacked, {
// summary:
// A convenience object to set up a stacked area plot.
constructor: function(){
// summary:
// Force our Stacked plotter to include both lines and areas.
this.opt.lines = true;
this.opt.areas = true;
}
});
});
},
'dojox/charting/plot2d/Columns':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
"dojox/lang/functional", "dojox/lang/utils", "dojox/gfx/fx"],
function(lang, arr, declare, has, CartesianBase, _PlotEvents, dc, df, du, fx){
var alwaysFalse = function(){ return false; };
return declare("dojox.charting.plot2d.Columns", [CartesianBase, _PlotEvents], {
// summary:
// The plot object representing a column chart (vertical bars).
defaultParams: {
gap: 0, // gap between columns in pixels
animate: null, // animate bars into place
enableCache: false
},
optionalParams: {
minBarSize: 1, // minimal column width in pixels
maxBarSize: 1, // maximal column width in pixels
// theme component
stroke: {},
outline: {},
shadow: {},
fill: {},
filter: {},
styleFunc: null,
font: "",
fontColor: ""
},
constructor: function(chart, kwArgs){
// summary:
// The constructor for a columns chart.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__BarCtorArgs?
// An optional keyword arguments object to help define the plot.
this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.animate = this.opt.animate;
this.renderingOptions = { "shape-rendering": "crispEdges" };
},
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
var stats = dc.collectSimpleStats(this.series, lang.hitch(this, "isNullValue"));
stats.hmin -= 0.5;
stats.hmax += 0.5;
return stats; // Object
},
createRect: function(run, creator, params){
var rect;
if(this.opt.enableCache && run._rectFreePool.length > 0){
rect = run._rectFreePool.pop();
rect.setShape(params);
// was cleared, add it back
creator.add(rect);
}else{
rect = creator.createRect(params);
}
if(this.opt.enableCache){
run._rectUsePool.push(rect);
}
return rect;
},
render: function(dim, offsets){
// summary:
// Run the calculations for any axes for this plot.
// dim: Object
// An object in the form of { width, height }
// offsets: Object
// An object of the form { l, r, t, b}.
// returns: dojox/charting/plot2d/Columns
// A reference to this plot for functional chaining.
if(this.zoom && !this.isDataDirty()){
return this.performZoom(dim, offsets);
}
this.resetEvents();
this.dirty = this.isDirty();
var s;
if(this.dirty){
arr.forEach(this.series, dc.purgeGroup);
this._eventSeries = {};
this.cleanGroup();
s = this.getGroup();
df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
}
var t = this.chart.theme,
ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
baseline = Math.max(this._vScaler.bounds.lower,
this._vAxis ? this._vAxis.naturalBaseline : 0),
baselineHeight = vt(baseline),
events = this.events(),
bar = this.getBarProperties();
var z = 0; // the non-hidden series index
// Collect and calculate all values
var extractedValues = this.extractValues(this._hScaler);
extractedValues = this.rearrangeValues(extractedValues, vt, baselineHeight);
for(var i = 0; i < this.series.length; i++){
var run = this.series[i];
if(!this.dirty && !run.dirty){
t.skip();
this._reconnectEvents(run.name);
continue;
}
run.cleanGroup();
if(this.opt.enableCache){
run._rectFreePool = (run._rectFreePool?run._rectFreePool:[]).concat(run._rectUsePool?run._rectUsePool:[]);
run._rectUsePool = [];
}
var theme = t.next("column", [this.opt, run]),
eventSeries = new Array(run.data.length);
if(run.hidden){
run.dyn.fill = theme.series.fill;
continue;
}
s = run.group;
var indexed = arr.some(run.data, function(item){
return typeof item == "number" || (item && !item.hasOwnProperty("x"));
});
// on indexed charts we can easily just interate from the first visible to the last visible
// data point to save time
var min = indexed?Math.max(0, Math.floor(this._hScaler.bounds.from - 1)):0;
var max = indexed?Math.min(run.data.length, Math.ceil(this._hScaler.bounds.to)):run.data.length;
for(var j = min; j < max; ++j){
var value = run.data[j];
if(!this.isNullValue(value)){
var val = this.getValue(value, j, i, indexed),
vv = vt(val.y),
h = extractedValues[i][j],
finalTheme,
sshape;
if(this.opt.styleFunc || typeof value != "number"){
var tMixin = typeof value != "number" ? [value] : [];
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(value));
}
finalTheme = t.addMixin(theme, "column", tMixin, true);
}else{
finalTheme = t.post(theme, "column");
}
if(bar.width >= 1){
var rect = {
x: offsets.l + ht(val.x + 0.5) + bar.gap + bar.thickness * z,
y: dim.height - offsets.b - baselineHeight - Math.max(h, 0),
width: bar.width,
height: Math.abs(h)
};
if(finalTheme.series.shadow){
var srect = lang.clone(rect);
srect.x += finalTheme.series.shadow.dx;
srect.y += finalTheme.series.shadow.dy;
sshape = this.createRect(run, s, srect).setFill(finalTheme.series.shadow.color).setStroke(finalTheme.series.shadow);
if(this.animate){
this._animateColumn(sshape, dim.height - offsets.b + baselineHeight, h);
}
}
var specialFill = this._plotFill(finalTheme.series.fill, dim, offsets);
specialFill = this._shapeFill(specialFill, rect);
var shape = this.createRect(run, s, rect).setFill(specialFill).setStroke(finalTheme.series.stroke);
this.overrideShape(shape, {index: j, value: val});
if(shape.setFilter && finalTheme.series.filter){
shape.setFilter(finalTheme.series.filter);
}
run.dyn.fill = shape.getFill();
run.dyn.stroke = shape.getStroke();
if(events){
var o = {
element: "column",
index: j,
run: run,
shape: shape,
shadow: sshape,
cx: val.x + 0.5,
cy: val.y,
x: indexed?j:run.data[j].x,
y: indexed?run.data[j]:run.data[j].y
};
this._connectEvents(o);
eventSeries[j] = o;
}
// if val.py is here, this means we are stacking and we need to subtract previous
// value to get the high in which we will lay out the label
if(!isNaN(val.py) && val.py > baseline){
rect.height = h - vt(val.py);
}
this.createLabel(s, value, rect, finalTheme);
if(this.animate){
this._animateColumn(shape, dim.height - offsets.b - baselineHeight, h);
}
}
}
}
this._eventSeries[run.name] = eventSeries;
run.dirty = false;
z++;
}
this.dirty = false;
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
return this; // dojox/charting/plot2d/Columns
},
getValue: function(value, j, seriesIndex, indexed){
var y,x;
if(indexed){
if(typeof value == "number"){
y = value;
}else{
y = value.y;
}
x = j;
}else{
y = value.y;
x = value.x - 1;
}
return { x: x, y: y };
},
extractValues: function(scaler){
var extracted = [];
for(var i = this.series.length - 1; i >= 0; --i){
var run = this.series[i];
if(!this.dirty && !run.dirty){
continue;
}
// on indexed charts we can easily just interate from the first visible to the last visible
// data point to save time
var indexed = arr.some(run.data, function(item){
return typeof item == "number" || (item && !item.hasOwnProperty("x"));
}),
min = indexed ? Math.max(0, Math.floor(scaler.bounds.from - 1)) : 0,
max = indexed ? Math.min(run.data.length, Math.ceil(scaler.bounds.to)) : run.data.length,
extractedSet = extracted[i] = [];
extractedSet.min = min;
extractedSet.max = max;
for(var j = min; j < max; ++j){
var value = run.data[j];
extractedSet[j] = this.isNullValue(value) ? 0 :
(typeof value == "number" ? value : value.y);
}
}
return extracted;
},
rearrangeValues: function(values, transform, baseline){
// transform to pixels
for(var i = 0, n = values.length; i < n; ++i){
var extractedSet = values[i];
if(extractedSet){
for(var j = extractedSet.min, k = extractedSet.max; j < k; ++j){
var value = extractedSet[j];
extractedSet[j] = this.isNullValue(value) ? 0 : transform(value) - baseline;
}
}
}
return values;
},
isNullValue: function(value){
if(value === null || typeof value == "undefined"){
return true;
}
var h = this._hAxis ? this._hAxis.isNullValue : alwaysFalse,
v = this._vAxis ? this._vAxis.isNullValue : alwaysFalse;
if(typeof value == "number"){
return v(0.5) || h(value);
}
return v(isNaN(value.x) ? 0.5 : value.x + 0.5) || value.y === null || h(value.y);
},
getBarProperties: function(){
var f = dc.calculateBarSize(this._hScaler.bounds.scale, this.opt);
return {gap: f.gap, width: f.size, thickness: 0};
},
_animateColumn: function(shape, voffset, vsize){
if(vsize===0){
vsize = 1;
}
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: [0, voffset - (voffset/vsize)], end: [0, 0]},
{name: "scale", start: [1, 1/vsize], end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/StackedColumns':function(){
define(["dojo/_base/declare", "dojo/_base/lang", "./Columns", "./commonStacked"],
function(declare, lang, Columns, commonStacked){
return declare("dojox.charting.plot2d.StackedColumns", Columns, {
// summary:
// The plot object representing a stacked column chart (vertical bars).
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
var stats = commonStacked.collectStats(this.series, lang.hitch(this, "isNullValue"));
stats.hmin -= 0.5;
stats.hmax += 0.5;
return stats; // Object
},
rearrangeValues: function(values, transform, baseline){
return commonStacked.rearrangeValues.call(this, values, transform, baseline);
}
});
});
},
'dojox/charting/plot2d/ClusteredColumns':function(){
define(["dojo/_base/declare", "dojo/_base/array", "./Columns", "./common"],
function(declare, array, Columns, dc){
return declare("dojox.charting.plot2d.ClusteredColumns", Columns, {
// summary:
// A plot representing grouped or clustered columns (vertical bars)
getBarProperties: function(){
var length = this.series.length;
array.forEach(this.series, function(serie){if(serie.hidden){length--;}});
var f = dc.calculateBarSize(this._hScaler.bounds.scale, this.opt, length);
return {gap: f.gap, width: f.size, thickness: f.size, clusterSize: length};
}
});
});
},
'dojox/charting/plot2d/Bars':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
"dojox/gfx/fx", "dojox/lang/utils", "dojox/lang/functional"],
function(lang, arr, declare, has, CartesianBase, _PlotEvents, dc, fx, du, df){
/*=====
declare("dojox.charting.plot2d.__BarCtorArgs", dojox.charting.plot2d.__DefaultCtorArgs, {
// summary:
// Additional keyword arguments for bar charts.
// minBarSize: Number?
// The minimum size for a bar in pixels. Default is 1.
minBarSize: 1,
// maxBarSize: Number?
// The maximum size for a bar in pixels. Default is 1.
maxBarSize: 1,
// stroke: dojox.gfx.Stroke?
// An optional stroke to use for any series on the plot.
stroke: {},
// outline: dojox.gfx.Stroke?
// An optional stroke used to outline any series on the plot.
outline: {},
// shadow: dojox.gfx.Stroke?
// An optional stroke to use to draw any shadows for a series on a plot.
shadow: {},
// fill: dojox.gfx.Fill?
// Any fill to be used for elements on the plot.
fill: {},
// filter: dojox.gfx.Filter?
// An SVG filter to be used for elements on the plot. gfx SVG renderer must be used and dojox/gfx/svgext must
// be required for this to work.
filter: {},
// styleFunc: Function?
// A function that returns a styling object for the a given data item.
styleFunc: null,
// font: String?
// A font definition to be used for labels and other text-based elements on the plot.
font: "",
// fontColor: String|dojo.Color?
// The color to be used for any text-based elements on the plot.
fontColor: "",
// enableCache: Boolean?
// Whether the bars rect are cached from one rendering to another. This improves the rendering performance of
// successive rendering but penalize the first rendering. Default false.
enableCache: false
});
=====*/
var alwaysFalse = function(){ return false; }
return declare("dojox.charting.plot2d.Bars", [CartesianBase, _PlotEvents], {
// summary:
// The plot object representing a bar chart (horizontal bars).
defaultParams: {
gap: 0, // gap between columns in pixels
animate: null, // animate bars into place
enableCache: false
},
optionalParams: {
minBarSize: 1, // minimal bar width in pixels
maxBarSize: 1, // maximal bar width in pixels
// theme component
stroke: {},
outline: {},
shadow: {},
fill: {},
filter: {},
styleFunc: null,
font: "",
fontColor: ""
},
constructor: function(chart, kwArgs){
// summary:
// The constructor for a bar chart.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__BarCtorArgs?
// An optional keyword arguments object to help define the plot.
this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.animate = this.opt.animate;
this.renderingOptions = { "shape-rendering": "crispEdges" };
},
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
var stats = dc.collectSimpleStats(this.series, lang.hitch(this, "isNullValue")), t;
stats.hmin -= 0.5;
stats.hmax += 0.5;
t = stats.hmin, stats.hmin = stats.vmin, stats.vmin = t;
t = stats.hmax, stats.hmax = stats.vmax, stats.vmax = t;
return stats; // Object
},
createRect: function(run, creator, params){
var rect;
if(this.opt.enableCache && run._rectFreePool.length > 0){
rect = run._rectFreePool.pop();
rect.setShape(params);
// was cleared, add it back
creator.add(rect);
}else{
rect = creator.createRect(params);
}
if(this.opt.enableCache){
run._rectUsePool.push(rect);
}
return rect;
},
createLabel: function(group, value, bbox, theme){
if(this.opt.labels && this.opt.labelStyle == "outside"){
var y = bbox.y + bbox.height / 2;
var x = bbox.x + bbox.width + this.opt.labelOffset;
this.renderLabel(group, x, y, this._getLabel(isNaN(value.y)?value:value.y), theme, "start");
}else{
this.inherited(arguments);
}
},
render: function(dim, offsets){
// summary:
// Run the calculations for any axes for this plot.
// dim: Object
// An object in the form of { width, height }
// offsets: Object
// An object of the form { l, r, t, b}.
// returns: dojox/charting/plot2d/Bars
// A reference to this plot for functional chaining.
if(this.zoom && !this.isDataDirty()){
return this.performZoom(dim, offsets); // dojox/charting/plot2d/Bars
}
this.dirty = this.isDirty();
this.resetEvents();
var s;
if(this.dirty){
arr.forEach(this.series, dc.purgeGroup);
this._eventSeries = {};
this.cleanGroup();
s = this.getGroup();
df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
}
var t = this.chart.theme,
ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
baseline = Math.max(this._hScaler.bounds.lower,
this._hAxis ? this._hAxis.naturalBaseline : 0),
baselineWidth = ht(baseline),
events = this.events();
var bar = this.getBarProperties();
var actualLength = this.series.length;
arr.forEach(this.series, function(serie){if(serie.hidden){actualLength--;}});
var z = actualLength;
// Collect and calculate all values
var extractedValues = this.extractValues(this._vScaler);
extractedValues = this.rearrangeValues(extractedValues, ht, baselineWidth);
for(var i = 0; i < this.series.length; i++){
var run = this.series[i];
if(!this.dirty && !run.dirty){
t.skip();
this._reconnectEvents(run.name);
continue;
}
run.cleanGroup();
if(this.opt.enableCache){
run._rectFreePool = (run._rectFreePool?run._rectFreePool:[]).concat(run._rectUsePool?run._rectUsePool:[]);
run._rectUsePool = [];
}
var theme = t.next("bar", [this.opt, run]);
if(run.hidden){
run.dyn.fill = theme.series.fill;
run.dyn.stroke = theme.series.stroke;
continue;
}
z--;
var eventSeries = new Array(run.data.length);
s = run.group;
var indexed = arr.some(run.data, function(item){
return typeof item == "number" || (item && !item.hasOwnProperty("x"));
});
// on indexed charts we can easily just interate from the first visible to the last visible
// data point to save time
var min = indexed?Math.max(0, Math.floor(this._vScaler.bounds.from - 1)):0;
var max = indexed?Math.min(run.data.length, Math.ceil(this._vScaler.bounds.to)):run.data.length;
for(var j = min; j < max; ++j){
var value = run.data[j];
if(!this.isNullValue(value)){
var val = this.getValue(value, j, i, indexed),
w = extractedValues[i][j], finalTheme, sshape;
if(this.opt.styleFunc || typeof value != "number"){
var tMixin = typeof value != "number" ? [value] : [];
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(value));
}
finalTheme = t.addMixin(theme, "bar", tMixin, true);
}else{
finalTheme = t.post(theme, "bar");
}
if(w && bar.height >= 1){
var rect = {
x: offsets.l + baselineWidth + Math.min(w, 0),
y: dim.height - offsets.b - vt(val.x + 1.5) + bar.gap + bar.thickness * (actualLength - z - 1),
width: Math.abs(w),
height: bar.height
};
if(finalTheme.series.shadow){
var srect = lang.clone(rect);
srect.x += finalTheme.series.shadow.dx;
srect.y += finalTheme.series.shadow.dy;
sshape = this.createRect(run, s, srect).setFill(finalTheme.series.shadow.color).setStroke(finalTheme.series.shadow);
if(this.animate){
this._animateBar(sshape, offsets.l + baselineWidth, -w);
}
}
var specialFill = this._plotFill(finalTheme.series.fill, dim, offsets);
specialFill = this._shapeFill(specialFill, rect);
var shape = this.createRect(run, s, rect).setFill(specialFill).setStroke(finalTheme.series.stroke);
if(shape.setFilter && finalTheme.series.filter){
shape.setFilter(finalTheme.series.filter);
}
run.dyn.fill = shape.getFill();
run.dyn.stroke = shape.getStroke();
if(events){
var o = {
element: "bar",
index: j,
run: run,
shape: shape,
shadow: sshape,
cx: val.y,
cy: val.x + 1.5,
x: indexed?j:run.data[j].x,
y: indexed?run.data[j]:run.data[j].y
};
this._connectEvents(o);
eventSeries[j] = o;
}
if(!isNaN(val.py) && val.py > baseline){
rect.x += ht(val.py);
rect.width -= ht(val.py);
}
this.createLabel(s, value, rect, finalTheme);
if(this.animate){
this._animateBar(shape, offsets.l + baselineWidth, -Math.abs(w));
}
}
}
}
this._eventSeries[run.name] = eventSeries;
run.dirty = false;
}
this.dirty = false;
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
return this; // dojox/charting/plot2d/Bars
},
getValue: function(value, j, seriesIndex, indexed){
var y, x;
if(indexed){
if(typeof value == "number"){
y = value;
}else{
y = value.y;
}
x = j;
}else{
y = value.y;
x = value.x -1;
}
return {y:y, x:x};
},
extractValues: function(scaler){
var extracted = [];
for(var i = this.series.length - 1; i >= 0; --i){
var run = this.series[i];
if(!this.dirty && !run.dirty){
continue;
}
// on indexed charts we can easily just interate from the first visible to the last visible
// data point to save time
var indexed = arr.some(run.data, function(item){
return typeof item == "number" || (item && !item.hasOwnProperty("x"));
}),
min = indexed ? Math.max(0, Math.floor(scaler.bounds.from - 1)) : 0,
max = indexed ? Math.min(run.data.length, Math.ceil(scaler.bounds.to)) : run.data.length,
extractedSet = extracted[i] = [];
extractedSet.min = min;
extractedSet.max = max;
for(var j = min; j < max; ++j){
var value = run.data[j];
extractedSet[j] = this.isNullValue(value) ? 0 :
(typeof value == "number" ? value : value.y);
}
}
return extracted;
},
rearrangeValues: function(values, transform, baseline){
// transform to pixels
for(var i = 0, n = values.length; i < n; ++i){
var extractedSet = values[i];
if(extractedSet){
for(var j = extractedSet.min, k = extractedSet.max; j < k; ++j){
var value = extractedSet[j];
extractedSet[j] = this.isNullValue(value) ? 0 : transform(value) - baseline;
}
}
}
return values;
},
isNullValue: function(value){
if(value === null || typeof value == "undefined"){
return true;
}
var h = this._hAxis ? this._hAxis.isNullValue : alwaysFalse,
v = this._vAxis ? this._vAxis.isNullValue : alwaysFalse;
if(typeof value == "number"){
return v(0.5) || h(value);
}
return v(isNaN(value.x) ? 0.5 : value.x + 0.5) || value.y === null || h(value.y);
},
getBarProperties: function(){
var f = dc.calculateBarSize(this._vScaler.bounds.scale, this.opt);
return {gap: f.gap, height: f.size, thickness: 0};
},
_animateBar: function(shape, hoffset, hsize){
if(hsize==0){
hsize = 1;
}
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: [hoffset - (hoffset/hsize), 0], end: [0, 0]},
{name: "scale", start: [1/hsize, 1], end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/StackedBars':function(){
define(["dojo/_base/declare", "dojo/_base/lang", "./Bars", "./commonStacked"],
function(declare, lang, Bars, commonStacked){
return declare("dojox.charting.plot2d.StackedBars", Bars, {
// summary:
// The plot object representing a stacked bar chart (horizontal bars).
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
var stats = commonStacked.collectStats(this.series, lang.hitch(this, "isNullValue")), t;
stats.hmin -= 0.5;
stats.hmax += 0.5;
t = stats.hmin, stats.hmin = stats.vmin, stats.vmin = t;
t = stats.hmax, stats.hmax = stats.vmax, stats.vmax = t;
return stats; // Object
},
rearrangeValues: function(values, transform, baseline){
return commonStacked.rearrangeValues.call(this, values, transform, baseline);
}
});
});
},
'dojox/charting/plot2d/ClusteredBars':function(){
define(["dojo/_base/declare", "dojo/_base/array", "./Bars", "./common"],
function(declare, array, Bars, dc){
return declare("dojox.charting.plot2d.ClusteredBars", Bars, {
// summary:
// A plot representing grouped or clustered bars (horizontal bars)
getBarProperties: function(){
var length = this.series.length;
array.forEach(this.series, function(serie){if(serie.hidden){length--;}});
var f = dc.calculateBarSize(this._vScaler.bounds.scale, this.opt, length);
return {gap: f.gap, height: f.size, thickness: f.size};
}
});
});
},
'dojox/charting/plot2d/Grid':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/array", "dojo/sniff",
"./CartesianBase", "./common", "dojox/lang/utils", "dojox/gfx/fx"],
function(lang, declare, arr, has, CartesianBase, dc, du, fx){
var sortTicks = function(a,b){return a.value - b.value};
/*=====
declare("dojox.charting.plot2d.__GridCtorArgs", dojox.charting.plot2d.__CartesianCtorArgs, {
// summary:
// A special keyword arguments object that is specific to a grid "plot".
// majorHLine: dojox.gfx.Stroke?
// An optional dojox.gfx.Stroke for a major horizontal line. By default major lines use major tick stroke.
majorHLine:undefined,
// minorHLine: dojox.gfx.Stroke?
// An optional dojox.gfx.Stroke for a minor horizontal line. By default minor lines use minor tick stroke.
minorHLine:undefined,
// majorVLine: dojox.gfx.Stroke?
// An optional dojox.gfx.Stroke for a major vertical line. By default major lines use major tick stroke.
majorVLine:undefined,
// minorVLine: dojox.gfx.Stroke?
// An optional dojox.gfx.Stroke for a minor vertical line. By default major lines use major tick stroke.
minorVLine:undefined,
// hFill: dojox.gfx.Fill?
// An optional dojox.gfx.Fill used to fill every other horizontal stripe created by grid lines.
hFill: undefined,
// hAlternateFill: dojox.gfx.Fill?
// An optional dojox.gfx.Fill used to fill alternating horizontal stripe created by grid lines not filled by `hFill`.
hAlternateFill: undefined,
// vFill: dojox.gfx.Fill?
// An optional dojox.gfx.Fill used to fill every other vertical stripe created by grid lines.
vFill: undefined,
// vAlternateFill: dojox.gfx.Fill?
// An optional dojox.gfx.Fill used to fill alternating vertical stripe created by grid lines not filled by `vFill`.
vAlternateFill: undefined,
// hMajorLines: Boolean?
// Whether to show lines at the major ticks along the horizontal axis. Default is true.
hMajorLines: true,
// hMinorLines: Boolean?
// Whether to show lines at the minor ticks along the horizontal axis. Default is false.
hMinorLines: false,
// vMajorLines: Boolean?
// Whether to show lines at the major ticks along the vertical axis. Default is true.
vMajorLines: true,
// vMinorLines: Boolean?
// Whether to show lines at the major ticks along the vertical axis. Default is false.
vMinorLines: false,
// hStripes: Boolean?
// Whether to show horizontal stripes. Default is false.
hStripes: false,
// vStripes: Boolean?
// Whether to show vertical stripes. Default is false.
vStripes: false,
// enableCache: Boolean?
// Whether the grid lines are cached from one rendering to another. This improves the rendering performance of
// successive rendering but penalize the first rendering. Default false.
enableCache: false,
// renderOnAxis: Boolean?
// Whether or not the grid is rendered when drawn at horizontal or vertical axis position. Default is true.
renderOnAxis: true
});
=====*/
return declare("dojox.charting.plot2d.Grid", CartesianBase, {
// summary:
// A "faux" plot that can be placed behind other plots to represent
// a grid against which other plots can be easily measured.
defaultParams: {
hMajorLines: true, // draw horizontal major lines
hMinorLines: false, // draw horizontal minor lines
vMajorLines: true, // draw vertical major lines
vMinorLines: false, // draw vertical minor lines
hStripes: false, // draw vertical stripes
vStripes: false, // draw vertical stripes
animate: null, // animate bars into place
enableCache: false,
renderOnAxis: true
},
optionalParams: {
majorHLine: {},
minorHLine: {},
majorVLine: {},
minorVLine: {},
hFill: {},
vFill: {},
hAlternateFill: {},
vAlternateFill: {}
},
constructor: function(chart, kwArgs){
// summary:
// Create the faux Grid plot.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__GridCtorArgs?
// An optional keyword arguments object to help define the parameters of the underlying grid.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.animate = this.opt.animate;
if(this.opt.enableCache){
this._lineFreePool = [];
this._lineUsePool = [];
this._rectFreePool = [];
this._rectUsePool = [];
}
},
addSeries: function(run){
// summary:
// Ignored but included as a dummy method.
// returns: dojox/charting/plot2d/Grid
// The reference to this plot for functional chaining.
return this; // dojox/charting/plot2d/Grid
},
getSeriesStats: function(){
// summary:
// Returns default stats (irrelevant for this type of plot).
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
return lang.delegate(dc.defaultStats); // Object
},
cleanGroup: function(){
this.inherited(arguments);
if(this.opt.enableCache){
this._lineFreePool = this._lineFreePool.concat(this._lineUsePool);
this._lineUsePool = [];
this._rectFreePool = this._rectFreePool.concat(this._rectUsePool);
this._rectUsePool = [];
}
},
createLine: function(creator, params){
var line;
if(this.opt.enableCache && this._lineFreePool.length > 0){
line = this._lineFreePool.pop();
line.setShape(params);
// was cleared, add it back
creator.add(line);
}else{
line = creator.createLine(params);
}
if(this.opt.enableCache){
this._lineUsePool.push(line);
}
return line;
},
createRect: function(creator, params){
var rect;
if(this.opt.enableCache && this._rectFreePool.length > 0){
rect = this._rectFreePool.pop();
rect.setShape(params);
// was cleared, add it back
creator.add(rect);
}else{
rect = creator.createRect(params);
}
if(this.opt.enableCache){
this._rectUsePool.push(rect);
}
return rect;
},
render: function(dim, offsets){
// summary:
// Render the plot on the chart.
// dim: Object
// An object of the form { width, height }.
// offsets: Object
// An object of the form { l, r, t, b }.
// returns: dojox/charting/plot2d/Grid
// A reference to this plot for functional chaining.
if(this.zoom){
return this.performZoom(dim, offsets);
}
this.dirty = this.isDirty();
if(!this.dirty){ return this; }
this.cleanGroup();
var s = this.getGroup(), ta = this.chart.theme, lineStroke, ticks;
if((has("ios") && has("ios") < 6) || has("android") || (has("safari") && !has("ios"))){
// clipping seems buggy in some mobile Webkit browser and Safari desktop
// it does not clip correctly if only lines are present => create a invisible rectangle...
var w = Math.max(0, dim.width - offsets.l - offsets.r),
h = Math.max(0, dim.height - offsets.t - offsets.b);
s.createRect({ x: offsets.l, y: offsets.t, width: w, height: h});
}
if(this._vAxis){
// draw horizontal stripes and lines
ticks = this._vAxis.getTicks();
var vScaler = this._vAxis.getScaler();
if(ticks != null && vScaler != null){
var vt = vScaler.scaler.getTransformerFromModel(vScaler);
if(this.opt.hStripes){
this._renderHRect(ticks, ta.grid, dim, offsets, vScaler, vt);
}
if(this.opt.hMinorLines){
lineStroke = this.opt.minorHLine || (ta.grid && ta.grid.minorLine) || ta.axis.minorTick;
this._renderHLines(ticks.minor, lineStroke, dim, offsets, vScaler, vt);
}
if(this.opt.hMajorLines){
lineStroke = this.opt.majorHLine || (ta.grid && ta.grid.majorLine) || ta.axis.majorTick;
this._renderHLines(ticks.major, lineStroke, dim, offsets, vScaler, vt);
}
}
}
if(this._hAxis){
// draw vertical stripes and lines
ticks = this._hAxis.getTicks();
var hScaler = this._hAxis.getScaler();
if(ticks != null && hScaler != null){
var ht = hScaler.scaler.getTransformerFromModel(hScaler);
if(this.opt.vStripes){
this._renderVRect(ticks, ta.grid, dim, offsets, hScaler, ht);
}
if(ticks && this.opt.vMinorLines){
lineStroke = this.opt.minorVLine || (ta.grid && ta.grid.minorLine) || ta.axis.minorTick;
this._renderVLines(ticks.minor, lineStroke, dim, offsets, hScaler, ht);
}
if(ticks && this.opt.vMajorLines){
lineStroke = this.opt.majorVLine || (ta.grid && ta.grid.majorLine) || ta.axis.majorTick;
this._renderVLines(ticks.major, lineStroke, dim, offsets, hScaler, ht);
}
}
}
this.dirty = false;
return this; // dojox/charting/plot2d/Grid
},
_renderHLines: function(ticks, lineStroke, dim, offsets, vScaler, vt){
var s = this.getGroup();
arr.forEach(ticks, function(tick){
if(!this.opt.renderOnAxis && tick.value == (this._vAxis.opt.leftBottom?vScaler.bounds.from:vScaler.bounds.to)){
return;
}
var y = dim.height - offsets.b - vt(tick.value);
var hLine = this.createLine(s, {
x1: offsets.l,
y1: y,
x2: dim.width - offsets.r,
y2: y
}).setStroke(lineStroke);
if(this.animate){
this._animateGrid(hLine, "h", offsets.l, offsets.r + offsets.l - dim.width);
}
}, this);
},
_renderVLines: function(ticks, lineStroke, dim, offsets, hScaler, ht){
var s = this.getGroup();
arr.forEach(ticks, function(tick){
if(!this.opt.renderOnAxis && tick.value == (this._hAxis.opt.leftBottom?hScaler.bounds.from:hScaler.bounds.to)){
return;
}
var x = offsets.l + ht(tick.value);
var vLine = this.createLine(s, {
x1: x,
y1: offsets.t,
x2: x,
y2: dim.height - offsets.b
}).setStroke(lineStroke);
if(this.animate){
this._animateGrid(vLine, "v", dim.height - offsets.b, dim.height - offsets.b - offsets.t);
}
}, this);
},
_renderHRect: function(ticks, theme, dim, offsets, vScaler, vt){
var fill, tick, y, y2, hStripe;
var allTicks = ticks.major.concat(ticks.minor);
allTicks.sort(sortTicks);
if(allTicks[0].value > vScaler.bounds.from){
allTicks.splice(0, 0, {value: vScaler.bounds.from});
}
if(allTicks[allTicks.length - 1].value < vScaler.bounds.to){
allTicks.push({value: vScaler.bounds.to});
}
var s = this.getGroup();
for(var j = 0; j < allTicks.length - 1; j++){
tick = allTicks[j];
y = dim.height - offsets.b - vt(tick.value);
y2 = dim.height - offsets.b - vt(allTicks[j+1].value);
fill = (j%2 == 0)?(this.opt.hAlternateFill ||(theme && theme.alternateFill)):
(this.opt.hFill || (theme && theme.fill));
if(fill){
hStripe = this.createRect(s, {
x: offsets.l,
y: y,
width: dim.width - offsets.r,
height: y - y2
}).setFill(fill);
if(this.animate){
this._animateGrid(hStripe, "h", offsets.l, offsets.r + offsets.l - dim.width);
}
}
}
},
_renderVRect: function(ticks, theme, dim, offsets, hScaler, ht){
var fill, tick, x, x2, vStripe;
var allTicks = ticks.major.concat(ticks.minor);
allTicks.sort(sortTicks);
if(allTicks[0].value > hScaler.bounds.from){
allTicks.splice(0, 0, {value: hScaler.bounds.from});
}
if(allTicks[allTicks.length - 1].value < hScaler.bounds.to){
allTicks.push({value: hScaler.bounds.to});
}
var s = this.getGroup();
for(var j = 0; j < allTicks.length - 1; j++){
tick = allTicks[j];
x = offsets.l + ht(tick.value);
x2 = offsets.l + ht(allTicks[j+1].value);
fill = (j%2 == 0)?(this.opt.vAlternateFill ||(theme && theme.alternateFill)):
(this.opt.vFill || (theme && theme.fill));
if(fill){
vStripe = this.createRect(s, {
x: x,
y: offsets.t,
width: x2 - x,
height: dim.width - offsets.r
}).setFill(fill);
if(this.animate){
this._animateGrid(vStripe, "v", dim.height - offsets.b, dim.height - offsets.b - offsets.t);
}
}
}
},
_animateGrid: function(shape, type, offset, size){
var transStart = type == "h" ? [offset, 0] : [0, offset];
var scaleStart = type == "h" ? [1/size, 1] : [1, 1/size];
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: transStart, end: [0, 0]},
{name: "scale", start: scaleStart, end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/Pie':function(){
define(["dojo/_base/lang", "dojo/_base/array" ,"dojo/_base/declare", "dojo/dom-geometry", "dojo/_base/Color",
"./Base", "./_PlotEvents", "./common",
"dojox/gfx", "dojox/gfx/matrix", "dojox/lang/functional", "dojox/lang/utils","dojo/has"],
function(lang, arr, declare, domGeom, Color, Base, PlotEvents, dc, g, m, df, du, has){
/*=====
declare("dojox.charting.plot2d.__PieCtorArgs", dojox.charting.plot2d.__DefaultCtorArgs, {
// summary:
// Specialized keyword arguments object for use in defining parameters on a Pie chart.
// labels: Boolean?
// Whether or not to draw labels for each pie slice. Default is true.
labels: true,
// ticks: Boolean?
// Whether or not to draw ticks to labels within each slice. Default is false.
ticks: false,
// fixed: Boolean?
// Whether a fixed precision must be applied to data values for display. Default is true.
fixed: true,
// precision: Number?
// The precision at which to round data values for display. Default is 0.
precision: 1,
// labelOffset: Number?
// The amount in pixels by which to offset labels. Default is 20.
labelOffset: 20,
// labelStyle: String?
// Options as to where to draw labels. Values include "default", and "columns". Default is "default".
labelStyle: "default", // default/columns
// omitLabels: Boolean?
// Whether labels of slices small to the point of not being visible are omitted. Default false.
omitLabels: false,
// htmlLabels: Boolean?
// Whether or not to use HTML to render slice labels. Default is true.
htmlLabels: true,
// radGrad: String?
// The type of radial gradient to use in rendering. Default is "native".
radGrad: "native",
// fanSize: Number?
// The amount for a radial gradient. Default is 5.
fanSize: 5,
// startAngle: Number?
// Where to being rendering gradients in slices, in degrees. Default is 0.
startAngle: 0,
// radius: Number?
// The size of the radial gradient. Default is 0.
radius: 0,
// shadow: dojox.gfx.Stroke?
// An optional stroke to use to draw any shadows for a series on a plot.
shadow: {},
// fill: dojox.gfx.Fill?
// Any fill to be used for elements on the plot.
fill: {},
// filter: dojox.gfx.Filter?
// An SVG filter to be used for elements on the plot. gfx SVG renderer must be used and dojox/gfx/svgext must
// be required for this to work.
filter: {},
// styleFunc: Function?
// A function that returns a styling object for the a given data item.
styleFunc: null,
// innerRadius: Number?
// The inner radius of a ring in percent (0-100). If value < 0
// then it is assumed to be pixels, not percent.
innerRadius: 0,
// minWidth: Number?
// The minimum width of a pie slice at its chord. The default is 10px.
minWidth: 10
});
=====*/
var FUDGE_FACTOR = 0.2; // use to overlap fans
return declare("dojox.charting.plot2d.Pie", [Base, PlotEvents], {
// summary:
// The plot that represents a typical pie chart.
defaultParams: {
labels: true,
ticks: false,
fixed: true,
precision: 1,
labelOffset: 20,
labelStyle: "default", // default/columns
htmlLabels: true, // use HTML to draw labels
radGrad: "native", // or "linear", or "fan"
fanSize: 5, // maximum fan size in degrees
startAngle: 0, // start angle for slices in degrees
innerRadius: 0, // inner radius in pixels
minWidth: 0, // minimal width of degenerated slices
zeroDataMessage: "" // The message to display when there is no data, if provided by the user.
},
optionalParams: {
radius: 0,
omitLabels: false,
// theme components
stroke: {},
outline: {},
shadow: {},
fill: {},
filter: {},
styleFunc: null,
font: "",
fontColor: "",
labelWiring: {}
},
constructor: function(chart, kwArgs){
// summary:
// Create a pie plot.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.axes = [];
this.run = null;
this.dyn = [];
this.runFilter = [];
if(kwArgs && kwArgs.hasOwnProperty("innerRadius")){
this._plotSetInnerRadius = true;
}
},
clear: function(){
// summary:
// Clear out all of the information tied to this plot.
// returns: dojox/charting/plot2d/Pie
// A reference to this plot for functional chaining.
this.inherited(arguments);
this.dyn = [];
this.run = null;
return this; // dojox/charting/plot2d/Pie
},
setAxis: function(axis){
// summary:
// Dummy method, since axes are irrelevant with a Pie chart.
// returns: dojox/charting/plot2d/Pie
// The reference to this plot for functional chaining.
return this; // dojox/charting/plot2d/Pie
},
addSeries: function(run){
// summary:
// Add a series of data to this plot.
// returns: dojox/charting/plot2d/Pie
// The reference to this plot for functional chaining.
this.run = run;
return this; // dojox/charting/plot2d/Pie
},
getSeriesStats: function(){
// summary:
// Returns default stats (irrelevant for this type of plot).
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
return lang.delegate(dc.defaultStats); // Object
},
getRequiredColors: function(){
// summary:
// Return the number of colors needed to draw this plot.
return this.run ? this.run.data.length : 0;
},
render: function(dim, offsets){
// summary:
// Render the plot on the chart.
// dim: Object
// An object of the form { width, height }.
// offsets: Object
// An object of the form { l, r, t, b }.
// returns: dojox/charting/plot2d/Pie
// A reference to this plot for functional chaining.
if(!this.dirty){ return this; }
this.resetEvents();
this.dirty = false;
this._eventSeries = {};
this.cleanGroup();
var s = this.group, t = this.chart.theme;
if(!this._plotSetInnerRadius && t && t.pieInnerRadius){
this.opt.innerRadius = t.pieInnerRadius;
}
// calculate the geometry
var rx = (dim.width - offsets.l - offsets.r) / 2,
ry = (dim.height - offsets.t - offsets.b) / 2,
r = Math.min(rx, ry),
taFont = "font" in this.opt ? this.opt.font : t.axis.tick.titleFont || "",
size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0,
taFontColor = this.opt.hasOwnProperty("fontColor") ? this.opt.fontColor : t.axis.tick.fontColor,
startAngle = m._degToRad(this.opt.startAngle),
start = startAngle, filteredRun, slices, labels, shift, labelR,
run = this.run.data,
events = this.events();
/* Added to handle no data case */
var noDataFunc = lang.hitch(this, function(){
var ct = t.clone();
var themes = df.map(run, function(v){
var tMixin = [this.opt, this.run];
if(v !== null && typeof v != "number"){
tMixin.push(v);
}
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(v));
}
return ct.next("slice", tMixin, true);
}, this);
// Draw initial pie, with text in it noting 0 data.
if("radius" in this.opt){
r = this.opt.radius < r ? this.opt.radius : r;
}
var circle = {
cx: offsets.l + rx,
cy: offsets.t + ry,
r: r
};
var rColor = new Color(taFontColor);
// If we have a radius, we'll need to fade the ring some
if(this.opt.innerRadius){
rColor.a = 0.1;
}
var ring = this._createRing(s, circle).setStroke(rColor);
if(this.opt.innerRadius){
// If we have a radius, fill it with the faded color.
ring.setFill(rColor);
}
if(this.opt.zeroDataMessage){
this.renderLabel(s, circle.cx, circle.cy + size/3, this.opt.zeroDataMessage, {
series: {
font: taFont,
fontColor: taFontColor
}
}, null, "middle");
}
this.dyn = [];
arr.forEach(run, function(item, i){
this.dyn.push({
fill: this._plotFill(themes[i].series.fill, dim, offsets),
stroke: themes[i].series.stroke});
}, this);
});
/* END Added to handle no data case */
// Draw over circle!
if(!this.run && !this.run.data.ength){
noDataFunc();
return this;
}
if(typeof run[0] == "number"){
filteredRun = df.map(run, "x ? Math.max(x, 0) : 0");
if(df.every(filteredRun, "<= 0")){
noDataFunc();
return this;
}
slices = df.map(filteredRun, "/this", df.foldl(filteredRun, "+", 0));
if(this.opt.labels){
labels = arr.map(slices, function(x){
return x > 0 ? this._getLabel(x * 100) + "%" : "";
}, this);
}
}else{
filteredRun = df.map(run, "x ? Math.max(x.y, 0) : 0");
if(!filteredRun.length || df.every(filteredRun, "<= 0")){
noDataFunc();
return this;
}
slices = df.map(filteredRun, "/this", df.foldl(filteredRun, "+", 0));
if(this.opt.labels){
labels = arr.map(slices, function(x, i){
if(x < 0){ return ""; }
var v = run[i];
return v.hasOwnProperty("text") ? v.text : this._getLabel(x * 100) + "%";
}, this);
}
}
var themes = df.map(run, function(v){
var tMixin = [this.opt, this.run];
if(v !== null && typeof v != "number"){
tMixin.push(v);
}
if(this.opt.styleFunc){
tMixin.push(this.opt.styleFunc(v));
}
return t.next("slice", tMixin, true);
}, this);
if(this.opt.labels) {
shift = df.foldl1(df.map(labels, function(label, i){
var font = themes[i].series.font;
return g._base._getTextBox(label, {font: font}).w;
}, this), "Math.max(a, b)") / 2;
if(this.opt.labelOffset < 0){
r = Math.min(rx - 2 * shift, ry - size) + this.opt.labelOffset;
}
}
if(this.opt.hasOwnProperty("radius")){
r = this.opt.radius < r * 0.9 ? this.opt.radius : r * 0.9;
}
if (!this.opt.radius && this.opt.labels && this.opt.labelStyle == "columns") {
r = r / 2;
if (rx > ry && rx > r * 2) {
r *= rx / (r * 2);
}
if (r >= ry * 0.8) {
r = ry * 0.8;
}
} else {
if (r >= ry * 0.9) {
r = ry * 0.9;
}
}
labelR = r - this.opt.labelOffset;
var circle = {
cx: offsets.l + rx,
cy: offsets.t + ry,
r: r
};
this.dyn = [];
// draw slices
var eventSeries = new Array(slices.length);
// Calulate primarily size for each slice
var slicesSteps = [], localStart = start;
var minWidth = this.opt.minWidth;
arr.forEach(slices, function(slice, i){
if(slice === 0){
slicesSteps[i] = {
step: 0,
end: localStart,
start: localStart,
weak: false
};
return;
}
var end = localStart + slice * 2 * Math.PI;
if(i === slices.length - 1){
end = startAngle + 2 * Math.PI;
}
var step = end - localStart,
dist = step * r;
slicesSteps[i] = {
step: step,
start: localStart,
end: end,
weak: dist < minWidth
};
localStart = end;
});
if(minWidth > 0){
var weakCount = 0, weakCoef = minWidth / r, oldWeakCoefSum = 0, i;
for(i = slicesSteps.length - 1; i >= 0; i--){
if(slicesSteps[i].weak){
++weakCount;
oldWeakCoefSum += slicesSteps[i].step;
slicesSteps[i].step = weakCoef;
}
}
// make sure that our steps are small enough
var weakCoefSum = weakCount * weakCoef;
if(weakCoefSum > Math.PI){
weakCoef = Math.PI / weakCount;
for(i = 0; i < slicesSteps.length; ++i){
if(slicesSteps[i].weak){
slicesSteps[i].step = weakCoef;
}
}
weakCoefSum = Math.PI;
}
// now let's redistribute percentage
if(weakCount > 0){
weakCoef = 1 - (weakCoefSum - oldWeakCoefSum) / 2 / Math.PI;
for(i = 0; i < slicesSteps.length; ++i){
if(!slicesSteps[i].weak){
slicesSteps[i].step = weakCoef * slicesSteps[i].step;
}
}
}
// now let's update start and end values
for(i = 0; i < slicesSteps.length; ++i){
slicesSteps[i].start = i ? slicesSteps[i].end : localStart;
slicesSteps[i].end = slicesSteps[i].start + slicesSteps[i].step;
}
// let's make sure that our last end is exactly 2 * Math.PI
for(i = slicesSteps.length - 1; i >= 0; --i){
if(slicesSteps[i].step !== 0){
slicesSteps[i].end = localStart + 2 * Math.PI;
break;
}
}
}
localStart = start;
var o, specialFill;
arr.some(slices, function(slice, i){
var shape;
var v = run[i], theme = themes[i];
if(slice >= 1){
// whole pie
specialFill = this._plotFill(theme.series.fill, dim, offsets);
specialFill = this._shapeFill(specialFill,
{
x: circle.cx - circle.r, y: circle.cy - circle.r,
width: 2 * circle.r, height: 2 * circle.r
});
specialFill = this._pseudoRadialFill(specialFill, {x: circle.cx, y: circle.cy}, circle.r);
shape = this._createRing(s, circle).setFill(specialFill).setStroke(theme.series.stroke);
this.dyn.push({fill: specialFill, stroke: theme.series.stroke});
if(events){
o = {
element: "slice",
index: i,
run: this.run,
shape: shape,
x: i,
y: typeof v == "number" ? v : v.y,
cx: circle.cx,
cy: circle.cy,
cr: r
};
this._connectEvents(o);
eventSeries[i] = o;
}
var k;
for(k = i + 1; k < slices.length; k++){
theme = themes[k];
this.dyn.push({fill: theme.series.fill, stroke: theme.series.stroke});
}
return true; // stop iteration
}
if(slicesSteps[i].step === 0){
// degenerated slice
// But we still want a fill since this will be skipped and we need the fill
// for the label.
this.dyn.push({fill: theme.series.fill, stroke: theme.series.stroke});
return false; // continue
}
// calculate the geometry of the slice
var step = slicesSteps[i].step,
x1 = circle.cx + r * Math.cos(localStart),
y1 = circle.cy + r * Math.sin(localStart),
x2 = circle.cx + r * Math.cos(localStart + step),
y2 = circle.cy + r * Math.sin(localStart + step);
// draw the slice
var fanSize = m._degToRad(this.opt.fanSize), stroke;
if(theme.series.fill && theme.series.fill.type === "radial" && this.opt.radGrad === "fan" && step > fanSize){
var group = s.createGroup(), nfans = Math.ceil(step / fanSize), delta = step / nfans;
specialFill = this._shapeFill(theme.series.fill,
{x: circle.cx - circle.r, y: circle.cy - circle.r, width: 2 * circle.r, height: 2 * circle.r});
var j, alpha, beta, fansx, fansy, fanex, faney;
for(j = 0; j < nfans; ++j){
alpha = localStart + (j - FUDGE_FACTOR) * delta;
beta = localStart + (j + 1 + FUDGE_FACTOR) * delta;
fansx = j == 0 ? x1 : circle.cx + r * Math.cos(alpha);
fansy = j == 0 ? y1 : circle.cy + r * Math.sin(alpha);
fanex = j == nfans - 1 ? x2 : circle.cx + r * Math.cos(beta);
faney = j == nfans - 1 ? y2 : circle.cy + r * Math.sin(beta);
this._createSlice(group, circle, r, fansx, fansy, fanex, faney, alpha, delta).
setFill(this._pseudoRadialFill(specialFill, {x: circle.cx, y: circle.cy}, r,
localStart + (j + 0.5) * delta, localStart + (j + 0.5) * delta));
}
stroke = theme.series.stroke;
this._createSlice(group, circle, r, x1, y1, x2, y2, localStart, step).setStroke(stroke);
shape = group;
}else{
stroke = theme.series.stroke;
shape = this._createSlice(s, circle, r, x1, y1, x2, y2, localStart, step).setStroke(stroke);
specialFill = theme.series.fill;
if(specialFill && specialFill.type === "radial"){
specialFill = this._shapeFill(specialFill, {x: circle.cx - circle.r, y: circle.cy - circle.r, width: 2 * circle.r, height: 2 * circle.r});
if(this.opt.radGrad === "linear"){
specialFill = this._pseudoRadialFill(specialFill, {x: circle.cx, y: circle.cy}, r, localStart, localStart + step);
}
}else if(specialFill && specialFill.type === "linear"){
var bbox = lang.clone(shape.getBoundingBox());
if(g.renderer === "svg"){
// Try to fix the bounding box calculations for
// height. Only really works for SVG.
var pos = {w: 0, h: 0};
try{
pos = domGeom.position(shape.rawNode);
}catch(ignore){}
if(pos.h > bbox.height){
bbox.height = pos.h;
}
if(pos.w > bbox.width){
bbox.width = pos.w;
}
}
specialFill = this._plotFill(specialFill, dim, offsets);
specialFill = this._shapeFill(specialFill, bbox);
}
shape.setFill(specialFill);
}
this.dyn.push({fill: specialFill, stroke: theme.series.stroke});
if(events){
o = {
element: "slice",
index: i,
run: this.run,
shape: shape,
x: i,
y: typeof v == "number" ? v : v.y,
cx: circle.cx,
cy: circle.cy,
cr: r
};
this._connectEvents(o);
eventSeries[i] = o;
}
localStart = localStart + step;
return false; // continue
}, this);
// draw labels
if(this.opt.labels){
var isRtl = has("dojo-bidi") && this.chart.isRightToLeft();
if(this.opt.labelStyle == "default"){
start = startAngle;
localStart = start;
arr.some(slices, function(slice, i){
if(slice <= 0 && !this.opt.minWidth){
// degenerated slice
return false; // continue
}
var theme = themes[i];
if(slice >= 1){
// whole pie
this.renderLabel(s, circle.cx, circle.cy + size / 2, labels[i], theme, this.opt.labelOffset > 0);
return true; // stop iteration
}
// calculate the geometry of the slice
var end = start + slice * 2 * Math.PI;
if(i + 1 == slices.length){
end = startAngle + 2 * Math.PI;
}
if(this.opt.omitLabels && end-start < 0.001){
return false; // continue
}
var labelAngle = localStart + (slicesSteps[i].step / 2),//(start + end) / 2,
x = circle.cx + labelR * Math.cos(labelAngle),
y = circle.cy + labelR * Math.sin(labelAngle) + size / 2;
// draw the label
this.renderLabel(s, isRtl ? dim.width - x : x, y, labels[i], theme, this.opt.labelOffset > 0);
localStart += slicesSteps[i].step;
start = end;
return false; // continue
}, this);
}else if(this.opt.labelStyle == "columns"){
//calculate label angles
var omitLabels = this.opt.omitLabels;
start = startAngle;
localStart = start;
var labeledSlices = [],
significantCount = 0, k;
for(k = slices.length - 1; k >= 0; --k){
if(slices[k]){
++significantCount;
}
}
arr.forEach(slices, function(slice, i){
var end = start + slice * 2 * Math.PI;
if(i + 1 == slices.length){
end = startAngle + 2 * Math.PI;
}
if(this.minWidth !== 0 || end - start >= 0.001){
// var labelAngle = (start + end) / 2;
var labelAngle = localStart + (slicesSteps[i].step / 2);//(start + end) / 2,
if(significantCount === 1 && !this.opt.minWidth){
labelAngle = (start + end) / 2;
}
labeledSlices.push({
angle: labelAngle,
left: Math.cos(labelAngle) < 0,
theme: themes[i],
index: i,
omit: omitLabels? end - start < 0.001:false
});
}
start = end;
localStart += slicesSteps[i].step;
}, this);
//calculate label radius to each slice
var labelHeight = g._base._getTextBox("a", {font:taFont, whiteSpace: "nowrap"}).h;
this._getProperLabelRadius(labeledSlices, labelHeight, circle.r * 1.1);
//draw label and wiring
var leftColumn = circle.cx - circle.r * 2,
rightColumn = circle.cx + circle.r * 2;
arr.forEach(labeledSlices, function(slice){
if(slice.omit){
return;
}
var cTheme = themes[slice.index], lrPadding = 0;
if(cTheme && cTheme.axis && cTheme.axis.tick && cTheme.axis.tick.labelGap){
// Try to pad the lable a bit, the same as a tick gap.
lrPadding = cTheme.axis.tick.labelGap;
}
var labelWidth = g._base._getTextBox(labels[slice.index],
{font: cTheme.series.font, whiteSpace: "nowrap", paddingLeft: lrPadding + "px"}).w,
x = circle.cx + slice.labelR * Math.cos(slice.angle),
y = circle.cy + slice.labelR * Math.sin(slice.angle),
jointX = (slice.left) ? (leftColumn + labelWidth) : (rightColumn - labelWidth),
labelX = (slice.left) ? leftColumn : jointX + lrPadding,
newRadius = circle.r,
wiring = s.createPath().moveTo(circle.cx + newRadius * Math.cos(slice.angle),
circle.cy + newRadius * Math.sin(slice.angle));
if(Math.abs(slice.labelR * Math.cos(slice.angle)) < circle.r * 2 - labelWidth){
wiring.lineTo(x, y);
}
wiring.lineTo(jointX, y).setStroke(slice.theme.series.labelWiring);
// Push the wiring to the back so that highlight/magnify actions don't bleed the wire.
wiring.moveToBack();
// Try to adjust the wiring position here. The browser always adds a bit
// of padding on height, so divide by 3 instead of 2.
var mid = labelHeight/3 + y;
var elem = this.renderLabel(s, labelX, mid || 0, labels[slice.index], cTheme, false, "left");
if(events && !this.opt.htmlLabels){
var fontWidth = g._base._getTextBox(labels[slice.index], {font: slice.theme.series.font}).w || 0,
fontHeight = g.normalizedLength(g.splitFontString(slice.theme.series.font).size);
o = {
element: "labels",
index: slice.index,
run: this.run,
shape: elem,
x: labelX,
y: y,
label: labels[slice.index]
};
var shp = elem.getShape(),
lt = domGeom.position(this.chart.node, true),
aroundRect = lang.mixin({ type : 'rect' }, {
x: shp.x,
y: shp.y - 2 * fontHeight
});
aroundRect.x += lt.x;
aroundRect.y += lt.y;
aroundRect.x = Math.round(aroundRect.x);
aroundRect.y = Math.round(aroundRect.y);
aroundRect.width = Math.ceil(fontWidth);
aroundRect.height = Math.ceil(fontHeight);
o.aroundRect = aroundRect;
this._connectEvents(o);
eventSeries[slices.length + slice.index] = o;
}
}, this);
}
}
// post-process events to restore the original indexing
var esi = 0;
this._eventSeries[this.run.name] = df.map(run, function(v){
return v <= 0 ? null : eventSeries[esi++];
});
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
return this; // dojox/charting/plot2d/Pie
},
_getProperLabelRadius: function(slices, labelHeight, minRadius){
if(slices.length == 1){
slices[0].labelR = minRadius;
return;
}
var leftCenterSlice = {}, rightCenterSlice = {}, leftMinSIN = 2, rightMinSIN = 2, i;
var tempSIN;
for(i = 0; i < slices.length; ++i){
tempSIN = Math.abs(Math.sin(slices[i].angle));
if(slices[i].left){
if(leftMinSIN > tempSIN){
leftMinSIN = tempSIN;
leftCenterSlice = slices[i];
}
}else{
if(rightMinSIN > tempSIN){
rightMinSIN = tempSIN;
rightCenterSlice = slices[i];
}
}
}
leftCenterSlice.labelR = rightCenterSlice.labelR = minRadius;
this._caculateLabelR(leftCenterSlice, slices, labelHeight);
this._caculateLabelR(rightCenterSlice, slices, labelHeight);
},
_caculateLabelR: function(firstSlice, slices, labelHeight){
var i, j, k, length = slices.length, currentLabelR = firstSlice.labelR, nextLabelR,
step = slices[firstSlice.index].left ? -labelHeight : labelHeight;
for(k = 0, i = firstSlice.index, j = (i + 1) % length; k < length && slices[i].left === slices[j].left; ++k){
nextLabelR = (Math.sin(slices[i].angle) * currentLabelR + step) / Math.sin(slices[j].angle);
currentLabelR = Math.max(firstSlice.labelR, nextLabelR);
slices[j].labelR = currentLabelR;
i = (i + 1) % length;
j = (j + 1) % length;
}
if(k >= length){
slices[0].labelR = firstSlice.labelR;
}
for(k = 0, i = firstSlice.index, j = (i || length) - 1; k < length && slices[i].left === slices[j].left; ++k){
nextLabelR = (Math.sin(slices[i].angle) * currentLabelR - step) / Math.sin(slices[j].angle);
currentLabelR = Math.max(firstSlice.labelR, nextLabelR);
slices[j].labelR = currentLabelR;
i = (i || length) - 1;
j = (j || length) - 1;
}
},
_createRing: function(group, circle){
var r = this.opt.innerRadius;
if(r > 0){
// Percentage, use circle. Anything < 0 for innerRadius
// is assumed to be a multiple of the radius. So 0.25 innerRadius value
// is computed to be 25% of the outer radius.
r = circle.r * (r/100);
}else if(r < 0){
r = -r; // Assume it is pixels, fixed size hole.
}
if(r){
return group.createPath({}).setAbsoluteMode(true).
moveTo(circle.cx, circle.cy - circle.r).
arcTo(circle.r, circle.r, 0, false, true, circle.cx + circle.r, circle.cy).
arcTo(circle.r, circle.r, 0, true, true, circle.cx, circle.cy - circle.r).
closePath().
moveTo(circle.cx, circle.cy - r).
arcTo(r, r, 0, false, true, circle.cx + r, circle.cy).
arcTo(r, r, 0, true, true, circle.cx, circle.cy - r).
closePath();
}
return group.createCircle(circle);
},
_createSlice: function(group, circle, R, x1, y1, x2, y2, fromAngle, stepAngle){
var r = this.opt.innerRadius;
if(r > 0){
// Percentage, use circle. Anything < 0 for innerRadius
// is assumed to be a multiple of the radius. So 0.25 innerRadius value
// is computed to be 25% of the outer radius.
r = circle.r * (r/100);
}else if(r < 0){
r = -r; // Assume it is pixels, fixed size hole.
}
if(r){
var innerX1 = circle.cx + r * Math.cos(fromAngle),
innerY1 = circle.cy + r * Math.sin(fromAngle),
innerX2 = circle.cx + r * Math.cos(fromAngle + stepAngle),
innerY2 = circle.cy + r * Math.sin(fromAngle + stepAngle);
return group.createPath({}).setAbsoluteMode(true).
moveTo(innerX1, innerY1).
lineTo(x1, y1).
arcTo(R, R, 0, stepAngle > Math.PI, true, x2, y2).
lineTo(innerX2, innerY2).
arcTo(r, r, 0, stepAngle > Math.PI, false, innerX1, innerY1).
closePath();
}
return group.createPath({}).setAbsoluteMode(true).
moveTo(circle.cx, circle.cy).
lineTo(x1, y1).
arcTo(R, R, 0, stepAngle > Math.PI, true, x2, y2).
lineTo(circle.cx, circle.cy).
closePath();
}
});
});
},
'dojox/charting/plot2d/Bubble':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/array", "dojo/has",
"./CartesianBase", "./_PlotEvents", "./common", "dojox/lang/functional",
"dojox/lang/utils", "dojox/gfx/fx"],
function(lang, declare, arr, has, CartesianBase, _PlotEvents, dc, df, du, fx){
return declare("dojox.charting.plot2d.Bubble", [CartesianBase, _PlotEvents], {
// summary:
// A plot representing bubbles. Note that data for Bubbles requires 3 parameters,
// in the form of: { x, y, size }, where size determines the size of the bubble.
defaultParams: {
animate: null // animate bars into place
},
optionalParams: {
// theme component
stroke: {},
outline: {},
shadow: {},
fill: {},
filter: {},
styleFunc: null,
font: "",
fontColor: "",
labelFunc: null
},
constructor: function(chart, kwArgs){
// summary:
// Create a plot of bubbles.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__DefaultCtorArgs?
// Optional keyword arguments object to help define plot parameters.
this.opt = lang.clone(lang.mixin(this.opt, this.defaultParams));
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
if(!this.opt.labelFunc){
this.opt.labelFunc = function(value, fixed, precision){
return this._getLabel(value.size, fixed, precision);
};
}
this.animate = this.opt.animate;
},
// override the render so that we are plotting only circles.
render: function(dim, offsets){
// summary:
// Run the calculations for any axes for this plot.
// dim: Object
// An object in the form of { width, height }
// offsets: Object
// An object of the form { l, r, t, b}.
// returns: dojox/charting/plot2d/Bubble
// A reference to this plot for functional chaining.
var s;
if(this.zoom && !this.isDataDirty()){
return this.performZoom(dim, offsets);
}
this.resetEvents();
this.dirty = this.isDirty();
if(this.dirty){
arr.forEach(this.series, dc.purgeGroup);
this._eventSeries = {};
this.cleanGroup();
s = this.getGroup();
df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
}
var t = this.chart.theme,
ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
events = this.events();
for(var i = 0; i < this.series.length; i++){
var run = this.series[i];
if(!this.dirty && !run.dirty){
t.skip();
this._reconnectEvents(run.name);
continue;
}
run.cleanGroup();
if(!run.data.length){
run.dirty = false;
t.skip();
continue;
}
if(typeof run.data[0] == "number"){
console.warn("dojox.charting.plot2d.Bubble: the data in the following series cannot be rendered as a bubble chart; ", run);
continue;
}
var theme = t.next("circle", [this.opt, run]),
points = arr.map(run.data, function(v){
return v ? {
x: ht(v.x) + offsets.l,
y: dim.height - offsets.b - vt(v.y),
radius: this._vScaler.bounds.scale * (v.size / 2)
} : null;
}, this);
if(run.hidden){
run.dyn.fill = theme.series.fill;
run.dyn.stroke = theme.series.stroke;
continue;
}
s = run.group;
var frontCircles = null, outlineCircles = null, shadowCircles = null, styleFunc = this.opt.styleFunc;
var getFinalTheme = function(item){
if(styleFunc){
return t.addMixin(theme, "circle", [item, styleFunc(item)], true);
}
return t.addMixin(theme, "circle", item, true);
};
// make shadows if needed
if(theme.series.shadow){
shadowCircles = arr.map(points, function(item, i){
if(!this.isNullValue(item)){
var finalTheme = getFinalTheme(run.data[i]),
shadow = finalTheme.series.shadow;
var shape = s.createCircle({
cx: item.x + shadow.dx, cy: item.y + shadow.dy, r: item.radius
}).setStroke(shadow).setFill(shadow.color);
if(this.animate){
this._animateBubble(shape, dim.height - offsets.b, item.radius);
}
return shape;
}
return null;
}, this);
if(shadowCircles.length){
run.dyn.shadow = shadowCircles[shadowCircles.length - 1].getStroke();
}
}
// make outlines if needed
if(theme.series.outline){
outlineCircles = arr.map(points, function(item, i){
if(!this.isNullValue(item)){
var finalTheme = getFinalTheme(run.data[i]),
outline = dc.makeStroke(finalTheme.series.outline);
outline.width = 2 * outline.width + (theme.series.stroke && theme.series.stroke.width || 0);
var shape = s.createCircle({
cx: item.x, cy: item.y, r: item.radius
}).setStroke(outline);
if(this.animate){
this._animateBubble(shape, dim.height - offsets.b, item.radius);
}
return shape;
}
return null;
}, this);
if(outlineCircles.length){
run.dyn.outline = outlineCircles[outlineCircles.length - 1].getStroke();
}
}
// run through the data and add the circles.
frontCircles = arr.map(points, function(item, i){
if(!this.isNullValue(item)){
var finalTheme = getFinalTheme(run.data[i]),
rect = {
x: item.x - item.radius,
y: item.y - item.radius,
width: 2 * item.radius,
height: 2 * item.radius
};
var specialFill = this._plotFill(finalTheme.series.fill, dim, offsets);
specialFill = this._shapeFill(specialFill, rect);
var shape = s.createCircle({
cx: item.x, cy: item.y, r: item.radius
}).setFill(specialFill).setStroke(finalTheme.series.stroke);
if(shape.setFilter && finalTheme.series.filter){
shape.setFilter(finalTheme.series.filter);
}
if(this.animate){
this._animateBubble(shape, dim.height - offsets.b, item.radius);
}
this.createLabel(s, run.data[i], rect, finalTheme);
return shape;
}
return null;
}, this);
if(frontCircles.length){
run.dyn.fill = frontCircles[frontCircles.length - 1].getFill();
run.dyn.stroke = frontCircles[frontCircles.length - 1].getStroke();
}
if(events){
var eventSeries = new Array(frontCircles.length);
arr.forEach(frontCircles, function(s, i){
if(s !== null){
var o = {
element: "circle",
index: i,
run: run,
shape: s,
outline: outlineCircles && outlineCircles[i] || null,
shadow: shadowCircles && shadowCircles[i] || null,
x: run.data[i].x,
y: run.data[i].y,
r: run.data[i].size / 2,
cx: points[i].x,
cy: points[i].y,
cr: points[i].radius
};
this._connectEvents(o);
eventSeries[i] = o;
}
}, this);
this._eventSeries[run.name] = eventSeries;
}else{
delete this._eventSeries[run.name];
}
run.dirty = false;
}
this.dirty = false;
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
return this; // dojox/charting/plot2d/Bubble
},
_animateBubble: function(shape, offset, size){
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: [0, offset], end: [0, 0]},
{name: "scale", start: [0, 1/size], end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/Candlesticks':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/array", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
"dojox/lang/functional", "dojox/lang/utils", "dojox/gfx/fx"],
function(lang, declare, arr, has, CartesianBase, _PlotEvents, dc, df, du, fx){
// Candlesticks are based on the Bars plot type; we expect the following passed
// as values in a series:
// { x?, open, close, high, low, mid? }
// if x is not provided, the array index is used.
// failing to provide the OHLC values will throw an error.
return declare("dojox.charting.plot2d.Candlesticks", [CartesianBase, _PlotEvents], {
// summary:
// A plot that represents typical candlesticks (financial reporting, primarily).
// Unlike most charts, the Candlestick expects data points to be represented by
// an object of the form { x?, open, close, high, low, mid? }, where both
// x and mid are optional parameters. If x is not provided, the index of the
// data array is used.
defaultParams: {
gap: 2, // gap between columns in pixels
animate: null // animate bars into place
},
optionalParams: {
minBarSize: 1, // minimal candle width in pixels
maxBarSize: 1, // maximal candle width in pixels
// theme component
stroke: {},
outline: {},
shadow: {},
fill: {},
font: "",
fontColor: ""
},
constructor: function(chart, kwArgs){
// summary:
// The constructor for a candlestick chart.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__BarCtorArgs?
// An optional keyword arguments object to help define the plot.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.animate = this.opt.animate;
},
collectStats: function(series){
// summary:
// Collect all statistics for drawing this chart. Since the common
// functionality only assumes x and y, Candlesticks must create it's own
// stats (since data has no y value, but open/close/high/low instead).
// series: dojox.charting.Series[]
// The data series array to be drawn on this plot.
// returns: Object
// Returns an object in the form of { hmin, hmax, vmin, vmax }.
// we have to roll our own, since we need to use all four passed
// values to figure out our stats, and common only assumes x and y.
var stats = lang.delegate(dc.defaultStats);
for(var i=0; i= 0; --i){
var run = this.series[i];
if(!this.dirty && !run.dirty){
t.skip();
this._reconnectEvents(run.name);
continue;
}
run.cleanGroup();
var theme = t.next("candlestick", [this.opt, run]),
eventSeries = new Array(run.data.length);
if(run.hidden){
run.dyn.fill = theme.series.fill;
run.dyn.stroke = theme.series.stroke;
continue;
}
s = run.group;
for(var j = 0; j < run.data.length; ++j){
var v = run.data[j];
if(!this.isNullValue(v)){
var finalTheme = t.addMixin(theme, "candlestick", v, true);
// calculate the points we need for OHLC
var x = ht(v.x || (j+0.5)) + offsets.l + gap,
y = dim.height - offsets.b,
open = vt(v.open),
close = vt(v.close),
high = vt(v.high),
low = vt(v.low);
if("mid" in v){
var mid = vt(v.mid);
}
if(low > high){
var tmp = high;
high = low;
low = tmp;
}
if(width >= 1){
// draw the line and rect, set up as a group and pass that to the events.
var doFill = open > close;
var line = { x1: width/2, x2: width/2, y1: y - high, y2: y - low },
rect = {
x: 0, y: y-Math.max(open, close),
width: width, height: Math.max(doFill ? open-close : close-open, 1)
};
var shape = s.createGroup();
shape.setTransform({dx: x, dy: 0 });
var inner = shape.createGroup();
inner.createLine(line).setStroke(finalTheme.series.stroke);
inner.createRect(rect).setStroke(finalTheme.series.stroke).
setFill(doFill ? finalTheme.series.fill : "white");
if("mid" in v){
// add the mid line.
inner.createLine({
x1: (finalTheme.series.stroke ? finalTheme.series.stroke.width || 1 : 1), x2: width - (finalTheme.series.stroke ? finalTheme.series.stroke.width || 1 : 1),
y1: y - mid, y2: y - mid
}).setStroke(doFill ? "white" : finalTheme.series.stroke);
}
// TODO: double check this.
run.dyn.fill = finalTheme.series.fill;
run.dyn.stroke = finalTheme.series.stroke;
if(events){
var o = {
element: "candlestick",
index: j,
run: run,
shape: inner,
x: x,
y: y-Math.max(open, close),
cx: width/2,
cy: (y-Math.max(open, close)) + (Math.max(doFill ? open-close : close-open, 1)/2),
width: width,
height: Math.max(doFill ? open-close : close-open, 1),
data: v
};
this._connectEvents(o);
eventSeries[j] = o;
}
}
if(this.animate){
this._animateCandlesticks(shape, y - low, high - low);
}
}
}
this._eventSeries[run.name] = eventSeries;
run.dirty = false;
}
this.dirty = false;
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
return this; // dojox/charting/plot2d/Candlesticks
},
tooltipFunc: function(o){
return '
'
+ '
Open:
' + o.data.open + '
'
+ '
High:
' + o.data.high + '
'
+ '
Low:
' + o.data.low + '
'
+ '
Close:
' + o.data.close + '
'
+ (o.data.mid !== undefined ? '
Mid:
' + o.data.mid + '
' : '')
+ '
';
},
_animateCandlesticks: function(shape, voffset, vsize){
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: [0, voffset - (voffset/vsize)], end: [0, 0]},
{name: "scale", start: [1, 1/vsize], end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/OHLC':function(){
define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "dojo/has", "./CartesianBase", "./_PlotEvents", "./common",
"dojox/lang/functional", "dojox/lang/utils", "dojox/gfx/fx"],
function(lang, arr, declare, has, CartesianBase, _PlotEvents, dc, df, du, fx){
// Candlesticks are based on the Bars plot type; we expect the following passed
// as values in a series:
// { x?, open, close, high, low }
// if x is not provided, the array index is used.
// failing to provide the OHLC values will throw an error.
return declare("dojox.charting.plot2d.OHLC", [CartesianBase, _PlotEvents], {
// summary:
// A plot that represents typical open/high/low/close (financial reporting, primarily).
// Unlike most charts, the Candlestick expects data points to be represented by
// an object of the form { x?, open, close, high, low, mid? }, where both
// x and mid are optional parameters. If x is not provided, the index of the
// data array is used.
defaultParams: {
gap: 2, // gap between columns in pixels
animate: null // animate chart to place
},
optionalParams: {
minBarSize: 1, // minimal bar size in pixels
maxBarSize: 1, // maximal bar size in pixels
// theme component
stroke: {},
outline: {},
shadow: {},
fill: {},
font: "",
fontColor: ""
},
constructor: function(chart, kwArgs){
// summary:
// The constructor for a candlestick chart.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__BarCtorArgs?
// An optional keyword arguments object to help define the plot.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.animate = this.opt.animate;
},
collectStats: function(series){
// summary:
// Collect all statistics for drawing this chart. Since the common
// functionality only assumes x and y, OHLC must create it's own
// stats (since data has no y value, but open/close/high/low instead).
// series: dojox/charting/Series[]
// The data series array to be drawn on this plot.
// returns: Object
// Returns an object in the form of { hmin, hmax, vmin, vmax }.
// we have to roll our own, since we need to use all four passed
// values to figure out our stats, and common only assumes x and y.
var stats = lang.delegate(dc.defaultStats);
for(var i=0; i high){
var tmp = high;
high = low;
low = tmp;
}
if(width >= 1){
var hl = {x1: width/2, x2: width/2, y1: y - high, y2: y - low},
op = {x1: 0, x2: ((width/2) + ((finalTheme.series.stroke ? finalTheme.series.stroke.width || 1 : 1)/2)), y1: y-open, y2: y-open},
cl = {x1: ((width/2) - ((finalTheme.series.stroke ? finalTheme.series.stroke.width || 1 : 1)/2)), x2: width, y1: y-close, y2: y-close};
var shape = s.createGroup();
shape.setTransform({dx: x, dy: 0});
var inner = shape.createGroup();
inner.createLine(hl).setStroke(finalTheme.series.stroke);
inner.createLine(op).setStroke(finalTheme.series.stroke);
inner.createLine(cl).setStroke(finalTheme.series.stroke);
// TODO: double check this.
run.dyn.stroke = finalTheme.series.stroke;
if(events){
var o = {
element: "candlestick",
index: j,
run: run,
shape: inner,
x: x,
y: y-Math.max(open, close),
cx: width/2,
cy: (y-Math.max(open, close)) + (Math.max(open > close ? open-close : close-open, 1)/2),
width: width,
height: Math.max(open > close ? open-close : close-open, 1),
data: v
};
this._connectEvents(o);
eventSeries[j] = o;
}
}
if(this.animate){
this._animateOHLC(shape, y - low, high - low);
}
}
}
this._eventSeries[run.name] = eventSeries;
run.dirty = false;
}
this.dirty = false;
// chart mirroring starts
if(has("dojo-bidi")){
this._checkOrientation(this.group, dim, offsets);
}
// chart mirroring ends
return this; // dojox/charting/plot2d/OHLC
},
_animateOHLC: function(shape, voffset, vsize){
fx.animateTransform(lang.delegate({
shape: shape,
duration: 1200,
transform: [
{name: "translate", start: [0, voffset - (voffset/vsize)], end: [0, 0]},
{name: "scale", start: [1, 1/vsize], end: [1, 1]},
{name: "original"}
]
}, this.animate)).play();
}
});
});
},
'dojox/charting/plot2d/Spider':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/connect", "dojo/_base/array",
"dojo/dom-geometry", "dojo/_base/fx", "dojo/fx", "dojo/sniff",
"./Base", "./_PlotEvents", "./common", "../axis2d/common",
"dojox/gfx", "dojox/gfx/matrix", "dojox/gfx/fx", "dojox/lang/functional",
"dojox/lang/utils", "dojo/fx/easing"],
function(lang, declare, hub, arr, domGeom, baseFx, coreFx, has,
Base, PlotEvents, dc, da, g, m, gfxfx, df, du, easing){
var FUDGE_FACTOR = 0.2; // use to overlap fans
var Spider = declare("dojox.charting.plot2d.Spider", [Base, PlotEvents], {
// summary:
// The plot that represents a typical Spider chart.
defaultParams: {
labels: true,
ticks: false,
fixed: true,
precision: 1,
labelOffset: -10,
labelStyle: "default", // default/rows/auto
htmlLabels: true, // use HTML to draw labels
startAngle: -90, // start angle for slices in degrees
divisions: 3, // radius tick count
axisColor: "", // spider axis color
axisWidth: 0, // spider axis stroke width
spiderColor: "", // spider web color
spiderWidth: 0, // spider web stroke width
seriesWidth: 0, // plot border with
seriesFillAlpha: 0.2, // plot fill alpha
spiderOrigin: 0.16,
markerSize: 3, // radius of plot vertex (px)
spiderType: "polygon", //"circle"
animationType: easing.backOut,
animate: null,
axisTickFont: "",
axisTickFontColor: "",
axisFont: "",
axisFontColor: ""
},
optionalParams: {
radius: 0,
font: "",
fontColor: ""
},
constructor: function(chart, kwArgs){
// summary:
// Create a Spider plot.
// chart: dojox/charting/Chart
// The chart this plot belongs to.
// kwArgs: dojox.charting.plot2d.__DefaultCtorArgs?
// An optional keyword arguments object to help define this plot's parameters.
this.opt = lang.clone(this.defaultParams);
du.updateWithObject(this.opt, kwArgs);
du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
this.dyn = [];
this.datas = {};
this.labelKey = [];
this.oldSeriePoints = {};
this.animate = this.opt.animate === null ? {} : this.opt.animate;
this.animations = {};
},
clear: function(){
// summary:
// Clear out all of the information tied to this plot.
// returns: dojox/charting/plot2d/Spider
// A reference to this plot for functional chaining.
this.inherited(arguments);
this.dyn = [];
this.axes = [];
this.datas = {};
this.labelKey = [];
this.oldSeriePoints = {};
this.animations = {};
return this; // dojox/charting/plot2d/Spider
},
setAxis: function(axis){
// summary:
// Optionally set axis min and max property.
// returns: dojox/charting/plot2d/Spider
// The reference to this plot for functional chaining.
// override the computed min/max with provided values if any
if(axis){
if(axis.opt.min != undefined){
this.datas[axis.name].min = axis.opt.min;
}
if(axis.opt.max != undefined){
this.datas[axis.name].max = axis.opt.max;
}
}
return this; // dojox/charting/plot2d/Spider
},
addSeries: function(run){
// summary:
// Add a data series to this plot.
// run: dojox.charting.Series
// The series to be added.
// returns: dojox/charting/plot2d/Base
// A reference to this plot for functional chaining.
this.series.push(run);
var key;
for(key in run.data){
var val = run.data[key],
data = this.datas[key];
if(data){
data.vlist.push(val);
data.min = Math.min(data.min, val);
data.max = Math.max(data.max, val);
}else{
var axisKey = "__"+key;
this.axes.push(axisKey);
this[axisKey] = key;
this.datas[key] = {min: val, max: val, vlist: [val]};
}
}
if(this.labelKey.length <= 0){
for(key in run.data){
this.labelKey.push(key);
}
}
return this; // dojox.charting.plot2d.Base
},
getSeriesStats: function(){
// summary:
// Calculate the min/max on all attached series in both directions.
// returns: Object
// {hmin, hmax, vmin, vmax} min/max in both directions.
return dc.collectSimpleStats(this.series, function(v){ return v === null; }); // Object
},
render: function(dim, offsets){
// summary:
// Render the plot on the chart.
// dim: Object
// An object of the form { width, height }.
// offsets: Object
// An object of the form { l, r, t, b }.
// returns: dojox/charting/plot2d/Spider
// A reference to this plot for functional chaining.
if(!this.dirty){ return this; }
this.dirty = false;
this.cleanGroup();
var s = this.group, t = this.chart.theme;
this.resetEvents();
if(!this.series || !this.series.length){
return this;
}
// calculate the geometry
var o = this.opt, ta = t.axis,
rx = (dim.width - offsets.l - offsets.r) / 2,
ry = (dim.height - offsets.t - offsets.b) / 2,
r = Math.min(rx, ry),
axisTickFont = o.font || (ta.majorTick && ta.majorTick.font) || (ta.tick && ta.tick.font) || "normal normal normal 7pt Tahoma",
axisFont = o.axisFont || (ta.tick && ta.tick.titleFont) || "normal normal normal 11pt Tahoma",
axisTickFontColor = o.axisTickFontColor || (ta.majorTick && ta.majorTick.fontColor) || (ta.tick && ta.tick.fontColor) || "silver",
axisFontColor = o.axisFontColor || (ta.tick && ta.tick.titleFontColor) || "black",
axisColor = o.axisColor || (ta.tick && ta.tick.axisColor) || "silver",
spiderColor = o.spiderColor || (ta.tick && ta.tick.spiderColor) || "silver",
axisWidth = o.axisWidth || (ta.stroke && ta.stroke.width) || 2,
spiderWidth = o.spiderWidth || (ta.stroke && ta.stroke.width) || 2,
seriesWidth = o.seriesWidth || (ta.stroke && ta.stroke.width) || 2,
asize = g.normalizedLength(g.splitFontString(axisFont).size),
startAngle = m._degToRad(o.startAngle),
start = startAngle, labels, shift, labelR,
outerPoints, innerPoints, divisionPoints, divisionRadius, labelPoints,
ro = o.spiderOrigin, dv = o.divisions >= 3 ? o.divisions : 3, ms = o.markerSize,
spt = o.spiderType, at = o.animationType, lboffset = o.labelOffset < -10 ? o.labelOffset : -10,
axisExtra = 0.2,
i, j, point, len, fontWidth, render, serieEntry, run, data, min, max, distance;
if(o.labels){
labels = arr.map(this.series, function(s){
return s.name;
}, this);
shift = df.foldl1(df.map(labels, function(label){
var font = t.series.font;
return g._base._getTextBox(label, {
font: font
}).w;
}, this), "Math.max(a, b)") / 2;
r = Math.min(rx - 2 * shift, ry - asize) + lboffset;
labelR = r - lboffset;
}
if("radius" in o){
r = o.radius;
labelR = r - lboffset;
}
r /= (1+axisExtra);
var circle = {
cx: offsets.l + rx,
cy: offsets.t + ry,
r: r
};
for(var i = 0; i < this.series.length; i++){
serieEntry = this.series[i];
if(!this.dirty && !serieEntry.dirty){
t.skip();
continue;
}
serieEntry.cleanGroup();
run = serieEntry.data;
if(run !== null){
len = this._getObjectLength(run);
//construct connect points
if(!outerPoints || outerPoints.length <= 0){
outerPoints = [], innerPoints = [], labelPoints = [];
this._buildPoints(outerPoints, len, circle, r, start, true, dim);
this._buildPoints(innerPoints, len, circle, r*ro, start, true, dim);
this._buildPoints(labelPoints, len, circle, labelR, start, false, dim);
if(dv > 2){
divisionPoints = [], divisionRadius = [];
for (j = 0; j < dv - 2; j++){
divisionPoints[j] = [];
this._buildPoints(divisionPoints[j], len, circle, r*(ro + (1-ro)*(j+1)/(dv-1)), start, true, dim);
divisionRadius[j] = r*(ro + (1-ro)*(j+1)/(dv-1));
}
}
}
}
}
//draw Spider
//axis
var axisGroup = s.createGroup(), axisStroke = {color: axisColor, width: axisWidth},
spiderStroke = {color: spiderColor, width: spiderWidth};
for (j = outerPoints.length - 1; j >= 0; --j){
point = outerPoints[j];
var st = {
x: point.x + (point.x - circle.cx) * axisExtra,
y: point.y + (point.y - circle.cy) * axisExtra
},
nd = {
x: point.x + (point.x - circle.cx) * axisExtra / 2,
y: point.y + (point.y - circle.cy) * axisExtra / 2
};
axisGroup.createLine({
x1: circle.cx,
y1: circle.cy,
x2: st.x,
y2: st.y
}).setStroke(axisStroke);
//arrow
this._drawArrow(axisGroup, st, nd, axisStroke);
}
// draw the label
var labelGroup = s.createGroup();
for (j = labelPoints.length - 1; j >= 0; --j){
point = labelPoints[j];
fontWidth = g._base._getTextBox(this.labelKey[j], {font: axisFont}).w || 0;
render = this.opt.htmlLabels && g.renderer != "vml" ? "html" : "gfx";
var elem = da.createText[render](this.chart, labelGroup, (!domGeom.isBodyLtr() && render == "html") ? (point.x + fontWidth - dim.width) : point.x, point.y,
"middle", this.labelKey[j], axisFont, axisFontColor);
if(this.opt.htmlLabels){
this.htmlElements.push(elem);
}
}
//spider web: polygon or circle
var spiderGroup = s.createGroup();
if(spt == "polygon"){
spiderGroup.createPolyline(outerPoints).setStroke(spiderStroke);
spiderGroup.createPolyline(innerPoints).setStroke(spiderStroke);
if(divisionPoints.length > 0){
for (j = divisionPoints.length - 1; j >= 0; --j){
spiderGroup.createPolyline(divisionPoints[j]).setStroke(spiderStroke);
}
}
}else{//circle
spiderGroup.createCircle({cx: circle.cx, cy: circle.cy, r: r}).setStroke(spiderStroke);
spiderGroup.createCircle({cx: circle.cx, cy: circle.cy, r: r*ro}).setStroke(spiderStroke);
if(divisionRadius.length > 0){
for (j = divisionRadius.length - 1; j >= 0; --j){
spiderGroup.createCircle({cx: circle.cx, cy: circle.cy, r: divisionRadius[j]}).setStroke(spiderStroke);
}
}
}
//text
len = this._getObjectLength(this.datas);
var textGroup = s.createGroup(), k = 0;
for(var key in this.datas){
data = this.datas[key];
min = data.min;
max = data.max;
distance = max - min;
end = start + 2 * Math.PI * k / len;
for (i = 0; i < dv; i++){
var text = min + distance*i/(dv-1);
point = this._getCoordinate(circle, r*(ro + (1-ro)*i/(dv-1)), end, dim);
text = this._getLabel(text);
fontWidth = g._base._getTextBox(text, {font: axisTickFont}).w || 0;
render = this.opt.htmlLabels && g.renderer != "vml" ? "html" : "gfx";
if(this.opt.htmlLabels){
this.htmlElements.push(da.createText[render]
(this.chart, textGroup, (!domGeom.isBodyLtr() && render == "html") ? (point.x + fontWidth - dim.width) : point.x, point.y,
"start", text, axisTickFont, axisTickFontColor));
}
}
k++;
}
//draw series (animation)
this.chart.seriesShapes = {};
for (i = this.series.length - 1; i >= 0; i--){
serieEntry = this.series[i];
run = serieEntry.data;
if(run !== null){
var theme = t.next("spider", [o, serieEntry]),
f = g.normalizeColor(theme.series.fill),
sk = {color: theme.series.fill, width: seriesWidth};
f.a = o.seriesFillAlpha;
serieEntry.dyn = {fill: f, stroke: sk};
if(serieEntry.hidden){
continue;
}
//series polygon
var seriePoints = [], tipData = [];
k = 0;
for(key in run){
data = this.datas[key];
min = data.min;
max = data.max;
distance = max - min;
var entry = run[key], end = start + 2 * Math.PI * k / len;
point = this._getCoordinate(circle, r*(ro + (1-ro)*(entry-min)/distance), end, dim);
seriePoints.push(point);
tipData.push({sname: serieEntry.name, key: key, data: entry});
k++;
}
seriePoints[seriePoints.length] = seriePoints[0];
tipData[tipData.length] = tipData[0];
var polygonBoundRect = this._getBoundary(seriePoints),
ts = serieEntry.group;
var osps = this.oldSeriePoints[serieEntry.name];
var cs = this._createSeriesEntry(ts, (osps || innerPoints), seriePoints, f, sk, r, ro, ms, at);
this.chart.seriesShapes[serieEntry.name] = cs;
this.oldSeriePoints[serieEntry.name] = seriePoints;
var po = {
element: "spider_poly",
index: i,
id: "spider_poly_"+serieEntry.name,
run: serieEntry,
plot: this,
shape: cs.poly,
parent: ts,
brect: polygonBoundRect,
cx: circle.cx,
cy: circle.cy,
cr: r,
f: f,
s: s
};
this._connectEvents(po);
var so = {
element: "spider_plot",
index: i,
id: "spider_plot_"+serieEntry.name,
run: serieEntry,
plot: this,
shape: serieEntry.group
};
this._connectEvents(so);
arr.forEach(cs.circles, function(c, i){
var co = {
element: "spider_circle",
index: i,
id: "spider_circle_"+serieEntry.name+i,
run: serieEntry,
plot: this,
shape: c,
parent: ts,
tdata: tipData[i],
cx: seriePoints[i].x,
cy: seriePoints[i].y,
f: f,
s: s
};
this._connectEvents(co);
}, this);
}
}
return this; // dojox/charting/plot2d/Spider
},
_createSeriesEntry: function(ts, osps, sps, f, sk, r, ro, ms, at){
//polygon
var initpoints = this.animate?osps:sps;
var spoly = ts.createPolyline(initpoints).setFill(f).setStroke(sk), scircle = [];
for (var j = 0; j < initpoints.length; j++){
var point = initpoints[j], cr = ms;
var circle = ts.createCircle({cx: point.x, cy: point.y, r: cr}).setFill(f).setStroke(sk);
scircle.push(circle);
}
if(this.animate) {
var anims = arr.map(sps, function (np, j) {
// create animation
var sp = osps[j],
anim = new baseFx.Animation(lang.delegate({
duration: 1000,
easing: at,
curve: [sp.y, np.y]
}, this.animate));
var spl = spoly, sc = scircle[j];
hub.connect(anim, "onAnimate", function (y) {
//apply poly
var pshape = spl.getShape();
pshape.points[j].y = y;
spl.setShape(pshape);
//apply circle
var cshape = sc.getShape();
cshape.cy = y;
sc.setShape(cshape);
});
return anim;
}, this);
var anims1 = arr.map(sps, function (np, j) {
// create animation
var sp = osps[j],
anim = new baseFx.Animation(lang.delegate({
duration: 1000,
easing: at,
curve: [sp.x, np.x]
}, this.animate));
var spl = spoly, sc = scircle[j];
hub.connect(anim, "onAnimate", function (x) {
//apply poly
var pshape = spl.getShape();
pshape.points[j].x = x;
spl.setShape(pshape);
//apply circle
var cshape = sc.getShape();
cshape.cx = x;
sc.setShape(cshape);
});
return anim;
}, this);
var masterAnimation = coreFx.combine(anims.concat(anims1)); //dojo.fx.chain(anims);
masterAnimation.play();
}
return {group :ts, poly: spoly, circles: scircle};
},
plotEvent: function(o){
// summary:
// Stub function for use by specific plots.
// o: Object
// An object intended to represent event parameters.
if(o.element == "spider_plot"){
//dojo gfx function "moveToFront" not work in IE
if(o.type == "onmouseover" && !has("ie")){
o.shape.moveToFront();
}
}
},
tooltipFunc: function(o){
if(o.element == "spider_circle"){
return o.tdata.sname + " " + o.tdata.key + " " + o.tdata.data;
}else{
return null;
}
},
_getBoundary: function(points){
var xmax = points[0].x,
xmin = points[0].x,
ymax = points[0].y,
ymin = points[0].y;
for(var i = 0; i < points.length; i++){
var point = points[i];
xmax = Math.max(point.x, xmax);
ymax = Math.max(point.y, ymax);
xmin = Math.min(point.x, xmin);
ymin = Math.min(point.y, ymin);
}
return {
x: xmin,
y: ymin,
width: xmax - xmin,
height: ymax - ymin
};
},
_drawArrow: function(s, start, end, stroke){
var len = Math.sqrt(Math.pow(end.x - start.x, 2) + Math.pow(end.y - start.y, 2)),
sin = (end.y - start.y)/len, cos = (end.x - start.x)/len,
point2 = {x: end.x + (len/3)*(-sin), y: end.y + (len/3)*cos},
point3 = {x: end.x + (len/3)*sin, y: end.y + (len/3)*(-cos)};
s.createPolyline([start, point2, point3]).setFill(stroke.color).setStroke(stroke);
},
_buildPoints: function(points, count, circle, radius, angle, recursive, dim){
for(var i = 0; i < count; i++){
var end = angle + 2 * Math.PI * i / count;
points.push(this._getCoordinate(circle, radius, end, dim));
}
if(recursive){
points.push(this._getCoordinate(circle, radius, angle + 2 * Math.PI, dim));
}
},
_getCoordinate: function(circle, radius, angle, dim){
var x = circle.cx + radius * Math.cos(angle);
if(has("dojo-bidi") && this.chart.isRightToLeft() && dim){
x = dim.width - x;
}
return {
x: x,
y: circle.cy + radius * Math.sin(angle)
}
},
_getObjectLength: function(obj){
var count = 0;
if(lang.isObject(obj)){
for(var key in obj){
count++;
}
}
return count;
},
// utilities
_getLabel: function(number){
return dc.getLabel(number, this.opt.fixed, this.opt.precision);
}
});
return Spider; // dojox/plot2d/Spider
});
},
'dojo/fx':function(){
define([
"./_base/lang",
"./Evented",
"./_base/kernel",
"./_base/array",
"./aspect",
"./_base/fx",
"./dom",
"./dom-style",
"./dom-geometry",
"./ready",
"require" // for context sensitive loading of Toggler
], function(lang, Evented, dojo, arrayUtil, aspect, baseFx, dom, domStyle, geom, ready, require){
// module:
// dojo/fx
// For back-compat, remove in 2.0.
if(!dojo.isAsync){
ready(0, function(){
var requires = ["./fx/Toggler"];
require(requires); // use indirection so modules not rolled into a build
});
}
var coreFx = dojo.fx = {
// summary:
// Effects library on top of Base animations
};
var _baseObj = {
_fire: function(evt, args){
if(this[evt]){
this[evt].apply(this, args||[]);
}
return this;
}
};
var _chain = function(animations){
this._index = -1;
this._animations = animations||[];
this._current = this._onAnimateCtx = this._onEndCtx = null;
this.duration = 0;
arrayUtil.forEach(this._animations, function(a){
if(a){
if(typeof a.duration != "undefined"){
this.duration += a.duration;
}
if(a.delay){
this.duration += a.delay;
}
}
}, this);
};
_chain.prototype = new Evented();
lang.extend(_chain, {
_onAnimate: function(){
this._fire("onAnimate", arguments);
},
_onEnd: function(){
this._onAnimateCtx.remove();
this._onEndCtx.remove();
this._onAnimateCtx = this._onEndCtx = null;
if(this._index + 1 == this._animations.length){
this._fire("onEnd");
}else{
// switch animations
this._current = this._animations[++this._index];
this._onAnimateCtx = aspect.after(this._current, "onAnimate", lang.hitch(this, "_onAnimate"), true);
this._onEndCtx = aspect.after(this._current, "onEnd", lang.hitch(this, "_onEnd"), true);
this._current.play(0, true);
}
},
play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
if(!this._current){ this._current = this._animations[this._index = 0]; }
if(!gotoStart && this._current.status() == "playing"){ return this; }
var beforeBegin = aspect.after(this._current, "beforeBegin", lang.hitch(this, function(){
this._fire("beforeBegin");
}), true),
onBegin = aspect.after(this._current, "onBegin", lang.hitch(this, function(arg){
this._fire("onBegin", arguments);
}), true),
onPlay = aspect.after(this._current, "onPlay", lang.hitch(this, function(arg){
this._fire("onPlay", arguments);
beforeBegin.remove();
onBegin.remove();
onPlay.remove();
}));
if(this._onAnimateCtx){
this._onAnimateCtx.remove();
}
this._onAnimateCtx = aspect.after(this._current, "onAnimate", lang.hitch(this, "_onAnimate"), true);
if(this._onEndCtx){
this._onEndCtx.remove();
}
this._onEndCtx = aspect.after(this._current, "onEnd", lang.hitch(this, "_onEnd"), true);
this._current.play.apply(this._current, arguments);
return this;
},
pause: function(){
if(this._current){
var e = aspect.after(this._current, "onPause", lang.hitch(this, function(arg){
this._fire("onPause", arguments);
e.remove();
}), true);
this._current.pause();
}
return this;
},
gotoPercent: function(/*Decimal*/percent, /*Boolean?*/ andPlay){
this.pause();
var offset = this.duration * percent;
this._current = null;
arrayUtil.some(this._animations, function(a, index){
if(offset <= a.duration){
this._current = a;
this._index = index;
return true;
}
offset -= a.duration;
return false;
}, this);
if(this._current){
this._current.gotoPercent(offset / this._current.duration);
}
if (andPlay) { this.play(); }
return this;
},
stop: function(/*boolean?*/ gotoEnd){
if(this._current){
if(gotoEnd){
for(; this._index + 1 < this._animations.length; ++this._index){
this._animations[this._index].stop(true);
}
this._current = this._animations[this._index];
}
var e = aspect.after(this._current, "onStop", lang.hitch(this, function(arg){
this._fire("onStop", arguments);
e.remove();
}), true);
this._current.stop();
}
return this;
},
status: function(){
return this._current ? this._current.status() : "stopped";
},
destroy: function(){
this.stop();
if(this._onAnimateCtx){ this._onAnimateCtx.remove(); }
if(this._onEndCtx){ this._onEndCtx.remove(); }
}
});
lang.extend(_chain, _baseObj);
coreFx.chain = function(/*dojo/_base/fx.Animation[]*/ animations){
// summary:
// Chain a list of `dojo/_base/fx.Animation`s to run in sequence
//
// description:
// Return a `dojo/_base/fx.Animation` which will play all passed
// `dojo/_base/fx.Animation` instances in sequence, firing its own
// synthesized events simulating a single animation. (eg:
// onEnd of this animation means the end of the chain,
// not the individual animations within)
//
// example:
// Once `node` is faded out, fade in `otherNode`
// | require(["dojo/fx"], function(fx){
// | fx.chain([
// | fx.fadeIn({ node:node }),
// | fx.fadeOut({ node:otherNode })
// | ]).play();
// | });
//
return new _chain(lang.isArray(animations) ? animations : Array.prototype.slice.call(animations, 0)); // dojo/_base/fx.Animation
};
var _combine = function(animations){
this._animations = animations||[];
this._connects = [];
this._finished = 0;
this.duration = 0;
arrayUtil.forEach(animations, function(a){
var duration = a.duration;
if(a.delay){ duration += a.delay; }
if(this.duration < duration){ this.duration = duration; }
this._connects.push(aspect.after(a, "onEnd", lang.hitch(this, "_onEnd"), true));
}, this);
this._pseudoAnimation = new baseFx.Animation({curve: [0, 1], duration: this.duration});
var self = this;
arrayUtil.forEach(["beforeBegin", "onBegin", "onPlay", "onAnimate", "onPause", "onStop", "onEnd"],
function(evt){
self._connects.push(aspect.after(self._pseudoAnimation, evt,
function(){ self._fire(evt, arguments); },
true));
}
);
};
lang.extend(_combine, {
_doAction: function(action, args){
arrayUtil.forEach(this._animations, function(a){
a[action].apply(a, args);
});
return this;
},
_onEnd: function(){
if(++this._finished > this._animations.length){
this._fire("onEnd");
}
},
_call: function(action, args){
var t = this._pseudoAnimation;
t[action].apply(t, args);
},
play: function(/*int?*/ delay, /*Boolean?*/ gotoStart){
this._finished = 0;
this._doAction("play", arguments);
this._call("play", arguments);
return this;
},
pause: function(){
this._doAction("pause", arguments);
this._call("pause", arguments);
return this;
},
gotoPercent: function(/*Decimal*/percent, /*Boolean?*/ andPlay){
var ms = this.duration * percent;
arrayUtil.forEach(this._animations, function(a){
a.gotoPercent(a.duration < ms ? 1 : (ms / a.duration), andPlay);
});
this._call("gotoPercent", arguments);
return this;
},
stop: function(/*boolean?*/ gotoEnd){
this._doAction("stop", arguments);
this._call("stop", arguments);
return this;
},
status: function(){
return this._pseudoAnimation.status();
},
destroy: function(){
this.stop();
arrayUtil.forEach(this._connects, function(handle){
handle.remove();
});
}
});
lang.extend(_combine, _baseObj);
coreFx.combine = function(/*dojo/_base/fx.Animation[]*/ animations){
// summary:
// Combine a list of `dojo/_base/fx.Animation`s to run in parallel
//
// description:
// Combine an array of `dojo/_base/fx.Animation`s or N
// `dojo/_base/fx.Animation`s to run in parallel, providing
// a new `dojo/_base/fx.Animation` instance encompassing each
// animation, firing standard animation events.
//
// example:
// Fade out `node` while fading in `otherNode` simultaneously
// | require(["dojo/fx"], function(fx){
// | fx.combine([
// | fx.fadeIn({ node:node }),
// | fx.fadeOut({ node:otherNode })
// | ]).play();
// | });
//
// example:
// When the longest animation ends, execute a function:
// | require(["dojo/fx"], function(fx){
// | var anim = fx.combine([
// | fx.fadeIn({ node: n, duration:700 }),
// | fx.fadeOut({ node: otherNode, duration: 300 })
// | ]);
// | aspect.after(anim, "onEnd", function(){
// | // overall animation is done.
// | }, true);
// | anim.play(); // play the animation
// | });
//
return new _combine(lang.isArray(animations) ? animations : Array.prototype.slice.call(animations, 0)); // dojo/_base/fx.Animation
};
coreFx.wipeIn = function(/*Object*/ args){
// summary:
// Expand a node to it's natural height.
//
// description:
// Returns an animation that will expand the
// node defined in 'args' object from it's current height to
// it's natural height (with no scrollbar).
// Node must have no margin/border/padding.
//
// args: Object
// A hash-map of standard `dojo/_base/fx.Animation` constructor properties
// (such as easing: node: duration: and so on)
//
// example:
// | require(["dojo/fx"], function(fx){
// | fx.wipeIn({
// | node:"someId"
// | }).play()
// | });
var node = args.node = dom.byId(args.node), s = node.style, o;
var anim = baseFx.animateProperty(lang.mixin({
properties: {
height: {
// wrapped in functions so we wait till the last second to query (in case value has changed)
start: function(){
// start at current [computed] height, but use 1px rather than 0
// because 0 causes IE to display the whole panel
o = s.overflow;
s.overflow = "hidden";
if(s.visibility == "hidden" || s.display == "none"){
s.height = "1px";
s.display = "";
s.visibility = "";
return 1;
}else{
var height = domStyle.get(node, "height");
return Math.max(height, 1);
}
},
end: function(){
return node.scrollHeight;
}
}
}
}, args));
var fini = function(){
s.height = "auto";
s.overflow = o;
};
aspect.after(anim, "onStop", fini, true);
aspect.after(anim, "onEnd", fini, true);
return anim; // dojo/_base/fx.Animation
};
coreFx.wipeOut = function(/*Object*/ args){
// summary:
// Shrink a node to nothing and hide it.
//
// description:
// Returns an animation that will shrink node defined in "args"
// from it's current height to 1px, and then hide it.
//
// args: Object
// A hash-map of standard `dojo/_base/fx.Animation` constructor properties
// (such as easing: node: duration: and so on)
//
// example:
// | require(["dojo/fx"], function(fx){
// | fx.wipeOut({ node:"someId" }).play()
// | });
var node = args.node = dom.byId(args.node), s = node.style, o;
var anim = baseFx.animateProperty(lang.mixin({
properties: {
height: {
end: 1 // 0 causes IE to display the whole panel
}
}
}, args));
aspect.after(anim, "beforeBegin", function(){
o = s.overflow;
s.overflow = "hidden";
s.display = "";
}, true);
var fini = function(){
s.overflow = o;
s.height = "auto";
s.display = "none";
};
aspect.after(anim, "onStop", fini, true);
aspect.after(anim, "onEnd", fini, true);
return anim; // dojo/_base/fx.Animation
};
coreFx.slideTo = function(/*Object*/ args){
// summary:
// Slide a node to a new top/left position
//
// description:
// Returns an animation that will slide "node"
// defined in args Object from its current position to
// the position defined by (args.left, args.top).
//
// args: Object
// A hash-map of standard `dojo/_base/fx.Animation` constructor properties
// (such as easing: node: duration: and so on). Special args members
// are `top` and `left`, which indicate the new position to slide to.
//
// example:
// | .slideTo({ node: node, left:"40", top:"50", units:"px" }).play()
var node = args.node = dom.byId(args.node),
top = null, left = null;
var init = (function(n){
return function(){
var cs = domStyle.getComputedStyle(n);
var pos = cs.position;
top = (pos == 'absolute' ? n.offsetTop : parseInt(cs.top) || 0);
left = (pos == 'absolute' ? n.offsetLeft : parseInt(cs.left) || 0);
if(pos != 'absolute' && pos != 'relative'){
var ret = geom.position(n, true);
top = ret.y;
left = ret.x;
n.style.position="absolute";
n.style.top=top+"px";
n.style.left=left+"px";
}
};
})(node);
init();
var anim = baseFx.animateProperty(lang.mixin({
properties: {
top: args.top || 0,
left: args.left || 0
}
}, args));
aspect.after(anim, "beforeBegin", init, true);
return anim; // dojo/_base/fx.Animation
};
return coreFx;
});
},
'dojo/fx/easing':function(){
define(["../_base/lang"], function(lang){
// module:
// dojo/fx/easing
var easingFuncs = {
// summary:
// Collection of easing functions to use beyond the default
// `dojo._defaultEasing` function.
// description:
// Easing functions are used to manipulate the iteration through
// an `dojo.Animation`s _Line. _Line being the properties of an Animation,
// and the easing function progresses through that Line determining
// how quickly (or slowly) it should go. Or more accurately: modify
// the value of the _Line based on the percentage of animation completed.
//
// All functions follow a simple naming convention of "ease type" + "when".
// If the name of the function ends in Out, the easing described appears
// towards the end of the animation. "In" means during the beginning,
// and InOut means both ranges of the Animation will applied, both
// beginning and end.
//
// One does not call the easing function directly, it must be passed to
// the `easing` property of an animation.
// example:
// | dojo.require("dojo.fx.easing");
// | var anim = dojo.fadeOut({
// | node: 'node',
// | duration: 2000,
// | // note there is no ()
// | easing: dojo.fx.easing.quadIn
// | }).play();
//
linear: function(/* Decimal? */n){
// summary:
// A linear easing function
return n;
},
quadIn: function(/* Decimal? */n){
return Math.pow(n, 2);
},
quadOut: function(/* Decimal? */n){
return n * (n - 2) * -1;
},
quadInOut: function(/* Decimal? */n){
n = n * 2;
if(n < 1){ return Math.pow(n, 2) / 2; }
return -1 * ((--n) * (n - 2) - 1) / 2;
},
cubicIn: function(/* Decimal? */n){
return Math.pow(n, 3);
},
cubicOut: function(/* Decimal? */n){
return Math.pow(n - 1, 3) + 1;
},
cubicInOut: function(/* Decimal? */n){
n = n * 2;
if(n < 1){ return Math.pow(n, 3) / 2; }
n -= 2;
return (Math.pow(n, 3) + 2) / 2;
},
quartIn: function(/* Decimal? */n){
return Math.pow(n, 4);
},
quartOut: function(/* Decimal? */n){
return -1 * (Math.pow(n - 1, 4) - 1);
},
quartInOut: function(/* Decimal? */n){
n = n * 2;
if(n < 1){ return Math.pow(n, 4) / 2; }
n -= 2;
return -1 / 2 * (Math.pow(n, 4) - 2);
},
quintIn: function(/* Decimal? */n){
return Math.pow(n, 5);
},
quintOut: function(/* Decimal? */n){
return Math.pow(n - 1, 5) + 1;
},
quintInOut: function(/* Decimal? */n){
n = n * 2;
if(n < 1){ return Math.pow(n, 5) / 2; }
n -= 2;
return (Math.pow(n, 5) + 2) / 2;
},
sineIn: function(/* Decimal? */n){
return -1 * Math.cos(n * (Math.PI / 2)) + 1;
},
sineOut: function(/* Decimal? */n){
return Math.sin(n * (Math.PI / 2));
},
sineInOut: function(/* Decimal? */n){
return -1 * (Math.cos(Math.PI * n) - 1) / 2;
},
expoIn: function(/* Decimal? */n){
return (n == 0) ? 0 : Math.pow(2, 10 * (n - 1));
},
expoOut: function(/* Decimal? */n){
return (n == 1) ? 1 : (-1 * Math.pow(2, -10 * n) + 1);
},
expoInOut: function(/* Decimal? */n){
if(n == 0){ return 0; }
if(n == 1){ return 1; }
n = n * 2;
if(n < 1){ return Math.pow(2, 10 * (n - 1)) / 2; }
--n;
return (-1 * Math.pow(2, -10 * n) + 2) / 2;
},
circIn: function(/* Decimal? */n){
return -1 * (Math.sqrt(1 - Math.pow(n, 2)) - 1);
},
circOut: function(/* Decimal? */n){
n = n - 1;
return Math.sqrt(1 - Math.pow(n, 2));
},
circInOut: function(/* Decimal? */n){
n = n * 2;
if(n < 1){ return -1 / 2 * (Math.sqrt(1 - Math.pow(n, 2)) - 1); }
n -= 2;
return 1 / 2 * (Math.sqrt(1 - Math.pow(n, 2)) + 1);
},
backIn: function(/* Decimal? */n){
// summary:
// An easing function that starts away from the target,
// and quickly accelerates towards the end value.
//
// Use caution when the easing will cause values to become
// negative as some properties cannot be set to negative values.
var s = 1.70158;
return Math.pow(n, 2) * ((s + 1) * n - s);
},
backOut: function(/* Decimal? */n){
// summary:
// An easing function that pops past the range briefly, and slowly comes back.
// description:
// An easing function that pops past the range briefly, and slowly comes back.
//
// Use caution when the easing will cause values to become negative as some
// properties cannot be set to negative values.
n = n - 1;
var s = 1.70158;
return Math.pow(n, 2) * ((s + 1) * n + s) + 1;
},
backInOut: function(/* Decimal? */n){
// summary:
// An easing function combining the effects of `backIn` and `backOut`
// description:
// An easing function combining the effects of `backIn` and `backOut`.
// Use caution when the easing will cause values to become negative
// as some properties cannot be set to negative values.
var s = 1.70158 * 1.525;
n = n * 2;
if(n < 1){ return (Math.pow(n, 2) * ((s + 1) * n - s)) / 2; }
n-=2;
return (Math.pow(n, 2) * ((s + 1) * n + s) + 2) / 2;
},
elasticIn: function(/* Decimal? */n){
// summary:
// An easing function the elastically snaps from the start value
// description:
// An easing function the elastically snaps from the start value
//
// Use caution when the elasticity will cause values to become negative
// as some properties cannot be set to negative values.
if(n == 0 || n == 1){ return n; }
var p = .3;
var s = p / 4;
n = n - 1;
return -1 * Math.pow(2, 10 * n) * Math.sin((n - s) * (2 * Math.PI) / p);
},
elasticOut: function(/* Decimal? */n){
// summary:
// An easing function that elasticly snaps around the target value,
// near the end of the Animation
// description:
// An easing function that elasticly snaps around the target value,
// near the end of the Animation
//
// Use caution when the elasticity will cause values to become
// negative as some properties cannot be set to negative values.
if(n==0 || n == 1){ return n; }
var p = .3;
var s = p / 4;
return Math.pow(2, -10 * n) * Math.sin((n - s) * (2 * Math.PI) / p) + 1;
},
elasticInOut: function(/* Decimal? */n){
// summary:
// An easing function that elasticly snaps around the value, near
// the beginning and end of the Animation.
// description:
// An easing function that elasticly snaps around the value, near
// the beginning and end of the Animation.
//
// Use caution when the elasticity will cause values to become
// negative as some properties cannot be set to negative values.
if(n == 0) return 0;
n = n * 2;
if(n == 2) return 1;
var p = .3 * 1.5;
var s = p / 4;
if(n < 1){
n -= 1;
return -.5 * (Math.pow(2, 10 * n) * Math.sin((n - s) * (2 * Math.PI) / p));
}
n -= 1;
return .5 * (Math.pow(2, -10 * n) * Math.sin((n - s) * (2 * Math.PI) / p)) + 1;
},
bounceIn: function(/* Decimal? */n){
// summary:
// An easing function that 'bounces' near the beginning of an Animation
return (1 - easingFuncs.bounceOut(1 - n)); // Decimal
},
bounceOut: function(/* Decimal? */n){
// summary:
// An easing function that 'bounces' near the end of an Animation
var s = 7.5625;
var p = 2.75;
var l;
if(n < (1 / p)){
l = s * Math.pow(n, 2);
}else if(n < (2 / p)){
n -= (1.5 / p);
l = s * Math.pow(n, 2) + .75;
}else if(n < (2.5 / p)){
n -= (2.25 / p);
l = s * Math.pow(n, 2) + .9375;
}else{
n -= (2.625 / p);
l = s * Math.pow(n, 2) + .984375;
}
return l;
},
bounceInOut: function(/* Decimal? */n){
// summary:
// An easing function that 'bounces' at the beginning and end of the Animation
if(n < 0.5){ return easingFuncs.bounceIn(n * 2) / 2; }
return (easingFuncs.bounceOut(n * 2 - 1) / 2) + 0.5; // Decimal
}
};
lang.setObject("dojo.fx.easing", easingFuncs);
return easingFuncs;
});
},
'dojox/charting/action2d/Highlight':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/Color", "dojo/_base/connect", "dojox/color/_base",
"./PlotAction", "dojo/fx/easing", "dojox/gfx/fx"],
function(lang, declare, Color, hub, c, PlotAction, dfe, dgf){
/*=====
var __HighlightCtorArgs = {
// summary:
// Additional arguments for highlighting actions.
// duration: Number?
// The amount of time in milliseconds for an animation to last. Default is 400.
// easing: dojo/fx/easing/*?
// An easing object (see dojo.fx.easing) for use in an animation. The
// default is dojo.fx.easing.backOut.
// highlight: String|dojo/_base/Color|Function?
// Either a color or a function that creates a color when highlighting happens.
};
=====*/
var DEFAULT_SATURATION = 100, // %
DEFAULT_LUMINOSITY1 = 75, // %
DEFAULT_LUMINOSITY2 = 50, // %
cc = function(color){
return function(){ return color; };
},
hl = function(color){
var a = new c.Color(color),
x = a.toHsl();
if(x.s == 0){
x.l = x.l < 50 ? 100 : 0;
}else{
x.s = DEFAULT_SATURATION;
if(x.l < DEFAULT_LUMINOSITY2){
x.l = DEFAULT_LUMINOSITY1;
}else if(x.l > DEFAULT_LUMINOSITY1){
x.l = DEFAULT_LUMINOSITY2;
}else{
x.l = x.l - DEFAULT_LUMINOSITY2 > DEFAULT_LUMINOSITY1 - x.l ?
DEFAULT_LUMINOSITY2 : DEFAULT_LUMINOSITY1;
}
}
var rcolor = c.fromHsl(x);
rcolor.a = a.a;
return rcolor;
},
spiderhl = function(color){
var r = hl(color);
r.a = 0.7;
return r;
}
return declare("dojox.charting.action2d.Highlight", PlotAction, {
// summary:
// Creates a highlighting action on a plot, where an element on that plot
// has a highlight on it.
// the data description block for the widget parser
defaultParams: {
duration: 400, // duration of the action in ms
easing: dfe.backOut // easing for the action
},
optionalParams: {
highlight: "red" // name for the highlight color
// programmatic instantiation can use functions and color objects
},
constructor: function(chart, plot, kwArgs){
// summary:
// Create the highlighting action and connect it to the plot.
// chart: dojox/charting/Chart
// The chart this action belongs to.
// plot: String?
// The plot this action is attached to. If not passed, "default" is assumed.
// kwArgs: __HighlightCtorArgs?
// Optional keyword arguments object for setting parameters.
var a = kwArgs && kwArgs.highlight;
this.colorFunc = a ? (lang.isFunction(a) ? a : cc(a)) : hl;
this.connect();
},
process: function(o){
// summary:
// Process the action on the given object.
// o: dojox/gfx/shape.Shape
// The object on which to process the highlighting action.
if(!o.shape || !(o.type in this.overOutEvents)){ return; }
// if spider let's deal only with poly
if(o.element == "spider_circle" || o.element == "spider_plot"){
return;
}else if(o.element == "spider_poly" && this.colorFunc == hl){
// hardcode alpha for compatibility reasons
// TODO to remove in 2.0
this.colorFunc = spiderhl;
}
var runName = o.run.name, index = o.index, anim;
if(runName in this.anim){
anim = this.anim[runName][index];
}else{
this.anim[runName] = {};
}
if(anim){
anim.action.stop(true);
}else{
var color = o.shape.getFill();
if(!color || !(color instanceof Color)){
return;
}
this.anim[runName][index] = anim = {
start: color,
end: this.colorFunc(color)
};
}
var start = anim.start, end = anim.end;
if(o.type == "onmouseout"){
// swap colors
var t = start;
start = end;
end = t;
}
anim.action = dgf.animateFill({
shape: o.shape,
duration: this.duration,
easing: this.easing,
color: {start: start, end: end}
});
if(o.type == "onmouseout"){
hub.connect(anim.action, "onEnd", this, function(){
if(this.anim[runName]){
delete this.anim[runName][index];
}
});
}
anim.action.play();
}
});
});
},
'dojox/color/_base':function(){
define(["../main", "dojo/_base/lang", "dojo/_base/Color", "dojo/colors"],
function(dojox, lang, Color, colors){
var cx = lang.getObject("color", true, dojox);
/*===== cx = dojox.color =====*/
// alias all the dojo.Color mechanisms
cx.Color=Color;
cx.blend=Color.blendColors;
cx.fromRgb=Color.fromRgb;
cx.fromHex=Color.fromHex;
cx.fromArray=Color.fromArray;
cx.fromString=Color.fromString;
// alias the dojo.colors mechanisms
cx.greyscale=colors.makeGrey;
lang.mixin(cx,{
fromCmy: function(/* Object|Array|int */cyan, /*int*/magenta, /*int*/yellow){
// summary:
// Create a dojox.color.Color from a CMY defined color.
// All colors should be expressed as 0-100 (percentage)
if(lang.isArray(cyan)){
magenta=cyan[1], yellow=cyan[2], cyan=cyan[0];
} else if(lang.isObject(cyan)){
magenta=cyan.m, yellow=cyan.y, cyan=cyan.c;
}
cyan/=100, magenta/=100, yellow/=100;
var r=1-cyan, g=1-magenta, b=1-yellow;
return new Color({ r:Math.round(r*255), g:Math.round(g*255), b:Math.round(b*255) }); // dojox.color.Color
},
fromCmyk: function(/* Object|Array|int */cyan, /*int*/magenta, /*int*/yellow, /*int*/black){
// summary:
// Create a dojox.color.Color from a CMYK defined color.
// All colors should be expressed as 0-100 (percentage)
if(lang.isArray(cyan)){
magenta=cyan[1], yellow=cyan[2], black=cyan[3], cyan=cyan[0];
} else if(lang.isObject(cyan)){
magenta=cyan.m, yellow=cyan.y, black=cyan.b, cyan=cyan.c;
}
cyan/=100, magenta/=100, yellow/=100, black/=100;
var r,g,b;
r = 1-Math.min(1, cyan*(1-black)+black);
g = 1-Math.min(1, magenta*(1-black)+black);
b = 1-Math.min(1, yellow*(1-black)+black);
return new Color({ r:Math.round(r*255), g:Math.round(g*255), b:Math.round(b*255) }); // dojox.color.Color
},
fromHsl: function(/* Object|Array|int */hue, /* int */saturation, /* int */luminosity){
// summary:
// Create a dojox.color.Color from an HSL defined color.
// hue from 0-359 (degrees), saturation and luminosity 0-100.
if(lang.isArray(hue)){
saturation=hue[1], luminosity=hue[2], hue=hue[0];
} else if(lang.isObject(hue)){
saturation=hue.s, luminosity=hue.l, hue=hue.h;
}
saturation/=100;
luminosity/=100;
while(hue<0){ hue+=360; }
while(hue>=360){ hue-=360; }
var r, g, b;
if(hue<120){
r=(120-hue)/60, g=hue/60, b=0;
} else if (hue<240){
r=0, g=(240-hue)/60, b=(hue-120)/60;
} else {
r=(hue-240)/60, g=0, b=(360-hue)/60;
}
r=2*saturation*Math.min(r, 1)+(1-saturation);
g=2*saturation*Math.min(g, 1)+(1-saturation);
b=2*saturation*Math.min(b, 1)+(1-saturation);
if(luminosity<0.5){
r*=luminosity, g*=luminosity, b*=luminosity;
}else{
r=(1-luminosity)*r+2*luminosity-1;
g=(1-luminosity)*g+2*luminosity-1;
b=(1-luminosity)*b+2*luminosity-1;
}
return new Color({ r:Math.round(r*255), g:Math.round(g*255), b:Math.round(b*255) }); // dojox.color.Color
}
});
cx.fromHsv = function(/* Object|Array|int */hue, /* int */saturation, /* int */value){
// summary:
// Create a dojox.color.Color from an HSV defined color.
// hue from 0-359 (degrees), saturation and value 0-100.
if(lang.isArray(hue)){
saturation=hue[1], value=hue[2], hue=hue[0];
} else if (lang.isObject(hue)){
saturation=hue.s, value=hue.v, hue=hue.h;
}
if(hue==360){ hue=0; }
saturation/=100;
value/=100;
var r, g, b;
if(saturation==0){
r=value, b=value, g=value;
}else{
var hTemp=hue/60, i=Math.floor(hTemp), f=hTemp-i;
var p=value*(1-saturation);
var q=value*(1-(saturation*f));
var t=value*(1-(saturation*(1-f)));
switch(i){
case 0:{ r=value, g=t, b=p; break; }
case 1:{ r=q, g=value, b=p; break; }
case 2:{ r=p, g=value, b=t; break; }
case 3:{ r=p, g=q, b=value; break; }
case 4:{ r=t, g=p, b=value; break; }
case 5:{ r=value, g=p, b=q; break; }
}
}
return new Color({ r:Math.round(r*255), g:Math.round(g*255), b:Math.round(b*255) }); // dojox.color.Color
};
lang.extend(Color,{
toCmy: function(){
// summary:
// Convert this Color to a CMY definition.
var cyan=1-(this.r/255), magenta=1-(this.g/255), yellow=1-(this.b/255);
return { c:Math.round(cyan*100), m:Math.round(magenta*100), y:Math.round(yellow*100) }; // Object
},
toCmyk: function(){
// summary:
// Convert this Color to a CMYK definition.
var cyan, magenta, yellow, black;
var r=this.r/255, g=this.g/255, b=this.b/255;
black = Math.min(1-r, 1-g, 1-b);
cyan = (1-r-black)/(1-black);
magenta = (1-g-black)/(1-black);
yellow = (1-b-black)/(1-black);
return { c:Math.round(cyan*100), m:Math.round(magenta*100), y:Math.round(yellow*100), b:Math.round(black*100) }; // Object
},
toHsl: function(){
// summary:
// Convert this Color to an HSL definition.
var r=this.r/255, g=this.g/255, b=this.b/255;
var min = Math.min(r, b, g), max = Math.max(r, g, b);
var delta = max-min;
var h=0, s=0, l=(min+max)/2;
if(l>0 && l<1){
s = delta/((l<0.5)?(2*l):(2-2*l));
}
if(delta>0){
if(max==r && max!=g){
h+=(g-b)/delta;
}
if(max==g && max!=b){
h+=(2+(b-r)/delta);
}
if(max==b && max!=r){
h+=(4+(r-g)/delta);
}
h*=60;
}
return { h:h, s:Math.round(s*100), l:Math.round(l*100) }; // Object
},
toHsv: function(){
// summary:
// Convert this Color to an HSV definition.
var r=this.r/255, g=this.g/255, b=this.b/255;
var min = Math.min(r, b, g), max = Math.max(r, g, b);
var delta = max-min;
var h = null, s = (max==0)?0:(delta/max);
if(s==0){
h = 0;
}else{
if(r==max){
h = 60*(g-b)/delta;
}else if(g==max){
h = 120 + 60*(b-r)/delta;
}else{
h = 240 + 60*(r-g)/delta;
}
if(h<0){ h+=360; }
}
return { h:h, s:Math.round(s*100), v:Math.round(max*100) }; // Object
}
});
return cx;
});
},
'dojo/colors':function(){
define(["./_base/kernel", "./_base/lang", "./_base/Color", "./_base/array"], function(dojo, lang, Color, ArrayUtil){
// module:
// dojo/colors
/*=====
return {
// summary:
// Color utilities, extending Base dojo.Color
};
=====*/
var ColorExt = {};
lang.setObject("dojo.colors", ColorExt);
//TODO: this module appears to break naming conventions
// this is a standard conversion prescribed by the CSS3 Color Module
var hue2rgb = function(m1, m2, h){
if(h < 0){ ++h; }
if(h > 1){ --h; }
var h6 = 6 * h;
if(h6 < 1){ return m1 + (m2 - m1) * h6; }
if(2 * h < 1){ return m2; }
if(3 * h < 2){ return m1 + (m2 - m1) * (2 / 3 - h) * 6; }
return m1;
};
// Override base Color.fromRgb with the impl in this module
dojo.colorFromRgb = Color.fromRgb = function(/*String*/ color, /*dojo/_base/Color?*/ obj){
// summary:
// get rgb(a) array from css-style color declarations
// description:
// this function can handle all 4 CSS3 Color Module formats: rgb,
// rgba, hsl, hsla, including rgb(a) with percentage values.
var m = color.toLowerCase().match(/^(rgba?|hsla?)\(([\s\.\-,%0-9]+)\)/);
if(m){
var c = m[2].split(/\s*,\s*/), l = c.length, t = m[1], a;
if((t == "rgb" && l == 3) || (t == "rgba" && l == 4)){
var r = c[0];
if(r.charAt(r.length - 1) == "%"){
// 3 rgb percentage values
a = ArrayUtil.map(c, function(x){
return parseFloat(x) * 2.56;
});
if(l == 4){ a[3] = c[3]; }
return Color.fromArray(a, obj); // dojo/_base/Color
}
return Color.fromArray(c, obj); // dojo/_base/Color
}
if((t == "hsl" && l == 3) || (t == "hsla" && l == 4)){
// normalize hsl values
var H = ((parseFloat(c[0]) % 360) + 360) % 360 / 360,
S = parseFloat(c[1]) / 100,
L = parseFloat(c[2]) / 100,
// calculate rgb according to the algorithm
// recommended by the CSS3 Color Module
m2 = L <= 0.5 ? L * (S + 1) : L + S - L * S,
m1 = 2 * L - m2;
a = [
hue2rgb(m1, m2, H + 1 / 3) * 256,
hue2rgb(m1, m2, H) * 256,
hue2rgb(m1, m2, H - 1 / 3) * 256,
1
];
if(l == 4){ a[3] = c[3]; }
return Color.fromArray(a, obj); // dojo/_base/Color
}
}
return null; // dojo/_base/Color
};
var confine = function(c, low, high){
// summary:
// sanitize a color component by making sure it is a number,
// and clamping it to valid values
c = Number(c);
return isNaN(c) ? high : c < low ? low : c > high ? high : c; // Number
};
Color.prototype.sanitize = function(){
// summary:
// makes sure that the object has correct attributes
var t = this;
t.r = Math.round(confine(t.r, 0, 255));
t.g = Math.round(confine(t.g, 0, 255));
t.b = Math.round(confine(t.b, 0, 255));
t.a = confine(t.a, 0, 1);
return this; // dojo/_base/Color
};
ColorExt.makeGrey = Color.makeGrey = function(/*Number*/ g, /*Number?*/ a){
// summary:
// creates a greyscale color with an optional alpha
return Color.fromArray([g, g, g, a]); // dojo/_base/Color
};
// mixin all CSS3 named colors not already in _base, along with SVG 1.0 variant spellings
lang.mixin(Color.named, {
"aliceblue": [240,248,255],
"antiquewhite": [250,235,215],
"aquamarine": [127,255,212],
"azure": [240,255,255],
"beige": [245,245,220],
"bisque": [255,228,196],
"blanchedalmond": [255,235,205],
"blueviolet": [138,43,226],
"brown": [165,42,42],
"burlywood": [222,184,135],
"cadetblue": [95,158,160],
"chartreuse": [127,255,0],
"chocolate": [210,105,30],
"coral": [255,127,80],
"cornflowerblue": [100,149,237],
"cornsilk": [255,248,220],
"crimson": [220,20,60],
"cyan": [0,255,255],
"darkblue": [0,0,139],
"darkcyan": [0,139,139],
"darkgoldenrod": [184,134,11],
"darkgray": [169,169,169],
"darkgreen": [0,100,0],
"darkgrey": [169,169,169],
"darkkhaki": [189,183,107],
"darkmagenta": [139,0,139],
"darkolivegreen": [85,107,47],
"darkorange": [255,140,0],
"darkorchid": [153,50,204],
"darkred": [139,0,0],
"darksalmon": [233,150,122],
"darkseagreen": [143,188,143],
"darkslateblue": [72,61,139],
"darkslategray": [47,79,79],
"darkslategrey": [47,79,79],
"darkturquoise": [0,206,209],
"darkviolet": [148,0,211],
"deeppink": [255,20,147],
"deepskyblue": [0,191,255],
"dimgray": [105,105,105],
"dimgrey": [105,105,105],
"dodgerblue": [30,144,255],
"firebrick": [178,34,34],
"floralwhite": [255,250,240],
"forestgreen": [34,139,34],
"gainsboro": [220,220,220],
"ghostwhite": [248,248,255],
"gold": [255,215,0],
"goldenrod": [218,165,32],
"greenyellow": [173,255,47],
"grey": [128,128,128],
"honeydew": [240,255,240],
"hotpink": [255,105,180],
"indianred": [205,92,92],
"indigo": [75,0,130],
"ivory": [255,255,240],
"khaki": [240,230,140],
"lavender": [230,230,250],
"lavenderblush": [255,240,245],
"lawngreen": [124,252,0],
"lemonchiffon": [255,250,205],
"lightblue": [173,216,230],
"lightcoral": [240,128,128],
"lightcyan": [224,255,255],
"lightgoldenrodyellow": [250,250,210],
"lightgray": [211,211,211],
"lightgreen": [144,238,144],
"lightgrey": [211,211,211],
"lightpink": [255,182,193],
"lightsalmon": [255,160,122],
"lightseagreen": [32,178,170],
"lightskyblue": [135,206,250],
"lightslategray": [119,136,153],
"lightslategrey": [119,136,153],
"lightsteelblue": [176,196,222],
"lightyellow": [255,255,224],
"limegreen": [50,205,50],
"linen": [250,240,230],
"magenta": [255,0,255],
"mediumaquamarine": [102,205,170],
"mediumblue": [0,0,205],
"mediumorchid": [186,85,211],
"mediumpurple": [147,112,219],
"mediumseagreen": [60,179,113],
"mediumslateblue": [123,104,238],
"mediumspringgreen": [0,250,154],
"mediumturquoise": [72,209,204],
"mediumvioletred": [199,21,133],
"midnightblue": [25,25,112],
"mintcream": [245,255,250],
"mistyrose": [255,228,225],
"moccasin": [255,228,181],
"navajowhite": [255,222,173],
"oldlace": [253,245,230],
"olivedrab": [107,142,35],
"orange": [255,165,0],
"orangered": [255,69,0],
"orchid": [218,112,214],
"palegoldenrod": [238,232,170],
"palegreen": [152,251,152],
"paleturquoise": [175,238,238],
"palevioletred": [219,112,147],
"papayawhip": [255,239,213],
"peachpuff": [255,218,185],
"peru": [205,133,63],
"pink": [255,192,203],
"plum": [221,160,221],
"powderblue": [176,224,230],
"rosybrown": [188,143,143],
"royalblue": [65,105,225],
"saddlebrown": [139,69,19],
"salmon": [250,128,114],
"sandybrown": [244,164,96],
"seagreen": [46,139,87],
"seashell": [255,245,238],
"sienna": [160,82,45],
"skyblue": [135,206,235],
"slateblue": [106,90,205],
"slategray": [112,128,144],
"slategrey": [112,128,144],
"snow": [255,250,250],
"springgreen": [0,255,127],
"steelblue": [70,130,180],
"tan": [210,180,140],
"thistle": [216,191,216],
"tomato": [255,99,71],
"turquoise": [64,224,208],
"violet": [238,130,238],
"wheat": [245,222,179],
"whitesmoke": [245,245,245],
"yellowgreen": [154,205,50]
});
return Color; // TODO: return ColorExt, not Color
});
},
'dojox/charting/action2d/PlotAction':function(){
define(["dojo/_base/connect", "dojo/_base/declare", "./Base", "dojo/fx/easing", "dojox/lang/functional"],
function(hub, declare, Base, dfe, df){
/*=====
var __PlotActionCtorArgs = {
// summary:
// The base keyword arguments object for creating an action2d.
// duration: Number?
// The amount of time in milliseconds for an animation to last. Default is 400.
// easing: dojo/fx/easing/*?
// An easing object (see dojo.fx.easing) for use in an animation. The
// default is dojo.fx.easing.backOut.
};
=====*/
var DEFAULT_DURATION = 400, // ms
DEFAULT_EASING = dfe.backOut;
return declare("dojox.charting.action2d.PlotAction", Base, {
// summary:
// Base action class for plot actions.
overOutEvents: {onmouseover: 1, onmouseout: 1},
constructor: function(chart, plot, kwargs){
// summary:
// Create a new base PlotAction.
// chart: dojox/charting/Chart
// The chart this action applies to.
// plot: String?
// The name of the plot this action belongs to. If none is passed "default" is assumed.
// kwargs: __PlotActionCtorArgs?
// Optional arguments for the action.
this.anim = {};
// process common optional named parameters
if(!kwargs){ kwargs = {}; }
this.duration = kwargs.duration ? kwargs.duration : DEFAULT_DURATION;
this.easing = kwargs.easing ? kwargs.easing : DEFAULT_EASING;
},
connect: function(){
// summary:
// Connect this action to the given plot.
this.handle = this.chart.connectToPlot(this.plot.name, this, "process");
},
disconnect: function(){
// summary:
// Disconnect this action from the given plot, if connected.
if(this.handle){
hub.disconnect(this.handle);
this.handle = null;
}
},
reset: function(){
// summary:
// Reset the action.
},
destroy: function(){
// summary:
// Do any cleanup needed when destroying parent elements.
this.inherited(arguments);
df.forIn(this.anim, function(o){
df.forIn(o, function(anim){
anim.action.stop(true);
});
});
this.anim = {};
}
});
});
},
'dojox/charting/action2d/Base':function(){
define(["dojo/_base/lang", "dojo/_base/declare", "dojo/Evented"],
function(lang, declare, Evented){
return declare("dojox.charting.action2d.Base", Evented, {
// summary:
// Base action class for plot and chart actions.
constructor: function(chart, plot){
// summary:
// Create a new base action. This can either be a plot or a chart action.
// chart: dojox/charting/Chart
// The chart this action applies to.
// plot: String|dojox/charting/plot2d/Base?
// Optional target plot for this action. Default is "default".
this.chart = chart;
this.plot = plot ? (lang.isString(plot) ? this.chart.getPlot(plot) : plot) : this.chart.getPlot("default");
},
connect: function(){
// summary:
// Connect this action to the plot or the chart.
},
disconnect: function(){
// summary:
// Disconnect this action from the plot or the chart.
},
destroy: function(){
// summary:
// Do any cleanup needed when destroying parent elements.
this.disconnect();
}
});
});
},
'dojox/charting/action2d/Magnify':function(){
define(["dojo/_base/connect", "dojo/_base/declare",
"./PlotAction", "dojox/gfx/matrix",
"dojox/gfx/fx", "dojo/fx", "dojo/fx/easing"],
function(Hub, declare, PlotAction, m, gf, df, dfe){
/*=====
var __MagnifyCtorArgs = {
// summary:
// Additional arguments for magnifying actions.
// duration: Number?
// The amount of time in milliseconds for an animation to last. Default is 400.
// easing: dojo/fx/easing/*?
// An easing object (see dojo.fx.easing) for use in an animation. The
// default is dojo.fx.easing.backOut.
// scale: Number?
// The amount to magnify the given object to. Default is 2.
};
=====*/
var DEFAULT_SCALE = 2;
return declare("dojox.charting.action2d.Magnify", PlotAction, {
// summary:
// Create an action that magnifies the object the action is applied to.
// the data description block for the widget parser
defaultParams: {
duration: 400, // duration of the action in ms
easing: dfe.backOut, // easing for the action
scale: DEFAULT_SCALE // scale of magnification
},
optionalParams: {}, // no optional parameters
constructor: function(chart, plot, kwArgs){
// summary:
// Create the magnifying action.
// chart: dojox/charting/Chart
// The chart this action belongs to.
// plot: String?
// The plot to apply the action to. If not passed, "default" is assumed.
// kwArgs: __MagnifyCtorArgs?
// Optional keyword arguments for this action.
// process optional named parameters
this.scale = kwArgs && typeof kwArgs.scale == "number" ? kwArgs.scale : DEFAULT_SCALE;
this.connect();
},
process: function(o){
// summary:
// Process the action on the given object.
// o: dojox/gfx/shape.Shape
// The object on which to process the magnifying action.
if(!o.shape || !(o.type in this.overOutEvents) ||
!("cx" in o) || !("cy" in o)){ return; }
// if spider deal only with circle
if(o.element == "spider_plot" || o.element == "spider_poly"){
return;
}
var runName = o.run.name, index = o.index, vector = [], anim, init, scale;
if(runName in this.anim){
anim = this.anim[runName][index];
}else{
this.anim[runName] = {};
}
if(anim){
anim.action.stop(true);
}else{
this.anim[runName][index] = anim = {};
}
if(o.type == "onmouseover"){
init = m.identity;
scale = this.scale;
}else{
init = m.scaleAt(this.scale, o.cx, o.cy);
scale = 1 / this.scale;
}
var kwArgs = {
shape: o.shape,
duration: this.duration,
easing: this.easing,
transform: [
{name: "scaleAt", start: [1, o.cx, o.cy], end: [scale, o.cx, o.cy]},
init
]
};
if(o.shape){
vector.push(gf.animateTransform(kwArgs));
}
if(o.outline){
kwArgs.shape = o.outline;
vector.push(gf.animateTransform(kwArgs));
}
if(o.shadow){
kwArgs.shape = o.shadow;
vector.push(gf.animateTransform(kwArgs));
}
if(!vector.length){
delete this.anim[runName][index];
return;
}
anim.action = df.combine(vector);
if(o.type == "onmouseout"){
Hub.connect(anim.action, "onEnd", this, function(){
if(this.anim[runName]){
delete this.anim[runName][index];
}
});
}
anim.action.play();
}
});
});
},
'dojox/charting/action2d/MoveSlice':function(){
define(["dojo/_base/connect", "dojo/_base/declare", "dojo/_base/array", "./PlotAction", "dojo/fx/easing", "dojox/gfx/matrix",
"dojox/gfx/fx", "dojox/lang/functional", "dojox/lang/functional/scan", "dojox/lang/functional/fold"],
function(hub, declare, array, PlotAction, dfe, m, gf, df){
/*=====
var __MoveSliceCtorArgs = {
// summary:
// Additional arguments for move slice actions.
// duration: Number?
// The amount of time in milliseconds for an animation to last. Default is 400.
// easing: dojo/fx/easing/*?
// An easing object (see dojo.fx.easing) for use in an animation. The
// default is dojo.fx.easing.backOut.
// scale: Number?
// The amount to scale the pie slice. Default is 1.05.
// shift: Number?
// The amount in pixels to shift the pie slice. Default is 7.
};
=====*/
var DEFAULT_SCALE = 1.05,
DEFAULT_SHIFT = 7; // px
return declare("dojox.charting.action2d.MoveSlice", PlotAction, {
// summary:
// Create an action for a pie chart that moves and scales a pie slice.
// the data description block for the widget parser
defaultParams: {
duration: 400, // duration of the action in ms
easing: dfe.backOut, // easing for the action
scale: DEFAULT_SCALE, // scale of magnification
shift: DEFAULT_SHIFT // shift of the slice
},
optionalParams: {}, // no optional parameters
constructor: function(chart, plot, kwArgs){
// summary:
// Create the slice moving action and connect it to the plot.
// chart: dojox/charting/Chart
// The chart this action belongs to.
// plot: String?
// The plot this action is attached to. If not passed, "default" is assumed.
// kwArgs: __MoveSliceCtorArgs?
// Optional keyword arguments object for setting parameters.
if(!kwArgs){ kwArgs = {}; }
this.scale = typeof kwArgs.scale == "number" ? kwArgs.scale : DEFAULT_SCALE;
this.shift = typeof kwArgs.shift == "number" ? kwArgs.shift : DEFAULT_SHIFT;
this.connect();
},
process: function(o){
// summary:
// Process the action on the given object.
// o: dojox/gfx/shape.Shape
// The object on which to process the slice moving action.
if(!o.shape || o.element != "slice" || !(o.type in this.overOutEvents)){ return; }
if(!this.angles){
// calculate the running total of slice angles
var startAngle = m._degToRad(o.plot.opt.startAngle);
if(typeof o.run.data[0] == "number"){
this.angles = df.map(df.scanl(o.run.data, "+", 0),
"* 2 * Math.PI / this", df.foldl(o.run.data, "+", 0));
}else{
this.angles = df.map(df.scanl(o.run.data, "a + b.y", 0),
"* 2 * Math.PI / this", df.foldl(o.run.data, "a + b.y", 0));
}
this.angles = array.map(this.angles, function(item){
return item + startAngle;
});
}
var index = o.index, anim, startScale, endScale, startOffset, endOffset,
angle = (this.angles[index] + this.angles[index + 1]) / 2,
rotateTo0 = m.rotateAt(-angle, o.cx, o.cy),
rotateBack = m.rotateAt( angle, o.cx, o.cy);
anim = this.anim[index];
if(anim){
anim.action.stop(true);
}else{
this.anim[index] = anim = {};
}
if(o.type == "onmouseover"){
startOffset = 0;
endOffset = this.shift;
startScale = 1;
endScale = this.scale;
}else{
startOffset = this.shift;
endOffset = 0;
startScale = this.scale;
endScale = 1;
}
anim.action = gf.animateTransform({
shape: o.shape,
duration: this.duration,
easing: this.easing,
transform: [
rotateBack,
{name: "translate", start: [startOffset, 0], end: [endOffset, 0]},
{name: "scaleAt", start: [startScale, o.cx, o.cy], end: [endScale, o.cx, o.cy]},
rotateTo0
]
});
if(o.type == "onmouseout"){
hub.connect(anim.action, "onEnd", this, function(){
delete this.anim[index];
});
}
anim.action.play();
},
reset: function(){
delete this.angles;
}
});
});
},
'dojox/lang/functional/scan':function(){
define(["dojo/_base/kernel", "dojo/_base/lang", "./lambda"], function(kernel, lang, df){
// This module adds high-level functions and related constructs:
// - "scan" family of functions
// Notes:
// - missing high-level functions are provided with the compatible API:
// scanl, scanl1, scanr, scanr1
// Defined methods:
// - take any valid lambda argument as the functional argument
// - operate on dense arrays
// - take a string as the array argument
// - take an iterator objects as the array argument (only scanl, and scanl1)
var empty = {};
lang.mixin(df, {
// classic reduce-class functions
scanl: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from left
// to right using a seed value as a starting point; returns an array
// of values produced by foldl() at that point.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var t, n, i;
if(lang.isArray(a)){
// array
t = new Array((n = a.length) + 1);
t[0] = z;
for(i = 0; i < n; z = f.call(o, z, a[i], i, a), t[++i] = z);
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
t = [z];
for(i = 0; a.hasNext(); t.push(z = f.call(o, z, a.next(), i++, a)));
}else{
// object/dictionary
t = [z];
for(i in a){
if(!(i in empty)){
t.push(z = f.call(o, z, a[i], i, a));
}
}
}
return t; // Array
},
scanl1: function(/*Array|String|Object*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from left
// to right; returns an array of values produced by foldl1() at that
// point.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var t, n, z, first = true;
if(lang.isArray(a)){
// array
t = new Array(n = a.length);
t[0] = z = a[0];
for(var i = 1; i < n; t[i] = z = f.call(o, z, a[i], i, a), ++i);
}else if(typeof a.hasNext == "function" && typeof a.next == "function"){
// iterator
if(a.hasNext()){
t = [z = a.next()];
for(i = 1; a.hasNext(); t.push(z = f.call(o, z, a.next(), i++, a)));
}
}else{
// object/dictionary
for(i in a){
if(!(i in empty)){
if(first){
t = [z = a[i]];
first = false;
}else{
t.push(z = f.call(o, z, a[i], i, a));
}
}
}
}
return t; // Array
},
scanr: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object*/ z, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from right
// to left using a seed value as a starting point; returns an array
// of values produced by foldr() at that point.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var n = a.length, t = new Array(n + 1), i = n;
t[n] = z;
for(; i > 0; --i, z = f.call(o, z, a[i], i, a), t[i] = z);
return t; // Array
},
scanr1: function(/*Array|String*/ a, /*Function|String|Array*/ f, /*Object?*/ o){
// summary:
// repeatedly applies a binary function to an array from right
// to left; returns an array of values produced by foldr1() at that
// point.
if(typeof a == "string"){ a = a.split(""); }
o = o || kernel.global; f = df.lambda(f);
var n = a.length, t = new Array(n), z = a[n - 1], i = n - 1;
t[i] = z;
for(; i > 0; --i, z = f.call(o, z, a[i], i, a), t[i] = z);
return t; // Array
}
});
});
},
'dojox/charting/action2d/Shake':function(){
define(["dojo/_base/connect", "dojo/_base/declare", "./PlotAction",
"dojo/fx", "dojo/fx/easing", "dojox/gfx/matrix", "dojox/gfx/fx"],
function(hub, declare, PlotAction, df, dfe, m, gf){
/*=====
var __ShakeCtorArgs = {
// summary:
// Additional arguments for shaking actions.
// duration: Number?
// The amount of time in milliseconds for an animation to last. Default is 400.
// easing: dojo/fx/easing/*?
// An easing object (see dojo.fx.easing) for use in an animation. The
// default is dojo.fx.easing.backOut.
// shift: Number?
// The amount in pixels to shift the pie slice. Default is 3.
};
=====*/
var DEFAULT_SHIFT = 3;
return declare("dojox.charting.action2d.Shake", PlotAction, {
// summary:
// Create a shaking action for use on an element in a chart.
// the data description block for the widget parser
defaultParams: {
duration: 400, // duration of the action in ms
easing: dfe.backOut, // easing for the action
shiftX: DEFAULT_SHIFT, // shift of the element along the X axis
shiftY: DEFAULT_SHIFT // shift of the element along the Y axis
},
optionalParams: {}, // no optional parameters
constructor: function(chart, plot, kwArgs){
// summary:
// Create the shaking action and connect it to the plot.
// chart: dojox/charting/Chart
// The chart this action belongs to.
// plot: String?
// The plot this action is attached to. If not passed, "default" is assumed.
// kwArgs: __ShakeCtorArgs?
// Optional keyword arguments object for setting parameters.
if(!kwArgs){ kwArgs = {}; }
this.shiftX = typeof kwArgs.shiftX == "number" ? kwArgs.shiftX : DEFAULT_SHIFT;
this.shiftY = typeof kwArgs.shiftY == "number" ? kwArgs.shiftY : DEFAULT_SHIFT;
this.connect();
},
process: function(o){
// summary:
// Process the action on the given object.
// o: dojox/gfx/shape.Shape
// The object on which to process the slice moving action.
if(!o.shape || !(o.type in this.overOutEvents)){ return; }
var runName = o.run.name, index = o.index, vector = [], anim;
if(runName in this.anim){
anim = this.anim[runName][index];
}else{
this.anim[runName] = {};
}
if(anim){
anim.action.stop(true);
}else{
this.anim[runName][index] = anim = {};
}
var kwArgs = {
shape: o.shape,
duration: this.duration,
easing: this.easing,
transform: [
{name: "translate", start: [this.shiftX, this.shiftY], end: [0, 0]},
m.identity
]
};
if(o.shape){
vector.push(gf.animateTransform(kwArgs));
}
if(o.oultine){
kwArgs.shape = o.outline;
vector.push(gf.animateTransform(kwArgs));
}
if(o.shadow){
kwArgs.shape = o.shadow;
vector.push(gf.animateTransform(kwArgs));
}
if(!vector.length){
delete this.anim[runName][index];
return;
}
anim.action = df.combine(vector);
if(o.type == "onmouseout"){
hub.connect(anim.action, "onEnd", this, function(){
if(this.anim[runName]){
delete this.anim[runName][index];
}
});
}
anim.action.play();
}
});
});
},
'dojox/charting/action2d/Tooltip':function(){
define(["dijit/Tooltip", "dojo/_base/lang", "dojo/_base/declare", "dojo/_base/window", "dojo/_base/connect", "dojo/dom-style",
"./PlotAction", "dojox/gfx/matrix", "dojo/has", "dojo/has!dojo-bidi?../bidi/action2d/Tooltip",
"dojox/lang/functional", "dojox/lang/functional/scan", "dojox/lang/functional/fold"],
function(DijitTooltip, lang, declare, win, hub, domStyle, PlotAction, m, has, BidiTooltip, df){
/*=====
var __TooltipCtorArgs = {
// summary:
// Additional arguments for tooltip actions.
// duration: Number?
// The amount of time in milliseconds for an animation to last. Default is 400.
// easing: dojo/fx/easing/*?
// An easing object (see dojo.fx.easing) for use in an animation. The
// default is dojo.fx.easing.backOut.
// text: Function?
// The function that produces the text to be shown within a tooltip. By default this will be
// set by the plot in question, by returning the value of the element.
// mouseOver: Boolean?
// Whether the tooltip is enabled on mouse over or on mouse click / touch down. Default is true.
};
=====*/
var DEFAULT_TEXT = function(o, plot){
var t = o.run && o.run.data && o.run.data[o.index];
if(t && typeof t != "number" && (t.tooltip || t.text)){
return t.tooltip || t.text;
}
if(plot.tooltipFunc){
return plot.tooltipFunc(o);
}else{
return o.y;
}
};
var pi4 = Math.PI / 4, pi2 = Math.PI / 2;
var Tooltip = declare(has("dojo-bidi")? "dojox.charting.action2d.NonBidiTooltip" : "dojox.charting.action2d.Tooltip", PlotAction, {
// summary:
// Create an action on a plot where a tooltip is shown when hovering over an element.
// the data description block for the widget parser
defaultParams: {
text: DEFAULT_TEXT, // the function to produce a tooltip from the object
mouseOver: true,
defaultPosition: ["after-centered", "before-centered"]
},
optionalParams: {}, // no optional parameters
constructor: function(chart, plot, kwArgs){
// summary:
// Create the tooltip action and connect it to the plot.
// chart: dojox/charting/Chart
// The chart this action belongs to.
// plot: String?
// The plot this action is attached to. If not passed, "default" is assumed.
// kwArgs: __TooltipCtorArgs?
// Optional keyword arguments object for setting parameters.
this.text = kwArgs && kwArgs.text ? kwArgs.text : DEFAULT_TEXT;
this.mouseOver = kwArgs && kwArgs.mouseOver != undefined ? kwArgs.mouseOver : true;
this.defaultPosition = kwArgs && kwArgs.defaultPosition != undefined ? kwArgs.defaultPosition : ["after-centered", "before-centered"];
this.connect();
},
process: function(o){
// summary:
// Process the action on the given object.
// o: dojox/gfx/shape.Shape
// The object on which to process the highlighting action.
if(o.type === "onplotreset" || o.type === "onmouseout"){
DijitTooltip.hide(this.aroundRect);
this.aroundRect = null;
if(o.type === "onplotreset"){
delete this.angles;
}
return;
}
if(!o.shape || (this.mouseOver && o.type !== "onmouseover") || (!this.mouseOver && o.type !== "onclick")){ return; }
// calculate relative coordinates and the position
var aroundRect = {type: "rect"}, position = this.defaultPosition;
switch(o.element){
case "marker":
aroundRect.x = o.cx;
aroundRect.y = o.cy;
aroundRect.w = aroundRect.h = 1;
break;
case "circle":
aroundRect.x = o.cx - o.cr;
aroundRect.y = o.cy - o.cr;
aroundRect.w = aroundRect.h = 2 * o.cr;
break;
case "spider_circle":
aroundRect.x = o.cx;
aroundRect.y = o.cy ;
aroundRect.w = aroundRect.h = 1;
break;
case "spider_plot":
return;
case "column":
position = ["above-centered", "below-centered"];
// intentional fall down
case "bar":
aroundRect = lang.clone(o.shape.getShape());
aroundRect.w = aroundRect.width;
aroundRect.h = aroundRect.height;
break;
case "candlestick":
aroundRect.x = o.x;
aroundRect.y = o.y;
aroundRect.w = o.width;
aroundRect.h = o.height;
break;
default:
//case "slice":
if(!this.angles){
// calculate the running total of slice angles
var filteredRun = typeof o.run.data[0] == "number" ?
df.map(o.run.data, "x ? Math.max(x, 0) : 0") : df.map(o.run.data, "x ? Math.max(x.y, 0) : 0");
this.angles = df.map(df.scanl(filteredRun, "+", 0),
"* 2 * Math.PI / this", df.foldl(filteredRun, "+", 0));
}
var startAngle = m._degToRad(o.plot.opt.startAngle),
angle = (this.angles[o.index] + this.angles[o.index + 1]) / 2 + startAngle;
aroundRect.x = o.cx + o.cr * Math.cos(angle);
aroundRect.y = o.cy + o.cr * Math.sin(angle);
aroundRect.w = aroundRect.h = 1;
// depending on startAngle we might go out of the 0-2*PI range, normalize that
if(startAngle && (angle < 0 || angle > 2 * Math.PI)){
angle = Math.abs(2 * Math.PI - Math.abs(angle));
}
// calculate the position
if(angle < pi4){
// do nothing: the position is right
}else if(angle < pi2 + pi4){
position = ["below-centered", "above-centered"];
}else if(angle < Math.PI + pi4){
position = ["before-centered", "after-centered"];
}else if(angle < 2 * Math.PI - pi4){
position = ["above-centered", "below-centered"];
}
/*
else{
// do nothing: the position is right
}
*/
break;
}
if(has("dojo-bidi")){
this._recheckPosition(o,aroundRect,position);
}
// adjust relative coordinates to absolute, and remove fractions
var lt = this.chart.getCoords();
aroundRect.x += lt.x;
aroundRect.y += lt.y;
aroundRect.x = Math.round(aroundRect.x);
aroundRect.y = Math.round(aroundRect.y);
aroundRect.w = Math.ceil(aroundRect.w);
aroundRect.h = Math.ceil(aroundRect.h);
this.aroundRect = aroundRect;
var tooltipText = this.text(o, this.plot);
if(tooltipText){
DijitTooltip.show(this._format(tooltipText), this.aroundRect, position);
}
if(!this.mouseOver){
this._handle = hub.connect(win.doc, "onclick", this, "onClick");
}
},
onClick: function(){
this.process({ type: "onmouseout"});
},
_recheckPosition: function(obj,rect,position){
},
_format: function(tooltipText){
return tooltipText;
}
});
return has("dojo-bidi")? declare("dojox.charting.action2d.Tooltip", [Tooltip, BidiTooltip]) : Tooltip;
});
},
'dijit/Tooltip':function(){
define([
"dojo/_base/array", // array.forEach array.indexOf array.map
"dojo/_base/declare", // declare
"dojo/_base/fx", // fx.fadeIn fx.fadeOut
"dojo/dom", // dom.byId
"dojo/dom-class", // domClass.add
"dojo/dom-geometry", // domGeometry.position
"dojo/dom-style", // domStyle.set, domStyle.get
"dojo/_base/lang", // lang.hitch lang.isArrayLike
"dojo/mouse",
"dojo/on",
"dojo/sniff", // has("ie"), has("trident")
"./_base/manager", // manager.defaultDuration
"./place",
"./_Widget",
"./_TemplatedMixin",
"./BackgroundIframe",
"dojo/text!./templates/Tooltip.html",
"./main" // sets dijit.showTooltip etc. for back-compat
], function(array, declare, fx, dom, domClass, domGeometry, domStyle, lang, mouse, on, has,
manager, place, _Widget, _TemplatedMixin, BackgroundIframe, template, dijit){
// module:
// dijit/Tooltip
// TODO: Tooltip should really share more positioning code with TooltipDialog, like:
// - the orient() method
// - the connector positioning code in show()
// - the dijitTooltip[Dialog] class
//
// The problem is that Tooltip's implementation supplies it's own