YUI.add('graphics-vml', function (Y, NAME) {

var IMPLEMENTATION = "vml",

    SHAPE = "shape",

	SPLITPATHPATTERN = /[a-z][^a-z]*/ig,

    SPLITARGSPATTERN = /[\-]?[0-9]*[0-9|\.][0-9]*/g,

    Y_LANG = Y.Lang,

    IS_NUM = Y_LANG.isNumber,

    IS_ARRAY = Y_LANG.isArray,

    Y_DOM = Y.DOM,

    Y_SELECTOR = Y.Selector,

    DOCUMENT = Y.config.doc,

    AttributeLite = Y.AttributeLite,

	VMLShape,

	VMLCircle,

	VMLPath,

	VMLRect,

	VMLEllipse,

	VMLGraphic,

    VMLPieSlice,

    _getClassName = Y.ClassNameManager.getClassName;

function VMLDrawing() {}

/**

 * <a href="http://www.w3.org/TR/NOTE-VML">VML</a> implementation of the <a href="Drawing.html">`Drawing`</a> class.

 * `VMLDrawing` is not intended to be used directly. Instead, use the <a href="Drawing.html">`Drawing`</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="Drawing.html">`Drawing`</a> class will point to the `VMLDrawing` class.

 *

 * @module graphics

 * @class VMLDrawing

 * @constructor

 */

VMLDrawing.prototype = {

    /**

     * Maps path to methods

     *

     * @property _pathSymbolToMethod

     * @type Object

     * @private

     */

    _pathSymbolToMethod: {

        M: "moveTo",

        m: "relativeMoveTo",

        L: "lineTo",

        l: "relativeLineTo",

        C: "curveTo",

        c: "relativeCurveTo",

        Q: "quadraticCurveTo",

        q: "relativeQuadraticCurveTo",

        z: "closePath",

        Z: "closePath"

    },

    /**

     * Value for rounding up to coordsize

     *

     * @property _coordSpaceMultiplier

     * @type Number

     * @private

     */

    _coordSpaceMultiplier: 100,

    /**

     * Rounds dimensions and position values based on the coordinate space.

     *

     * @method _round

     * @param {Number} The value for rounding

     * @return Number

     * @private

     */

    _round:function(val)

    {

        return Math.round(val * this._coordSpaceMultiplier);

    },

    /**

     * Concatanates the path.

     *

     * @method _addToPath

     * @param {String} val The value to add to the path string.

     * @private

     */

    _addToPath: function(val)

    {

        this._path = this._path || "";

        if(this._movePath)

        {

            this._path += this._movePath;

            this._movePath = null;

        }

        this._path += val;

    },

    /**

     * Current x position of the drawing.

     *

     * @property _currentX

     * @type Number

     * @private

     */

    _currentX: 0,

    /**

     * Current y position of the drqwing.

     *

     * @property _currentY

     * @type Number

     * @private

     */

    _currentY: 0,

    /**

     * Draws a bezier curve.

     *

     * @method curveTo

     * @param {Number} cp1x x-coordinate for the first control point.

     * @param {Number} cp1y y-coordinate for the first control point.

     * @param {Number} cp2x x-coordinate for the second control point.

     * @param {Number} cp2y y-coordinate for the second control point.

     * @param {Number} x x-coordinate for the end point.

     * @param {Number} y y-coordinate for the end point.

     * @chainable

     */

    curveTo: function() {

        this._curveTo.apply(this, [Y.Array(arguments), false]);

        return this;

    },

    /**

     * Draws a bezier curve.

     *

     * @method relativeCurveTo

     * @param {Number} cp1x x-coordinate for the first control point.

     * @param {Number} cp1y y-coordinate for the first control point.

     * @param {Number} cp2x x-coordinate for the second control point.

     * @param {Number} cp2y y-coordinate for the second control point.

     * @param {Number} x x-coordinate for the end point.

     * @param {Number} y y-coordinate for the end point.

     * @chainable

     */

    relativeCurveTo: function() {

        this._curveTo.apply(this, [Y.Array(arguments), true]);

        return this;

    },

    /**

     * Implements curveTo methods.

     *

     * @method _curveTo

     * @param {Array} args The arguments to be used.

     * @param {Boolean} relative Indicates whether or not to use relative coordinates.

     * @private

     */

    _curveTo: function(args, relative) {

        var w,

            h,

            x,

            y,

            cp1x,

            cp1y,

            cp2x,

            cp2y,

            pts,

            right,

            left,

            bottom,

            top,

            i,

            len,

            path,

            command = relative ? " v " : " c ",

            relativeX = relative ? parseFloat(this._currentX) : 0,

            relativeY = relative ? parseFloat(this._currentY) : 0;

        len = args.length - 5;

        path = command;

        for(i = 0; i < len; i = i + 6)

        {

            cp1x = parseFloat(args[i]);

            cp1y = parseFloat(args[i + 1]);

            cp2x = parseFloat(args[i + 2]);

            cp2y = parseFloat(args[i + 3]);

            x = parseFloat(args[i + 4]);

            y = parseFloat(args[i + 5]);

            if(i > 0)

            {

                path = path + ", ";

            }

            path = path +

                    this._round(cp1x) +

                    ", " +

                    this._round(cp1y) +

                    ", " +

                    this._round(cp2x) +

                    ", " +

                    this._round(cp2y) +

                    ", " +

                    this._round(x) +

                    ", " +

                    this._round(y);

            cp1x = cp1x + relativeX;

            cp1y = cp1y + relativeY;

            cp2x = cp2x + relativeX;

            cp2y = cp2y + relativeY;

            x = x + relativeX;

            y = y + relativeY;

            right = Math.max(x, Math.max(cp1x, cp2x));

            bottom = Math.max(y, Math.max(cp1y, cp2y));

            left = Math.min(x, Math.min(cp1x, cp2x));

            top = Math.min(y, Math.min(cp1y, cp2y));

            w = Math.abs(right - left);

            h = Math.abs(bottom - top);

            pts = [[this._currentX, this._currentY] , [cp1x, cp1y], [cp2x, cp2y], [x, y]];

            this._setCurveBoundingBox(pts, w, h);

            this._currentX = x;

            this._currentY = y;

        }

        this._addToPath(path);

    },

    /**

     * Draws a quadratic bezier curve.

     *

     * @method quadraticCurveTo

     * @param {Number} cpx x-coordinate for the control point.

     * @param {Number} cpy y-coordinate for the control point.

     * @param {Number} x x-coordinate for the end point.

     * @param {Number} y y-coordinate for the end point.

     * @chainable

     */

    quadraticCurveTo: function() {

        this._quadraticCurveTo.apply(this, [Y.Array(arguments), false]);

        return this;

    },

    /**

     * Draws a quadratic bezier curve relative to the current position.

     *

     * @method relativeQuadraticCurveTo

     * @param {Number} cpx x-coordinate for the control point.

     * @param {Number} cpy y-coordinate for the control point.

     * @param {Number} x x-coordinate for the end point.

     * @param {Number} y y-coordinate for the end point.

     * @chainable

     */

    relativeQuadraticCurveTo: function() {

        this._quadraticCurveTo.apply(this, [Y.Array(arguments), true]);

        return this;

    },

    /**

     * Implements quadraticCurveTo methods.

     *

     * @method _quadraticCurveTo

     * @param {Array} args The arguments to be used.

     * @param {Boolean} relative Indicates whether or not to use relative coordinates.

     * @private

     */

    _quadraticCurveTo: function(args, relative) {

        var cpx,

            cpy,

            cp1x,

            cp1y,

            cp2x,

            cp2y,

            x,

            y,

            currentX = this._currentX,

            currentY = this._currentY,

            i,

            len = args.length - 3,

            bezierArgs = [],

            relativeX = relative ? parseFloat(this._currentX) : 0,

            relativeY = relative ? parseFloat(this._currentY) : 0;

        for(i = 0; i < len; i = i + 4)

        {

            cpx = parseFloat(args[i]) + relativeX;

            cpy = parseFloat(args[i + 1]) + relativeY;

            x = parseFloat(args[i + 2]) + relativeX;

            y = parseFloat(args[i + 3]) + relativeY;

            cp1x = currentX + 0.67*(cpx - currentX);

            cp1y = currentY + 0.67*(cpy - currentY);

            cp2x = cp1x + (x - currentX) * 0.34;

            cp2y = cp1y + (y - currentY) * 0.34;

            bezierArgs.push(cp1x);

            bezierArgs.push(cp1y);

            bezierArgs.push(cp2x);

            bezierArgs.push(cp2y);

            bezierArgs.push(x);

            bezierArgs.push(y);

        }

        this._curveTo.apply(this, [bezierArgs, false]);

    },

    /**

     * Draws a rectangle.

     *

     * @method drawRect

     * @param {Number} x x-coordinate

     * @param {Number} y y-coordinate

     * @param {Number} w width

     * @param {Number} h height

     * @chainable

     */

    drawRect: function(x, y, w, h) {

        this.moveTo(x, y);

        this.lineTo(x + w, y);

        this.lineTo(x + w, y + h);

        this.lineTo(x, y + h);

        this.lineTo(x, y);

        this._currentX = x;

        this._currentY = y;

        return this;

    },

    /**

     * Draws a rectangle with rounded corners.

     *

     * @method drawRect

     * @param {Number} x x-coordinate

     * @param {Number} y y-coordinate

     * @param {Number} w width

     * @param {Number} h height

     * @param {Number} ew width of the ellipse used to draw the rounded corners

     * @param {Number} eh height of the ellipse used to draw the rounded corners

     * @chainable

     */

    drawRoundRect: function(x, y, w, h, ew, eh) {

        this.moveTo(x, y + eh);

        this.lineTo(x, y + h - eh);

        this.quadraticCurveTo(x, y + h, x + ew, y + h);

        this.lineTo(x + w - ew, y + h);

        this.quadraticCurveTo(x + w, y + h, x + w, y + h - eh);

        this.lineTo(x + w, y + eh);

        this.quadraticCurveTo(x + w, y, x + w - ew, y);

        this.lineTo(x + ew, y);

        this.quadraticCurveTo(x, y, x, y + eh);

        return this;

    },

    /**

     * Draws a circle. Used internally by `CanvasCircle` class.

     *

     * @method drawCircle

     * @param {Number} x y-coordinate

     * @param {Number} y x-coordinate

     * @param {Number} r radius

     * @chainable

     * @protected

     */

	drawCircle: function(x, y, radius) {

        var startAngle = 0,

            endAngle = 360,

            circum = radius * 2;

        endAngle *= 65535;

        this._drawingComplete = false;

        this._trackSize(x + circum, y + circum);

        this.moveTo((x + circum), (y + radius));

        this._addToPath(

            " ae " +

            this._round(x + radius) +

            ", " +

            this._round(y + radius) +

            ", " +

            this._round(radius) +

            ", " +

            this._round(radius) +

            ", " +

            startAngle +

            ", " +

            endAngle

        );

        return this;

    },

    /**

     * Draws an ellipse.

     *

     * @method drawEllipse

     * @param {Number} x x-coordinate

     * @param {Number} y y-coordinate

     * @param {Number} w width

     * @param {Number} h height

     * @chainable