source: Dev/trunk/src/client/dojox/charting/plot2d/Base.js

define(["dojo/_base/declare", "dojo/_base/array", "dojox/gfx",
                "../Element", "./common", "../axis2d/common", "dojo/has"],
        function(declare, arr, gfx, Element, common, ac, has){
/*=====
dojox.charting.plot2d.__PlotCtorArgs = {
        // summary:
        //              The base keyword arguments object for plot constructors.
        //              Note that the parameters for this may change based on the
        //              specific plot type (see the corresponding plot type for
        //              details).

        // tooltipFunc: Function?
        //              An optional function used to compute tooltip text for this plot. It takes precedence over
        //              the default function when available.
        //      |               function tooltipFunc(o) { return "text"; }
        //              `o`is the event object that triggered the tooltip.
        tooltipFunc: null
};
=====*/
        var Base = declare("dojox.charting.plot2d.Base", Element, {
                // summary:
                //              Base class for all plot types.
                constructor: function(chart, kwArgs){
                        // summary:
                        //              Create a base plot for charting.
                        // chart: dojox/chart/Chart
                        //              The chart this plot belongs to.
                        // kwArgs: dojox.charting.plot2d.__PlotCtorArgs?
                        //              An optional arguments object to help define the plot.
        
                        // TODO does not work in markup
                        if(kwArgs && kwArgs.tooltipFunc){
                                this.tooltipFunc = kwArgs.tooltipFunc;
                        }
                },
                clear: function(){
                        // summary:
                        //              Clear out all of the information tied to this plot.
                        // returns: dojox.charting.plot2d.Base
                        //              A reference to this plot for functional chaining.
                        this.series = [];
                        this.dirty = true;
                        return this;    //      dojox/charting/plot2d/Base
                },
                setAxis: function(axis){
                        // summary:
                        //              Set an axis for this plot.
                        // axis: dojox.charting.axis2d.Base
                        //              The axis to set.
                        // returns: dojox/charting/plot2d/Base
                        //              A reference to this plot for functional chaining.
                        return this;    //      dojox/charting/plot2d/Base
                },
                assignAxes: function(axes){
                        // summary:
                        //              From an array of axes pick the ones that correspond to this plot and
                        //              assign them to the plot using setAxis method.
                        // axes: Array
                        //              An array of dojox/charting/axis2d/Base
                        // tags:
                        //              protected
                        arr.forEach(this.axes, function(axis){
                                if(this[axis]){
                                        this.setAxis(axes[this[axis]]);
                                }
                        }, this);
                },
                addSeries: function(run){
                        // summary:
                        //              Add a data series to this plot.
                        // run: dojox.charting.Series
                        //              The series to be added.
                        // returns: dojox/charting/plot2d/Base
                        //              A reference to this plot for functional chaining.
                        this.series.push(run);
                        return this;    //      dojox/charting/plot2d/Base
                },
                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.
                        return common.collectSimpleStats(this.series);
                },
                calculateAxes: function(dim){
                        // summary:
                        //              Stub function for running the axis calculations (deprecated).
                        // dim: Object
                        //              An object of the form { width, height }
                        // returns: dojox/charting/plot2d/Base
                        //              A reference to this plot for functional chaining.
                        this.initializeScalers(dim, this.getSeriesStats());
                        return this;    //      dojox/charting/plot2d/Base
                },
                initializeScalers: function(){
                        // summary:
                        //              Does nothing.
                        return this;
                },
                isDataDirty: function(){
                        // summary:
                        //              Returns whether or not any of this plot's data series need to be rendered.
                        // returns: Boolean
                        //              Flag indicating if any of this plot's series are invalid and need rendering.
                        return arr.some(this.series, function(item){ return item.dirty; });     //      Boolean
                },
                render: function(dim, offsets){
                        // summary:
                        //              Render the plot on the chart.
                        // dim: Object
                        //              An object of the form { width, height }.
                        // offsets: Object
                        //              An object of the form { l, r, t, b }.
                        // returns: dojox/charting/plot2d/Base
                        //              A reference to this plot for functional chaining.
                        return this;    //      dojox/charting/plot2d/Base
                },
                renderLabel: function(group, x, y, label, theme, block, align){
                        var elem = ac.createText[this.opt.htmlLabels && gfx.renderer != "vml" ? "html" : "gfx"]
                                (this.chart, group, x, y, align?align:"middle", label, theme.series.font, theme.series.fontColor);
                        // if the label is inside we need to avoid catching events on it this would prevent action on
                        // chart elements
                        if(block){
                                // TODO this won't work in IE neither in VML nor in HTML
                                // a solution would be to catch the event on the label and refire it to the element
                                // possibly using elementFromPoint or having it already available
                                if(this.opt.htmlLabels && gfx.renderer != "vml"){
                                        // we have HTML labels, let's use pointEvents on the HTML node
                                        elem.style.pointerEvents = "none";
                                }else if(elem.rawNode){
                                        // we have SVG labels, let's use pointerEvents on the SVG or VML node
                                        elem.rawNode.style.pointerEvents = "none";
                                }
                                // else we have Canvas, we need do nothing, as Canvas text won't catch events
                        }
                        if(this.opt.htmlLabels && gfx.renderer != "vml"){
                                this.htmlElements.push(elem);
                        }

                        return elem;
                },
                getRequiredColors: function(){
                        // summary:
                        //              Get how many data series we have, so we know how many colors to use.
                        // returns: Number
                        //              The number of colors needed.
                        return this.series.length;      //      Number
                },
                _getLabel: function(number){
                        return common.getLabel(number, this.opt.fixed, this.opt.precision);
                }
        });
        if(has("dojo-bidi")){
                Base.extend({
                        _checkOrientation: function(group, dim, offsets){
                                this.chart.applyMirroring(this.group, dim, offsets);
                        }               
                });
        }
        return Base;
});