- Author:
- David Nickerson <nickerso@users.sourceforge.net>
- Date:
- 2009-07-16 02:00:03+12:00
- Desc:
- the starting point for the HH tutorial example
- Permanent Source URI:
- https://models.fieldml.org/workspace/a1/rawfile/f6a8f90307388eb4b040ee3566b84d88b59247f7/dojo-presentation/js/dojo/dojox/charting/Chart2D.js
dojo.provide("dojox.charting.Chart2D");
dojo.require("dojox.gfx");
dojo.require("dojox.lang.functional");
dojo.require("dojox.lang.functional.fold");
dojo.require("dojox.lang.functional.reversed");
dojo.require("dojox.charting.Theme");
dojo.require("dojox.charting.Series");
// require all axes to support references by name
dojo.require("dojox.charting.axis2d.Default");
// require all plots to support references by name
dojo.require("dojox.charting.plot2d.Default");
dojo.require("dojox.charting.plot2d.Lines");
dojo.require("dojox.charting.plot2d.Areas");
dojo.require("dojox.charting.plot2d.Markers");
dojo.require("dojox.charting.plot2d.MarkersOnly");
dojo.require("dojox.charting.plot2d.Scatter");
dojo.require("dojox.charting.plot2d.Stacked");
dojo.require("dojox.charting.plot2d.StackedLines");
dojo.require("dojox.charting.plot2d.StackedAreas");
dojo.require("dojox.charting.plot2d.Columns");
dojo.require("dojox.charting.plot2d.StackedColumns");
dojo.require("dojox.charting.plot2d.ClusteredColumns");
dojo.require("dojox.charting.plot2d.Bars");
dojo.require("dojox.charting.plot2d.StackedBars");
dojo.require("dojox.charting.plot2d.ClusteredBars");
dojo.require("dojox.charting.plot2d.Grid");
dojo.require("dojox.charting.plot2d.Pie");
dojo.require("dojox.charting.plot2d.Bubble");
(function(){
var df = dojox.lang.functional, dc = dojox.charting,
clear = df.lambda("item.clear()"),
purge = df.lambda("item.purgeGroup()"),
destroy = df.lambda("item.destroy()"),
makeClean = df.lambda("item.dirty = false"),
makeDirty = df.lambda("item.dirty = true");
dojo.declare("dojox.charting.Chart2D", null, {
constructor: function(node, kwArgs){
// initialize parameters
if(!kwArgs){ kwArgs = {}; }
this.margins = kwArgs.margins ? kwArgs.margins : {l: 10, t: 10, r: 10, b: 10};
this.stroke = kwArgs.stroke;
this.fill = kwArgs.fill;
// 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;
this.coords = null;
// create a surface
this.node = dojo.byId(node);
var box = dojo.marginBox(node);
this.surface = dojox.gfx.createSurface(this.node, box.w, box.h);
},
destroy: function(){
dojo.forEach(this.series, destroy);
dojo.forEach(this.stack, destroy);
df.forIn(this.axes, destroy);
},
getCoords: function(){
if(!this.coords){
this.coords = dojo.coords(this.node, true);
}
return this.coords;
},
setTheme: function(theme){
this.theme = theme;
this.dirty = true;
return this;
},
addAxis: function(name, kwArgs){
var axis;
if(!kwArgs || !("type" in kwArgs)){
axis = new dc.axis2d.Default(this, kwArgs);
}else{
axis = typeof kwArgs.type == "string" ?
new dc.axis2d[kwArgs.type](this, kwArgs) :
new kwArgs.type(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;
},
getAxis: function(name){
return this.axes[name];
},
addPlot: function(name, kwArgs){
var plot;
if(!kwArgs || !("type" in kwArgs)){
plot = new dc.plot2d.Default(this, kwArgs);
}else{
plot = typeof kwArgs.type == "string" ?
new dc.plot2d[kwArgs.type](this, kwArgs) :
new kwArgs.type(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;
},
addSeries: function(name, data, kwArgs){
var run = new dc.Series(this, data, kwArgs);
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);
}
run.name = name;
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;
},
updateSeries: function(name, data){
if(name in this.runs){
var run = this.series[this.runs[name]],
plot = this.stack[this.plots[run.plot]], axis;
run.data = data;
run.dirty = true;
// check to see if axes and plot should be updated
if(plot.hAxis){
axis = this.axes[plot.hAxis];
if(axis.dependOnData()){
axis.dirty = true;
// find all plots and mark them dirty
dojo.forEach(this.stack, function(p){
if(p.hAxis && p.hAxis == plot.hAxis){
p.dirty = true;
}
});
}
}else{
plot.dirty = true;
}
if(plot.vAxis){
axis = this.axes[plot.vAxis];
if(axis.dependOnData()){
axis.dirty = true;
// find all plots and mark them dirty
dojo.forEach(this.stack, function(p){
if(p.vAxis && p.vAxis == plot.vAxis){
p.dirty = true;
}
});
}
}else{
plot.dirty = true;
}
}
return this;
},
resize: function(width, height){
var box;
switch(arguments.length){
case 0:
box = dojo.marginBox(this.node);
break;
case 1:
box = width;
break;
default:
box = {w: width, h: height};
break;
}
dojo.marginBox(this.node, box);
this.surface.setDimensions(box.w, box.h);
this.dirty = true;
this.coords = null;
return this.render();
},
getGeometry: function(){
var ret = {};
df.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;
},
setAxisWindow: function(name, scale, offset){
var axis = this.axes[name];
if(axis){
axis.setWindow(scale, offset);
}
return this;
},
setWindow: function(sx, sy, dx, dy){
if(!("plotArea" in this)){
this.calculateGeometry();
}
df.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);
});
return this;
},
calculateGeometry: function(){
if(this.dirty){
return this.fullGeometry();
}
// calculate geometry
dojo.forEach(this.stack, function(plot){
if(plot.dirty || (plot.hAxis && this.axes[plot.hAxis].dirty) ||
(plot.vAxis && this.axes[plot.vAxis].dirty)){
plot.calculateAxes(this.plotArea);
}
}, this);
return this;
},
fullGeometry: function(){
this._makeDirty();
// clear old values
dojo.forEach(this.stack, clear);
// rebuild new connections, and add defaults
// set up a theme
if(!this.theme){
this.theme = new dojox.charting.Theme(dojox.charting._def);
}
// assign series
dojo.forEach(this.series, function(run){
if(!(run.plot in this.plots)){
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
dojo.forEach(this.stack, function(plot){
if(plot.hAxis){
plot.setAxis(this.axes[plot.hAxis]);
}
if(plot.vAxis){
plot.setAxis(this.axes[plot.vAxis]);
}
}, this);
// calculate geometry
// 1st pass
var dim = this.dim = this.surface.getDimensions();
dim.width = dojox.gfx.normalizedLength(dim.width);
dim.height = dojox.gfx.normalizedLength(dim.height);
df.forIn(this.axes, clear);
dojo.forEach(this.stack, function(plot){ plot.calculateAxes(dim); });
// assumption: we don't have stacked axes yet
var offsets = this.offsets = {l: 0, r: 0, t: 0, b: 0};
df.forIn(this.axes, function(axis){
df.forIn(axis.getOffsets(), function(o, i){ offsets[i] += o; });
});
// add margins
df.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};
df.forIn(this.axes, clear);
dojo.forEach(this.stack, function(plot){ plot.calculateAxes(this.plotArea); }, this);
return this;
},
render: function(){
if(this.dirty){
return this.fullRender();
}
this.calculateGeometry();
// go over the stack backwards
df.forEachRev(this.stack, function(plot){ plot.render(this.dim, this.offsets); }, this);
// go over axes
df.forIn(this.axes, function(axis){ axis.render(this.dim, this.offsets); }, this);
this._makeClean();
// BEGIN FOR HTML CANVAS
if(this.surface.render){ this.surface.render(); };
// END FOR HTML CANVAS
return this;
},
fullRender: function(){
// calculate geometry
this.fullGeometry();
var offsets = this.offsets, dim = this.dim;
// get required colors
var requiredColors = df.foldl(this.stack, "z + plot.getRequiredColors()", 0);
this.theme.defineColors({num: requiredColors, cache: false});
// clear old shapes
dojo.forEach(this.series, purge);
df.forIn(this.axes, purge);
dojo.forEach(this.stack, purge);
this.surface.clear();
// generate shapes
// draw a plot background
var t = this.theme,
fill = t.plotarea && t.plotarea.fill,
stroke = t.plotarea && t.plotarea.stroke;
if(fill){
this.surface.createRect({
x: offsets.l, y: offsets.t,
width: dim.width - offsets.l - offsets.r,
height: dim.height - offsets.t - offsets.b
}).setFill(fill);
}
if(stroke){
this.surface.createRect({
x: offsets.l, y: offsets.t,
width: dim.width - offsets.l - offsets.r - 1,
height: dim.height - offsets.t - offsets.b - 1
}).setStroke(stroke);
}
// go over the stack backwards
df.foldr(this.stack, function(z, plot){ return plot.render(dim, offsets), 0; }, 0);
// pseudo-clipping: matting
fill = this.fill ? this.fill : (t.chart && t.chart.fill);
stroke = this.stroke ? 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 dojo.Color(dojo.style(node, "backgroundColor"));
while(fill.a==0 && node!=document.documentElement){
fill = new dojo.Color(dojo.style(node, "backgroundColor"));
node = node.parentNode;
}
}
if(fill){
if(offsets.l){ // left
this.surface.createRect({
width: offsets.l,
height: dim.height + 1
}).setFill(fill);
}
if(offsets.r){ // right
this.surface.createRect({
x: dim.width - offsets.r,
width: offsets.r + 1,
height: dim.height + 1
}).setFill(fill);
}
if(offsets.t){ // top
this.surface.createRect({
width: dim.width + 1,
height: offsets.t
}).setFill(fill);
}
if(offsets.b){ // bottom
this.surface.createRect({
y: dim.height - offsets.b,
width: dim.width + 1,
height: offsets.b + 2
}).setFill(fill);
}
}
if(stroke){
this.surface.createRect({
width: dim.width - 1,
height: dim.height - 1
}).setStroke(stroke);
}
// go over axes
df.forIn(this.axes, function(axis){ axis.render(dim, offsets); });
this._makeClean();
// BEGIN FOR HTML CANVAS
if(this.surface.render){ this.surface.render(); };
// END FOR HTML CANVAS
return this;
},
connectToPlot: function(name, object, method){
return name in this.plots ? this.stack[this.plots[name]].connect(object, method) : null;
},
_makeClean: function(){
// reset dirty flags
dojo.forEach(this.axes, makeClean);
dojo.forEach(this.stack, makeClean);
dojo.forEach(this.series, makeClean);
this.dirty = false;
},
_makeDirty: function(){
// reset dirty flags
dojo.forEach(this.axes, makeDirty);
dojo.forEach(this.stack, makeDirty);
dojo.forEach(this.series, makeDirty);
this.dirty = true;
}
});
})();
