+/*
+Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+Code licensed under the BSD License:
+http://developer.yahoo.net/yui/license.txt
+version: 2.7.0
+*/
+/**
+ * Provides Attribute configurations.
+ * @namespace YAHOO.util
+ * @class Attribute
+ * @constructor
+ * @param hash {Object} The intial Attribute.
+ * @param {YAHOO.util.AttributeProvider} The owner of the Attribute instance.
+ */
+
+YAHOO.util.Attribute = function(hash, owner) {
+ if (owner) {
+ this.owner = owner;
+ this.configure(hash, true);
+ }
+};
+
+YAHOO.util.Attribute.prototype = {
+ /**
+ * The name of the attribute.
+ * @property name
+ * @type String
+ */
+ name: undefined,
+
+ /**
+ * The value of the attribute.
+ * @property value
+ * @type String
+ */
+ value: null,
+
+ /**
+ * The owner of the attribute.
+ * @property owner
+ * @type YAHOO.util.AttributeProvider
+ */
+ owner: null,
+
+ /**
+ * Whether or not the attribute is read only.
+ * @property readOnly
+ * @type Boolean
+ */
+ readOnly: false,
+
+ /**
+ * Whether or not the attribute can only be written once.
+ * @property writeOnce
+ * @type Boolean
+ */
+ writeOnce: false,
+
+ /**
+ * The attribute's initial configuration.
+ * @private
+ * @property _initialConfig
+ * @type Object
+ */
+ _initialConfig: null,
+
+ /**
+ * Whether or not the attribute's value has been set.
+ * @private
+ * @property _written
+ * @type Boolean
+ */
+ _written: false,
+
+ /**
+ * A function to call when setting the attribute's value.
+ * The method receives the new value as the first arg and the attribute name as the 2nd
+ * @property method
+ * @type Function
+ */
+ method: null,
+
+ /**
+ * The function to use when setting the attribute's value.
+ * The setter receives the new value as the first arg and the attribute name as the 2nd
+ * The return value of the setter replaces the value passed to set().
+ * @property setter
+ * @type Function
+ */
+ setter: null,
+
+ /**
+ * The function to use when getting the attribute's value.
+ * The getter receives the new value as the first arg and the attribute name as the 2nd
+ * The return value of the getter will be used as the return from get().
+ * @property getter
+ * @type Function
+ */
+ getter: null,
+
+ /**
+ * The validator to use when setting the attribute's value.
+ * @property validator
+ * @type Function
+ * @return Boolean
+ */
+ validator: null,
+
+ /**
+ * Retrieves the current value of the attribute.
+ * @method getValue
+ * @return {any} The current value of the attribute.
+ */
+ getValue: function() {
+ var val = this.value;
+
+ if (this.getter) {
+ val = this.getter.call(this.owner, this.name);
+ }
+
+ return val;
+ },
+
+ /**
+ * Sets the value of the attribute and fires beforeChange and change events.
+ * @method setValue
+ * @param {Any} value The value to apply to the attribute.
+ * @param {Boolean} silent If true the change events will not be fired.
+ * @return {Boolean} Whether or not the value was set.
+ */
+ setValue: function(value, silent) {
+ var beforeRetVal,
+ owner = this.owner,
+ name = this.name;
+
+ var event = {
+ type: name,
+ prevValue: this.getValue(),
+ newValue: value
+ };
+
+ if (this.readOnly || ( this.writeOnce && this._written) ) {
+ return false; // write not allowed
+ }
+
+ if (this.validator && !this.validator.call(owner, value) ) {
+ return false; // invalid value
+ }
+
+ if (!silent) {
+ beforeRetVal = owner.fireBeforeChangeEvent(event);
+ if (beforeRetVal === false) {
+ return false;
+ }
+ }
+
+ if (this.setter) {
+ value = this.setter.call(owner, value, this.name);
+ if (value === undefined) {
+ }
+ }
+
+ if (this.method) {
+ this.method.call(owner, value, this.name);
+ }
+
+ this.value = value; // TODO: set before calling setter/method?
+ this._written = true;
+
+ event.type = name;
+
+ if (!silent) {
+ this.owner.fireChangeEvent(event);
+ }
+
+ return true;
+ },
+
+ /**
+ * Allows for configuring the Attribute's properties.
+ * @method configure
+ * @param {Object} map A key-value map of Attribute properties.
+ * @param {Boolean} init Whether or not this should become the initial config.
+ */
+ configure: function(map, init) {
+ map = map || {};
+
+ if (init) {
+ this._written = false; // reset writeOnce
+ }
+
+ this._initialConfig = this._initialConfig || {};
+
+ for (var key in map) {
+ if ( map.hasOwnProperty(key) ) {
+ this[key] = map[key];
+ if (init) {
+ this._initialConfig[key] = map[key];
+ }
+ }
+ }
+ },
+
+ /**
+ * Resets the value to the initial config value.
+ * @method resetValue
+ * @return {Boolean} Whether or not the value was set.
+ */
+ resetValue: function() {
+ return this.setValue(this._initialConfig.value);
+ },
+
+ /**
+ * Resets the attribute config to the initial config state.
+ * @method resetConfig
+ */
+ resetConfig: function() {
+ this.configure(this._initialConfig, true);
+ },
+
+ /**
+ * Resets the value to the current value.
+ * Useful when values may have gotten out of sync with actual properties.
+ * @method refresh
+ * @return {Boolean} Whether or not the value was set.
+ */
+ refresh: function(silent) {
+ this.setValue(this.value, silent);
+ }
+};
+
+(function() {
+ var Lang = YAHOO.util.Lang;
+
+ /*
+ Copyright (c) 2006, Yahoo! Inc. All rights reserved.
+ Code licensed under the BSD License:
+ http://developer.yahoo.net/yui/license.txt
+ */
+
+ /**
+ * Provides and manages YAHOO.util.Attribute instances
+ * @namespace YAHOO.util
+ * @class AttributeProvider
+ * @uses YAHOO.util.EventProvider
+ */
+ YAHOO.util.AttributeProvider = function() {};
+
+ YAHOO.util.AttributeProvider.prototype = {
+
+ /**
+ * A key-value map of Attribute configurations
+ * @property _configs
+ * @protected (may be used by subclasses and augmentors)
+ * @private
+ * @type {Object}
+ */
+ _configs: null,
+ /**
+ * Returns the current value of the attribute.
+ * @method get
+ * @param {String} key The attribute whose value will be returned.
+ * @return {Any} The current value of the attribute.
+ */
+ get: function(key){
+ this._configs = this._configs || {};
+ var config = this._configs[key];
+
+ if (!config || !this._configs.hasOwnProperty(key)) {
+ return null;
+ }
+
+ return config.getValue();
+ },
+
+ /**
+ * Sets the value of a config.
+ * @method set
+ * @param {String} key The name of the attribute
+ * @param {Any} value The value to apply to the attribute
+ * @param {Boolean} silent Whether or not to suppress change events
+ * @return {Boolean} Whether or not the value was set.
+ */
+ set: function(key, value, silent){
+ this._configs = this._configs || {};
+ var config = this._configs[key];
+
+ if (!config) {
+ return false;
+ }
+
+ return config.setValue(value, silent);
+ },
+
+ /**
+ * Returns an array of attribute names.
+ * @method getAttributeKeys
+ * @return {Array} An array of attribute names.
+ */
+ getAttributeKeys: function(){
+ this._configs = this._configs;
+ var keys = [], key;
+
+ for (key in this._configs) {
+ if ( Lang.hasOwnProperty(this._configs, key) &&
+ !Lang.isUndefined(this._configs[key]) ) {
+ keys[keys.length] = key;
+ }
+ }
+
+ return keys;
+ },
+
+ /**
+ * Sets multiple attribute values.
+ * @method setAttributes
+ * @param {Object} map A key-value map of attributes
+ * @param {Boolean} silent Whether or not to suppress change events
+ */
+ setAttributes: function(map, silent){
+ for (var key in map) {
+ if ( Lang.hasOwnProperty(map, key) ) {
+ this.set(key, map[key], silent);
+ }
+ }
+ },
+
+ /**
+ * Resets the specified attribute's value to its initial value.
+ * @method resetValue
+ * @param {String} key The name of the attribute
+ * @param {Boolean} silent Whether or not to suppress change events
+ * @return {Boolean} Whether or not the value was set
+ */
+ resetValue: function(key, silent){
+ this._configs = this._configs || {};
+ if (this._configs[key]) {
+ this.set(key, this._configs[key]._initialConfig.value, silent);
+ return true;
+ }
+ return false;
+ },
+
+ /**
+ * Sets the attribute's value to its current value.
+ * @method refresh
+ * @param {String | Array} key The attribute(s) to refresh
+ * @param {Boolean} silent Whether or not to suppress change events
+ */
+ refresh: function(key, silent) {
+ this._configs = this._configs || {};
+ var configs = this._configs;
+
+ key = ( ( Lang.isString(key) ) ? [key] : key ) ||
+ this.getAttributeKeys();
+
+ for (var i = 0, len = key.length; i < len; ++i) {
+ if (configs.hasOwnProperty(key[i])) {
+ this._configs[key[i]].refresh(silent);
+ }
+ }
+ },
+
+ /**
+ * Adds an Attribute to the AttributeProvider instance.
+ * @method register
+ * @param {String} key The attribute's name
+ * @param {Object} map A key-value map containing the
+ * attribute's properties.
+ * @deprecated Use setAttributeConfig
+ */
+ register: function(key, map) {
+ this.setAttributeConfig(key, map);
+ },
+
+
+ /**
+ * Returns the attribute's properties.
+ * @method getAttributeConfig
+ * @param {String} key The attribute's name
+ * @private
+ * @return {object} A key-value map containing all of the
+ * attribute's properties.
+ */
+ getAttributeConfig: function(key) {
+ this._configs = this._configs || {};
+ var config = this._configs[key] || {};
+ var map = {}; // returning a copy to prevent overrides
+
+ for (key in config) {
+ if ( Lang.hasOwnProperty(config, key) ) {
+ map[key] = config[key];
+ }
+ }
+
+ return map;
+ },
+
+ /**
+ * Sets or updates an Attribute instance's properties.
+ * @method setAttributeConfig
+ * @param {String} key The attribute's name.
+ * @param {Object} map A key-value map of attribute properties
+ * @param {Boolean} init Whether or not this should become the intial config.
+ */
+ setAttributeConfig: function(key, map, init) {
+ this._configs = this._configs || {};
+ map = map || {};
+ if (!this._configs[key]) {
+ map.name = key;
+ this._configs[key] = this.createAttribute(map);
+ } else {
+ this._configs[key].configure(map, init);
+ }
+ },
+
+ /**
+ * Sets or updates an Attribute instance's properties.
+ * @method configureAttribute
+ * @param {String} key The attribute's name.
+ * @param {Object} map A key-value map of attribute properties
+ * @param {Boolean} init Whether or not this should become the intial config.
+ * @deprecated Use setAttributeConfig
+ */
+ configureAttribute: function(key, map, init) {
+ this.setAttributeConfig(key, map, init);
+ },
+
+ /**
+ * Resets an attribute to its intial configuration.
+ * @method resetAttributeConfig
+ * @param {String} key The attribute's name.
+ * @private
+ */
+ resetAttributeConfig: function(key){
+ this._configs = this._configs || {};
+ this._configs[key].resetConfig();
+ },
+
+ // wrapper for EventProvider.subscribe
+ // to create events on the fly
+ subscribe: function(type, callback) {
+ this._events = this._events || {};
+
+ if ( !(type in this._events) ) {
+ this._events[type] = this.createEvent(type);
+ }
+
+ YAHOO.util.EventProvider.prototype.subscribe.apply(this, arguments);
+ },
+
+ on: function() {
+ this.subscribe.apply(this, arguments);
+ },
+
+ addListener: function() {
+ this.subscribe.apply(this, arguments);
+ },
+
+ /**
+ * Fires the attribute's beforeChange event.
+ * @method fireBeforeChangeEvent
+ * @param {String} key The attribute's name.
+ * @param {Obj} e The event object to pass to handlers.
+ */
+ fireBeforeChangeEvent: function(e) {
+ var type = 'before';
+ type += e.type.charAt(0).toUpperCase() + e.type.substr(1) + 'Change';
+ e.type = type;
+ return this.fireEvent(e.type, e);
+ },
+
+ /**
+ * Fires the attribute's change event.
+ * @method fireChangeEvent
+ * @param {String} key The attribute's name.
+ * @param {Obj} e The event object to pass to the handlers.
+ */
+ fireChangeEvent: function(e) {
+ e.type += 'Change';
+ return this.fireEvent(e.type, e);
+ },
+
+ createAttribute: function(map) {
+ return new YAHOO.util.Attribute(map, this);
+ }
+ };
+
+ YAHOO.augment(YAHOO.util.AttributeProvider, YAHOO.util.EventProvider);
+})();
+
+(function() {
+// internal shorthand
+var Dom = YAHOO.util.Dom,
+ AttributeProvider = YAHOO.util.AttributeProvider;
+
+/**
+ * Element provides an wrapper object to simplify adding
+ * event listeners, using dom methods, and managing attributes.
+ * @module element
+ * @namespace YAHOO.util
+ * @requires yahoo, dom, event
+ */
+
+/**
+ * Element provides an wrapper object to simplify adding
+ * event listeners, using dom methods, and managing attributes.
+ * @class Element
+ * @uses YAHOO.util.AttributeProvider
+ * @constructor
+ * @param el {HTMLElement | String} The html element that
+ * represents the Element.
+ * @param {Object} map A key-value map of initial config names and values
+ */
+var Element = function(el, map) {
+ this.init.apply(this, arguments);
+};
+
+Element.DOM_EVENTS = {
+ 'click': true,
+ 'dblclick': true,
+ 'keydown': true,
+ 'keypress': true,
+ 'keyup': true,
+ 'mousedown': true,
+ 'mousemove': true,
+ 'mouseout': true,
+ 'mouseover': true,
+ 'mouseup': true,
+ 'focus': true,
+ 'blur': true,
+ 'submit': true,
+ 'change': true
+};
+
+Element.prototype = {
+ /**
+ * Dom events supported by the Element instance.
+ * @property DOM_EVENTS
+ * @type Object
+ */
+ DOM_EVENTS: null,
+
+ DEFAULT_HTML_SETTER: function(value, key) {
+ var el = this.get('element');
+
+ if (el) {
+ el[key] = value;
+ }
+ },
+
+ DEFAULT_HTML_GETTER: function(key) {
+ var el = this.get('element'),
+ val;
+
+ if (el) {
+ val = el[key];
+ }
+
+ return val;
+ },
+
+ /**
+ * Wrapper for HTMLElement method.
+ * @method appendChild
+ * @param {YAHOO.util.Element || HTMLElement} child The element to append.
+ * @return {HTMLElement} The appended DOM element.
+ */
+ appendChild: function(child) {
+ child = child.get ? child.get('element') : child;
+ return this.get('element').appendChild(child);
+ },
+
+ /**
+ * Wrapper for HTMLElement method.
+ * @method getElementsByTagName
+ * @param {String} tag The tagName to collect
+ * @return {HTMLCollection} A collection of DOM elements.
+ */
+ getElementsByTagName: function(tag) {
+ return this.get('element').getElementsByTagName(tag);
+ },
+
+ /**
+ * Wrapper for HTMLElement method.
+ * @method hasChildNodes
+ * @return {Boolean} Whether or not the element has childNodes
+ */
+ hasChildNodes: function() {
+ return this.get('element').hasChildNodes();
+ },
+
+ /**
+ * Wrapper for HTMLElement method.
+ * @method insertBefore
+ * @param {HTMLElement} element The HTMLElement to insert
+ * @param {HTMLElement} before The HTMLElement to insert
+ * the element before.
+ * @return {HTMLElement} The inserted DOM element.
+ */
+ insertBefore: function(element, before) {
+ element = element.get ? element.get('element') : element;
+ before = (before && before.get) ? before.get('element') : before;
+
+ return this.get('element').insertBefore(element, before);
+ },
+
+ /**
+ * Wrapper for HTMLElement method.
+ * @method removeChild
+ * @param {HTMLElement} child The HTMLElement to remove
+ * @return {HTMLElement} The removed DOM element.
+ */
+ removeChild: function(child) {
+ child = child.get ? child.get('element') : child;
+ return this.get('element').removeChild(child);
+ },
+
+ /**
+ * Wrapper for HTMLElement method.
+ * @method replaceChild
+ * @param {HTMLElement} newNode The HTMLElement to insert
+ * @param {HTMLElement} oldNode The HTMLElement to replace
+ * @return {HTMLElement} The replaced DOM element.
+ */
+ replaceChild: function(newNode, oldNode) {
+ newNode = newNode.get ? newNode.get('element') : newNode;
+ oldNode = oldNode.get ? oldNode.get('element') : oldNode;
+ return this.get('element').replaceChild(newNode, oldNode);
+ },
+
+
+ /**
+ * Registers Element specific attributes.
+ * @method initAttributes
+ * @param {Object} map A key-value map of initial attribute configs
+ */
+ initAttributes: function(map) {
+ },
+
+ /**
+ * Adds a listener for the given event. These may be DOM or
+ * customEvent listeners. Any event that is fired via fireEvent
+ * can be listened for. All handlers receive an event object.
+ * @method addListener
+ * @param {String} type The name of the event to listen for
+ * @param {Function} fn The handler to call when the event fires
+ * @param {Any} obj A variable to pass to the handler
+ * @param {Object} scope The object to use for the scope of the handler
+ */
+ addListener: function(type, fn, obj, scope) {
+ var el = this.get('element') || this.get('id');
+ scope = scope || this;
+
+ var self = this;
+ if (!this._events[type]) { // create on the fly
+ if (el && this.DOM_EVENTS[type]) {
+ YAHOO.util.Event.addListener(el, type, function(e) {
+ if (e.srcElement && !e.target) { // supplement IE with target
+ e.target = e.srcElement;
+ }
+ self.fireEvent(type, e);
+ }, obj, scope);
+ }
+ this.createEvent(type, this);
+ }
+
+ return YAHOO.util.EventProvider.prototype.subscribe.apply(this, arguments); // notify via customEvent
+ },
+
+
+ /**
+ * Alias for addListener
+ * @method on
+ * @param {String} type The name of the event to listen for
+ * @param {Function} fn The function call when the event fires
+ * @param {Any} obj A variable to pass to the handler
+ * @param {Object} scope The object to use for the scope of the handler
+ */
+ on: function() {
+ return this.addListener.apply(this, arguments);
+ },
+
+ /**
+ * Alias for addListener
+ * @method subscribe
+ * @param {String} type The name of the event to listen for
+ * @param {Function} fn The function call when the event fires
+ * @param {Any} obj A variable to pass to the handler
+ * @param {Object} scope The object to use for the scope of the handler
+ */
+ subscribe: function() {
+ return this.addListener.apply(this, arguments);
+ },
+
+ /**
+ * Remove an event listener
+ * @method removeListener
+ * @param {String} type The name of the event to listen for
+ * @param {Function} fn The function call when the event fires
+ */
+ removeListener: function(type, fn) {
+ return this.unsubscribe.apply(this, arguments);
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method addClass
+ * @param {String} className The className to add
+ */
+ addClass: function(className) {
+ Dom.addClass(this.get('element'), className);
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method getElementsByClassName
+ * @param {String} className The className to collect
+ * @param {String} tag (optional) The tag to use in
+ * conjunction with class name
+ * @return {Array} Array of HTMLElements
+ */
+ getElementsByClassName: function(className, tag) {
+ return Dom.getElementsByClassName(className, tag,
+ this.get('element') );
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method hasClass
+ * @param {String} className The className to add
+ * @return {Boolean} Whether or not the element has the class name
+ */
+ hasClass: function(className) {
+ return Dom.hasClass(this.get('element'), className);
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method removeClass
+ * @param {String} className The className to remove
+ */
+ removeClass: function(className) {
+ return Dom.removeClass(this.get('element'), className);
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method replaceClass
+ * @param {String} oldClassName The className to replace
+ * @param {String} newClassName The className to add
+ */
+ replaceClass: function(oldClassName, newClassName) {
+ return Dom.replaceClass(this.get('element'),
+ oldClassName, newClassName);
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method setStyle
+ * @param {String} property The style property to set
+ * @param {String} value The value to apply to the style property
+ */
+ setStyle: function(property, value) {
+ return Dom.setStyle(this.get('element'), property, value); // TODO: always queuing?
+ },
+
+ /**
+ * Wrapper for Dom method.
+ * @method getStyle
+ * @param {String} property The style property to retrieve
+ * @return {String} The current value of the property
+ */
+ getStyle: function(property) {
+ return Dom.getStyle(this.get('element'), property);
+ },
+
+ /**
+ * Apply any queued set calls.
+ * @method fireQueue
+ */
+ fireQueue: function() {
+ var queue = this._queue;
+ for (var i = 0, len = queue.length; i < len; ++i) {
+ this[queue[i][0]].apply(this, queue[i][1]);
+ }
+ },
+
+ /**
+ * Appends the HTMLElement into either the supplied parentNode.
+ * @method appendTo
+ * @param {HTMLElement | Element} parentNode The node to append to
+ * @param {HTMLElement | Element} before An optional node to insert before
+ * @return {HTMLElement} The appended DOM element.
+ */
+ appendTo: function(parent, before) {
+ parent = (parent.get) ? parent.get('element') : Dom.get(parent);
+
+ this.fireEvent('beforeAppendTo', {
+ type: 'beforeAppendTo',
+ target: parent
+ });
+
+
+ before = (before && before.get) ?
+ before.get('element') : Dom.get(before);
+ var element = this.get('element');
+
+ if (!element) {
+ return false;
+ }
+
+ if (!parent) {
+ return false;
+ }
+
+ if (element.parent != parent) {
+ if (before) {
+ parent.insertBefore(element, before);
+ } else {
+ parent.appendChild(element);
+ }
+ }
+
+
+ this.fireEvent('appendTo', {
+ type: 'appendTo',
+ target: parent
+ });
+
+ return element;
+ },
+
+ get: function(key) {
+ var configs = this._configs || {},
+ el = configs.element; // avoid loop due to 'element'
+
+ if (el && !configs[key] && !YAHOO.lang.isUndefined(el.value[key]) ) {
+ this._setHTMLAttrConfig(key);
+ }
+
+ return AttributeProvider.prototype.get.call(this, key);
+ },
+
+ setAttributes: function(map, silent) {
+ // set based on configOrder
+ var done = {},
+ configOrder = this._configOrder;
+
+ // set based on configOrder
+ for (var i = 0, len = configOrder.length; i < len; ++i) {
+ if (map[configOrder[i]] !== undefined) {
+ done[configOrder[i]] = true;
+ this.set(configOrder[i], map[configOrder[i]], silent);
+ }
+ }
+
+ // unconfigured (e.g. Dom attributes)
+ for (var att in map) {
+ if (map.hasOwnProperty(att) && !done[att]) {
+ this.set(att, map[att], silent);
+ }
+ }
+ },
+
+ set: function(key, value, silent) {
+ var el = this.get('element');
+ if (!el) {
+ this._queue[this._queue.length] = ['set', arguments];
+ if (this._configs[key]) {
+ this._configs[key].value = value; // so "get" works while queueing
+
+ }
+ return;
+ }
+
+ // set it on the element if not configured and is an HTML attribute
+ if ( !this._configs[key] && !YAHOO.lang.isUndefined(el[key]) ) {
+ this._setHTMLAttrConfig(key);
+ }
+
+ return AttributeProvider.prototype.set.apply(this, arguments);
+ },
+
+ setAttributeConfig: function(key, map, init) {
+ this._configOrder.push(key);
+ AttributeProvider.prototype.setAttributeConfig.apply(this, arguments);
+ },
+
+ createEvent: function(type, scope) {
+ this._events[type] = true;
+ return AttributeProvider.prototype.createEvent.apply(this, arguments);
+ },
+
+ init: function(el, attr) {
+ this._initElement(el, attr);
+ },
+
+ destroy: function() {
+ var el = this.get('element');
+ YAHOO.util.Event.purgeElement(el, true); // purge DOM listeners recursively
+ this.unsubscribeAll(); // unsubscribe all custom events
+
+ if (el && el.parentNode) {
+ el.parentNode.removeChild(el); // pull from the DOM
+ }
+
+ // revert initial configs
+ this._queue = [];
+ this._events = {};
+ this._configs = {};
+ this._configOrder = [];
+ },
+
+ _initElement: function(el, attr) {
+ this._queue = this._queue || [];
+ this._events = this._events || {};
+ this._configs = this._configs || {};
+ this._configOrder = [];
+ attr = attr || {};
+ attr.element = attr.element || el || null;
+
+ var isReady = false; // to determine when to init HTMLElement and content
+
+ var DOM_EVENTS = Element.DOM_EVENTS;
+ this.DOM_EVENTS = this.DOM_EVENTS || {};
+
+ for (var event in DOM_EVENTS) {
+ if (DOM_EVENTS.hasOwnProperty(event)) {
+ this.DOM_EVENTS[event] = DOM_EVENTS[event];
+ }
+ }
+
+ if (typeof attr.element === 'string') { // register ID for get() access
+ this._setHTMLAttrConfig('id', { value: attr.element });
+ }
+
+ if (Dom.get(attr.element)) {
+ isReady = true;
+ this._initHTMLElement(attr);
+ this._initContent(attr);
+ }
+
+ YAHOO.util.Event.onAvailable(attr.element, function() {
+ if (!isReady) { // otherwise already done
+ this._initHTMLElement(attr);
+ }
+
+ this.fireEvent('available', { type: 'available', target: Dom.get(attr.element) });
+ }, this, true);
+
+ YAHOO.util.Event.onContentReady(attr.element, function() {
+ if (!isReady) { // otherwise already done
+ this._initContent(attr);
+ }
+ this.fireEvent('contentReady', { type: 'contentReady', target: Dom.get(attr.element) });
+ }, this, true);
+ },
+
+ _initHTMLElement: function(attr) {
+ /**
+ * The HTMLElement the Element instance refers to.
+ * @attribute element
+ * @type HTMLElement
+ */
+ this.setAttributeConfig('element', {
+ value: Dom.get(attr.element),
+ readOnly: true
+ });
+ },
+
+ _initContent: function(attr) {
+ this.initAttributes(attr);
+ this.setAttributes(attr, true);
+ this.fireQueue();
+
+ },
+
+ /**
+ * Sets the value of the property and fires beforeChange and change events.
+ * @private
+ * @method _setHTMLAttrConfig
+ * @param {YAHOO.util.Element} element The Element instance to
+ * register the config to.
+ * @param {String} key The name of the config to register
+ * @param {Object} map A key-value map of the config's params
+ */
+ _setHTMLAttrConfig: function(key, map) {
+ var el = this.get('element');
+ map = map || {};
+ map.name = key;
+
+ map.setter = map.setter || this.DEFAULT_HTML_SETTER;
+ map.getter = map.getter || this.DEFAULT_HTML_GETTER;
+
+ map.value = map.value || el[key];
+ this._configs[key] = new YAHOO.util.Attribute(map, this);
+ }
+};
+
+/**
+ * Fires when the Element's HTMLElement can be retrieved by Id.
+ * <p>See: <a href="#addListener">Element.addListener</a></p>
+ * <p><strong>Event fields:</strong><br>
+ * <code><String> type</code> available<br>
+ * <code><HTMLElement>
+ * target</code> the HTMLElement bound to this Element instance<br>
+ * <p><strong>Usage:</strong><br>
+ * <code>var handler = function(e) {var target = e.target};<br>
+ * myTabs.addListener('available', handler);</code></p>
+ * @event available
+ */
+
+/**
+ * Fires when the Element's HTMLElement subtree is rendered.
+ * <p>See: <a href="#addListener">Element.addListener</a></p>
+ * <p><strong>Event fields:</strong><br>
+ * <code><String> type</code> contentReady<br>
+ * <code><HTMLElement>
+ * target</code> the HTMLElement bound to this Element instance<br>
+ * <p><strong>Usage:</strong><br>
+ * <code>var handler = function(e) {var target = e.target};<br>
+ * myTabs.addListener('contentReady', handler);</code></p>
+ * @event contentReady
+ */
+
+/**
+ * Fires before the Element is appended to another Element.
+ * <p>See: <a href="#addListener">Element.addListener</a></p>
+ * <p><strong>Event fields:</strong><br>
+ * <code><String> type</code> beforeAppendTo<br>
+ * <code><HTMLElement/Element>
+ * target</code> the HTMLElement/Element being appended to
+ * <p><strong>Usage:</strong><br>
+ * <code>var handler = function(e) {var target = e.target};<br>
+ * myTabs.addListener('beforeAppendTo', handler);</code></p>
+ * @event beforeAppendTo
+ */
+
+/**
+ * Fires after the Element is appended to another Element.
+ * <p>See: <a href="#addListener">Element.addListener</a></p>
+ * <p><strong>Event fields:</strong><br>
+ * <code><String> type</code> appendTo<br>
+ * <code><HTMLElement/Element>
+ * target</code> the HTMLElement/Element being appended to
+ * <p><strong>Usage:</strong><br>
+ * <code>var handler = function(e) {var target = e.target};<br>
+ * myTabs.addListener('appendTo', handler);</code></p>
+ * @event appendTo
+ */
+
+YAHOO.augment(Element, AttributeProvider);
+YAHOO.util.Element = Element;
+})();
+
+YAHOO.register("element", YAHOO.util.Element, {version: "2.7.0", build: "1799"});
ToastFreeware / philipp / winterrodeln / wradmin.git / blobdiff