Version 3.18.1
Show:

File: graphics/js/VMLShape.js

            /**
             * <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;