source: Dev/branches/rest-dojo-ui/client/dojox/charting/plot2d/StackedColumns.js @ 274

define(["dojo/_base/lang", "dojo/_base/array", "dojo/_base/declare", "./Columns", "./common", 
        "dojox/lang/functional", "dojox/lang/functional/reversed", "dojox/lang/functional/sequence"], 
        function(lang, arr, declare, Columns, dc, df, dfr, dfs){

        var     purgeGroup = dfr.lambda("item.purgeGroup()");
/*=====
var Columns = dojox.charting.plot2d.Columns;
=====*/
        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 = dc.collectStackedStats(this.series);
                        this._maxRunLength = stats.hmax;
                        stats.hmin -= 0.5;
                        stats.hmax += 0.5;
                        return stats;
                },
                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.StackedColumns
                        //              A reference to this plot for functional chaining.
                        if(this._maxRunLength <= 0){
                                return this;
                        }

                        // stack all values
                        var acc = df.repeat(this._maxRunLength, "-> 0", 0);
                        for(var i = 0; i < this.series.length; ++i){
                                var run = this.series[i];
                                for(var j = 0; j < run.data.length; ++j){
                                        var value = run.data[j];
                                        if(value !== null){
                                                var v = typeof value == "number" ? value : value.y;
                                                if(isNaN(v)){ v = 0; }
                                                acc[j] += v;
                                        }
                                }
                        }
                        // draw runs in backwards
                        if(this.zoom && !this.isDataDirty()){
                                return this.performZoom(dim, offsets);
                        }
                        this.resetEvents();
                        this.dirty = this.isDirty();
                        if(this.dirty){
                                arr.forEach(this.series, purgeGroup);
                                this._eventSeries = {};
                                this.cleanGroup();
                                var s = this.group;
                                df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
                        }
                        var t = this.chart.theme, f, gap, width,
                                ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
                                vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
                                events = this.events();
                        f = dc.calculateBarSize(this._hScaler.bounds.scale, this.opt);
                        gap = f.gap;
                        width = f.size;
                        for(var i = this.series.length - 1; 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("column", [this.opt, run]), s = run.group,
                                        eventSeries = new Array(acc.length);
                                for(var j = 0; j < acc.length; ++j){
                                        var value = run.data[j];
                                        if(value !== null){
                                                var v = acc[j],
                                                        height = vt(v),
                                                        finalTheme = typeof value != "number" ?
                                                                t.addMixin(theme, "column", value, true) :
                                                                t.post(theme, "column");
                                                if(width >= 1 && height >= 0){
                                                        var rect = {
                                                                x: offsets.l + ht(j + 0.5) + gap,
                                                                y: dim.height - offsets.b - vt(v),
                                                                width: width, height: height
                                                        };
                                                        var specialFill = this._plotFill(finalTheme.series.fill, dim, offsets);
                                                        specialFill = this._shapeFill(specialFill, rect);
                                                        var shape = s.createRect(rect).setFill(specialFill).setStroke(finalTheme.series.stroke);
                                                        run.dyn.fill   = shape.getFill();
                                                        run.dyn.stroke = shape.getStroke();
                                                        if(events){
                                                                var o = {
                                                                        element: "column",
                                                                        index:   j,
                                                                        run:     run,
                                                                        shape:   shape,
                                                                        x:       j + 0.5,
                                                                        y:       v
                                                                };
                                                                this._connectEvents(o);
                                                                eventSeries[j] = o;
                                                        }
                                                        if(this.animate){
                                                                this._animateColumn(shape, dim.height - offsets.b, height);
                                                        }
                                                }
                                        }
                                }
                                this._eventSeries[run.name] = eventSeries;
                                run.dirty = false;
                                // update the accumulator
                                for(var j = 0; j < run.data.length; ++j){
                                        var value = run.data[j];
                                        if(value !== null){
                                                var v = typeof value == "number" ? value : value.y;
                                                if(isNaN(v)){ v = 0; }
                                                acc[j] -= v;
                                        }
                                }
                        }
                        this.dirty = false;
                        return this;    //      dojox.charting.plot2d.StackedColumns
                }
        });
});