Subversion Repositories Applications.papyrus

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

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

dojo.declare("dojox.gfx.Shape", null, {
        // summary: a Shape object, which knows how to apply 
        // graphical attributes and transformations
        
        constructor: function(){
                // rawNode: Node: underlying node
                this.rawNode = null;
                
                // shape: Object: an abstract shape object
                //      (see dojox.gfx.defaultPath,
                //      dojox.gfx.defaultPolyline,
                //      dojox.gfx.defaultRect,
                //      dojox.gfx.defaultEllipse,
                //      dojox.gfx.defaultCircle,
                //      dojox.gfx.defaultLine,
                //      or dojox.gfx.defaultImage)
                this.shape = null;
                
                // matrix: dojox.gfx.Matrix2D: a transformation matrix
                this.matrix = null;
                
                // fillStyle: Object: a fill object 
                //      (see dojox.gfx.defaultLinearGradient, 
                //      dojox.gfx.defaultRadialGradient, 
                //      dojox.gfx.defaultPattern, 
                //      or dojo.Color)
                this.fillStyle = null;
                
                // strokeStyle: Object: a stroke object 
                //      (see dojox.gfx.defaultStroke) 
                this.strokeStyle = null;
                
                // bbox: dojox.gfx.Rectangle: a bounding box of this shape
                //      (see dojox.gfx.defaultRect)
                this.bbox = null;
                
                // virtual group structure
                
                // parent: Object: a parent or null
                //      (see dojox.gfx.Surface,
                //      dojox.gfx.shape.VirtualGroup,
                //      or dojox.gfx.Group)
                this.parent = null;
                
                // parentMatrix: dojox.gfx.Matrix2D
                //      a transformation matrix inherited from the parent
                this.parentMatrix = null;
        },
        
        // trivial getters
        
        getNode: function(){
                // summary: returns the current DOM Node or null
                return this.rawNode; // Node
        },
        getShape: function(){
                // summary: returns the current shape object or null
                //      (see dojox.gfx.defaultPath,
                //      dojox.gfx.defaultPolyline,
                //      dojox.gfx.defaultRect,
                //      dojox.gfx.defaultEllipse,
                //      dojox.gfx.defaultCircle,
                //      dojox.gfx.defaultLine,
                //      or dojox.gfx.defaultImage)
                return this.shape; // Object
        },
        getTransform: function(){
                // summary: returns the current transformation matrix or null
                return this.matrix;     // dojox.gfx.Matrix2D
        },
        getFill: function(){
                // summary: returns the current fill object or null
                //      (see dojox.gfx.defaultLinearGradient, 
                //      dojox.gfx.defaultRadialGradient, 
                //      dojox.gfx.defaultPattern, 
                //      or dojo.Color)
                return this.fillStyle;  // Object
        },
        getStroke: function(){
                // summary: returns the current stroke object or null
                //      (see dojox.gfx.defaultStroke) 
                return this.strokeStyle;        // Object
        },
        getParent: function(){
                // summary: returns the parent or null
                //      (see dojox.gfx.Surface,
                //      dojox.gfx.shape.VirtualGroup,
                //      or dojox.gfx.Group)
                return this.parent;     // Object
        },
        getBoundingBox: function(){
                // summary: returns the bounding box or null
                //      (see dojox.gfx.defaultRect)
                return this.bbox;       // dojox.gfx.Rectangle
        },
        getTransformedBoundingBox: function(){
                // summary: returns an array of four points or null
                //      four points represent four corners of the untransformed bounding box
                var b = this.getBoundingBox();
                if(!b){
                        return null;    // null
                }
                var m = this._getRealMatrix();
                var r = [];
                var g = dojox.gfx.matrix;
                r.push(g.multiplyPoint(m, b.x, b.y));
                r.push(g.multiplyPoint(m, b.x + b.width, b.y));
                r.push(g.multiplyPoint(m, b.x + b.width, b.y + b.height));
                r.push(g.multiplyPoint(m, b.x, b.y + b.height));
                return r;       // Array
        },
        getEventSource: function(){
                // summary: returns a Node, which is used as 
                //      a source of events for this shape

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                return this.rawNode;    // Node
        },
        
        // empty settings
        
        setShape: function(shape){
                // summary: sets a shape object
                //      (the default implementation simply ignores it)
                // shape: Object: a shape object
                //      (see dojox.gfx.defaultPath,
                //      dojox.gfx.defaultPolyline,
                //      dojox.gfx.defaultRect,
                //      dojox.gfx.defaultEllipse,
                //      dojox.gfx.defaultCircle,
                //      dojox.gfx.defaultLine,
                //      or dojox.gfx.defaultImage)

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                this.shape = dojox.gfx.makeParameters(this.shape, shape);
                this.bbox = null;
                return this;    // self
        },
        setFill: function(fill){
                // summary: sets a fill object
                //      (the default implementation simply ignores it)
                // fill: Object: a fill object
                //      (see dojox.gfx.defaultLinearGradient, 
                //      dojox.gfx.defaultRadialGradient, 
                //      dojox.gfx.defaultPattern, 
                //      or dojo.Color)

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                if(!fill){
                        // don't fill
                        this.fillStyle = null;
                        return this;    // self
                }
                var f = null;
                if(typeof(fill) == "object" && "type" in fill){
                        // gradient or pattern
                        switch(fill.type){
                                case "linear":
                                        f = dojox.gfx.makeParameters(dojox.gfx.defaultLinearGradient, fill);
                                        break;
                                case "radial":
                                        f = dojox.gfx.makeParameters(dojox.gfx.defaultRadialGradient, fill);
                                        break;
                                case "pattern":
                                        f = dojox.gfx.makeParameters(dojox.gfx.defaultPattern, fill);
                                        break;
                        }
                }else{
                        // color object
                        f = dojox.gfx.normalizeColor(fill);
                }
                this.fillStyle = f;
                return this;    // self
        },
        setStroke: function(stroke){
                // summary: sets a stroke object
                //      (the default implementation simply ignores it)
                // stroke: Object: a stroke object
                //      (see dojox.gfx.defaultStroke) 

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                if(!stroke){
                        // don't stroke
                        this.strokeStyle = null;
                        return this;    // self
                }
                // normalize the stroke
                if(typeof stroke == "string"){
                        stroke = {color: stroke};
                }
                var s = this.strokeStyle = dojox.gfx.makeParameters(dojox.gfx.defaultStroke, stroke);
                s.color = dojox.gfx.normalizeColor(s.color);
                return this;    // self
        },
        setTransform: function(matrix){
                // summary: sets a transformation matrix
                // matrix: dojox.gfx.Matrix2D: a matrix or a matrix-like object
                //      (see an argument of dojox.gfx.Matrix2D 
                //      constructor for a list of acceptable arguments)

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                this.matrix = dojox.gfx.matrix.clone(matrix ? dojox.gfx.matrix.normalize(matrix) : dojox.gfx.matrix.identity);
                return this._applyTransform();  // self
        },
        
        _applyTransform: function(){
                // summary: physically sets a matrix

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                return this;    // self
        },
        
        // z-index
        
        moveToFront: function(){
                // summary: moves a shape to front of its parent's list of shapes
                var p = this.getParent();
                if(p){
                        p._moveChildToFront(this);
                        this._moveToFront();    // execute renderer-specific action
                }
                return this;    // self
        },
        moveToBack: function(){
                // summary: moves a shape to back of its parent's list of shapes
                var p = this.getParent();
                if(p){
                        p._moveChildToBack(this);
                        this._moveToBack();     // execute renderer-specific action
                }
                return this;
        },
        _moveToFront: function(){
                // summary: renderer-specific hook, see dojox.gfx.shape.Shape.moveToFront()

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!
        },
        _moveToBack: function(){
                // summary: renderer-specific hook, see dojox.gfx.shape.Shape.moveToFront()

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!
        },

        // apply left & right transformation
        
        applyRightTransform: function(matrix){
                // summary: multiplies the existing matrix with an argument on right side
                //      (this.matrix * matrix)
                // matrix: dojox.gfx.Matrix2D: a matrix or a matrix-like object
                //      (see an argument of dojox.gfx.Matrix2D 
                //      constructor for a list of acceptable arguments)
                return matrix ? this.setTransform([this.matrix, matrix]) : this;        // self
        },
        applyLeftTransform: function(matrix){
                // summary: multiplies the existing matrix with an argument on left side
                //      (matrix * this.matrix)
                // matrix: dojox.gfx.Matrix2D: a matrix or a matrix-like object
                //      (see an argument of dojox.gfx.Matrix2D 
                //      constructor for a list of acceptable arguments)
                return matrix ? this.setTransform([matrix, this.matrix]) : this;        // self
        },
        applyTransform: function(matrix){
                // summary: a shortcut for dojox.gfx.Shape.applyRightTransform
                // matrix: dojox.gfx.Matrix2D: a matrix or a matrix-like object
                //      (see an argument of dojox.gfx.Matrix2D 
                //      constructor for a list of acceptable arguments)
                return matrix ? this.setTransform([this.matrix, matrix]) : this;        // self
        },
        
        // virtual group methods
        
        removeShape: function(silently){
                // summary: removes the shape from its parent's list of shapes
                // silently: Boolean?: if true, do not redraw a picture yet
                if(this.parent){
                        this.parent.remove(this, silently);
                }
                return this;    // self
        },
        _setParent: function(parent, matrix){
                // summary: sets a parent
                // parent: Object: a parent or null
                //      (see dojox.gfx.Surface,
                //      dojox.gfx.shape.VirtualGroup,
                //      or dojox.gfx.Group)
                // matrix: dojox.gfx.Matrix2D:
                //      a 2D matrix or a matrix-like object
                this.parent = parent;
                return this._updateParentMatrix(matrix);        // self
        },
        _updateParentMatrix: function(matrix){
                // summary: updates the parent matrix with new matrix
                // matrix: dojox.gfx.Matrix2D:
                //      a 2D matrix or a matrix-like object
                this.parentMatrix = matrix ? dojox.gfx.matrix.clone(matrix) : null;
                return this._applyTransform();  // self
        },
        _getRealMatrix: function(){
                // summary: returns the cumulative ("real") transformation matrix
                //      by combining the shape's matrix with its parent's matrix
                var m = this.matrix;
                var p = this.parent;
                while(p){
                        if(p.matrix){
                                m = dojox.gfx.matrix.multiply(p.matrix, m);
                        }
                        p = p.parent;
                }
                return m;       // dojox.gfx.Matrix2D
        }
});

dojox.gfx.shape._eventsProcessing = {
        connect: function(name, object, method){
                // summary: connects a handler to an event on this shape

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                return arguments.length > 2 ?   // Object
                        dojo.connect(this.getEventSource(), name, object, method) :
                        dojo.connect(this.getEventSource(), name, object);
        },
        disconnect: function(token){
                // summary: connects a handler by token from an event on this shape

                // COULD BE RE-IMPLEMENTED BY THE RENDERER!

                dojo.disconnect(token);
        }
};

dojo.extend(dojox.gfx.Shape, dojox.gfx.shape._eventsProcessing);

dojox.gfx.shape.Container = {
        // summary: a container of shapes, which can be used 
        //      as a foundation for renderer-specific groups, or as a way 
        //      to logically group shapes (e.g, to propagate matricies)
        
        _init: function() {
                // children: Array: a list of children
                this.children = [];
        },
        
        // group management
        
        add: function(shape){
                // summary: adds a shape to the list
                // shape: dojox.gfx.Shape: a shape
                var oldParent = shape.getParent();
                if(oldParent){
                        oldParent.remove(shape, true);
                }
                this.children.push(shape);
                return shape._setParent(this, this._getRealMatrix());   // self
        },
        remove: function(shape, silently){
                // summary: removes a shape from the list
                // silently: Boolean?: if true, do not redraw a picture yet
                for(var i = 0; i < this.children.length; ++i){
                        if(this.children[i] == shape){
                                if(silently){
                                        // skip for now
                                }else{
                                        shape._setParent(null, null);
                                }
                                this.children.splice(i, 1);
                                break;
                        }
                }
                return this;    // self
        },
        clear: function(){
                // summary: removes all shapes from a group/surface
                this.children = [];
                return this;    // self
        },
        
        // moving child nodes
        
        _moveChildToFront: function(shape){
                // summary: moves a shape to front of the list of shapes
                for(var i = 0; i < this.children.length; ++i){
                        if(this.children[i] == shape){
                                this.children.splice(i, 1);
                                this.children.push(shape);
                                break;
                        }
                }
                return this;    // self
        },
        _moveChildToBack: function(shape){
                // summary: moves a shape to back of the list of shapes
                for(var i = 0; i < this.children.length; ++i){
                        if(this.children[i] == shape){
                                this.children.splice(i, 1);
                                this.children.unshift(shape);
                                break;
                        }
                }
                return this;    // self
        }
};

dojo.declare("dojox.gfx.shape.Surface", null, {
        // summary: a surface object to be used for drawings
        constructor: function(){
                // underlying node
                this.rawNode = null;
        },
        getEventSource: function(){
                // summary: returns a node, which can be used to attach event listeners
                return this.rawNode; // Node
        },
        _getRealMatrix: function(){
                // summary: always returns the identity matrix
                return null;    // dojox.gfx.Matrix2D
        }
});

dojo.extend(dojox.gfx.shape.Surface, dojox.gfx.shape._eventsProcessing);

dojo.declare("dojox.gfx.Point", null, {
        // summary: a hypothetical 2D point to be used for drawings - {x, y}
        // description: This object is defined for documentation purposes.
        //      You should use the naked object instead: {x: 1, y: 2}.
});

dojo.declare("dojox.gfx.Rectangle", null, {
        // summary: a hypothetical rectangle - {x, y, width, height}
        // description: This object is defined for documentation purposes.
        //      You should use the naked object instead: {x: 1, y: 2, width: 100, height: 200}.
});

dojo.declare("dojox.gfx.shape.Rect", dojox.gfx.Shape, {
        // summary: a generic rectangle
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.shape = dojo.clone(dojox.gfx.defaultRect);
                this.rawNode = rawNode;
        },
        getBoundingBox: function(){
                // summary: returns the bounding box (its shape in this case)
                return this.shape;      // dojox.gfx.Rectangle
        }
});

dojo.declare("dojox.gfx.shape.Ellipse", dojox.gfx.Shape, {
        // summary: a generic ellipse
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.shape = dojo.clone(dojox.gfx.defaultEllipse);
                this.rawNode = rawNode;
        },
        getBoundingBox: function(){
                // summary: returns the bounding box
                if(!this.bbox){
                        var shape = this.shape;
                        this.bbox = {x: shape.cx - shape.rx, y: shape.cy - shape.ry, 
                                width: 2 * shape.rx, height: 2 * shape.ry};
                }
                return this.bbox;       // dojox.gfx.Rectangle
        }
});

dojo.declare("dojox.gfx.shape.Circle", dojox.gfx.Shape, {
        // summary: a generic circle
        //      (this is a helper object, which is defined for convenience)
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.shape = dojo.clone(dojox.gfx.defaultCircle);
                this.rawNode = rawNode;
        },
        getBoundingBox: function(){
                // summary: returns the bounding box
                if(!this.bbox){
                        var shape = this.shape;
                        this.bbox = {x: shape.cx - shape.r, y: shape.cy - shape.r, 
                                width: 2 * shape.r, height: 2 * shape.r};
                }
                return this.bbox;       // dojox.gfx.Rectangle
        }
});

dojo.declare("dojox.gfx.shape.Line", dojox.gfx.Shape, {
        // summary: a generic line
        //      (this is a helper object, which is defined for convenience)
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.shape = dojo.clone(dojox.gfx.defaultLine);
                this.rawNode = rawNode;
        },
        getBoundingBox: function(){
                // summary: returns the bounding box
                if(!this.bbox){
                        var shape = this.shape;
                        this.bbox = {
                                x:              Math.min(shape.x1, shape.x2),
                                y:              Math.min(shape.y1, shape.y2),
                                width:  Math.abs(shape.x2 - shape.x1),
                                height: Math.abs(shape.y2 - shape.y1)
                        };
                }
                return this.bbox;       // dojox.gfx.Rectangle
        }
});

dojo.declare("dojox.gfx.shape.Polyline", dojox.gfx.Shape, {
        // summary: a generic polyline/polygon
        //      (this is a helper object, which is defined for convenience)
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.shape = dojo.clone(dojox.gfx.defaultPolyline);
                this.rawNode = rawNode;
        },
        setShape: function(points, closed){
                // summary: sets a polyline/polygon shape object
                // points: Object: a polyline/polygon shape object
                // closed: Boolean: close the polyline to make a polygon
                if(points && points instanceof Array){
                        // points: Array: an array of points
                        dojox.gfx.Shape.prototype.setShape.call(this, {points: points});
                        if(closed && this.shape.points.length){ 
                                this.shape.points.push(this.shape.points[0]);
                        }
                }else{
                        dojox.gfx.Shape.prototype.setShape.call(this, points);
                }
                return this;    // self
        },
        getBoundingBox: function(){
                // summary: returns the bounding box
                if(!this.bbox && this.shape.points.length){
                        var p = this.shape.points;
                        var l = p.length;
                        var t = p[0];
                        var bbox = {l: t.x, t: t.y, r: t.x, b: t.y};
                        for(var i = 1; i < l; ++i){
                                t = p[i];
                                if(bbox.l > t.x) bbox.l = t.x;
                                if(bbox.r < t.x) bbox.r = t.x;
                                if(bbox.t > t.y) bbox.t = t.y;
                                if(bbox.b < t.y) bbox.b = t.y;
                        }
                        this.bbox = {
                                x:              bbox.l, 
                                y:              bbox.t, 
                                width:  bbox.r - bbox.l, 
                                height: bbox.b - bbox.t
                        };
                }
                return this.bbox;       // dojox.gfx.Rectangle
        }
});

dojo.declare("dojox.gfx.shape.Image", dojox.gfx.Shape, {
        // summary: a generic image
        //      (this is a helper object, which is defined for convenience)
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.shape = dojo.clone(dojox.gfx.defaultImage);
                this.rawNode = rawNode;
        },
        getBoundingBox: function(){
                // summary: returns the bounding box (its shape in this case)
                return this.shape;      // dojox.gfx.Rectangle
        },
        setStroke: function(){
                // summary: ignore setting a stroke style
                return this;    // self
        },
        setFill: function(){
                // summary: ignore setting a fill style
                return this;    // self
        }
});

dojo.declare("dojox.gfx.shape.Text", dojox.gfx.Shape, {
        // summary: a generic text
        constructor: function(rawNode) {
                // rawNode: Node: a DOM Node
                this.fontStyle = null;
                this.shape = dojo.clone(dojox.gfx.defaultText);
                this.rawNode = rawNode;
        },
        setFont: function(newFont){
                // summary: sets a font for text
                // newFont: Object: a font object (see dojox.gfx.defaultFont) or a font string
                this.fontStyle = typeof newFont == "string" ? dojox.gfx.splitFontString(newFont) :
                        dojox.gfx.makeParameters(dojox.gfx.defaultFont, newFont);
                this._setFont();
                return this;    // self
        }
});

dojox.gfx.shape.Creator = {
        // summary: shape creators
        createShape: function(shape){
                // summary: creates a shape object based on its type; it is meant to be used
                //      by group-like objects
                // shape: Object: a shape descriptor object
                switch(shape.type){
                        case dojox.gfx.defaultPath.type:                return this.createPath(shape);
                        case dojox.gfx.defaultRect.type:                return this.createRect(shape);
                        case dojox.gfx.defaultCircle.type:              return this.createCircle(shape);
                        case dojox.gfx.defaultEllipse.type:             return this.createEllipse(shape);
                        case dojox.gfx.defaultLine.type:                return this.createLine(shape);
                        case dojox.gfx.defaultPolyline.type:    return this.createPolyline(shape);
                        case dojox.gfx.defaultImage.type:               return this.createImage(shape);
                        case dojox.gfx.defaultText.type:                return this.createText(shape);
                        case dojox.gfx.defaultTextPath.type:    return this.createTextPath(shape);
                }
                return null;
        },
        createGroup: function(){
                // summary: creates an SVG group shape
                return this.createObject(dojox.gfx.Group);      // dojox.gfx.Group
        },
        createRect: function(rect){
                // summary: creates an SVG rectangle shape
                // rect: Object: a path object (see dojox.gfx.defaultRect)
                return this.createObject(dojox.gfx.Rect, rect); // dojox.gfx.Rect
        },
        createEllipse: function(ellipse){
                // summary: creates an SVG ellipse shape
                // ellipse: Object: an ellipse object (see dojox.gfx.defaultEllipse)
                return this.createObject(dojox.gfx.Ellipse, ellipse);   // dojox.gfx.Ellipse
        },
        createCircle: function(circle){
                // summary: creates an SVG circle shape
                // circle: Object: a circle object (see dojox.gfx.defaultCircle)
                return this.createObject(dojox.gfx.Circle, circle);     // dojox.gfx.Circle
        },
        createLine: function(line){
                // summary: creates an SVG line shape
                // line: Object: a line object (see dojox.gfx.defaultLine)
                return this.createObject(dojox.gfx.Line, line); // dojox.gfx.Line
        },
        createPolyline: function(points){
                // summary: creates an SVG polyline/polygon shape
                // points: Object: a points object (see dojox.gfx.defaultPolyline)
                //      or an Array of points
                return this.createObject(dojox.gfx.Polyline, points);   // dojox.gfx.Polyline
        },
        createImage: function(image){
                // summary: creates an SVG image shape
                // image: Object: an image object (see dojox.gfx.defaultImage)
                return this.createObject(dojox.gfx.Image, image);       // dojox.gfx.Image
        },
        createText: function(text){
                // summary: creates an SVG text shape
                // text: Object: a text object (see dojox.gfx.defaultText)
                return this.createObject(dojox.gfx.Text, text); // dojox.gfx.Text
        },
        createPath: function(path){
                // summary: creates an SVG path shape
                // path: Object: a path object (see dojox.gfx.defaultPath)
                return this.createObject(dojox.gfx.Path, path); // dojox.gfx.Path
        },
        createTextPath: function(text){
                // summary: creates an SVG text shape
                // text: Object: a textpath object (see dojox.gfx.defaultTextPath)
                return this.createObject(dojox.gfx.TextPath, {}).setText(text); // dojox.gfx.TextPath
        },
        createObject: function(shapeType, rawShape){
                // summary: creates an instance of the passed shapeType class
                // shapeType: Function: a class constructor to create an instance of
                // rawShape: Object: properties to be passed in to the classes "setShape" method

                // SHOULD BE RE-IMPLEMENTED BY THE RENDERER!

                return null;    // dojox.gfx.Shape
        }
};

}