YUI.add('widget-base', function (Y, NAME) {

/**

 * Provides the base Widget class, with HTML Parser support

 *

 * @module widget

 * @main widget

 */

/**

 * Provides the base Widget class

 *

 * @module widget

 * @submodule widget-base

 */

var L = Y.Lang,

    Node = Y.Node,

    ClassNameManager = Y.ClassNameManager,

    _getClassName = ClassNameManager.getClassName,

    _getWidgetClassName,

    _toInitialCap = Y.cached(function(str) {

        return str.substring(0, 1).toUpperCase() + str.substring(1);

    }),

    // K-Weight, IE GC optimizations

    CONTENT = "content",

    VISIBLE = "visible",

    HIDDEN = "hidden",

    DISABLED = "disabled",

    FOCUSED = "focused",

    WIDTH = "width",

    HEIGHT = "height",

    BOUNDING_BOX = "boundingBox",

    CONTENT_BOX = "contentBox",

    PARENT_NODE = "parentNode",

    OWNER_DOCUMENT = "ownerDocument",

    AUTO = "auto",

    SRC_NODE = "srcNode",

    BODY = "body",

    TAB_INDEX = "tabIndex",

    ID = "id",

    RENDER = "render",

    RENDERED = "rendered",

    DESTROYED = "destroyed",

    STRINGS = "strings",

    DIV = "<div></div>",

    CHANGE = "Change",

    LOADING = "loading",

    _UISET = "_uiSet",

    EMPTY_STR = "",

    EMPTY_FN = function() {},

    TRUE = true,

    FALSE = false,

    UI,

    ATTRS = {},

    UI_ATTRS = [VISIBLE, DISABLED, HEIGHT, WIDTH, FOCUSED, TAB_INDEX],

    WEBKIT = Y.UA.webkit,

    // Widget nodeid-to-instance map.

    _instances = {};

/**

 * A base class for widgets, providing:

 * <ul>

 *    <li>The render lifecycle method, in addition to the init and destroy

 *        lifecycle methods provide by Base</li>

 *    <li>Abstract methods to support consistent MVC structure across

 *        widgets: renderer, renderUI, bindUI, syncUI</li>

 *    <li>Support for common widget attributes, such as boundingBox, contentBox, visible,

 *        disabled, focused, strings</li>

 * </ul>

 *

 * @param config {Object} Object literal specifying widget configuration properties.

 *

 * @class Widget

 * @constructor

 * @extends Base

 */

function Widget(config) {

    Y.log('constructor called', 'life', 'widget');

    // kweight

    var widget = this,

        parentNode,

        render,

        constructor = widget.constructor;

    widget._strs = {};

    widget._cssPrefix = constructor.CSS_PREFIX || _getClassName(constructor.NAME.toLowerCase());

    // We need a config for HTML_PARSER to work.

    config = config || {};

    Widget.superclass.constructor.call(widget, config);

    render = widget.get(RENDER);

    if (render) {

        // Render could be a node or boolean

        if (render !== TRUE) {

            parentNode = render;

        }

        widget.render(parentNode);

    }

}

/**

 * Static property provides a string to identify the class.

 * <p>

 * Currently used to apply class identifiers to the bounding box

 * and to classify events fired by the widget.

 * </p>

 *

 * @property NAME

 * @type String

 * @static

 */

Widget.NAME = "widget";

/**

 * Constant used to identify state changes originating from

 * the DOM (as opposed to the JavaScript model).

 *

 * @property UI_SRC

 * @type String

 * @static

 * @final

 */

UI = Widget.UI_SRC = "ui";

/**

 * Static property used to define the default attribute

 * configuration for the Widget.

 *

 * @property ATTRS

 * @type Object

 * @static

 */

Widget.ATTRS = ATTRS;

// Trying to optimize kweight by setting up attrs this way saves about 0.4K min'd

/**

 * @attribute id

 * @writeOnce

 * @default Generated using guid()

 * @type String

 */

ATTRS[ID] = {

    valueFn: "_guid",

    writeOnce: TRUE

};

/**

 * Flag indicating whether or not this Widget

 * has been through the render lifecycle phase.

 *

 * @attribute rendered

 * @readOnly

 * @default false

 * @type boolean

 */

ATTRS[RENDERED] = {

    value:FALSE,

    readOnly: TRUE

};

/**

 * @attribute boundingBox

 * @description The outermost DOM node for the Widget, used for sizing and positioning

 * of a Widget as well as a containing element for any decorator elements used

 * for skinning.

 * @type String | Node

 * @writeOnce

 */

ATTRS[BOUNDING_BOX] = {

    valueFn:"_defaultBB",

    setter: "_setBB",

    writeOnce: TRUE

};

/**

 * @attribute contentBox

 * @description A DOM node that is a direct descendant of a Widget's bounding box that

 * houses its content.

 * @type String | Node

 * @writeOnce

 */

ATTRS[CONTENT_BOX] = {

    valueFn:"_defaultCB",

    setter: "_setCB",

    writeOnce: TRUE

};

/**

 * @attribute tabIndex

 * @description Number (between -32767 to 32767) indicating the widget's

 * position in the default tab flow.  The value is used to set the

 * "tabIndex" attribute on the widget's bounding box.  Negative values allow

 * the widget to receive DOM focus programmatically (by calling the focus

 * method), while being removed from the default tab flow.  A value of

 * null removes the "tabIndex" attribute from the widget's bounding box.

 * @type Number

 * @default null

 */

ATTRS[TAB_INDEX] = {

    value: null,

    validator: "_validTabIndex"

};

/**

 * @attribute focused

 * @description Boolean indicating if the Widget, or one of its descendants,

 * has focus.

 * @readOnly

 * @default false

 * @type boolean

 */

ATTRS[FOCUSED] = {

    value: FALSE,

    readOnly:TRUE

};

/**

 * @attribute disabled

 * @description Boolean indicating if the Widget should be disabled. The disabled implementation

 * is left to the specific classes extending widget.

 * @default false

 * @type boolean

 */

ATTRS[DISABLED] = {

    value: FALSE

};

/**

 * @attribute visible

 * @description Boolean indicating whether or not the Widget is visible.

 * @default TRUE

 * @type boolean

 */

ATTRS[VISIBLE] = {

    value: TRUE

};

/**

 * @attribute height

 * @description String with units, or number, representing the height of the Widget. If a number is provided,

 * the default unit, defined by the Widgets DEF_UNIT, property is used.

 * @default EMPTY_STR

 * @type {String | Number}

 */

ATTRS[HEIGHT] = {

    value: EMPTY_STR

};

/**

 * @attribute width

 * @description String with units, or number, representing the width of the Widget. If a number is provided,

 * the default unit, defined by the Widgets DEF_UNIT, property is used.

 * @default EMPTY_STR

 * @type {String | Number}

 */

ATTRS[WIDTH] = {

    value: EMPTY_STR

};

/**

 * @attribute strings

 * @description Collection of strings used to label elements of the Widget's UI.

 * @default null

 * @type Object

 */

ATTRS[STRINGS] = {

    value: {},

    setter: "_strSetter",

    getter: "_strGetter"

};

/**

 * Whether or not to render the widget automatically after init, and optionally, to which parent node.

 *

 * @attribute render

 * @type boolean | Node

 * @writeOnce

 */

ATTRS[RENDER] = {

    value:FALSE,

    writeOnce:TRUE

};

/**

 * The css prefix which the static Widget.getClassName method should use when constructing class names

 *

 * @property CSS_PREFIX

 * @type String

 * @default Widget.NAME.toLowerCase()

 * @private

 * @static

 */

Widget.CSS_PREFIX = _getClassName(Widget.NAME.toLowerCase());

/**

 * Generate a standard prefixed classname for the Widget, prefixed by the default prefix defined

 * by the <code>Y.config.classNamePrefix</code> attribute used by <code>ClassNameManager</code> and

 * <code>Widget.NAME.toLowerCase()</code> (e.g. "yui-widget-xxxxx-yyyyy", based on default values for

 * the prefix and widget class name).

 * <p>

 * The instance based version of this method can be used to generate standard prefixed classnames,

 * based on the instances NAME, as opposed to Widget.NAME. This method should be used when you

 * need to use a constant class name across different types instances.

 * </p>

 * @method getClassName

 * @param {String*} args* 0..n strings which should be concatenated, using the default separator defined by ClassNameManager, to create the class name

 */

Widget.getClassName = function() {

    // arguments needs to be array'fied to concat

    return _getClassName.apply(ClassNameManager, [Widget.CSS_PREFIX].concat(Y.Array(arguments), true));

};

_getWidgetClassName = Widget.getClassName;

/**

 * Returns the widget instance whose bounding box contains, or is, the given node.

 * <p>

 * In the case of nested widgets, the nearest bounding box ancestor is used to

 * return the widget instance.

 * </p>

 * @method getByNode

 * @static

 * @param node {Node | String} The node for which to return a Widget instance. If a selector

 * string is passed in, which selects more than one node, the first node found is used.

 * @return {Widget} Widget instance, or null if not found.

 */

Widget.getByNode = function(node) {

    var widget,

        widgetMarker = _getWidgetClassName();

    node = Node.one(node);

    if (node) {

        node = node.ancestor("." + widgetMarker, true);

        if (node) {

            widget = _instances[Y.stamp(node, true)];

        }

    }

    return widget || null;

};

Y.extend(Widget, Y.Base, {

    /**

     * Returns a class name prefixed with the the value of the

     * <code>YUI.config.classNamePrefix</code> attribute + the instances <code>NAME</code> property.

     * Uses <code>YUI.config.classNameDelimiter</code> attribute to delimit the provided strings.

     * e.g.

     * <code>

     * <pre>

     *    // returns "yui-slider-foo-bar", for a slider instance

     *    var scn = slider.getClassName('foo','bar');

     *

     *    // returns "yui-overlay-foo-bar", for an overlay instance

     *    var ocn = overlay.getClassName('foo','bar');

     * </pre>

     * </code>

     *

     * @method getClassName

     * @param {String} [classnames*] One or more classname bits to be joined and prefixed

     */

    getClassName: function () {

        return _getClassName.apply(ClassNameManager, [this._cssPrefix].concat(Y.Array(arguments), true));

    },

    /**

     * Initializer lifecycle implementation for the Widget class. Registers the

     * widget instance, and runs through the Widget's HTML_PARSER definition.

     *

     * @method initializer

     * @protected

     * @param  config {Object} Configuration object literal for the widget

     */

    initializer: function(config) {

        Y.log('initializer called', 'life', 'widget');

        var bb = this.get(BOUNDING_BOX);

        if (bb instanceof Node) {

            this._mapInstance(Y.stamp(bb));

        }

        /**

         * Notification event, which widget implementations can fire, when

         * they change the content of the widget. This event has no default

         * behavior and cannot be prevented, so the "on" or "after"

         * moments are effectively equivalent (with on listeners being invoked before

         * after listeners).

         *

         * @event widget:contentUpdate

         * @preventable false

         * @param {EventFacade} e The Event Facade

         */

    },

    /**

     * Utility method used to add an entry to the boundingBox id to instance map.

     *

     * This method can be used to populate the instance with lazily created boundingBox Node references.

     *

     * @method _mapInstance

     * @param {String} The boundingBox id

     * @protected

     */

    _mapInstance : function(id) {

        _instances[id] = this;

    },

    /**

     * Destructor lifecycle implementation for the Widget class. Purges events attached

     * to the bounding box and content box, removes them from the DOM and removes

     * the Widget from the list of registered widgets.

     *

     * @method destructor

     * @protected

     */

    destructor: function() {

        Y.log('destructor called', 'life', 'widget');

        var boundingBox = this.get(BOUNDING_BOX),

            bbGuid;

        if (boundingBox instanceof Node) {