You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
291 lines
8.4 KiB
291 lines
8.4 KiB
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; |
|
});
|
|
|