Version 3.18.1
Show:

File: 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;