/*

YUI 3.10.3 (build 2fb5187)

Copyright 2013 Yahoo! Inc. All rights reserved.

Licensed under the BSD License.

http://yuilibrary.com/license/

*/

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

/**

 *

 * <p>The `Graphics` module provides a JavaScript API for creating shapes in a variety of formats across

 * a <a href="http://developer.yahoo.com/yui/articles/gbs">browser test baseline</a>.

 * Based on device and browser capabilities, `Graphics` leverages <a href="http://www.w3.org/TR/SVG/">SVG</a>,

 * <a href="http://www.w3.org/TR/html5/the-canvas-element.html">Canvas</a> and <a href="http://www.w3.org/TR/NOTE-VML">VML</a>

 * to render its graphical elements.</p>

 *

 * <p>The `Graphics` module features a <a href="../classes/Graphic.html">`Graphic`</a> class that allows you to easily create and manage shapes.

 * Currently, a <a href="../classes/Graphic.html">`Graphic`</a> instance can be used to create predifined shapes and free-form polygons with fill

 * and stroke properties.</p>

 *

 * <p>The `Graphics` module normalizes an API through the use of alias and implementation classes that share

 * interfaces. Each alias class points to an appropriate implementation class dependent on the browser's

 * capabilities. There should rarely, if ever, be a need to interact directly with an implementation class.</p>

 *

 * <p>Below is a list of available classes.

 *     <ul>

 *         <li><a href="../classes/Graphic.html">`Graphic`</a>

 *         <li><a href="../classes/Shape.html">`Shape`</a>

 *         <li><a href="../classes/Circle.html">`Circle`</a>

 *         <li><a href="../classes/Ellipse.html">`Ellipse`</a>

 *         <li><a href="../classes/Rect.html">`Rect`</a>

 *         <li><a href="../classes/Path.html">`Path`</a>

 *     </ul>

 * You can also extend the `Shape` class to create your own custom shape classes.</p>

 * @module graphics

 * @main graphics

 */

var SETTER = "setter",

	PluginHost = Y.Plugin.Host,

    VALUE = "value",

    VALUEFN = "valueFn",

    READONLY = "readOnly",

    Y_LANG = Y.Lang,

    STR = "string",

    WRITE_ONCE = "writeOnce",

    GraphicBase,

    AttributeLite;

    /**

	 * AttributeLite provides Attribute-like getters and setters for shape classes in the Graphics module.

     * It provides a get/set API without the event infastructure. This class is temporary and a work in progress.

	 *

	 * @class AttributeLite

	 * @constructor

	 */

    AttributeLite = function()

    {

        var host = this; // help compression

        // Perf tweak - avoid creating event literals if not required.

        host._ATTR_E_FACADE = {};

        Y.EventTarget.call(this, {emitFacade:true});

        host._state = {};

        host.prototype = Y.mix(AttributeLite.prototype, host.prototype);

    };

    AttributeLite.prototype = {

		/**

		 * Initializes the attributes for a shape. If an attribute config is passed into the constructor of the host,

		 * the initial values will be overwritten.

		 *

		 * @method addAttrs

		 * @param {Object} cfg Optional object containing attributes key value pairs to be set.

		 */

		addAttrs: function(cfg)

		{

			var host = this,

				attrConfig = this.constructor.ATTRS,

				attr,

				i,

				fn,

				state = host._state;

			for(i in attrConfig)

			{

				if(attrConfig.hasOwnProperty(i))

				{

					attr = attrConfig[i];

					if(attr.hasOwnProperty(VALUE))

					{

						state[i] = attr.value;

					}

					else if(attr.hasOwnProperty(VALUEFN))

					{

						fn = attr.valueFn;

						if(Y_LANG.isString(fn))

						{

							state[i] = host[fn].apply(host);

						}

						else

						{

							state[i] = fn.apply(host);

						}

					}

                }

            }

			host._state = state;

            for(i in attrConfig)

			{

				if(attrConfig.hasOwnProperty(i))

				{

					attr = attrConfig[i];

                    if(attr.hasOwnProperty(READONLY) && attr.readOnly)

					{

						continue;

					}

					if(attr.hasOwnProperty(WRITE_ONCE) && attr.writeOnce)

					{

						attr.readOnly = true;

					}

					if(cfg && cfg.hasOwnProperty(i))

					{

						if(attr.hasOwnProperty(SETTER))

						{

							host._state[i] = attr.setter.apply(host, [cfg[i]]);

						}

						else

						{

							host._state[i] = cfg[i];

						}

					}

				}

			}

		},

        /**

         * For a given item, returns the value of the property requested, or undefined if not found.

         *

         * @method get

         * @param name {String} The name of the item

         * @return {Any} The value of the supplied property.

         */

        get: function(attr)

        {

            var host = this,

                getter,

                attrConfig = host.constructor.ATTRS;

            if(attrConfig && attrConfig[attr])

            {

                getter = attrConfig[attr].getter;

                if(getter)

                {

                    if(typeof getter === STR)

                    {

                        return host[getter].apply(host);

                    }

                    return attrConfig[attr].getter.apply(host);

                }

                return host._state[attr];

            }

            return null;

        },

        /**

         * 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 attr = arguments[0],

                i;

            if(Y_LANG.isObject(attr))

            {

                for(i in attr)

                {

                    if(attr.hasOwnProperty(i))

                    {

                        this._set(i, attr[i]);

                    }

                }

            }

            else

            {

                this._set.apply(this, arguments);

            }

        },

		/**

         * Provides setter logic. Used by `set`.

         *

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

		 * @protected

		 */

		_set: function(attr, val)

		{

			var host = this,

				setter,

				args,

				attrConfig = host.constructor.ATTRS;

			if(attrConfig && attrConfig.hasOwnProperty(attr))

			{

				setter = attrConfig[attr].setter;

				if(setter)

				{

					args = [val];

					if(typeof setter === STR)

					{

						val = host[setter].apply(host, args);

					}

					else

                    {

                        val = attrConfig[attr].setter.apply(host, args);

                    }

				}

				host._state[attr] = val;

			}

		}

	};

    Y.mix(AttributeLite, Y.EventTarget, false, null, 1);

	Y.AttributeLite = AttributeLite;

    /**

     * GraphicBase serves as the base class for the graphic layer. It serves the same purpose as

     * Base but uses a lightweight getter/setter class instead of Attribute.

     * This class is temporary and a work in progress.

     *

     * @class GraphicBase

     * @constructor

     * @param {Object} cfg Key value pairs for attributes

     */

    GraphicBase = function(cfg)

    {

        var host = this,

            PluginHost = Y.Plugin && Y.Plugin.Host;

        if (host._initPlugins && PluginHost) {

            PluginHost.call(host);

        }

        host.name = host.constructor.NAME;

        host._eventPrefix = host.constructor.EVENT_PREFIX || host.constructor.NAME;

        AttributeLite.call(host);

        host.addAttrs(cfg);

        host.init.apply(this, arguments);

        if (host._initPlugins) {

            // Need to initPlugins manually, to handle constructor parsing, static Plug parsing

            host._initPlugins(cfg);

        }

        host.initialized = true;

    };

    GraphicBase.NAME = "baseGraphic";

    GraphicBase.prototype = {

        /**

         * Init method, invoked during construction.

         * Fires an init event after calling `initializer` on implementers.

         *

         * @method init

         * @protected

         */

        init: function()

        {

            this.publish("init", {

                fireOnce:true

            });

            this.initializer.apply(this, arguments);

            this.fire("init", {cfg: arguments[0]});

        },

        /**

         * Camel case concatanates two strings.

         *

         * @method _camelCaseConcat

         * @param {String} prefix The first string

         * @param {String} name The second string

         * @return String

         * @private

         */

        _camelCaseConcat: function(prefix, name)

        {

            return prefix + name.charAt(0).toUpperCase() + name.slice(1);

        }

    };

//Straightup augment, no wrapper functions

Y.mix(GraphicBase, Y.AttributeLite, false, null, 1);

Y.mix(GraphicBase, PluginHost, false, null, 1);

GraphicBase.prototype.constructor = GraphicBase;

GraphicBase.plug = PluginHost.plug;

GraphicBase.unplug = PluginHost.unplug;

Y.GraphicBase = GraphicBase;

/**

 * `Drawing` provides a set of drawing methods used by `Path` and custom shape classes.

 * `Drawing` has the following implementations based on browser capability.

 *  <ul>

 *      <li><a href="SVGDrawing.html">`SVGDrawing`</a></li>

 *      <li><a href="VMLDrawing.html">`VMLDrawing`</a></li>

 *      <li><a href="CanvasDrawing.html">`CanvasDrawing`</a></li>

 *  </ul>

 *

 * @class Drawing

 * @constructor

 */

    /**

     * Draws a line segment using the current line style from the current drawing position to the specified x and y coordinates.

     *

     * @method lineTo

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

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

     */

    /**

     * Moves the current drawing position to specified x and y coordinates.

     *

     * @method moveTo

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

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

     */

    /**

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

     */

    /**

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

     */

    /**

     * Draws a rectangle.

     *

     * @method drawRect

     * @param {Number} x x-coordinate

     * @param {Number} y y-coordinate

     * @param {Number} w width

     * @param {Number} h height

     */

    /**

     * 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

     */

    /**

     * Completes a drawing operation.

     *

     * @method end

     */

    /**

     * Clears the path.

     *

     * @method clear

     */

/**

 *  <p>Base class for creating shapes.</p>

 *  <p>`Shape` is an abstract class and is not meant to be used directly. The following classes extend

 *  `Shape`.

 *

 *  <ul>

 *      <li><a href="Circle.html">`Circle`</a></li>

 *      <li><a href="Ellipse.html">`Ellipse`</a></li>

 *      <li><a href="Rect.html">`Rect`</a></li>

 *      <li><a href="Path.html">`Path`</a></li>

 *  </ul>

 *

 * `Shape` can also be extended to create custom shape classes.</p>

 *

 * `Shape` has the following implementations based on browser capability.

 *  <ul>

 *      <li><a href="SVGShape.html">`SVGShape`</a></li>

 *      <li><a href="VMLShape.html">`VMLShape`</a></li>

 *      <li><a href="CanvasShape.html">`CanvasShape`</a></li>

 *  </ul>

 *

 * It is not necessary to interact with these classes directly. `Shape` will point to the appropriate implemention.</p>

 *

 * @class Shape

 * @constructor

 * @param {Object} cfg (optional) Attribute configs

 */

    /**

     * Init method, invoked during construction.

     * Calls `initializer` method.

     *

     * @method init

     * @protected

     */

	/**

	 * Initializes the shape

	 *

	 * @private

	 * @method initializer

	 */

	/**

	 * Add a class name to each node.

	 *

	 * @method addClass

	 * @param {String} className the class name to add to the node's class attribute

	 */

	/**