1115 lines
33 KiB
JavaScript
1115 lines
33 KiB
JavaScript
define("dojox/gfx/shape", ["./_base", "dojo/_base/lang", "dojo/_base/declare", "dojo/_base/kernel", "dojo/_base/sniff",
|
|
"dojo/_base/connect", "dojo/_base/array", "dojo/dom-construct", "dojo/_base/Color", "./matrix" /*===== , "./path" =====*/ ],
|
|
function(g, lang, declare, kernel, has, events, arr, domConstruct, Color, matrixLib){
|
|
|
|
var shape = g.shape = {
|
|
// summary:
|
|
// This module contains the core graphics Shape API.
|
|
// Different graphics renderer implementation modules (svg, canvas, vml, silverlight, etc.) extend this
|
|
// basic api to provide renderer-specific implementations for each shape.
|
|
};
|
|
|
|
// a set of ids (keys=type)
|
|
var _ids = {};
|
|
// a simple set impl to map shape<->id
|
|
var registry = {};
|
|
var disposeCount = 0, fixIELeak = has("ie") < 9;
|
|
|
|
function repack(oldRegistry){
|
|
var newRegistry = {};
|
|
for(var key in oldRegistry){
|
|
if(oldRegistry.hasOwnProperty(key)){
|
|
newRegistry[key] = oldRegistry[key]
|
|
}
|
|
}
|
|
return newRegistry;
|
|
}
|
|
|
|
shape.register = function(/*dojox/gfx/shape.Shape*/s){
|
|
// summary:
|
|
// Register the specified shape into the graphics registry.
|
|
// s: dojox/gfx/shape.Shape
|
|
// The shape to register.
|
|
// returns: Number
|
|
// The unique id associated with this shape.
|
|
|
|
// the id pattern : type+number (ex: Rect0,Rect1,etc)
|
|
var t = s.declaredClass.split('.').pop();
|
|
var i = t in _ids ? ++_ids[t] : ((_ids[t] = 0));
|
|
var uid = t+i;
|
|
registry[uid] = s;
|
|
return uid;
|
|
};
|
|
|
|
shape.byId = function(/*String*/id){
|
|
// summary:
|
|
// Returns the shape that matches the specified id.
|
|
// id: String
|
|
// The unique identifier for this Shape.
|
|
// returns: dojox/gfx/shape.Shape
|
|
return registry[id]; //dojox/gfx/shape.Shape
|
|
};
|
|
|
|
shape.dispose = function(/*dojox/gfx/shape.Shape*/s, /*Boolean?*/recurse){
|
|
// summary:
|
|
// Removes the specified shape from the registry.
|
|
// s: dojox/gfx/shape.Shape
|
|
// The shape to unregister.
|
|
if(recurse && s.children){
|
|
for(var i=0; i< s.children.length; ++i){
|
|
shape.dispose(s.children[i], true);
|
|
}
|
|
}
|
|
delete registry[s.getUID()];
|
|
++disposeCount;
|
|
if(fixIELeak && disposeCount>10000){
|
|
registry = repack(registry);
|
|
disposeCount = 0;
|
|
}
|
|
};
|
|
|
|
shape.Shape = declare("dojox.gfx.shape.Shape", null, {
|
|
// summary:
|
|
// a Shape object, which knows how to apply
|
|
// graphical attributes and transformations
|
|
|
|
constructor: function(){
|
|
// rawNode: Node
|
|
// underlying graphics-renderer-specific implementation object (if applicable)
|
|
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/matrix.Matrix2D
|
|
// a transformation matrix
|
|
this.matrix = null;
|
|
|
|
// fillStyle: dojox/gfx.Fill
|
|
// a fill object
|
|
// (see dojox/gfx.defaultLinearGradient,
|
|
// dojox/gfx.defaultRadialGradient,
|
|
// dojox/gfx.defaultPattern,
|
|
// or dojo/Color)
|
|
this.fillStyle = null;
|
|
|
|
// strokeStyle: dojox/gfx.Stroke
|
|
// 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/shape.Surface,
|
|
// or dojox/gfx.Group)
|
|
this.parent = null;
|
|
|
|
// parentMatrix: dojox/gfx/matrix.Matrix2D
|
|
// a transformation matrix inherited from the parent
|
|
this.parentMatrix = null;
|
|
|
|
var uid = shape.register(this);
|
|
this.getUID = function(){
|
|
return uid;
|
|
}
|
|
},
|
|
|
|
destroy: function(){
|
|
// summary:
|
|
// Releases all internal resources owned by this shape. Once this method has been called,
|
|
// the instance is considered destroyed and should not be used anymore.
|
|
shape.dispose(this);
|
|
},
|
|
|
|
// trivial getters
|
|
|
|
getNode: function(){
|
|
// summary:
|
|
// Different graphics rendering subsystems implement shapes in different ways. This
|
|
// method provides access to the underlying graphics subsystem object. Clients calling this
|
|
// method and using the return value must be careful not to try sharing or using the underlying node
|
|
// in a general way across renderer implementation.
|
|
// Returns the underlying graphics Node, or null if no underlying graphics node is used by this shape.
|
|
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 applied to this Shape or null
|
|
return this.matrix; // dojox/gfx/matrix.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 Shape, Group or null if this Shape is unparented.
|
|
// (see dojox/gfx/shape.Surface,
|
|
// or dojox/gfx.Group)
|
|
return this.parent; // Object
|
|
},
|
|
getBoundingBox: function(){
|
|
// summary:
|
|
// Returns the bounding box Rectangle for this shape or null if a BoundingBox cannot be
|
|
// calculated for the shape on the current renderer or for shapes with no geometric area (points).
|
|
// A bounding box is a rectangular geometric region
|
|
// defining the X and Y extent of the shape.
|
|
// (see dojox/gfx.defaultRect)
|
|
// Note that this method returns a direct reference to the attribute of this instance. Therefore you should
|
|
// not modify its value directly but clone it instead.
|
|
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(),
|
|
gm = matrixLib;
|
|
return [ // Array
|
|
gm.multiplyPoint(m, b.x, b.y),
|
|
gm.multiplyPoint(m, b.x + b.width, b.y),
|
|
gm.multiplyPoint(m, b.x + b.width, b.y + b.height),
|
|
gm.multiplyPoint(m, b.x, b.y + b.height)
|
|
];
|
|
},
|
|
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
|
|
|
|
setClip: function(clip){
|
|
// summary:
|
|
// sets the clipping area of this shape.
|
|
// description:
|
|
// The clipping area defines the shape area that will be effectively visible. Everything that
|
|
// would be drawn outside of the clipping area will not be rendered.
|
|
// The possible clipping area types are rectangle, ellipse, polyline and path, but all are not
|
|
// supported by all the renderers. vml only supports rectangle clipping, while the gfx silverlight renderer does not
|
|
// support path clipping.
|
|
// The clip parameter defines the clipping area geometry, and should be an object with the following properties:
|
|
//
|
|
// - {x:Number, y:Number, width:Number, height:Number} for rectangular clip
|
|
// - {cx:Number, cy:Number, rx:Number, ry:Number} for ellipse clip
|
|
// - {points:Array} for polyline clip
|
|
// - {d:String} for a path clip.
|
|
//
|
|
// The clip geometry coordinates are expressed in the coordinate system used to draw the shape. In other
|
|
// words, the clipping area is defined in the shape parent coordinate system and the shape transform is automatically applied.
|
|
// example:
|
|
// The following example shows how to clip a gfx image with all the possible clip geometry: a rectangle,
|
|
// an ellipse, a circle (using the ellipse geometry), a polyline and a path:
|
|
//
|
|
// | surface.createImage({src:img, width:200,height:200}).setClip({x:10,y:10,width:50,height:50});
|
|
// | surface.createImage({src:img, x:100,y:50,width:200,height:200}).setClip({cx:200,cy:100,rx:20,ry:30});
|
|
// | surface.createImage({src:img, x:0,y:350,width:200,height:200}).setClip({cx:100,cy:425,rx:60,ry:60});
|
|
// | surface.createImage({src:img, x:300,y:0,width:200,height:200}).setClip({points:[350,0,450,50,380,130,300,110]});
|
|
// | surface.createImage({src:img, x:300,y:350,width:200,height:200}).setClip({d:"M 350,350 C314,414 317,557 373,450.0000 z"});
|
|
|
|
// clip: Object
|
|
// an object that defines the clipping geometry, or null to remove clip.
|
|
|
|
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
|
|
this.clip = clip;
|
|
},
|
|
|
|
getClip: function(){
|
|
return this.clip;
|
|
},
|
|
|
|
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 = g.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/_base/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 = g.makeParameters(g.defaultLinearGradient, fill);
|
|
break;
|
|
case "radial":
|
|
f = g.makeParameters(g.defaultRadialGradient, fill);
|
|
break;
|
|
case "pattern":
|
|
f = g.makeParameters(g.defaultPattern, fill);
|
|
break;
|
|
}
|
|
}else{
|
|
// color object
|
|
f = g.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" || lang.isArray(stroke) || stroke instanceof Color){
|
|
stroke = {color: stroke};
|
|
}
|
|
var s = this.strokeStyle = g.makeParameters(g.defaultStroke, stroke);
|
|
s.color = g.normalizeColor(s.color);
|
|
return this; // self
|
|
},
|
|
setTransform: function(matrix){
|
|
// summary:
|
|
// sets a transformation matrix
|
|
// matrix: dojox/gfx/matrix.Matrix2D
|
|
// a matrix or a matrix-like object
|
|
// (see an argument of dojox/gfx/matrix.Matrix2D
|
|
// constructor for a list of acceptable arguments)
|
|
|
|
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
|
|
this.matrix = matrixLib.clone(matrix ? matrixLib.normalize(matrix) : matrixLib.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/matrix.Matrix2D
|
|
// a matrix or a matrix-like object
|
|
// (see an argument of dojox/gfx/matrix.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/matrix.Matrix2D
|
|
// a matrix or a matrix-like object
|
|
// (see an argument of dojox/gfx/matrix.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.Shape.applyRightTransform
|
|
// matrix: dojox/gfx/matrix.Matrix2D
|
|
// a matrix or a matrix-like object
|
|
// (see an argument of dojox/gfx/matrix.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/shape.Surface,
|
|
// or dojox/gfx.Group)
|
|
// matrix: dojox/gfx/matrix.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 ? matrixLib.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 = matrixLib.multiply(p.matrix, m);
|
|
}
|
|
p = p.parent;
|
|
}
|
|
return m; // dojox/gfx/matrix.Matrix2D
|
|
}
|
|
});
|
|
|
|
shape._eventsProcessing = {
|
|
connect: function(name, object, method){
|
|
// summary:
|
|
// connects a handler to an event on this shape
|
|
|
|
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
|
|
// redirect to fixCallback to normalize events and add the gfxTarget to the event. The latter
|
|
// is done by dojox/gfx.fixTarget which is defined by each renderer
|
|
return events.connect(this.getEventSource(), name, shape.fixCallback(this, g.fixTarget, object, method));
|
|
|
|
},
|
|
disconnect: function(token){
|
|
// summary:
|
|
// connects a handler by token from an event on this shape
|
|
|
|
// COULD BE RE-IMPLEMENTED BY THE RENDERER!
|
|
|
|
events.disconnect(token);
|
|
}
|
|
};
|
|
|
|
shape.fixCallback = function(gfxElement, fixFunction, scope, method){
|
|
// summary:
|
|
// Wraps the callback to allow for tests and event normalization
|
|
// before it gets invoked. This is where 'fixTarget' is invoked.
|
|
// tags:
|
|
// private
|
|
// gfxElement: Object
|
|
// The GFX object that triggers the action (ex.:
|
|
// dojox/gfx.Surface and dojox/gfx/shape.Shape). A new event property
|
|
// 'gfxTarget' is added to the event to reference this object.
|
|
// for easy manipulation of GFX objects by the event handlers.
|
|
// fixFunction: Function
|
|
// The function that implements the logic to set the 'gfxTarget'
|
|
// property to the event. It should be 'dojox/gfx.fixTarget' for
|
|
// most of the cases
|
|
// scope: Object
|
|
// Optional. The scope to be used when invoking 'method'. If
|
|
// omitted, a global scope is used.
|
|
// method: Function|String
|
|
// The original callback to be invoked.
|
|
if(!method){
|
|
method = scope;
|
|
scope = null;
|
|
}
|
|
if(lang.isString(method)){
|
|
scope = scope || kernel.global;
|
|
if(!scope[method]){ throw(['dojox.gfx.shape.fixCallback: scope["', method, '"] is null (scope="', scope, '")'].join('')); }
|
|
return function(e){
|
|
return fixFunction(e,gfxElement) ? scope[method].apply(scope, arguments || []) : undefined; }; // Function
|
|
}
|
|
return !scope
|
|
? function(e){
|
|
return fixFunction(e,gfxElement) ? method.apply(scope, arguments) : undefined; }
|
|
: function(e){
|
|
return fixFunction(e,gfxElement) ? method.apply(scope, arguments || []) : undefined; }; // Function
|
|
};
|
|
lang.extend(shape.Shape, shape._eventsProcessing);
|
|
|
|
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
|
|
|
|
openBatch: function() {
|
|
// summary:
|
|
// starts a new batch, subsequent new child shapes will be held in
|
|
// the batch instead of appending to the container directly
|
|
},
|
|
closeBatch: function() {
|
|
// summary:
|
|
// submits the current batch, append all pending child shapes to DOM
|
|
},
|
|
add: function(shape){
|
|
// summary:
|
|
// adds a shape to the list
|
|
// shape: dojox/gfx/shape.Shape
|
|
// the shape to add to the list
|
|
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
|
|
// shape: dojox/gfx/shape.Shape
|
|
// the shape to remove
|
|
// 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.parent = null;
|
|
shape.parentMatrix = null;
|
|
}
|
|
this.children.splice(i, 1);
|
|
break;
|
|
}
|
|
}
|
|
return this; // self
|
|
},
|
|
clear: function(/*Boolean?*/ destroy){
|
|
// summary:
|
|
// removes all shapes from a group/surface.
|
|
// destroy: Boolean
|
|
// Indicates whether the children should be destroyed. Optional.
|
|
var shape;
|
|
for(var i = 0; i < this.children.length;++i){
|
|
shape = this.children[i];
|
|
shape.parent = null;
|
|
shape.parentMatrix = null;
|
|
if(destroy){
|
|
shape.destroy();
|
|
}
|
|
}
|
|
this.children = [];
|
|
return this; // self
|
|
},
|
|
getBoundingBox: function(){
|
|
// summary:
|
|
// Returns the bounding box Rectangle for this shape.
|
|
if(this.children){
|
|
// if this is a composite shape, then sum up all the children
|
|
var result = null;
|
|
arr.forEach(this.children, function(shape){
|
|
var bb = shape.getBoundingBox();
|
|
if(bb){
|
|
var ct = shape.getTransform();
|
|
if(ct){
|
|
bb = matrixLib.multiplyRectangle(ct, bb);
|
|
}
|
|
if(result){
|
|
// merge two bbox
|
|
result.x = Math.min(result.x, bb.x);
|
|
result.y = Math.min(result.y, bb.y);
|
|
result.endX = Math.max(result.endX, bb.x + bb.width);
|
|
result.endY = Math.max(result.endY, bb.y + bb.height);
|
|
}else{
|
|
// first bbox
|
|
result = {
|
|
x: bb.x,
|
|
y: bb.y,
|
|
endX: bb.x + bb.width,
|
|
endY: bb.y + bb.height
|
|
};
|
|
}
|
|
}
|
|
});
|
|
if(result){
|
|
result.width = result.endX - result.x;
|
|
result.height = result.endY - result.y;
|
|
}
|
|
return result; // dojox/gfx.Rectangle
|
|
}
|
|
// unknown/empty bounding box, subclass shall override this impl
|
|
return null;
|
|
},
|
|
// moving child nodes
|
|
_moveChildToFront: function(shape){
|
|
// summary:
|
|
// moves a shape to front of the list of shapes
|
|
// shape: dojox/gfx/shape.Shape
|
|
// one of the child shapes to move to the front
|
|
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
|
|
// shape: dojox/gfx/shape.Shape
|
|
// one of the child shapes to move to the front
|
|
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
|
|
}
|
|
};
|
|
|
|
shape.Surface = declare("dojox.gfx.shape.Surface", null, {
|
|
// summary:
|
|
// a surface object to be used for drawings
|
|
constructor: function(){
|
|
// underlying node
|
|
this.rawNode = null;
|
|
// the parent node
|
|
this._parent = null;
|
|
// the list of DOM nodes to be deleted in the case of destruction
|
|
this._nodes = [];
|
|
// the list of events to be detached in the case of destruction
|
|
this._events = [];
|
|
},
|
|
destroy: function(){
|
|
// summary:
|
|
// destroy all relevant external resources and release all
|
|
// external references to make this object garbage-collectible
|
|
arr.forEach(this._nodes, domConstruct.destroy);
|
|
this._nodes = [];
|
|
arr.forEach(this._events, events.disconnect);
|
|
this._events = [];
|
|
this.rawNode = null; // recycle it in _nodes, if it needs to be recycled
|
|
if(has("ie")){
|
|
while(this._parent.lastChild){
|
|
domConstruct.destroy(this._parent.lastChild);
|
|
}
|
|
}else{
|
|
this._parent.innerHTML = "";
|
|
}
|
|
this._parent = 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
|
|
},
|
|
/*=====
|
|
setDimensions: function(width, height){
|
|
// summary:
|
|
// sets the width and height of the rawNode
|
|
// width: String
|
|
// width of surface, e.g., "100px"
|
|
// height: String
|
|
// height of surface, e.g., "100px"
|
|
return this; // self
|
|
},
|
|
getDimensions: function(){
|
|
// summary:
|
|
// gets current width and height in pixels
|
|
// returns: Object
|
|
// object with properties "width" and "height"
|
|
},
|
|
=====*/
|
|
isLoaded: true,
|
|
onLoad: function(/*dojox/gfx/shape.Surface*/ surface){
|
|
// summary:
|
|
// local event, fired once when the surface is created
|
|
// asynchronously, used only when isLoaded is false, required
|
|
// only for Silverlight.
|
|
},
|
|
whenLoaded: function(/*Object|Null*/ context, /*Function|String*/ method){
|
|
var f = lang.hitch(context, method);
|
|
if(this.isLoaded){
|
|
f(this);
|
|
}else{
|
|
var h = events.connect(this, "onLoad", function(surface){
|
|
events.disconnect(h);
|
|
f(surface);
|
|
});
|
|
}
|
|
}
|
|
});
|
|
lang.extend(shape.Surface, shape._eventsProcessing);
|
|
|
|
/*=====
|
|
g.Point = declare("dojox/gfx.Point", null, {
|
|
// summary:
|
|
// 2D point for drawings - {x, y}
|
|
// description:
|
|
// Do not use this object directly!
|
|
// Use the naked object instead: {x: 1, y: 2}.
|
|
});
|
|
|
|
g.Rectangle = declare("dojox.gfx.Rectangle", null, {
|
|
// summary:
|
|
// rectangle - {x, y, width, height}
|
|
// description:
|
|
// Do not use this object directly!
|
|
// Use the naked object instead: {x: 1, y: 2, width: 100, height: 200}.
|
|
});
|
|
=====*/
|
|
|
|
|
|
shape.Rect = declare("dojox.gfx.shape.Rect", shape.Shape, {
|
|
// summary:
|
|
// a generic rectangle
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// The underlying graphics system object (typically a DOM Node)
|
|
this.shape = g.getDefault("Rect");
|
|
this.rawNode = rawNode;
|
|
},
|
|
getBoundingBox: function(){
|
|
// summary:
|
|
// returns the bounding box (its shape in this case)
|
|
return this.shape; // dojox/gfx.Rectangle
|
|
}
|
|
});
|
|
|
|
shape.Ellipse = declare("dojox.gfx.shape.Ellipse", shape.Shape, {
|
|
// summary:
|
|
// a generic ellipse
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// a DOM Node
|
|
this.shape = g.getDefault("Ellipse");
|
|
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
|
|
}
|
|
});
|
|
|
|
shape.Circle = declare("dojox.gfx.shape.Circle", shape.Shape, {
|
|
// summary:
|
|
// a generic circle
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// a DOM Node
|
|
this.shape = g.getDefault("Circle");
|
|
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
|
|
}
|
|
});
|
|
|
|
shape.Line = declare("dojox.gfx.shape.Line", shape.Shape, {
|
|
// summary:
|
|
// a generic line (do not instantiate it directly)
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// a DOM Node
|
|
this.shape = g.getDefault("Line");
|
|
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
|
|
}
|
|
});
|
|
|
|
shape.Polyline = declare("dojox.gfx.shape.Polyline", shape.Shape, {
|
|
// summary:
|
|
// a generic polyline/polygon (do not instantiate it directly)
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// a DOM Node
|
|
this.shape = g.getDefault("Polyline");
|
|
this.rawNode = rawNode;
|
|
},
|
|
setShape: function(points, closed){
|
|
// summary:
|
|
// sets a polyline/polygon shape object
|
|
// points: Object|Array
|
|
// a polyline/polygon shape object, or an array of points
|
|
// closed: Boolean
|
|
// close the polyline to make a polygon
|
|
if(points && points instanceof Array){
|
|
this.inherited(arguments, [{points: points}]);
|
|
if(closed && this.shape.points.length){
|
|
this.shape.points.push(this.shape.points[0]);
|
|
}
|
|
}else{
|
|
this.inherited(arguments, [points]);
|
|
}
|
|
return this; // self
|
|
},
|
|
_normalizePoints: function(){
|
|
// summary:
|
|
// normalize points to array of {x:number, y:number}
|
|
var p = this.shape.points, l = p && p.length;
|
|
if(l && typeof p[0] == "number"){
|
|
var points = [];
|
|
for(var i = 0; i < l; i += 2){
|
|
points.push({x: p[i], y: p[i + 1]});
|
|
}
|
|
this.shape.points = points;
|
|
}
|
|
},
|
|
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
|
|
}
|
|
});
|
|
|
|
shape.Image = declare("dojox.gfx.shape.Image", shape.Shape, {
|
|
// summary:
|
|
// a generic image (do not instantiate it directly)
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// a DOM Node
|
|
this.shape = g.getDefault("Image");
|
|
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
|
|
}
|
|
});
|
|
|
|
shape.Text = declare(shape.Shape, {
|
|
// summary:
|
|
// a generic text (do not instantiate it directly)
|
|
constructor: function(rawNode){
|
|
// rawNode: Node
|
|
// a DOM Node
|
|
this.fontStyle = null;
|
|
this.shape = g.getDefault("Text");
|
|
this.rawNode = rawNode;
|
|
},
|
|
getFont: function(){
|
|
// summary:
|
|
// returns the current font object or null
|
|
return this.fontStyle; // Object
|
|
},
|
|
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" ? g.splitFontString(newFont) :
|
|
g.makeParameters(g.defaultFont, newFont);
|
|
this._setFont();
|
|
return this; // self
|
|
}
|
|
});
|
|
|
|
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
|
|
// returns: dojox/gfx/shape.Shape | Null
|
|
// a fully instantiated surface-specific Shape object
|
|
switch(shape.type){
|
|
case g.defaultPath.type: return this.createPath(shape);
|
|
case g.defaultRect.type: return this.createRect(shape);
|
|
case g.defaultCircle.type: return this.createCircle(shape);
|
|
case g.defaultEllipse.type: return this.createEllipse(shape);
|
|
case g.defaultLine.type: return this.createLine(shape);
|
|
case g.defaultPolyline.type: return this.createPolyline(shape);
|
|
case g.defaultImage.type: return this.createImage(shape);
|
|
case g.defaultText.type: return this.createText(shape);
|
|
case g.defaultTextPath.type: return this.createTextPath(shape);
|
|
}
|
|
return null;
|
|
},
|
|
createGroup: function(){
|
|
// summary:
|
|
// creates a group shape
|
|
return this.createObject(g.Group); // dojox/gfx/Group
|
|
},
|
|
createRect: function(rect){
|
|
// summary:
|
|
// creates a rectangle shape
|
|
// rect: Object
|
|
// a path object (see dojox/gfx.defaultRect)
|
|
return this.createObject(g.Rect, rect); // dojox/gfx/shape.Rect
|
|
},
|
|
createEllipse: function(ellipse){
|
|
// summary:
|
|
// creates an ellipse shape
|
|
// ellipse: Object
|
|
// an ellipse object (see dojox/gfx.defaultEllipse)
|
|
return this.createObject(g.Ellipse, ellipse); // dojox/gfx/shape.Ellipse
|
|
},
|
|
createCircle: function(circle){
|
|
// summary:
|
|
// creates a circle shape
|
|
// circle: Object
|
|
// a circle object (see dojox/gfx.defaultCircle)
|
|
return this.createObject(g.Circle, circle); // dojox/gfx/shape.Circle
|
|
},
|
|
createLine: function(line){
|
|
// summary:
|
|
// creates a line shape
|
|
// line: Object
|
|
// a line object (see dojox/gfx.defaultLine)
|
|
return this.createObject(g.Line, line); // dojox/gfx/shape.Line
|
|
},
|
|
createPolyline: function(points){
|
|
// summary:
|
|
// creates a polyline/polygon shape
|
|
// points: Object
|
|
// a points object (see dojox/gfx.defaultPolyline)
|
|
// or an Array of points
|
|
return this.createObject(g.Polyline, points); // dojox/gfx/shape.Polyline
|
|
},
|
|
createImage: function(image){
|
|
// summary:
|
|
// creates a image shape
|
|
// image: Object
|
|
// an image object (see dojox/gfx.defaultImage)
|
|
return this.createObject(g.Image, image); // dojox/gfx/shape.Image
|
|
},
|
|
createText: function(text){
|
|
// summary:
|
|
// creates a text shape
|
|
// text: Object
|
|
// a text object (see dojox/gfx.defaultText)
|
|
return this.createObject(g.Text, text); // dojox/gfx/shape.Text
|
|
},
|
|
createPath: function(path){
|
|
// summary:
|
|
// creates a path shape
|
|
// path: Object
|
|
// a path object (see dojox/gfx.defaultPath)
|
|
return this.createObject(g.Path, path); // dojox/gfx/shape.Path
|
|
},
|
|
createTextPath: function(text){
|
|
// summary:
|
|
// creates a text shape
|
|
// text: Object
|
|
// a textpath object (see dojox/gfx.defaultTextPath)
|
|
return this.createObject(g.TextPath, {}).setText(text); // dojox/gfx/shape.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.Shape
|
|
}
|
|
};
|
|
|
|
/*=====
|
|
lang.extend(shape.Surface, shape.Container);
|
|
lang.extend(shape.Surface, shape.Creator);
|
|
|
|
g.Group = declare(shape.Shape, {
|
|
// summary:
|
|
// a group shape, which can be used
|
|
// to logically group shapes (e.g, to propagate matricies)
|
|
});
|
|
lang.extend(g.Group, shape.Container);
|
|
lang.extend(g.Group, shape.Creator);
|
|
|
|
g.Rect = shape.Rect;
|
|
g.Circle = shape.Circle;
|
|
g.Ellipse = shape.Ellipse;
|
|
g.Line = shape.Line;
|
|
g.Polyline = shape.Polyline;
|
|
g.Path = shape.Path;
|
|
g.Text = shape.Text;
|
|
g.Surface = shape.Surface;
|
|
|
|
g.Path = g.path.Path;
|
|
g.TextPath = g.path.TextPath;
|
|
=====*/
|
|
|
|
return shape;
|
|
});
|