Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dojox.charting.axis2d.Default"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
dojo._hasResource["dojox.charting.axis2d.Default"] = true;
dojo.provide("dojox.charting.axis2d.Default");

dojo.require("dojox.charting.scaler");
dojo.require("dojox.charting.axis2d.common");
dojo.require("dojox.charting.axis2d.Base");

dojo.require("dojo.colors");
dojo.require("dojox.gfx");
dojo.require("dojox.lang.functional");
dojo.require("dojox.lang.utils");

(function(){
        var dc = dojox.charting, 
                df = dojox.lang.functional, 
                du = dojox.lang.utils, 
                g = dojox.gfx,
                labelGap = 4,                           // in pixels
                labelFudgeFactor = 0.8;         // in percents (to convert font's heigth to label width)
                
        var eq = function(/* Number */ a, /* Number */ b){
                // summary: compare two FP numbers for equality
                return Math.abs(a - b) <= 1e-6 * (Math.abs(a) + Math.abs(b));   // Boolean
        };

        dojo.declare("dojox.charting.axis2d.Default", dojox.charting.axis2d.Base, {
                 defaultParams: {
                        vertical:    false,             // true for vertical axis
                        fixUpper:    "none",    // align the upper on ticks: "major", "minor", "micro", "none"
                        fixLower:    "none",    // align the lower on ticks: "major", "minor", "micro", "none"
                        natural:     false,             // all tick marks should be made on natural numbers
                        leftBottom:  true,              // position of the axis, used with "vertical"
                        includeZero: false,             // 0 should be included
                        fixed:       true,              // all labels are fixed numbers
                        majorLabels: true,              // draw major labels
                        minorTicks:  true,              // draw minor ticks
                        minorLabels: true,              // draw minor labels
                        microTicks:  false,             // draw micro ticks
                        htmlLabels:  true               // use HTML to draw labels
                },
                optionalParams: {
                        "min":           0,             // minimal value on this axis
                        "max":           1,             // maximal value on this axis
                        "majorTickStep": 4,             // major tick step
                        "minorTickStep": 2,             // minor tick step
                        "microTickStep": 1,             // micro tick step
                        "labels":        [],    // array of labels for major ticks
                                                                        // with corresponding numeric values
                                                                        // ordered by values
                        // theme components
                        "stroke":        {},    // stroke for an axis
                        "majorTick":     {},    // stroke + length for a tick
                        "minorTick":     {},    // stroke + length for a tick
                        "font":          "",    // font for labels
                        "fontColor":     ""             // color for labels as a string
                },

                constructor: function(chart, kwArgs){
                        this.opt = dojo.clone(this.defaultParams);
                        du.updateWithObject(this.opt, kwArgs);
                        du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
                },
                dependOnData: function(){
                        return !("min" in this.opt) || !("max" in this.opt);
                },
                clear: function(){
                        delete this.scaler;
                        this.dirty = true;
                        return this;
                },
                initialized: function(){
                        return "scaler" in this;
                },
                calculate: function(min, max, span, labels){
                        if(this.initialized()){ return this; }
                        this.labels = "labels" in this.opt ? this.opt.labels : labels;
                        if("min" in this.opt){ min = this.opt.min; }
                        if("max" in this.opt){ max = this.opt.max; }
                        if(this.opt.includeZero){
                                if(min > 0){ min = 0; }
                                if(max < 0){ max = 0; }
                        }
                        var minMinorStep = 0, ta = this.chart.theme.axis, 
                                taFont = "font" in this.opt ? this.opt.font : ta.font,
                                size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0;
                        if(this.vertical){
                                if(size){
                                        minMinorStep = size + labelGap;
                                }
                        }else{
                                if(size){
                                        var labelLength = Math.ceil(Math.log(Math.max(Math.abs(min), Math.abs(max))) / Math.LN10);
                                        if(min < 0 || max < 0){ ++labelLength; }
                                        var precision = Math.floor(Math.log(max - min) / Math.LN10);
                                        if(precision > 0){ labelLength += precision; }
                                        if(this.labels){
                                                labelLength = df.foldl(df.map(this.labels, "x.text.length"), "Math.max(a, b)", labelLength);
                                        }
                                        minMinorStep = Math.floor(size * labelLength * labelFudgeFactor) + labelGap;
                                }
                        }
                        var kwArgs = {
                                fixUpper: this.opt.fixUpper, 
                                fixLower: this.opt.fixLower, 
                                natural:  this.opt.natural
                        };
                        if("majorTickStep" in this.opt){ kwArgs.majorTick = this.opt.majorTickStep; }
                        if("minorTickStep" in this.opt){ kwArgs.minorTick = this.opt.minorTickStep; }
                        if("microTickStep" in this.opt){ kwArgs.microTick = this.opt.microTickStep; }
                        this.scaler = dojox.charting.scaler(min, max, span, kwArgs);
                        this.scaler.minMinorStep = minMinorStep;
                        return this;
                },
                getScaler: function(){
                        return this.scaler;
                },
                getOffsets: function(){
                        var offsets = {l: 0, r: 0, t: 0, b: 0};
                        var offset = 0, ta = this.chart.theme.axis,
                                taFont = "font" in this.opt ? this.opt.font : ta.font,
                                taMajorTick = "majorTick" in this.opt ? this.opt.majorTick : ta.majorTick,
                                taMinorTick = "minorTick" in this.opt ? this.opt.minorTick : ta.minorTick,
                                size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0;
                        if(this.vertical){
                                if(size){
                                        var s = this.scaler,
                                                a = this._getLabel(s.major.start, s.major.prec).length,
                                                b = this._getLabel(s.major.start + s.major.count * s.major.tick, s.major.prec).length,
                                                c = this._getLabel(s.minor.start, s.minor.prec).length,
                                                d = this._getLabel(s.minor.start + s.minor.count * s.minor.tick, s.minor.prec).length,
                                                labelLength = Math.max(a, b, c, d);
                                        if(this.labels){
                                                labelLength = df.foldl(df.map(this.labels, "x.text.length"), "Math.max(a, b)", labelLength);
                                        }
                                        offset = Math.floor(size * labelLength * labelFudgeFactor) + labelGap;
                                }
                                offset += labelGap + Math.max(taMajorTick.length, taMinorTick.length);
                                offsets[this.opt.leftBottom ? "l" : "r"] = offset;
                                offsets.t = offsets.b = size / 2;
                        }else{
                                if(size){
                                        offset = size + labelGap;
                                }
                                offset += labelGap + Math.max(taMajorTick.length, taMinorTick.length);
                                offsets[this.opt.leftBottom ? "b" : "t"] = offset;
                                if(size){
                                        var s = this.scaler,
                                                a = this._getLabel(s.major.start, s.major.prec).length,
                                                b = this._getLabel(s.major.start + s.major.count * s.major.tick, s.major.prec).length,
                                                c = this._getLabel(s.minor.start, s.minor.prec).length,
                                                d = this._getLabel(s.minor.start + s.minor.count * s.minor.tick, s.minor.prec).length,
                                                labelLength = Math.max(a, b, c, d);
                                        if(this.labels){
                                                labelLength = df.foldl(df.map(this.labels, "x.text.length"), "Math.max(a, b)", labelLength);
                                        }
                                        offsets.l = offsets.r = Math.floor(size * labelLength * labelFudgeFactor) / 2;
                                }
                        }
                        return offsets;
                },
                render: function(dim, offsets){
                        if(!this.dirty){ return this; }
                        // prepare variable
                        var start, stop, axisVector, tickVector, labelOffset, labelAlign,
                                ta = this.chart.theme.axis, 
                                taStroke = "stroke" in this.opt ? this.opt.stroke : ta.stroke,
                                taMajorTick = "majorTick" in this.opt ? this.opt.majorTick : ta.majorTick,
                                taMinorTick = "minorTick" in this.opt ? this.opt.minorTick : ta.minorTick,
                                taFont = "font" in this.opt ? this.opt.font : ta.font,
                                taFontColor = "fontColor" in this.opt ? this.opt.fontColor : ta.fontColor,
                                tickSize = Math.max(taMajorTick.length, taMinorTick.length),
                                size = taFont ? g.normalizedLength(g.splitFontString(taFont).size) : 0;
                        if(this.vertical){
                                start = {y: dim.height - offsets.b};
                                stop  = {y: offsets.t};
                                axisVector = {x: 0, y: -1};
                                if(this.opt.leftBottom){
                                        start.x = stop.x = offsets.l;
                                        tickVector = {x: -1, y: 0};
                                        labelAlign = "end";
                                }else{
                                        start.x = stop.x = dim.width - offsets.r;
                                        tickVector = {x: 1, y: 0};
                                        labelAlign = "start";
                                }
                                labelOffset = {x: tickVector.x * (tickSize + labelGap), y: size * 0.4};
                        }else{
                                start = {x: offsets.l};
                                stop  = {x: dim.width - offsets.r};
                                axisVector = {x: 1, y: 0};
                                labelAlign = "middle";
                                if(this.opt.leftBottom){
                                        start.y = stop.y = dim.height - offsets.b;
                                        tickVector = {x: 0, y: 1};
                                        labelOffset = {y: tickSize + labelGap + size};
                                }else{
                                        start.y = stop.y = offsets.t;
                                        tickVector = {x: 0, y: -1};
                                        labelOffset = {y: -tickSize - labelGap};
                                }
                                labelOffset.x = 0;
                        }
                        
                        // render shapes
                        this.cleanGroup();
                        var s = this.group, c = this.scaler, step, next,
                                nextMajor = c.major.start, nextMinor = c.minor.start, nextMicro = c.micro.start;
                        s.createLine({x1: start.x, y1: start.y, x2: stop.x, y2: stop.y}).setStroke(taStroke);
                        if(this.opt.microTicks && c.micro.tick){
                                step = c.micro.tick, next = nextMicro;
                        }else if(this.opt.minorTicks && c.minor.tick){
                                step = c.minor.tick, next = nextMinor;
                        }else if(c.major.tick){
                                step = c.major.tick, next = nextMajor;
                        }else{
                                // don't draw anything
                                return this;
                        }
                        while(next <= c.bounds.upper + 1/c.scale){
                                var offset = (next - c.bounds.lower) * c.scale,
                                        x = start.x + axisVector.x * offset,
                                        y = start.y + axisVector.y * offset;
                                if(Math.abs(nextMajor - next) < step / 2){
                                        // major tick
                                        s.createLine({
                                                x1: x, y1: y,
                                                x2: x + tickVector.x * taMajorTick.length,
                                                y2: y + tickVector.y * taMajorTick.length
                                        }).setStroke(taMajorTick);
                                        if(this.opt.majorLabels){
                                                var elem = dc.axis2d.common.createText[this.opt.htmlLabels ? "html" : "gfx"]
                                                                                (this.chart, s, x + labelOffset.x, y + labelOffset.y, labelAlign,
                                                                                        this._getLabel(nextMajor, c.major.prec), taFont, taFontColor);
                                                if(this.opt.htmlLabels){ this.htmlElements.push(elem); }
                                        }
                                        nextMajor += c.major.tick;
                                        nextMinor += c.minor.tick;
                                        nextMicro += c.micro.tick;
                                }else if(Math.abs(nextMinor - next) < step / 2){
                                        // minor tick
                                        if(this.opt.minorTicks){
                                                s.createLine({
                                                        x1: x, y1: y,
                                                        x2: x + tickVector.x * taMinorTick.length,
                                                        y2: y + tickVector.y * taMinorTick.length
                                                }).setStroke(taMinorTick);
                                                if(this.opt.minorLabels && (c.minMinorStep <= c.minor.tick * c.scale)){
                                                        var elem = dc.axis2d.common.createText[this.opt.htmlLabels ? "html" : "gfx"]
                                                                                        (this.chart, s, x + labelOffset.x, y + labelOffset.y, labelAlign,
                                                                                                this._getLabel(nextMinor, c.minor.prec), taFont, taFontColor);
                                                        if(this.opt.htmlLabels){ this.htmlElements.push(elem); }
                                                }
                                        }
                                        nextMinor += c.minor.tick;
                                        nextMicro += c.micro.tick;
                                }else{
                                        // micro tick
                                        if(this.opt.microTicks){
                                                s.createLine({
                                                        x1: x, y1: y,
                                                        // use minor ticks for now
                                                        x2: x + tickVector.x * taMinorTick.length,
                                                        y2: y + tickVector.y * taMinorTick.length
                                                }).setStroke(taMinorTick);
                                        }
                                        nextMicro += c.micro.tick;
                                }
                                next += step;
                        }
                        this.dirty = false;
                        return this;
                },
                
                // utilities
                _getLabel: function(number, precision){
                        if(this.opt.labels){
                                // classic binary search
                                var l = this.opt.labels, lo = 0, hi = l.length;
                                while(lo < hi){
                                        var mid = Math.floor((lo + hi) / 2), val = l[mid].value;
                                        if(val < number){
                                                lo = mid + 1;
                                        }else{
                                                hi = mid;
                                        }
                                }
                                // lets take into account FP errors
                                if(lo < l.length && eq(l[lo].value, number)){
                                        return l[lo].text;
                                }
                                --lo;
                                if(lo < l.length && eq(l[lo].value, number)){
                                        return l[lo].text;
                                }
                                lo += 2;
                                if(lo < l.length && eq(l[lo].value, number)){
                                        return l[lo].text;
                                }
                                // otherwise we will produce a number
                        }
                        return this.opt.fixed ? number.toFixed(precision < 0 ? -precision : 0) : number.toString();
                }
        });
})();

}