/**
* <a href="http://www.w3.org/TR/SVG/">SVG</a> implementation of the <a href="Shape.html">`Shape`</a> class.
* `SVGShape` is not intended to be used directly. Instead, use the <a href="Shape.html">`Shape`</a> class.
* If the browser has <a href="http://www.w3.org/TR/SVG/">SVG</a> capabilities, the <a href="Shape.html">`Shape`</a>
* class will point to the `SVGShape` class.
*
* @module graphics
* @class SVGShape
* @constructor
* @param {Object} cfg (optional) Attribute configs
*/
SVGShape = function()
{
this._transforms = [];
this.matrix = new Y.Matrix();
this._normalizedMatrix = new Y.Matrix();
SVGShape.superclass.constructor.apply(this, arguments);
};
SVGShape.NAME = "shape";
Y.extend(SVGShape, Y.GraphicBase, Y.mix({
/**
* Storage for x attribute.
*
* @property _x
* @protected
*/
_x: 0,
/**
* Storage for y attribute.
*
* @property _y
* @protected
*/
_y: 0,
/**
* Init method, invoked during construction.
* Calls `initializer` method.
*
* @method init
* @protected
*/
init: function()
{
this.initializer.apply(this, arguments);
},
/**
* Initializes the shape
*
* @private
* @method initializer
*/
initializer: function(cfg)
{
var host = this,
graphic = cfg.graphic,
data = this.get("data");
host.createNode();
if(graphic)
{
host._setGraphic(graphic);
}
if(data)
{
host._parsePathData(data);
}
host._updateHandler();
},
/**
* Set the Graphic instance for the shape.
*
* @method _setGraphic
* @param {Graphic | Node | HTMLElement | String} render This param is used to determine the graphic instance. If it is a
* `Graphic` instance, it will be assigned to the `graphic` attribute. Otherwise, a new Graphic instance will be created
* and rendered into the dom element that the render represents.
* @private
*/
_setGraphic: function(render)
{
var graphic;
if(render instanceof Y.SVGGraphic)
{
this._graphic = render;
}
else
{
graphic = new Y.SVGGraphic({
render: render
});
graphic._appendShape(this);
this._graphic = graphic;
}
},
/**
* Add a class name to each node.
*
* @method addClass
* @param {String} className the class name to add to the node's class attribute
*/
addClass: function(className)
{
var node = this.node;
node.className.baseVal = Y_LANG.trim([node.className.baseVal, className].join(' '));
},
/**
* 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)
{
var node = this.node,
classString = node.className.baseVal;
classString = classString.replace(new RegExp(className + ' '), className).replace(new RegExp(className), '');
node.className.baseVal = classString;
},
/**
* Gets the current position of the node in page coordinates.
*
* @method getXY
* @return Array The XY position of the shape.
*/
getXY: function()
{
var graphic = this._graphic,
parentXY = graphic.getXY(),
x = this._x,
y = this._y;
return [parentXY[0] + x, parentXY[1] + 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)
*/
setXY: function(xy)
{
var graphic = this._graphic,
parentXY = graphic.getXY();
this._x = xy[0] - parentXY[0];
this._y = xy[1] - parentXY[1];
this.set("transform", this.get("transform"));
},
/**
* 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.
*/
contains: function(needle)
{
var node = needle instanceof Y.Node ? needle._node : needle;
return node === this.node;
},
/**
* Compares nodes to determine if they match.
* Node instances can be compared to each other and/or HTMLElements.
* @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.
*/
compareTo: function(refNode) {
var node = this.node;
return node === refNode;
},
/**
* 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.
*/
test: function(selector)
{
return Y.Selector.test(this.node, 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()
{
var host = this,
node = DOCUMENT.createElementNS("http://www.w3.org/2000/svg", "svg:" + this._type),
id = host.get("id"),
name = host.name,
concat = host._camelCaseConcat,
pointerEvents = host.get("pointerEvents");
host.node = node;
host.addClass(
_getClassName(SHAPE) +
" " +
_getClassName(concat(IMPLEMENTATION, SHAPE)) +
" " +
_getClassName(name) +
" " +
_getClassName(concat(IMPLEMENTATION, name))
);
if(id)
{
node.setAttribute("id", id);
}
if(pointerEvents)
{
node.setAttribute("pointer-events", pointerEvents);
}
if(!host.get("visible"))
{
Y.DOM.setStyle(node, "visibility", "hidden");
}
Y.DOM.setAttribute(this.node, "shape-rendering", this.get("shapeRendering"));
},
/**
* 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
*/
on: function(type, fn)
{
if(Y.Node.DOM_EVENTS[type])
{
return Y.on(type, fn, "#" + this.get("id"));
}
return Y.on.apply(this, arguments);
},
/**
* Adds a stroke to the shape node.
*
* @method _strokeChangeHandler
* @private
*/
_strokeChangeHandler: function()
{
var node = this.node,
stroke = this.get("stroke"),
strokeOpacity,
dashstyle,
dash,
linejoin;
if(stroke && stroke.weight && stroke.weight > 0)
{
linejoin = stroke.linejoin || "round";
strokeOpacity = parseFloat(stroke.opacity);
dashstyle = stroke.dashstyle || "none";
dash = Y_LANG.isArray(dashstyle) ? dashstyle.toString() : dashstyle;
stroke.color = stroke.color || "#000000";
stroke.weight = stroke.weight || 1;
stroke.opacity = Y_LANG.isNumber(strokeOpacity) ? strokeOpacity : 1;
stroke.linecap = stroke.linecap || "butt";
node.setAttribute("stroke-dasharray", dash);
node.setAttribute("stroke", stroke.color);
node.setAttribute("stroke-linecap", stroke.linecap);
node.setAttribute("stroke-width", stroke.weight);
node.setAttribute("stroke-opacity", stroke.opacity);
if(linejoin === "round" || linejoin === "bevel")
{
node.setAttribute("stroke-linejoin", linejoin);
}
else
{
linejoin = parseInt(linejoin, 10);
if(Y_LANG.isNumber(linejoin))
{
node.setAttribute("stroke-miterlimit", Math.max(linejoin, 1));
node.setAttribute("stroke-linejoin", "miter");
}
}
}
else
{
node.setAttribute("stroke", "none");
}
},
/**
* Adds a fill to the shape node.
*
* @method _fillChangeHandler
* @private
*/
_fillChangeHandler: function()
{
var node = this.node,
fill = this.get("fill"),
fillOpacity,
type;
if(fill)
{
type = fill.type;
if(type === "linear" || type === "radial")
{
this._setGradientFill(fill);
node.setAttribute("fill", "url(#grad" + this.get("id") + ")");
}
else if(!fill.color)
{
node.setAttribute("fill", "none");
}
else
{
fillOpacity = parseFloat(fill.opacity);
fillOpacity = Y_LANG.isNumber(fillOpacity) ? fillOpacity : 1;
node.setAttribute("fill", fill.color);
node.setAttribute("fill-opacity", fillOpacity);
}
}
else
{
node.setAttribute("fill", "none");
}
},
/**
* Creates a gradient fill
*
* @method _setGradientFill
* @param {String} type gradient type
* @private
*/
_setGradientFill: function(fill) {
var offset,
opacity,
color,
stopNode,
newStop,
isNumber = Y_LANG.isNumber,
graphic = this._graphic,
type = fill.type,
gradientNode = graphic.getGradientNode("grad" + this.get("id"), type),
stops = fill.stops,
w = this.get("width"),
h = this.get("height"),
rotation = fill.rotation || 0,
radCon = Math.PI/180,
tanRadians = parseFloat(parseFloat(Math.tan(rotation * radCon)).toFixed(8)),
i,
len,
def,
stop,
x1 = "0%",
x2 = "100%",
y1 = "0%",
y2 = "0%",
cx = fill.cx,
cy = fill.cy,
fx = fill.fx,
fy = fill.fy,
r = fill.r,
stopNodes = [];
if(type === "linear")
{
cx = w/2;
cy = h/2;
if(Math.abs(tanRadians) * w/2 >= h/2)
{
if(rotation < 180)
{
y1 = 0;
y2 = h;
}
else
{
y1 = h;
y2 = 0;
}
x1 = cx - ((cy - y1)/tanRadians);
x2 = cx - ((cy - y2)/tanRadians);
}
else
{
if(rotation > 90 && rotation < 270)
{
x1 = w;
x2 = 0;
}
else
{
x1 = 0;
x2 = w;
}
y1 = ((tanRadians * (cx - x1)) - cy) * -1;
y2 = ((tanRadians * (cx - x2)) - cy) * -1;
}
x1 = Math.round(100 * x1/w);
x2 = Math.round(100 * x2/w);
y1 = Math.round(100 * y1/h);
y2 = Math.round(100 * y2/h);
//Set default value if not valid
x1 = isNumber(x1) ? x1 : 0;
x2 = isNumber(x2) ? x2 : 100;
y1 = isNumber(y1) ? y1 : 0;
y2 = isNumber(y2) ? y2 : 0;
gradientNode.setAttribute("spreadMethod", "pad");
gradientNode.setAttribute("width", w);
gradientNode.setAttribute("height", h);
gradientNode.setAttribute("x1", x1 + "%");
gradientNode.setAttribute("x2", x2 + "%");
gradientNode.setAttribute("y1", y1 + "%");
gradientNode.setAttribute("y2", y2 + "%");
}
else
{
gradientNode.setAttribute("cx", (cx * 100) + "%");
gradientNode.setAttribute("cy", (cy * 100) + "%");
gradientNode.setAttribute("fx", (fx * 100) + "%");
gradientNode.setAttribute("fy", (fy * 100) + "%");
gradientNode.setAttribute("r", (r * 100) + "%");
}
len = stops.length;
def = 0;
for(i = 0; i < len; ++i)
{
if(this._stops && this._stops.length > 0)
{
stopNode = this._stops.shift();
newStop = false;
}
else
{
stopNode = graphic._createGraphicNode("stop");
newStop = true;
}
stop = stops[i];
opacity = stop.opacity;
color = stop.color;
offset = stop.offset || i/(len - 1);
offset = Math.round(offset * 100) + "%";
opacity = isNumber(opacity) ? opacity : 1;
opacity = Math.max(0, Math.min(1, opacity));
def = (i + 1) / len;
stopNode.setAttribute("offset", offset);
stopNode.setAttribute("stop-color", color);
stopNode.setAttribute("stop-opacity", opacity);
if(newStop)
{
gradientNode.appendChild(stopNode);
}
stopNodes.push(stopNode);
}
while(this._stops && this._stops.length > 0)
{
gradientNode.removeChild(this._stops.shift());
}
this._stops = stopNodes;
},
_stops: null,
/**
* 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;
AttributeLite.prototype.set.apply(host, arguments);
if(host.initialized)
{
host._updateHandler();
}
},
/**
* Specifies a 2d translation.
*
* @method translate
* @param {Number} x The value to transate on the x-axis.
* @param {Number} y The value to translate on the y-axis.
*/
translate: function()
{
this._addTransform("translate", arguments);
},
/**
* Translates the shape along the x-axis. When translating x and y coordinates,
* use the `translate` method.
*
* @method translateX
* @param {Number} x The value to translate.
*/
translateX: function()
{
this._addTransform("translateX", arguments);
},
/**
* Translates the shape along the y-axis. When translating x and y coordinates,
* use the `translate` method.
*
* @method translateY
* @param {Number} y The value to translate.
*/
translateY: function()
{
this._addTransform("translateY", arguments);
},
/**
* Skews the shape around the x-axis and y-axis.
*
* @method skew
* @param {Number} x The value to skew on the x-axis.
* @param {Number} y The value to skew on the y-axis.
*/
skew: function()
{
this._addTransform("skew", arguments);
},
/**
* Skews the shape around the x-axis.
*
* @method skewX
* @param {Number} x x-coordinate
*/
skewX: function()
{
this._addTransform("skewX", arguments);
},
/**
* Skews the shape around the y-axis.
*
* @method skewY
* @param {Number} y y-coordinate
*/
skewY: function()
{
this._addTransform("skewY", arguments);
},
/**
* Rotates the shape clockwise around it transformOrigin.
*
* @method rotate
* @param {Number} deg The degree of the rotation.
*/
rotate: function()
{
this._addTransform("rotate", arguments);
},
/**
* Specifies a 2d scaling operation.
*
* @method scale
* @param {Number} val
*/
scale: function()
{
this._addTransform("scale", arguments);
},
/**
* Adds a transform to the shape.
*
* @method _addTransform
* @param {String} type The transform being applied.
* @param {Array} args The arguments for the transform.
* @private
*/
_addTransform: function(type, args)
{
args = Y.Array(args);
this._transform = Y_LANG.trim(this._transform + " " + type + "(" + args.join(", ") + ")");
args.unshift(type);
this._transforms.push(args);
if(this.initialized)
{
this._updateTransform();
}
},
/**
* Applies all transforms.
*
* @method _updateTransform
* @private
*/
_updateTransform: function()
{
var isPath = this._type === "path",
node = this.node,
key,
transform,
transformOrigin,
x,
y,
tx,
ty,
matrix = this.matrix,
normalizedMatrix = this._normalizedMatrix,
i,
len = this._transforms.length;
if(isPath || (this._transforms && this._transforms.length > 0))
{
x = this._x;
y = this._y;
transformOrigin = this.get("transformOrigin");
tx = x + (transformOrigin[0] * this.get("width"));
ty = y + (transformOrigin[1] * this.get("height"));
//need to use translate for x/y coords
if(isPath)
{
//adjust origin for custom shapes
if(!(this instanceof Y.SVGPath))
{
tx = this._left + (transformOrigin[0] * this.get("width"));
ty = this._top + (transformOrigin[1] * this.get("height"));
}
normalizedMatrix.init({dx: x + this._left, dy: y + this._top});
}
normalizedMatrix.translate(tx, ty);
for(i = 0; i < len; ++i)
{
key = this._transforms[i].shift();
if(key)
{
normalizedMatrix[key].apply(normalizedMatrix, this._transforms[i]);
matrix[key].apply(matrix, this._transforms[i]);
}
if(isPath)
{
this._transforms[i].unshift(key);
}
}
normalizedMatrix.translate(-tx, -ty);
transform = "matrix(" + normalizedMatrix.a + "," +
normalizedMatrix.b + "," +
normalizedMatrix.c + "," +
normalizedMatrix.d + "," +
normalizedMatrix.dx + "," +
normalizedMatrix.dy + ")";
}
this._graphic.addToRedrawQueue(this);
if(transform)
{
node.setAttribute("transform", transform);
}
if(!isPath)
{
this._transforms = [];
}
},
/**
* Draws the shape.
*
* @method _draw
* @private
*/
_draw: function()
{
var node = this.node;
node.setAttribute("width", this.get("width"));
node.setAttribute("height", this.get("height"));
node.setAttribute("x", this._x);
node.setAttribute("y", this._y);
node.style.left = this._x + "px";
node.style.top = this._y + "px";
this._fillChangeHandler();
this._strokeChangeHandler();
this._updateTransform();
},
/**
* Updates `Shape` based on attribute changes.
*
* @method _updateHandler
* @private
*/
_updateHandler: function()
{
this._draw();
},
/**
* Storage for the transform attribute.
*
* @property _transform
* @type String
* @private
*/
_transform: "",
/**
* Returns the bounds for a shape.
*
* Calculates the a new bounding box from the original corner coordinates (base on size and position) and the transform matrix.
* The calculated bounding box is used by the graphic instance to calculate its viewBox.
*
* @method getBounds
* @return Object
*/
getBounds: function()
{
var type = this._type,
stroke = this.get("stroke"),
w = this.get("width"),
h = this.get("height"),
x = type === "path" ? 0 : this._x,
y = type === "path" ? 0 : this._y,
wt = 0;
if(stroke && stroke.weight)
{
wt = stroke.weight;
w = (x + w + wt) - (x - wt);
h = (y + h + wt) - (y - wt);
x -= wt;
y -= wt;
}
return this._normalizedMatrix.getContentRect(w, h, x, y);
},
/**
* Places the shape above all other shapes.
*
* @method toFront
*/
toFront: function()
{
var graphic = this.get("graphic");
if(graphic)
{
graphic._toFront(this);
}
},
/**
* Places the shape underneath all other shapes.
*
* @method toFront
*/
toBack: function()
{
var graphic = this.get("graphic");
if(graphic)
{
graphic._toBack(this);
}
},
/**
* Parses path data string and call mapped methods.
*
* @method _parsePathData
* @param {String} val The path data
* @private
*/
_parsePathData: function(val)
{
var method,
methodSymbol,
args,
commandArray = Y.Lang.trim(val.match(SPLITPATHPATTERN)),
i,
len,
str,
symbolToMethod = this._pathSymbolToMethod;
if(commandArray)
{
this.clear();
len = commandArray.length || 0;
for(i = 0; i < len; i = i + 1)
{
str = commandArray[i];
methodSymbol = str.substr(0, 1);
args = str.substr(1).match(SPLITARGSPATTERN);
method = symbolToMethod[methodSymbol];
if(method)
{
if(args)
{
this[method].apply(this, args);
}
else
{
this[method].apply(this);
}
}
}
this.end();
}
},
/**
* Destroys the shape instance.
*
* @method destroy
*/
destroy: function()
{
var graphic = this.get("graphic");
if(graphic)
{
graphic.removeShape(this);
}
else
{
this._destroy();
}
},
/**
* Implementation for shape destruction
*
* @method destroy
* @protected
*/
_destroy: function()
{
if(this.node)
{
Y.Event.purgeElement(this.node, true);
if(this.node.parentNode)
{
this.node.parentNode.removeChild(this.node);
}
this.node = null;
}
}
}, Y.SVGDrawing.prototype));
SVGShape.ATTRS = {
/**
* 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].
*
* @config transformOrigin
* @type Array
*/
transformOrigin: {
valueFn: function()
{
return [0.5, 0.5];
}
},
/**
* <p>A string containing, in order, transform operations applied to the shape instance. The `transform` string can contain the following values:
*
* <dl>
* <dt>rotate</dt><dd>Rotates the shape clockwise around it transformOrigin.</dd>
* <dt>translate</dt><dd>Specifies a 2d translation.</dd>
* <dt>skew</dt><dd>Skews the shape around the x-axis and y-axis.</dd>
* <dt>scale</dt><dd>Specifies a 2d scaling operation.</dd>
* <dt>translateX</dt><dd>Translates the shape along the x-axis.</dd>
* <dt>translateY</dt><dd>Translates the shape along the y-axis.</dd>
* <dt>skewX</dt><dd>Skews the shape around the x-axis.</dd>
* <dt>skewY</dt><dd>Skews the shape around the y-axis.</dd>
* <dt>matrix</dt><dd>Specifies a 2D transformation matrix comprised of the specified six values.</dd>
* </dl>
* </p>
* <p>Applying transforms through the transform attribute will reset the transform matrix and apply a new transform. The shape class also contains
* corresponding methods for each transform that will apply the transform to the current matrix. The below code illustrates how you might use the
* `transform` attribute to instantiate a recangle with a rotation of 45 degrees.</p>
var myRect = new Y.Rect({
type:"rect",
width: 50,
height: 40,
transform: "rotate(45)"
};
* <p>The code below would apply `translate` and `rotate` to an existing shape.</p>
myRect.set("transform", "translate(40, 50) rotate(45)");
* @config transform
* @type String
*/
transform: {
setter: function(val)
{
this.matrix.init();
this._normalizedMatrix.init();
this._transforms = this.matrix.getTransformArray(val);
this._transform = val;
return val;
},
getter: function()
{
return this._transform;
}
},
/**
* Unique id for class instance.
*
* @config id
* @type String
*/
id: {
valueFn: function()
{
return Y.guid();
},
setter: function(val)
{
var node = this.node;
if(node)
{
node.setAttribute("id", val);
}
return val;
}
},
/**
* Indicates the x position of shape.
*
* @config x
* @type Number
*/
x: {
getter: function()
{
return this._x;
},
setter: function(val)
{
var transform = this.get("transform");
this._x = val;
if(transform)
{
this.set("transform", transform);
}
}
},
/**
* Indicates the y position of shape.
*
* @config y
* @type Number
*/
y: {
getter: function()
{
return this._y;
},
setter: function(val)
{
var transform = this.get("transform");
this._y = val;
if(transform)
{
this.set("transform", transform);
}
}
},
/**
* Indicates the width of the shape
*
* @config width
* @type Number
*/
width: {
value: 0
},
/**
* Indicates the height of the shape
*
* @config height
* @type Number
*/
height: {
value: 0
},
/**
* Indicates whether the shape is visible.
*
* @config visible
* @type Boolean
*/
visible: {
value: true,
setter: function(val){
var visibility = val ? "visible" : "hidden";
if(this.node)
{
this.node.style.visibility = visibility;
}
return val;
}
},
/**
* Only implemented in SVG implementation.
* Applies the SVG shape-rendering attribute to the shape.
* <dl>
* <dt>auto</dt>
* <dd>Indicates that the user agent shall make appropriate tradeoffs to balance speed,
* crisp edges and geometric precision, but with geometric precision given more importance than speed and crisp edges.</dd>
* <dt>optimizeSpeed</dt>
* <dd>Indicates that the user agent shall emphasize rendering speed over geometric precision and crisp edges.
* This option will sometimes cause the user agent to turn off shape anti-aliasing.</dd>
* <dt>crispEdges</dt>
* <dd>Indicates that the user agent shall attempt to emphasize the contrast between clean edges of artwork over rendering
* speed and geometric precision. To achieve crisp edges, the user agent might turn off anti-aliasing for all lines and curves
* or possibly just for straight lines which are close to vertical or horizontal. Also, the user agent might adjust line
* positions and line widths to align edges with device pixels.</dd>
* <dt>geometricPrecision</dt>
* <dd>Indicates that the user agent shall emphasize geometric precision over speed and crisp edges.</dd>
* </dl>
*
* @config shapeRendering
* @type String
*/
shapeRendering: {
value: "auto",
setter: function(val) {
if(this.node)
{
Y.DOM.setAttribute(this.node, "shape-rendering", val);
}
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 `linear` or `radial` is specified as the fill type. The following additional property is 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 6 - 8</dd>
* <dt>offset</dt><dd>Number between 0 and 1 indicating where the color stop is positioned.</dd>
* </dl>
* </dd>
* <p>Linear gradients also have the following property:</p>
* <dt>rotation</dt><dd>Linear gradients flow left to right by default. The rotation property allows you to change the
* flow by rotation. (e.g. A rotation of 180 would make the gradient pain from right to left.)</dd>
* <p>Radial gradients have the following additional properties:</p>
* <dt>r</dt><dd>Radius of the gradient circle.</dd>
* <dt>fx</dt><dd>Focal point x-coordinate of the gradient.</dd>
* <dt>fy</dt><dd>Focal point y-coordinate of the gradient.</dd>
* <dt>cx</dt><dd>
* <p>The x-coordinate of the center of the gradient circle. Determines where the color stop begins. The default value 0.5.</p>
* <p><strong>Note: </strong>Currently, this property is not implemented for corresponding `CanvasShape` and
* `VMLShape` classes which are used on Android or IE 6 - 8.</p>
* </dd>
* <dt>cy</dt><dd>
* <p>The y-coordinate of the center of the gradient circle. Determines where the color stop begins. The default value 0.5.</p>
* <p><strong>Note: </strong>Currently, this property is not implemented for corresponding `CanvasShape` and `VMLShape`
* classes which are used on Android or IE 6 - 8.</p>
* </dd>
* </dl>
*
* @config fill
* @type Object
*/
fill: {
valueFn: "_getDefaultFill",
setter: function(val)
{
var fill,
tmpl = this.get("fill") || this._getDefaultFill();
fill = (val) ? Y.merge(tmpl, val) : null;
if(fill && fill.color)
{
if(fill.color === undefined || fill.color === "none")
{
fill.color = null;
}
}
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.
* <dt>linecap</dt><dd>Specifies the linecap for the stroke. The following values can be specified:
* <dl>
* <dt>butt (default)</dt><dd>Specifies a butt linecap.</dd>
* <dt>square</dt><dd>Specifies a sqare linecap.</dd>
* <dt>round</dt><dd>Specifies a round linecap.</dd>
* </dl>
* </dd>
* <dt>linejoin</dt><dd>Specifies a linejoin for the stroke. The following values can be specified:
* <dl>
* <dt>round (default)</dt><dd>Specifies that the linejoin will be round.</dd>
* <dt>bevel</dt><dd>Specifies a bevel for the linejoin.</dd>
* <dt>miter limit</dt><dd>An integer specifying the miter limit of a miter linejoin. If you want to specify a linejoin
* of miter, you simply specify the limit as opposed to having separate miter and miter limit values.</dd>
* </dl>
* </dd>
* </dl>
*
* @config stroke
* @type Object
*/
stroke: {
valueFn: "_getDefaultStroke",
setter: function(val)
{
var tmpl = this.get("stroke") || this._getDefaultStroke(),
wt;
if(val && val.hasOwnProperty("weight"))
{
wt = parseInt(val.weight, 10);
if(!isNaN(wt))
{
val.weight = wt;
}
}
return (val) ? Y.merge(tmpl, val) : null;
}
},
// Only implemented in SVG
// Determines whether the instance will receive mouse events.
//
// @config pointerEvents
// @type string
//
pointerEvents: {
valueFn: function()
{
var val = "visiblePainted",
node = this.node;
if(node)
{
node.setAttribute("pointer-events", val);
}
return val;
},
setter: function(val)
{
var node = this.node;
if(node)
{
node.setAttribute("pointer-events", val);
}
return val;
}
},
/**
* Dom node for the shape.
*
* @config node
* @type HTMLElement
* @readOnly
*/
node: {
readOnly: true,
getter: function()
{
return this.node;
}
},
/**
* Represents an SVG Path string. This will be parsed and added to shape's API to represent the SVG data across all
* implementations. Note that when using VML or SVG implementations, part of this content will be added to the DOM using
* respective VML/SVG attributes. If your content comes from an untrusted source, you will need to ensure that no
* malicious code is included in that content.
*
* @config data
* @type String
*/
data: {
setter: function(val)
{
if(this.get("node"))
{
this._parsePathData(val);
}
return val;
}
},
/**
* Reference to the parent graphic instance
*
* @config graphic
* @type SVGGraphic
* @readOnly
*/
graphic: {
readOnly: true,
getter: function()
{
return this._graphic;
}
}
};
Y.SVGShape = SVGShape;