Show:
                            /**
                             * <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Shape.html">`Shape`</a> class.
                             * `VMLShape` 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> and <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 `VMLShape` class.
                             *
                             * @module graphics
                             * @class VMLShape
                             * @constructor
                             * @param {Object} cfg (optional) Attribute configs
                             */
                            VMLShape = function()
                            {
                                this._transforms = [];
                                this.matrix = new Y.Matrix();
                                this._normalizedMatrix = new Y.Matrix();
                                VMLShape.superclass.constructor.apply(this, arguments);
                            };
                            
                            VMLShape.NAME = "shape";
                            
                            Y.extend(VMLShape, Y.GraphicBase, Y.mix({
                            	/**
                            	 * Indicates the type of shape
                            	 *
                            	 * @property _type
                            	 * @type String
                                 * @private
                            	 */
                            	_type: "shape",
                            
                                /**
                                 * 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.createNode();
                                    if(graphic)
                                    {
                                        this._setGraphic(graphic);
                                    }
                                    if(data)
                                    {
                                        host._parsePathData(data);
                                    }
                                    this._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.VMLGraphic)
                                    {
                                        this._graphic = render;
                                    }
                                    else
                                    {
                                        graphic = new Y.VMLGraphic({
                                            render: render
                                        });
                                        graphic._appendShape(this);
                                        this._graphic = graphic;
                                        this._appendStrokeAndFill();
                                    }
                                },
                            
                                /**
                                 * Appends fill and stroke nodes to the shape.
                                 *
                                 * @method _appendStrokeAndFill
                                 * @private
                                 */
                                _appendStrokeAndFill: function()
                                {
                                    if(this._strokeNode)
                                    {
                                        this.node.appendChild(this._strokeNode);
                                    }
                                    if(this._fillNode)
                                    {
                                        this.node.appendChild(this._fillNode);
                                    }
                                },
                            
                            	/**
                            	 * Creates the dom node for the shape.
                            	 *
                                 * @method createNode
                            	 * @return HTMLElement
                            	 * @private
                            	 */
                            	createNode: function()
                            	{
                                    var node,
                                        concat = this._camelCaseConcat,
                            			x = this.get("x"),
                            			y = this.get("y"),
                                        w = this.get("width"),
                                        h = this.get("height"),
                            			id,
                            			type,
                            			name = this.name,
                                        nodestring,
                                        visibility = this.get("visible") ? "visible" : "hidden",
                            			strokestring,
                            			classString,
                            			stroke,
                            			endcap,
                            			opacity,
                            			joinstyle,
                            			miterlimit,
                            			dashstyle,
                            			fill,
                            			fillstring;
                            			id = this.get("id");
                            		type = this._type === "path" ? "shape" : this._type;
                                    classString = _getClassName(SHAPE) +
                                                " " +
                                                _getClassName(concat(IMPLEMENTATION, SHAPE)) +
                                                " " +
                                                _getClassName(name) +
                                                " " +
                                                _getClassName(concat(IMPLEMENTATION, name)) +
                                                " " +
                                                IMPLEMENTATION +
                                                type;
                                    stroke = this._getStrokeProps();
                                    fill = this._getFillProps();
                            
                            		nodestring  = '<' +
                                                    type +
                                                    '  xmlns="urn:schemas-microsft.com:vml" id="' +
                                                    id +
                                                    '" class="' +
                                                    classString +
                                                    '" style="behavior:url(#default#VML);display:inline-block;position:absolute;left:' +
                                                    x +
                                                    'px;top:' +
                                                    y +
                                                    'px;width:' +
                                                    w +
                                                    'px;height:' +
                                                    h +
                                                    'px;visibility:' +
                                                    visibility +
                                                    '"';
                            
                                    if(stroke && stroke.weight && stroke.weight > 0)
                                    {
                                        endcap = stroke.endcap;
                                        opacity = parseFloat(stroke.opacity);
                                        joinstyle = stroke.joinstyle;
                                        miterlimit = stroke.miterlimit;
                                        dashstyle = stroke.dashstyle;
                                        nodestring += ' stroked="t" strokecolor="' + stroke.color + '" strokeWeight="' + stroke.weight + 'px"';
                            
                                        strokestring = '<stroke class="vmlstroke"' +
                                                        ' xmlns="urn:schemas-microsft.com:vml"' +
                                                        ' on="t"' +
                                                        ' style="behavior:url(#default#VML);display:inline-block;"' +
                                                        ' opacity="' + opacity + '"';
                                        if(endcap)
                                        {
                                            strokestring += ' endcap="' + endcap + '"';
                                        }
                                        if(joinstyle)
                                        {
                                            strokestring += ' joinstyle="' + joinstyle + '"';
                                        }
                                        if(miterlimit)
                                        {
                                            strokestring += ' miterlimit="' + miterlimit + '"';
                                        }
                                        if(dashstyle)
                                        {
                                            strokestring += ' dashstyle="' + dashstyle + '"';
                                        }
                                        strokestring += '></stroke>';
                                        this._strokeNode = DOCUMENT.createElement(strokestring);
                                        nodestring += ' stroked="t"';
                                    }
                                    else
                                    {
                                        nodestring += ' stroked="f"';
                                    }
                                    if(fill)
                                    {
                                        if(fill.node)
                                        {
                                            fillstring = fill.node;
                                            this._fillNode = DOCUMENT.createElement(fillstring);
                                        }
                                        if(fill.color)
                                        {
                                            nodestring += ' fillcolor="' + fill.color + '"';
                                        }
                                        nodestring += ' filled="' + fill.filled + '"';
                                    }
                            
                            
                                    nodestring += '>';
                                    nodestring += '</' + type + '>';
                            
                                    node = DOCUMENT.createElement(nodestring);
                            
                                    this.node = node;
                                    this._strokeFlag = false;
                                    this._fillFlag = false;
                            	},
                            
                            	/**
                            	 * 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;
                            		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.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._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._graphic,
                            			parentXY = graphic.getXY();
                            		this.set("x", xy[0] - parentXY[0]);
                            		this.set("y", xy[1] - parentXY[1]);
                            	},
                            
                            	/**
                            	 * Determines whether the node is an ancestor of another HTML element in the DOM hierarchy.
                            	 *
                            	 * @method contains
                            	 * @param {VMLShape | 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);
                            	},
                            
                            	/**
                                 * Calculates and returns properties for setting an initial stroke.
                                 *
                                 * @method _getStrokeProps
                                 * @return Object
                                 *
                            	 * @private
                            	 */
                                _getStrokeProps: function()
                                {
                            		var props,
                            			stroke = this.get("stroke"),
                            			strokeOpacity,
                            			dashstyle,
                            			dash = "",
                            			val,
                            			i = 0,
                            			len,
                            			linecap,
                            			linejoin;
                                    if(stroke && stroke.weight && stroke.weight > 0)
                            		{
                            			props = {};
                            			linecap = stroke.linecap || "flat";
                            			linejoin = stroke.linejoin || "round";
                                        if(linecap !== "round" && linecap !== "square")
                                        {
                                            linecap = "flat";
                                        }
                            			strokeOpacity = parseFloat(stroke.opacity);
                            			dashstyle = stroke.dashstyle || "none";
                            			stroke.color = stroke.color || "#000000";
                            			stroke.weight = stroke.weight || 1;
                            			stroke.opacity = IS_NUM(strokeOpacity) ? strokeOpacity : 1;
                            			props.stroked = true;
                            			props.color = stroke.color;
                            			props.weight = stroke.weight;
                            			props.endcap = linecap;
                            			props.opacity = stroke.opacity;
                            			if(IS_ARRAY(dashstyle))
                            			{
                            				dash = [];
                            				len = dashstyle.length;
                            				for(i = 0; i < len; ++i)
                            				{
                            					val = dashstyle[i];
                            					dash[i] = val / stroke.weight;
                            				}
                            			}
                            			if(linejoin === "round" || linejoin === "bevel")
                            			{
                            				props.joinstyle = linejoin;
                            			}
                            			else
                            			{
                            				linejoin = parseInt(linejoin, 10);
                            				if(IS_NUM(linejoin))
                            				{
                            					props.miterlimit = Math.max(linejoin, 1);
                            					props.joinstyle = "miter";
                            				}
                            			}
                            			props.dashstyle = dash;
                                    }
                                    return props;
                                },
                            
                            	/**
                            	 * Adds a stroke to the shape node.
                            	 *
                            	 * @method _strokeChangeHandler
                            	 * @private
                            	 */
                            	_strokeChangeHandler: function()
                            	{
                                    if(!this._strokeFlag)
                                    {
                                        return;
                                    }
                                    var node = this.node,
                            			stroke = this.get("stroke"),
                            			strokeOpacity,
                            			dashstyle,
                            			dash = "",
                            			val,
                            			i = 0,
                            			len,
                            			linecap,
                            			linejoin;
                            		if(stroke && stroke.weight && stroke.weight > 0)
                            		{
                            			linecap = stroke.linecap || "flat";
                            			linejoin = stroke.linejoin || "round";
                            			if(linecap !== "round" && linecap !== "square")
                            			{
                            				linecap = "flat";
                            			}
                            			strokeOpacity = parseFloat(stroke.opacity);
                            			dashstyle = stroke.dashstyle || "none";
                            			stroke.color = stroke.color || "#000000";
                            			stroke.weight = stroke.weight || 1;
                            			stroke.opacity = IS_NUM(strokeOpacity) ? strokeOpacity : 1;
                            			node.stroked = true;
                            			node.strokeColor = stroke.color;
                            			node.strokeWeight = stroke.weight + "px";
                            			if(!this._strokeNode)
                            			{
                            				this._strokeNode = this._createGraphicNode("stroke");
                            				node.appendChild(this._strokeNode);
                            			}
                            			this._strokeNode.endcap = linecap;
                            			this._strokeNode.opacity = stroke.opacity;
                            			if(IS_ARRAY(dashstyle))
                            			{
                            				dash = [];
                            				len = dashstyle.length;
                            				for(i = 0; i < len; ++i)
                            				{
                            					val = dashstyle[i];
                            					dash[i] = val / stroke.weight;
                            				}
                            			}
                            			if(linejoin === "round" || linejoin === "bevel")
                            			{
                            				this._strokeNode.joinstyle = linejoin;
                            			}
                            			else
                            			{
                            				linejoin = parseInt(linejoin, 10);
                            				if(IS_NUM(linejoin))
                            				{
                            					this._strokeNode.miterlimit = Math.max(linejoin, 1);
                            					this._strokeNode.joinstyle = "miter";
                            				}
                            			}
                            			this._strokeNode.dashstyle = dash;
                                        this._strokeNode.on = true;
                            		}
                            		else
                            		{
                                        if(this._strokeNode)
                                        {
                                            this._strokeNode.on = false;
                                        }
                            			node.stroked = false;
                            		}
                                    this._strokeFlag = false;
                            	},
                            
                            	/**
                                 * Calculates and returns properties for setting an initial fill.
                                 *
                                 * @method _getFillProps
                                 * @return Object
                                 *
                            	 * @private
                            	 */
                            	_getFillProps: function()
                            	{
                            		var fill = this.get("fill"),
                            			fillOpacity,
                            			props,
                            			gradient,
                            			i,
                            			fillstring,
                            			filled = false;
                            		if(fill)
                            		{
                            			props = {};
                            
                            			if(fill.type === "radial" || fill.type === "linear")
                            			{
                            				fillOpacity = parseFloat(fill.opacity);
                            				fillOpacity = IS_NUM(fillOpacity) ? fillOpacity : 1;
                            				filled = true;
                            				gradient = this._getGradientFill(fill);
                            				fillstring = '<fill xmlns="urn:schemas-microsft.com:vml"' +
                                                        ' class="vmlfill" style="behavior:url(#default#VML);display:inline-block;"' +
                                                        ' opacity="' + fillOpacity + '"';
                            				for(i in gradient)
                            				{
                            					if(gradient.hasOwnProperty(i))
                            					{
                            						fillstring += ' ' + i + '="' + gradient[i] + '"';
                            					}
                            				}
                            				fillstring += ' />';
                            				props.node = fillstring;
                            			}
                            			else if(fill.color)
                            			{
                            				fillOpacity = parseFloat(fill.opacity);
                            				filled = true;
                                            props.color = fill.color;
                            				if(IS_NUM(fillOpacity))
                            				{
                            					fillOpacity = Math.max(Math.min(fillOpacity, 1), 0);
                                                props.opacity = fillOpacity;
                                                if(fillOpacity < 1)
                                                {
                                                    props.node = '<fill xmlns="urn:schemas-microsft.com:vml"' +
                                                    ' class="vmlfill" style="behavior:url(#default#VML);display:inline-block;"' +
                                                    ' type="solid" opacity="' + fillOpacity + '"/>';
                                                }
                                            }
                            			}
                            			props.filled = filled;
                            		}
                            		return props;
                            	},
                            
                            	/**
                            	 * Adds a fill to the shape node.
                            	 *
                            	 * @method _fillChangeHandler
                            	 * @private
                            	 */
                            	_fillChangeHandler: function()
                            	{
                                    if(!this._fillFlag)
                                    {
                                        return;
                                    }
                            		var node = this.node,
                            			fill = this.get("fill"),
                            			fillOpacity,
                            			fillstring,
                            			filled = false,
                                        i,
                                        gradient;
                            		if(fill)
                            		{
                            			if(fill.type === "radial" || fill.type === "linear")
                            			{
                            				filled = true;
                            				gradient = this._getGradientFill(fill);
                                            if(this._fillNode)
                                            {
                                                for(i in gradient)
                                                {
                                                    if(gradient.hasOwnProperty(i))
                                                    {
                                                        if(i === "colors")
                                                        {
                                                            this._fillNode.colors.value = gradient[i];
                                                        }
                                                        else
                                                        {
                                                            this._fillNode[i] = gradient[i];
                                                        }
                                                    }
                                                }
                                            }
                                            else
                                            {
                                                fillstring = '<fill xmlns="urn:schemas-microsft.com:vml"' +
                                                            ' class="vmlfill"' +
                                                            ' style="behavior:url(#default#VML);display:inline-block;"';
                                                for(i in gradient)
                                                {
                                                    if(gradient.hasOwnProperty(i))
                                                    {
                                                        fillstring += ' ' + i + '="' + gradient[i] + '"';
                                                    }
                                                }
                                                fillstring += ' />';
                                                this._fillNode = DOCUMENT.createElement(fillstring);
                                                node.appendChild(this._fillNode);
                                            }
                            			}
                            			else if(fill.color)
                            			{
                                            node.fillcolor = fill.color;
                            				fillOpacity = parseFloat(fill.opacity);
                            				filled = true;
                            				if(IS_NUM(fillOpacity) && fillOpacity < 1)
                            				{
                            					fill.opacity = fillOpacity;
                                                if(this._fillNode)
                            					{
                                                    if(this._fillNode.getAttribute("type") !== "solid")
                                                    {
                                                        this._fillNode.type = "solid";
                                                    }
                            						this._fillNode.opacity = fillOpacity;
                            					}
                            					else
                            					{
                                                    fillstring = '<fill xmlns="urn:schemas-microsft.com:vml"' +
                                                    ' class="vmlfill"' +
                                                    ' style="behavior:url(#default#VML);display:inline-block;"' +
                                                    ' type="solid"' +
                                                    ' opacity="' + fillOpacity + '"' +
                                                    '/>';
                                                    this._fillNode = DOCUMENT.createElement(fillstring);
                                                    node.appendChild(this._fillNode);
                            					}
                            				}
                            				else if(this._fillNode)
                                            {
                                                this._fillNode.opacity = 1;
                                                this._fillNode.type = "solid";
                            				}
                            			}
                            		}
                            		node.filled = filled;
                                    this._fillFlag = false;
                            	},
                            
                            	//not used. remove next release.
                                _updateFillNode: function(node)
                            	{
                            		if(!this._fillNode)
                            		{
                            			this._fillNode = this._createGraphicNode("fill");
                            			node.appendChild(this._fillNode);
                            		}
                            	},
                            
                                /**
                                 * Calculates and returns an object containing gradient properties for a fill node.
                                 *
                                 * @method _getGradientFill
                                 * @param {Object} fill Object containing fill properties.
                                 * @return Object
                                 * @private
                                 */
                            	_getGradientFill: function(fill)
                            	{
                            		var gradientProps = {},
                            			gradientBoxWidth,
                            			gradientBoxHeight,
                            			type = fill.type,
                            			w = this.get("width"),
                            			h = this.get("height"),
                            			isNumber = IS_NUM,
                            			stop,
                            			stops = fill.stops,
                            			len = stops.length,
                            			opacity,
                            			color,
                            			i,
                            			oi,
                            			colorstring = "",
                            			cx = fill.cx,
                            			cy = fill.cy,
                            			fx = fill.fx,
                            			fy = fill.fy,
                            			r = fill.r,
                                        pct,
                            			rotation = fill.rotation || 0;
                            		if(type === "linear")
                            		{
                                        if(rotation <= 270)
                                        {
                                            rotation = Math.abs(rotation - 270);
                                        }
                            			else if(rotation < 360)
                                        {
                                            rotation = 270 + (360 - rotation);
                                        }
                                        else
                                        {
                                            rotation = 270;
                                        }
                                        gradientProps.type = "gradient";//"gradientunscaled";
                            			gradientProps.angle = rotation;
                            		}
                            		else if(type === "radial")
                            		{
                            			gradientBoxWidth = w * (r * 2);
                            			gradientBoxHeight = h * (r * 2);
                            			fx = r * 2 * (fx - 0.5);
                            			fy = r * 2 * (fy - 0.5);
                            			fx += cx;
                            			fy += cy;
                            			gradientProps.focussize = (gradientBoxWidth/w)/10 + "% " + (gradientBoxHeight/h)/10 + "%";
                            			gradientProps.alignshape = false;
                            			gradientProps.type = "gradientradial";
                            			gradientProps.focus = "100%";
                            			gradientProps.focusposition = Math.round(fx * 100) + "% " + Math.round(fy * 100) + "%";
                            		}
                            		for(i = 0;i < len; ++i) {
                            			stop = stops[i];
                            			color = stop.color;
                            			opacity = stop.opacity;
                            			opacity = isNumber(opacity) ? opacity : 1;
                            			pct = stop.offset || i/(len-1);
                            			pct *= (r * 2);
                                        pct = Math.round(100 * pct) + "%";
                                        oi = i > 0 ? i + 1 : "";
                                        gradientProps["opacity" + oi] = opacity + "";
                                        colorstring += ", " + pct + " " + color;
                            		}
                            		if(parseFloat(pct) < 100)
                            		{
                            			colorstring += ", 100% " + color;
                            		}
                            		gradientProps.colors = colorstring.substr(2);
                            		return gradientProps;
                            	},
                            
                                /**
                                 * 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,
                                        x = this.get("x"),
                                        y = this.get("y"),
                                        tx,
                                        ty,
                                        matrix = this.matrix,
                                        normalizedMatrix = this._normalizedMatrix,
                                        isPathShape = this instanceof Y.VMLPath,
                                        i,
                                        len = this._transforms.length;
                                    if(this._transforms && this._transforms.length > 0)
                            		{
                                        transformOrigin = this.get("transformOrigin");
                            
                                        if(isPathShape)
                                        {
                                            normalizedMatrix.translate(this._left, this._top);
                                        }
                                        //vml skew matrix transformOrigin ranges from -0.5 to 0.5.
                                        //subtract 0.5 from values
                                        tx = transformOrigin[0] - 0.5;
                                        ty = transformOrigin[1] - 0.5;
                            
                                        //ensure the values are within the appropriate range to avoid errors
                                        tx = Math.max(-0.5, Math.min(0.5, tx));
                                        ty = Math.max(-0.5, Math.min(0.5, 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(isPathShape)
                                        {
                                            normalizedMatrix.translate(-this._left, -this._top);
                                        }
                                        transform = normalizedMatrix.a + "," +
                                                    normalizedMatrix.c + "," +
                                                    normalizedMatrix.b + "," +
                                                    normalizedMatrix.d + "," +
                                                    0 + "," +
                                                    0;
                            		}
                                    this._graphic.addToRedrawQueue(this);
                                    if(transform)
                                    {
                                        if(!this._skew)
                                        {
                                            this._skew = DOCUMENT.createElement(
                                                '<skew class="vmlskew"' +
                                                ' xmlns="urn:schemas-microsft.com:vml"' +
                                                ' on="false"' +
                                                ' style="behavior:url(#default#VML);display:inline-block;"' +
                                                '/>'
                                            );
                                            this.node.appendChild(this._skew);
                                        }
                                        this._skew.matrix = transform;
                                        this._skew.on = true;
                                        //this._skew.offset = this._getSkewOffsetValue(normalizedMatrix.dx) + "px, " + this._getSkewOffsetValue(normalizedMatrix.dy) + "px";
                                        this._skew.origin = tx + ", " + ty;
                                    }
                                    if(this._type !== "path")
                                    {
                                        this._transforms = [];
                                    }
                                    //add the translate to the x and y coordinates
                                    node.style.left = (x + this._getSkewOffsetValue(normalizedMatrix.dx)) + "px";
                                    node.style.top =  (y + this._getSkewOffsetValue(normalizedMatrix.dy)) + "px";
                                },
                            
                                /**
                                 * Normalizes the skew offset values between -32767 and 32767.
                                 *
                                 * @method _getSkewOffsetValue
                                 * @param {Number} val The value to normalize
                                 * @return Number
                                 * @private
                                 */
                                _getSkewOffsetValue: function(val)
                                {
                                    var sign = Y.MatrixUtil.sign(val),
                                        absVal = Math.abs(val);
                                    val = Math.min(absVal, 32767) * sign;
                                    return val;
                                },
                            
                            	/**
                            	 * Storage for translateX
                            	 *
                                 * @property _translateX
                                 * @type Number
                            	 * @private
                            	 */
                            	_translateX: 0,
                            
                            	/**
                            	 * Storage for translateY
                            	 *
                                 * @property _translateY
                                 * @type Number
                            	 * @private
                            	 */
                            	_translateY: 0,
                            
                                /**
                                 * Storage for the transform attribute.
                                 *
                                 * @property _transform
                                 * @type String
                                 * @private
                                 */
                                _transform: "",
                            
                                /**
                            	 * Specifies a 2d translation.
                            	 *
                            	 * @method translate
                            	 * @param {Number} x The value to translate 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);
                                },
                            
                            	/**
                                 * 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);
                            	},
                            
                            	/**
                            	 * Draws the shape.
                            	 *
                            	 * @method _draw
                            	 * @private
                            	 */
                            	_draw: function()
                            	{
                            	},
                            
                            	/**
                                 * Updates `Shape` based on attribute changes.
                                 *
                                 * @method _updateHandler
                            	 * @private
                            	 */
                            	_updateHandler: function()
                            	{
                            		var host = this,
                                        node = host.node;
                                    host._fillChangeHandler();
                                    host._strokeChangeHandler();
                                    node.style.width = this.get("width") + "px";
                                    node.style.height = this.get("height") + "px";
                                    this._draw();
                            		host._updateTransform();
                            	},
                            
                            	/**
                            	 * Creates a graphic node
                            	 *
                            	 * @method _createGraphicNode
                            	 * @param {String} type node type to create
                            	 * @return HTMLElement
                            	 * @private
                            	 */
                            	_createGraphicNode: function(type)
                            	{
                            		type = type || this._type;
                            		return DOCUMENT.createElement(
                                            '<' + type +
                                            ' xmlns="urn:schemas-microsft.com:vml"' +
                                            ' style="behavior:url(#default#VML);display:inline-block;"' +
                                            ' class="vml' + type + '"' +
                                            '/>'
                                        );
                            	},
                            
                            	/**
                            	 * 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
                            		};
                            	},
                            
                                /**
                                 * 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();
                            		}
                            	},
                            
                            	/**
                            	 * 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 isPathShape = this instanceof Y.VMLPath,
                            			w = this.get("width"),
                            			h = this.get("height"),
                                        x = this.get("x"),
                                        y = this.get("y");
                                    if(isPathShape)
                                    {
                                        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,
                                        isPathShape = this instanceof Y.VMLPath;
                                    if(isPathShape)
                                    {
                                        matrix.translate(this._left, this._top);
                                    }
                                    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);
                                    if(isPathShape)
                                    {
                                        matrix.translate(-this._left, -this._top);
                                    }
                                    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 shape
                                 *
                                 *  @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)
                                    {
                                        if(this._fillNode)
                                        {
                                            this.node.removeChild(this._fillNode);
                                            this._fillNode = null;
                                        }
                                        if(this._strokeNode)
                                        {
                                            this.node.removeChild(this._strokeNode);
                                            this._strokeNode = null;
                                        }
                                        Y.Event.purgeElement(this.node, true);
                                        if(this.node.parentNode)
                                        {
                                            this.node.parentNode.removeChild(this.node);
                                        }
                                        this.node = null;
                                    }
                                }
                            }, Y.VMLDrawing.prototype));
                            
                            VMLShape.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)
                            		{
                                        var i,
                                            len,
                                            transform;
                                        this.matrix.init();
                                        this._normalizedMatrix.init();
                                        this._transforms = this.matrix.getTransformArray(val);
                                        len = this._transforms.length;
                                        for(i = 0;i < len; ++i)
                                        {
                                            transform = this._transforms[i];
                                        }
                                        this._transform = val;
                                        return val;
                            		},
                            
                                    getter: function()
                                    {
                                        return this._transform;
                                    }
                            	},
                            
                            	/**
                            	 * 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
                            	},
                            
                            	/**
                            	 * 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;
                            		}
                            	},
                            
                            	/**
                            	 *
                            	 * @config width
                            	 */
                            	width: {
                            		value: 0
                            	},
                            
                            	/**
                            	 *
                            	 * @config height
                            	 */
                            	height: {
                            		value: 0
                            	},
                            
                            	/**
                            	 * Indicates whether the shape is visible.
                            	 *
                            	 * @config visible
                            	 * @type Boolean
                            	 */
                            	visible: {
                            		value: true,
                            
                            		setter: function(val){
                            			var node = this.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 i,
                            				fill,
                            				tmpl = this.get("fill") || this._getDefaultFill();
                            
                            			if(val)
                            			{
                            				//ensure, fill type is solid if color is explicitly passed.
                            				if(val.hasOwnProperty("color"))
                            				{
                            					val.type = "solid";
                            				}
                            				for(i in val)
                            				{
                            					if(val.hasOwnProperty(i))
                            					{
                            						tmpl[i] = val[i];
                            					}
                            				}
                            			}
                            			fill = tmpl;
                            			if(fill && fill.color)
                            			{
                            				if(fill.color === undefined || fill.color === "none")
                            				{
                                                fill.color = null;
                            				}
                                            else
                                            {
                                                if(fill.color.toLowerCase().indexOf("rgba") > -1)
                                                {
                                                    fill.opacity = Y.Color._getAlpha(fill.color);
                                                    fill.color =  Y.Color.toHex(fill.color);
                                                }
                                            }
                            			}
                            			this._fillFlag = true;
                                        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 i,
                            				stroke,
                                            wt,
                            				tmpl = this.get("stroke") || this._getDefaultStroke();
                            			if(val)
                            			{
                                            if(val.hasOwnProperty("weight"))
                                            {
                                                wt = parseInt(val.weight, 10);
                                                if(!isNaN(wt))
                                                {
                                                    val.weight = wt;
                                                }
                                            }
                            				for(i in val)
                            				{
                            					if(val.hasOwnProperty(i))
                            					{
                            						tmpl[i] = val[i];
                            					}
                            				}
                            			}
                                        if(tmpl.color && tmpl.color.toLowerCase().indexOf("rgba") > -1)
                                        {
                                           tmpl.opacity = Y.Color._getAlpha(tmpl.color);
                                           tmpl.color =  Y.Color.toHex(tmpl.color);
                                        }
                            			stroke = tmpl;
                                        this._strokeFlag = true;
                            			return stroke;
                            		}
                            	},
                            
                            	//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"
                            	},
                            
                            	/**
                            	 * 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 container Graphic.
                            	 *
                            	 * @config graphic
                            	 * @type Graphic
                            	 */
                            	graphic: {
                            		readOnly: true,
                            
                            		getter: function()
                            		{
                            			return this._graphic;
                            		}
                            	}
                            };
                            Y.VMLShape = VMLShape;