graphics-svg-debug.js revision 45be085c4155ae7ef409ffa4d79457928742f18f
var SHAPE = "svgShape",
function SVGDrawing(){}
/**
* Set of drawing methods for SVG based classes.
*
* @module graphics
* @class SVGDrawing
* @constructor
*/
SVGDrawing.prototype = {
/**
* Indicates the type of shape
*
* @private
* @property _type
* @readOnly
* @type String
*/
_type: "path",
/**
* Draws a bezier curve.
*
* @method curveTo
* @param {Number} cp1x x-coordinate for the first control point.
* @param {Number} cp1y y-coordinate for the first control point.
* @param {Number} cp2x x-coordinate for the second control point.
* @param {Number} cp2y y-coordinate for the second control point.
* @param {Number} x x-coordinate for the end point.
* @param {Number} y y-coordinate for the end point.
*/
var pathArrayLen,
hiX,
loX,
hiY,
loY;
if(this._pathType !== "C")
{
this._pathType = "C";
currentArray = ["C"];
}
else
{
if(!currentArray)
{
currentArray = [];
}
}
this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat([Math.round(cp1x), Math.round(cp1y), Math.round(cp2x) , Math.round(cp2y), x, y]);
},
/**
* Draws a quadratic bezier curve.
*
* @method quadraticCurveTo
* @param {Number} cpx x-coordinate for the control point.
* @param {Number} cpy y-coordinate for the control point.
* @param {Number} x x-coordinate for the end point.
* @param {Number} y y-coordinate for the end point.
*/
var pathArrayLen,
hiX,
loX,
hiY,
loY;
if(this._pathType !== "Q")
{
this._pathType = "Q";
currentArray = ["Q"];
}
else
{
if(!currentArray)
{
currentArray = [];
}
}
this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat([Math.round(cpx), Math.round(cpy), Math.round(x), Math.round(y)]);
},
/**
* Draws a rectangle.
*
* @method drawRect
* @param {Number} x x-coordinate
* @param {Number} y y-coordinate
* @param {Number} w width
* @param {Number} h height
*/
drawRect: function(x, y, w, h) {
this.moveTo(x, y);
this.lineTo(x + w, y);
this.lineTo(x + w, y + h);
this.lineTo(x, y + h);
this.lineTo(x, y);
},
/**
* Draws a rectangle with rounded corners.
*
* @method drawRect
* @param {Number} x x-coordinate
* @param {Number} y y-coordinate
* @param {Number} w width
* @param {Number} h height
* @param {Number} ew width of the ellipse used to draw the rounded corners
* @param {Number} eh height of the ellipse used to draw the rounded corners
*/
this.quadraticCurveTo(x, y + h, x + ew, y + h);
this.quadraticCurveTo(x + w, y + h, x + w, y + h - eh);
this.quadraticCurveTo(x + w, y, x + w - ew, y);
this.quadraticCurveTo(x, y, x, y + eh);
},
/**
* Draws a wedge.
*
* @param {Number} x x-coordinate of the wedge's center point
* @param {Number} y y-coordinate of the wedge's center point
* @param {Number} startAngle starting angle in degrees
* @param {Number} arc sweep of the wedge. Negative values draw clockwise.
* @param {Number} radius radius of wedge. If [optional] yRadius is defined, then radius is the x radius.
* @param {Number} yRadius [optional] y radius for wedge.
*/
{
var segs,
ax,
ay,
bx,
by,
cx,
cy,
i = 0,
if(this._pathType != "M")
{
this._pathType = "M";
currentArray = ["M"];
}
else
{
currentArray = this._getCurrentArray();
}
// limit sweep to reasonable numbers
{
arc = 360;
}
// First we calculate how many segments are needed
// for a smooth arc.
// Now calculate the sweep of each segment.
// The math requires radians rather than degrees. To convert from degrees
// use the formula (degrees/180)*Math.PI to get radians.
// convert angle startAngle to radians
if(segs > 0)
{
// draw a line from the center to the start of the curve
this._pathType = "L";
pathArrayLen++;
pathArrayLen++;
this._pathType = "Q";
for(; i < segs; ++i)
{
}
}
return this;
},
/**
* Draws a line segment using the current line style from the current drawing position to the specified x and y coordinates.
*
* @method lineTo
* @param {Number} point1 x-coordinate for the end point.
* @param {Number} point2 y-coordinate for the end point.
*/
i,
len,
this._pathArray = this._pathArray || [];
}
this._shapeType = "path";
if(this._pathType !== "L")
{
this._pathType = "L";
currentArray = ['L'];
}
else
{
currentArray = this._getCurrentArray();
}
for (i = 0; i < len; ++i) {
}
},
_getCurrentArray: function()
{
if(!currentArray)
{
currentArray = [];
}
return currentArray;
},
/**
* Moves the current drawing position to specified x and y coordinates.
*
* @method moveTo
* @param {Number} x x-coordinate for the end point.
* @param {Number} y y-coordinate for the end point.
*/
moveTo: function(x, y) {
var pathArrayLen,
this._pathArray = this._pathArray || [];
if(this._pathType != "M")
{
this._pathType = "M";
currentArray = ["M"];
}
else
{
currentArray = this._getCurrentArray();
}
this._trackSize(x, y);
},
/**
* Completes a drawing operation.
*
* @method end
*/
end: function()
{
this._closePath();
this._graphic.addToRedrawQueue(this);
},
/**
* Clears the path.
*
* @method clear
*/
clear: function()
{
this._left = 0;
this._right = 0;
this._top = 0;
this._bottom = 0;
this._pathArray = [];
this._path = "";
},
/**
* Draws the path.
*
* @method _closePath
* @private
*/
_closePath: function()
{
var pathArray,
len,
val,
val2,
i,
path = "",
if(this._pathArray)
{
{
switch(pathType)
{
case "L" :
case "M" :
case "Q" :
for(i = 2; i < len; ++i)
{
}
break;
case "C" :
for(i = 2; i < len; ++i)
{
val2 = segmentArray[i];
}
break;
}
}
{
path += 'z';
}
if(path)
{
}
//Use transform to handle positioning.
this._transformArgs = this._transformArgs || {};
this._fillChangeHandler();
this._strokeChangeHandler();
this._updateTransform();
}
},
/**
* Updates the size of the graphics object
*
* @method _trackSize
* @param {Number} w width
* @param {Number} h height
* @private
*/
_trackSize: function(w, h) {
if (w > this._right) {
this._right = w;
}
if(w < this._left)
{
this._left = w;
}
if (h < this._top)
{
this._top = h;
}
if (h > this._bottom)
{
this._bottom = h;
}
}
};
Y.SVGDrawing = SVGDrawing;
/**
* Base class for creating shapes.
*
* @module graphics
* @class SVGShape
* @constructor
* @param {Object} cfg (optional) Attribute configs
*/
{
};
/**
* Init method, invoked during construction.
* Calls `initializer` method.
*
* @method init
* @protected
*/
init: function()
{
},
/**
* Initializes the shape
*
* @private
* @method _initialize
*/
initializer: function(cfg)
{
var host = this;
host.createNode();
},
/**
* Add a class name to each node.
*
* @method addClass
* @param {String} className the class name to add to the node's class attribute
*/
{
},
/**
* Removes a class name from each node.
*
* @method removeClass
* @param {String} className the class name to remove from the node's class attribute
*/
removeClass: function(className)
{
classString = classString.replace(new RegExp(className + ' '), className).replace(new RegExp(className), '');
},
/**
* Gets the current position of the node in page coordinates.
*
* @method getXY
* @return Array The XY position of the shape.
*/
getXY: function()
{
x = this.get("x"),
y = this.get("y");
},
/**
* Set the position of the shape in page coordinates, regardless of how the node is positioned.
*
* @method setXY
* @param {Array} Contains x & y values for new position (coordinates are page-based)
*/
{
},
/**
* Determines whether the node is an ancestor of another HTML element in the DOM hierarchy.
*
* @method contains
* @param {SVGShape | HTMLElement} needle The possible node or descendent
* @return Boolean Whether or not this shape is the needle or its ancestor.
*/
{
},
/**
* Compares nodes to determine if they match.
* @method compareTo
* @param {HTMLElement | Node} refNode The reference node to compare to the node.
* @return {Boolean} True if the nodes match, false if they do not.
*/
},
/**
* Test if the supplied node matches the supplied selector.
*
* @method test
* @param {String} selector The CSS selector to test against.
* @return Boolean Wheter or not the shape matches the selector.
*/
{
},
/**
* Value function for fill attribute
*
* @private
* @method _getDefaultFill
* @return Object
*/
_getDefaultFill: function() {
return {
type: "solid",
opacity: 1,
cx: 0.5,
cy: 0.5,
fx: 0.5,
fy: 0.5,
r: 0.5
};
},
/**
* Value function for stroke attribute
*
* @private
* @method _getDefaultStroke
* @return Object
*/
_getDefaultStroke: function()
{
return {
weight: 1,
dashstyle: "none",
color: "#000",
opacity: 1.0
};
},
/**
* Creates the dom node for the shape.
*
* @method createNode
* @return HTMLElement
* @private
*/
createNode: function()
{
if(id)
{
}
if(pointerEvents)
{
}
},
/**
* Parses event to determine if it is a dom interaction event.
*
* @method isMouseEvent
* @param {String} type Type of event
* @return Boolean
* @private
*/
isMouseEvent: function(type)
{
{
return true;
}
return false;
},
/**
* Overrides default `before` method. Checks to see if its a dom interaction event. If so,
* return an event attached to the `node` element. If not, return the normal functionality.
*
* @method before
* @param {String} type event type
* @param {Object} callback function
* @private
*/
{
if(this.isMouseEvent(type))
{
}
},
/**
* Overrides default `on` method. Checks to see if its a dom interaction event. If so,
* return an event attached to the `node` element. If not, return the normal functionality.
*
* @method on
* @param {String} type event type
* @param {Object} callback function
* @private
*/
{
if(this.isMouseEvent(type))
{
}
},
/**
* Overrides default `after` method. Checks to see if its a dom interaction event. If so,
* return an event attached to the `node` element. If not, return the normal functionality.
*
* @method after
* @param {String} type event type
* @param {Object} callback function
* @private
*/
{
if(this.isMouseEvent(type))
{
}
},
/**
* Adds a stroke to the shape node.
*
* @method _strokeChangeHandler
* @private
*/
_strokeChangeHandler: function(e)
{
dash,
{
{
}
else
{
{
}
}
}
else
{
}
},
/**
* Adds a fill to the shape node.
*
* @method _fillChangeHandler
* @private
*/
_fillChangeHandler: function(e)
{
type;
if(fill)
{
{
this._setGradientFill(fill);
}
{
}
else
{
}
}
else
{
}
},
/**
* Creates a gradient fill
*
* @method _setGradientFill
* @param {String} type gradient type
* @private
*/
_setGradientFill: function(fill) {
var offset,
w = this.get("width"),
h = this.get("height"),
i,
len,
def,
stop,
x = this.get("x"),
y = this.get("y"),
x1 = "0%",
x2 = "100%",
y1 = "0%",
y2 = "0%",
r = fill.r;
if(type == "linear")
{
cx = w/2;
cy = h/2;
{
if(rotation < 180)
{
y1 = 0;
y2 = h;
}
else
{
y1 = h;
y2 = 0;
}
}
else
{
{
x1 = w;
x2 = 0;
}
else
{
x1 = 0;
x2 = w;
}
}
}
else
{
}
def = 0;
for(i = 0; i < len; ++i)
{
}
},
/**
* Sets the value of an attribute.
*
* @method set
* @param {String|Object} name The name of the attribute. Alternatively, an object of key value pairs can
* be passed in to set multiple attributes at once.
* @param {Any} value The value to set the attribute to. This value is ignored if an object is received as
* the name param.
*/
set: function()
{
var host = this;
if(host.initialized)
{
}
},
/**
* Applies translate transformation.
*
* @method translate
* @param {Number} x The x-coordinate
* @param {Number} y The y-coordinate
*/
translate: function(x, y)
{
this._translateX = x;
this._translateY = y;
},
/**
* Applies translate transformation.
*
* @method translate
* @param {Number} x The x-coordinate
* @param {Number} y The y-coordinate
* @protected
*/
_translate: function(x, y)
{
},
/**
* Applies a skew to the x-coordinate
*
* @method skewX
* @param {Number} x x-coordinate
*/
skewX: function(x)
{
},
/**
* Applies a skew to the y-coordinate
*
* @method skewY
* @param {Number} y y-coordinate
*/
skewY: function(y)
{
},
/**
* Storage for `rotation` atribute.
*
* @property _rotation
* @type Number
* @private
*/
_rotation: 0,
/**
* Applies a rotation.
*
* @method rotate
* @param {Number} deg The degree of the rotation.
*/
{
},
/**
* Applies a scale transform
*
* @method scale
* @param {Number} val
*/
{
},
/**
* Applies a matrix transformation
*
* @method matrix
* @param {Number} a
* @param {Number} b
* @param {Number} c
* @param {Number} d
* @param {Number} e
* @param {Number} f
*/
matrix: function(a, b, c, d, e, f)
{
},
/**
* Adds a transform to the shape.
*
* @method _addTransform
* @param {String} type The transform being applied.
* @param {Array} args The arguments for the transform.
* @private
*/
{
if(!this._transformArgs)
{
this._transformArgs = {};
}
if(this.initialized)
{
this._updateTransform();
}
},
/**
* Applies all transforms.
*
* @method _updateTransform
* @private
*/
_updateTransform: function()
{
key,
args,
val,
test,
if(this._transformArgs)
{
{
}
}
for(key in this._transformArgs)
{
{
{
{
}
else
{
}
}
else
{
}
}
}
this._graphic.addToRedrawQueue(this);
if(transform)
{
}
},
/**
* Draws the shape.
*
* @method _draw
* @private
*/
_draw: function()
{
this._fillChangeHandler();
this._strokeChangeHandler();
this._updateTransform();
},
/**
* Updates `Shape` based on attribute changes.
*
* @method _updateHandler
* @private
*/
_updateHandler: function(e)
{
this._draw();
},
/**
* Storage for translateX
*
* @property _translateX
* @type Number
* @private
*/
_translateX: 0,
/**
* Storage for translateY
*
* @property _translateY
* @type Number
* @private
*/
_translateY: 0,
/**
* Returns the bounds for a shape.
*
* @method getBounds
* @return Object
*/
getBounds: function()
{
w = this.get("width"),
h = this.get("height"),
x = this.get("x"),
y = this.get("y"),
right = x + w,
bottom = y + h,
tlx,
tly,
blx,
bly,
brx,
bry,
trx,
trY,
wt = 0,
bounds = {},
{
}
if(rotation !== 0)
{
}
else
{
}
return bounds;
},
/**
* Returns the x coordinate for a bounding box's corner based on the corner's original x/y coordinates, rotation and transform origin of the rotation.
*
* @method _getRotatedCornerX
* @param {Number} x original x-coordinate of corner
* @param {Number} y original y-coordinate of corner
* @param {Number} tox transform origin x-coordinate of rotation
* @param {Number} toy transform origin y-coordinate of rotation
* @param {Number} cosRadians cosine (in radians) of rotation
* @param {Number} sinRadians sin (in radians) or rotation
* @return Number
* @private
*/
{
},
/**
* Returns the y coordinate for a bounding box's corner based on the corner's original x/y coordinates, rotation and transform origin of the rotation.
*
* @method _getRotatedCornerY
* @param {Number} x original x-coordinate of corner
* @param {Number} y original y-coordinate of corner
* @param {Number} tox transform origin x-coordinate of rotation
* @param {Number} toy transform origin y-coordinate of rotation
* @param {Number} cosRadians cosine (in radians) of rotation
* @param {Number} sinRadians sin (in radians) or rotation
* @return Number
* @private
*/
{
},
/**
* Destroys the instance.
*
* @method destroy
*/
destroy: function()
{
{
}
}
}, Y.SVGDrawing.prototype));
/**
* An array of x, y values which indicates the transformOrigin in which to rotate the shape. Valid values range between 0 and 1 representing a
* fraction of the shape's corresponding bounding box dimension. The default value is [0.5, 0.5].
*
* @attribute transformOrigin
* @type Array
*/
valueFn: function()
{
return [0.5, 0.5];
}
},
/**
* The rotation (in degrees) of the shape.
*
* @attribute rotation
* @type Number
*/
rotation: {
{
},
getter: function()
{
return this._rotation;
}
},
/**
* Unique id for class instance.
*
* @attribute id
* @type String
*/
id: {
valueFn: function()
{
return Y.guid();
},
{
if(node)
{
}
return val;
}
},
/**
* Indicates the x position of shape.
*
* @attribute x
* @type Number
*/
x: {
value: 0
},
/**
* Indicates the y position of shape.
*
* @attribute y
* @type Number
*/
y: {
value: 0
},
/**
* Indicates the width of the shape
*
* @attribute width
* @type Number
*/
width: {
value: 0
},
/**
* Indicates the height of the shape
*
* @attribute height
* @type Number
*/
height: {
value: 0
},
/**
* Indicates whether the shape is visible.
*
* @attribute visible
* @type Boolean
*/
visible: {
value: true,
return val;
}
},
/**
* Contains information about the fill of the shape.
* <dl>
* <dt>color</dt><dd>The color of the fill.</dd>
* <dt>opacity</dt><dd>Number between 0 and 1 that indicates the opacity of the fill. The default value is 1.</dd>
* <dt>type</dt><dd>Type of fill.
* <dl>
* <dt>solid</dt><dd>Solid single color fill. (default)</dd>
* <dt>linear</dt><dd>Linear gradient fill.</dd>
* <dt>radial</dt><dd>Radial gradient fill.</dd>
* </dl>
* </dd>
* </dl>
*
* <p>If a gradient (linear or radial) is specified as the fill type. The following properties are used:
* <dl>
* <dt>stops</dt><dd>An array of objects containing the following properties:
* <dl>
* <dt>color</dt><dd>The color of the stop.</dd>
* <dt>opacity</dt><dd>Number between 0 and 1 that indicates the opacity of the stop. The default value is 1. Note: No effect for IE <= 8</dd>
* <dt>offset</dt><dd>Number between 0 and 1 indicating where the color stop is positioned.</dd>
* </dl>
* </dd>
* <dt></dt><dd></dd>
* <dt></dt><dd></dd>
* <dt></dt><dd></dd>
* </dl>
* </p>
*
* @attribute fill
* @type Object
*/
fill: {
valueFn: "_getDefaultFill",
{
var fill,
{
{
}
}
return fill;
}
},
/**
* Contains information about the stroke of the shape.
* <dl>
* <dt>color</dt><dd>The color of the stroke.</dd>
* <dt>weight</dt><dd>Number that indicates the width of the stroke.</dd>
* <dt>opacity</dt><dd>Number between 0 and 1 that indicates the opacity of the stroke. The default value is 1.</dd>
* <dt>dashstyle</dt>Indicates whether to draw a dashed stroke. When set to "none", a solid stroke is drawn. When set to an array, the first index indicates the
* length of the dash. The second index indicates the length of gap.
* </dl>
*
* @attribute stroke
* @type Object
*/
stroke: {
valueFn: "_getDefaultStroke",
{
}
},
/**
* Indicates whether or not the instance will size itself based on its contents.
*
* @attribute autoSize
* @type Boolean
*/
autoSize: {
value: false
},
/**
* Determines whether the instance will receive mouse events.
*
* @attribute pointerEvents
* @type string
*/
valueFn: function()
{
var val = "visiblePainted",
if(node)
{
}
return val;
},
{
if(node)
{
}
return val;
}
},
/**
* Performs a translate on the x-coordinate. When translating x and y coordinates,
* use the <code>translate</code> method.
*
* @attribute translateX
* @type Number
*/
translateX: {
getter: function()
{
return this._translateX;
},
{
this._translateX = val;
return val;
}
},
/**
* Performs a translate on the y-coordinate. When translating x and y coordinates,
* use the <code>translate</code> method.
*
* @attribute translateX
* @type Number
*/
translateY: {
getter: function()
{
return this._translateY;
},
{
this._translateY = val;
return val;
}
},
/**
* The node used for gradient fills.
*
* @attribute gradientNode
* @type HTMLElement
*/
gradientNode: {
{
{
}
return val;
}
},
/**
* Indicates whether to automatically refresh.
*
* @attribute autoDraw
* @type Boolean
* @readOnly
*/
autoDraw: {
getter: function()
{
}
},
/**
* Dom node for the shape.
*
* @attribute node
* @type HTMLElement
* @readOnly
*/
node: {
readOnly: true,
getter: function()
{
return this.node;
}
},
/**
* Reference to the parent graphic instance
*
* @attribute graphic
* @type SVGGraphic
* @readOnly
*/
graphic: {
readOnly: true,
getter: function()
{
return this._graphic;
}
}
};
/**
* The SVGPath class creates a shape through the use of drawing methods.
*
* @module graphics
* @class SVGPath
* @extends SVGShape
* @constructor
*/
{
};
/**
* Left edge of the path
*
* @property _left
* @type Number
* @private
*/
_left: 0,
/**
* Right edge of the path
*
* @property _right
* @type Number
* @private
*/
_right: 0,
/**
* Top edge of the path
*
* @property _top
* @type Number
* @private
*/
_top: 0,
/**
* Bottom edge of the path
*
* @property _bottom
* @type Number
* @private
*/
_bottom: 0,
/**
* Indicates the type of shape
*
* @property _type
* @readOnly
* @type String
* @private
*/
_type: "path",
/**
* Applies translate transformation.
*
* @method translate
* @param {Number} x The x-coordinate
* @param {Number} y The y-coordinate
*/
translate: function(x, y)
{
x = parseInt(x, 10);
y = parseInt(y, 10);
this._translateX = x;
this._translateY = y;
},
/**
* Draws the shape.
*
* @method _draw
* @private
*/
_draw: function()
{
this._fillChangeHandler();
this._strokeChangeHandler();
},
/**
* Returns the bounds for a shape.
*
* @method getBounds
* @return Object
*/
getBounds: function()
{
var wt = 0,
bounds = {},
{
}
return bounds;
},
/**
* @private
*/
_path: ""
});
/**
* Path string of the shape
*
* @attribute path
* @type String
*/
path: {
readOnly: true,
getter: function()
{
return this._path;
}
},
/**
* Indicates the height of the shape
*
* @attribute height
* @type Number
*/
width: {
getter: function()
{
return val;
}
},
/**
* Indicates the height of the shape
*
* @attribute height
* @type Number
*/
height: {
getter: function()
{
}
}
});
/**
* Draws rectangles
*
* @module graphics
* @class SVGRect
* @constructor
*/
SVGRect = function()
{
};
/**
* Indicates the type of shape
*
* @property _type
* @readOnly
* @type String
*/
_type: "rect"
});
/**
* Draws an ellipse
*
* @module graphics
* @class SVGEllipse
* @constructor
*/
SVGEllipse = function(cfg)
{
};
/**
* Indicates the type of shape
*
* @property _type
* @readOnly
* @type String
*/
_type: "ellipse",
/**
* Updates the shape.
*
* @method _draw
* @private
*/
_draw: function()
{
w = this.get("width"),
h = this.get("height"),
x = this.get("x"),
y = this.get("y"),
xRadius = w * 0.5,
yRadius = h * 0.5,
this._fillChangeHandler();
this._strokeChangeHandler();
this._updateTransform();
}
});
/**
* Horizontal radius for the ellipse.
*
* @attribute xRadius
* @type Number
* @readOnly
*/
xRadius: {
{
},
getter: function()
{
if(val)
{
val *= 0.5;
}
return val;
}
},
/**
* Vertical radius for the ellipse.
*
* @attribute yRadius
* @type Number
* @readOnly
*/
yRadius: {
{
},
getter: function()
{
if(val)
{
val *= 0.5;
}
return val;
}
}
});
Y.SVGEllipse = SVGEllipse;
/**
* Draws an circle
*
* @module graphics
* @class SVGCircle
* @constructor
*/
{
};
/**
* Indicates the type of shape
*
* @property _type
* @readOnly
* @type String
*/
_type: "circle",
/**
* Updates the shape.
*
* @method _draw
* @private
*/
_draw: function()
{
x = this.get("x"),
y = this.get("y"),
this._fillChangeHandler();
this._strokeChangeHandler();
this._updateTransform();
}
});
/**
* Indicates the width of the shape
*
* @attribute width
* @type Number
*/
width: {
{
return val;
},
getter: function()
{
}
},
/**
* Indicates the height of the shape
*
* @attribute height
* @type Number
*/
height: {
{
return val;
},
getter: function()
{
}
},
/**
* Radius of the circle
*
* @attribute radius
* @type Number
*/
radius: {
value: 0
}
});
/**
* Draws pie slices
*
* @module graphics
* @class SVGPieSlice
* @constructor
*/
SVGPieSlice = function()
{
};
/**
* Indicates the type of shape
*
* @property _type
* @readOnly
* @type String
*/
_type: "path",
/**
* Change event listener
*
* @private
* @method _updateHandler
*/
_draw: function(e)
{
var x = this.get("cx"),
y = this.get("cy"),
this.clear();
this.end();
}
}, Y.SVGDrawing.prototype));
cx: {
value: 0
},
cy: {
value: 0
},
/**
* Starting angle in relation to a circle in which to begin the pie slice drawing.
*
* @attribute startAngle
* @type Number
*/
startAngle: {
value: 0
},
/**
* Arc of the slice.
*
* @attribute arc
* @type Number
*/
arc: {
value: 0
},
/**
* Radius of the circle in which the pie slice is drawn
*
* @attribute radius
* @type Number
*/
radius: {
value: 0
}
Y.SVGPieSlice = SVGPieSlice;
/**
* Graphic is a simple drawing api that allows for basic drawing operations.
*
* @module graphics
* @class SVGGraphic
* @constructor
*/
SVGGraphic = function(cfg) {
};
SVGGraphic.ATTRS = {
render: {},
/**
* Unique id for class instance.
*
* @attribute id
* @type String
*/
id: {
valueFn: function()
{
return Y.guid();
},
{
if(node)
{
}
return val;
}
},
/**
* Key value pairs in which a shape instance is associated with its id.
*
* @attribute shapes
* @type Object
* @readOnly
*/
shapes: {
readOnly: true,
getter: function()
{
return this._shapes;
}
},
/**
* Object containing size and coordinate data for the content of a Graphic in relation to the coordSpace node.
*
* @attribute contentBounds
* @type Object
* @readOnly
*/
readOnly: true,
getter: function()
{
return this._contentBounds;
}
},
/**
* The html element that represents to coordinate system of the Graphic instance.
*
* @attribute node
* @type HTMLElement
* @readOnly
*/
node: {
readOnly: true,
getter: function()
{
return this._node;
}
},
width: {
{
if(this._node)
{
}
return val;
}
},
height: {
{
if(this._node)
{
}
return val;
}
},
/**
* Determines how the size of instance is calculated. If true, the width and height are determined by the size of the contents.
* If false, the width and height values are either explicitly set or determined by the size of the parent node's dimensions.
*
* @attribute autoSize
* @type Boolean
* @default false
*/
autoSize: {
value: false
},
/**
* When overflow is set to true, by default, the contentBounds will resize to greater values but not to smaller values. (for performance)
* When resizing the contentBounds down is desirable, set the resizeDown value to true.
*
* @attribute resizeDown
* @type Boolean
*/
resizeDown: {
getter: function()
{
return this._resizeDown;
},
{
this._resizeDown = val;
this._redraw();
return val;
}
},
/**
* Indicates the x-coordinate for the instance.
*
* @attribute x
* @type Number
*/
x: {
getter: function()
{
return this._x;
},
{
if(this._node)
{
}
return val;
}
},
/**
* Indicates the y-coordinate for the instance.
*
* @attribute y
* @type Number
*/
y: {
getter: function()
{
return this._y;
},
{
if(this._node)
{
}
return val;
}
},
/**
* Indicates whether or not the instance will automatically redraw after a change is made to a shape.
* This property will get set to false when batching operations.
*
* @attribute autoDraw
* @type Boolean
* @default true
* @private
*/
autoDraw: {
value: true
},
visible: {
value: true,
{
this._toggleVisible(val);
return val;
}
},
/**
* Indicates the pointer-events setting for the svg:svg element.
*
* @attribute pointerEvents
* @type String
*/
value: "none"
}
};
/**
* @private
*/
_x: 0,
/**
* @private
*/
_y: 0,
/**
* Gets the current position of the graphic instance in page coordinates.
*
* @method getXY
* @return Array The XY position of the shape.
*/
getXY: function()
{
xy;
if(node)
{
}
return xy;
},
/**
* @private
* @property _resizeDown
* @type Boolean
*/
_resizeDown: false,
/**
* Initializes the class.
*
* @method initializer
* @private
*/
initializer: function() {
this._shapes = {};
this._contentBounds = {
left: 0,
top: 0,
right: 0,
bottom: 0
};
this._gradients = {};
this._contentNode = this._createGraphics();
if(render)
{
}
},
/**
* Adds the graphics node to the dom.
*
* @method render
* @param {HTMLElement} parentNode node in which to render the graphics node into.
*/
this.parentNode = parentNode;
this.set("width", w);
this.set("height", h);
this.parentNode = parentNode;
return this;
},
/**
* Removes all nodes.
*
* @method destroy
*/
destroy: function()
{
this.removeAllShapes();
this._removeChildren(this._node);
{
}
},
/**
* Generates a shape instance by type.
*
* @method getShape
* @param {String} type type of shape to generate.
* @param {Object} cfg attributes for the shape
* @return Shape
*/
{
return shape;
},
/**
* Adds a shape instance to the graphic instance.
*
* @method addShape
* @param {Shape} shape The shape instance to be added to the graphic.
*/
{
if(this.get("autoDraw"))
{
}
else
{
}
},
/**
* Removes a shape instance from from the graphic instance.
*
* @method removeShape
* @param {Shape|String} shape The instance or id of the shape to be removed.
*/
removeShape: function(shape)
{
{
{
}
}
{
}
if(this.get("autoDraw"))
{
this._redraw();
}
return shape;
},
/**
* Removes all shape instances from the dom.
*
* @method removeAllShapes
*/
removeAllShapes: function()
{
i;
for(i in shapes)
{
if(shapes.hasOwnProperty(i))
{
}
}
this._shapes = {};
},
/**
* Removes all child nodes.
*
* @method _removeChildren
* @param {HTMLElement} node
* @private
*/
_removeChildren: function(node)
{
if(node.hasChildNodes())
{
var child;
while(node.firstChild)
{
this._removeChildren(child);
}
}
},
/**
* Clears the graphics object.
*
* @method clear
*/
clear: function() {
this.removeAllShapes();
},
/**
* Toggles visibility
*
* @method _toggleVisible
* @param {Boolean} val indicates visibilitye
* @private
*/
_toggleVisible: function(val)
{
var i,
if(shapes)
{
for(i in shapes)
{
if(shapes.hasOwnProperty(i))
{
}
}
}
},
/**
* @private
*/
_getShapeClass: function(val)
{
if(shape)
{
return shape;
}
return val;
},
/**
* @private
*/
_shapeClass: {
ellipse: Y.SVGEllipse,
},
/**
* Returns a shape based on the id of its dom node.
*
* @method getShapeById
* @param {String} id Dom id of the shape's node attribute.
* @return Shape
*/
getShapeById: function(id)
{
return shape;
},
/**
* Allows for creating multiple shapes in order to batch appending and redraw operations.
*
* @method batch
* @param {Function} method Method to execute.
*/
{
this.set("autoDraw", false);
method();
this._redraw();
},
_getDocFrag: function()
{
if(!this._frag)
{
}
return this._frag;
},
_redraw: function()
{
this._contentNode.setAttribute("viewBox", "" + box.left + " " + box.top + " " + box.width + " " + box.height + "");
if(this.get("autoSize"))
{
}
if(this._frag)
{
this._frag = null;
}
},
/**
* Adds a shape to the redraw queue and calculates the contentBounds.
*
* @method addToRedrawQueue
* @param shape {SVGShape}
*/
addToRedrawQueue: function(shape)
{
var shapeBox,
box;
if(!this.get("resizeDown"))
{
box = this._contentBounds;
this._contentBounds = box;
}
if(this.get("autoDraw"))
{
this._redraw();
}
},
_getUpdatedContentBounds: function()
{
var bounds,
i,
box = {
left: 0,
top: 0,
right: 0,
bottom: 0
};
for(i in queue)
{
if(queue.hasOwnProperty(i))
{
}
}
this._contentBounds = box;
return box;
},
/**
* Creates a contentNode element
*
* @method _createGraphics
* @private
*/
_createGraphics: function() {
return contentNode;
},
/**
* Creates a graphic node
*
* @method _createGraphicNode
* @param {String} type node type to create
* @param {String} pe specified pointer-events value
* @return HTMLElement
* @private
*/
{
v = pe || "none";
{
}
return node;
},
/**
* Returns a reference to a gradient definition based on an id and type.
*
* @method getGradientNode
* @param {String} key id that references the gradient definition
* @param {String} type description of the gradient type
* @return HTMLElement
*/
{
var gradients = this._gradients,
{
}
else
{
if(!this._defs)
{
}
{
}
}
return gradient;
}
});
Y.SVGGraphic = SVGGraphic;