File yui3/src/graphics/js/SVGDrawing.js
var IMPLEMENTATION = "svg",
SHAPE = "shape",
SPLITPATHPATTERN = /[a-z][^a-z]*/ig,
SPLITARGSPATTERN = /[\-]?[0-9]*[0-9|\.][0-9]*/g,
Y_LANG = Y.Lang,
AttributeLite = Y.AttributeLite,
SVGGraphic,
SVGShape,
SVGCircle,
SVGRect,
SVGPath,
SVGEllipse,
SVGPieSlice,
DOCUMENT = Y.config.doc,
_getClassName = Y.ClassNameManager.getClassName;
function SVGDrawing(){}
/**
* <a href="http://www.w3.org/TR/SVG/">SVG</a> implementation of the <a href="Drawing.html">`Drawing`</a> class.
* `SVGDrawing` is not intended to be used directly. Instead, use the <a href="Drawing.html">`Drawing`</a> class.
* If the browser has <a href="http://www.w3.org/TR/SVG/">SVG</a> capabilities, the <a href="Drawing.html">`Drawing`</a>
* class will point to the `SVGDrawing` class.
*
* @module graphics
* @class SVGDrawing
* @constructor
*/
SVGDrawing.prototype = {
/**
* Rounds a value to the nearest hundredth.
*
* @method _round
* @param {Number} val Value to be rounded.
* @return Number
* @private
*/
_round: function(val) {
return Math.round(val * 100)/100;
},
/**
* Maps path to methods
*
* @property _pathSymbolToMethod
* @type Object
* @private
*/
_pathSymbolToMethod: {
M: "moveTo",
m: "relativeMoveTo",
L: "lineTo",
l: "relativeLineTo",
C: "curveTo",
c: "relativeCurveTo",
Q: "quadraticCurveTo",
q: "relativeQuadraticCurveTo",
z: "closePath",
Z: "closePath"
},
/**
* Current x position of the drawing.
*
* @property _currentX
* @type Number
* @private
*/
_currentX: 0,
/**
* Current y position of the drqwing.
*
* @property _currentY
* @type Number
* @private
*/
_currentY: 0,
/**
* 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.
* @chainable
*/
curveTo: function() {
this._curveTo.apply(this, [Y.Array(arguments), false]);
return this;
},
/**
* Draws a bezier curve relative to the current coordinates.
*
* @method relativeCurveTo
* @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.
* @chainable
*/
relativeCurveTo: function() {
this._curveTo.apply(this, [Y.Array(arguments), true]);
return this;
},
/**
* Implements curveTo methods.
*
* @method _curveTo
* @param {Array} args The arguments to be used.
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
* @private
*/
_curveTo: function(args, relative) {
var w,
h,
pts,
cp1x,
cp1y,
cp2x,
cp2y,
x,
y,
right,
left,
bottom,
top,
i,
len,
pathArrayLen,
currentArray,
command = relative ? "c" : "C",
relativeX = relative ? parseFloat(this._currentX) : 0,
relativeY = relative ? parseFloat(this._currentY) : 0;
this._pathArray = this._pathArray || [];
if(this._pathType !== command)
{
this._pathType = command;
currentArray = [command];
this._pathArray.push(currentArray);
}
else
{
currentArray = this._pathArray[Math.max(0, this._pathArray.length - 1)];
if(!currentArray)
{
currentArray = [];
this._pathArray.push(currentArray);
}
}
pathArrayLen = this._pathArray.length - 1;
this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat(args);
len = args.length - 5;
for(i = 0; i < len; i = i + 6)
{
cp1x = parseFloat(args[i]) + relativeX;
cp1y = parseFloat(args[i + 1]) + relativeY;
cp2x = parseFloat(args[i + 2]) + relativeX;
cp2y = parseFloat(args[i + 3]) + relativeY;
x = parseFloat(args[i + 4]) + relativeX;
y = parseFloat(args[i + 5]) + relativeY;
right = Math.max(x, Math.max(cp1x, cp2x));
bottom = Math.max(y, Math.max(cp1y, cp2y));
left = Math.min(x, Math.min(cp1x, cp2x));
top = Math.min(y, Math.min(cp1y, cp2y));
w = Math.abs(right - left);
h = Math.abs(bottom - top);
pts = [[this._currentX, this._currentY] , [cp1x, cp1y], [cp2x, cp2y], [x, y]];
this._setCurveBoundingBox(pts, w, h);
this._currentX = x;
this._currentY = 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.
* @chainable
*/
quadraticCurveTo: function() {
this._quadraticCurveTo.apply(this, [Y.Array(arguments), false]);
return this;
},
/**
* Draws a quadratic bezier curve relative to the current position.
*
* @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.
* @chainable
*/
relativeQuadraticCurveTo: function() {
this._quadraticCurveTo.apply(this, [Y.Array(arguments), true]);
return this;
},
/**
* Implements quadraticCurveTo methods.
*
* @method _quadraticCurveTo
* @param {Array} args The arguments to be used.
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
* @private
*/
_quadraticCurveTo: function(args, relative) {
var cpx,
cpy,
x,
y,
pathArrayLen,
currentArray,
w,
h,
pts,
right,
left,
bottom,
top,
i,
len,
command = relative ? "q" : "Q",
relativeX = relative ? parseFloat(this._currentX) : 0,
relativeY = relative ? parseFloat(this._currentY) : 0;
this._pathArray = this._pathArray || [];
if(this._pathType !== command)
{
this._pathType = command;
currentArray = [command];
this._pathArray.push(currentArray);
}
else
{
currentArray = this._pathArray[Math.max(0, this._pathArray.length - 1)];
if(!currentArray)
{
currentArray = [];
this._pathArray.push(currentArray);
}
}
pathArrayLen = this._pathArray.length - 1;
this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat(args);
len = args.length - 3;
for(i = 0; i < len; i = i + 4)
{
cpx = parseFloat(args[i]) + relativeX;
cpy = parseFloat(args[i + 1]) + relativeY;
x = parseFloat(args[i + 2]) + relativeX;
y = parseFloat(args[i + 3]) + relativeY;
right = Math.max(x, cpx);
bottom = Math.max(y, cpy);
left = Math.min(x, cpx);
top = Math.min(y, cpy);
w = Math.abs(right - left);
h = Math.abs(bottom - top);
pts = [[this._currentX, this._currentY] , [cpx, cpy], [x, y]];
this._setCurveBoundingBox(pts, w, h);
this._currentX = x;
this._currentY = y;
}
},
/**
* Draws a rectangle.
*
* @method drawRect
* @param {Number} x x-coordinate
* @param {Number} y y-coordinate
* @param {Number} w width
* @param {Number} h height
* @chainable
*/
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);
return this;
},
/**
* Draws a rectangle with rounded corners.
*
* @method drawRoundRect
* @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
* @chainable
*/
drawRoundRect: function(x, y, w, h, ew, eh) {
this.moveTo(x, y + eh);
this.lineTo(x, y + h - eh);
this.quadraticCurveTo(x, y + h, x + ew, y + h);
this.lineTo(x + w - ew, y + h);
this.quadraticCurveTo(x + w, y + h, x + w, y + h - eh);
this.lineTo(x + w, y + eh);
this.quadraticCurveTo(x + w, y, x + w - ew, y);
this.lineTo(x + ew, y);
this.quadraticCurveTo(x, y, x, y + eh);
return this;
},
/**
* Draws a circle.
*
* @method drawCircle
* @param {Number} x y-coordinate
* @param {Number} y x-coordinate
* @param {Number} r radius
* @chainable
* @protected
*/
drawCircle: function(x, y, radius) {
var circum = radius * 2;
this._drawingComplete = false;
this._trackSize(x, y);
this._trackSize(x + circum, y + circum);
this._pathArray = this._pathArray || [];
this._pathArray.push(["M", x + radius, y]);
this._pathArray.push(["A", radius, radius, 0, 1, 0, x + radius, y + circum]);
this._pathArray.push(["A", radius, radius, 0, 1, 0, x + radius, y]);
this._currentX = x;
this._currentY = y;
return this;
},
/**
* Draws an ellipse.
*
* @method drawEllipse
* @param {Number} x x-coordinate
* @param {Number} y y-coordinate
* @param {Number} w width
* @param {Number} h height
* @chainable
* @protected
*/
drawEllipse: function(x, y, w, h) {
var radius = w * 0.5,
yRadius = h * 0.5;
this._drawingComplete = false;
this._trackSize(x, y);
this._trackSize(x + w, y + h);
this._pathArray = this._pathArray || [];
this._pathArray.push(["M", x + radius, y]);
this._pathArray.push(["A", radius, yRadius, 0, 1, 0, x + radius, y + h]);
this._pathArray.push(["A", radius, yRadius, 0, 1, 0, x + radius, y]);
this._currentX = x;
this._currentY = y;
return this;
},
/**
* Draws a diamond.
*
* @method drawDiamond
* @param {Number} x y-coordinate
* @param {Number} y x-coordinate
* @param {Number} width width
* @param {Number} height height
* @chainable
* @protected
*/
drawDiamond: function(x, y, width, height)
{
var midWidth = width * 0.5,
midHeight = height * 0.5;
this.moveTo(x + midWidth, y);
this.lineTo(x + width, y + midHeight);
this.lineTo(x + midWidth, y + height);
this.lineTo(x, y + midHeight);
this.lineTo(x + midWidth, y);
return this;
},
/**
* Draws a wedge.
*
* @method drawWedge
* @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.
* @chainable
* @private
*/
drawWedge: function(x, y, startAngle, arc, radius, yRadius)
{
var segs,
segAngle,
theta,
angle,
angleMid,
ax,
ay,
bx,
by,
cx,
cy,
i,
diameter = radius * 2,
currentArray,
pathArrayLen;
this._pathArray = this._pathArray || [];
yRadius = yRadius || radius;
if(this._pathType !== "M")
{
this._pathType = "M";
currentArray = ["M"];
this._pathArray.push(currentArray);
}
else
{
currentArray = this._getCurrentArray();
}
pathArrayLen = this._pathArray.length - 1;
this._pathArray[pathArrayLen].push(x);
this._pathArray[pathArrayLen].push(x);
// limit sweep to reasonable numbers
if(Math.abs(arc) > 360)
{
arc = 360;
}
// First we calculate how many segments are needed
// for a smooth arc.
segs = Math.ceil(Math.abs(arc) / 45);
// Now calculate the sweep of each segment.
segAngle = arc / segs;
// The math requires radians rather than degrees. To convert from degrees
// use the formula (degrees/180)*Math.PI to get radians.
theta = -(segAngle / 180) * Math.PI;
// convert angle startAngle to radians
angle = (startAngle / 180) * Math.PI;
if(segs > 0)
{
// draw a line from the center to the start of the curve
ax = x + Math.cos(startAngle / 180 * Math.PI) * radius;
ay = y + Math.sin(startAngle / 180 * Math.PI) * yRadius;
this._pathType = "L";
pathArrayLen++;
this._pathArray[pathArrayLen] = ["L"];
this._pathArray[pathArrayLen].push(this._round(ax));
this._pathArray[pathArrayLen].push(this._round(ay));
pathArrayLen++;
this._pathType = "Q";
this._pathArray[pathArrayLen] = ["Q"];
for(i = 0; i < segs; ++i)
{
angle += theta;
angleMid = angle - (theta / 2);
bx = x + Math.cos(angle) * radius;
by = y + Math.sin(angle) * yRadius;
cx = x + Math.cos(angleMid) * (radius / Math.cos(theta / 2));
cy = y + Math.sin(angleMid) * (yRadius / Math.cos(theta / 2));
this._pathArray[pathArrayLen].push(this._round(cx));
this._pathArray[pathArrayLen].push(this._round(cy));
this._pathArray[pathArrayLen].push(this._round(bx));
this._pathArray[pathArrayLen].push(this._round(by));
}
}
this._currentX = x;
this._currentY = y;
this._trackSize(diameter, diameter);
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.
* @chainable
*/
lineTo: function()
{
this._lineTo.apply(this, [Y.Array(arguments), false]);
return this;
},
/**
* Draws a line segment using the current line style from the current drawing position to the relative x and y coordinates.
*
* @method relativeLineTo
* @param {Number} point1 x-coordinate for the end point.
* @param {Number} point2 y-coordinate for the end point.
* @chainable
*/
relativeLineTo: function()
{
this._lineTo.apply(this, [Y.Array(arguments), true]);
return this;
},
/**
* Implements lineTo methods.
*
* @method _lineTo
* @param {Array} args The arguments to be used.
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
* @private
*/
_lineTo: function(args, relative) {
var point1 = args[0],
i,
len,
pathArrayLen,
currentArray,
x,
y,
command = relative ? "l" : "L",
relativeX = relative ? parseFloat(this._currentX) : 0,
relativeY = relative ? parseFloat(this._currentY) : 0;
this._pathArray = this._pathArray || [];
this._shapeType = "path";
len = args.length;
if(this._pathType !== command)
{
this._pathType = command;
currentArray = [command];
this._pathArray.push(currentArray);
}
else
{
currentArray = this._getCurrentArray();
}
pathArrayLen = this._pathArray.length - 1;
if (typeof point1 === 'string' || typeof point1 === 'number') {
for (i = 0; i < len; i = i + 2) {
x = parseFloat(args[i]);
y = parseFloat(args[i + 1]);
this._pathArray[pathArrayLen].push(x);
this._pathArray[pathArrayLen].push(y);
x = x + relativeX;
y = y + relativeY;
this._currentX = x;
this._currentY = y;
this._trackSize.apply(this, [x, y]);
}
}
else
{
for (i = 0; i < len; ++i) {
x = parseFloat(args[i][0]);
y = parseFloat(args[i][1]);
this._pathArray[pathArrayLen].push(x);
this._pathArray[pathArrayLen].push(y);
this._currentX = x;
this._currentY = y;
x = x + relativeX;
y = y + relativeY;
this._trackSize.apply(this, [x, y]);
}
}
},
/**
* 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.
* @chainable
*/
moveTo: function()
{
this._moveTo.apply(this, [Y.Array(arguments), false]);
return this;
},
/**
* Moves the current drawing position relative to specified x and y coordinates.
*
* @method relativeMoveTo
* @param {Number} x x-coordinate for the end point.
* @param {Number} y y-coordinate for the end point.
* @chainable
*/
relativeMoveTo: function()
{
this._moveTo.apply(this, [Y.Array(arguments), true]);
return this;
},
/**
* Implements moveTo methods.
*
* @method _moveTo
* @param {Array} args The arguments to be used.
* @param {Boolean} relative Indicates whether or not to use relative coordinates.
* @private
*/
_moveTo: function(args, relative) {
var pathArrayLen,
currentArray,
x = parseFloat(args[0]),
y = parseFloat(args[1]),
command = relative ? "m" : "M",
relativeX = relative ? parseFloat(this._currentX) : 0,
relativeY = relative ? parseFloat(this._currentY) : 0;
this._pathArray = this._pathArray || [];
this._pathType = command;
currentArray = [command];
this._pathArray.push(currentArray);
pathArrayLen = this._pathArray.length - 1;
this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat([x, y]);
x = x + relativeX;
y = y + relativeY;
this._currentX = x;
this._currentY = y;
this._trackSize(x, y);
},
/**
* Completes a drawing operation.
*
* @method end
* @chainable
*/
end: function()
{
this._closePath();
return this;
},
/**
* Clears the path.
*
* @method clear
* @chainable
*/
clear: function()
{
this._currentX = 0;
this._currentY = 0;
this._width = 0;
this._height = 0;
this._left = 0;
this._right = 0;
this._top = 0;
this._bottom = 0;
this._pathArray = [];
this._path = "";
this._pathType = "";
return this;
},
/**
* Draws the path.
*
* @method _closePath
* @private
*/
_closePath: function()
{
var pathArray,
segmentArray,
pathType,
len,
val,
i,
path = "",
node = this.node,
left = parseFloat(this._left),
top = parseFloat(this._top),
fill = this.get("fill");
if(this._pathArray)
{
pathArray = this._pathArray.concat();
while(pathArray && pathArray.length > 0)
{
segmentArray = pathArray.shift();
len = segmentArray.length;
pathType = segmentArray[0];
if(pathType === "A")
{
path += pathType + segmentArray[1] + "," + segmentArray[2];
}
else if(pathType === "z" || pathType === "Z")
{
path += " z ";
}
else if(pathType === "C" || pathType === "c")
{
path += pathType + (segmentArray[1] - left)+ "," + (segmentArray[2] - top);
}
else
{
path += " " + pathType + parseFloat(segmentArray[1] - left);
}
switch(pathType)
{
case "L" :
case "l" :
case "M" :
case "m" :
case "Q" :
case "q" :
for(i = 2; i < len; ++i)
{
val = (i % 2 === 0) ? top : left;
val = segmentArray[i] - val;
path += ", " + parseFloat(val);
}
break;
case "A" :
val = " " + parseFloat(segmentArray[3]) + " " + parseFloat(segmentArray[4]);
val += "," + parseFloat(segmentArray[5]) + " " + parseFloat(segmentArray[6] - left);
val += "," + parseFloat(segmentArray[7] - top);
path += " " + val;
break;
case "C" :
case "c" :
for(i = 3; i < len - 1; i = i + 2)
{
val = parseFloat(segmentArray[i] - left);
val = val + ", ";
val = val + parseFloat(segmentArray[i + 1] - top);
path += " " + val;
}
break;
}
}
if(fill && fill.color)
{
path += 'z';
}
Y.Lang.trim(path);
if(path)
{
node.setAttribute("d", path);
}
this._path = path;
this._fillChangeHandler();
this._strokeChangeHandler();
this._updateTransform();
}
},
/**
* Ends a fill and stroke
*
* @method closePath
* @chainable
*/
closePath: function()
{
this._pathArray.push(["z"]);
return this;
},
/**
* Returns the current array of drawing commands.
*
* @method _getCurrentArray
* @return Array
* @private
*/
_getCurrentArray: function()
{
var currentArray = this._pathArray[Math.max(0, this._pathArray.length - 1)];
if(!currentArray)
{
currentArray = [];
this._pathArray.push(currentArray);
}
return currentArray;
},
/**
* Returns the points on a curve
*
* @method getBezierData
* @param Array points Array containing the begin, end and control points of a curve.
* @param Number t The value for incrementing the next set of points.
* @return Array
* @private
*/
getBezierData: function(points, t) {
var n = points.length,
tmp = [],
i,
j;
for (i = 0; i < n; ++i){
tmp[i] = [points[i][0], points[i][1]]; // save input
}
for (j = 1; j < n; ++j) {
for (i = 0; i < n - j; ++i) {
tmp[i][0] = (1 - t) * tmp[i][0] + t * tmp[parseInt(i + 1, 10)][0];
tmp[i][1] = (1 - t) * tmp[i][1] + t * tmp[parseInt(i + 1, 10)][1];
}
}
return [ tmp[0][0], tmp[0][1] ];
},
/**
* Calculates the bounding box for a curve
*
* @method _setCurveBoundingBox
* @param Array pts Array containing points for start, end and control points of a curve.
* @param Number w Width used to calculate the number of points to describe the curve.
* @param Number h Height used to calculate the number of points to describe the curve.
* @private
*/
_setCurveBoundingBox: function(pts, w, h)
{
var i,
left = this._currentX,
right = left,
top = this._currentY,
bottom = top,
len = Math.round(Math.sqrt((w * w) + (h * h))),
t = 1/len,
xy;
for(i = 0; i < len; ++i)
{
xy = this.getBezierData(pts, t * i);
left = isNaN(left) ? xy[0] : Math.min(xy[0], left);
right = isNaN(right) ? xy[0] : Math.max(xy[0], right);
top = isNaN(top) ? xy[1] : Math.min(xy[1], top);
bottom = isNaN(bottom) ? xy[1] : Math.max(xy[1], bottom);
}
left = Math.round(left * 10)/10;
right = Math.round(right * 10)/10;
top = Math.round(top * 10)/10;
bottom = Math.round(bottom * 10)/10;
this._trackSize(right, bottom);
this._trackSize(left, top);
},
/**
* 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;
}
this._width = this._right - this._left;
this._height = this._bottom - this._top;
}
};
Y.SVGDrawing = SVGDrawing;