File yui3/src/graphics/js/CanvasShape.js
/**
* <a href="http://www.w3.org/TR/html5/the-canvas-element.html">Canvas</a> implementation of the <a href="Shape.html">`Shape`</a> class.
* `CanvasShape` is not intended to be used directly. Instead, use the <a href="Shape.html">`Shape`</a> class.
* If the browser lacks <a href="http://www.w3.org/TR/SVG/">SVG</a> capabilities but has
* <a href="http://www.w3.org/TR/html5/the-canvas-element.html">Canvas</a> capabilities, the <a href="Shape.html">`Shape`</a>
* class will point to the `CanvasShape` class.
*
* @module graphics
* @class CanvasShape
* @constructor
*/
CanvasShape = function()
{
this._transforms = [];
this.matrix = new Y.Matrix();
CanvasShape.superclass.constructor.apply(this, arguments);
};
CanvasShape.NAME = "shape";
Y.extend(CanvasShape, Y.GraphicBase, Y.mix({
/**
* Init method, invoked during construction.
* Calls `initializer` method.
*
* @method init
* @protected
*/
init: function()
{
this.initializer.apply(this, arguments);
},
/**
* Initializes the shape
*
* @private
* @method _initialize
*/
initializer: function(cfg)
{
var host = this,
graphic = cfg.graphic,
data = this.get("data");
host._initProps();
host.createNode();
host._xcoords = [0];
host._ycoords = [0];
if(graphic)
{
this._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.CanvasGraphic)
{
this._graphic = render;
}
else
{
graphic = new Y.CanvasGraphic({
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.get("node");
Y.DOM.addClass(node, className);
},
/**
* 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.get("node");
Y.DOM.removeClass(node, className);
},
/**
* 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.get("graphic"),
parentXY = graphic.getXY(),
x = this.get("x"),
y = this.get("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.get("graphic"),
parentXY = graphic.getXY(),
x = xy[0] - parentXY[0],
y = xy[1] - parentXY[1];
this._set("x", x);
this._set("y", y);
this._updateNodePosition(x, y);
},
/**
* Determines whether the node is an ancestor of another HTML element in the DOM hierarchy.
*
* @method contains
* @param {CanvasShape | 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;
},
/**
* 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);
},
/**
* 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;
},
/**
* Value function for fill attribute
*
* @method _getDefaultFill
* @return Object
* @private
*/
_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
*
* @method _getDefaultStroke
* @return Object
* @private
*/
_getDefaultStroke: function()
{
return {
weight: 1,
dashstyle: "none",
color: "#000",
opacity: 1.0
};
},
/**
* 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,
/**
* Creates the dom node for the shape.
*
* @method createNode
* @return HTMLElement
* @private
*/
createNode: function()
{
var host = this,
node = Y.config.doc.createElement('canvas'),
id = host.get("id"),
concat = host._camelCaseConcat,
name = host.name;
host._context = node.getContext('2d');
node.setAttribute("overflow", "visible");
node.style.overflow = "visible";
if(!host.get("visible"))
{
node.style.visibility = "hidden";
}
node.setAttribute("id", id);
id = "#" + id;
host.node = node;
host.addClass(
_getClassName(SHAPE) +
" " +
_getClassName(concat(IMPLEMENTATION, SHAPE)) +
" " +
_getClassName(name) +
" " +
_getClassName(concat(IMPLEMENTATION, name))
);
},
/**
* 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
* @param {Object} stroke Properties of the `stroke` attribute.
* @private
*/
_setStrokeProps: function(stroke)
{
var color,
weight,
opacity,
linejoin,
linecap,
dashstyle;
if(stroke)
{
color = stroke.color;
weight = PARSE_FLOAT(stroke.weight);
opacity = PARSE_FLOAT(stroke.opacity);
linejoin = stroke.linejoin || "round";
linecap = stroke.linecap || "butt";
dashstyle = stroke.dashstyle;
this._miterlimit = null;
this._dashstyle = (dashstyle && Y.Lang.isArray(dashstyle) && dashstyle.length > 1) ? dashstyle : null;
this._strokeWeight = weight;
if (IS_NUMBER(weight) && weight > 0)
{
this._stroke = 1;
}
else
{
this._stroke = 0;
}
if (IS_NUMBER(opacity)) {
this._strokeStyle = this._toRGBA(color, opacity);
}
else
{
this._strokeStyle = color;
}
this._linecap = linecap;
if(linejoin === "round" || linejoin === "bevel")
{
this._linejoin = linejoin;
}
else
{
linejoin = parseInt(linejoin, 10);
if(IS_NUMBER(linejoin))
{
this._miterlimit = Math.max(linejoin, 1);
this._linejoin = "miter";
}
}
}
else
{
this._stroke = 0;
}
},
/**
* 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();
}
},
/**
* Adds a fill to the shape node.
*
* @method _setFillProps
* @param {Object} fill Properties of the `fill` attribute.
* @private
*/
_setFillProps: function(fill)
{
var isNumber = IS_NUMBER,
color,
opacity,
type;
if(fill)
{
color = fill.color;
type = fill.type;
if(type === "linear" || type === "radial")
{
this._fillType = type;
}
else if(color)
{
opacity = fill.opacity;
if (isNumber(opacity))
{
opacity = Math.max(0, Math.min(1, opacity));
color = this._toRGBA(color, opacity);
}
else
{
color = TORGB(color);
}
this._fillColor = color;
this._fillType = 'solid';
}
else
{
this._fillColor = null;
}
}
else
{
this._fillType = null;
this._fillColor = null;
}
},
/**
* 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(x, y)
{
this._translateX += x;
this._translateY += y;
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(x)
{
this._translateX += x;
this._addTransform("translateX", arguments);
},
/**
* Performs a translate on the y-coordinate. When translating x and y coordinates,
* use the `translate` method.
*
* @method translateY
* @param {Number} y The value to translate.
*/
translateY: function(y)
{
this._translateY += y;
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);
},
/**
* Storage for the transform attribute.
*
* @property _transform
* @type String
* @private
*/
_transform: "",
/**
* 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 node = this.node,
key,
transform,
transformOrigin = this.get("transformOrigin"),
matrix = this.matrix,
i,
len = this._transforms.length;
if(this._transforms && this._transforms.length > 0)
{
for(i = 0; i < len; ++i)
{
key = this._transforms[i].shift();
if(key)
{
matrix[key].apply(matrix, this._transforms[i]);
}
}
transform = matrix.toCSSText();
}
this._graphic.addToRedrawQueue(this);
transformOrigin = (100 * transformOrigin[0]) + "% " + (100 * transformOrigin[1]) + "%";
Y_DOM.setStyle(node, "transformOrigin", transformOrigin);
if(transform)
{
Y_DOM.setStyle(node, "transform", transform);
}
this._transforms = [];
},
/**
* Updates `Shape` based on attribute changes.
*
* @method _updateHandler
* @private
*/
_updateHandler: function()
{
this._draw();
this._updateTransform();
},
/**
* Updates the shape.
*
* @method _draw
* @private
*/
_draw: function()
{
var node = this.node;
this.clear();
this._closePath();
node.style.left = this.get("x") + "px";
node.style.top = this.get("y") + "px";
},
/**
* Completes a shape or drawing
*
* @method _closePath
* @private
*/
_closePath: function()
{
if(!this._methods)
{
return;
}
var node = this.get("node"),
w = this._right - this._left,
h = this._bottom - this._top,
context = this._context,
methods = [],
cachedMethods = this._methods.concat(),
i,
j,
method,
args,
argsLen,
len = 0;
this._context.clearRect(0, 0, node.width, node.height);
if(this._methods)
{
len = cachedMethods.length;
if(!len || len < 1)
{
return;
}
for(i = 0; i < len; ++i)
{
methods[i] = cachedMethods[i].concat();
args = methods[i];
argsLen = (args[0] === "quadraticCurveTo" || args[0] === "bezierCurveTo") ? args.length : 3;
for(j = 1; j < argsLen; ++j)
{
if(j % 2 === 0)
{
args[j] = args[j] - this._top;
}
else
{
args[j] = args[j] - this._left;
}
}
}
node.setAttribute("width", Math.min(w, 2000));
node.setAttribute("height", Math.min(2000, h));
context.beginPath();
for(i = 0; i < len; ++i)
{
args = methods[i].concat();
if(args && args.length > 0)
{
method = args.shift();
if(method)
{
if(method === "closePath")
{
context.closePath();
this._strokeAndFill(context);
}
else if(method && method === "lineTo" && this._dashstyle)
{
args.unshift(this._xcoords[i] - this._left, this._ycoords[i] - this._top);
this._drawDashedLine.apply(this, args);
}
else
{
context[method].apply(context, args);
}
}
}
}
this._strokeAndFill(context);
this._drawingComplete = true;
this._clearAndUpdateCoords();
this._updateNodePosition();
this._methods = cachedMethods;
}
},
/**
* Completes a stroke and/or fill operation on the context.
*
* @method _strokeAndFill
* @param {Context} Reference to the context element of the canvas instance.
* @private
*/
_strokeAndFill: function(context)
{
if (this._fillType)
{
if(this._fillType === "linear")
{
context.fillStyle = this._getLinearGradient();
}
else if(this._fillType === "radial")
{
context.fillStyle = this._getRadialGradient();
}
else
{
context.fillStyle = this._fillColor;
}
context.closePath();
context.fill();
}
if (this._stroke) {
if(this._strokeWeight)
{
context.lineWidth = this._strokeWeight;
}
context.lineCap = this._linecap;
context.lineJoin = this._linejoin;
if(this._miterlimit)
{
context.miterLimit = this._miterlimit;
}
context.strokeStyle = this._strokeStyle;
context.stroke();
}
},
/**
* Draws a dashed line between two points.
*
* @method _drawDashedLine
* @param {Number} xStart The x position of the start of the line
* @param {Number} yStart The y position of the start of the line
* @param {Number} xEnd The x position of the end of the line
* @param {Number} yEnd The y position of the end of the line
* @private
*/
_drawDashedLine: function(xStart, yStart, xEnd, yEnd)
{
var context = this._context,
dashsize = this._dashstyle[0],
gapsize = this._dashstyle[1],
segmentLength = dashsize + gapsize,
xDelta = xEnd - xStart,
yDelta = yEnd - yStart,
delta = Math.sqrt(Math.pow(xDelta, 2) + Math.pow(yDelta, 2)),
segmentCount = Math.floor(Math.abs(delta / segmentLength)),
radians = Math.atan2(yDelta, xDelta),
xCurrent = xStart,
yCurrent = yStart,
i;
xDelta = Math.cos(radians) * segmentLength;
yDelta = Math.sin(radians) * segmentLength;
for(i = 0; i < segmentCount; ++i)
{
context.moveTo(xCurrent, yCurrent);
context.lineTo(xCurrent + Math.cos(radians) * dashsize, yCurrent + Math.sin(radians) * dashsize);
xCurrent += xDelta;
yCurrent += yDelta;
}
context.moveTo(xCurrent, yCurrent);
delta = Math.sqrt((xEnd - xCurrent) * (xEnd - xCurrent) + (yEnd - yCurrent) * (yEnd - yCurrent));
if(delta > dashsize)
{
context.lineTo(xCurrent + Math.cos(radians) * dashsize, yCurrent + Math.sin(radians) * dashsize);
}
else if(delta > 0)
{
context.lineTo(xCurrent + Math.cos(radians) * delta, yCurrent + Math.sin(radians) * delta);
}
context.moveTo(xEnd, yEnd);
},
/**
* 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,
w = this.get("width"),
h = this.get("height"),
x = this.get("x"),
y = this.get("y");
if(type === "path")
{
x = x + this._left;
y = y + this._top;
w = this._right - this._left;
h = this._bottom - this._top;
}
return this._getContentRect(w, h, x, y);
},
/**
* Calculates the bounding box for the shape.
*
* @method _getContentRect
* @param {Number} w width of the shape
* @param {Number} h height of the shape
* @param {Number} x x-coordinate of the shape
* @param {Number} y y-coordinate of the shape
* @private
*/
_getContentRect: function(w, h, x, y)
{
var transformOrigin = this.get("transformOrigin"),
transformX = transformOrigin[0] * w,
transformY = transformOrigin[1] * h,
transforms = this.matrix.getTransformArray(this.get("transform")),
matrix = new Y.Matrix(),
i,
len = transforms.length,
transform,
key,
contentRect;
if(this._type === "path")
{
transformX = transformX + x;
transformY = transformY + y;
}
transformX = !isNaN(transformX) ? transformX : 0;
transformY = !isNaN(transformY) ? transformY : 0;
matrix.translate(transformX, transformY);
for(i = 0; i < len; i = i + 1)
{
transform = transforms[i];
key = transform.shift();
if(key)
{
matrix[key].apply(matrix, transform);
}
}
matrix.translate(-transformX, -transformY);
contentRect = matrix.getContentRect(w, h, x, y);
return contentRect;
},
/**
* 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.style.visibility = "";
this.node.parentNode.removeChild(this.node);
}
this._context = null;
this.node = null;
}
}
}, Y.CanvasDrawing.prototype));
CanvasShape.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._transforms = this.matrix.getTransformArray(val);
this._transform = val;
return val;
},
getter: function()
{
return this._transform;
}
},
/**
* Dom node for the shape
*
* @config node
* @type HTMLElement
* @readOnly
*/
node: {
readOnly: true,
getter: function()
{
return this.node;
}
},
/**
* 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 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 the x position of shape.
*
* @config x
* @type Number
*/
x: {
value: 0
},
/**
* Indicates the y position of shape.
*
* @config y
* @type Number
*/
y: {
value: 0
},
/**
* Indicates whether the shape is visible.
*
* @config visible
* @type Boolean
*/
visible: {
value: true,
setter: function(val){
var node = this.get("node"),
visibility = val ? "visible" : "hidden";
if(node)
{
node.style.visibility = visibility;
}
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>
* </dl>
* <p>The corresponding `SVGShape` class implements the following additional properties.</p>
* <dl>
* <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>
* <p>These properties are not currently implemented in `CanvasShape` or `VMLShape`.</p>
*
* @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;
}
}
this._setFillProps(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.
* <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;
}
}
val = (val) ? Y.merge(tmpl, val) : null;
this._setStrokeProps(val);
return val;
}
},
//Not used. Remove in future.
autoSize: {
value: false
},
// Only implemented in SVG
// Determines whether the instance will receive mouse events.
//
// @config pointerEvents
// @type string
//
pointerEvents: {
value: "visiblePainted"
},
/**
* 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 container Graphic.
*
* @config graphic
* @type Graphic
*/
graphic: {
readOnly: true,
getter: function()
{
return this._graphic;
}
}
};
Y.CanvasShape = CanvasShape;