#

API Docs for: 3.10.3
Show: Inherited Protected Private Deprecated

# 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
            {
                render = Y.one(render);
                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)
    	{
    		return needle === Y.one(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.one("#" +  this.get("id")).on(type, fn);
    		}
    		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.one(this.node).remove(true);
            }
        }
    }, 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;
    				}
    			}
    			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];
    					}
    				}
    			}
    			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;