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

var IMPLEMENTATION = "svg",

    SHAPE = "shape",

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

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

    Y_LANG = Y.Lang,

	AttributeLite = Y.AttributeLite,

	SVGGraphic,

    SVGShape,

	SVGCircle,

	SVGRect,

	SVGPath,

	SVGEllipse,

    SVGPieSlice,

    DOCUMENT = Y.config.doc,

    _getClassName = Y.ClassNameManager.getClassName;

function SVGDrawing(){}

/**

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

 * `SVGDrawing` is not intended to be used directly. Instead, use the <a href="Drawing.html">`Drawing`</a> class.

 * If the browser has <a href="http://www.w3.org/TR/SVG/">SVG</a> capabilities, the <a href="Drawing.html">`Drawing`</a>

 * class will point to the `SVGDrawing` class.

 *

 * @module graphics

 * @class SVGDrawing

 * @constructor

 */

SVGDrawing.prototype = {

    /**

     * Rounds a value to the nearest hundredth.

     *

     * @method _round

     * @param {Number} val Value to be rounded.

     * @return Number

     * @private

     */

    _round: function(val) {

        return Math.round(val * 100)/100;

    },

    /**

     * 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"

    },

    /**

     * 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,

    /**

     * Indicates the type of shape

     *

     * @private

     * @property _type

     * @readOnly

     * @type String

     */

    _type: "path",

    /**

     * 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 relative to the current coordinates.

     *

     * @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,

            pts,

            cp1x,

            cp1y,

            cp2x,

            cp2y,

            x,

            y,

            right,

            left,

            bottom,

            top,

            i,

            len,

            pathArrayLen,

            currentArray,

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

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

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

        this._pathArray = this._pathArray || [];

        if(this._pathType !== command)

        {

            this._pathType = command;

            currentArray = [command];

            this._pathArray.push(currentArray);

        }

        else

        {

            currentArray = this._pathArray[Math.max(0, this._pathArray.length - 1)];

            if(!currentArray)

            {

                currentArray = [];

                this._pathArray.push(currentArray);

            }

        }

        pathArrayLen = this._pathArray.length - 1;

        this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat(args);

        len = args.length - 5;

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

        {

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

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

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

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

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

            y = parseFloat(args[i + 5]) + 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;

        }

    },

    /**

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

     */

    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,

            x,

            y,

            pathArrayLen,

            currentArray,

            w,

            h,

            pts,

            right,

            left,

            bottom,

            top,

            i,

            len,

            command = relative ? "q" : "Q",

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

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

        this._pathArray = this._pathArray || [];

        if(this._pathType !== command)

        {

            this._pathType = command;

            currentArray = [command];

            this._pathArray.push(currentArray);

        }

        else

        {

            currentArray = this._pathArray[Math.max(0, this._pathArray.length - 1)];

            if(!currentArray)

            {

                currentArray = [];

                this._pathArray.push(currentArray);

            }

        }

        pathArrayLen = this._pathArray.length - 1;

        this._pathArray[pathArrayLen] = this._pathArray[pathArrayLen].concat(args);

        len = args.length - 3;

        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;

            right = Math.max(x, cpx);

            bottom = Math.max(y, cpy);

            left = Math.min(x, cpx);

            top = Math.min(y, cpy);

            w = Math.abs(right - left);

            h = Math.abs(bottom - top);

            pts = [[this._currentX, this._currentY] , [cpx, cpy], [x, y]];

            this._setCurveBoundingBox(pts, w, h);

            this._currentX = x;

            this._currentY = y;

        }

    },

    /**

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

        return this;

    },

    /**

     * Draws a rectangle with rounded corners.

     *

     * @method drawRoundRect

     * @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.

     *

     * @method drawCircle

     * @param {Number} x y-coordinate

     * @param {Number} y x-coordinate

     * @param {Number} r radius

     * @chainable

     * @protected

     */

	drawCircle: function(x, y, radius) {

        var circum = radius * 2;

        this._drawingComplete = false;

        this._trackSize(x, y);

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

        this._pathArray = this._pathArray || [];

        this._pathArray.push(["M", x + radius, y]);

        this._pathArray.push(["A",  radius, radius, 0, 1, 0, x + radius, y + circum]);

        this._pathArray.push(["A",  radius, radius, 0, 1, 0, x + radius, y]);

        this._currentX = x;

        this._currentY = y;

        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

     * @protected

     */

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

        var radius = w * 0.5,

            yRadius = h * 0.5;

        this._drawingComplete = false;

        this._trackSize(x, y);

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

        this._pathArray = this._pathArray || [];

        this._pathArray.push(["M", x + radius, y]);