summaryrefslogtreecommitdiff
path: root/includes/js/dojox/charting/Chart2D.js
diff options
context:
space:
mode:
Diffstat (limited to 'includes/js/dojox/charting/Chart2D.js')
-rw-r--r--includes/js/dojox/charting/Chart2D.js341
1 files changed, 341 insertions, 0 deletions
diff --git a/includes/js/dojox/charting/Chart2D.js b/includes/js/dojox/charting/Chart2D.js
new file mode 100644
index 0000000..27be653
--- /dev/null
+++ b/includes/js/dojox/charting/Chart2D.js
@@ -0,0 +1,341 @@
+if(!dojo._hasResource["dojox.charting.Chart2D"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.charting.Chart2D"] = true;
+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");
+
+dojo.require("dojox.charting.axis2d.Default");
+
+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");
+
+(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;
+ },
+ 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);
+ }
+ 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();
+ },
+ render: function(){
+ if(this.dirty){
+ return this.fullRender();
+ }
+
+ // 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);
+
+ // 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(){
+ this._makeDirty();
+
+ // clear old values
+ dojo.forEach(this.stack, clear);
+ dojo.forEach(this.series, purge);
+ df.forIn(this.axes, purge);
+ dojo.forEach(this.stack, purge);
+ this.surface.clear();
+
+ // rebuild new connections, and add defaults
+
+ // 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);
+ // set up a theme
+ if(!this.theme){
+ this.theme = new dojox.charting.Theme(dojox.charting._def);
+ }
+ var requiredColors = df.foldl(this.stack, "z + plot.getRequiredColors()", 0);
+ this.theme.defineColors({num: requiredColors, cache: false});
+
+ // 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);
+
+ // generate shapes
+
+ // draw a chart background
+ var t = this.theme,
+ fill = this.fill ? this.fill : (t.chart && t.chart.fill),
+ stroke = this.stroke ? this.stroke : (t.chart && t.chart.stroke);
+ if(fill){
+ this.surface.createRect({
+ width: dim.width,
+ height: dim.height
+ }).setFill(fill);
+ }
+ if(stroke){
+ this.surface.createRect({
+ width: dim.width - 1,
+ height: dim.height - 1
+ }).setStroke(stroke);
+ }
+ // draw a plot background
+ 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);
+
+ // go over axes
+ df.forIn(this.axes, function(axis){ axis.render(dim, offsets); });
+
+ this._makeClean();
+
+ return this;
+ },
+ _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;
+ }
+ });
+})();
+
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-10 05:12:03 +0000