Subversion Repositories Applications.papyrus

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.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.forEachReversed(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;
                }
        });
})();

}