Subversion Repositories Applications.papyrus

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

dojo.require("dojox.gfx.shape");

dojo.declare("dojox.gfx.path.Path", dojox.gfx.Shape, {
        // summary: a generalized path shape
        
        constructor: function(rawNode){
                // summary: a path constructor
                // rawNode: Node: a DOM node to be used by this path object
                this.shape = dojo.clone(dojox.gfx.defaultPath);
                this.segments = [];
                this.absolute = true;
                this.last = {};
                this.rawNode = rawNode;
        },
        
        // mode manipulations
        setAbsoluteMode: function(mode){
                // summary: sets an absolute or relative mode for path points
                // mode: Boolean: true/false or "absolute"/"relative" to specify the mode
                this.absolute = typeof mode == "string" ? (mode == "absolute") : mode;
                return this; // self
        },
        getAbsoluteMode: function(){
                // summary: returns a current value of the absolute mode
                return this.absolute; // Boolean
        },
        
        getBoundingBox: function(){
                // summary: returns the bounding box {x, y, width, height} or null
                return (this.bbox && ("l" in this.bbox)) ? {x: this.bbox.l, y: this.bbox.t, width: this.bbox.r - this.bbox.l, height: this.bbox.b - this.bbox.t} : null; // dojox.gfx.Rectangle
        },
        
        getLastPosition: function(){
                // summary: returns the last point in the path, or null
                return "x" in this.last ? this.last : null; // Object
        },
        
        // segment interpretation
        _updateBBox: function(x, y){
                // summary: updates the bounding box of path with new point
                // x: Number: an x coordinate
                // y: Number: a y coordinate
                
                // we use {l, b, r, t} representation of a bbox
                if(this.bbox && ("l" in this.bbox)){
                        if(this.bbox.l > x) this.bbox.l = x;
                        if(this.bbox.r < x) this.bbox.r = x;
                        if(this.bbox.t > y) this.bbox.t = y;
                        if(this.bbox.b < y) this.bbox.b = y;
                }else{
                        this.bbox = {l: x, b: y, r: x, t: y};
                }
        },
        _updateWithSegment: function(segment){
                // summary: updates the bounding box of path with new segment
                // segment: Object: a segment
                var n = segment.args, l = n.length;
                // update internal variables: bbox, absolute, last
                switch(segment.action){
                        case "M":
                        case "L":
                        case "C":
                        case "S":
                        case "Q":
                        case "T":
                                for(var i = 0; i < l; i += 2){
                                        this._updateBBox(n[i], n[i + 1]);
                                }
                                this.last.x = n[l - 2];
                                this.last.y = n[l - 1];
                                this.absolute = true;
                                break;
                        case "H":
                                for(var i = 0; i < l; ++i){
                                        this._updateBBox(n[i], this.last.y);
                                }
                                this.last.x = n[l - 1];
                                this.absolute = true;
                                break;
                        case "V":
                                for(var i = 0; i < l; ++i){
                                        this._updateBBox(this.last.x, n[i]);
                                }
                                this.last.y = n[l - 1];
                                this.absolute = true;
                                break;
                        case "m":
                                var start = 0;
                                if(!("x" in this.last)){
                                        this._updateBBox(this.last.x = n[0], this.last.y = n[1]);
                                        start = 2;
                                }
                                for(var i = start; i < l; i += 2){
                                        this._updateBBox(this.last.x += n[i], this.last.y += n[i + 1]);
                                }
                                this.absolute = false;
                                break;
                        case "l":
                        case "t":
                                for(var i = 0; i < l; i += 2){
                                        this._updateBBox(this.last.x += n[i], this.last.y += n[i + 1]);
                                }
                                this.absolute = false;
                                break;
                        case "h":
                                for(var i = 0; i < l; ++i){
                                        this._updateBBox(this.last.x += n[i], this.last.y);
                                }
                                this.absolute = false;
                                break;
                        case "v":
                                for(var i = 0; i < l; ++i){
                                        this._updateBBox(this.last.x, this.last.y += n[i]);
                                }
                                this.absolute = false;
                                break;
                        case "c":
                                for(var i = 0; i < l; i += 6){
                                        this._updateBBox(this.last.x + n[i], this.last.y + n[i + 1]);
                                        this._updateBBox(this.last.x + n[i + 2], this.last.y + n[i + 3]);
                                        this._updateBBox(this.last.x += n[i + 4], this.last.y += n[i + 5]);
                                }
                                this.absolute = false;
                                break;
                        case "s":
                        case "q":
                                for(var i = 0; i < l; i += 4){
                                        this._updateBBox(this.last.x + n[i], this.last.y + n[i + 1]);
                                        this._updateBBox(this.last.x += n[i + 2], this.last.y += n[i + 3]);
                                }
                                this.absolute = false;
                                break;
                        case "A":
                                for(var i = 0; i < l; i += 7){
                                        this._updateBBox(n[i + 5], n[i + 6]);
                                }
                                this.last.x = n[l - 2];
                                this.last.y = n[l - 1];
                                this.absolute = true;
                                break;
                        case "a":
                                for(var i = 0; i < l; i += 7){
                                        this._updateBBox(this.last.x += n[i + 5], this.last.y += n[i + 6]);
                                }
                                this.absolute = false;
                                break;
                }
                // add an SVG path segment
                var path = [segment.action];
                for(var i = 0; i < l; ++i){
                        path.push(dojox.gfx.formatNumber(n[i], true));
                }
                if(typeof this.shape.path == "string"){
                        this.shape.path += path.join("");
                }else{
                        var l = path.length, a = this.shape.path;
                        for(var i = 0; i < l; ++i){
                                a.push(path[i]);
                        }
                }
        },
        
        // a dictionary, which maps segment type codes to a number of their argemnts
        _validSegments: {m: 2, l: 2, h: 1, v: 1, c: 6, s: 4, q: 4, t: 2, a: 7, z: 0},
        
        _pushSegment: function(action, args){
                // summary: adds a segment
                // action: String: valid SVG code for a segment's type
                // args: Array: a list of parameters for this segment
                var group = this._validSegments[action.toLowerCase()];
                if(typeof group == "number"){
                        if(group){
                                if(args.length >= group){
                                        var segment = {action: action, args: args.slice(0, args.length - args.length % group)};
                                        this.segments.push(segment);
                                        this._updateWithSegment(segment);
                                }
                        }else{
                                var segment = {action: action, args: []};
                                this.segments.push(segment);
                                this._updateWithSegment(segment);
                        }
                }
        },
        
        _collectArgs: function(array, args){
                // summary: converts an array of arguments to plain numeric values
                // array: Array: an output argument (array of numbers)
                // args: Array: an input argument (can be values of Boolean, Number, dojox.gfx.Point, or an embedded array of them)
                for(var i = 0; i < args.length; ++i){
                        var t = args[i];
                        if(typeof t == "boolean"){
                                array.push(t ? 1 : 0);
                        }else if(typeof t == "number"){
                                array.push(t);
                        }else if(t instanceof Array){
                                this._collectArgs(array, t);
                        }else if("x" in t && "y" in t){
                                array.push(t.x, t.y);
                        }
                }
        },

        // segments     
        moveTo: function(){
                // summary: formes a move segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "M" : "m", args);
                return this; // self
        },
        lineTo: function(){
                // summary: formes a line segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "L" : "l", args);
                return this; // self
        },
        hLineTo: function(){
                // summary: formes a horizontal line segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "H" : "h", args);
                return this; // self
        },
        vLineTo: function(){
                // summary: formes a vertical line segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "V" : "v", args);
                return this; // self
        },
        curveTo: function(){
                // summary: formes a curve segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "C" : "c", args);
                return this; // self
        },
        smoothCurveTo: function(){
                // summary: formes a smooth curve segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "S" : "s", args);
                return this; // self
        },
        qCurveTo: function(){
                // summary: formes a quadratic curve segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "Q" : "q", args);
                return this; // self
        },
        qSmoothCurveTo: function(){
                // summary: formes a quadratic smooth curve segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "T" : "t", args);
                return this; // self
        },
        arcTo: function(){
                // summary: formes an elliptic arc segment
                var args = [];
                this._collectArgs(args, arguments);
                this._pushSegment(this.absolute ? "A" : "a", args);
                return this; // self
        },
        closePath: function(){
                // summary: closes a path
                this._pushSegment("Z", []);
                return this; // self
        },
        
        // setShape
        _setPath: function(path){
                // summary: forms a path using an SVG path string
                // path: String: an SVG path string
                var p = dojo.isArray(path) ? path : path.match(dojox.gfx.pathSvgRegExp);
                this.segments = [];
                this.absolute = true;
                this.bbox = {};
                this.last = {};
                if(!p) return;
                // create segments
                var action = "",        // current action
                        args = [],              // current arguments
                        l = p.length;
                for(var i = 0; i < l; ++i){
                        var t = p[i], x = parseFloat(t);
                        if(isNaN(x)){
                                if(action){
                                        this._pushSegment(action, args);
                                }
                                args = [];
                                action = t;
                        }else{
                                args.push(x);
                        }
                }
                this._pushSegment(action, args);
        },
        setShape: function(newShape){
                // summary: forms a path using a shape
                // newShape: Object: an SVG path string or a path object (see dojox.gfx.defaultPath)
                dojox.gfx.Shape.prototype.setShape.call(this, typeof newShape == "string" ? {path: newShape} : newShape);
                var path = this.shape.path;
                // switch to non-updating version of path building
                this.shape.path = [];
                this._setPath(path);
                // switch back to the string path
                this.shape.path = this.shape.path.join("");
                return this; // self
        },
        
        // useful constant for descendants
        _2PI: Math.PI * 2
});

dojo.declare("dojox.gfx.path.TextPath", dojox.gfx.path.Path, {
        // summary: a generalized TextPath shape

        constructor: function(rawNode){
                // summary: a TextPath shape constructor
                // rawNode: Node: a DOM node to be used by this TextPath object
                if(!("text" in this)){
                        this.text = dojo.clone(dojox.gfx.defaultTextPath);
                }
                if(!("fontStyle" in this)){
                        this.fontStyle = dojo.clone(dojox.gfx.defaultFont);
                }
        },
        setText: function(newText){
                // summary: sets a text to be drawn along the path
                this.text = dojox.gfx.makeParameters(this.text, 
                        typeof newText == "string" ? {text: newText} : newText);
                this._setText();
                return this;    // self
        },
        setFont: function(newFont){
                // summary: sets a font for text
                this.fontStyle = typeof newFont == "string" ? 
                        dojox.gfx.splitFontString(newFont) :
                        dojox.gfx.makeParameters(dojox.gfx.defaultFont, newFont);
                this._setFont();
                return this;    // self
        }
});

}