/*

Copyright (c) 2009, Yahoo! Inc. All rights reserved.

Code licensed under the BSD License:

http://developer.yahoo.net/yui/license.txt

version: 3.0.0

build: 1549

*/

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

/**

 * The Node Utility provides a DOM-like interface for interacting with DOM nodes.

 * @module node

 * @submodule node-base

 */    

/**

 * The Node class provides a wrapper for manipulating DOM Nodes.

 * Node properties can be accessed via the set/get methods.

 * Use Y.get() to retrieve Node instances.

 *

 * <strong>NOTE:</strong> Node properties are accessed using

 * the <code>set</code> and <code>get</code> methods.

 *

 * @class Node

 * @constructor

 * @for Node

 */

// "globals"

var DOT = '.',

    NODE_NAME = 'nodeName',

    NODE_TYPE = 'nodeType',

    OWNER_DOCUMENT = 'ownerDocument',

    TAG_NAME = 'tagName',

    UID = '_yuid',

    Node = function(node) {

        var uid = node[UID];

        if (uid && Node._instances[uid] && Node._instances[uid]._node !== node) {

            node[UID] = null; // unset existing uid to prevent collision (via clone or hack)

        }

        uid = Y.stamp(node);

        if (!uid) { // stamp failed; likely IE non-HTMLElement

            uid = Y.guid();

        }

        this[UID] = uid;

        this._node = node;

        Node._instances[uid] = this;

        this._stateProxy = node; // when augmented with Attribute

        if (this._initPlugins) { // when augmented with Plugin.Host

            this._initPlugins();

        }

    },

    // used with previous/next/ancestor tests

    _wrapFn = function(fn) {

        var ret = null;

        if (fn) {

            ret = (typeof fn === 'string') ?

            function(n) {

                return Y.Selector.test(n, fn);

            } : 

            function(n) {

                return fn(Node.get(n));

            };

        }

        return ret;

    };

// end "globals"

Node.NAME = 'Node';

Node.re_aria = /^(?:role$|aria-)/;

Node.DOM_EVENTS = {

    abort: true,

    beforeunload: true,

    blur: true,

    change: true,

    click: true,

    close: true,

    command: true,

    contextmenu: true,

    drag: true,

    dragstart: true,

    dragenter: true,

    dragover: true,

    dragleave: true,

    dragend: true,

    drop: true,

    dblclick: true,

    error: true,

    focus: true,

    keydown: true,

    keypress: true,

    keyup: true,

    load: true,

    message: true,

    mousedown: true,

    mousemove: true,

    mouseout: true, 

    mouseover: true, 

    mouseup: true,

    mousemultiwheel: true,

    mousewheel: true,

    submit: true,

    mouseenter: true,

    mouseleave: true,

    scroll: true,

    reset: true,

    resize: true,

    select: true,

    textInput: true,

    unload: true

};

// Add custom event adaptors to this list.  This will make it so

// that delegate, key, available, contentready, etc all will

// be available through Node.on

Y.mix(Node.DOM_EVENTS, Y.Env.evt.plugins);

Node._instances = {};

/**

 * Retrieves the DOM node bound to a Node instance

 * @method Node.getDOMNode

 * @static

 *

 * @param {Y.Node || HTMLNode} node The Node instance or an HTMLNode

 * @return {HTMLNode} The DOM node bound to the Node instance.  If a DOM node is passed

 * as the node argument, it is simply returned.

 */

Node.getDOMNode = function(node) {

    if (node) {

        return (node.nodeType) ? node : node._node || null;

    }

    return null;

};

Node.scrubVal = function(val, node) {

    if (node && val) { // only truthy values are risky

        if (typeof val === 'object' || typeof val === 'function') { // safari nodeList === function

            if (NODE_TYPE in val || Y.DOM.isWindow(val)) {// node || window

                val = Node.get(val);

            } else if ((val.item && !val._nodes) || // dom collection or Node instance

                    (val[0] && val[0][NODE_TYPE])) { // array of DOM Nodes

                val = Y.all(val);

            }

        }

    } else if (val === undefined) {

        val = node; // for chaining

    }

    return val;

};

Node.addMethod = function(name, fn, context) {

    if (name && fn && typeof fn === 'function') {

        Node.prototype[name] = function() {

            context = context || this;

            var args = Y.Array(arguments),

                ret;

            if (args[0] && args[0] instanceof Node) {

                args[0] = args[0]._node;

            }

            if (args[1] && args[1] instanceof Node) {

                args[1] = args[1]._node;

            }

            args.unshift(this._node);

            ret = Node.scrubVal(fn.apply(context, args), this);

            return ret;

        };

    } else {

    }

};

Node.importMethod = function(host, name, altName) {

    if (typeof name === 'string') {

        altName = altName || name;

        Node.addMethod(altName, host[name], host);

    } else {

        Y.each(name, function(n) {

            Node.importMethod(host, n);

        });

    }

};

/**

 * Returns a single Node instance bound to the node or the

 * first element matching the given selector.

 * @method Y.one

 * @static

 * @param {String | HTMLElement} node a node or Selector 

 * @param {Y.Node || HTMLElement} doc an optional document to scan. Defaults to Y.config.doc. 

 */

Node.one = function(node) {

    var instance = null,

        cachedNode,

        uid;

    if (node) {

        if (typeof node === 'string') {

            if (node.indexOf('doc') === 0) { // doc OR document

                node = Y.config.doc;

            } else if (node.indexOf('win') === 0) { // win OR window

                node = Y.config.win;

            } else {

                node = Y.Selector.query(node, null, true);

            }

            if (!node) {

                return null;

            }

        } else if (node instanceof Node) {

            return node; // NOTE: return

        }

        uid = node._yuid;

        instance = Node._instances[uid]; // reuse exising instances

        cachedNode = instance ? instance._node : null;

        if (!instance || (cachedNode && node !== cachedNode)) { // new Node when nodes don't match

            instance = new Node(node);

        }

    }

    return instance;

};

/**

 * Returns a single Node instance bound to the node or the

 * first element matching the given selector.

 * @method Y.get

 * @deprecated Use Y.one

 * @static

 * @param {String | HTMLElement} node a node or Selector 

 * @param {Y.Node || HTMLElement} doc an optional document to scan. Defaults to Y.config.doc. 

 */

Node.get = function() {

    return Node.one.apply(Node, arguments);

};

/**

 * Creates a new dom node using the provided markup string. 

 * @method create

 * @static

 * @param {String} html The markup used to create the element

 * @param {HTMLDocument} doc An optional document context 

 * @return {Node} A Node instance bound to a DOM node or fragment 

 */

Node.create = function() {

    return Node.get(Y.DOM.create.apply(Y.DOM, arguments));

};

Node.ATTRS = {

    /**

     * Allows for getting and setting the text of an element.

     * Formatting is preserved and special characters are treated literally.

     * @config text

     * @type String

     */

    text: {

        getter: function() {

            return Y.DOM.getText(this._node);

        },

        setter: function(content) {

            Y.DOM.setText(this._node, content);

            return content;

        }

    },

    'options': {

        getter: function() {

            return this._node.getElementsByTagName('option');

        }

    },

     // IE: elements collection is also FORM node which trips up scrubVal.

     // preconverting to NodeList

     // TODO: break out for IE only

    'elements': {

        getter: function() {

            return Y.all(this._node.elements);

        }

    },

    /**

     * Returns a NodeList instance of all HTMLElement children.

     * @readOnly

     * @config children

     * @type NodeList

     */

    'children': {

        getter: function() {

            var node = this._node,

                children = node.children,

                childNodes, i, len;

            if (!children) {

                childNodes = node.childNodes;

                children = [];

                for (i = 0, len = childNodes.length; i < len; ++i) {

                    if (childNodes[i][TAG_NAME]) {

                        children[children.length] = childNodes[i];

                    }

                }

            }

            return Y.all(children);

        }

    },

    value: {

        getter: function() {

            return Y.DOM.getValue(this._node);

        },

        setter: function(val) {

            Y.DOM.setValue(this._node, val);

            return val;

        }

    },

    data: {

        getter: function() {

            return this._data;

        },

        setter: function(val) {

            this._data = val;

            return val;

        }

    }

};

// call with instance context

Node.DEFAULT_SETTER = function(name, val) {

    var node = this._stateProxy,

        strPath;

    if (name.indexOf(DOT) > -1) {

        strPath = name;

        name = name.split(DOT);

        // only allow when defined on node

        Y.Object.setValue(node, name, val);

    } else if (node[name] !== undefined) { // pass thru DOM properties 

        node[name] = val;

    }

    return val;

};

// call with instance context

Node.DEFAULT_GETTER = function(name) {

    var node = this._stateProxy,

        val;

    if (name.indexOf && name.indexOf(DOT) > -1) {

        val = Y.Object.getValue(node, name.split(DOT));

    } else if (node[name] !== undefined) { // pass thru from DOM

        val = node[name];

    }

    return val;

};

Y.augment(Node, Y.Event.Target);

Y.mix(Node.prototype, {

    toString: function() {

        var str = '',

            errorMsg = this[UID] + ': not bound to a node',

            node = this._node;

        if (node) {