/* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('oop', function(Y) { /** * Supplies object inheritance and manipulation utilities. This adds * additional functionaity to what is provided in yui-base, and the * methods are applied directly to the YUI instance. This module * is required for most YUI components. * @module oop */ var L = Y.Lang, A = Y.Array, OP = Object.prototype, CLONE_MARKER = "_~yuim~_", EACH = 'each', SOME = 'some', dispatch = function(o, f, c, proto, action) { if (o && o[action] && o !== Y) { return o[action].call(o, f, c); } else { switch (A.test(o)) { case 1: return A[action](o, f, c); case 2: return A[action](Y.Array(o, 0, true), f, c); default: return Y.Object[action](o, f, c, proto); } } }; /** * The following methods are added to the YUI instance * @class YUI~oop */ /** * Applies prototype properties from the supplier to the receiver. * The receiver can be a constructor or an instance. * @method augment * @param {Function} r the object to receive the augmentation * @param {Function} s the object that supplies the properties to augment * @param ov {boolean} if true, properties already on the receiver * will be overwritten if found on the supplier. * @param wl {string[]} a whitelist. If supplied, only properties in * this list will be applied to the receiver. * @param args {Array | Any} arg or arguments to apply to the supplier * constructor when initializing. * @return {object} the augmented object * * @todo constructor optional? * @todo understanding what an instance is augmented with * @TODO best practices for overriding sequestered methods. */ Y.augment = function(r, s, ov, wl, args) { var sProto = s.prototype, newProto = null, construct = s, a = (args) ? Y.Array(args) : [], rProto = r.prototype, target = rProto || r, applyConstructor = false, sequestered, replacements, i; // working on a class, so apply constructor infrastructure if (rProto && construct) { sequestered = {}; replacements = {}; newProto = {}; // sequester all of the functions in the supplier and replace with // one that will restore all of them. Y.Object.each(sProto, function(v, k) { replacements[k] = function() { // overwrite the prototype with all of the sequestered functions, // but only if it hasn't been overridden for (i in sequestered) { if (sequestered.hasOwnProperty(i) && (this[i] === replacements[i])) { this[i] = sequestered[i]; } } // apply the constructor construct.apply(this, a); // apply the original sequestered function return sequestered[k].apply(this, arguments); }; if ((!wl || (k in wl)) && (ov || !(k in this))) { if (L.isFunction(v)) { // sequester the function sequestered[k] = v; // replace the sequestered function with a function that will // restore all sequestered functions and exectue the constructor. this[k] = replacements[k]; } else { this[k] = v; } } }, newProto, true); // augmenting an instance, so apply the constructor immediately } else { applyConstructor = true; } Y.mix(target, newProto || sProto, ov, wl); if (applyConstructor) { s.apply(target, a); } return r; }; /** * Applies object properties from the supplier to the receiver. If * the target has the property, and the property is an object, the target * object will be augmented with the supplier's value. If the property * is an array, the suppliers value will be appended to the target. * @method aggregate * @param {Function} r the object to receive the augmentation * @param {Function} s the object that supplies the properties to augment * @param ov {boolean} if true, properties already on the receiver * will be overwritten if found on the supplier. * @param wl {string[]} a whitelist. If supplied, only properties in * this list will be applied to the receiver. * @return {object} the extended object */ Y.aggregate = function(r, s, ov, wl) { return Y.mix(r, s, ov, wl, 0, true); }; /** * Utility to set up the prototype, constructor and superclass properties to * support an inheritance strategy that can chain constructors and methods. * Static members will not be inherited. * * @method extend * @param {Function} r the object to modify * @param {Function} s the object to inherit * @param {Object} px prototype properties to add/override * @param {Object} sx static properties to add/override * @return {YUI} the YUI instance */ Y.extend = function(r, s, px, sx) { if (!s||!r) { // @TODO error symbols Y.error("extend failed, verify dependencies"); } var sp = s.prototype, rp=Y.Object(sp); r.prototype=rp; rp.constructor=r; r.superclass=sp; // assign constructor property if (s != Object && sp.constructor == OP.constructor) { sp.constructor=s; } // add prototype overrides if (px) { Y.mix(rp, px, true); } // add object overrides if (sx) { Y.mix(r, sx, true); } return r; }; /** * Executes the supplied function for each item in * a collection. Supports arrays, objects, and * Y.NodeLists * @method each * @param o the object to iterate * @param f the function to execute. This function * receives the value, key, and object as parameters * @param proto if true, prototype properties are * iterated on objects * @return {YUI} the YUI instance */ Y.each = function(o, f, c, proto) { return dispatch(o, f, c, proto, EACH); }; /* * Executes the supplied function for each item in * a collection. The operation stops if the function * returns true. Supports arrays, objects, and * Y.NodeLists. * @method some * @param o the object to iterate * @param f the function to execute. This function * receives the value, key, and object as parameters * @param proto if true, prototype properties are * iterated on objects * @return {boolean} true if the function ever returns true, false otherwise */ Y.some = function(o, f, c, proto) { return dispatch(o, f, c, proto, SOME); }; /** * Deep obj/array copy. Function clones are actually * wrappers around the original function. * Array-like objects are treated as arrays. * Primitives are returned untouched. Optionally, a * function can be provided to handle other data types, * filter keys, validate values, etc. * * @method clone * @param o what to clone * @param safe {boolean} if true, objects will not have prototype * items from the source. If false, they will. In this case, the * original is initially protected, but the clone is not completely immune * from changes to the source object prototype. Also, cloned prototype * items that are deleted from the clone will result in the value * of the source prototype being exposed. If operating on a non-safe * clone, items should be nulled out rather than deleted. * @param f optional function to apply to each item in a collection; * it will be executed prior to applying the value to * the new object. Return false to prevent the copy. * @param c optional execution context for f * @param owner Owner object passed when clone is iterating an * object. Used to set up context for cloned functions. * @return {Array|Object} the cloned object */ Y.clone = function(o, safe, f, c, owner, cloned) { if (!L.isObject(o)) { return o; } // @TODO cloning YUI instances doesn't currently work if (o instanceof YUI) { return o; } var o2, marked = cloned || {}, stamp, each = Y.each || Y.Object.each; switch (L.type(o)) { case 'date': return new Date(o); case 'regexp': // return new RegExp(o.source); // if we do this we need to set the flags too return o; case 'function': // o2 = Y.bind(o, owner); // break; return o; case 'array': o2 = []; break; default: // #2528250 only one clone of a given object should be created. if (o[CLONE_MARKER]) { return marked[o[CLONE_MARKER]]; } stamp = Y.guid(); o2 = (safe) ? {} : Y.Object(o); o[CLONE_MARKER] = stamp; marked[stamp] = o; } // #2528250 don't try to clone element properties if (!o.addEventListener && !o.attachEvent) { each(o, function(v, k) { if (!f || (f.call(c || this, v, k, this, o) !== false)) { if (k !== CLONE_MARKER) { if (k == 'prototype') { // skip the prototype // } else if (o[k] === o) { // this[k] = this; } else { this[k] = Y.clone(v, safe, f, c, owner || o, marked); } } } }, o2); } if (!cloned) { Y.Object.each(marked, function(v, k) { delete v[CLONE_MARKER]; }); marked = null; } return o2; }; /** * Returns a function that will execute the supplied function in the * supplied object's context, optionally adding any additional * supplied parameters to the beginning of the arguments collection the * supplied to the function. * * @method bind * @param f {Function|String} the function to bind, or a function name * to execute on the context object * @param c the execution context * @param args* 0..n arguments to include before the arguments the * function is executed with. * @return {function} the wrapped function */ Y.bind = function(f, c) { var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null; return function () { var fn = L.isString(f) ? c[f] : f, args = (xargs) ? xargs.concat(Y.Array(arguments, 0, true)) : arguments; return fn.apply(c || fn, args); }; }; /** * Returns a function that will execute the supplied function in the * supplied object's context, optionally adding any additional * supplied parameters to the end of the arguments the function * is executed with. * * @method rbind * @param f {Function|String} the function to bind, or a function name * to execute on the context object * @param c the execution context * @param args* 0..n arguments to append to the end of arguments collection * supplied to the function * @return {function} the wrapped function */ Y.rbind = function(f, c) { var xargs = arguments.length > 2 ? Y.Array(arguments, 2, true) : null; return function () { var fn = L.isString(f) ? c[f] : f, args = (xargs) ? Y.Array(arguments, 0, true).concat(xargs) : arguments; return fn.apply(c || fn, args); }; }; }, '3.1.2' ); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('event-custom-base', function(Y) { /** * Custom event engine, DOM event listener abstraction layer, synthetic DOM * events. * @module event-custom */ Y.Env.evt = { handles: {}, plugins: {} }; /** * Custom event engine, DOM event listener abstraction layer, synthetic DOM * events. * @module event-custom * @submodule event-custom-base */ (function() { /** * Allows for the insertion of methods that are executed before or after * a specified method * @class Do * @static */ var BEFORE = 0, AFTER = 1; Y.Do = { /** * Cache of objects touched by the utility * @property objs * @static */ objs: {}, /** * Execute the supplied method before the specified function * @method before * @param fn {Function} the function to execute * @param obj the object hosting the method to displace * @param sFn {string} the name of the method to displace * @param c The execution context for fn * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * when the event fires. * @return {string} handle for the subscription * @static */ before: function(fn, obj, sFn, c) { var f = fn, a; if (c) { a = [fn, c].concat(Y.Array(arguments, 4, true)); f = Y.rbind.apply(Y, a); } return this._inject(BEFORE, f, obj, sFn); }, /** * Execute the supplied method after the specified function * @method after * @param fn {Function} the function to execute * @param obj the object hosting the method to displace * @param sFn {string} the name of the method to displace * @param c The execution context for fn * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * @return {string} handle for the subscription * @static */ after: function(fn, obj, sFn, c) { var f = fn, a; if (c) { a = [fn, c].concat(Y.Array(arguments, 4, true)); f = Y.rbind.apply(Y, a); } return this._inject(AFTER, f, obj, sFn); }, /** * Execute the supplied method after the specified function * @method _inject * @param when {string} before or after * @param fn {Function} the function to execute * @param obj the object hosting the method to displace * @param sFn {string} the name of the method to displace * @param c The execution context for fn * @return {string} handle for the subscription * @private * @static */ _inject: function(when, fn, obj, sFn) { // object id var id = Y.stamp(obj), o, sid; if (! this.objs[id]) { // create a map entry for the obj if it doesn't exist this.objs[id] = {}; } o = this.objs[id]; if (! o[sFn]) { // create a map entry for the method if it doesn't exist o[sFn] = new Y.Do.Method(obj, sFn); // re-route the method to our wrapper obj[sFn] = function() { return o[sFn].exec.apply(o[sFn], arguments); }; } // subscriber id sid = id + Y.stamp(fn) + sFn; // register the callback o[sFn].register(sid, fn, when); return new Y.EventHandle(o[sFn], sid); }, /** * Detach a before or after subscription * @method detach * @param handle {string} the subscription handle */ detach: function(handle) { if (handle.detach) { handle.detach(); } }, _unload: function(e, me) { } }; ////////////////////////////////////////////////////////////////////////// /** * Wrapper for a displaced method with aop enabled * @class Do.Method * @constructor * @param obj The object to operate on * @param sFn The name of the method to displace */ Y.Do.Method = function(obj, sFn) { this.obj = obj; this.methodName = sFn; this.method = obj[sFn]; this.before = {}; this.after = {}; }; /** * Register a aop subscriber * @method register * @param sid {string} the subscriber id * @param fn {Function} the function to execute * @param when {string} when to execute the function */ Y.Do.Method.prototype.register = function (sid, fn, when) { if (when) { this.after[sid] = fn; } else { this.before[sid] = fn; } }; /** * Unregister a aop subscriber * @method delete * @param sid {string} the subscriber id * @param fn {Function} the function to execute * @param when {string} when to execute the function */ Y.Do.Method.prototype._delete = function (sid) { delete this.before[sid]; delete this.after[sid]; }; /** * Execute the wrapped method * @method exec */ Y.Do.Method.prototype.exec = function () { var args = Y.Array(arguments, 0, true), i, ret, newRet, bf = this.before, af = this.after, prevented = false; // execute before for (i in bf) { if (bf.hasOwnProperty(i)) { ret = bf[i].apply(this.obj, args); if (ret) { switch (ret.constructor) { case Y.Do.Halt: return ret.retVal; case Y.Do.AlterArgs: args = ret.newArgs; break; case Y.Do.Prevent: prevented = true; break; default: } } } } // execute method if (!prevented) { ret = this.method.apply(this.obj, args); } // execute after methods. for (i in af) { if (af.hasOwnProperty(i)) { newRet = af[i].apply(this.obj, args); // Stop processing if a Halt object is returned if (newRet && newRet.constructor == Y.Do.Halt) { return newRet.retVal; // Check for a new return value } else if (newRet && newRet.constructor == Y.Do.AlterReturn) { ret = newRet.newRetVal; } } } return ret; }; ////////////////////////////////////////////////////////////////////////// /** * Return an AlterArgs object when you want to change the arguments that * were passed into the function. An example would be a service that scrubs * out illegal characters prior to executing the core business logic. * @class Do.AlterArgs */ Y.Do.AlterArgs = function(msg, newArgs) { this.msg = msg; this.newArgs = newArgs; }; /** * Return an AlterReturn object when you want to change the result returned * from the core method to the caller * @class Do.AlterReturn */ Y.Do.AlterReturn = function(msg, newRetVal) { this.msg = msg; this.newRetVal = newRetVal; }; /** * Return a Halt object when you want to terminate the execution * of all subsequent subscribers as well as the wrapped method * if it has not exectued yet. * @class Do.Halt */ Y.Do.Halt = function(msg, retVal) { this.msg = msg; this.retVal = retVal; }; /** * Return a Prevent object when you want to prevent the wrapped function * from executing, but want the remaining listeners to execute * @class Do.Prevent */ Y.Do.Prevent = function(msg) { this.msg = msg; }; /** * Return an Error object when you want to terminate the execution * of all subsequent method calls. * @class Do.Error * @deprecated use Y.Do.Halt or Y.Do.Prevent */ Y.Do.Error = Y.Do.Halt; ////////////////////////////////////////////////////////////////////////// // Y["Event"] && Y.Event.addListener(window, "unload", Y.Do._unload, Y.Do); })(); /** * Custom event engine, DOM event listener abstraction layer, synthetic DOM * events. * @module event-custom * @submodule event-custom-base */ /** * Return value from all subscribe operations * @class EventHandle * @constructor * @param evt {CustomEvent} the custom event * @param sub {Subscriber} the subscriber */ // var onsubscribeType = "_event:onsub", var AFTER = 'after', CONFIGS = [ 'broadcast', 'monitored', 'bubbles', 'context', 'contextFn', 'currentTarget', 'defaultFn', 'defaultTargetOnly', 'details', 'emitFacade', 'fireOnce', 'async', 'host', 'preventable', 'preventedFn', 'queuable', 'silent', 'stoppedFn', 'target', 'type' ], YUI3_SIGNATURE = 9, YUI_LOG = 'yui:log'; Y.EventHandle = function(evt, sub) { /** * The custom event * @type CustomEvent */ this.evt = evt; /** * The subscriber object * @type Subscriber */ this.sub = sub; }; Y.EventHandle.prototype = { /** * Detaches this subscriber * @method detach */ detach: function() { var evt = this.evt, detached = 0, i; if (evt) { if (Y.Lang.isArray(evt)) { for (i=0; i 2) { // this.log('CustomEvent context and silent are now in the config', 'warn', 'Event'); // } o = o || {}; this.id = Y.stamp(this); /** * The type of event, returned to subscribers when the event fires * @property type * @type string */ this.type = type; /** * The context the the event will fire from by default. Defaults to the YUI * instance. * @property context * @type object */ this.context = Y; /** * Monitor when an event is attached or detached. * * @property monitored * @type boolean */ // this.monitored = false; this.logSystem = (type == YUI_LOG); /** * If 0, this event does not broadcast. If 1, the YUI instance is notified * every time this event fires. If 2, the YUI instance and the YUI global * (if event is enabled on the global) are notified every time this event * fires. * @property broadcast * @type int */ // this.broadcast = 0; /** * By default all custom events are logged in the debug build, set silent * to true to disable debug outpu for this event. * @property silent * @type boolean */ this.silent = this.logSystem; /** * Specifies whether this event should be queued when the host is actively * processing an event. This will effect exectution order of the callbacks * for the various events. * @property queuable * @type boolean * @default false */ // this.queuable = false; /** * The subscribers to this event * @property subscribers * @type Subscriber{} */ this.subscribers = {}; /** * 'After' subscribers * @property afters * @type Subscriber{} */ this.afters = {}; /** * This event has fired if true * * @property fired * @type boolean * @default false; */ // this.fired = false; /** * An array containing the arguments the custom event * was last fired with. * @property firedWith * @type Array */ // this.firedWith; /** * This event should only fire one time if true, and if * it has fired, any new subscribers should be notified * immediately. * * @property fireOnce * @type boolean * @default false; */ // this.fireOnce = false; /** * fireOnce listeners will fire syncronously unless async * is set to true * @property async * @type boolean * @default false */ //this.async = false; /** * Flag for stopPropagation that is modified during fire() * 1 means to stop propagation to bubble targets. 2 means * to also stop additional subscribers on this target. * @property stopped * @type int */ // this.stopped = 0; /** * Flag for preventDefault that is modified during fire(). * if it is not 0, the default behavior for this event * @property prevented * @type int */ // this.prevented = 0; /** * Specifies the host for this custom event. This is used * to enable event bubbling * @property host * @type EventTarget */ // this.host = null; /** * The default function to execute after event listeners * have fire, but only if the default action was not * prevented. * @property defaultFn * @type Function */ // this.defaultFn = null; /** * The function to execute if a subscriber calls * stopPropagation or stopImmediatePropagation * @property stoppedFn * @type Function */ // this.stoppedFn = null; /** * The function to execute if a subscriber calls * preventDefault * @property preventedFn * @type Function */ // this.preventedFn = null; /** * Specifies whether or not this event's default function * can be cancelled by a subscriber by executing preventDefault() * on the event facade * @property preventable * @type boolean * @default true */ this.preventable = true; /** * Specifies whether or not a subscriber can stop the event propagation * via stopPropagation(), stopImmediatePropagation(), or halt() * * Events can only bubble if emitFacade is true. * * @property bubbles * @type boolean * @default true */ this.bubbles = true; /** * Supports multiple options for listener signatures in order to * port YUI 2 apps. * @property signature * @type int * @default 9 */ this.signature = YUI3_SIGNATURE; this.subCount = 0; this.afterCount = 0; // this.hasSubscribers = false; // this.hasAfters = false; /** * If set to true, the custom event will deliver an EventFacade object * that is similar to a DOM event object. * @property emitFacade * @type boolean * @default false */ // this.emitFacade = false; this.applyConfig(o, true); // this.log("Creating " + this.type); }; Y.CustomEvent.prototype = { hasSubs: function(when) { var s = this.subCount, a = this.afterCount, sib = this.sibling; if (sib) { s += sib.subCount; a += sib.afterCount; } if (when) { return (when == 'after') ? a : s; } return (s + a); }, /** * Monitor the event state for the subscribed event. The first parameter * is what should be monitored, the rest are the normal parameters when * subscribing to an event. * @method monitor * @param what {string} what to monitor ('detach', 'attach', 'publish') * @return {EventHandle} return value from the monitor event subscription */ monitor: function(what) { this.monitored = true; var type = this.id + '|' + this.type + '_' + what, args = Y.Array(arguments, 0, true); args[0] = type; return this.host.on.apply(this.host, args); }, /** * Get all of the subscribers to this event and any sibling event * @return {Array} first item is the on subscribers, second the after */ getSubs: function() { var s = Y.merge(this.subscribers), a = Y.merge(this.afters), sib = this.sibling; if (sib) { Y.mix(s, sib.subscribers); Y.mix(a, sib.afters); } return [s, a]; }, /** * Apply configuration properties. Only applies the CONFIG whitelist * @method applyConfig * @param o hash of properties to apply * @param force {boolean} if true, properties that exist on the event * will be overwritten. */ applyConfig: function(o, force) { if (o) { Y.mix(this, o, force, CONFIGS); } }, _on: function(fn, context, args, when) { if (!fn) { this.log("Invalid callback for CE: " + this.type); } var s = new Y.Subscriber(fn, context, args, when); if (this.fireOnce && this.fired) { if (this.async) { setTimeout(Y.bind(this._notify, this, s, this.firedWith), 0); } else { this._notify(s, this.firedWith); } } if (when == AFTER) { this.afters[s.id] = s; this.afterCount++; } else { this.subscribers[s.id] = s; this.subCount++; } return new Y.EventHandle(this, s); }, /** * Listen for this event * @method subscribe * @param {Function} fn The function to execute * @return {EventHandle} Unsubscribe handle * @deprecated use on */ subscribe: function(fn, context) { var a = (arguments.length > 2) ? Y.Array(arguments, 2, true): null; return this._on(fn, context, a, true); }, /** * Listen for this event * @method on * @param {Function} fn The function to execute * @param context {object} optional execution context. * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * when the event fires. * @return {EventHandle} An object with a detach method to detch the handler(s) */ on: function(fn, context) { var a = (arguments.length > 2) ? Y.Array(arguments, 2, true): null; this.host._monitor('attach', this.type, { args: arguments }); return this._on(fn, context, a, true); }, /** * Listen for this event after the normal subscribers have been notified and * the default behavior has been applied. If a normal subscriber prevents the * default behavior, it also prevents after listeners from firing. * @method after * @param {Function} fn The function to execute * @param context {object} optional execution context. * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * when the event fires. * @return {EventHandle} handle Unsubscribe handle */ after: function(fn, context) { var a = (arguments.length > 2) ? Y.Array(arguments, 2, true): null; return this._on(fn, context, a, AFTER); }, /** * Detach listeners. * @method detach * @param {Function} fn The subscribed function to remove, if not supplied * all will be removed * @param {Object} context The context object passed to subscribe. * @return {int} returns the number of subscribers unsubscribed */ detach: function(fn, context) { // unsubscribe handle if (fn && fn.detach) { return fn.detach(); } var found = 0, subs = this.subscribers, i, s; for (i in subs) { if (subs.hasOwnProperty(i)) { s = subs[i]; if (s && (!fn || fn === s.fn)) { this._delete(s); found++; } } } return found; }, /** * Detach listeners. * @method unsubscribe * @param {Function} fn The subscribed function to remove, if not supplied * all will be removed * @param {Object} context The context object passed to subscribe. * @return {int|undefined} returns the number of subscribers unsubscribed * @deprecated use detach */ unsubscribe: function() { return this.detach.apply(this, arguments); }, /** * Notify a single subscriber * @method _notify * @param s {Subscriber} the subscriber * @param args {Array} the arguments array to apply to the listener * @private */ _notify: function(s, args, ef) { this.log(this.type + "->" + "sub: " + s.id); var ret; ret = s.notify(args, this); if (false === ret || this.stopped > 1) { this.log(this.type + " cancelled by subscriber"); return false; } return true; }, /** * Logger abstraction to centralize the application of the silent flag * @method log * @param msg {string} message to log * @param cat {string} log category */ log: function(msg, cat) { if (!this.silent) { } }, /** * Notifies the subscribers. The callback functions will be executed * from the context specified when the event was created, and with the * following parameters: * * @method fire * @param {Object*} arguments an arbitrary set of parameters to pass to * the handler. * @return {boolean} false if one of the subscribers returned false, * true otherwise * */ fire: function() { if (this.fireOnce && this.fired) { this.log('fireOnce event: ' + this.type + ' already fired'); return true; } else { var args = Y.Array(arguments, 0, true); // this doesn't happen if the event isn't published // this.host._monitor('fire', this.type, args); this.fired = true; this.firedWith = args; if (this.emitFacade) { return this.fireComplex(args); } else { return this.fireSimple(args); } } }, fireSimple: function(args) { this.stopped = 0; this.prevented = 0; if (this.hasSubs()) { // this._procSubs(Y.merge(this.subscribers, this.afters), args); var subs = this.getSubs(); this._procSubs(subs[0], args); this._procSubs(subs[1], args); } this._broadcast(args); return this.stopped ? false : true; }, // Requires the event-custom-complex module for full funcitonality. fireComplex: function(args) { args[0] = args[0] || {}; return this.fireSimple(args); }, _procSubs: function(subs, args, ef) { var s, i; for (i in subs) { if (subs.hasOwnProperty(i)) { s = subs[i]; if (s && s.fn) { if (false === this._notify(s, args, ef)) { this.stopped = 2; } if (this.stopped == 2) { return false; } } } } return true; }, _broadcast: function(args) { if (!this.stopped && this.broadcast) { var a = Y.Array(args); a.unshift(this.type); if (this.host !== Y) { Y.fire.apply(Y, a); } if (this.broadcast == 2) { Y.Global.fire.apply(Y.Global, a); } } }, /** * Removes all listeners * @method unsubscribeAll * @return {int} The number of listeners unsubscribed * @deprecated use detachAll */ unsubscribeAll: function() { return this.detachAll.apply(this, arguments); }, /** * Removes all listeners * @method detachAll * @return {int} The number of listeners unsubscribed */ detachAll: function() { return this.detach(); }, /** * @method _delete * @param subscriber object * @private */ _delete: function(s) { if (s) { delete s.fn; delete s.context; delete this.subscribers[s.id]; delete this.afters[s.id]; } this.host._monitor('detach', this.type, { ce: this, sub: s }); } }; ///////////////////////////////////////////////////////////////////// /** * Stores the subscriber information to be used when the event fires. * @param {Function} fn The wrapped function to execute * @param {Object} context The value of the keyword 'this' in the listener * @param {Array} args* 0..n additional arguments to supply the listener * * @class Subscriber * @constructor */ Y.Subscriber = function(fn, context, args) { /** * The callback that will be execute when the event fires * This is wrapped by Y.rbind if obj was supplied. * @property fn * @type Function */ this.fn = fn; /** * Optional 'this' keyword for the listener * @property context * @type Object */ this.context = context; /** * Unique subscriber id * @property id * @type String */ this.id = Y.stamp(this); /** * Additional arguments to propagate to the subscriber * @property args * @type Array */ this.args = args; /** * Custom events for a given fire transaction. * @property events * @type {EventTarget} */ // this.events = null; /** * This listener only reacts to the event once * @property once */ // this.once = false; }; Y.Subscriber.prototype = { _notify: function(c, args, ce) { var a = this.args, ret; switch (ce.signature) { case 0: ret = this.fn.call(c, ce.type, args, c); break; case 1: ret = this.fn.call(c, args[0] || null, c); break; default: if (a || args) { args = args || []; a = (a) ? args.concat(a) : args; ret = this.fn.apply(c, a); } else { ret = this.fn.call(c); } } if (this.once) { ce._delete(this); } return ret; }, /** * Executes the subscriber. * @method notify * @param args {Array} Arguments array for the subscriber * @param ce {CustomEvent} The custom event that sent the notification */ notify: function(args, ce) { var c = this.context, ret = true; if (!c) { c = (ce.contextFn) ? ce.contextFn() : ce.context; } // only catch errors if we will not re-throw them. if (Y.config.throwFail) { ret = this._notify(c, args, ce); } else { try { ret = this._notify(c, args, ce); } catch(e) { Y.error(this + ' failed: ' + e.message, e); } } return ret; }, /** * Returns true if the fn and obj match this objects properties. * Used by the unsubscribe method to match the right subscriber. * * @method contains * @param {Function} fn the function to execute * @param {Object} context optional 'this' keyword for the listener * @return {boolean} true if the supplied arguments match this * subscriber's signature. */ contains: function(fn, context) { if (context) { return ((this.fn == fn) && this.context == context); } else { return (this.fn == fn); } } }; /** * Custom event engine, DOM event listener abstraction layer, synthetic DOM * events. * @module event-custom * @submodule event-custom-base */ (function() { /** * EventTarget provides the implementation for any object to * publish, subscribe and fire to custom events, and also * alows other EventTargets to target the object with events * sourced from the other object. * EventTarget is designed to be used with Y.augment to wrap * EventCustom in an interface that allows events to be listened to * and fired by name. This makes it possible for implementing code to * subscribe to an event that either has not been created yet, or will * not be created at all. * @class EventTarget * @param opts a configuration object * @config emitFacade {boolean} if true, all events will emit event * facade payloads by default (default false) * @config prefix {string} the prefix to apply to non-prefixed event names * @config chain {boolean} if true, on/after/detach return the host to allow * chaining, otherwise they return an EventHandle (default false) */ var L = Y.Lang, PREFIX_DELIMITER = ':', CATEGORY_DELIMITER = '|', AFTER_PREFIX = '~AFTER~', _wildType = Y.cached(function(type) { return type.replace(/(.*)(:)(.*)/, "*$2$3"); }), /** * If the instance has a prefix attribute and the * event type is not prefixed, the instance prefix is * applied to the supplied type. * @method _getType * @private */ _getType = Y.cached(function(type, pre) { if (!pre || !L.isString(type) || type.indexOf(PREFIX_DELIMITER) > -1) { return type; } return pre + PREFIX_DELIMITER + type; }), /** * Returns an array with the detach key (if provided), * and the prefixed event name from _getType * Y.on('detachcategory| menu:click', fn) * @method _parseType * @private */ _parseType = Y.cached(function(type, pre) { var t = type, detachcategory, after, i; if (!L.isString(t)) { return t; } i = t.indexOf(AFTER_PREFIX); if (i > -1) { after = true; t = t.substr(AFTER_PREFIX.length); } i = t.indexOf(CATEGORY_DELIMITER); if (i > -1) { detachcategory = t.substr(0, (i)); t = t.substr(i+1); if (t == '*') { t = null; } } // detach category, full type with instance prefix, is this an after listener, short type return [detachcategory, (pre) ? _getType(t, pre) : t, after, t]; }), ET = function(opts) { var o = (L.isObject(opts)) ? opts : {}; this._yuievt = this._yuievt || { id: Y.guid(), events: {}, targets: {}, config: o, chain: ('chain' in o) ? o.chain : Y.config.chain, bubbling: false, defaults: { context: o.context || this, host: this, emitFacade: o.emitFacade, fireOnce: o.fireOnce, queuable: o.queuable, monitored: o.monitored, broadcast: o.broadcast, defaultTargetOnly: o.defaulTargetOnly, bubbles: ('bubbles' in o) ? o.bubbles : true } }; }; ET.prototype = { /** * Listen to a custom event hosted by this object one time. * This is the equivalent to on except the * listener is immediatelly detached when it is executed. * @method once * @param type {string} The type of the event * @param fn {Function} The callback * @param context {object} optional execution context. * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * @return the event target or a detach handle per 'chain' config */ once: function() { var handle = this.on.apply(this, arguments); handle.sub.once = true; return handle; }, /** * Subscribe to a custom event hosted by this object * @method on * @param type {string} The type of the event * @param fn {Function} The callback * @param context {object} optional execution context. * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * @return the event target or a detach handle per 'chain' config */ on: function(type, fn, context) { var parts = _parseType(type, this._yuievt.config.prefix), f, c, args, ret, ce, detachcategory, handle, store = Y.Env.evt.handles, after, adapt, shorttype, Node = Y.Node, n, domevent, isArr; // full name, args, detachcategory, after this._monitor('attach', parts[1], { args: arguments, category: parts[0], after: parts[2] }); if (L.isObject(type)) { if (L.isFunction(type)) { return Y.Do.before.apply(Y.Do, arguments); } f = fn; c = context; args = Y.Array(arguments, 0, true); ret = {}; if (L.isArray(type)) { isArr = true; } else { after = type._after; delete type._after; } Y.each(type, function(v, k) { if (L.isObject(v)) { f = v.fn || ((L.isFunction(v)) ? v : f); c = v.context || c; } args[0] = (isArr) ? v : ((after) ? AFTER_PREFIX + k : k); args[1] = f; args[2] = c; ret[k] = this.on.apply(this, args); }, this); return (this._yuievt.chain) ? this : new Y.EventHandle(ret); } detachcategory = parts[0]; after = parts[2]; shorttype = parts[3]; // extra redirection so we catch adaptor events too. take a look at this. if (Node && (this instanceof Node) && (shorttype in Node.DOM_EVENTS)) { args = Y.Array(arguments, 0, true); args.splice(2, 0, Node.getDOMNode(this)); return Y.on.apply(Y, args); } type = parts[1]; if (this instanceof YUI) { adapt = Y.Env.evt.plugins[type]; args = Y.Array(arguments, 0, true); args[0] = shorttype; if (Node) { n = args[2]; if (n instanceof Y.NodeList) { n = Y.NodeList.getDOMNodes(n); } else if (n instanceof Node) { n = Node.getDOMNode(n); } domevent = (shorttype in Node.DOM_EVENTS); // Captures both DOM events and event plugins. if (domevent) { args[2] = n; } } // check for the existance of an event adaptor if (adapt) { handle = adapt.on.apply(Y, args); } else if ((!type) || domevent) { handle = Y.Event._attach(args); } } if (!handle) { ce = this._yuievt.events[type] || this.publish(type); handle = ce._on(fn, context, (arguments.length > 3) ? Y.Array(arguments, 3, true) : null, (after) ? 'after' : true); } if (detachcategory) { store[detachcategory] = store[detachcategory] || {}; store[detachcategory][type] = store[detachcategory][type] || []; store[detachcategory][type].push(handle); } return (this._yuievt.chain) ? this : handle; }, /** * subscribe to an event * @method subscribe * @deprecated use on */ subscribe: function() { return this.on.apply(this, arguments); }, /** * Detach one or more listeners the from the specified event * @method detach * @param type {string|Object} Either the handle to the subscriber or the * type of event. If the type * is not specified, it will attempt to remove * the listener from all hosted events. * @param fn {Function} The subscribed function to unsubscribe, if not * supplied, all subscribers will be removed. * @param context {Object} The custom object passed to subscribe. This is * optional, but if supplied will be used to * disambiguate multiple listeners that are the same * (e.g., you subscribe many object using a function * that lives on the prototype) * @return {EventTarget} the host */ detach: function(type, fn, context) { var evts = this._yuievt.events, i, Node = Y.Node, isNode = Node && (this instanceof Node); // detachAll disabled on the Y instance. if (!type && (this !== Y)) { for (i in evts) { if (evts.hasOwnProperty(i)) { evts[i].detach(fn, context); } } if (isNode) { Y.Event.purgeElement(Node.getDOMNode(this)); } return this; } var parts = _parseType(type, this._yuievt.config.prefix), detachcategory = L.isArray(parts) ? parts[0] : null, shorttype = (parts) ? parts[3] : null, handle, adapt, store = Y.Env.evt.handles, cat, args, ce, keyDetacher = function(lcat, ltype) { var handles = lcat[ltype]; if (handles) { while (handles.length) { handle = handles.pop(); handle.detach(); } } }; if (detachcategory) { cat = store[detachcategory]; type = parts[1]; if (cat) { if (type) { keyDetacher(cat, type); } else { for (i in cat) { if (cat.hasOwnProperty(i)) { keyDetacher(cat, i); } } } return this; } // If this is an event handle, use it to detach } else if (L.isObject(type) && type.detach) { type.detach(); return this; // extra redirection so we catch adaptor events too. take a look at this. } else if (isNode && ((!shorttype) || (shorttype in Node.DOM_EVENTS))) { args = Y.Array(arguments, 0, true); args[2] = Node.getDOMNode(this); Y.detach.apply(Y, args); return this; } adapt = Y.Env.evt.plugins[shorttype]; // The YUI instance handles DOM events and adaptors if (this instanceof YUI) { args = Y.Array(arguments, 0, true); // use the adaptor specific detach code if if (adapt && adapt.detach) { adapt.detach.apply(Y, args); return this; // DOM event fork } else if (!type || (!adapt && Node && (type in Node.DOM_EVENTS))) { args[0] = type; Y.Event.detach.apply(Y.Event, args); return this; } } // ce = evts[type]; ce = evts[parts[1]]; if (ce) { ce.detach(fn, context); } return this; }, /** * detach a listener * @method unsubscribe * @deprecated use detach */ unsubscribe: function() { return this.detach.apply(this, arguments); }, /** * Removes all listeners from the specified event. If the event type * is not specified, all listeners from all hosted custom events will * be removed. * @method detachAll * @param type {string} The type, or name of the event */ detachAll: function(type) { return this.detach(type); }, /** * Removes all listeners from the specified event. If the event type * is not specified, all listeners from all hosted custom events will * be removed. * @method unsubscribeAll * @param type {string} The type, or name of the event * @deprecated use detachAll */ unsubscribeAll: function() { return this.detachAll.apply(this, arguments); }, /** * Creates a new custom event of the specified type. If a custom event * by that name already exists, it will not be re-created. In either * case the custom event is returned. * * @method publish * * @param type {string} the type, or name of the event * @param opts {object} optional config params. Valid properties are: * * * * @return {CustomEvent} the custom event * */ publish: function(type, opts) { var events, ce, ret, pre = this._yuievt.config.prefix; type = (pre) ? _getType(type, pre) : type; this._monitor('publish', type, { args: arguments }); if (L.isObject(type)) { ret = {}; Y.each(type, function(v, k) { ret[k] = this.publish(k, v || opts); }, this); return ret; } events = this._yuievt.events; ce = events[type]; if (ce) { // ce.log("publish applying new config to published event: '"+type+"' exists", 'info', 'event'); if (opts) { ce.applyConfig(opts, true); } } else { // apply defaults ce = new Y.CustomEvent(type, (opts) ? Y.mix(opts, this._yuievt.defaults) : this._yuievt.defaults); events[type] = ce; } // make sure we turn the broadcast flag off if this // event was published as a result of bubbling // if (opts instanceof Y.CustomEvent) { // events[type].broadcast = false; // } return events[type]; }, /** * This is the entry point for the event monitoring system. * You can monitor 'attach', 'detach', 'fire', and 'publish'. * When configured, these events generate an event. click -> * click_attach, click_detach, click_publish -- these can * be subscribed to like other events to monitor the event * system. Inividual published events can have monitoring * turned on or off (publish can't be turned off before it * it published) by setting the events 'monitor' config. * * @private */ _monitor: function(what, type, o) { var monitorevt, ce = this.getEvent(type); if ((this._yuievt.config.monitored && (!ce || ce.monitored)) || (ce && ce.monitored)) { monitorevt = type + '_' + what; o.monitored = what; this.fire.call(this, monitorevt, o); } }, /** * Fire a custom event by name. The callback functions will be executed * from the context specified when the event was created, and with the * following parameters. * * If the custom event object hasn't been created, then the event hasn't * been published and it has no subscribers. For performance sake, we * immediate exit in this case. This means the event won't bubble, so * if the intention is that a bubble target be notified, the event must * be published on this object first. * * The first argument is the event type, and any additional arguments are * passed to the listeners as parameters. If the first of these is an * object literal, and the event is configured to emit an event facade, * that object is mixed into the event facade and the facade is provided * in place of the original object. * * @method fire * @param type {String|Object} The type of the event, or an object that contains * a 'type' property. * @param arguments {Object*} an arbitrary set of parameters to pass to * the handler. If the first of these is an object literal and the event is * configured to emit an event facade, the event facade will replace that * parameter after the properties the object literal contains are copied to * the event facade. * @return {EventTarget} the event host * */ fire: function(type) { var typeIncluded = L.isString(type), t = (typeIncluded) ? type : (type && type.type), ce, ret, pre = this._yuievt.config.prefix, ce2, args = (typeIncluded) ? Y.Array(arguments, 1, true) : arguments; t = (pre) ? _getType(t, pre) : t; this._monitor('fire', t, { args: args }); ce = this.getEvent(t, true); ce2 = this.getSibling(t, ce); if (ce2 && !ce) { ce = this.publish(t); } // this event has not been published or subscribed to if (!ce) { if (this._yuievt.hasTargets) { return this.bubble({ type: t }, args, this); } // otherwise there is nothing to be done ret = true; } else { ce.sibling = ce2; ret = ce.fire.apply(ce, args); } return (this._yuievt.chain) ? this : ret; }, getSibling: function(type, ce) { var ce2; // delegate to *:type events if there are subscribers if (type.indexOf(PREFIX_DELIMITER) > -1) { type = _wildType(type); // console.log(type); ce2 = this.getEvent(type, true); if (ce2) { // console.log("GOT ONE: " + type); ce2.applyConfig(ce); ce2.bubbles = false; ce2.broadcast = 0; // ret = ce2.fire.apply(ce2, a); } } return ce2; }, /** * Returns the custom event of the provided type has been created, a * falsy value otherwise * @method getEvent * @param type {string} the type, or name of the event * @param prefixed {string} if true, the type is prefixed already * @return {CustomEvent} the custom event or null */ getEvent: function(type, prefixed) { var pre, e; if (!prefixed) { pre = this._yuievt.config.prefix; type = (pre) ? _getType(type, pre) : type; } e = this._yuievt.events; return e[type] || null; }, /** * Subscribe to a custom event hosted by this object. The * supplied callback will execute after any listeners add * via the subscribe method, and after the default function, * if configured for the event, has executed. * @method after * @param type {string} The type of the event * @param fn {Function} The callback * @param context {object} optional execution context. * @param arg* {mixed} 0..n additional arguments to supply to the subscriber * @return the event target or a detach handle per 'chain' config */ after: function(type, fn) { var a = Y.Array(arguments, 0, true); switch (L.type(type)) { case 'function': return Y.Do.after.apply(Y.Do, arguments); case 'object': a[0]._after = true; break; default: a[0] = AFTER_PREFIX + type; } return this.on.apply(this, a); }, /** * Executes the callback before a DOM event, custom event * or method. If the first argument is a function, it * is assumed the target is a method. For DOM and custom * events, this is an alias for Y.on. * * For DOM and custom events: * type, callback, context, 0-n arguments * * For methods: * callback, object (method host), methodName, context, 0-n arguments * * @method before * @return detach handle */ before: function() { return this.on.apply(this, arguments); } }; Y.EventTarget = ET; // make Y an event target Y.mix(Y, ET.prototype, false, false, { bubbles: false }); ET.call(Y); YUI.Env.globalEvents = YUI.Env.globalEvents || new ET(); /** * Hosts YUI page level events. This is where events bubble to * when the broadcast config is set to 2. This property is * only available if the custom event module is loaded. * @property Global * @type EventTarget * @for YUI */ Y.Global = YUI.Env.globalEvents; // @TODO implement a global namespace function on Y.Global? })(); /** * YUI's on method is a unified interface for subscribing to * most events exposed by YUI. This includes custom events, DOM events, and * function events. detach is also provided to remove listeners * serviced by this function. * * The signature that on accepts varies depending on the type * of event being consumed. Refer to the specific methods that will * service a specific request for additional information about subscribing * to that type of event. * * * * on corresponds to the moment before any default behavior of * the event. after works the same way, but these listeners * execute after the event's default behavior. before is an * alias for on. * * @method on * @param type** event type (this parameter does not apply for function events) * @param fn the callback * @param target** a descriptor for the target (applies to custom events only). * For function events, this is the object that contains the function to * execute. * @param extra** 0..n Extra information a particular event may need. These * will be documented with the event. In the case of function events, this * is the name of the function to execute on the host. In the case of * delegate listeners, this is the event delegation specification. * @param context optionally change the value of 'this' in the callback * @param args* 0..n additional arguments to pass to the callback. * @return the event target or a detach handle per 'chain' config * @for YUI */ /** * Listen for an event one time. Equivalent to on, except that * the listener is immediately detached when executed. * @see on * @method once * @param type** event type (this parameter does not apply for function events) * @param fn the callback * @param target** a descriptor for the target (applies to custom events only). * For function events, this is the object that contains the function to * execute. * @param extra** 0..n Extra information a particular event may need. These * will be documented with the event. In the case of function events, this * is the name of the function to execute on the host. In the case of * delegate listeners, this is the event delegation specification. * @param context optionally change the value of 'this' in the callback * @param args* 0..n additional arguments to pass to the callback. * @return the event target or a detach handle per 'chain' config * @for YUI */ /** * after() is a unified interface for subscribing to * most events exposed by YUI. This includes custom events, * DOM events, and AOP events. This works the same way as * the on() function, only it operates after any default * behavior for the event has executed. @see on for more * information. * @method after * @param type event type (this parameter does not apply for function events) * @param fn the callback * @param target a descriptor for the target (applies to custom events only). * For function events, this is the object that contains the function to * execute. * @param extra 0..n Extra information a particular event may need. These * will be documented with the event. In the case of function events, this * is the name of the function to execute on the host. In the case of * delegate listeners, this is the event delegation specification. * @param context optionally change the value of 'this' in the callback * @param args* 0..n additional arguments to pass to the callback. * @return the event target or a detach handle per 'chain' config * @for YUI */ }, '3.1.2' ,{requires:['oop']}); YUI.add('event-custom-complex', function(Y) { /** * Adds event facades, preventable default behavior, and bubbling. * events. * @module event-custom * @submodule event-custom-complex */ (function() { var FACADE, FACADE_KEYS, CEProto = Y.CustomEvent.prototype, ETProto = Y.EventTarget.prototype; /** * Wraps and protects a custom event for use when emitFacade is set to true. * Requires the event-custom-complex module * @class EventFacade * @param e {Event} the custom event * @param currentTarget {HTMLElement} the element the listener was attached to */ Y.EventFacade = function(e, currentTarget) { e = e || {}; /** * The arguments passed to fire * @property details * @type Array */ this.details = e.details; /** * The event type, this can be overridden by the fire() payload * @property type * @type string */ this.type = e.type; /** * The real event type * @property type * @type string */ this._type = e.type; ////////////////////////////////////////////////////// /** * Node reference for the targeted eventtarget * @propery target * @type Node */ this.target = e.target; /** * Node reference for the element that the listener was attached to. * @propery currentTarget * @type Node */ this.currentTarget = currentTarget; /** * Node reference to the relatedTarget * @propery relatedTarget * @type Node */ this.relatedTarget = e.relatedTarget; /** * Stops the propagation to the next bubble target * @method stopPropagation */ this.stopPropagation = function() { e.stopPropagation(); }; /** * Stops the propagation to the next bubble target and * prevents any additional listeners from being exectued * on the current target. * @method stopImmediatePropagation */ this.stopImmediatePropagation = function() { e.stopImmediatePropagation(); }; /** * Prevents the event's default behavior * @method preventDefault */ this.preventDefault = function() { e.preventDefault(); }; /** * Stops the event propagation and prevents the default * event behavior. * @method halt * @param immediate {boolean} if true additional listeners * on the current target will not be executed */ this.halt = function(immediate) { e.halt(immediate); }; }; CEProto.fireComplex = function(args) { var es = Y.Env._eventstack, ef, q, queue, ce, ret, events, subs, self = this, host = self.host || self, next, oldbubble; if (es) { // queue this event if the current item in the queue bubbles if (self.queuable && self.type != es.next.type) { self.log('queue ' + self.type); es.queue.push([self, args]); return true; } } else { Y.Env._eventstack = { // id of the first event in the stack id: self.id, next: self, silent: self.silent, stopped: 0, prevented: 0, bubbling: null, type: self.type, // defaultFnQueue: new Y.Queue(), afterQueue: new Y.Queue(), defaultTargetOnly: self.defaultTargetOnly, queue: [] }; es = Y.Env._eventstack; } subs = self.getSubs(); self.stopped = (self.type !== es.type) ? 0 : es.stopped; self.prevented = (self.type !== es.type) ? 0 : es.prevented; self.target = self.target || host; events = new Y.EventTarget({ fireOnce: true, context: host }); self.events = events; if (self.preventedFn) { events.on('prevented', self.preventedFn); } if (self.stoppedFn) { events.on('stopped', self.stoppedFn); } self.currentTarget = host; self.details = args.slice(); // original arguments in the details // self.log("Firing " + self + ", " + "args: " + args); self.log("Firing " + self.type); self._facade = null; // kill facade to eliminate stale properties ef = self._getFacade(args); if (Y.Lang.isObject(args[0])) { args[0] = ef; } else { args.unshift(ef); } // if (subCount) { if (subs[0]) { // self._procSubs(Y.merge(self.subscribers), args, ef); self._procSubs(subs[0], args, ef); } // bubble if this is hosted in an event target and propagation has not been stopped if (self.bubbles && host.bubble && !self.stopped) { oldbubble = es.bubbling; // self.bubbling = true; es.bubbling = self.type; // if (host !== ef.target || es.type != self.type) { if (es.type != self.type) { es.stopped = 0; es.prevented = 0; } ret = host.bubble(self); self.stopped = Math.max(self.stopped, es.stopped); self.prevented = Math.max(self.prevented, es.prevented); // self.bubbling = false; es.bubbling = oldbubble; } // execute the default behavior if not prevented // console.log('defaultTargetOnly: ' + self.defaultTargetOnly); // console.log('host === target: ' + (host === ef.target)); // if (self.defaultFn && !self.prevented && ((!self.defaultTargetOnly) || host === es.id === self.id)) { if (self.defaultFn && !self.prevented && ((!self.defaultTargetOnly && !es.defaultTargetOnly) || host === ef.target)) { // if (es.id === self.id) { // self.defaultFn.apply(host, args); // while ((next = es.defaultFnQueue.last())) { // next(); // } // } else { // es.defaultFnQueue.add(function() { // self.defaultFn.apply(host, args); // }); // } self.defaultFn.apply(host, args); } // broadcast listeners are fired as discreet events on the // YUI instance and potentially the YUI global. self._broadcast(args); // process after listeners. If the default behavior was // prevented, the after events don't fire. // if (self.afterCount && !self.prevented && self.stopped < 2) { // if (subs[1] && !self.prevented && self.stopped < 2) { // // self._procSubs(Y.merge(self.afters), args, ef); // self._procSubs(subs[1], args, ef); // } // Queue the after if (subs[1] && !self.prevented && self.stopped < 2) { if (es.id === self.id || self.type != host._yuievt.bubbling) { self._procSubs(subs[1], args, ef); while ((next = es.afterQueue.last())) { next(); } } else { es.afterQueue.add(function() { self._procSubs(subs[1], args, ef); }); } } self.target = null; // es.stopped = 0; // es.prevented = 0; if (es.id === self.id) { queue = es.queue; while (queue.length) { q = queue.pop(); ce = q[0]; // set up stack to allow the next item to be processed es.next = ce; ce.fire.apply(ce, q[1]); // es.stopped = 0; // es.prevented = 0; } Y.Env._eventstack = null; } ret = !(self.stopped); if (self.type != host._yuievt.bubbling) { es.stopped = 0; es.prevented = 0; self.stopped = 0; self.prevented = 0; } return ret; }; CEProto._getFacade = function() { var ef = this._facade, o, o2, args = this.details; if (!ef) { ef = new Y.EventFacade(this, this.currentTarget); } // if the first argument is an object literal, apply the // properties to the event facade o = args && args[0]; if (Y.Lang.isObject(o, true)) { o2 = {}; // protect the event facade properties Y.mix(o2, ef, true, FACADE_KEYS); // mix the data Y.mix(ef, o, true); // restore ef Y.mix(ef, o2, true, FACADE_KEYS); // Allow the event type to be faked // http://yuilibrary.com/projects/yui3/ticket/2528376 ef.type = o.type || ef.type; } // update the details field with the arguments // ef.type = this.type; ef.details = this.details; // use the original target when the event bubbled to this target ef.target = this.originalTarget || this.target; ef.currentTarget = this.currentTarget; ef.stopped = 0; ef.prevented = 0; this._facade = ef; return this._facade; }; /** * Stop propagation to bubble targets * @for CustomEvent * @method stopPropagation */ CEProto.stopPropagation = function() { this.stopped = 1; Y.Env._eventstack.stopped = 1; this.events.fire('stopped', this); }; /** * Stops propagation to bubble targets, and prevents any remaining * subscribers on the current target from executing. * @method stopImmediatePropagation */ CEProto.stopImmediatePropagation = function() { this.stopped = 2; Y.Env._eventstack.stopped = 2; this.events.fire('stopped', this); }; /** * Prevents the execution of this event's defaultFn * @method preventDefault */ CEProto.preventDefault = function() { if (this.preventable) { this.prevented = 1; Y.Env._eventstack.prevented = 1; this.events.fire('prevented', this); } }; /** * Stops the event propagation and prevents the default * event behavior. * @method halt * @param immediate {boolean} if true additional listeners * on the current target will not be executed */ CEProto.halt = function(immediate) { if (immediate) { this.stopImmediatePropagation(); } else { this.stopPropagation(); } this.preventDefault(); }; /** * Registers another EventTarget as a bubble target. Bubble order * is determined by the order registered. Multiple targets can * be specified. * * Events can only bubble if emitFacade is true. * * Included in the event-custom-complex submodule. * * @method addTarget * @param o {EventTarget} the target to add * @for EventTarget */ ETProto.addTarget = function(o) { this._yuievt.targets[Y.stamp(o)] = o; this._yuievt.hasTargets = true; }; /** * Returns an array of bubble targets for this object. * @method getTargets * @return EventTarget[] */ ETProto.getTargets = function() { return Y.Object.values(this._yuievt.targets); }; /** * Removes a bubble target * @method removeTarget * @param o {EventTarget} the target to remove * @for EventTarget */ ETProto.removeTarget = function(o) { delete this._yuievt.targets[Y.stamp(o)]; }; /** * Propagate an event. Requires the event-custom-complex module. * @method bubble * @param evt {Event.Custom} the custom event to propagate * @return {boolean} the aggregated return value from Event.Custom.fire * @for EventTarget */ ETProto.bubble = function(evt, args, target) { var targs = this._yuievt.targets, ret = true, t, type = evt && evt.type, ce, i, bc, ce2, originalTarget = target || (evt && evt.target) || this, es = Y.Env._eventstack, oldbubble; if (!evt || ((!evt.stopped) && targs)) { for (i in targs) { if (targs.hasOwnProperty(i)) { t = targs[i]; ce = t.getEvent(type, true); ce2 = t.getSibling(type, ce); if (ce2 && !ce) { ce = t.publish(type); } oldbubble = t._yuievt.bubbling; t._yuievt.bubbling = type; // if this event was not published on the bubble target, // continue propagating the event. if (!ce) { if (t._yuievt.hasTargets) { t.bubble(evt, args, originalTarget); } } else { ce.sibling = ce2; // set the original target to that the target payload on the // facade is correct. ce.target = originalTarget; ce.originalTarget = originalTarget; ce.currentTarget = t; bc = ce.broadcast; ce.broadcast = false; ret = ret && ce.fire.apply(ce, args || evt.details || []); ce.broadcast = bc; ce.originalTarget = null; // stopPropagation() was called if (ce.stopped) { break; } } t._yuievt.bubbling = oldbubble; } } } return ret; }; FACADE = new Y.EventFacade(); FACADE_KEYS = Y.Object.keys(FACADE); })(); }, '3.1.2' ,{requires:['event-custom-base']}); YUI.add('event-custom', function(Y){}, '3.1.2' ,{use:['event-custom-base', 'event-custom-complex']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('attribute-base', function(Y) { /** * The State class maintains state for a collection of named items, with * a varying number of properties defined. * * It avoids the need to create a separate class for the item, and separate instances * of these classes for each item, by storing the state in a 2 level hash table, * improving performance when the number of items is likely to be large. * * @constructor * @class State */ Y.State = function() { /** * Hash of attributes * @property data */ this.data = {}; }; Y.State.prototype = { /** * Adds a property to an item. * * @method add * @param name {String} The name of the item. * @param key {String} The name of the property. * @param val {Any} The value of the property. */ add : function(name, key, val) { var d = this.data; d[key] = d[key] || {}; d[key][name] = val; }, /** * Adds multiple properties to an item. * * @method addAll * @param name {String} The name of the item. * @param o {Object} A hash of property/value pairs. */ addAll: function(name, o) { var key; for (key in o) { if (o.hasOwnProperty(key)) { this.add(name, key, o[key]); } } }, /** * Removes a property from an item. * * @method remove * @param name {String} The name of the item. * @param key {String} The property to remove. */ remove: function(name, key) { var d = this.data; if (d[key] && (name in d[key])) { delete d[key][name]; } }, /** * Removes multiple properties from an item, or remove the item completely. * * @method removeAll * @param name {String} The name of the item. * @param o {Object|Array} Collection of properties to delete. If not provided, the entire item is removed. */ removeAll: function(name, o) { var d = this.data; Y.each(o || d, function(v, k) { if(Y.Lang.isString(k)) { this.remove(name, k); } else { this.remove(name, v); } }, this); }, /** * 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 * @param key {String} Optional. The property value to retrieve. * @return {Any} The value of the supplied property. */ get: function(name, key) { var d = this.data; return (d[key] && name in d[key]) ? d[key][name] : undefined; }, /** * For the given item, returns a disposable object with all of the * item's property/value pairs. * * @method getAll * @param name {String} The name of the item * @return {Object} An object with property/value pairs for the item. */ getAll : function(name) { var d = this.data, o; Y.each(d, function(v, k) { if (name in d[k]) { o = o || {}; o[k] = v[name]; } }, this); return o; } }; /** * The attribute module provides an augmentable Attribute implementation, which * adds configurable attributes and attribute change events to the class being * augmented. It also provides a State class, which is used internally by Attribute, * but can also be used independently to provide a name/property/value data structure to * store state. * * @module attribute */ /** * The attribute-base submodule provides core attribute handling support, with everything * aside from complex attribute handling in the provider's constructor. * * @module attribute * @submodule attribute-base */ var O = Y.Object, Lang = Y.Lang, EventTarget = Y.EventTarget, DOT = ".", CHANGE = "Change", // Externally configurable props GETTER = "getter", SETTER = "setter", READ_ONLY = "readOnly", WRITE_ONCE = "writeOnce", INIT_ONLY = "initOnly", VALIDATOR = "validator", VALUE = "value", VALUE_FN = "valueFn", BROADCAST = "broadcast", LAZY_ADD = "lazyAdd", BYPASS_PROXY = "_bypassProxy", // Used for internal state management ADDED = "added", INITIALIZING = "initializing", INIT_VALUE = "initValue", PUBLISHED = "published", DEF_VALUE = "defaultValue", LAZY = "lazy", IS_LAZY_ADD = "isLazyAdd", INVALID_VALUE, MODIFIABLE = {}; // Properties which can be changed after the attribute has been added. MODIFIABLE[READ_ONLY] = 1; MODIFIABLE[WRITE_ONCE] = 1; MODIFIABLE[GETTER] = 1; MODIFIABLE[BROADCAST] = 1; /** *

* Attribute provides configurable attribute support along with attribute change events. It is designed to be * augmented on to a host class, and provides the host with the ability to configure attributes to store and retrieve state, * along with attribute change events. *

*

For example, attributes added to the host can be configured:

* * *

See the addAttr method, for the complete set of configuration * options available for attributes

. * *

NOTE: Most implementations will be better off extending the Base class, * instead of augmenting Attribute directly. Base augments Attribute and will handle the initial configuration * of attributes for derived classes, accounting for values passed into the constructor.

* * @class Attribute * @uses EventTarget */ function Attribute() { var host = this, // help compression attrs = this.constructor.ATTRS, Base = Y.Base; // Perf tweak - avoid creating event literals if not required. host._ATTR_E_FACADE = {}; EventTarget.call(host, {emitFacade:true}); // _conf maintained for backwards compat host._conf = host._state = new Y.State(); host._stateProxy = host._stateProxy || null; host._requireAddAttr = host._requireAddAttr || false; // ATTRS support for Node, which is not Base based if ( attrs && !(Base && host instanceof Base)) { host.addAttrs(this._protectAttrs(attrs)); } } /** *

The value to return from an attribute setter in order to prevent the set from going through.

* *

You can return this value from your setter if you wish to combine validator and setter * functionality into a single setter function, which either returns the massaged value to be stored or * Attribute.INVALID_VALUE to prevent invalid values from being stored.

* * @property Attribute.INVALID_VALUE * @type Object * @static * @final */ Attribute.INVALID_VALUE = {}; INVALID_VALUE = Attribute.INVALID_VALUE; /** * The list of properties which can be configured for * each attribute (e.g. setter, getter, writeOnce etc.). * * This property is used internally as a whitelist for faster * Y.mix operations. * * @property Attribute._ATTR_CFG * @type Array * @static * @protected */ Attribute._ATTR_CFG = [SETTER, GETTER, VALIDATOR, VALUE, VALUE_FN, WRITE_ONCE, READ_ONLY, LAZY_ADD, BROADCAST, BYPASS_PROXY]; Attribute.prototype = { /** *

* Adds an attribute with the provided configuration to the host object. *

*

* The config argument object supports the following properties: *

* *
*
value <Any>
*
The initial value to set on the attribute
* *
valueFn <Function | String>
*
*

A function, which will return the initial value to set on the attribute. This is useful * for cases where the attribute configuration is defined statically, but needs to * reference the host instance ("this") to obtain an initial value. * If defined, valueFn has precedence over the value property.

* *

valueFn can also be set to a string, representing the name of the instance method to be used to retrieve the value.

*
* *
readOnly <boolean>
*
Whether or not the attribute is read only. Attributes having readOnly set to true * cannot be modified by invoking the set method.
* *
writeOnce <boolean>
*
Whether or not the attribute is "write once". Attributes having writeOnce set to true, * can only have their values set once, be it through the default configuration, * constructor configuration arguments, or by invoking set.
* *
setter <Function | String>
*
*

The setter function used to massage or normalize the value passed to the set method for the attribute. * The value returned by the setter will be the final stored value. Returning * Attribute.INVALID_VALUE, from the setter will prevent * the value from being stored. *

* *

setter can also be set to a string, representing the name of the instance method to be used as the setter function.

*
* *
getter <Function | String>
*
*

* The getter function used to massage or normalize the value returned by the get method for the attribute. * The value returned by the getter function is the value which will be returned to the user when they * invoke get. *

* *

getter can also be set to a string, representing the name of the instance method to be used as the getter function.

*
* *
validator <Function | String>
*
*

* The validator function invoked prior to setting the stored value. Returning * false from the validator function will prevent the value from being stored. *

* *

validator can also be set to a string, representing the name of the instance method to be used as the validator function.

*
* *
broadcast <int>
*
If and how attribute change events for this attribute should be broadcast. See CustomEvent's broadcast property for * valid values. By default attribute change events are not broadcast.
* *
lazyAdd <boolean>
*
Whether or not to delay initialization of the attribute until the first call to get/set it. * This flag can be used to over-ride lazy initialization on a per attribute basis, when adding multiple attributes through * the addAttrs method.
* *
* *

The setter, getter and validator are invoked with the value and name passed in as the first and second arguments, and with * the context ("this") set to the host object.

* *

Configuration properties outside of the list mentioned above are considered private properties used internally by attribute, and are not intended for public use.

* * @method addAttr * * @param {String} name The name of the attribute. * @param {Object} config An object with attribute configuration property/value pairs, specifying the configuration for the attribute. * *

* NOTE: The configuration object is modified when adding an attribute, so if you need * to protect the original values, you will need to merge the object. *

* * @param {boolean} lazy (optional) Whether or not to add this attribute lazily (on the first call to get/set). * * @return {Object} A reference to the host object. * * @chainable */ addAttr: function(name, config, lazy) { var host = this, // help compression state = host._state, value, hasValue; lazy = (LAZY_ADD in config) ? config[LAZY_ADD] : lazy; if (lazy && !host.attrAdded(name)) { state.add(name, LAZY, config || {}); state.add(name, ADDED, true); } else { if (!host.attrAdded(name) || state.get(name, IS_LAZY_ADD)) { config = config || {}; hasValue = (VALUE in config); if(hasValue) { // We'll go through set, don't want to set value in config directly value = config.value; delete config.value; } config.added = true; config.initializing = true; state.addAll(name, config); if (hasValue) { // Go through set, so that raw values get normalized/validated host.set(name, value); } state.remove(name, INITIALIZING); } } return host; }, /** * Checks if the given attribute has been added to the host * * @method attrAdded * @param {String} name The name of the attribute to check. * @return {boolean} true if an attribute with the given name has been added, false if it hasn't. This method will return true for lazily added attributes. */ attrAdded: function(name) { return !!this._state.get(name, ADDED); }, /** * Updates the configuration of an attribute which has already been added. *

* The properties which can be modified through this interface are limited * to the following subset of attributes, which can be safely modified * after a value has already been set on the attribute: readOnly, writeOnce, * broadcast and getter. *

* @method modifyAttr * @param {String} name The name of the attribute whose configuration is to be updated. * @param {Object} config An object with configuration property/value pairs, specifying the configuration properties to modify. */ modifyAttr: function(name, config) { var host = this, // help compression prop, state; if (host.attrAdded(name)) { if (host._isLazyAttr(name)) { host._addLazyAttr(name); } state = host._state; for (prop in config) { if (MODIFIABLE[prop] && config.hasOwnProperty(prop)) { state.add(name, prop, config[prop]); // If we reconfigured broadcast, need to republish if (prop === BROADCAST) { state.remove(name, PUBLISHED); } } } } }, /** * Removes an attribute from the host object * * @method removeAttr * @param {String} name The name of the attribute to be removed. */ removeAttr: function(name) { this._state.removeAll(name); }, /** * Returns the current value of the attribute. If the attribute * has been configured with a 'getter' function, this method will delegate * to the 'getter' to obtain the value of the attribute. * * @method get * * @param {String} name The name of the attribute. If the value of the attribute is an Object, * dot notation can be used to obtain the value of a property of the object (e.g. get("x.y.z")) * * @return {Any} The value of the attribute */ get : function(name) { return this._getAttr(name); }, /** * Checks whether or not the attribute is one which has been * added lazily and still requires initialization. * * @method _isLazyAttr * @private * @param {String} name The name of the attribute * @return {boolean} true if it's a lazily added attribute, false otherwise. */ _isLazyAttr: function(name) { return this._state.get(name, LAZY); }, /** * Finishes initializing an attribute which has been lazily added. * * @method _addLazyAttr * @private * @param {Object} name The name of the attribute */ _addLazyAttr: function(name) { var state = this._state, lazyCfg = state.get(name, LAZY); state.add(name, IS_LAZY_ADD, true); state.remove(name, LAZY); this.addAttr(name, lazyCfg); }, /** * Sets the value of an attribute. * * @method set * @chainable * * @param {String} name The name of the attribute. If the * current value of the attribute is an Object, dot notation can be used * to set the value of a property within the object (e.g. set("x.y.z", 5)). * * @param {Any} value The value to set the attribute to. * * @param {Object} opts (Optional) Optional event data to be mixed into * the event facade passed to subscribers of the attribute's change event. This * can be used as a flexible way to identify the source of a call to set, allowing * the developer to distinguish between set called internally by the host, vs. * set called externally by the application developer. * * @return {Object} A reference to the host object. */ set : function(name, val, opts) { return this._setAttr(name, val, opts); }, /** * Resets the attribute (or all attributes) to its initial value, as long as * the attribute is not readOnly, or writeOnce. * * @method reset * @param {String} name Optional. The name of the attribute to reset. If omitted, all attributes are reset. * @return {Object} A reference to the host object. * @chainable */ reset : function(name) { var host = this, // help compression added; if (name) { if (host._isLazyAttr(name)) { host._addLazyAttr(name); } host.set(name, host._state.get(name, INIT_VALUE)); } else { added = host._state.data.added; Y.each(added, function(v, n) { host.reset(n); }, host); } return host; }, /** * Allows setting of readOnly/writeOnce attributes. See set for argument details. * * @method _set * @protected * @chainable * * @param {String} name The name of the attribute. * @param {Any} val The value to set the attribute to. * @param {Object} opts (Optional) Optional event data to be mixed into * the event facade passed to subscribers of the attribute's change event. * @return {Object} A reference to the host object. */ _set : function(name, val, opts) { return this._setAttr(name, val, opts, true); }, /** * Provides the common implementation for the public get method, * allowing Attribute hosts to over-ride either method. * * See get for argument details. * * @method _getAttr * @protected * @chainable * * @param {String} name The name of the attribute. * @return {Any} The value of the attribute. */ _getAttr : function(name) { var host = this, // help compression fullName = name, state = host._state, path, getter, val, cfg; if (name.indexOf(DOT) !== -1) { path = name.split(DOT); name = path.shift(); } // On Demand - Should be rare - handles out of order valueFn references if (host._tCfgs && host._tCfgs[name]) { cfg = {}; cfg[name] = host._tCfgs[name]; delete host._tCfgs[name]; host._addAttrs(cfg, host._tVals); } // Lazy Init if (host._isLazyAttr(name)) { host._addLazyAttr(name); } val = host._getStateVal(name); getter = state.get(name, GETTER); if (getter && !getter.call) { getter = this[getter]; } val = (getter) ? getter.call(host, val, fullName) : val; val = (path) ? O.getValue(val, path) : val; return val; }, /** * Provides the common implementation for the public set and protected _set methods. * * See set for argument details. * * @method _setAttr * @protected * @chainable * * @param {String} name The name of the attribute. * @param {Any} value The value to set the attribute to. * @param {Object} opts (Optional) Optional event data to be mixed into * the event facade passed to subscribers of the attribute's change event. * @param {boolean} force If true, allows the caller to set values for * readOnly or writeOnce attributes which have already been set. * * @return {Object} A reference to the host object. */ _setAttr : function(name, val, opts, force) { var allowSet = true, state = this._state, stateProxy = this._stateProxy, data = state.data, initialSet, strPath, path, currVal, writeOnce, initializing; if (name.indexOf(DOT) !== -1) { strPath = name; path = name.split(DOT); name = path.shift(); } if (this._isLazyAttr(name)) { this._addLazyAttr(name); } initialSet = (!data.value || !(name in data.value)); if (stateProxy && name in stateProxy && !this._state.get(name, BYPASS_PROXY)) { // TODO: Value is always set for proxy. Can we do any better? Maybe take a snapshot as the initial value for the first call to set? initialSet = false; } if (this._requireAddAttr && !this.attrAdded(name)) { } else { writeOnce = state.get(name, WRITE_ONCE); initializing = state.get(name, INITIALIZING); if (!initialSet && !force) { if (writeOnce) { allowSet = false; } if (state.get(name, READ_ONLY)) { allowSet = false; } } if (!initializing && !force && writeOnce === INIT_ONLY) { allowSet = false; } if (allowSet) { // Don't need currVal if initialSet (might fail in custom getter if it always expects a non-undefined/non-null value) if (!initialSet) { currVal = this.get(name); } if (path) { val = O.setValue(Y.clone(currVal), path, val); if (val === undefined) { allowSet = false; } } if (allowSet) { if (initializing) { this._setAttrVal(name, strPath, currVal, val); } else { this._fireAttrChange(name, strPath, currVal, val, opts); } } } } return this; }, /** * Utility method to help setup the event payload and fire the attribute change event. * * @method _fireAttrChange * @private * @param {String} attrName The name of the attribute * @param {String} subAttrName The full path of the property being changed, * if this is a sub-attribute value being change. Otherwise null. * @param {Any} currVal The current value of the attribute * @param {Any} newVal The new value of the attribute * @param {Object} opts Any additional event data to mix into the attribute change event's event facade. */ _fireAttrChange : function(attrName, subAttrName, currVal, newVal, opts) { var host = this, eventName = attrName + CHANGE, state = host._state, facade; if (!state.get(attrName, PUBLISHED)) { host.publish(eventName, { queuable:false, defaultTargetOnly: true, defaultFn:host._defAttrChangeFn, silent:true, broadcast : state.get(attrName, BROADCAST) }); state.add(attrName, PUBLISHED, true); } facade = (opts) ? Y.merge(opts) : host._ATTR_E_FACADE; facade.type = eventName; facade.attrName = attrName; facade.subAttrName = subAttrName; facade.prevVal = currVal; facade.newVal = newVal; host.fire(facade); }, /** * Default function for attribute change events. * * @private * @method _defAttrChangeFn * @param {EventFacade} e The event object for attribute change events. */ _defAttrChangeFn : function(e) { if (!this._setAttrVal(e.attrName, e.subAttrName, e.prevVal, e.newVal)) { // Prevent "after" listeners from being invoked since nothing changed. e.stopImmediatePropagation(); } else { e.newVal = this.get(e.attrName); } }, /** * Gets the stored value for the attribute, from either the * internal state object, or the state proxy if it exits * * @method _getStateVal * @private * @param {String} name The name of the attribute * @return {Any} The stored value of the attribute */ _getStateVal : function(name) { var stateProxy = this._stateProxy; return stateProxy && (name in stateProxy) && !this._state.get(name, BYPASS_PROXY) ? stateProxy[name] : this._state.get(name, VALUE); }, /** * Sets the stored value for the attribute, in either the * internal state object, or the state proxy if it exits * * @method _setStateVal * @private * @param {String} name The name of the attribute * @param {Any} value The value of the attribute */ _setStateVal : function(name, value) { var stateProxy = this._stateProxy; if (stateProxy && (name in stateProxy) && !this._state.get(name, BYPASS_PROXY)) { stateProxy[name] = value; } else { this._state.add(name, VALUE, value); } }, /** * Updates the stored value of the attribute in the privately held State object, * if validation and setter passes. * * @method _setAttrVal * @private * @param {String} attrName The attribute name. * @param {String} subAttrName The sub-attribute name, if setting a sub-attribute property ("x.y.z"). * @param {Any} prevVal The currently stored value of the attribute. * @param {Any} newVal The value which is going to be stored. * * @return {booolean} true if the new attribute value was stored, false if not. */ _setAttrVal : function(attrName, subAttrName, prevVal, newVal) { var host = this, allowSet = true, state = host._state, validator = state.get(attrName, VALIDATOR), setter = state.get(attrName, SETTER), initializing = state.get(attrName, INITIALIZING), prevValRaw = this._getStateVal(attrName), name = subAttrName || attrName, retVal, valid; if (validator) { if (!validator.call) { // Assume string - trying to keep critical path tight, so avoiding Lang check validator = this[validator]; } if (validator) { valid = validator.call(host, newVal, name); if (!valid && initializing) { newVal = state.get(attrName, DEF_VALUE); valid = true; // Assume it's valid, for perf. } } } if (!validator || valid) { if (setter) { if (!setter.call) { // Assume string - trying to keep critical path tight, so avoiding Lang check setter = this[setter]; } if (setter) { retVal = setter.call(host, newVal, name); if (retVal === INVALID_VALUE) { allowSet = false; } else if (retVal !== undefined){ newVal = retVal; } } } if (allowSet) { if(!subAttrName && (newVal === prevValRaw) && !Lang.isObject(newVal)) { allowSet = false; } else { // Store value if (state.get(attrName, INIT_VALUE) === undefined) { state.add(attrName, INIT_VALUE, newVal); } host._setStateVal(attrName, newVal); } } } else { allowSet = false; } return allowSet; }, /** * Sets multiple attribute values. * * @method setAttrs * @param {Object} attrs An object with attributes name/value pairs. * @return {Object} A reference to the host object. * @chainable */ setAttrs : function(attrs, opts) { return this._setAttrs(attrs, opts); }, /** * Implementation behind the public setAttrs method, to set multiple attribute values. * * @method _setAttrs * @protected * @param {Object} attrs An object with attributes name/value pairs. * @return {Object} A reference to the host object. * @chainable */ _setAttrs : function(attrs, opts) { for (var attr in attrs) { if ( attrs.hasOwnProperty(attr) ) { this.set(attr, attrs[attr]); } } return this; }, /** * Gets multiple attribute values. * * @method getAttrs * @param {Array | boolean} attrs Optional. An array of attribute names. If omitted, all attribute values are * returned. If set to true, all attributes modified from their initial values are returned. * @return {Object} An object with attribute name/value pairs. */ getAttrs : function(attrs) { return this._getAttrs(attrs); }, /** * Implementation behind the public getAttrs method, to get multiple attribute values. * * @method _getAttrs * @protected * @param {Array | boolean} attrs Optional. An array of attribute names. If omitted, all attribute values are * returned. If set to true, all attributes modified from their initial values are returned. * @return {Object} An object with attribute name/value pairs. */ _getAttrs : function(attrs) { var host = this, o = {}, i, l, attr, val, modifiedOnly = (attrs === true); attrs = (attrs && !modifiedOnly) ? attrs : O.keys(host._state.data.added); for (i = 0, l = attrs.length; i < l; i++) { // Go through get, to honor cloning/normalization attr = attrs[i]; val = host.get(attr); if (!modifiedOnly || host._getStateVal(attr) != host._state.get(attr, INIT_VALUE)) { o[attr] = host.get(attr); } } return o; }, /** * Configures a group of attributes, and sets initial values. * *

* NOTE: This method does not isolate the configuration object by merging/cloning. * The caller is responsible for merging/cloning the configuration object if required. *

* * @method addAttrs * @chainable * * @param {Object} cfgs An object with attribute name/configuration pairs. * @param {Object} values An object with attribute name/value pairs, defining the initial values to apply. * Values defined in the cfgs argument will be over-written by values in this argument unless defined as read only. * @param {boolean} lazy Whether or not to delay the intialization of these attributes until the first call to get/set. * Individual attributes can over-ride this behavior by defining a lazyAdd configuration property in their configuration. * See addAttr. * * @return {Object} A reference to the host object. */ addAttrs : function(cfgs, values, lazy) { var host = this; // help compression if (cfgs) { host._tCfgs = cfgs; host._tVals = host._normAttrVals(values); host._addAttrs(cfgs, host._tVals, lazy); host._tCfgs = host._tVals = null; } return host; }, /** * Implementation behind the public addAttrs method. * * This method is invoked directly by get if it encounters a scenario * in which an attribute's valueFn attempts to obtain the * value an attribute in the same group of attributes, which has not yet * been added (on demand initialization). * * @method _addAttrs * @private * @param {Object} cfgs An object with attribute name/configuration pairs. * @param {Object} values An object with attribute name/value pairs, defining the initial values to apply. * Values defined in the cfgs argument will be over-written by values in this argument unless defined as read only. * @param {boolean} lazy Whether or not to delay the intialization of these attributes until the first call to get/set. * Individual attributes can over-ride this behavior by defining a lazyAdd configuration property in their configuration. * See addAttr. */ _addAttrs : function(cfgs, values, lazy) { var host = this, // help compression attr, attrCfg, value; for (attr in cfgs) { if (cfgs.hasOwnProperty(attr)) { // Not Merging. Caller is responsible for isolating configs attrCfg = cfgs[attr]; attrCfg.defaultValue = attrCfg.value; // Handle simple, complex and user values, accounting for read-only value = host._getAttrInitVal(attr, attrCfg, host._tVals); if (value !== undefined) { attrCfg.value = value; } if (host._tCfgs[attr]) { delete host._tCfgs[attr]; } host.addAttr(attr, attrCfg, lazy); } } }, /** * Utility method to protect an attribute configuration * hash, by merging the entire object and the individual * attr config objects. * * @method _protectAttrs * @protected * @param {Object} attrs A hash of attribute to configuration object pairs. * @return {Object} A protected version of the attrs argument. */ _protectAttrs : function(attrs) { if (attrs) { attrs = Y.merge(attrs); for (var attr in attrs) { if (attrs.hasOwnProperty(attr)) { attrs[attr] = Y.merge(attrs[attr]); } } } return attrs; }, /** * Utility method to normalize attribute values. The base implementation * simply merges the hash to protect the original. * * @method _normAttrVals * @param {Object} valueHash An object with attribute name/value pairs * * @return {Object} * * @private */ _normAttrVals : function(valueHash) { return (valueHash) ? Y.merge(valueHash) : null; }, /** * Returns the initial value of the given attribute from * either the default configuration provided, or the * over-ridden value if it exists in the set of initValues * provided and the attribute is not read-only. * * @param {String} attr The name of the attribute * @param {Object} cfg The attribute configuration object * @param {Object} initValues The object with simple and complex attribute name/value pairs returned from _normAttrVals * * @return {Any} The initial value of the attribute. * * @method _getAttrInitVal * @private */ _getAttrInitVal : function(attr, cfg, initValues) { var val, valFn; // init value is provided by the user if it exists, else, provided by the config if (!cfg[READ_ONLY] && initValues && initValues.hasOwnProperty(attr)) { val = initValues[attr]; } else { val = cfg[VALUE]; valFn = cfg[VALUE_FN]; if (valFn) { if (!valFn.call) { valFn = this[valFn]; } if (valFn) { val = valFn.call(this); } } } return val; } }; // Basic prototype augment - no lazy constructor invocation. Y.mix(Attribute, EventTarget, false, null, 1); Y.Attribute = Attribute; }, '3.1.2' ,{requires:['event-custom']}); YUI.add('attribute-complex', function(Y) { /** * Adds support for attribute providers to handle complex attributes in the constructor * * @module attribute * @submodule attribute-complex * @for Attribute */ var O = Y.Object, DOT = "."; Y.Attribute.Complex = function() {}; Y.Attribute.Complex.prototype = { /** * Utility method to split out simple attribute name/value pairs ("x") * from complex attribute name/value pairs ("x.y.z"), so that complex * attributes can be keyed by the top level attribute name. * * @method _normAttrVals * @param {Object} valueHash An object with attribute name/value pairs * * @return {Object} An object literal with 2 properties - "simple" and "complex", * containing simple and complex attribute values respectively keyed * by the top level attribute name, or null, if valueHash is falsey. * * @private */ _normAttrVals : function(valueHash) { var vals = {}, subvals = {}, path, attr, v, k; if (valueHash) { for (k in valueHash) { if (valueHash.hasOwnProperty(k)) { if (k.indexOf(DOT) !== -1) { path = k.split(DOT); attr = path.shift(); v = subvals[attr] = subvals[attr] || []; v[v.length] = { path : path, value: valueHash[k] }; } else { vals[k] = valueHash[k]; } } } return { simple:vals, complex:subvals }; } else { return null; } }, /** * Returns the initial value of the given attribute from * either the default configuration provided, or the * over-ridden value if it exists in the set of initValues * provided and the attribute is not read-only. * * @param {String} attr The name of the attribute * @param {Object} cfg The attribute configuration object * @param {Object} initValues The object with simple and complex attribute name/value pairs returned from _normAttrVals * * @return {Any} The initial value of the attribute. * * @method _getAttrInitVal * @private */ _getAttrInitVal : function(attr, cfg, initValues) { var val = cfg.value, valFn = cfg.valueFn, simple, complex, i, l, path, subval, subvals; if (valFn) { if (!valFn.call) { valFn = this[valFn]; } if (valFn) { val = valFn.call(this); } } if (!cfg.readOnly && initValues) { // Simple Attributes simple = initValues.simple; if (simple && simple.hasOwnProperty(attr)) { val = simple[attr]; } // Complex Attributes (complex values applied, after simple, incase both are set) complex = initValues.complex; if (complex && complex.hasOwnProperty(attr)) { subvals = complex[attr]; for (i = 0, l = subvals.length; i < l; ++i) { path = subvals[i].path; subval = subvals[i].value; O.setValue(val, path, subval); } } } return val; } }; Y.mix(Y.Attribute, Y.Attribute.Complex, true, null, 1); }, '3.1.2' ,{requires:['attribute-base']}); YUI.add('attribute', function(Y){}, '3.1.2' ,{use:['attribute-base', 'attribute-complex']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('pluginhost', function(Y) { /** * Provides the augmentable PluginHost interface, which can be added to any class. * @module pluginhost */ /** *

* An augmentable class, which provides the augmented class with the ability to host plugins. * It adds plug and unplug methods to the augmented class, which can * be used to add or remove plugins from instances of the class. *

* *

Plugins can also be added through the constructor configuration object passed to the host class' constructor using * the "plugins" property. Supported values for the "plugins" property are those defined by the plug method. * * For example the following code would add the AnimPlugin and IOPlugin to Overlay (the plugin host): *

* var o = new Overlay({plugins: [ AnimPlugin, {fn:IOPlugin, cfg:{section:"header"}}]}); * *

*

* Plug.Host's protected _initPlugins and _destroyPlugins * methods should be invoked by the host class at the appropriate point in the host's lifecyle. *

* * @class Plugin.Host */ var L = Y.Lang; function PluginHost() { this._plugins = {}; } PluginHost.prototype = { /** * Adds a plugin to the host object. This will instantiate the * plugin and attach it to the configured namespace on the host object. * * @method plug * @chainable * @param p {Function | Object |Array} Accepts the plugin class, or an * object with a "fn" property specifying the plugin class and * a "cfg" property specifying the configuration for the Plugin. *

* Additionally an Array can also be passed in, with the above function or * object values, allowing the user to add multiple plugins in a single call. *

* @param config (Optional) If the first argument is the plugin class, the second argument * can be the configuration for the plugin. * @return {Base} A reference to the host object */ plug: function(p, config) { if (p) { if (L.isFunction(p)) { this._plug(p, config); } else if (L.isArray(p)) { for (var i = 0, ln = p.length; i < ln; i++) { this.plug(p[i]); } } else { this._plug(p.fn, p.cfg); } } return this; }, /** * Removes a plugin from the host object. This will destroy the * plugin instance and delete the namepsace from the host object. * * @method unplug * @param {String | Function} plugin The namespace of the plugin, or the plugin class with the static NS namespace property defined. If not provided, * all registered plugins are unplugged. * @return {Base} A reference to the host object * @chainable */ unplug: function(plugin) { if (plugin) { this._unplug(plugin); } else { var ns; for (ns in this._plugins) { if (this._plugins.hasOwnProperty(ns)) { this._unplug(ns); } } } return this; }, /** * Determines if a plugin has plugged into this host. * * @method hasPlugin * @param {String} ns The plugin's namespace * @return {boolean} returns true, if the plugin has been plugged into this host, false otherwise. */ hasPlugin : function(ns) { return (this._plugins[ns] && this[ns]); }, /** * Initializes static plugins registered on the host (using the * Base.plug static method) and any plugins passed to the * instance through the "plugins" configuration property. * * @method _initPlugins * @param {Config} config The configuration object with property name/value pairs. * @private */ _initPlugins: function(config) { this._plugins = this._plugins || {}; // Class Configuration var classes = (this._getClasses) ? this._getClasses() : [this.constructor], plug = [], unplug = {}, constructor, i, classPlug, classUnplug, pluginClassName; //TODO: Room for optimization. Can we apply statically/unplug in same pass? for (i = classes.length - 1; i >= 0; i--) { constructor = classes[i]; classUnplug = constructor._UNPLUG; if (classUnplug) { // subclasses over-write Y.mix(unplug, classUnplug, true); } classPlug = constructor._PLUG; if (classPlug) { // subclasses over-write Y.mix(plug, classPlug, true); } } for (pluginClassName in plug) { if (plug.hasOwnProperty(pluginClassName)) { if (!unplug[pluginClassName]) { this.plug(plug[pluginClassName]); } } } // User Configuration if (config && config.plugins) { this.plug(config.plugins); } }, /** * Unplugs and destroys all plugins on the host * @method _destroyPlugins * @private */ _destroyPlugins: function() { this.unplug(); }, /** * Private method used to instantiate and attach plugins to the host * * @method _plug * @param {Function} PluginClass The plugin class to instantiate * @param {Object} config The configuration object for the plugin * @private */ _plug: function(PluginClass, config) { if (PluginClass && PluginClass.NS) { var ns = PluginClass.NS; config = config || {}; config.host = this; if (this.hasPlugin(ns)) { // Update config this[ns].setAttrs(config); } else { // Create new instance this[ns] = new PluginClass(config); this._plugins[ns] = PluginClass; } } }, /** * Unplugs and destroys a plugin already instantiated with the host. * * @method _unplug * @private * @param {String | Function} plugin The namespace for the plugin, or a plugin class with the static NS property defined. */ _unplug : function(plugin) { var ns = plugin, plugins = this._plugins; if (L.isFunction(plugin)) { ns = plugin.NS; if (ns && (!plugins[ns] || plugins[ns] !== plugin)) { ns = null; } } if (ns) { if (this[ns]) { this[ns].destroy(); delete this[ns]; } if (plugins[ns]) { delete plugins[ns]; } } } }; /** * Registers plugins to be instantiated at the class level (plugins * which should be plugged into every instance of the class by default). * * @method Plugin.Host.plug * @static * * @param {Function} hostClass The host class on which to register the plugins * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined) * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin */ PluginHost.plug = function(hostClass, plugin, config) { // Cannot plug into Base, since Plugins derive from Base [ will cause infinite recurrsion ] var p, i, l, name; if (hostClass !== Y.Base) { hostClass._PLUG = hostClass._PLUG || {}; if (!L.isArray(plugin)) { if (config) { plugin = {fn:plugin, cfg:config}; } plugin = [plugin]; } for (i = 0, l = plugin.length; i < l;i++) { p = plugin[i]; name = p.NAME || p.fn.NAME; hostClass._PLUG[name] = p; } } }; /** * Unregisters any class level plugins which have been registered by the host class, or any * other class in the hierarchy. * * @method Plugin.Host.unplug * @static * * @param {Function} hostClass The host class from which to unregister the plugins * @param {Function | Array} plugin The plugin class, or an array of plugin classes */ PluginHost.unplug = function(hostClass, plugin) { var p, i, l, name; if (hostClass !== Y.Base) { hostClass._UNPLUG = hostClass._UNPLUG || {}; if (!L.isArray(plugin)) { plugin = [plugin]; } for (i = 0, l = plugin.length; i < l; i++) { p = plugin[i]; name = p.NAME; if (!hostClass._PLUG[name]) { hostClass._UNPLUG[name] = p; } else { delete hostClass._PLUG[name]; } } } }; Y.namespace("Plugin").Host = PluginHost; }, '3.1.2' ,{requires:['yui-base']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('base-base', function(Y) { /** * The base module provides the Base class, which objects requiring attribute and custom event support can extend. * The module also provides two ways to reuse code - It augments Base with the Plugin.Host interface which provides * plugin support and also provides the Base.build method which provides a way to build custom classes using extensions. * * @module base */ /** * The base-base submodule provides the Base class without the Plugin support, provided by Plugin.Host, * and without the extension support provided by Base.build. * * @module base * @submodule base-base */ var O = Y.Object, L = Y.Lang, DOT = ".", DESTROY = "destroy", INIT = "init", INITIALIZED = "initialized", DESTROYED = "destroyed", INITIALIZER = "initializer", BUBBLETARGETS = "bubbleTargets", _BUBBLETARGETS = "_bubbleTargets", OBJECT_CONSTRUCTOR = Object.prototype.constructor, DEEP = "deep", SHALLOW = "shallow", DESTRUCTOR = "destructor", Attribute = Y.Attribute; /** *

* A base class which objects requiring attributes and custom event support can * extend. Base also handles the chaining of initializer and destructor methods across * the hierarchy as part of object construction and destruction. Additionally, attributes configured * through the static ATTRS property for each class * in the hierarchy will be initialized by Base. *

* *

* The static NAME property of each class extending * from Base will be used as the identifier for the class, and is used by Base to prefix * all events fired by instances of that class. *

* * @class Base * @constructor * @uses Attribute * @uses Plugin.Host * * @param {Object} config Object with configuration property name/value pairs. The object can be * used to provide default values for the objects published attributes. * *

* The config object can also contain the following non-attribute properties, providing a convenient * way to configure events listeners and plugins for the instance, as part of the constructor call: *

* *
*
on
*
An event name to listener function map, to register event listeners for the "on" moment of the event. A constructor convenience property for the on method.
*
after
*
An event name to listener function map, to register event listeners for the "after" moment of the event. A constructor convenience property for the after method.
*
bubbleTargets
*
An object, or array of objects, to register as bubble targets for bubbled events fired by this instance. A constructor convenience property for the addTarget method.
*
plugins
*
A plugin, or array of plugins to be plugged into the instance (see PluginHost's plug method for signature details). A constructor convenience property for the plug method.
*
*/ function Base() { Attribute.call(this); // If Plugin.Host has been augmented [ through base-pluginhost ], setup it's // initial state, but don't initialize Plugins yet. That's done after initialization. var PluginHost = Y.Plugin && Y.Plugin.Host; if (this._initPlugins && PluginHost) { PluginHost.call(this); } if (this._lazyAddAttrs !== false) { this._lazyAddAttrs = true; } /** * The string used to identify the class of this object. * * @deprecated Use this.constructor.NAME * @property name * @type String */ this.name = this.constructor.NAME; this._eventPrefix = this.constructor.EVENT_PREFIX || this.constructor.NAME; this.init.apply(this, arguments); } /** * The list of properties which can be configured for * each attribute (e.g. setter, getter, writeOnce, readOnly etc.) * * @property Base._ATTR_CFG * @type Array * @static * @private */ Base._ATTR_CFG = Attribute._ATTR_CFG.concat("cloneDefaultValue"); /** *

* The string to be used to identify instances of * this class, for example in prefixing events. *

*

* Classes extending Base, should define their own * static NAME property, which should be camelCase by * convention (e.g. MyClass.NAME = "myClass";). *

* @property Base.NAME * @type String * @static */ Base.NAME = "base"; /** * The default set of attributes which will be available for instances of this class, and * their configuration. In addition to the configuration properties listed by * Attribute's addAttr method, the attribute * can also be configured with a "cloneDefaultValue" property, which defines how the statically * defined value field should be protected ("shallow", "deep" and false are supported values). * * By default if the value is an object literal or an array it will be "shallow" cloned, to * protect the default value. * * @property Base.ATTRS * @type Object * @static */ Base.ATTRS = { /** * Flag indicating whether or not this object * has been through the init lifecycle phase. * * @attribute initialized * @readonly * @default false * @type boolean */ initialized: { readOnly:true, value:false }, /** * Flag indicating whether or not this object * has been through the destroy lifecycle phase. * * @attribute destroyed * @readonly * @default false * @type boolean */ destroyed: { readOnly:true, value:false } }; Base.prototype = { /** * Init lifecycle method, invoked during construction. * Fires the init event prior to setting up attributes and * invoking initializers for the class hierarchy. * * @method init * @final * @chainable * @param {Object} config Object with configuration property name/value pairs * @return {Base} A reference to this object */ init: function(config) { this._yuievt.config.prefix = this._eventPrefix; /** *

* Lifecycle event for the init phase, fired prior to initialization. * Invoking the preventDefault() method on the event object provided * to subscribers will prevent initialization from occuring. *

*

* Subscribers to the "after" momemt of this event, will be notified * after initialization of the object is complete (and therefore * cannot prevent initialization). *

* * @event init * @preventable _defInitFn * @param {EventFacade} e Event object, with a cfg property which * refers to the configuration object passed to the constructor. */ this.publish(INIT, { queuable:false, fireOnce:true, defaultTargetOnly:true, defaultFn:this._defInitFn }); this._preInitEventCfg(config); this.fire(INIT, {cfg: config}); return this; }, /** * Handles the special on, after and target properties which allow the user to * easily configure on and after listeners as well as bubble targets during * construction, prior to init. * * @method _preInitEventCfg * @param {Object} config The user configuration object */ _preInitEventCfg : function(config) { if (config) { if (config.on) { this.on(config.on); } if (config.after) { this.after(config.after); } } var i, l, target, userTargets = (config && BUBBLETARGETS in config); if (userTargets || _BUBBLETARGETS in this) { target = userTargets ? (config && config.bubbleTargets) : this._bubbleTargets; if (L.isArray(target)) { for (i = 0, l = target.length; i < l; i++) { this.addTarget(target[i]); } } else if (target) { this.addTarget(target); } } }, /** *

* Destroy lifecycle method. Fires the destroy * event, prior to invoking destructors for the * class hierarchy. *

*

* Subscribers to the destroy * event can invoke preventDefault on the event object, to prevent destruction * from proceeding. *

* @method destroy * @return {Base} A reference to this object * @final * @chainable */ destroy: function() { /** *

* Lifecycle event for the destroy phase, * fired prior to destruction. Invoking the preventDefault * method on the event object provided to subscribers will * prevent destruction from proceeding. *

*

* Subscribers to the "after" moment of this event, will be notified * after destruction is complete (and as a result cannot prevent * destruction). *

* @event destroy * @preventable _defDestroyFn * @param {EventFacade} e Event object */ this.publish(DESTROY, { queuable:false, fireOnce:true, defaultTargetOnly:true, defaultFn: this._defDestroyFn }); this.fire(DESTROY); this.detachAll(); return this; }, /** * Default init event handler * * @method _defInitFn * @param {EventFacade} e Event object, with a cfg property which * refers to the configuration object passed to the constructor. * @protected */ _defInitFn : function(e) { this._initHierarchy(e.cfg); if (this._initPlugins) { // Need to initPlugins manually, to handle constructor parsing, static Plug parsing this._initPlugins(e.cfg); } this._set(INITIALIZED, true); }, /** * Default destroy event handler * * @method _defDestroyFn * @param {EventFacade} e Event object * @protected */ _defDestroyFn : function(e) { this._destroyHierarchy(); if (this._destroyPlugins) { this._destroyPlugins(); } this._set(DESTROYED, true); }, /** * Returns the class hierarchy for this object, with Base being the last class in the array. * * @method _getClasses * @protected * @return {Function[]} An array of classes (constructor functions), making up the class hierarchy for this object. * This value is cached the first time the method, or _getAttrCfgs, is invoked. Subsequent invocations return the * cached value. */ _getClasses : function() { if (!this._classes) { this._initHierarchyData(); } return this._classes; }, /** * Returns an aggregated set of attribute configurations, by traversing the class hierarchy. * * @method _getAttrCfgs * @protected * @return {Object} The hash of attribute configurations, aggregated across classes in the hierarchy * This value is cached the first time the method, or _getClasses, is invoked. Subsequent invocations return * the cached value. */ _getAttrCfgs : function() { if (!this._attrs) { this._initHierarchyData(); } return this._attrs; }, /** * A helper method used when processing ATTRS across the class hierarchy during * initialization. Returns a disposable object with the attributes defined for * the provided class, extracted from the set of all attributes passed in . * * @method _filterAttrCfs * @private * * @param {Function} clazz The class for which the desired attributes are required. * @param {Object} allCfgs The set of all attribute configurations for this instance. * Attributes will be removed from this set, if they belong to the filtered class, so * that by the time all classes are processed, allCfgs will be empty. * * @return {Object} The set of attributes belonging to the class passed in, in the form * of an object with attribute name/configuration pairs. */ _filterAttrCfgs : function(clazz, allCfgs) { var cfgs = null, attr, attrs = clazz.ATTRS; if (attrs) { for (attr in attrs) { if (attrs.hasOwnProperty(attr) && allCfgs[attr]) { cfgs = cfgs || {}; cfgs[attr] = allCfgs[attr]; delete allCfgs[attr]; } } } return cfgs; }, /** * A helper method used by _getClasses and _getAttrCfgs, which determines both * the array of classes and aggregate set of attribute configurations * across the class hierarchy for the instance. * * @method _initHierarchyData * @private */ _initHierarchyData : function() { var c = this.constructor, classes = [], attrs = []; while (c) { // Add to classes classes[classes.length] = c; // Add to attributes if (c.ATTRS) { attrs[attrs.length] = c.ATTRS; } c = c.superclass ? c.superclass.constructor : null; } this._classes = classes; this._attrs = this._aggregateAttrs(attrs); }, /** * A helper method, used by _initHierarchyData to aggregate * attribute configuration across the instances class hierarchy. * * The method will potect the attribute configuration value to protect the statically defined * default value in ATTRS if required (if the value is an object literal, array or the * attribute configuration has cloneDefaultValue set to shallow or deep). * * @method _aggregateAttrs * @private * @param {Array} allAttrs An array of ATTRS definitions across classes in the hierarchy * (subclass first, Base last) * @return {Object} The aggregate set of ATTRS definitions for the instance */ _aggregateAttrs : function(allAttrs) { var attr, attrs, cfg, val, path, i, clone, cfgProps = Base._ATTR_CFG, aggAttrs = {}; if (allAttrs) { for (i = allAttrs.length-1; i >= 0; --i) { attrs = allAttrs[i]; for (attr in attrs) { if (attrs.hasOwnProperty(attr)) { // Protect config passed in cfg = Y.mix({}, attrs[attr], true, cfgProps); val = cfg.value; clone = cfg.cloneDefaultValue; if (val) { if ( (clone === undefined && (OBJECT_CONSTRUCTOR === val.constructor || L.isArray(val))) || clone === DEEP || clone === true) { cfg.value = Y.clone(val); } else if (clone === SHALLOW) { cfg.value = Y.merge(val); } // else if (clone === false), don't clone the static default value. // It's intended to be used by reference. } path = null; if (attr.indexOf(DOT) !== -1) { path = attr.split(DOT); attr = path.shift(); } if (path && aggAttrs[attr] && aggAttrs[attr].value) { O.setValue(aggAttrs[attr].value, path, val); } else if (!path){ if (!aggAttrs[attr]) { aggAttrs[attr] = cfg; } else { Y.mix(aggAttrs[attr], cfg, true, cfgProps); } } } } } } return aggAttrs; }, /** * Initializes the class hierarchy for the instance, which includes * initializing attributes for each class defined in the class's * static ATTRS property and * invoking the initializer method on the prototype of each class in the hierarchy. * * @method _initHierarchy * @param {Object} userVals Object with configuration property name/value pairs * @private */ _initHierarchy : function(userVals) { var lazy = this._lazyAddAttrs, constr, constrProto, ci, ei, el, classes = this._getClasses(), attrCfgs = this._getAttrCfgs(); for (ci = classes.length-1; ci >= 0; ci--) { constr = classes[ci]; constrProto = constr.prototype; if (constr._yuibuild && constr._yuibuild.exts) { for (ei = 0, el = constr._yuibuild.exts.length; ei < el; ei++) { constr._yuibuild.exts[ei].apply(this, arguments); } } this.addAttrs(this._filterAttrCfgs(constr, attrCfgs), userVals, lazy); // Using INITIALIZER in hasOwnProperty check, for performance reasons (helps IE6 avoid GC thresholds when // referencing string literals). Not using it in apply, again, for performance "." is faster. if (constrProto.hasOwnProperty(INITIALIZER)) { constrProto.initializer.apply(this, arguments); } } }, /** * Destroys the class hierarchy for this instance by invoking * the descructor method on the prototype of each class in the hierarchy. * * @method _destroyHierarchy * @private */ _destroyHierarchy : function() { var constr, constrProto, ci, cl, classes = this._getClasses(); for (ci = 0, cl = classes.length; ci < cl; ci++) { constr = classes[ci]; constrProto = constr.prototype; if (constrProto.hasOwnProperty(DESTRUCTOR)) { constrProto.destructor.apply(this, arguments); } } }, /** * Default toString implementation. Provides the constructor NAME * and the instance ID. * * @method toString * @return {String} String representation for this object */ toString: function() { return this.constructor.NAME + "[" + Y.stamp(this) + "]"; } }; // Straightup augment, no wrapper functions Y.mix(Base, Attribute, false, null, 1); // Fix constructor Base.prototype.constructor = Base; Y.Base = Base; }, '3.1.2' ,{requires:['attribute-base']}); YUI.add('base-pluginhost', function(Y) { /** * The base-pluginhost submodule adds Plugin support to Base, by augmenting Base with * Plugin.Host and setting up static (class level) Base.plug and Base.unplug methods. * * @module base * @submodule base-pluginhost * @for Base */ var Base = Y.Base, PluginHost = Y.Plugin.Host; Y.mix(Base, PluginHost, false, null, 1); /** * Alias for Plugin.Host.plug. See aliased * method for argument and return value details. * * @method Base.plug * @static */ Base.plug = PluginHost.plug; /** * Alias for Plugin.Host.unplug. See the * aliased method for argument and return value details. * * @method Base.unplug * @static */ Base.unplug = PluginHost.unplug; }, '3.1.2' ,{requires:['base-base', 'pluginhost']}); YUI.add('base-build', function(Y) { /** * The base-build submodule provides Base.build functionality, which * can be used to create custom classes, by aggregating extensions onto * a main class. * * @module base * @submodule base-build * @for Base */ var Base = Y.Base, L = Y.Lang, build; Base._build = function(name, main, extensions, px, sx, cfg) { var build = Base._build, builtClass = build._ctor(main, cfg), buildCfg = build._cfg(main, cfg), _mixCust = build._mixCust, aggregates = buildCfg.aggregates, custom = buildCfg.custom, dynamic = builtClass._yuibuild.dynamic, i, l, val, extClass; if (dynamic && aggregates) { for (i = 0, l = aggregates.length; i < l; ++i) { val = aggregates[i]; if (main.hasOwnProperty(val)) { builtClass[val] = L.isArray(main[val]) ? [] : {}; } } } // Augment/Aggregate for (i = 0, l = extensions.length; i < l; i++) { extClass = extensions[i]; // Prototype, old non-displacing augment Y.mix(builtClass, extClass, true, null, 1); // Custom Statics _mixCust(builtClass, extClass, aggregates, custom); builtClass._yuibuild.exts.push(extClass); } if (px) { Y.mix(builtClass.prototype, px, true); } if (sx) { Y.mix(builtClass, build._clean(sx, aggregates, custom), true); _mixCust(builtClass, sx, aggregates, custom); } builtClass.prototype.hasImpl = build._impl; if (dynamic) { builtClass.NAME = name; builtClass.prototype.constructor = builtClass; } return builtClass; }; build = Base._build; Y.mix(build, { _mixCust: function(r, s, aggregates, custom) { if (aggregates) { Y.aggregate(r, s, true, aggregates); } if (custom) { for (var j in custom) { if (custom.hasOwnProperty(j)) { custom[j](j, r, s); } } } }, _tmpl: function(main) { function BuiltClass() { BuiltClass.superclass.constructor.apply(this, arguments); } Y.extend(BuiltClass, main); return BuiltClass; }, _impl : function(extClass) { var classes = this._getClasses(), i, l, cls, exts, ll, j; for (i = 0, l = classes.length; i < l; i++) { cls = classes[i]; if (cls._yuibuild) { exts = cls._yuibuild.exts; ll = exts.length; for (j = 0; j < ll; j++) { if (exts[j] === extClass) { return true; } } } } return false; }, _ctor : function(main, cfg) { var dynamic = (cfg && false === cfg.dynamic) ? false : true, builtClass = (dynamic) ? build._tmpl(main) : main; builtClass._yuibuild = { id: null, exts : [], dynamic: dynamic }; return builtClass; }, _cfg : function(main, cfg) { var aggr = [], cust = {}, buildCfg, cfgAggr = (cfg && cfg.aggregates), cfgCustBuild = (cfg && cfg.custom), c = main; while (c && c.prototype) { buildCfg = c._buildCfg; if (buildCfg) { if (buildCfg.aggregates) { aggr = aggr.concat(buildCfg.aggregates); } if (buildCfg.custom) { Y.mix(cust, buildCfg.custom, true); } } c = c.superclass ? c.superclass.constructor : null; } if (cfgAggr) { aggr = aggr.concat(cfgAggr); } if (cfgCustBuild) { Y.mix(cust, cfg.cfgBuild, true); } return { aggregates: aggr, custom: cust }; }, _clean : function(sx, aggregates, custom) { var prop, i, l, sxclone = Y.merge(sx); for (prop in custom) { if (sxclone.hasOwnProperty(prop)) { delete sxclone[prop]; } } for (i = 0, l = aggregates.length; i < l; i++) { prop = aggregates[i]; if (sxclone.hasOwnProperty(prop)) { delete sxclone[prop]; } } return sxclone; } }); /** *

* Builds a custom constructor function (class) from the * main function, and array of extension functions (classes) * provided. The NAME field for the constructor function is * defined by the first argument passed in. *

*

* The cfg object supports the following properties *

*
*
dynamic <boolean>
*
*

If true (default), a completely new class * is created which extends the main class, and acts as the * host on which the extension classes are augmented.

*

If false, the extensions classes are augmented directly to * the main class, modifying the main class' prototype.

*
*
aggregates <String[]>
*
An array of static property names, which will get aggregated * on to the built class, in addition to the default properties build * will always aggregate as defined by the main class' static _buildCfg * property. *
*
* * @method Base.build * @static * @param {Function} name The name of the new class. Used to defined the NAME property for the new class. * @param {Function} main The main class on which to base the built class * @param {Function[]} extensions The set of extension classes which will be * augmented/aggregated to the built class. * @param {Object} cfg Optional. Build configuration for the class (see description). * @return {Function} A custom class, created from the provided main and extension classes */ Base.build = function(name, main, extensions, cfg) { return build(name, main, extensions, null, null, cfg); }; /** *

Creates a new class (constructor function) which extends the base class passed in as the second argument, * and mixes in the array of extensions provided.

*

Prototype properties or methods can be added to the new class, using the px argument (similar to Y.extend).

*

Static properties or methods can be added to the new class, using the sx argument (similar to Y.extend).

*

* *

* @method Base.create * @static * @param {Function} name The name of the newly created class. Used to defined the NAME property for the new class. * @param {Function} main The base class which the new class should extend. This class needs to be Base or a class derived from base (e.g. Widget). * @param {Function[]} extensions The list of extensions which will be mixed into the built class. * @return {Function} The newly created class. */ Base.create = function(name, base, extensions, px, sx) { return build(name, base, extensions, px, sx); }; /** *

Mixes in a list of extensions to an existing class.

* @method Base.mix * @static * @param {Function} main The existing class into which the extensions should be mixed. The class needs to be Base or class derived from base (e.g. Widget) * @param {Function[]} extensions The set of extension classes which will mixed into the existing main class. * @return {Function} The modified main class, with extensions mixed in. */ Base.mix = function(main, extensions) { return build(null, main, extensions, null, null, {dynamic:false}); }; /** * The build configuration for the Base class. * * Defines the static fields which need to be aggregated * when the Base class is used as the main class passed to * the Base.build method. * * @property Base._buildCfg * @type Object * @static * @final * @private */ Base._buildCfg = { custom : { ATTRS : function(prop, r, s) { r[prop] = r[prop] || {}; if (s[prop]) { Y.aggregate(r[prop], s[prop], true); } } }, aggregates : ["_PLUG", "_UNPLUG"] }; }, '3.1.2' ,{requires:['base-base']}); YUI.add('base', function(Y){}, '3.1.2' ,{use:['base-base', 'base-pluginhost', 'base-build']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('dom-base', function(Y) { (function(Y) { /** * The DOM utility provides a cross-browser abtraction layer * normalizing DOM tasks, and adds extra helper functionality * for other common tasks. * @module dom * @submodule dom-base * */ /** * Provides DOM helper methods. * @class DOM * */ var NODE_TYPE = 'nodeType', OWNER_DOCUMENT = 'ownerDocument', DEFAULT_VIEW = 'defaultView', PARENT_WINDOW = 'parentWindow', TAG_NAME = 'tagName', PARENT_NODE = 'parentNode', FIRST_CHILD = 'firstChild', PREVIOUS_SIBLING = 'previousSibling', NEXT_SIBLING = 'nextSibling', CONTAINS = 'contains', COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition', EMPTY_STRING = '', documentElement = document.documentElement, re_tag = /<([a-z]+)/i; Y.DOM = { /** * Returns the HTMLElement with the given ID (Wrapper for document.getElementById). * @method byId * @param {String} id the id attribute * @param {Object} doc optional The document to search. Defaults to current document * @return {HTMLElement | null} The HTMLElement with the id, or null if none found. */ byId: function(id, doc) { // handle dupe IDs and IE name collision return Y.DOM.allById(id, doc)[0] || null; }, // @deprecated children: function(node, tag) { var ret = []; if (node) { tag = tag || '*'; ret = Y.Selector.query('> ' + tag, node); } return ret; }, // @deprecated firstByTag: function(tag, root) { var ret; root = root || Y.config.doc; if (tag && root.getElementsByTagName) { ret = root.getElementsByTagName(tag)[0]; } return ret || null; }, /** * Returns the text content of the HTMLElement. * @method getText * @param {HTMLElement} element The html element. * @return {String} The text content of the element (includes text of any descending elements). */ getText: (documentElement.textContent !== undefined) ? function(element) { var ret = ''; if (element) { ret = element.textContent; } return ret || ''; } : function(element) { var ret = ''; if (element) { ret = element.innerText; } return ret || ''; }, /** * Sets the text content of the HTMLElement. * @method setText * @param {HTMLElement} element The html element. * @param {String} content The content to add. */ setText: (documentElement.textContent !== undefined) ? function(element, content) { if (element) { element.textContent = content; } } : function(element, content) { if (element) { element.innerText = content; } }, /* * Finds the previous sibling of the element. * @method previous * @deprecated Use elementByAxis * @param {HTMLElement} element The html element. * @param {Function} fn optional An optional boolean test to apply. * The optional function is passed the current DOM node being tested as its only argument. * If no function is given, the first sibling is returned. * @param {Boolean} all optional Whether all node types should be scanned, or just element nodes. * @return {HTMLElement | null} The matching DOM node or null if none found. */ previous: function(element, fn, all) { return Y.DOM.elementByAxis(element, PREVIOUS_SIBLING, fn, all); }, /* * Finds the next sibling of the element. * @method next * @deprecated Use elementByAxis * @param {HTMLElement} element The html element. * @param {Function} fn optional An optional boolean test to apply. * The optional function is passed the current DOM node being tested as its only argument. * If no function is given, the first sibling is returned. * @param {Boolean} all optional Whether all node types should be scanned, or just element nodes. * @return {HTMLElement | null} The matching DOM node or null if none found. */ next: function(element, fn, all) { return Y.DOM.elementByAxis(element, NEXT_SIBLING, fn, all); }, /* * Finds the ancestor of the element. * @method ancestor * @deprecated Use elementByAxis * @param {HTMLElement} element The html element. * @param {Function} fn optional An optional boolean test to apply. * The optional function is passed the current DOM node being tested as its only argument. * If no function is given, the parentNode is returned. * @param {Boolean} testSelf optional Whether or not to include the element in the scan * @return {HTMLElement | null} The matching DOM node or null if none found. */ ancestor: function(element, fn, testSelf) { var ret = null; if (testSelf) { ret = (!fn || fn(element)) ? element : null; } return ret || Y.DOM.elementByAxis(element, PARENT_NODE, fn, null); }, /** * Searches the element by the given axis for the first matching element. * @method elementByAxis * @param {HTMLElement} element The html element. * @param {String} axis The axis to search (parentNode, nextSibling, previousSibling). * @param {Function} fn optional An optional boolean test to apply. * @param {Boolean} all optional Whether all node types should be returned, or just element nodes. * The optional function is passed the current HTMLElement being tested as its only argument. * If no function is given, the first element is returned. * @return {HTMLElement | null} The matching element or null if none found. */ elementByAxis: function(element, axis, fn, all) { while (element && (element = element[axis])) { // NOTE: assignment if ( (all || element[TAG_NAME]) && (!fn || fn(element)) ) { return element; } } return null; }, /** * Determines whether or not one HTMLElement is or contains another HTMLElement. * @method contains * @param {HTMLElement} element The containing html element. * @param {HTMLElement} needle The html element that may be contained. * @return {Boolean} Whether or not the element is or contains the needle. */ contains: function(element, needle) { var ret = false; if ( !needle || !element || !needle[NODE_TYPE] || !element[NODE_TYPE]) { ret = false; } else if (element[CONTAINS]) { if (Y.UA.opera || needle[NODE_TYPE] === 1) { // IE & SAF contains fail if needle not an ELEMENT_NODE ret = element[CONTAINS](needle); } else { ret = Y.DOM._bruteContains(element, needle); } } else if (element[COMPARE_DOCUMENT_POSITION]) { // gecko if (element === needle || !!(element[COMPARE_DOCUMENT_POSITION](needle) & 16)) { ret = true; } } return ret; }, /** * Determines whether or not the HTMLElement is part of the document. * @method inDoc * @param {HTMLElement} element The containing html element. * @param {HTMLElement} doc optional The document to check. * @return {Boolean} Whether or not the element is attached to the document. */ inDoc: function(element, doc) { // there may be multiple elements with the same ID doc = doc || element[OWNER_DOCUMENT]; var nodes = [], ret = false, i, node, query; element.id = element.id || Y.guid(); nodes = Y.DOM.allById(element.id, doc); for (i = 0; node = nodes[i++];) { // check for a match if (node === element) { ret = true; break; } } return ret; }, allById: function(id, root) { root = root || Y.config.doc; var nodes = [], ret = [], i, node; if (root.querySelectorAll) { ret = root.querySelectorAll('[id="' + id + '"]'); } else if (root.all) { nodes = root.all(id); if (nodes && nodes.nodeType) { // root.all may return one or many nodes = [nodes]; } if (nodes && nodes.length) { for (i = 0; node = nodes[i++];) { // check for a match if (node.id === id) { // avoid false positive for node.name ret.push(node); } } } } else { ret = [Y.DOM._getDoc(root).getElementById(id)]; } return ret; }, /** * Creates a new dom node using the provided markup string. * @method create * @param {String} html The markup used to create the element * @param {HTMLDocument} doc An optional document context * @return {HTMLElement|DocumentFragment} returns a single HTMLElement * when creating one node, and a documentFragment when creating * multiple nodes. */ create: function(html, doc) { if (typeof html === 'string') { html = Y.Lang.trim(html); // match IE which trims whitespace from innerHTML } doc = doc || Y.config.doc; var m = re_tag.exec(html), create = Y.DOM._create, custom = Y.DOM.creators, ret = null, tag, nodes; if (m && custom[m[1]]) { if (typeof custom[m[1]] === 'function') { create = custom[m[1]]; } else { tag = custom[m[1]]; } } nodes = create(html, doc, tag).childNodes; if (nodes.length === 1) { // return single node, breaking parentNode ref from "fragment" ret = nodes[0].parentNode.removeChild(nodes[0]); } else { // return multiple nodes as a fragment ret = Y.DOM._nl2frag(nodes, doc); } return ret; }, _nl2frag: function(nodes, doc) { var ret = null, i, len; if (nodes && (nodes.push || nodes.item) && nodes[0]) { doc = doc || nodes[0].ownerDocument; ret = doc.createDocumentFragment(); if (nodes.item) { // convert live list to static array nodes = Y.Array(nodes, 0, true); } for (i = 0, len = nodes.length; i < len; i++) { ret.appendChild(nodes[i]); } } // else inline with log for minification return ret; }, CUSTOM_ATTRIBUTES: (!documentElement.hasAttribute) ? { // IE < 8 'for': 'htmlFor', 'class': 'className' } : { // w3c 'htmlFor': 'for', 'className': 'class' }, /** * Provides a normalized attribute interface. * @method setAttibute * @param {String | HTMLElement} el The target element for the attribute. * @param {String} attr The attribute to set. * @param {String} val The value of the attribute. */ setAttribute: function(el, attr, val, ieAttr) { if (el && el.setAttribute) { attr = Y.DOM.CUSTOM_ATTRIBUTES[attr] || attr; el.setAttribute(attr, val, ieAttr); } }, /** * Provides a normalized attribute interface. * @method getAttibute * @param {String | HTMLElement} el The target element for the attribute. * @param {String} attr The attribute to get. * @return {String} The current value of the attribute. */ getAttribute: function(el, attr, ieAttr) { ieAttr = (ieAttr !== undefined) ? ieAttr : 2; var ret = ''; if (el && el.getAttribute) { attr = Y.DOM.CUSTOM_ATTRIBUTES[attr] || attr; ret = el.getAttribute(attr, ieAttr); if (ret === null) { ret = ''; // per DOM spec } } return ret; }, isWindow: function(obj) { return obj.alert && obj.document; }, _fragClones: {}, _create: function(html, doc, tag) { tag = tag || 'div'; var frag = Y.DOM._fragClones[tag]; if (frag) { frag = frag.cloneNode(false); } else { frag = Y.DOM._fragClones[tag] = doc.createElement(tag); } frag.innerHTML = html; return frag; }, _removeChildNodes: function(node) { while (node.firstChild) { node.removeChild(node.firstChild); } }, /** * Inserts content in a node at the given location * @method addHTML * @param {HTMLElement} node The node to insert into * @param {String} content The content to be inserted * @param {String} where Where to insert the content; default is after lastChild */ addHTML: function(node, content, where) { if (typeof content === 'string') { content = Y.Lang.trim(content); // match IE which trims whitespace from innerHTML } var nodeParent = node.parentNode, newNode; if (content) { if (content.nodeType) { // domNode newNode = content; } else { // create from string and cache newNode = Y.DOM.create(content); } } if (where) { if (where.nodeType) { // insert regardless of relationship to node // TODO: check if node.contains(where)? where.parentNode.insertBefore(newNode, where); } else { switch (where) { case 'replace': while (node.firstChild) { node.removeChild(node.firstChild); } if (newNode) { // allow empty content to clear node node.appendChild(newNode); } break; case 'before': nodeParent.insertBefore(newNode, node); break; case 'after': if (node.nextSibling) { // IE errors if refNode is null nodeParent.insertBefore(newNode, node.nextSibling); } else { nodeParent.appendChild(newNode); } break; default: node.appendChild(newNode); } } } else { node.appendChild(newNode); } return newNode; }, VALUE_SETTERS: {}, VALUE_GETTERS: {}, getValue: function(node) { var ret = '', // TODO: return null? getter; if (node && node[TAG_NAME]) { getter = Y.DOM.VALUE_GETTERS[node[TAG_NAME].toLowerCase()]; if (getter) { ret = getter(node); } else { ret = node.value; } } // workaround for IE8 JSON stringify bug // which converts empty string values to null if (ret === EMPTY_STRING) { ret = EMPTY_STRING; // for real } return (typeof ret === 'string') ? ret : ''; }, setValue: function(node, val) { var setter; if (node && node[TAG_NAME]) { setter = Y.DOM.VALUE_SETTERS[node[TAG_NAME].toLowerCase()]; if (setter) { setter(node, val); } else { node.value = val; } } }, siblings: function(node, fn) { var nodes = [], sibling = node; while ((sibling = sibling[PREVIOUS_SIBLING])) { if (sibling[TAG_NAME] && (!fn || fn(sibling))) { nodes.unshift(sibling); } } sibling = node; while ((sibling = sibling[NEXT_SIBLING])) { if (sibling[TAG_NAME] && (!fn || fn(sibling))) { nodes.push(sibling); } } return nodes; }, /** * Brute force version of contains. * Used for browsers without contains support for non-HTMLElement Nodes (textNodes, etc). * @method _bruteContains * @private * @param {HTMLElement} element The containing html element. * @param {HTMLElement} needle The html element that may be contained. * @return {Boolean} Whether or not the element is or contains the needle. */ _bruteContains: function(element, needle) { while (needle) { if (element === needle) { return true; } needle = needle.parentNode; } return false; }, // TODO: move to Lang? /** * Memoizes dynamic regular expressions to boost runtime performance. * @method _getRegExp * @private * @param {String} str The string to convert to a regular expression. * @param {String} flags optional An optinal string of flags. * @return {RegExp} An instance of RegExp */ _getRegExp: function(str, flags) { flags = flags || ''; Y.DOM._regexCache = Y.DOM._regexCache || {}; if (!Y.DOM._regexCache[str + flags]) { Y.DOM._regexCache[str + flags] = new RegExp(str, flags); } return Y.DOM._regexCache[str + flags]; }, // TODO: make getDoc/Win true privates? /** * returns the appropriate document. * @method _getDoc * @private * @param {HTMLElement} element optional Target element. * @return {Object} The document for the given element or the default document. */ _getDoc: function(element) { var doc = Y.config.doc; if (element) { doc = (element[NODE_TYPE] === 9) ? element : // element === document element[OWNER_DOCUMENT] || // element === DOM node element.document || // element === window Y.config.doc; // default } return doc; }, /** * returns the appropriate window. * @method _getWin * @private * @param {HTMLElement} element optional Target element. * @return {Object} The window for the given element or the default window. */ _getWin: function(element) { var doc = Y.DOM._getDoc(element); return doc[DEFAULT_VIEW] || doc[PARENT_WINDOW] || Y.config.win; }, _batch: function(nodes, fn, arg1, arg2, arg3, etc) { fn = (typeof name === 'string') ? Y.DOM[fn] : fn; var result, ret = []; if (fn && nodes) { Y.each(nodes, function(node) { if ((result = fn.call(Y.DOM, node, arg1, arg2, arg3, etc)) !== undefined) { ret[ret.length] = result; } }); } return ret.length ? ret : nodes; }, creators: {}, _IESimpleCreate: function(html, doc) { doc = doc || Y.config.doc; return doc.createElement(html); } }; (function(Y) { var creators = Y.DOM.creators, create = Y.DOM.create, re_tbody = /(?:\/(?:thead|tfoot|tbody|caption|col|colgroup)>)+\s* 1 && tb && !re_tbody.test(html)) { tb[PARENT_NODE].removeChild(tb); // strip extraneous tbody } return frag; }, script: function(html, doc) { var frag = doc.createElement('div'); frag.innerHTML = '-' + html; frag.removeChild(frag[FIRST_CHILD]); return frag; } }, true); Y.mix(Y.DOM.VALUE_GETTERS, { button: function(node) { return (node.attributes && node.attributes.value) ? node.attributes.value.value : ''; } }); Y.mix(Y.DOM.VALUE_SETTERS, { // IE: node.value changes the button text, which should be handled via innerHTML button: function(node, val) { var attr = node.attributes.value; if (!attr) { attr = node[OWNER_DOCUMENT].createAttribute('value'); node.setAttributeNode(attr); } attr.value = val; }, select: function(node, val) { for (var i = 0, options = node.getElementsByTagName('option'), option; option = options[i++];) { if (Y.DOM.getValue(option) === val) { Y.DOM.setAttribute(option, 'selected', true); break; } } } }); } if (Y.UA.gecko || Y.UA.ie) { Y.mix(creators, { option: function(html, doc) { return create('', doc); }, tr: function(html, doc) { return create('' + html + '', doc); }, td: function(html, doc) { return create('' + html + '', doc); }, tbody: function(html, doc) { return create(TABLE_OPEN + html + TABLE_CLOSE, doc); } }); Y.mix(creators, { legend: 'fieldset', th: creators.td, thead: creators.tbody, tfoot: creators.tbody, caption: creators.tbody, colgroup: creators.tbody, col: creators.tbody, optgroup: creators.option }); } Y.mix(Y.DOM.VALUE_GETTERS, { option: function(node) { var attrs = node.attributes; return (attrs.value && attrs.value.specified) ? node.value : node.text; }, select: function(node) { var val = node.value, options = node.options; if (options && val === '') { // TODO: implement multipe select if (node.multiple) { } else { val = Y.DOM.getValue(options[node.selectedIndex]); } } return val; } }); })(Y); })(Y); var addClass, hasClass, removeClass; Y.mix(Y.DOM, { /** * Determines whether a DOM element has the given className. * @method hasClass * @param {HTMLElement} element The DOM element. * @param {String} className the class name to search for * @return {Boolean} Whether or not the element has the given class. */ hasClass: function(node, className) { var re = Y.DOM._getRegExp('(?:^|\\s+)' + className + '(?:\\s+|$)'); return re.test(node.className); }, /** * Adds a class name to a given DOM element. * @method addClass * @param {HTMLElement} element The DOM element. * @param {String} className the class name to add to the class attribute */ addClass: function(node, className) { if (!Y.DOM.hasClass(node, className)) { // skip if already present node.className = Y.Lang.trim([node.className, className].join(' ')); } }, /** * Removes a class name from a given element. * @method removeClass * @param {HTMLElement} element The DOM element. * @param {String} className the class name to remove from the class attribute */ removeClass: function(node, className) { if (className && hasClass(node, className)) { node.className = Y.Lang.trim(node.className.replace(Y.DOM._getRegExp('(?:^|\\s+)' + className + '(?:\\s+|$)'), ' ')); if ( hasClass(node, className) ) { // in case of multiple adjacent removeClass(node, className); } } }, /** * Replace a class with another class for a given element. * If no oldClassName is present, the newClassName is simply added. * @method replaceClass * @param {HTMLElement} element The DOM element * @param {String} oldClassName the class name to be replaced * @param {String} newClassName the class name that will be replacing the old class name */ replaceClass: function(node, oldC, newC) { removeClass(node, oldC); // remove first in case oldC === newC addClass(node, newC); }, /** * If the className exists on the node it is removed, if it doesn't exist it is added. * @method toggleClass * @param {HTMLElement} element The DOM element * @param {String} className the class name to be toggled * @param {Boolean} addClass optional boolean to indicate whether class * should be added or removed regardless of current state */ toggleClass: function(node, className, force) { var add = (force !== undefined) ? force : !(hasClass(node, className)); if (add) { addClass(node, className); } else { removeClass(node, className); } } }); hasClass = Y.DOM.hasClass; removeClass = Y.DOM.removeClass; addClass = Y.DOM.addClass; }, '3.1.2' ,{requires:['oop']}); YUI.add('dom-style', function(Y) { (function(Y) { /** * Add style management functionality to DOM. * @module dom * @submodule dom-style * @for DOM */ var DOCUMENT_ELEMENT = 'documentElement', DEFAULT_VIEW = 'defaultView', OWNER_DOCUMENT = 'ownerDocument', STYLE = 'style', FLOAT = 'float', CSS_FLOAT = 'cssFloat', STYLE_FLOAT = 'styleFloat', TRANSPARENT = 'transparent', GET_COMPUTED_STYLE = 'getComputedStyle', DOCUMENT = Y.config.doc, UNDEFINED = undefined, Y_DOM = Y.DOM, re_color = /color$/i, re_unit = /width|height|top|left|right|bottom|margin|padding/i; Y.mix(Y_DOM, { DEFAULT_UNIT: 'px', CUSTOM_STYLES: { }, /** * Sets a style property for a given element. * @method setStyle * @param {HTMLElement} An HTMLElement to apply the style to. * @param {String} att The style property to set. * @param {String|Number} val The value. */ setStyle: function(node, att, val, style) { style = style || node.style; var CUSTOM_STYLES = Y_DOM.CUSTOM_STYLES, current; if (style) { if (val === null || val === '') { // normalize unsetting val = ''; } else if (!isNaN(new Number(val)) && re_unit.test(att)) { // number values may need a unit val += Y_DOM.DEFAULT_UNIT; } if (att in CUSTOM_STYLES) { if (CUSTOM_STYLES[att].set) { CUSTOM_STYLES[att].set(node, val, style); return; // NOTE: return } else if (typeof CUSTOM_STYLES[att] === 'string') { att = CUSTOM_STYLES[att]; } } style[att] = val; } }, /** * Returns the current style value for the given property. * @method getStyle * @param {HTMLElement} An HTMLElement to get the style from. * @param {String} att The style property to get. */ getStyle: function(node, att, style) { style = style || node.style; var CUSTOM_STYLES = Y_DOM.CUSTOM_STYLES, val = ''; if (style) { if (att in CUSTOM_STYLES) { if (CUSTOM_STYLES[att].get) { return CUSTOM_STYLES[att].get(node, att, style); // NOTE: return } else if (typeof CUSTOM_STYLES[att] === 'string') { att = CUSTOM_STYLES[att]; } } val = style[att]; if (val === '') { // TODO: is empty string sufficient? val = Y_DOM[GET_COMPUTED_STYLE](node, att); } } return val; }, /** * Sets multiple style properties. * @method setStyles * @param {HTMLElement} node An HTMLElement to apply the styles to. * @param {Object} hash An object literal of property:value pairs. */ setStyles: function(node, hash) { var style = node.style; Y.each(hash, function(v, n) { Y_DOM.setStyle(node, n, v, style); }, Y_DOM); }, /** * Returns the computed style for the given node. * @method getComputedStyle * @param {HTMLElement} An HTMLElement to get the style from. * @param {String} att The style property to get. * @return {String} The computed value of the style property. */ getComputedStyle: function(node, att) { var val = '', doc = node[OWNER_DOCUMENT]; if (node[STYLE]) { val = doc[DEFAULT_VIEW][GET_COMPUTED_STYLE](node, null)[att]; } return val; } }); // normalize reserved word float alternatives ("cssFloat" or "styleFloat") if (DOCUMENT[DOCUMENT_ELEMENT][STYLE][CSS_FLOAT] !== UNDEFINED) { Y_DOM.CUSTOM_STYLES[FLOAT] = CSS_FLOAT; } else if (DOCUMENT[DOCUMENT_ELEMENT][STYLE][STYLE_FLOAT] !== UNDEFINED) { Y_DOM.CUSTOM_STYLES[FLOAT] = STYLE_FLOAT; } // fix opera computedStyle default color unit (convert to rgb) if (Y.UA.opera) { Y_DOM[GET_COMPUTED_STYLE] = function(node, att) { var view = node[OWNER_DOCUMENT][DEFAULT_VIEW], val = view[GET_COMPUTED_STYLE](node, '')[att]; if (re_color.test(att)) { val = Y.Color.toRGB(val); } return val; }; } // safari converts transparent to rgba(), others use "transparent" if (Y.UA.webkit) { Y_DOM[GET_COMPUTED_STYLE] = function(node, att) { var view = node[OWNER_DOCUMENT][DEFAULT_VIEW], val = view[GET_COMPUTED_STYLE](node, '')[att]; if (val === 'rgba(0, 0, 0, 0)') { val = TRANSPARENT; } return val; }; } })(Y); (function(Y) { var PARSE_INT = parseInt, RE = RegExp; Y.Color = { KEYWORDS: { black: '000', silver: 'c0c0c0', gray: '808080', white: 'fff', maroon: '800000', red: 'f00', purple: '800080', fuchsia: 'f0f', green: '008000', lime: '0f0', olive: '808000', yellow: 'ff0', navy: '000080', blue: '00f', teal: '008080', aqua: '0ff' }, re_RGB: /^rgb\(([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\)$/i, re_hex: /^#?([0-9A-F]{2})([0-9A-F]{2})([0-9A-F]{2})$/i, re_hex3: /([0-9A-F])/gi, toRGB: function(val) { if (!Y.Color.re_RGB.test(val)) { val = Y.Color.toHex(val); } if(Y.Color.re_hex.exec(val)) { val = 'rgb(' + [ PARSE_INT(RE.$1, 16), PARSE_INT(RE.$2, 16), PARSE_INT(RE.$3, 16) ].join(', ') + ')'; } return val; }, toHex: function(val) { val = Y.Color.KEYWORDS[val] || val; if (Y.Color.re_RGB.exec(val)) { val = [ Number(RE.$1).toString(16), Number(RE.$2).toString(16), Number(RE.$3).toString(16) ]; for (var i = 0; i < val.length; i++) { if (val[i].length < 2) { val[i] = '0' + val[i]; } } val = val.join(''); } if (val.length < 6) { val = val.replace(Y.Color.re_hex3, '$1$1'); } if (val !== 'transparent' && val.indexOf('#') < 0) { val = '#' + val; } return val.toUpperCase(); } }; })(Y); (function(Y) { var HAS_LAYOUT = 'hasLayout', PX = 'px', FILTER = 'filter', FILTERS = 'filters', OPACITY = 'opacity', AUTO = 'auto', BORDER_WIDTH = 'borderWidth', BORDER_TOP_WIDTH = 'borderTopWidth', BORDER_RIGHT_WIDTH = 'borderRightWidth', BORDER_BOTTOM_WIDTH = 'borderBottomWidth', BORDER_LEFT_WIDTH = 'borderLeftWidth', WIDTH = 'width', HEIGHT = 'height', TRANSPARENT = 'transparent', VISIBLE = 'visible', GET_COMPUTED_STYLE = 'getComputedStyle', UNDEFINED = undefined, documentElement = document.documentElement, // TODO: unit-less lineHeight (e.g. 1.22) re_unit = /^(\d[.\d]*)+(em|ex|px|gd|rem|vw|vh|vm|ch|mm|cm|in|pt|pc|deg|rad|ms|s|hz|khz|%){1}?/i, _getStyleObj = function(node) { return node.currentStyle || node.style; }, ComputedStyle = { CUSTOM_STYLES: {}, get: function(el, property) { var value = '', current; if (el) { current = _getStyleObj(el)[property]; if (property === OPACITY && Y.DOM.CUSTOM_STYLES[OPACITY]) { value = Y.DOM.CUSTOM_STYLES[OPACITY].get(el); } else if (!current || (current.indexOf && current.indexOf(PX) > -1)) { // no need to convert value = current; } else if (Y.DOM.IE.COMPUTED[property]) { // use compute function value = Y.DOM.IE.COMPUTED[property](el, property); } else if (re_unit.test(current)) { // convert to pixel value = ComputedStyle.getPixel(el, property) + PX; } else { value = current; } } return value; }, sizeOffsets: { width: ['Left', 'Right'], height: ['Top', 'Bottom'], top: ['Top'], bottom: ['Bottom'] }, getOffset: function(el, prop) { var current = _getStyleObj(el)[prop], // value of "width", "top", etc. capped = prop.charAt(0).toUpperCase() + prop.substr(1), // "Width", "Top", etc. offset = 'offset' + capped, // "offsetWidth", "offsetTop", etc. pixel = 'pixel' + capped, // "pixelWidth", "pixelTop", etc. sizeOffsets = ComputedStyle.sizeOffsets[prop], value = ''; // IE pixelWidth incorrect for percent // manually compute by subtracting padding and border from offset size // NOTE: clientWidth/Height (size minus border) is 0 when current === AUTO so offsetHeight is used // reverting to auto from auto causes position stacking issues (old impl) if (current === AUTO || current.indexOf('%') > -1) { value = el['offset' + capped]; if (sizeOffsets[0]) { value -= ComputedStyle.getPixel(el, 'padding' + sizeOffsets[0]); value -= ComputedStyle.getBorderWidth(el, 'border' + sizeOffsets[0] + 'Width', 1); } if (sizeOffsets[1]) { value -= ComputedStyle.getPixel(el, 'padding' + sizeOffsets[1]); value -= ComputedStyle.getBorderWidth(el, 'border' + sizeOffsets[1] + 'Width', 1); } } else { // use style.pixelWidth, etc. to convert to pixels // need to map style.width to currentStyle (no currentStyle.pixelWidth) if (!el.style[pixel] && !el.style[prop]) { el.style[prop] = current; } value = el.style[pixel]; } return value + PX; }, borderMap: { thin: '2px', medium: '4px', thick: '6px' }, getBorderWidth: function(el, property, omitUnit) { var unit = omitUnit ? '' : PX, current = el.currentStyle[property]; if (current.indexOf(PX) < 0) { // look up keywords if a border exists if (ComputedStyle.borderMap[current] && el.currentStyle.borderStyle !== 'none') { current = ComputedStyle.borderMap[current]; } else { // otherwise no border (default is "medium") current = 0; } } return (omitUnit) ? parseFloat(current) : current; }, getPixel: function(node, att) { // use pixelRight to convert to px var val = null, style = _getStyleObj(node), styleRight = style.right, current = style[att]; node.style.right = current; val = node.style.pixelRight; node.style.right = styleRight; // revert return val; }, getMargin: function(node, att) { var val, style = _getStyleObj(node); if (style[att] == AUTO) { val = 0; } else { val = ComputedStyle.getPixel(node, att); } return val + PX; }, getVisibility: function(node, att) { var current; while ( (current = node.currentStyle) && current[att] == 'inherit') { // NOTE: assignment in test node = node.parentNode; } return (current) ? current[att] : VISIBLE; }, getColor: function(node, att) { var current = _getStyleObj(node)[att]; if (!current || current === TRANSPARENT) { Y.DOM.elementByAxis(node, 'parentNode', null, function(parent) { current = _getStyleObj(parent)[att]; if (current && current !== TRANSPARENT) { node = parent; return true; } }); } return Y.Color.toRGB(current); }, getBorderColor: function(node, att) { var current = _getStyleObj(node), val = current[att] || current.color; return Y.Color.toRGB(Y.Color.toHex(val)); } }, //fontSize: getPixelFont, IEComputed = {}; // use alpha filter for IE opacity try { if (documentElement.style[OPACITY] === UNDEFINED && documentElement[FILTERS]) { Y.DOM.CUSTOM_STYLES[OPACITY] = { get: function(node) { var val = 100; try { // will error if no DXImageTransform val = node[FILTERS]['DXImageTransform.Microsoft.Alpha'][OPACITY]; } catch(e) { try { // make sure its in the document val = node[FILTERS]('alpha')[OPACITY]; } catch(err) { } } return val / 100; }, set: function(node, val, style) { var current, styleObj; if (val === '') { // normalize inline style behavior styleObj = _getStyleObj(node); current = (OPACITY in styleObj) ? styleObj[OPACITY] : 1; // revert to original opacity val = current; } if (typeof style[FILTER] == 'string') { // in case not appended style[FILTER] = 'alpha(' + OPACITY + '=' + val * 100 + ')'; if (!node.currentStyle || !node.currentStyle[HAS_LAYOUT]) { style.zoom = 1; // needs layout } } } }; } } catch(e) { } try { document.createElement('div').style.height = '-1px'; } catch(e) { // IE throws error on invalid style set; trap common cases Y.DOM.CUSTOM_STYLES.height = { set: function(node, val, style) { var floatVal = parseFloat(val); if (isNaN(floatVal) || floatVal >= 0) { style.height = val; } else { } } }; Y.DOM.CUSTOM_STYLES.width = { set: function(node, val, style) { var floatVal = parseFloat(val); if (isNaN(floatVal) || floatVal >= 0) { style.width = val; } else { } } }; } // TODO: top, right, bottom, left IEComputed[WIDTH] = IEComputed[HEIGHT] = ComputedStyle.getOffset; IEComputed.color = IEComputed.backgroundColor = ComputedStyle.getColor; IEComputed[BORDER_WIDTH] = IEComputed[BORDER_TOP_WIDTH] = IEComputed[BORDER_RIGHT_WIDTH] = IEComputed[BORDER_BOTTOM_WIDTH] = IEComputed[BORDER_LEFT_WIDTH] = ComputedStyle.getBorderWidth; IEComputed.marginTop = IEComputed.marginRight = IEComputed.marginBottom = IEComputed.marginLeft = ComputedStyle.getMargin; IEComputed.visibility = ComputedStyle.getVisibility; IEComputed.borderColor = IEComputed.borderTopColor = IEComputed.borderRightColor = IEComputed.borderBottomColor = IEComputed.borderLeftColor = ComputedStyle.getBorderColor; if (!Y.config.win[GET_COMPUTED_STYLE]) { Y.DOM[GET_COMPUTED_STYLE] = ComputedStyle.get; } Y.namespace('DOM.IE'); Y.DOM.IE.COMPUTED = IEComputed; Y.DOM.IE.ComputedStyle = ComputedStyle; })(Y); Y.mix(Y.DOM, { /** * Sets the width of the element to the given size, regardless * of box model, border, padding, etc. * @method setWidth * @param {HTMLElement} element The DOM element. * @param {String|Int} size The pixel height to size to */ setWidth: function(node, size) { Y.DOM._setSize(node, 'width', size); }, /** * Sets the height of the element to the given size, regardless * of box model, border, padding, etc. * @method setHeight * @param {HTMLElement} element The DOM element. * @param {String|Int} size The pixel height to size to */ setHeight: function(node, size) { Y.DOM._setSize(node, 'height', size); }, _getOffsetProp: function(node, prop) { return 'offset' + prop.charAt(0).toUpperCase() + prop.substr(1); }, _setSize: function(node, prop, val) { var offset; Y.DOM.setStyle(node, prop, val + 'px'); offset = node[Y.DOM._getOffsetProp(node, prop)]; val = val - (offset - val); // TODO: handle size less than border/padding (add class?) if (val < 0) { val = 0; // no negative sizes } Y.DOM.setStyle(node, prop, val + 'px'); } }); }, '3.1.2' ,{requires:['dom-base']}); YUI.add('dom-screen', function(Y) { (function(Y) { /** * Adds position and region management functionality to DOM. * @module dom * @submodule dom-screen * @for DOM */ var DOCUMENT_ELEMENT = 'documentElement', COMPAT_MODE = 'compatMode', POSITION = 'position', FIXED = 'fixed', RELATIVE = 'relative', LEFT = 'left', TOP = 'top', _BACK_COMPAT = 'BackCompat', MEDIUM = 'medium', BORDER_LEFT_WIDTH = 'borderLeftWidth', BORDER_TOP_WIDTH = 'borderTopWidth', GET_BOUNDING_CLIENT_RECT = 'getBoundingClientRect', GET_COMPUTED_STYLE = 'getComputedStyle', Y_DOM = Y.DOM, // TODO: how about thead/tbody/tfoot/tr? // TODO: does caption matter? RE_TABLE = /^t(?:able|d|h)$/i; Y.mix(Y_DOM, { /** * Returns the inner height of the viewport (exludes scrollbar). * @method winHeight * @return {Number} The current height of the viewport. */ winHeight: function(node) { var h = Y_DOM._getWinSize(node).height; return h; }, /** * Returns the inner width of the viewport (exludes scrollbar). * @method winWidth * @return {Number} The current width of the viewport. */ winWidth: function(node) { var w = Y_DOM._getWinSize(node).width; return w; }, /** * Document height * @method docHeight * @return {Number} The current height of the document. */ docHeight: function(node) { var h = Y_DOM._getDocSize(node).height; return Math.max(h, Y_DOM._getWinSize(node).height); }, /** * Document width * @method docWidth * @return {Number} The current width of the document. */ docWidth: function(node) { var w = Y_DOM._getDocSize(node).width; return Math.max(w, Y_DOM._getWinSize(node).width); }, /** * Amount page has been scroll horizontally * @method docScrollX * @return {Number} The current amount the screen is scrolled horizontally. */ docScrollX: function(node, doc) { doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; // perf optimization var dv = doc.defaultView, pageOffset = (dv) ? dv.pageXOffset : 0; return Math.max(doc[DOCUMENT_ELEMENT].scrollLeft, doc.body.scrollLeft, pageOffset); }, /** * Amount page has been scroll vertically * @method docScrollY * @return {Number} The current amount the screen is scrolled vertically. */ docScrollY: function(node, doc) { doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; // perf optimization var dv = doc.defaultView, pageOffset = (dv) ? dv.pageYOffset : 0; return Math.max(doc[DOCUMENT_ELEMENT].scrollTop, doc.body.scrollTop, pageOffset); }, /** * Gets the current position of an element based on page coordinates. * Element must be part of the DOM tree to have page coordinates * (display:none or elements not appended return false). * @method getXY * @param element The target element * @return {Array} The XY position of the element TODO: test inDocument/display? */ getXY: function() { if (document[DOCUMENT_ELEMENT][GET_BOUNDING_CLIENT_RECT]) { return function(node) { var xy = null, scrollLeft, scrollTop, box, off1, off2, bLeft, bTop, mode, doc; if (node) { if (Y_DOM.inDoc(node)) { doc = node.ownerDocument; scrollLeft = Y_DOM.docScrollX(node, doc); scrollTop = Y_DOM.docScrollY(node, doc); box = node[GET_BOUNDING_CLIENT_RECT](); xy = [box.left, box.top]; if (Y.UA.ie) { off1 = 2; off2 = 2; mode = doc[COMPAT_MODE]; bLeft = Y_DOM[GET_COMPUTED_STYLE](doc[DOCUMENT_ELEMENT], BORDER_LEFT_WIDTH); bTop = Y_DOM[GET_COMPUTED_STYLE](doc[DOCUMENT_ELEMENT], BORDER_TOP_WIDTH); if (Y.UA.ie === 6) { if (mode !== _BACK_COMPAT) { off1 = 0; off2 = 0; } } if ((mode == _BACK_COMPAT)) { if (bLeft !== MEDIUM) { off1 = parseInt(bLeft, 10); } if (bTop !== MEDIUM) { off2 = parseInt(bTop, 10); } } xy[0] -= off1; xy[1] -= off2; } if ((scrollTop || scrollLeft)) { xy[0] += scrollLeft; xy[1] += scrollTop; } } else { // default to current offsets xy = Y_DOM._getOffset(node); } } return xy; }; } else { return function(node) { // manually calculate by crawling up offsetParents //Calculate the Top and Left border sizes (assumes pixels) var xy = null, doc, parentNode, bCheck, scrollTop, scrollLeft; if (node) { if (Y_DOM.inDoc(node)) { xy = [node.offsetLeft, node.offsetTop]; doc = node.ownerDocument; parentNode = node; // TODO: refactor with !! or just falsey bCheck = ((Y.UA.gecko || Y.UA.webkit > 519) ? true : false); // TODO: worth refactoring for TOP/LEFT only? while ((parentNode = parentNode.offsetParent)) { xy[0] += parentNode.offsetLeft; xy[1] += parentNode.offsetTop; if (bCheck) { xy = Y_DOM._calcBorders(parentNode, xy); } } // account for any scrolled ancestors if (Y_DOM.getStyle(node, POSITION) != FIXED) { parentNode = node; while ((parentNode = parentNode.parentNode)) { scrollTop = parentNode.scrollTop; scrollLeft = parentNode.scrollLeft; //Firefox does something funky with borders when overflow is not visible. if (Y.UA.gecko && (Y_DOM.getStyle(parentNode, 'overflow') !== 'visible')) { xy = Y_DOM._calcBorders(parentNode, xy); } if (scrollTop || scrollLeft) { xy[0] -= scrollLeft; xy[1] -= scrollTop; } } xy[0] += Y_DOM.docScrollX(node, doc); xy[1] += Y_DOM.docScrollY(node, doc); } else { //Fix FIXED position -- add scrollbars xy[0] += Y_DOM.docScrollX(node, doc); xy[1] += Y_DOM.docScrollY(node, doc); } } else { xy = Y_DOM._getOffset(node); } } return xy; }; } }(),// NOTE: Executing for loadtime branching _getOffset: function(node) { var pos, xy = null; if (node) { pos = Y_DOM.getStyle(node, POSITION); xy = [ parseInt(Y_DOM[GET_COMPUTED_STYLE](node, LEFT), 10), parseInt(Y_DOM[GET_COMPUTED_STYLE](node, TOP), 10) ]; if ( isNaN(xy[0]) ) { // in case of 'auto' xy[0] = parseInt(Y_DOM.getStyle(node, LEFT), 10); // try inline if ( isNaN(xy[0]) ) { // default to offset value xy[0] = (pos === RELATIVE) ? 0 : node.offsetLeft || 0; } } if ( isNaN(xy[1]) ) { // in case of 'auto' xy[1] = parseInt(Y_DOM.getStyle(node, TOP), 10); // try inline if ( isNaN(xy[1]) ) { // default to offset value xy[1] = (pos === RELATIVE) ? 0 : node.offsetTop || 0; } } } return xy; }, /** * Gets the current X position of an element based on page coordinates. * Element must be part of the DOM tree to have page coordinates * (display:none or elements not appended return false). * @method getX * @param element The target element * @return {Int} The X position of the element */ getX: function(node) { return Y_DOM.getXY(node)[0]; }, /** * Gets the current Y position of an element based on page coordinates. * Element must be part of the DOM tree to have page coordinates * (display:none or elements not appended return false). * @method getY * @param element The target element * @return {Int} The Y position of the element */ getY: function(node) { return Y_DOM.getXY(node)[1]; }, /** * Set the position of an html element in page coordinates. * The element must be part of the DOM tree to have page coordinates (display:none or elements not appended return false). * @method setXY * @param element The target element * @param {Array} xy Contains X & Y values for new position (coordinates are page-based) * @param {Boolean} noRetry By default we try and set the position a second time if the first fails */ setXY: function(node, xy, noRetry) { var setStyle = Y_DOM.setStyle, pos, delta, newXY, currentXY; if (node && xy) { pos = Y_DOM.getStyle(node, POSITION); delta = Y_DOM._getOffset(node); if (pos == 'static') { // default to relative pos = RELATIVE; setStyle(node, POSITION, pos); } currentXY = Y_DOM.getXY(node); if (xy[0] !== null) { setStyle(node, LEFT, xy[0] - currentXY[0] + delta[0] + 'px'); } if (xy[1] !== null) { setStyle(node, TOP, xy[1] - currentXY[1] + delta[1] + 'px'); } if (!noRetry) { newXY = Y_DOM.getXY(node); if (newXY[0] !== xy[0] || newXY[1] !== xy[1]) { Y_DOM.setXY(node, xy, true); } } } else { } }, /** * Set the X position of an html element in page coordinates, regardless of how the element is positioned. * The element(s) must be part of the DOM tree to have page coordinates (display:none or elements not appended return false). * @method setX * @param element The target element * @param {Int} x The X values for new position (coordinates are page-based) */ setX: function(node, x) { return Y_DOM.setXY(node, [x, null]); }, /** * Set the Y position of an html element in page coordinates, regardless of how the element is positioned. * The element(s) must be part of the DOM tree to have page coordinates (display:none or elements not appended return false). * @method setY * @param element The target element * @param {Int} y The Y values for new position (coordinates are page-based) */ setY: function(node, y) { return Y_DOM.setXY(node, [null, y]); }, /** * @method swapXY * @description Swap the xy position with another node * @param {Node} node The node to swap with * @param {Node} otherNode The other node to swap with * @return {Node} */ swapXY: function(node, otherNode) { var xy = Y_DOM.getXY(node); Y_DOM.setXY(node, Y_DOM.getXY(otherNode)); Y_DOM.setXY(otherNode, xy); }, _calcBorders: function(node, xy2) { var t = parseInt(Y_DOM[GET_COMPUTED_STYLE](node, BORDER_TOP_WIDTH), 10) || 0, l = parseInt(Y_DOM[GET_COMPUTED_STYLE](node, BORDER_LEFT_WIDTH), 10) || 0; if (Y.UA.gecko) { if (RE_TABLE.test(node.tagName)) { t = 0; l = 0; } } xy2[0] += l; xy2[1] += t; return xy2; }, _getWinSize: function(node, doc) { doc = doc || (node) ? Y_DOM._getDoc(node) : Y.config.doc; var win = doc.defaultView || doc.parentWindow, mode = doc[COMPAT_MODE], h = win.innerHeight, w = win.innerWidth, root = doc[DOCUMENT_ELEMENT]; if ( mode && !Y.UA.opera ) { // IE, Gecko if (mode != 'CSS1Compat') { // Quirks root = doc.body; } h = root.clientHeight; w = root.clientWidth; } return { height: h, width: w }; }, _getDocSize: function(node) { var doc = (node) ? Y_DOM._getDoc(node) : Y.config.doc, root = doc[DOCUMENT_ELEMENT]; if (doc[COMPAT_MODE] != 'CSS1Compat') { root = doc.body; } return { height: root.scrollHeight, width: root.scrollWidth }; } }); })(Y); (function(Y) { var TOP = 'top', RIGHT = 'right', BOTTOM = 'bottom', LEFT = 'left', getOffsets = function(r1, r2) { var t = Math.max(r1[TOP], r2[TOP]), r = Math.min(r1[RIGHT], r2[RIGHT]), b = Math.min(r1[BOTTOM], r2[BOTTOM]), l = Math.max(r1[LEFT], r2[LEFT]), ret = {}; ret[TOP] = t; ret[RIGHT] = r; ret[BOTTOM] = b; ret[LEFT] = l; return ret; }, DOM = Y.DOM; Y.mix(DOM, { /** * Returns an Object literal containing the following about this element: (top, right, bottom, left) * @method region * @param {HTMLElement} element The DOM element. @return {Object} Object literal containing the following about this element: (top, right, bottom, left) */ region: function(node) { var xy = DOM.getXY(node), ret = false; if (node && xy) { ret = DOM._getRegion( xy[1], // top xy[0] + node.offsetWidth, // right xy[1] + node.offsetHeight, // bottom xy[0] // left ); } return ret; }, /** * Find the intersect information for the passes nodes. * @method intersect * @param {HTMLElement} element The first element * @param {HTMLElement | Object} element2 The element or region to check the interect with * @param {Object} altRegion An object literal containing the region for the first element if we already have the data (for performance i.e. DragDrop) @return {Object} Object literal containing the following intersection data: (top, right, bottom, left, area, yoff, xoff, inRegion) */ intersect: function(node, node2, altRegion) { var r = altRegion || DOM.region(node), region = {}, n = node2, off; if (n.tagName) { region = DOM.region(n); } else if (Y.Lang.isObject(node2)) { region = node2; } else { return false; } off = getOffsets(region, r); return { top: off[TOP], right: off[RIGHT], bottom: off[BOTTOM], left: off[LEFT], area: ((off[BOTTOM] - off[TOP]) * (off[RIGHT] - off[LEFT])), yoff: ((off[BOTTOM] - off[TOP])), xoff: (off[RIGHT] - off[LEFT]), inRegion: DOM.inRegion(node, node2, false, altRegion) }; }, /** * Check if any part of this node is in the passed region * @method inRegion * @param {Object} node2 The node to get the region from or an Object literal of the region * $param {Boolean} all Should all of the node be inside the region * @param {Object} altRegion An object literal containing the region for this node if we already have the data (for performance i.e. DragDrop) * @return {Boolean} True if in region, false if not. */ inRegion: function(node, node2, all, altRegion) { var region = {}, r = altRegion || DOM.region(node), n = node2, off; if (n.tagName) { region = DOM.region(n); } else if (Y.Lang.isObject(node2)) { region = node2; } else { return false; } if (all) { return ( r[LEFT] >= region[LEFT] && r[RIGHT] <= region[RIGHT] && r[TOP] >= region[TOP] && r[BOTTOM] <= region[BOTTOM] ); } else { off = getOffsets(region, r); if (off[BOTTOM] >= off[TOP] && off[RIGHT] >= off[LEFT]) { return true; } else { return false; } } }, /** * Check if any part of this element is in the viewport * @method inViewportRegion * @param {HTMLElement} element The DOM element. * @param {Boolean} all Should all of the node be inside the region * @param {Object} altRegion An object literal containing the region for this node if we already have the data (for performance i.e. DragDrop) * @return {Boolean} True if in region, false if not. */ inViewportRegion: function(node, all, altRegion) { return DOM.inRegion(node, DOM.viewportRegion(node), all, altRegion); }, _getRegion: function(t, r, b, l) { var region = {}; region[TOP] = region[1] = t; region[LEFT] = region[0] = l; region[BOTTOM] = b; region[RIGHT] = r; region.width = region[RIGHT] - region[LEFT]; region.height = region[BOTTOM] - region[TOP]; return region; }, /** * Returns an Object literal containing the following about the visible region of viewport: (top, right, bottom, left) * @method viewportRegion @return {Object} Object literal containing the following about the visible region of the viewport: (top, right, bottom, left) */ viewportRegion: function(node) { node = node || Y.config.doc.documentElement; var ret = false, scrollX, scrollY; if (node) { scrollX = DOM.docScrollX(node); scrollY = DOM.docScrollY(node); ret = DOM._getRegion(scrollY, // top DOM.winWidth(node) + scrollX, // right scrollY + DOM.winHeight(node), // bottom scrollX); // left } return ret; } }); })(Y); }, '3.1.2' ,{requires:['dom-base', 'dom-style', 'event-base']}); YUI.add('selector-native', function(Y) { (function(Y) { /** * The selector-native module provides support for native querySelector * @module dom * @submodule selector-native * @for Selector */ /** * Provides support for using CSS selectors to query the DOM * @class Selector * @static * @for Selector */ Y.namespace('Selector'); // allow native module to standalone var COMPARE_DOCUMENT_POSITION = 'compareDocumentPosition', OWNER_DOCUMENT = 'ownerDocument'; var Selector = { _foundCache: [], useNative: true, _compare: ('sourceIndex' in document.documentElement) ? function(nodeA, nodeB) { var a = nodeA.sourceIndex, b = nodeB.sourceIndex; if (a === b) { return 0; } else if (a > b) { return 1; } return -1; } : (document.documentElement[COMPARE_DOCUMENT_POSITION] ? function(nodeA, nodeB) { if (nodeA[COMPARE_DOCUMENT_POSITION](nodeB) & 4) { return -1; } else { return 1; } } : function(nodeA, nodeB) { var rangeA, rangeB, compare; if (nodeA && nodeB) { rangeA = nodeA[OWNER_DOCUMENT].createRange(); rangeA.setStart(nodeA, 0); rangeB = nodeB[OWNER_DOCUMENT].createRange(); rangeB.setStart(nodeB, 0); compare = rangeA.compareBoundaryPoints(1, rangeB); // 1 === Range.START_TO_END } return compare; }), _sort: function(nodes) { if (nodes) { nodes = Y.Array(nodes, 0, true); if (nodes.sort) { nodes.sort(Selector._compare); } } return nodes; }, _deDupe: function(nodes) { var ret = [], i, node; for (i = 0; (node = nodes[i++]);) { if (!node._found) { ret[ret.length] = node; node._found = true; } } for (i = 0; (node = ret[i++]);) { node._found = null; node.removeAttribute('_found'); } return ret; }, /** * Retrieves a set of nodes based on a given CSS selector. * @method query * * @param {string} selector The CSS Selector to test the node against. * @param {HTMLElement} root optional An HTMLElement to start the query from. Defaults to Y.config.doc * @param {Boolean} firstOnly optional Whether or not to return only the first match. * @return {Array} An array of nodes that match the given selector. * @static */ query: function(selector, root, firstOnly, skipNative) { root = root || Y.config.doc; var ret = [], useNative = (Y.Selector.useNative && document.querySelector && !skipNative), queries = [[selector, root]], query, result, i, fn = (useNative) ? Y.Selector._nativeQuery : Y.Selector._bruteQuery; if (selector && fn) { // split group into seperate queries if (!skipNative && // already done if skipping (!useNative || root.tagName)) { // split native when element scoping is needed queries = Selector._splitQueries(selector, root); } for (i = 0; (query = queries[i++]);) { result = fn(query[0], query[1], firstOnly); if (!firstOnly) { // coerce DOM Collection to Array result = Y.Array(result, 0, true); } if (result) { ret = ret.concat(result); } } if (queries.length > 1) { // remove dupes and sort by doc order ret = Selector._sort(Selector._deDupe(ret)); } } return (firstOnly) ? (ret[0] || null) : ret; }, // allows element scoped queries to begin with combinator // e.g. query('> p', document.body) === query('body > p') _splitQueries: function(selector, node) { var groups = selector.split(','), queries = [], prefix = '', i, len; if (node) { // enforce for element scoping if (node.tagName) { node.id = node.id || Y.guid(); prefix = '[id="' + node.id + '"] '; } for (i = 0, len = groups.length; i < len; ++i) { selector = prefix + groups[i]; queries.push([selector, node]); } } return queries; }, _nativeQuery: function(selector, root, one) { try { return root['querySelector' + (one ? '' : 'All')](selector); } catch(e) { // fallback to brute if available return Y.Selector.query(selector, root, one, true); // redo with skipNative true } }, filter: function(nodes, selector) { var ret = [], i, node; if (nodes && selector) { for (i = 0; (node = nodes[i++]);) { if (Y.Selector.test(node, selector)) { ret[ret.length] = node; } } } else { } return ret; }, test: function(node, selector, root) { var ret = false, groups = selector.split(','), useFrag = false, parent, item, items, frag, i, j, group; if (node && node.tagName) { // only test HTMLElements // we need a root if off-doc if (!root && !Y.DOM.inDoc(node)) { parent = node.parentNode; if (parent) { root = parent; } else { // only use frag when no parent to query frag = node[OWNER_DOCUMENT].createDocumentFragment(); frag.appendChild(node); root = frag; useFrag = true; } } root = root || node[OWNER_DOCUMENT]; if (!node.id) { node.id = Y.guid(); } for (i = 0; (group = groups[i++]);) { // TODO: off-dom test group += '[id="' + node.id + '"]'; items = Y.Selector.query(group, root); for (j = 0; item = items[j++];) { if (item === node) { ret = true; break; } } if (ret) { break; } } if (useFrag) { // cleanup frag.removeChild(node); } } return ret; }, /** * A convenience function to emulate Y.Node's aNode.ancestor(selector). * @param {HTMLElement} element An HTMLElement to start the query from. * @param {String} selector The CSS selector to test the node against. * @return {HTMLElement} The ancestor node matching the selector, or null. * @param {Boolean} testSelf optional Whether or not to include the element in the scan * @static * @method ancestor */ ancestor: function (element, selector, testSelf) { return Y.DOM.ancestor(element, function(n) { return Y.Selector.test(n, selector); }, testSelf); } }; Y.mix(Y.Selector, Selector, true); })(Y); }, '3.1.2' ,{requires:['dom-base']}); YUI.add('selector-css2', function(Y) { /** * The selector module provides helper methods allowing CSS2 Selectors to be used with DOM elements. * @module dom * @submodule selector-css2 * @for Selector */ /** * Provides helper methods for collecting and filtering DOM elements. */ var PARENT_NODE = 'parentNode', TAG_NAME = 'tagName', ATTRIBUTES = 'attributes', COMBINATOR = 'combinator', PSEUDOS = 'pseudos', Selector = Y.Selector, SelectorCSS2 = { _reRegExpTokens: /([\^\$\?\[\]\*\+\-\.\(\)\|\\])/, // TODO: move? SORT_RESULTS: true, _children: function(node, tag) { var ret = node.children, i, children = [], childNodes, child; if (node.children && tag && node.children.tags) { children = node.children.tags(tag); } else if ((!ret && node[TAG_NAME]) || (ret && tag)) { // only HTMLElements have children childNodes = ret || node.childNodes; ret = []; for (i = 0; (child = childNodes[i++]);) { if (child.tagName) { if (!tag || tag === child.tagName) { ret.push(child); } } } } return ret || []; }, _re: { //attr: /(\[.*\])/g, attr: /(\[[^\]]*\])/g, pseudos: /:([\-\w]+(?:\(?:['"]?(.+)['"]?\)))*/i }, /** * Mapping of shorthand tokens to corresponding attribute selector * @property shorthand * @type object */ shorthand: { '\\#(-?[_a-z]+[-\\w]*)': '[id=$1]', '\\.(-?[_a-z]+[-\\w]*)': '[className~=$1]' }, /** * List of operators and corresponding boolean functions. * These functions are passed the attribute and the current node's value of the attribute. * @property operators * @type object */ operators: { '': function(node, attr) { return Y.DOM.getAttribute(node, attr) !== ''; }, // Just test for existence of attribute //'': '.+', //'=': '^{val}$', // equality '~=': '(?:^|\\s+){val}(?:\\s+|$)', // space-delimited '|=': '^{val}-?' // optional hyphen-delimited }, pseudos: { 'first-child': function(node) { return Y.Selector._children(node[PARENT_NODE])[0] === node; } }, _bruteQuery: function(selector, root, firstOnly) { var ret = [], nodes = [], tokens = Selector._tokenize(selector), token = tokens[tokens.length - 1], rootDoc = Y.DOM._getDoc(root), id, className, tagName; // if we have an initial ID, set to root when in document /* if (tokens[0] && rootDoc === root && (id = tokens[0].id) && rootDoc.getElementById(id)) { root = rootDoc.getElementById(id); } */ if (token) { // prefilter nodes id = token.id; className = token.className; tagName = token.tagName || '*'; // try ID first if (id) { nodes = Y.DOM.allById(id, root); // try className } else if (className) { nodes = root.getElementsByClassName(className); } else { // default to tagName nodes = root.getElementsByTagName(tagName); } if (nodes.length) { ret = Selector._filterNodes(nodes, tokens, firstOnly); } } return ret; }, _filterNodes: function(nodes, tokens, firstOnly) { var i = 0, j, len = tokens.length, n = len - 1, result = [], node = nodes[0], tmpNode = node, getters = Y.Selector.getters, operator, combinator, token, path, pass, //FUNCTION = 'function', value, tests, test; //do { for (i = 0; (tmpNode = node = nodes[i++]);) { n = len - 1; path = null; testLoop: while (tmpNode && tmpNode.tagName) { token = tokens[n]; tests = token.tests; j = tests.length; if (j && !pass) { while ((test = tests[--j])) { operator = test[1]; if (getters[test[0]]) { value = getters[test[0]](tmpNode, test[0]); } else { value = tmpNode[test[0]]; // use getAttribute for non-standard attributes if (value === undefined && tmpNode.getAttribute) { value = tmpNode.getAttribute(test[0]); } } if ((operator === '=' && value !== test[2]) || // fast path for equality (typeof operator !== 'string' && // protect against String.test monkey-patch (Moo) operator.test && !operator.test(value)) || // regex test (typeof operator === 'function' && !operator(tmpNode, test[0]))) { // function test // skip non element nodes or non-matching tags if ((tmpNode = tmpNode[path])) { while (tmpNode && (!tmpNode.tagName || (token.tagName && token.tagName !== tmpNode.tagName)) ) { tmpNode = tmpNode[path]; } } continue testLoop; } } } n--; // move to next token // now that we've passed the test, move up the tree by combinator if (!pass && (combinator = token.combinator)) { path = combinator.axis; tmpNode = tmpNode[path]; // skip non element nodes while (tmpNode && !tmpNode.tagName) { tmpNode = tmpNode[path]; } if (combinator.direct) { // one pass only path = null; } } else { // success if we made it this far result.push(node); if (firstOnly) { return result; } break; } } }// while (tmpNode = node = nodes[++i]); node = tmpNode = null; return result; }, combinators: { ' ': { axis: 'parentNode' }, '>': { axis: 'parentNode', direct: true }, '+': { axis: 'previousSibling', direct: true } }, _parsers: [ { name: ATTRIBUTES, re: /^\[(-?[a-z]+[\w\-]*)+([~\|\^\$\*!=]=?)?['"]?([^\]]*?)['"]?\]/i, fn: function(match, token) { var operator = match[2] || '', operators = Y.Selector.operators, test; // add prefiltering for ID and CLASS if ((match[1] === 'id' && operator === '=') || (match[1] === 'className' && document.documentElement.getElementsByClassName && (operator === '~=' || operator === '='))) { token.prefilter = match[1]; token[match[1]] = match[3]; } // add tests if (operator in operators) { test = operators[operator]; if (typeof test === 'string') { match[3] = match[3].replace(Y.Selector._reRegExpTokens, '\\$1'); test = Y.DOM._getRegExp(test.replace('{val}', match[3])); } match[2] = test; } if (!token.last || token.prefilter !== match[1]) { return match.slice(1); } } }, { name: TAG_NAME, re: /^((?:-?[_a-z]+[\w-]*)|\*)/i, fn: function(match, token) { var tag = match[1].toUpperCase(); token.tagName = tag; if (tag !== '*' && (!token.last || token.prefilter)) { return [TAG_NAME, '=', tag]; } if (!token.prefilter) { token.prefilter = 'tagName'; } } }, { name: COMBINATOR, re: /^\s*([>+~]|\s)\s*/, fn: function(match, token) { } }, { name: PSEUDOS, re: /^:([\-\w]+)(?:\(['"]?(.+)['"]?\))*/i, fn: function(match, token) { var test = Selector[PSEUDOS][match[1]]; if (test) { // reorder match array return [match[2], test]; } else { // selector token not supported (possibly missing CSS3 module) return false; } } } ], _getToken: function(token) { return { tagName: null, id: null, className: null, attributes: {}, combinator: null, tests: [] }; }, /** Break selector into token units per simple selector. Combinator is attached to the previous token. */ _tokenize: function(selector) { selector = selector || ''; selector = Selector._replaceShorthand(Y.Lang.trim(selector)); var token = Selector._getToken(), // one token per simple selector (left selector holds combinator) query = selector, // original query for debug report tokens = [], // array of tokens found = false, // whether or not any matches were found this pass match, // the regex match test, i, parser; /* Search for selector patterns, store, and strip them from the selector string until no patterns match (invalid selector) or we run out of chars. Multiple attributes and pseudos are allowed, in any order. for example: 'form:first-child[type=button]:not(button)[lang|=en]' */ outer: do { found = false; // reset after full pass for (i = 0; (parser = Selector._parsers[i++]);) { if ( (match = parser.re.exec(selector)) ) { // note assignment if (parser.name !== COMBINATOR ) { token.selector = selector; } selector = selector.replace(match[0], ''); // strip current match from selector if (!selector.length) { token.last = true; } if (Selector._attrFilters[match[1]]) { // convert class to className, etc. match[1] = Selector._attrFilters[match[1]]; } test = parser.fn(match, token); if (test === false) { // selector not supported found = false; break outer; } else if (test) { token.tests.push(test); } if (!selector.length || parser.name === COMBINATOR) { tokens.push(token); token = Selector._getToken(token); if (parser.name === COMBINATOR) { token.combinator = Y.Selector.combinators[match[1]]; } } found = true; } } } while (found && selector.length); if (!found || selector.length) { // not fully parsed tokens = []; } return tokens; }, _replaceShorthand: function(selector) { var shorthand = Selector.shorthand, attrs = selector.match(Selector._re.attr), // pull attributes to avoid false pos on "." and "#" pseudos = selector.match(Selector._re.pseudos), // pull attributes to avoid false pos on "." and "#" re, i, len; if (pseudos) { selector = selector.replace(Selector._re.pseudos, '!!REPLACED_PSEUDO!!'); } if (attrs) { selector = selector.replace(Selector._re.attr, '!!REPLACED_ATTRIBUTE!!'); } for (re in shorthand) { if (shorthand.hasOwnProperty(re)) { selector = selector.replace(Y.DOM._getRegExp(re, 'gi'), shorthand[re]); } } if (attrs) { for (i = 0, len = attrs.length; i < len; ++i) { selector = selector.replace('!!REPLACED_ATTRIBUTE!!', attrs[i]); } } if (pseudos) { for (i = 0, len = pseudos.length; i < len; ++i) { selector = selector.replace('!!REPLACED_PSEUDO!!', pseudos[i]); } } return selector; }, _attrFilters: { 'class': 'className', 'for': 'htmlFor' }, getters: { href: function(node, attr) { return Y.DOM.getAttribute(node, attr); } } }; Y.mix(Y.Selector, SelectorCSS2, true); Y.Selector.getters.src = Y.Selector.getters.rel = Y.Selector.getters.href; // IE wants class with native queries if (Y.Selector.useNative && document.querySelector) { Y.Selector.shorthand['\\.(-?[_a-z]+[-\\w]*)'] = '[class~=$1]'; } }, '3.1.2' ,{requires:['selector-native']}); YUI.add('selector', function(Y){}, '3.1.2' ,{use:['selector-native', 'selector-css2']}); YUI.add('dom', function(Y){}, '3.1.2' ,{use:['dom-base', 'dom-style', 'dom-screen', 'selector']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ 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. * * NOTE: Node properties are accessed using * the set and get methods. * * @class Node * @constructor * @param {DOMNode} node the DOM node to be mapped to the Node instance. * @for Node */ // "globals" var DOT = '.', NODE_NAME = 'nodeName', NODE_TYPE = 'nodeType', OWNER_DOCUMENT = 'ownerDocument', TAG_NAME = 'tagName', UID = '_yuid', Y_DOM = Y.DOM, Y_Node = function(node) { var uid = node[UID]; if (uid && Y_Node._instances[uid] && Y_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; /** * The underlying DOM node bound to the Y.Node instance * @property _node * @private */ this._node = node; Y_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(Y.one(n)); }; } return ret; }; // end "globals" /** * The name of the component * @static * @property NAME */ Y_Node.NAME = 'node'; /* * The pattern used to identify ARIA attributes */ Y_Node.re_aria = /^(?:role$|aria-)/; /** * List of events that route to DOM events * @static * @property DOM_EVENTS */ Y_Node.DOM_EVENTS = { abort: 1, beforeunload: 1, blur: 1, change: 1, changedTouches: 1, // iphone click: 1, close: 1, command: 1, contextmenu: 1, dblclick: 1, DOMMouseScroll: 1, drag: 1, dragstart: 1, dragenter: 1, dragover: 1, dragleave: 1, dragend: 1, drop: 1, error: 1, focus: 1, identifier: 1, // iphone key: 1, keydown: 1, keypress: 1, keyup: 1, load: 1, message: 1, mousedown: 1, mouseenter: 1, mouseleave: 1, mousemove: 1, mousemultiwheel: 1, mouseout: 1, mouseover: 1, mouseup: 1, mousewheel: 1, reset: 1, resize: 1, rotation: 1, // iphone scale: 1, // iphone select: 1, submit: 1, scroll: 1, targetTouches: 1, // iphone textInput: 1, touches: 1, // iphone unload: 1 }; // 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(Y_Node.DOM_EVENTS, Y.Env.evt.plugins); /** * A list of Node instances that have been created * @private * @property _instances * @static * */ Y_Node._instances = {}; /** * Retrieves the DOM node bound to a Node instance * @method 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. */ Y_Node.getDOMNode = function(node) { if (node) { return (node.nodeType) ? node : node._node || null; } return null; }; /** * Checks Node return values and wraps DOM Nodes as Y.Node instances * and DOM Collections / Arrays as Y.NodeList instances. * Other return values just pass thru. If undefined is returned (e.g. no return) * then the Node instance is returned for chainability. * @method scrubVal * @static * * @param {any} node The Node instance or an HTMLNode * @return {Y.Node | Y.NodeList | any} Depends on what is returned from the DOM node. */ Y_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 = Y.one(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; }; /** * Adds methods to the Y.Node prototype, routing through scrubVal. * @method addMethod * @static * * @param {String} name The name of the method to add * @param {Function} fn The function that becomes the method * @param {Object} context An optional context to call the method with * (defaults to the Node instance) * @return {any} Depends on what is returned from the DOM node. */ Y_Node.addMethod = function(name, fn, context) { if (name && fn && typeof fn === 'function') { Y_Node.prototype[name] = function() { context = context || this; var args = Y.Array(arguments, 0, true), ret; if (args[0] && args[0] instanceof Y_Node) { args[0] = args[0]._node; } if (args[1] && args[1] instanceof Y_Node) { args[1] = args[1]._node; } args.unshift(this._node); ret = Y_Node.scrubVal(fn.apply(context, args), this); return ret; }; } else { } }; /** * Imports utility methods to be added as Y.Node methods. * @method importMethod * @static * * @param {Object} host The object that contains the method to import. * @param {String} name The name of the method to import * @param {String} altName An optional name to use in place of the host name * @param {Object} context An optional context to call the method with */ Y_Node.importMethod = function(host, name, altName) { if (typeof name === 'string') { altName = altName || name; Y_Node.addMethod(altName, host[name], host); } else { Y.Array.each(name, function(n) { Y_Node.importMethod(host, n); }); } }; /** * Returns a single Node instance bound to the node or the * first element matching the given selector. Returns null if no match found. * Note: For chaining purposes you may want to * use Y.all, which returns a NodeList when no match is found. * @method Y.one * @static * @param {String | HTMLElement} node a node or Selector * @return {Y.Node | null} a Node instance or null if no match found. */ Y_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 Y_Node) { return node; // NOTE: return } uid = node._yuid; instance = Y_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 Y_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. */ Y_Node.get = function() { return Y_Node.one.apply(Y_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 */ Y_Node.create = function() { return Y.one(Y_DOM.create.apply(Y_DOM, arguments)); }; /** * Static collection of configuration attributes for special handling * @property ATTRS * @static * @type object */ Y_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; } }, /* * Flat data store for off-DOM usage * @config data * @type any * @deprecated Use getData/setData */ data: { getter: function() { return this._dataVal; }, setter: function(val) { this._dataVal = val; return val; }, value: null } }; /** * The default setter for DOM properties * Called with instance context (this === the Node instance) * @method DEFAULT_SETTER * @static * @param {String} name The attribute/property being set * @param {any} val The value to be set * @return {any} The value */ Y_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; }; /** * The default getter for DOM properties * Called with instance context (this === the Node instance) * @method DEFAULT_GETTER * @static * @param {String} name The attribute/property to look up * @return {any} The current value */ Y_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(Y_Node, Y.Event.Target); Y.mix(Y_Node.prototype, { /** * The method called when outputting Node instances as strings * @method toString * @return {String} A string representation of the Node instance */ toString: function() { var str = '', errorMsg = this[UID] + ': not bound to a node', node = this._node, id = node.getAttribute('id'); // form.id may be a field name if (node) { str += node[NODE_NAME]; if (id) { str += '#' + id; } if (node.className) { str += '.' + node.className.replace(' ', '.'); } // TODO: add yuid? str += ' ' + this[UID]; } return str || errorMsg; }, /** * Returns an attribute value on the Node instance. * Unless pre-configured (via Node.ATTRS), get hands * off to the underlying DOM node. Only valid * attributes/properties for the node will be set. * @method get * @param {String} attr The attribute * @return {any} The current value of the attribute */ get: function(attr) { var val; if (this._getAttr) { // use Attribute imple val = this._getAttr(attr); } else { val = this._get(attr); } if (val) { val = Y_Node.scrubVal(val, this); } return val; }, /** * Helper method for get. * @method _get * @private * @param {String} attr The attribute * @return {any} The current value of the attribute */ _get: function(attr) { var attrConfig = Y_Node.ATTRS[attr], val; if (attrConfig && attrConfig.getter) { val = attrConfig.getter.call(this); } else if (Y_Node.re_aria.test(attr)) { val = this._node.getAttribute(attr, 2); } else { val = Y_Node.DEFAULT_GETTER.apply(this, arguments); } return val; }, /** * Sets an attribute on the Node instance. * Unless pre-configured (via Node.ATTRS), set hands * off to the underlying DOM node. Only valid * attributes/properties for the node will be set. * To set custom attributes use setAttribute. * @method set * @param {String} attr The attribute to be set. * @param {any} val The value to set the attribute to. * @chainable */ set: function(attr, val) { var attrConfig = Y_Node.ATTRS[attr]; if (this._setAttr) { // use Attribute imple this._setAttr.apply(this, arguments); } else { // use setters inline if (attrConfig && attrConfig.setter) { attrConfig.setter.call(this, val); } else if (Y_Node.re_aria.test(attr)) { // special case Aria this._node.setAttribute(attr, val); } else { Y_Node.DEFAULT_SETTER.apply(this, arguments); } } return this; }, /** * Sets multiple attributes. * @method setAttrs * @param {Object} attrMap an object of name/value pairs to set * @chainable */ setAttrs: function(attrMap) { if (this._setAttrs) { // use Attribute imple this._setAttrs(attrMap); } else { // use setters inline Y.Object.each(attrMap, function(v, n) { this.set(n, v); }, this); } return this; }, /** * Returns an object containing the values for the requested attributes. * @method getAttrs * @param {Array} attrs an array of attributes to get values * @return {Object} An object with attribute name/value pairs. */ getAttrs: function(attrs) { var ret = {}; if (this._getAttrs) { // use Attribute imple this._getAttrs(attrs); } else { // use setters inline Y.Array.each(attrs, function(v, n) { ret[v] = this.get(v); }, this); } return ret; }, /** * Creates a new Node using the provided markup string. * @method create * @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 */ create: Y_Node.create, /** * Compares nodes to determine if they match. * Node instances can be compared to each other and/or HTMLElements. * @method compareTo * @param {HTMLElement | Node} refNode The reference node to compare to the node. * @return {Boolean} True if the nodes match, false if they do not. */ compareTo: function(refNode) { var node = this._node; if (refNode instanceof Y_Node) { refNode = refNode._node; } return node === refNode; }, /** * Determines whether the node is appended to the document. * @method inDoc * @param {Node|HTMLElement} doc optional An optional document to check against. * Defaults to current document. * @return {Boolean} Whether or not this node is appended to the document. */ inDoc: function(doc) { var node = this._node; doc = (doc) ? doc._node || doc : node[OWNER_DOCUMENT]; if (doc.documentElement) { return Y_DOM.contains(doc.documentElement, node); } }, getById: function(id) { var node = this._node, ret = Y_DOM.byId(id, node[OWNER_DOCUMENT]); if (ret && Y_DOM.contains(node, ret)) { ret = Y.one(ret); } else { ret = null; } return ret; }, /** * Returns the nearest ancestor that passes the test applied by supplied boolean method. * @method ancestor * @param {String | Function} fn A selector string or boolean method for testing elements. * @param {Boolean} testSelf optional Whether or not to include the element in the scan * If a function is used, it receives the current node being tested as the only argument. * @return {Node} The matching Node instance or null if not found */ ancestor: function(fn, testSelf) { return Y.one(Y_DOM.ancestor(this._node, _wrapFn(fn), testSelf)); }, /** * Returns the previous matching sibling. * Returns the nearest element node sibling if no method provided. * @method previous * @param {String | Function} fn A selector or boolean method for testing elements. * If a function is used, it receives the current node being tested as the only argument. * @return {Node} Node instance or null if not found */ previous: function(fn, all) { return Y.one(Y_DOM.elementByAxis(this._node, 'previousSibling', _wrapFn(fn), all)); }, /** * Returns the next matching sibling. * Returns the nearest element node sibling if no method provided. * @method next * @param {String | Function} fn A selector or boolean method for testing elements. * If a function is used, it receives the current node being tested as the only argument. * @return {Node} Node instance or null if not found */ next: function(fn, all) { return Y.one(Y_DOM.elementByAxis(this._node, 'nextSibling', _wrapFn(fn), all)); }, /** * Returns all matching siblings. * Returns all siblings if no method provided. * @method siblings * @param {String | Function} fn A selector or boolean method for testing elements. * If a function is used, it receives the current node being tested as the only argument. * @return {NodeList} NodeList instance bound to found siblings */ siblings: function(fn) { return Y.all(Y_DOM.siblings(this._node, _wrapFn(fn))); }, /** * Retrieves a Node instance of nodes based on the given CSS selector. * @method one * * @param {string} selector The CSS selector to test against. * @return {Node} A Node instance for the matching HTMLElement. */ one: function(selector) { return Y.one(Y.Selector.query(selector, this._node, true)); }, /** * Retrieves a Node instance of nodes based on the given CSS selector. * @method query * @deprecated Use one() * @param {string} selector The CSS selector to test against. * @return {Node} A Node instance for the matching HTMLElement. */ query: function(selector) { return this.one(selector); }, /** * Retrieves a nodeList based on the given CSS selector. * @method all * * @param {string} selector The CSS selector to test against. * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array. */ all: function(selector) { var nodelist = Y.all(Y.Selector.query(selector, this._node)); nodelist._query = selector; nodelist._queryRoot = this._node; return nodelist; }, /** * Retrieves a nodeList based on the given CSS selector. * @method queryAll * @deprecated Use all() * @param {string} selector The CSS selector to test against. * @return {NodeList} A NodeList instance for the matching HTMLCollection/Array. */ queryAll: function(selector) { return this.all(selector); }, // TODO: allow fn test /** * Test if the supplied node matches the supplied selector. * @method test * * @param {string} selector The CSS selector to test against. * @return {boolean} Whether or not the node matches the selector. */ test: function(selector) { return Y.Selector.test(this._node, selector); }, /** * Removes the node from its parent. * Shortcut for myNode.get('parentNode').removeChild(myNode); * @method remove * @chainable * */ remove: function(destroy) { var node = this._node, parentNode = node.parentNode; if (parentNode) { parentNode.removeChild(node); } if (destroy) { this.destroy(true); } return this; }, /** * Replace the node with the other node. This is a DOM update only * and does not change the node bound to the Node instance. * Shortcut for myNode.get('parentNode').replaceChild(newNode, myNode); * @method replace * @param {Y.Node || HTMLNode} newNode Node to be inserted * @chainable * */ replace: function(newNode) { var node = this._node; node.parentNode.replaceChild(Y_Node.getDOMNode(newNode), node); return this; }, /** * Removes event listeners from the node and (optionally) its subtree * @method purge * @param {Boolean} recurse (optional) Whether or not to remove listeners from the * node's subtree * @param {String} type (optional) Only remove listeners of the specified type * @chainable * */ purge: function(recurse, type) { Y.Event.purgeElement(this._node, recurse, type); return this; }, /** * Nulls internal node references, removes any plugins and event listeners * @method destroy * @param {Boolean} recursivePurge (optional) Whether or not to remove listeners from the * node's subtree (default is false) * */ destroy: function(recursivePurge) { delete Y_Node._instances[this[UID]]; this.purge(recursivePurge); if (this.unplug) { // may not be a PluginHost this.unplug(); } this._node._yuid = null; this._node = null; this._stateProxy = null; }, /** * Invokes a method on the Node instance * @method invoke * @param {String} method The name of the method to invoke * @param {Any} a, b, c, etc. Arguments to invoke the method with. * @return Whatever the underly method returns. * DOM Nodes and Collections return values * are converted to Node/NodeList instances. * */ invoke: function(method, a, b, c, d, e) { var node = this._node, ret; if (a && a instanceof Y_Node) { a = a._node; } if (b && b instanceof Y_Node) { b = b._node; } ret = node[method](a, b, c, d, e); return Y_Node.scrubVal(ret, this); }, /** * Applies the given function to each Node in the NodeList. * @method each * @deprecated Use NodeList * @param {Function} fn The function to apply * @param {Object} context optional An optional context to apply the function with * Default context is the NodeList instance * @chainable */ each: function(fn, context) { context = context || this; return fn.call(context, this); }, /** * Retrieves the Node instance at the given index. * @method item * @deprecated Use NodeList * * @param {Number} index The index of the target Node. * @return {Node} The Node instance at the given index. */ item: function(index) { return this; }, /** * Returns the current number of items in the Node. * @method size * @deprecated Use NodeList * @return {Int} The number of items in the Node. */ size: function() { return this._node ? 1 : 0; }, /** * Inserts the content before the reference node. * @method insert * @param {String | Y.Node | HTMLElement} content The content to insert * @param {Int | Y.Node | HTMLElement | String} where The position to insert at. * @chainable */ insert: function(content, where) { var node = this._node; if (content) { if (typeof where === 'number') { // allow index where = this._node.childNodes[where]; } else if (where && where._node) { // Node where = where._node; } if (typeof content !== 'string') { // allow Node or NodeList/Array instances if (content._node) { // Node content = content._node; } else if (content._nodes || (!content.nodeType && content.length)) { // NodeList or Array content = Y.all(content); Y.each(content._nodes, function(n) { Y_DOM.addHTML(node, n, where); }); return this; // NOTE: early return } } Y_DOM.addHTML(node, content, where); } else { } return this; }, /** * Inserts the content as the firstChild of the node. * @method prepend * @param {String | Y.Node | HTMLElement} content The content to insert * @chainable */ prepend: function(content) { return this.insert(content, 0); }, /** * Inserts the content as the lastChild of the node. * @method append * @param {String | Y.Node | HTMLElement} content The content to insert * @chainable */ append: function(content) { return this.insert(content, null); }, /** * Replaces the node's current content with the content. * @method setContent * @param {String | Y.Node | HTMLElement} content The content to insert * @chainable */ setContent: function(content) { if (content) { if (content._node) { // map to DOMNode content = content._node; } else if (content._nodes) { // convert DOMNodeList to documentFragment content = Y_DOM._nl2Frag(content._nodes); } } Y_DOM.addHTML(this._node, content, 'replace'); return this; }, /** * @method swap * @description Swap DOM locations with the given node. * This does not change which DOM node each Node instance refers to. * @param {Node} otherNode The node to swap with * @chainable */ swap: document.documentElement.swapNode ? function(otherNode) { this._node.swapNode(Y_Node.getDOMNode(otherNode)); } : function(otherNode) { otherNode = Y_Node.getDOMNode(otherNode); var node = this._node, parent = otherNode.parentNode, nextSibling = otherNode.nextSibling; if (nextSibling === node) { parent.insertBefore(node, otherNode); } else if (otherNode === node.nextSibling) { parent.insertBefore(otherNode, node); } else { node.parentNode.replaceChild(otherNode, node); Y_DOM.addHTML(parent, node, nextSibling); } return this; }, /** * @method getData * @description Retrieves arbitrary data stored on a Node instance. * This is not stored with the DOM node. * @param {string} name Optional name of the data field to retrieve. * If no name is given, all data is returned. * @return {any | Object} Whatever is stored at the given field, * or an object hash of all fields. */ getData: function(name) { var ret; this._data = this._data || {}; if (arguments.length) { ret = this._data[name]; } else { ret = this._data; } return ret; }, /** * @method setData * @description Stores arbitrary data on a Node instance. * This is not stored with the DOM node. * @param {string} name The name of the field to set. If no name * is given, name is treated as the data and overrides any existing data. * @param {any} val The value to be assigned to the field. * @chainable */ setData: function(name, val) { this._data = this._data || {}; if (arguments.length > 1) { this._data[name] = val; } else { this._data = name; } return this; }, /** * @method clearData * @description Clears stored data. * @param {string} name The name of the field to clear. If no name * is given, all data is cleared.. * @chainable */ clearData: function(name) { if (arguments.length) { delete this._data[name]; } else { this._data = {}; } return this; }, hasMethod: function(method) { var node = this._node; return (node && node[method] && (typeof node[method] === 'function')); } }, true); Y.Node = Y_Node; Y.get = Y.Node.get; Y.one = Y.Node.one; /** * The NodeList module provides support for managing collections of Nodes. * @module node * @submodule nodelist */ /** * The NodeList class provides a wrapper for manipulating DOM NodeLists. * NodeList properties can be accessed via the set/get methods. * Use Y.all() to retrieve NodeList instances. * * @class NodeList * @constructor */ var NodeList = function(nodes) { var tmp = []; if (typeof nodes === 'string') { // selector query this._query = nodes; nodes = Y.Selector.query(nodes); } else if (nodes.nodeType) { // domNode nodes = [nodes]; } else if (nodes instanceof Y.Node) { nodes = [nodes._node]; } else if (nodes[0] instanceof Y.Node) { // allow array of Y.Nodes Y.Array.each(nodes, function(node) { if (node._node) { tmp.push(node._node); } }); nodes = tmp; } else { // array of domNodes or domNodeList (no mixed array of Y.Node/domNodes) nodes = Y.Array(nodes, 0, true); } NodeList._instances[Y.stamp(this)] = this; /** * The underlying array of DOM nodes bound to the Y.NodeList instance * @property _nodes * @private */ this._nodes = nodes; }; NodeList.NAME = 'NodeList'; /** * Retrieves the DOM nodes bound to a NodeList instance * @method NodeList.getDOMNodes * @static * * @param {Y.NodeList} node The NodeList instance * @return {Array} The array of DOM nodes bound to the NodeList */ NodeList.getDOMNodes = function(nodeList) { return nodeList._nodes; }; NodeList._instances = []; NodeList.each = function(instance, fn, context) { var nodes = instance._nodes; if (nodes && nodes.length) { Y.Array.each(nodes, fn, context || instance); } else { } }; NodeList.addMethod = function(name, fn, context) { if (name && fn) { NodeList.prototype[name] = function() { var ret = [], args = arguments; Y.Array.each(this._nodes, function(node) { var UID = '_yuid', instance = Y.Node._instances[node[UID]], ctx, result; if (!instance) { instance = NodeList._getTempNode(node); } ctx = context || instance; result = fn.apply(ctx, args); if (result !== undefined && result !== instance) { ret[ret.length] = result; } }); // TODO: remove tmp pointer return ret.length ? ret : this; }; } else { } }; NodeList.importMethod = function(host, name, altName) { if (typeof name === 'string') { altName = altName || name; NodeList.addMethod(name, host[name]); } else { Y.Array.each(name, function(n) { NodeList.importMethod(host, n); }); } }; NodeList._getTempNode = function(node) { var tmp = NodeList._tempNode; if (!tmp) { tmp = Y.Node.create('
'); NodeList._tempNode = tmp; } tmp._node = node; tmp._stateProxy = node; return tmp; }; Y.mix(NodeList.prototype, { /** * Retrieves the Node instance at the given index. * @method item * * @param {Number} index The index of the target Node. * @return {Node} The Node instance at the given index. */ item: function(index) { return Y.one((this._nodes || [])[index]); }, /** * Applies the given function to each Node in the NodeList. * @method each * @param {Function} fn The function to apply. It receives 3 arguments: * the current node instance, the node's index, and the NodeList instance * @param {Object} context optional An optional context to apply the function with * Default context is the current Node instance * @chainable */ each: function(fn, context) { var instance = this; Y.Array.each(this._nodes, function(node, index) { node = Y.one(node); return fn.call(context || node, node, index, instance); }); return instance; }, batch: function(fn, context) { var nodelist = this; Y.Array.each(this._nodes, function(node, index) { var instance = Y.Node._instances[node[UID]]; if (!instance) { instance = NodeList._getTempNode(node); } return fn.call(context || instance, instance, index, nodelist); }); return nodelist; }, /** * Executes the function once for each node until a true value is returned. * @method some * @param {Function} fn The function to apply. It receives 3 arguments: * the current node instance, the node's index, and the NodeList instance * @param {Object} context optional An optional context to execute the function from. * Default context is the current Node instance * @return {Boolean} Whether or not the function returned true for any node. */ some: function(fn, context) { var instance = this; return Y.Array.some(this._nodes, function(node, index) { node = Y.one(node); context = context || node; return fn.call(context, node, index, instance); }); }, /** * Creates a documenFragment from the nodes bound to the NodeList instance * @method toFrag * @return Node a Node instance bound to the documentFragment */ toFrag: function() { return Y.one(Y.DOM._nl2frag(this._nodes)); }, /** * Returns the index of the node in the NodeList instance * or -1 if the node isn't found. * @method indexOf * @param {Y.Node || DOMNode} node the node to search for * @return {Int} the index of the node value or -1 if not found */ indexOf: function(node) { return Y.Array.indexOf(this._nodes, Y.Node.getDOMNode(node)); }, /** * Filters the NodeList instance down to only nodes matching the given selector. * @method filter * @param {String} selector The selector to filter against * @return {NodeList} NodeList containing the updated collection * @see Selector */ filter: function(selector) { return Y.all(Y.Selector.filter(this._nodes, selector)); }, /** * Creates a new NodeList containing all nodes at every n indices, where * remainder n % index equals r. * (zero-based index). * @method modulus * @param {Int} n The offset to use (return every nth node) * @param {Int} r An optional remainder to use with the modulus operation (defaults to zero) * @return {NodeList} NodeList containing the updated collection */ modulus: function(n, r) { r = r || 0; var nodes = []; NodeList.each(this, function(node, i) { if (i % n === r) { nodes.push(node); } }); return Y.all(nodes); }, /** * Creates a new NodeList containing all nodes at odd indices * (zero-based index). * @method odd * @return {NodeList} NodeList containing the updated collection */ odd: function() { return this.modulus(2, 1); }, /** * Creates a new NodeList containing all nodes at even indices * (zero-based index), including zero. * @method even * @return {NodeList} NodeList containing the updated collection */ even: function() { return this.modulus(2); }, destructor: function() { delete NodeList._instances[this[UID]]; }, /** * Reruns the initial query, when created using a selector query * @method refresh * @chainable */ refresh: function() { var doc, nodes = this._nodes, query = this._query, root = this._queryRoot; if (query) { if (!root) { if (nodes && nodes[0] && nodes[0].ownerDocument) { root = nodes[0].ownerDocument; } } this._nodes = Y.Selector.query(query, root); } return this; }, /** * Applies an event listener to each Node bound to the NodeList. * @method on * @param {String} type The event being listened for * @param {Function} fn The handler to call when the event fires * @param {Object} context The context to call the handler with. * Default is the NodeList instance. * @return {Object} Returns an event handle that can later be use to detach(). * @see Event.on */ on: function(type, fn, context) { var args = Y.Array(arguments, 0, true); args.splice(2, 0, this._nodes); args[3] = context || this; return Y.on.apply(Y, args); }, /** * Applies an event listener to each Node bound to the NodeList. * The handler is called only after all on() handlers are called * and the event is not prevented. * @method after * @param {String} type The event being listened for * @param {Function} fn The handler to call when the event fires * @param {Object} context The context to call the handler with. * Default is the NodeList instance. * @return {Object} Returns an event handle that can later be use to detach(). * @see Event.on */ after: function(type, fn, context) { var args = Y.Array(arguments, 0, true); args.splice(2, 0, this._nodes); args[3] = context || this; return Y.after.apply(Y, args); }, /** * Returns the current number of items in the NodeList. * @method size * @return {Int} The number of items in the NodeList. */ size: function() { return this._nodes.length; }, /** * Determines if the instance is bound to any nodes * @method isEmpty * @return {Boolean} Whether or not the NodeList is bound to any nodes */ isEmpty: function() { return this._nodes.length < 1; }, toString: function() { var str = '', errorMsg = this[UID] + ': not bound to any nodes', nodes = this._nodes, node; if (nodes && nodes[0]) { node = nodes[0]; str += node[NODE_NAME]; if (node.id) { str += '#' + node.id; } if (node.className) { str += '.' + node.className.replace(' ', '.'); } if (nodes.length > 1) { str += '...[' + nodes.length + ' items]'; } } return str || errorMsg; } }, true); NodeList.importMethod(Y.Node.prototype, [ /** * Called on each Node instance * @for NodeList * @method append * @see Node.append */ 'append', /** * Called on each Node instance * @method detach * @see Node.detach */ 'detach', /** Called on each Node instance * @method detachAll * @see Node.detachAll */ 'detachAll', /** Called on each Node instance * @method insert * @see NodeInsert */ 'insert', /** Called on each Node instance * @method prepend * @see Node.prepend */ 'prepend', /** Called on each Node instance * @method remove * @see Node.remove */ 'remove', /** Called on each Node instance * @method removeAttribute * @see Node.removeAttribute */ 'removeAttribute', /** Called on each Node instance * @method set * @see Node.set */ 'set', /** Called on each Node instance * @method setContent * @see Node.setContent */ 'setContent' ]); // one-off implementation to convert array of Nodes to NodeList // e.g. Y.all('input').get('parentNode'); /** Called on each Node instance * @method get * @see Node */ NodeList.prototype.get = function(attr) { var ret = [], nodes = this._nodes, isNodeList = false, getTemp = NodeList._getTempNode, instance, val; if (nodes[0]) { instance = Y.Node._instances[nodes[0]._yuid] || getTemp(nodes[0]); val = instance._get(attr); if (val && val.nodeType) { isNodeList = true; } } Y.Array.each(nodes, function(node) { instance = Y.Node._instances[node._yuid]; if (!instance) { instance = getTemp(node); } val = instance._get(attr); if (!isNodeList) { // convert array of Nodes to NodeList val = Y.Node.scrubVal(val, instance); } ret.push(val); }); return (isNodeList) ? Y.all(ret) : ret; }; Y.NodeList = NodeList; Y.all = function(nodes) { return new NodeList(nodes); }; Y.Node.all = Y.all; Y.Array.each([ /** * Passes through to DOM method. * @method replaceChild * @for Node * @param {HTMLElement | Node} node Node to be inserted * @param {HTMLElement | Node} refNode Node to be replaced * @return {Node} The replaced node */ 'replaceChild', /** * Passes through to DOM method. * @method appendChild * @param {HTMLElement | Node} node Node to be appended * @return {Node} The appended node */ 'appendChild', /** * Passes through to DOM method. * @method insertBefore * @param {HTMLElement | Node} newNode Node to be appended * @param {HTMLElement | Node} refNode Node to be inserted before * @return {Node} The inserted node */ 'insertBefore', /** * Passes through to DOM method. * @method removeChild * @param {HTMLElement | Node} node Node to be removed * @return {Node} The removed node */ 'removeChild', /** * Passes through to DOM method. * @method hasChildNodes * @return {Boolean} Whether or not the node has any childNodes */ 'hasChildNodes', /** * Passes through to DOM method. * @method cloneNode * @param {Boolean} deep Whether or not to perform a deep clone, which includes * subtree and attributes * @return {Node} The clone */ 'cloneNode', /** * Passes through to DOM method. * @method hasAttribute * @param {String} attribute The attribute to test for * @return {Boolean} Whether or not the attribute is present */ 'hasAttribute', /** * Passes through to DOM method. * @method removeAttribute * @param {String} attribute The attribute to be removed * @chainable */ 'removeAttribute', /** * Passes through to DOM method. * @method scrollIntoView * @chainable */ 'scrollIntoView', /** * Passes through to DOM method. * @method getElementsByTagName * @param {String} tagName The tagName to collect * @return {NodeList} A NodeList representing the HTMLCollection */ 'getElementsByTagName', /** * Passes through to DOM method. * @method focus * @chainable */ 'focus', /** * Passes through to DOM method. * @method blur * @chainable */ 'blur', /** * Passes through to DOM method. * Only valid on FORM elements * @method submit * @chainable */ 'submit', /** * Passes through to DOM method. * Only valid on FORM elements * @method reset * @chainable */ 'reset', /** * Passes through to DOM method. * @method select * @chainable */ 'select' ], function(method) { Y.Node.prototype[method] = function(arg1, arg2, arg3) { var ret = this.invoke(method, arg1, arg2, arg3); return ret; }; }); Y.Node.importMethod(Y.DOM, [ /** * Determines whether the node is an ancestor of another HTML element in the DOM hierarchy. * @method contains * @param {Node | HTMLElement} needle The possible node or descendent * @return {Boolean} Whether or not this node is the needle its ancestor */ 'contains', /** * Allows setting attributes on DOM nodes, normalizing in some cases. * This passes through to the DOM node, allowing for custom attributes. * @method setAttribute * @for Node * @for NodeList * @chainable * @param {string} name The attribute name * @param {string} value The value to set */ 'setAttribute', /** * Allows getting attributes on DOM nodes, normalizing in some cases. * This passes through to the DOM node, allowing for custom attributes. * @method getAttribute * @for Node * @for NodeList * @param {string} name The attribute name * @return {string} The attribute value */ 'getAttribute' ]); /** * Allows setting attributes on DOM nodes, normalizing in some cases. * This passes through to the DOM node, allowing for custom attributes. * @method setAttribute * @see Node * @for NodeList * @chainable * @param {string} name The attribute name * @param {string} value The value to set */ /** * Allows getting attributes on DOM nodes, normalizing in some cases. * This passes through to the DOM node, allowing for custom attributes. * @method getAttribute * @see Node * @for NodeList * @param {string} name The attribute name * @return {string} The attribute value */ Y.NodeList.importMethod(Y.Node.prototype, ['getAttribute', 'setAttribute', 'removeAttribute']); (function(Y) { var methods = [ /** * Determines whether each node has the given className. * @method hasClass * @for Node * @param {String} className the class name to search for * @return {Array} An array of booleans for each node bound to the NodeList. */ 'hasClass', /** * Adds a class name to each node. * @method addClass * @param {String} className the class name to add to the node's class attribute * @chainable */ 'addClass', /** * Removes a class name from each node. * @method removeClass * @param {String} className the class name to remove from the node's class attribute * @chainable */ 'removeClass', /** * Replace a class with another class for each node. * If no oldClassName is present, the newClassName is simply added. * @method replaceClass * @param {String} oldClassName the class name to be replaced * @param {String} newClassName the class name that will be replacing the old class name * @chainable */ 'replaceClass', /** * If the className exists on the node it is removed, if it doesn't exist it is added. * @method toggleClass * @param {String} className the class name to be toggled * @chainable */ 'toggleClass' ]; Y.Node.importMethod(Y.DOM, methods); /** * Determines whether each node has the given className. * @method hasClass * @see Node.hasClass * @for NodeList * @param {String} className the class name to search for * @return {Array} An array of booleans for each node bound to the NodeList. */ /** * Adds a class name to each node. * @method addClass * @see Node.addClass * @param {String} className the class name to add to the node's class attribute * @chainable */ /** * Removes a class name from each node. * @method removeClass * @see Node.removeClass * @param {String} className the class name to remove from the node's class attribute * @chainable */ /** * Replace a class with another class for each node. * If no oldClassName is present, the newClassName is simply added. * @method replaceClass * @see Node.replaceClass * @param {String} oldClassName the class name to be replaced * @param {String} newClassName the class name that will be replacing the old class name * @chainable */ /** * If the className exists on the node it is removed, if it doesn't exist it is added. * @method toggleClass * @see Node.toggleClass * @param {String} className the class name to be toggled * @chainable */ Y.NodeList.importMethod(Y.Node.prototype, methods); })(Y); if (!document.documentElement.hasAttribute) { // IE < 8 Y.Node.prototype.hasAttribute = function(attr) { return !!(this._node.attributes[attr] && this._node.attributes[attr].specified); }; } // IE throws error when setting input.type = 'hidden', // input.setAttribute('type', 'hidden') and input.attributes.type.value = 'hidden' Y.Node.ATTRS.type = { setter: function(val) { if (val === 'hidden') { try { this._node.type = 'hidden'; } catch(e) { this.setStyle('display', 'none'); this._inputType = 'hidden'; } } else { try { // IE errors when changing the type from "hidden' this._node.type = val; } catch (e) { } } return val; }, getter: function() { return this._inputType || this._node.type; }, _bypassProxy: true // don't update DOM when using with Attribute }; }, '3.1.2' ,{requires:['dom-base', 'selector-css2', 'event-base']}); YUI.add('node-style', function(Y) { (function(Y) { /** * Extended Node interface for managing node styles. * @module node * @submodule node-style */ var methods = [ /** * Returns the style's current value. * @method getStyle * @for Node * @param {String} attr The style attribute to retrieve. * @return {String} The current value of the style property for the element. */ 'getStyle', /** * Returns the computed value for the given style property. * @method getComputedStyle * @param {String} attr The style attribute to retrieve. * @return {String} The computed value of the style property for the element. */ 'getComputedStyle', /** * Sets a style property of the node. * @method setStyle * @param {String} attr The style attribute to set. * @param {String|Number} val The value. * @chainable */ 'setStyle', /** * Sets multiple style properties on the node. * @method setStyles * @param {Object} hash An object literal of property:value pairs. * @chainable */ 'setStyles' ]; Y.Node.importMethod(Y.DOM, methods); /** * Returns an array of values for each node. * @method getStyle * @for NodeList * @see Node.getStyle * @param {String} attr The style attribute to retrieve. * @return {Array} The current values of the style property for the element. */ /** * Returns an array of the computed value for each node. * @method getComputedStyle * @see Node.getComputedStyle * @param {String} attr The style attribute to retrieve. * @return {Array} The computed values for each node. */ /** * Sets a style property on each node. * @method setStyle * @see Node.setStyle * @param {String} attr The style attribute to set. * @param {String|Number} val The value. * @chainable */ /** * Sets multiple style properties on each node. * @method setStyles * @see Node.setStyles * @param {Object} hash An object literal of property:value pairs. * @chainable */ Y.NodeList.importMethod(Y.Node.prototype, methods); })(Y); Y.mix(Y.Node.ATTRS, { offsetHeight: { setter: function(h) { Y.DOM.setHeight(this._node, h); return h; }, getter: function() { return this._node.offsetHeight; } }, offsetWidth: { setter: function(w) { Y.DOM.setWidth(this._node, w); return w; }, getter: function() { return this._node.offsetWidth; } } }); Y.mix(Y.Node.prototype, { sizeTo: function(w, h) { var node; if (arguments.length < 2) { node = Y.one(w); w = node.get('offsetWidth'); h = node.get('offsetHeight'); } this.setAttrs({ offsetWidth: w, offsetHeight: h }); } }); }, '3.1.2' ,{requires:['dom-style', 'node-base']}); YUI.add('node-screen', function(Y) { /** * Extended Node interface for managing regions and screen positioning. * Adds support for positioning elements and normalizes window size and scroll detection. * @module node * @submodule node-screen */ // these are all "safe" returns, no wrapping required Y.each([ /** * Returns the inner width of the viewport (exludes scrollbar). * @config winWidth * @for Node * @type {Int} */ 'winWidth', /** * Returns the inner height of the viewport (exludes scrollbar). * @config winHeight * @type {Int} */ 'winHeight', /** * Document width * @config winHeight * @type {Int} */ 'docWidth', /** * Document height * @config docHeight * @type {Int} */ 'docHeight', /** * Amount page has been scroll vertically * @config docScrollX * @type {Int} */ 'docScrollX', /** * Amount page has been scroll horizontally * @config docScrollY * @type {Int} */ 'docScrollY' ], function(name) { Y.Node.ATTRS[name] = { getter: function() { var args = Array.prototype.slice.call(arguments); args.unshift(Y.Node.getDOMNode(this)); return Y.DOM[name].apply(this, args); } }; } ); Y.Node.ATTRS.scrollLeft = { getter: function() { var node = Y.Node.getDOMNode(this); return ('scrollLeft' in node) ? node.scrollLeft : Y.DOM.docScrollX(node); }, setter: function(val) { var node = Y.Node.getDOMNode(this); if (node) { if ('scrollLeft' in node) { node.scrollLeft = val; } else if (node.document || node.nodeType === 9) { Y.DOM._getWin(node).scrollTo(val, Y.DOM.docScrollY(node)); // scroll window if win or doc } } else { } } }; Y.Node.ATTRS.scrollTop = { getter: function() { var node = Y.Node.getDOMNode(this); return ('scrollTop' in node) ? node.scrollTop : Y.DOM.docScrollY(node); }, setter: function(val) { var node = Y.Node.getDOMNode(this); if (node) { if ('scrollTop' in node) { node.scrollTop = val; } else if (node.document || node.nodeType === 9) { Y.DOM._getWin(node).scrollTo(Y.DOM.docScrollX(node), val); // scroll window if win or doc } } else { } } }; Y.Node.importMethod(Y.DOM, [ /** * Gets the current position of the node in page coordinates. * @method getXY * @for Node * @return {Array} The XY position of the node */ 'getXY', /** * Set the position of the node in page coordinates, regardless of how the node is positioned. * @method setXY * @param {Array} xy Contains X & Y values for new position (coordinates are page-based) * @chainable */ 'setXY', /** * Gets the current position of the node in page coordinates. * @method getX * @return {Int} The X position of the node */ 'getX', /** * Set the position of the node in page coordinates, regardless of how the node is positioned. * @method setX * @param {Int} x X value for new position (coordinates are page-based) * @chainable */ 'setX', /** * Gets the current position of the node in page coordinates. * @method getY * @return {Int} The Y position of the node */ 'getY', /** * Set the position of the node in page coordinates, regardless of how the node is positioned. * @method setY * @param {Int} y Y value for new position (coordinates are page-based) * @chainable */ 'setY', /** * Swaps the XY position of this node with another node. * @method swapXY * @param {Y.Node || HTMLElement} otherNode The node to swap with. * @chainable */ 'swapXY' ]); /** * Returns a region object for the node * @config region * @for Node * @type Node */ Y.Node.ATTRS.region = { getter: function() { var node = Y.Node.getDOMNode(this), region; if (node && !node.tagName) { if (node.nodeType === 9) { // document node = node.documentElement; } } if (node.alert) { region = Y.DOM.viewportRegion(node); } else { region = Y.DOM.region(node); } return region; } }; /** * Returns a region object for the node's viewport * @config viewportRegion * @type Node */ Y.Node.ATTRS.viewportRegion = { getter: function() { return Y.DOM.viewportRegion(Y.Node.getDOMNode(this)); } }; Y.Node.importMethod(Y.DOM, 'inViewportRegion'); // these need special treatment to extract 2nd node arg /** * Compares the intersection of the node with another node or region * @method intersect * @for Node * @param {Node|Object} node2 The node or region to compare with. * @param {Object} altRegion An alternate region to use (rather than this node's). * @return {Object} An object representing the intersection of the regions. */ Y.Node.prototype.intersect = function(node2, altRegion) { var node1 = Y.Node.getDOMNode(this); if (node2 instanceof Y.Node) { // might be a region object node2 = Y.Node.getDOMNode(node2); } return Y.DOM.intersect(node1, node2, altRegion); }; /** * Determines whether or not the node is within the giving region. * @method inRegion * @param {Node|Object} node2 The node or region to compare with. * @param {Boolean} all Whether or not all of the node must be in the region. * @param {Object} altRegion An alternate region to use (rather than this node's). * @return {Object} An object representing the intersection of the regions. */ Y.Node.prototype.inRegion = function(node2, all, altRegion) { var node1 = Y.Node.getDOMNode(this); if (node2 instanceof Y.Node) { // might be a region object node2 = Y.Node.getDOMNode(node2); } return Y.DOM.inRegion(node1, node2, all, altRegion); }; }, '3.1.2' ,{requires:['dom-screen']}); YUI.add('node-pluginhost', function(Y) { /** * Registers plugins to be instantiated at the class level (plugins * which should be plugged into every instance of Node by default). * * @method Node.plug * @static * * @param {Function | Array} plugin Either the plugin class, an array of plugin classes or an array of objects (with fn and cfg properties defined) * @param {Object} config (Optional) If plugin is the plugin class, the configuration for the plugin */ Y.Node.plug = function() { var args = Y.Array(arguments); args.unshift(Y.Node); Y.Plugin.Host.plug.apply(Y.Base, args); return Y.Node; }; /** * Unregisters any class level plugins which have been registered by the Node * * @method Node.unplug * @static * * @param {Function | Array} plugin The plugin class, or an array of plugin classes */ Y.Node.unplug = function() { var args = Y.Array(arguments); args.unshift(Y.Node); Y.Plugin.Host.unplug.apply(Y.Base, args); return Y.Node; }; Y.mix(Y.Node, Y.Plugin.Host, false, null, 1); // allow batching of plug/unplug via NodeList // doesn't use NodeList.importMethod because we need real Nodes (not tmpNode) Y.NodeList.prototype.plug = function() { var args = arguments; Y.NodeList.each(this, function(node) { Y.Node.prototype.plug.apply(Y.one(node), args); }); }; Y.NodeList.prototype.unplug = function() { var args = arguments; Y.NodeList.each(this, function(node) { Y.Node.prototype.unplug.apply(Y.one(node), args); }); }; }, '3.1.2' ,{requires:['node-base', 'pluginhost']}); YUI.add('node-event-delegate', function(Y) { /** * Functionality to make the node a delegated event container * @module node * @submodule node-event-delegate */ /** * Functionality to make the node a delegated event container * @method delegate * @param type {String} the event type to delegate * @param fn {Function} the function to execute * @param selector {String} a selector that must match the target of the event. * @return {Event.Handle} the detach handle * @for Node */ Y.Node.prototype.delegate = function(type, fn, selector) { var args = Array.prototype.slice.call(arguments, 3), a = [type, fn, Y.Node.getDOMNode(this), selector]; a = a.concat(args); return Y.delegate.apply(Y, a); }; }, '3.1.2' ,{requires:['node-base', 'event-delegate', 'pluginhost']}); YUI.add('node', function(Y){}, '3.1.2' ,{requires:['dom', 'event-base', 'event-delegate', 'pluginhost'], skinnable:false, use:['node-base', 'node-style', 'node-screen', 'node-pluginhost', 'node-event-delegate']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ /* * DOM event listener abstraction layer * @module event * @submodule event-base */ (function() { // Unlike most of the library, this code has to be executed as soon as it is // introduced into the page -- and it should only be executed one time // regardless of the number of instances that use it. var stateChangeListener, GLOBAL_ENV = YUI.Env, config = YUI.config, doc = config.doc, docElement = doc.documentElement, doScrollCap = docElement.doScroll, add = YUI.Env.add, remove = YUI.Env.remove, targetEvent = (doScrollCap) ? 'onreadystatechange' : 'DOMContentLoaded', pollInterval = config.pollInterval || 40, _ready = function(e) { GLOBAL_ENV._ready(); }; if (!GLOBAL_ENV._ready) { GLOBAL_ENV._ready = function() { if (!GLOBAL_ENV.DOMReady) { GLOBAL_ENV.DOMReady = true; remove(doc, targetEvent, _ready); // remove DOMContentLoaded listener } }; /*! DOMReady: based on work by: Dean Edwards/John Resig/Matthias Miller/Diego Perini */ // Internet Explorer: use the doScroll() method on the root element. This isolates what // appears to be a safe moment to manipulate the DOM prior to when the document's readyState // suggests it is safe to do so. if (doScrollCap) { if (self !== self.top) { stateChangeListener = function() { if (doc.readyState == 'complete') { remove(doc, targetEvent, stateChangeListener); // remove onreadystatechange listener _ready(); } }; add(doc, targetEvent, stateChangeListener); // add onreadystatechange listener } else { GLOBAL_ENV._dri = setInterval(function() { try { docElement.doScroll('left'); clearInterval(GLOBAL_ENV._dri); GLOBAL_ENV._dri = null; _ready(); } catch (domNotReady) { } }, pollInterval); } } else { // FireFox, Opera, Safari 3+ provide an event for this moment. add(doc, targetEvent, _ready); // add DOMContentLoaded listener } } })(); YUI.add('event-base', function(Y) { (function() { /* * DOM event listener abstraction layer * @module event * @submodule event-base */ var GLOBAL_ENV = YUI.Env, yready = function() { Y.fire('domready'); }; /** * The domready event fires at the moment the browser's DOM is * usable. In most cases, this is before images are fully * downloaded, allowing you to provide a more responsive user * interface. * * In YUI 3, domready subscribers will be notified immediately if * that moment has already passed when the subscription is created. * * One exception is if the yui.js file is dynamically injected into * the page. If this is done, you must tell the YUI instance that * you did this in order for DOMReady (and window load events) to * fire normally. That configuration option is 'injected' -- set * it to true if the yui.js script is not included inline. * * This method is part of the 'event-ready' module, which is a * submodule of 'event'. * * @event domready * @for YUI */ Y.publish('domready', { fireOnce: true, async: true }); if (GLOBAL_ENV.DOMReady) { // console.log('DOMReady already fired', 'info', 'event'); yready(); } else { // console.log('setting up before listener', 'info', 'event'); // console.log('env: ' + YUI.Env.windowLoaded, 'info', 'event'); Y.before(yready, GLOBAL_ENV, "_ready"); } })(); (function() { /** * Custom event engine, DOM event listener abstraction layer, synthetic DOM * events. * @module event * @submodule event-base */ /** * Wraps a DOM event, properties requiring browser abstraction are * fixed here. Provids a security layer when required. * @class DOMEventFacade * @param ev {Event} the DOM event * @param currentTarget {HTMLElement} the element the listener was attached to * @param wrapper {Event.Custom} the custom event wrapper for this DOM event */ /* * @TODO constants? LEFTBUTTON, MIDDLEBUTTON, RIGHTBUTTON, keys */ /* var whitelist = { altKey : 1, // "button" : 1, // we supply // "bubbles" : 1, // needed? // "cancelable" : 1, // needed? // "charCode" : 1, // we supply cancelBubble : 1, // "currentTarget" : 1, // we supply ctrlKey : 1, clientX : 1, // needed? clientY : 1, // needed? detail : 1, // not fully implemented // "fromElement" : 1, keyCode : 1, // "height" : 1, // needed? // "initEvent" : 1, // need the init events? // "initMouseEvent" : 1, // "initUIEvent" : 1, // "layerX" : 1, // needed? // "layerY" : 1, // needed? metaKey : 1, // "modifiers" : 1, // needed? // "offsetX" : 1, // needed? // "offsetY" : 1, // needed? // "preventDefault" : 1, // we supply // "reason" : 1, // IE proprietary // "relatedTarget" : 1, // "returnValue" : 1, // needed? shiftKey : 1, // "srcUrn" : 1, // IE proprietary // "srcElement" : 1, // "srcFilter" : 1, IE proprietary // "stopPropagation" : 1, // we supply // "target" : 1, // "timeStamp" : 1, // needed? // "toElement" : 1, type : 1, // "view" : 1, // "which" : 1, // we supply // "width" : 1, // needed? x : 1, y : 1 }, */ var ua = Y.UA, /** * webkit key remapping required for Safari < 3.1 * @property webkitKeymap * @private */ webkitKeymap = { 63232: 38, // up 63233: 40, // down 63234: 37, // left 63235: 39, // right 63276: 33, // page up 63277: 34, // page down 25: 9, // SHIFT-TAB (Safari provides a different key code in // this case, even though the shiftKey modifier is set) 63272: 46, // delete 63273: 36, // home 63275: 35 // end }, /** * Returns a wrapped node. Intended to be used on event targets, * so it will return the node's parent if the target is a text * node. * * If accessing a property of the node throws an error, this is * probably the anonymous div wrapper Gecko adds inside text * nodes. This likely will only occur when attempting to access * the relatedTarget. In this case, we now return null because * the anonymous div is completely useless and we do not know * what the related target was because we can't even get to * the element's parent node. * * @method resolve * @private */ resolve = function(n) { try { if (n && 3 == n.nodeType) { n = n.parentNode; } } catch(e) { return null; } return Y.one(n); }; // provide a single event with browser abstractions resolved // // include all properties for both browers? // include only DOM2 spec properties? // provide browser-specific facade? Y.DOMEventFacade = function(ev, currentTarget, wrapper) { wrapper = wrapper || {}; var e = ev, ot = currentTarget, d = Y.config.doc, b = d.body, x = e.pageX, y = e.pageY, c, t, overrides = wrapper.overrides || {}; this.altKey = e.altKey; this.ctrlKey = e.ctrlKey; this.metaKey = e.metaKey; this.shiftKey = e.shiftKey; this.type = overrides.type || e.type; this.clientX = e.clientX; this.clientY = e.clientY; ////////////////////////////////////////////////////// if (!x && 0 !== x) { x = e.clientX || 0; y = e.clientY || 0; if (ua.ie) { x += Math.max(d.documentElement.scrollLeft, b.scrollLeft); y += Math.max(d.documentElement.scrollTop, b.scrollTop); } } this._yuifacade = true; /** * The native event * @property _event */ this._event = e; /** * The X location of the event on the page (including scroll) * @property pageX * @type int */ this.pageX = x; /** * The Y location of the event on the page (including scroll) * @property pageY * @type int */ this.pageY = y; ////////////////////////////////////////////////////// c = e.keyCode || e.charCode || 0; if (ua.webkit && (c in webkitKeymap)) { c = webkitKeymap[c]; } /** * The keyCode for key events. Uses charCode if keyCode is not available * @property keyCode * @type int */ this.keyCode = c; /** * The charCode for key events. Same as keyCode * @property charCode * @type int */ this.charCode = c; ////////////////////////////////////////////////////// /** * The button that was pushed. * @property button * @type int */ this.button = e.which || e.button; /** * The button that was pushed. Same as button. * @property which * @type int */ this.which = this.button; ////////////////////////////////////////////////////// /** * Node reference for the targeted element * @propery target * @type Node */ this.target = resolve(e.target || e.srcElement); /** * Node reference for the element that the listener was attached to. * @propery currentTarget * @type Node */ this.currentTarget = resolve(ot); t = e.relatedTarget; if (!t) { if (e.type == "mouseout") { t = e.toElement; } else if (e.type == "mouseover") { t = e.fromElement; } } /** * Node reference to the relatedTarget * @propery relatedTarget * @type Node */ this.relatedTarget = resolve(t); /** * Number representing the direction and velocity of the movement of the mousewheel. * Negative is down, the higher the number, the faster. Applies to the mousewheel event. * @property wheelDelta * @type int */ if (e.type == "mousewheel" || e.type == "DOMMouseScroll") { this.wheelDelta = (e.detail) ? (e.detail * -1) : Math.round(e.wheelDelta / 80) || ((e.wheelDelta < 0) ? -1 : 1); } ////////////////////////////////////////////////////// // methods /** * Stops the propagation to the next bubble target * @method stopPropagation */ this.stopPropagation = function() { if (e.stopPropagation) { e.stopPropagation(); } else { e.cancelBubble = true; } wrapper.stopped = 1; }; /** * Stops the propagation to the next bubble target and * prevents any additional listeners from being exectued * on the current target. * @method stopImmediatePropagation */ this.stopImmediatePropagation = function() { if (e.stopImmediatePropagation) { e.stopImmediatePropagation(); } else { this.stopPropagation(); } wrapper.stopped = 2; }; /** * Prevents the event's default behavior * @method preventDefault * @param returnValue {string} sets the returnValue of the event to this value * (rather than the default false value). This can be used to add a customized * confirmation query to the beforeunload event). */ this.preventDefault = function(returnValue) { if (e.preventDefault) { e.preventDefault(); } e.returnValue = returnValue || false; wrapper.prevented = 1; }; /** * Stops the event propagation and prevents the default * event behavior. * @method halt * @param immediate {boolean} if true additional listeners * on the current target will not be executed */ this.halt = function(immediate) { if (immediate) { this.stopImmediatePropagation(); } else { this.stopPropagation(); } this.preventDefault(); }; }; })(); (function() { /** * DOM event listener abstraction layer * @module event * @submodule event-base */ /** * The event utility provides functions to add and remove event listeners, * event cleansing. It also tries to automatically remove listeners it * registers during the unload event. * * @class Event * @static */ Y.Env.evt.dom_wrappers = {}; Y.Env.evt.dom_map = {}; var _eventenv = Y.Env.evt, add = YUI.Env.add, remove = YUI.Env.remove, onLoad = function() { YUI.Env.windowLoaded = true; Y.Event._load(); remove(window, "load", onLoad); }, onUnload = function() { Y.Event._unload(); remove(window, "unload", onUnload); }, EVENT_READY = 'domready', COMPAT_ARG = '~yui|2|compat~', shouldIterate = function(o) { try { return (o && typeof o !== "string" && Y.Lang.isNumber(o.length) && !o.tagName && !o.alert); } catch(ex) { return false; } }, Event = function() { /** * True after the onload event has fired * @property _loadComplete * @type boolean * @static * @private */ var _loadComplete = false, /** * The number of times to poll after window.onload. This number is * increased if additional late-bound handlers are requested after * the page load. * @property _retryCount * @static * @private */ _retryCount = 0, /** * onAvailable listeners * @property _avail * @static * @private */ _avail = [], /** * Custom event wrappers for DOM events. Key is * 'event:' + Element uid stamp + event type * @property _wrappers * @type Y.Event.Custom * @static * @private */ _wrappers = _eventenv.dom_wrappers, _windowLoadKey = null, /** * Custom event wrapper map DOM events. Key is * Element uid stamp. Each item is a hash of custom event * wrappers as provided in the _wrappers collection. This * provides the infrastructure for getListeners. * @property _el_events * @static * @private */ _el_events = _eventenv.dom_map; return { /** * The number of times we should look for elements that are not * in the DOM at the time the event is requested after the document * has been loaded. The default is 1000@amp;40 ms, so it will poll * for 40 seconds or until all outstanding handlers are bound * (whichever comes first). * @property POLL_RETRYS * @type int * @static * @final */ POLL_RETRYS: 1000, /** * The poll interval in milliseconds * @property POLL_INTERVAL * @type int * @static * @final */ POLL_INTERVAL: 40, /** * addListener/removeListener can throw errors in unexpected scenarios. * These errors are suppressed, the method returns false, and this property * is set * @property lastError * @static * @type Error */ lastError: null, /** * poll handle * @property _interval * @static * @private */ _interval: null, /** * document readystate poll handle * @property _dri * @static * @private */ _dri: null, /** * True when the document is initially usable * @property DOMReady * @type boolean * @static */ DOMReady: false, /** * @method startInterval * @static * @private */ startInterval: function() { if (!Event._interval) { Event._interval = setInterval(Y.bind(Event._poll, Event), Event.POLL_INTERVAL); } }, /** * Executes the supplied callback when the item with the supplied * id is found. This is meant to be used to execute behavior as * soon as possible as the page loads. If you use this after the * initial page load it will poll for a fixed time for the element. * The number of times it will poll and the frequency are * configurable. By default it will poll for 10 seconds. * *

The callback is executed with a single parameter: * the custom object parameter, if provided.

* * @method onAvailable * * @param {string||string[]} id the id of the element, or an array * of ids to look for. * @param {function} fn what to execute when the element is found. * @param {object} p_obj an optional object to be passed back as * a parameter to fn. * @param {boolean|object} p_override If set to true, fn will execute * in the context of p_obj, if set to an object it * will execute in the context of that object * @param checkContent {boolean} check child node readiness (onContentReady) * @static * @deprecated Use Y.on("available") */ // @TODO fix arguments onAvailable: function(id, fn, p_obj, p_override, checkContent, compat) { var a = Y.Array(id), i, availHandle; for (i=0; iThe callback is executed with a single parameter: * the custom object parameter, if provided.

* * @method onContentReady * * @param {string} id the id of the element to look for. * @param {function} fn what to execute when the element is ready. * @param {object} p_obj an optional object to be passed back as * a parameter to fn. * @param {boolean|object} p_override If set to true, fn will execute * in the context of p_obj. If an object, fn will * exectute in the context of that object * * @static * @deprecated Use Y.on("contentready") */ // @TODO fix arguments onContentReady: function(id, fn, p_obj, p_override, compat) { return this.onAvailable(id, fn, p_obj, p_override, true, compat); }, /** * Adds an event listener * * @method attach * * @param {String} type The type of event to append * @param {Function} fn The method the event invokes * @param {String|HTMLElement|Array|NodeList} el An id, an element * reference, or a collection of ids and/or elements to assign the * listener to. * @param {Object} context optional context object * @param {Boolean|object} args 0..n arguments to pass to the callback * @return {EventHandle} an object to that can be used to detach the listener * * @static */ attach: function(type, fn, el, context) { return Event._attach(Y.Array(arguments, 0, true)); }, _createWrapper: function (el, type, capture, compat, facade) { var cewrapper, ek = Y.stamp(el), key = 'event:' + ek + type; if (false === facade) { key += 'native'; } if (capture) { key += 'capture'; } cewrapper = _wrappers[key]; if (!cewrapper) { // create CE wrapper cewrapper = Y.publish(key, { silent: true, bubbles: false, contextFn: function() { if (compat) { return cewrapper.el; } else { cewrapper.nodeRef = cewrapper.nodeRef || Y.one(cewrapper.el); return cewrapper.nodeRef; } } }); cewrapper.overrides = {}; // for later removeListener calls cewrapper.el = el; cewrapper.key = key; cewrapper.domkey = ek; cewrapper.type = type; cewrapper.fn = function(e) { cewrapper.fire(Event.getEvent(e, el, (compat || (false === facade)))); }; cewrapper.capture = capture; if (el == Y.config.win && type == "load") { // window load happens once cewrapper.fireOnce = true; _windowLoadKey = key; } _wrappers[key] = cewrapper; _el_events[ek] = _el_events[ek] || {}; _el_events[ek][key] = cewrapper; add(el, type, cewrapper.fn, capture); } return cewrapper; }, _attach: function(args, config) { var compat, handles, oEl, cewrapper, context, fireNow = false, ret, type = args[0], fn = args[1], el = args[2] || Y.config.win, facade = config && config.facade, capture = config && config.capture, overrides = config && config.overrides; if (args[args.length-1] === COMPAT_ARG) { compat = true; // trimmedArgs.pop(); } if (!fn || !fn.call) { // throw new TypeError(type + " attach call failed, callback undefined"); return false; } // The el argument can be an array of elements or element ids. if (shouldIterate(el)) { handles=[]; Y.each(el, function(v, k) { args[2] = v; handles.push(Event._attach(args, config)); }); // return (handles.length === 1) ? handles[0] : handles; return new Y.EventHandle(handles); // If the el argument is a string, we assume it is // actually the id of the element. If the page is loaded // we convert el to the actual element, otherwise we // defer attaching the event until the element is // ready } else if (Y.Lang.isString(el)) { // oEl = (compat) ? Y.DOM.byId(el) : Y.Selector.query(el); if (compat) { oEl = Y.DOM.byId(el); } else { oEl = Y.Selector.query(el); switch (oEl.length) { case 0: oEl = null; break; case 1: oEl = oEl[0]; break; default: args[2] = oEl; return Event._attach(args, config); } } if (oEl) { el = oEl; // Not found = defer adding the event until the element is available } else { ret = this.onAvailable(el, function() { ret.handle = Event._attach(args, config); }, Event, true, false, compat); return ret; } } // Element should be an html element or node if (!el) { return false; } if (Y.Node && el instanceof Y.Node) { el = Y.Node.getDOMNode(el); } cewrapper = this._createWrapper(el, type, capture, compat, facade); if (overrides) { Y.mix(cewrapper.overrides, overrides); } if (el == Y.config.win && type == "load") { // if the load is complete, fire immediately. // all subscribers, including the current one // will be notified. if (YUI.Env.windowLoaded) { fireNow = true; } } if (compat) { args.pop(); } context = args[3]; // set context to the Node if not specified // ret = cewrapper.on.apply(cewrapper, trimmedArgs); ret = cewrapper._on(fn, context, (args.length > 4) ? args.slice(4) : null); if (fireNow) { cewrapper.fire(); } return ret; }, /** * Removes an event listener. Supports the signature the event was bound * with, but the preferred way to remove listeners is using the handle * that is returned when using Y.on * * @method detach * * @param {String} type the type of event to remove. * @param {Function} fn the method the event invokes. If fn is * undefined, then all event handlers for the type of event are * removed. * @param {String|HTMLElement|Array|NodeList|EventHandle} el An * event handle, an id, an element reference, or a collection * of ids and/or elements to remove the listener from. * @return {boolean} true if the unbind was successful, false otherwise. * @static */ detach: function(type, fn, el, obj) { var args=Y.Array(arguments, 0, true), compat, l, ok, i, id, ce; if (args[args.length-1] === COMPAT_ARG) { compat = true; // args.pop(); } if (type && type.detach) { return type.detach(); } // The el argument can be a string if (typeof el == "string") { // el = (compat) ? Y.DOM.byId(el) : Y.all(el); if (compat) { el = Y.DOM.byId(el); } else { el = Y.Selector.query(el); l = el.length; if (l < 1) { el = null; } else if (l == 1) { el = el[0]; } } // return Event.detach.apply(Event, args); } if (!el) { return false; } if (el.detach) { args.splice(2, 1); return el.detach.apply(el, args); // The el argument can be an array of elements or element ids. } else if (shouldIterate(el)) { ok = true; for (i=0, l=el.length; i 0); } // onAvailable notAvail = []; executeItem = function (el, item) { var context, ov = item.override; if (item.compat) { if (item.override) { if (ov === true) { context = item.obj; } else { context = ov; } } else { context = el; } item.fn.call(context, item.obj); } else { context = item.obj || Y.one(el); item.fn.apply(context, (Y.Lang.isArray(ov)) ? ov : []); } }; // onAvailable for (i=0,len=_avail.length; i 4 ? Y.Array(arguments, 4, true) : []; return Y.Event.onAvailable.call(Y.Event, id, fn, o, a); } }; /** * Executes the callback as soon as the specified element * is detected in the DOM with a nextSibling property * (indicating that the element's children are available) * @event contentready * @param type {string} 'contentready' * @param fn {function} the callback function to execute. * @param el {string|HTMLElement|collection} the element(s) to attach * @param context optional argument that specifies what 'this' refers to. * @param args* 0..n additional arguments to pass on to the callback function. * These arguments will be added after the event object. * @return {EventHandle} the detach handle * @for YUI */ Y.Env.evt.plugins.contentready = { on: function(type, fn, id, o) { var a = arguments.length > 4 ? Y.Array(arguments, 4, true) : []; return Y.Event.onContentReady.call(Y.Event, id, fn, o, a); } }; }, '3.1.2' ,{requires:['event-custom-base']}); YUI.add('event-delegate', function(Y) { /** * Adds event delegation support to the library. * * @module event * @submodule event-delegate */ var Event = Y.Event, Lang = Y.Lang, delegates = {}, specialTypes = { mouseenter: "mouseover", mouseleave: "mouseout" }, resolveTextNode = function(n) { try { if (n && 3 == n.nodeType) { return n.parentNode; } } catch(e) { } return n; }, delegateHandler = function(delegateKey, e, el) { var target = resolveTextNode((e.target || e.srcElement)), tests = delegates[delegateKey], spec, ename, matched, fn, ev; var getMatch = function(el, selector, container) { var returnVal; if (!el || el === container) { returnVal = false; } else { returnVal = Y.Selector.test(el, selector, container) ? el: getMatch(el.parentNode, selector, container); } return returnVal; }; for (spec in tests) { if (tests.hasOwnProperty(spec)) { ename = tests[spec]; fn = tests.fn; matched = null; if (Y.Selector.test(target, spec, el)) { matched = target; } else if (Y.Selector.test(target, ((spec.replace(/,/gi, " *,")) + " *"), el)) { // The target is a descendant of an element matching // the selector, so crawl up to find the ancestor that // matches the selector matched = getMatch(target, spec, el); } if (matched) { if (!ev) { ev = new Y.DOMEventFacade(e, el); ev.container = ev.currentTarget; } ev.currentTarget = Y.one(matched); Y.publish(ename, { contextFn: function() { return ev.currentTarget; } }); if (fn) { fn(ev, ename); } else { Y.fire(ename, ev); } } } } }, attach = function (type, key, element) { var focusMethods = { focus: Event._attachFocus, blur: Event._attachBlur }, attachFn = focusMethods[type], args = [type, function (e) { delegateHandler(key, (e || window.event), element); }, element]; if (attachFn) { return attachFn(args, { capture: true, facade: false }); } else { return Event._attach(args, { facade: false }); } }, sanitize = Y.cached(function(str) { return str.replace(/[|,:]/g, '~'); }); /** * Sets up event delegation on a container element. The delegated event * will use a supplied selector to test if the target or one of the * descendants of the target match it. The supplied callback function * will only be executed if a match was encountered, and, in fact, * will be executed for each element that matches if you supply an * ambiguous selector. * * The event object for the delegated event is supplied to the callback * function. It is modified slightly in order to support all properties * that may be needed for event delegation. 'currentTarget' is set to * the element that matched the delegation specifcation. 'container' is * set to the element that the listener is bound to (this normally would * be the 'currentTarget'). * * @method delegate * @param type {string} the event type to delegate * @param fn {function} the callback function to execute. This function * will be provided the event object for the delegated event. * @param el {string|node} the element that is the delegation container * @param spec {string} a selector that must match the target of the * event. * @param context optional argument that specifies what 'this' refers to. * @param args* 0..n additional arguments to pass on to the callback function. * These arguments will be added after the event object. * @return {EventHandle} the detach handle * @for YUI */ Event.delegate = function (type, fn, el, spec) { if (!spec) { return false; } var args = Y.Array(arguments, 0, true), element = el, // HTML element serving as the delegation container availHandle; if (Lang.isString(el)) { // Y.Selector.query returns an array of matches unless specified // to return just the first match. Since the primary use case for // event delegation is to use a single event handler on a container, // Y.delegate doesn't currently support being able to bind a // single listener to multiple containers. element = Y.Selector.query(el, null, true); if (!element) { // Not found, check using onAvailable availHandle = Event.onAvailable(el, function() { availHandle.handle = Event.delegate.apply(Event, args); }, Event, true, false); return availHandle; } } element = Y.Node.getDOMNode(element); var guid = Y.stamp(element), // The Custom Event for the delegation spec ename = 'delegate:' + guid + type + sanitize(spec), // The key to the listener for the event type and container delegateKey = type + guid, delegate = delegates[delegateKey], domEventHandle, ceHandle, listeners; if (!delegate) { delegate = {}; if (specialTypes[type]) { if (!Event._fireMouseEnter) { return false; } type = specialTypes[type]; delegate.fn = Event._fireMouseEnter; } // Create the DOM Event wrapper that will fire the Custom Event domEventHandle = attach(type, delegateKey, element); // Hook into the _delete method for the Custom Event wrapper of this // DOM Event in order to clean up the 'delegates' map and unsubscribe // the associated Custom Event listeners fired by this DOM event // listener if/when the user calls "purgeElement" OR removes all // listeners of the Custom Event. Y.after(function (sub) { if (domEventHandle.sub == sub) { // Delete this event from the map of known delegates delete delegates[delegateKey]; // Unsubscribe all listeners of the Custom Event fired // by this DOM event. Y.detachAll(ename); } }, domEventHandle.evt, "_delete"); delegate.handle = domEventHandle; delegates[delegateKey] = delegate; } listeners = delegate.listeners; delegate.listeners = listeners ? (listeners + 1) : 1; delegate[spec] = ename; args[0] = ename; // Remove element, delegation spec args.splice(2, 2); // Subscribe to the Custom Event for the delegation spec ceHandle = Y.on.apply(Y, args); // Hook into the detach method of the handle in order to clean up the // 'delegates' map and remove the associated DOM event handler // responsible for firing this Custom Event if all listener for this // event have been removed. Y.after(function () { delegate.listeners = (delegate.listeners - 1); if (delegate.listeners === 0) { delegate.handle.detach(); } }, ceHandle, "detach"); return ceHandle; }; Y.delegate = Event.delegate; }, '3.1.2' ,{requires:['node-base']}); YUI.add('event-mousewheel', function(Y) { /** * Adds mousewheel event support * @module event * @submodule event-mousewheel */ var DOM_MOUSE_SCROLL = 'DOMMouseScroll', fixArgs = function(args) { var a = Y.Array(args, 0, true), target; if (Y.UA.gecko) { a[0] = DOM_MOUSE_SCROLL; target = Y.config.win; } else { target = Y.config.doc; } if (a.length < 3) { a[2] = target; } else { a.splice(2, 0, target); } return a; }; /** * Mousewheel event. This listener is automatically attached to the * correct target, so one should not be supplied. Mouse wheel * direction and velocity is stored in the 'mouseDelta' field. * @event mousewheel * @param type {string} 'mousewheel' * @param fn {function} the callback to execute * @param context optional context object * @param args 0..n additional arguments to provide to the listener. * @return {EventHandle} the detach handle * @for YUI */ Y.Env.evt.plugins.mousewheel = { on: function() { return Y.Event._attach(fixArgs(arguments)); }, detach: function() { return Y.Event.detach.apply(Y.Event, fixArgs(arguments)); } }; }, '3.1.2' ,{requires:['node-base']}); YUI.add('event-mouseenter', function(Y) { /** * Adds support for mouseenter/mouseleave events * @module event * @submodule event-mouseenter */ var Event = Y.Event, Lang = Y.Lang, plugins = Y.Env.evt.plugins, listeners = {}, eventConfig = { on: function(type, fn, el) { var args = Y.Array(arguments, 0, true), element = el, availHandle; if (Lang.isString(el)) { // Need to use Y.all because if el is a string it could be a // selector that returns a NodeList element = Y.all(el); if (element.size() === 0) { // Not found, check using onAvailable availHandle = Event.onAvailable(el, function() { availHandle.handle = Y.on.apply(Y, args); }, Event, true, false); return availHandle; } } var sDOMEvent = (type === "mouseenter") ? "mouseover" : "mouseout", // The name of the custom event sEventName = type + ":" + Y.stamp(element) + sDOMEvent, listener = listeners[sEventName], domEventHandle, ceHandle, nListeners; // Bind an actual DOM event listener that will call the // the custom event if (!listener) { domEventHandle = Y.on(sDOMEvent, Y.rbind(Event._fireMouseEnter, Y, sEventName), element); // Hook into the _delete method for the Custom Event wrapper of this // DOM Event in order to clean up the 'listeners' map and unsubscribe // the associated Custom Event listeners fired by this DOM event // listener if/when the user calls "purgeElement" OR removes all // listeners of the Custom Event. Y.after(function (sub) { if (domEventHandle.sub == sub) { // Delete this event from the map of known mouseenter // and mouseleave listeners delete listeners[sEventName]; // Unsubscribe all listeners of the Custom Event fired // by this DOM event. Y.detachAll(sEventName); } }, domEventHandle.evt, "_delete"); listener = {}; listener.handle = domEventHandle; listeners[sEventName] = listener; } nListeners = listener.count; listener.count = nListeners ? (nListeners + 1) : 1; args[0] = sEventName; // Remove the element from the args args.splice(2, 1); // Subscribe to the custom event ceHandle = Y.on.apply(Y, args); // Hook into the detach method of the handle in order to clean up the // 'listeners' map and remove the associated DOM event handler // responsible for firing this Custom Event if all listener for this // event have been removed. Y.after(function () { listener.count = (listener.count - 1); if (listener.count === 0) { listener.handle.detach(); } }, ceHandle, "detach"); return ceHandle; } }; Event._fireMouseEnter = function (e, eventName) { var relatedTarget = e.relatedTarget, currentTarget = e.currentTarget; if (currentTarget !== relatedTarget && !currentTarget.contains(relatedTarget)) { Y.publish(eventName, { contextFn: function() { return currentTarget; } }); Y.fire(eventName, e); } }; /** * Sets up a "mouseenter" listener—a listener that is called the first time * the user's mouse enters the specified element(s). * * @event mouseenter * @param type {string} "mouseenter" * @param fn {function} The method the event invokes. * @param el {string|node} The element(s) to assign the listener to. * @param spec {string} Optional. String representing a selector that must * match the target of the event in order for the listener to be called. * @return {EventHandle} the detach handle * @for YUI */ plugins.mouseenter = eventConfig; /** * Sets up a "mouseleave" listener—a listener that is called the first time * the user's mouse leaves the specified element(s). * * @event mouseleave * @param type {string} "mouseleave" * @param fn {function} The method the event invokes. * @param el {string|node} The element(s) to assign the listener to. * @param spec {string} Optional. String representing a selector that must * match the target of the event in order for the listener to be called. * @return {EventHandle} the detach handle * @for YUI */ plugins.mouseleave = eventConfig; }, '3.1.2' ,{requires:['node-base']}); YUI.add('event-key', function(Y) { /** * Functionality to listen for one or more specific key combinations. * @module event * @submodule event-key */ /** * Add a key listener. The listener will only be notified if the * keystroke detected meets the supplied specification. The * spec consists of the key event type, followed by a colon, * followed by zero or more comma separated key codes, followed * by zero or more modifiers delimited by a plus sign. Ex: * press:12,65+shift+ctrl * @event key * @for YUI * @param type {string} 'key' * @param fn {function} the function to execute * @param id {string|HTMLElement|collection} the element(s) to bind * @param spec {string} the keyCode and modifier specification * @param o optional context object * @param args 0..n additional arguments to provide to the listener. * @return {Event.Handle} the detach handle */ Y.Env.evt.plugins.key = { on: function(type, fn, id, spec, o) { var a = Y.Array(arguments, 0, true), parsed, etype, criteria, ename; parsed = spec && spec.split(':'); if (!spec || spec.indexOf(':') == -1 || !parsed[1]) { a[0] = 'key' + ((parsed && parsed[0]) || 'press'); return Y.on.apply(Y, a); } // key event type: 'down', 'up', or 'press' etype = parsed[0]; // list of key codes optionally followed by modifiers criteria = (parsed[1]) ? parsed[1].split(/,|\+/) : null; // the name of the custom event that will be created for the spec ename = (Y.Lang.isString(id) ? id : Y.stamp(id)) + spec; ename = ename.replace(/,/g, '_'); if (!Y.getEvent(ename)) { // subscribe spec validator to the DOM event Y.on(type + etype, function(e) { var passed = false, failed = false, i, crit, critInt; for (i=0; i *
  • Easy creation of prefixed class names
    • *
  • Caching of previously created class names for improved performance.
    • * * * @class ClassNameManager * @static */ // String constants var CLASS_NAME_PREFIX = 'classNamePrefix', CLASS_NAME_DELIMITER = 'classNameDelimiter', CONFIG = Y.config; // Global config /** * Configuration property indicating the prefix for all CSS class names in this YUI instance. * * @property Y.config.classNamePrefix * @type {String} * @default "yui" * @static */ CONFIG[CLASS_NAME_PREFIX] = CONFIG[CLASS_NAME_PREFIX] || 'yui3'; /** * Configuration property indicating the delimiter used to compose all CSS class names in * this YUI instance. * * @property Y.config.classNameDelimiter * @type {String} * @default "-" * @static */ CONFIG[CLASS_NAME_DELIMITER] = CONFIG[CLASS_NAME_DELIMITER] || '-'; Y.ClassNameManager = function () { var sPrefix = CONFIG[CLASS_NAME_PREFIX], sDelimiter = CONFIG[CLASS_NAME_DELIMITER]; return { /** * Returns a class name prefixed with the the value of the * Y.config.classNamePrefix attribute + the provided strings. * Uses the Y.config.classNameDelimiter attribute to delimit the * provided strings. E.g. Y.ClassNameManager.getClassName('foo','bar'); // yui-foo-bar * * @method getClassName * @param {String}+ classnameSection one or more classname sections to be joined * @param {Boolean} skipPrefix If set to true, the classname will not be prefixed with the default Y.config.classNameDelimiter value. */ getClassName: Y.cached(function () { var args = Y.Array(arguments); if (args[args.length-1] !== true) { args.unshift(sPrefix); } else { args.pop(); } return args.join(sDelimiter); }) }; }(); }, '3.1.2' ); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('widget-base', function(Y) { /** * Provides the base Widget class, with HTML Parser support * * @module 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", OFFSET_HEIGHT = "offsetHeight", AUTO = "auto", SRC_NODE = "srcNode", BODY = "body", TAB_INDEX = "tabIndex", ID = "id", RENDER = "render", RENDERED = "rendered", DESTROYED = "destroyed", STRINGS = "strings", DIV = "
    ", CHANGE = "Change", LOADING = "loading", _UISET = "_uiSet", EMPTY_STR = "", EMPTY_FN = function() {}, UI_EVENT_REGEX = /(\w+):(\w+)/, UI_EVENT_REGEX_REPLACE = "$2", TRUE = true, FALSE = false, UI, ATTRS = {}, UI_ATTRS = [VISIBLE, DISABLED, HEIGHT, WIDTH, FOCUSED], WEBKIT = Y.UA.webkit, IE = Y.UA.ie, ContentUpdate = "contentUpdate", // Map of Node instances serving as a delegation containers for a specific // event type to Widget instances using that delegation container. _delegates = {}, // Widget nodeguid-to-instance map. _instances = {}; /** * A base class for widgets, providing: *
      *
    • The render lifecycle method, in addition to the init and destroy * lifecycle methods provide by Base
      • *
    • Abstract methods to support consistent MVC structure across * widgets: renderer, renderUI, bindUI, syncUI
      • *
    • Support for common widget attributes, such as boundingBox, contentBox, visible, * disabled, focused, strings
      • *
    * * @param config {Object} Object literal specifying widget configuration properties. * * @class Widget * @constructor * @extends Base */ function Widget(config) { this._strs = {}; this._cssPrefix = this.constructor.CSS_PREFIX || _getClassName(this.constructor.NAME.toLowerCase()); Widget.superclass.constructor.apply(this, arguments); var render = this.get(RENDER), parentNode; if (render) { // Render could be a node or boolean if (render !== TRUE) { parentNode = render; } this.render(parentNode); } } /** * Static property provides a string to identify the class. *

    * Currently used to apply class identifiers to the bounding box * and to classify events fired by the widget. *

    * * @property Widget.NAME * @type String * @static */ Widget.NAME = "widget"; /** * Constant used to identify state changes originating from * the DOM (as opposed to the JavaScript model). * * @property Widget.UI_SRC * @type String * @static * @final */ UI = Widget.UI_SRC = "ui"; /** * Static property used to define the default attribute * configuration for the Widget. * * @property Widget.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] = { value:null, setter: "_setBB", writeOnce: TRUE }; /** * @attribute contentBox * @description A DOM node that is a direct descendent 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 0 */ 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 weather 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 Widget.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 Y.config.classNamePrefix attribute used by ClassNameManager and * Widget.NAME.toLowerCase() (e.g. "yui-widget-xxxxx-yyyyy", based on default values for * the prefix and widget class name). *

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

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

    * In the case of nested widgets, the nearest bounding box ancestor is used to * return the widget instance. *

    * @method Widget.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 * YUI.config.classNamePrefix attribute + the instances NAME property. * Uses YUI.config.classNameDelimiter attribute to delimit the provided strings. * e.g. * * 
    	 *    // 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');
	 *
    *     * * @method getClassName * @param {String}+ One or more classname bits to be joined and prefixed */ getClassName: function () { return _getClassName.apply(ClassNameManager, [this._cssPrefix].concat(Y.Array(arguments), true)); }, /** * Returns the name of the skin that's currently applied to the widget. * This is only really useful after the widget's DOM structure is in the * document, either by render or by progressive enhancement. Searches up * the Widget's ancestor axis for a class yui3-skin-(name), and returns the * (name) portion. Otherwise, returns null. * * @method getSkinName * @return {String} the name of the skin, or null (yui3-skin-sam => sam) */ getSkinName: function () { var root = this.get( CONTENT_BOX ) || this.get( BOUNDING_BOX ), search = new RegExp( '\\b' + _getClassName( 'skin' ) + '-(\\S+)' ), match; if ( root ) { root.ancestor( function ( node ) { match = node.get( 'className' ).match( search ); return match; } ); } return ( match ) ? match[1] : null; }, /** * 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) { _instances[Y.stamp(this.get(BOUNDING_BOX))] = this; /** * 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 */ this.publish(ContentUpdate, { preventable:FALSE }); if (this._applyParser) { this._applyParser(config); } }, /** * Destructor lifecycle implementation for the Widget class. Purges events attached * to the bounding box (and all child nodes) and removes the Widget from the * list of registered widgets. * * @method destructor * @protected */ destructor: function() { var boundingBox = this.get(BOUNDING_BOX), bbGuid = Y.stamp(boundingBox, TRUE), widgetGuid = Y.stamp(this, TRUE); if (bbGuid in _instances) { delete _instances[bbGuid]; } Y.each(_delegates, function (info) { if (info.instances[widgetGuid]) { // Unregister this Widget instance as needing this delegated // event listener. delete info.instances[widgetGuid]; // There are no more Widget instances using this delegated // event listener, so detach it. if (Y.Object.size(info.instances) === 0) { info.handle.detach(); } } }); this._unbindUI(boundingBox); boundingBox.remove(TRUE); }, /** * Establishes the initial DOM for the widget. Invoking this * method will lead to the creating of all DOM elements for * the widget (or the manipulation of existing DOM elements * for the progressive enhancement use case). *

    * This method should only be invoked once for an initialized * widget. *

    *

    * It delegates to the widget specific renderer method to do * the actual work. *

    * * @method render * @chainable * @final * @param parentNode {Object | String} Optional. The Node under which the * Widget is to be rendered. This can be a Node instance or a CSS selector string. *

    * If the selector string returns more than one Node, the first node will be used * as the parentNode. NOTE: This argument is required if both the boundingBox and contentBox * are not currently in the document. If it's not provided, the Widget will be rendered * to the body of the current document in this case. *

    */ render: function(parentNode) { if (!this.get(DESTROYED) && !this.get(RENDERED)) { /** * Lifcyle event for the render phase, fired prior to rendering the UI * for the widget (prior to invoking the widget's renderer method). *

    * Subscribers to the "on" moment of this event, will be notified * before the widget is rendered. *

    *

    * Subscribers to the "after" moment of this event, will be notified * after rendering is complete. *

    * * @event widget:render * @preventable _defRenderFn * @param {EventFacade} e The Event Facade */ this.publish(RENDER, { queuable:FALSE, fireOnce:TRUE, defaultTargetOnly:TRUE, defaultFn: this._defRenderFn }); this.fire(RENDER, {parentNode: (parentNode) ? Node.one(parentNode) : null}); } return this; }, /** * Default render handler * * @method _defRenderFn * @protected * @param {EventFacade} e The Event object * @param {Node} parentNode The parent node to render to, if passed in to the render method */ _defRenderFn : function(e) { this._parentNode = e.parentNode; this.renderer(); this._set(RENDERED, TRUE); this._removeLoadingClassNames(); }, /** * Creates DOM (or manipulates DOM for progressive enhancement) * This method is invoked by render() and is not chained * automatically for the class hierarchy (unlike initializer, destructor) * so it should be chained manually for subclasses if required. * * @method renderer * @protected */ renderer: function() { this._renderUI(); this.renderUI(); this._bindUI(); this.bindUI(); this._syncUI(); this.syncUI(); }, /** * Configures/Sets up listeners to bind Widget State to UI/DOM * * This method is not called by framework and is not chained * automatically for the class hierarchy. * * @method bindUI * @protected */ bindUI: EMPTY_FN, /** * Adds nodes to the DOM * * This method is not called by framework and is not chained * automatically for the class hierarchy. * * @method renderUI * @protected */ renderUI: EMPTY_FN, /** * Refreshes the rendered UI, based on Widget State * * This method is not called by framework and is not chained * automatically for the class hierarchy. * * @method syncUI * @protected * */ syncUI: EMPTY_FN, /** * @method hide * @description Hides the Widget by setting the "visible" attribute to "false". * @chainable */ hide: function() { return this.set(VISIBLE, FALSE); }, /** * @method show * @description Shows the Widget by setting the "visible" attribute to "true". * @chainable */ show: function() { return this.set(VISIBLE, TRUE); }, /** * @method focus * @description Causes the Widget to receive the focus by setting the "focused" * attribute to "true". * @chainable */ focus: function () { return this._set(FOCUSED, TRUE); }, /** * @method blur * @description Causes the Widget to lose focus by setting the "focused" attribute * to "false" * @chainable */ blur: function () { return this._set(FOCUSED, FALSE); }, /** * @method enable * @description Set the Widget's "disabled" attribute to "false". * @chainable */ enable: function() { return this.set(DISABLED, FALSE); }, /** * @method disable * @description Set the Widget's "disabled" attribute to "true". * @chainable */ disable: function() { return this.set(DISABLED, TRUE); }, /** * @method _uiSizeCB * @protected * @param {boolean} expand */ _uiSizeCB : function(expand) { var bb = this.get(BOUNDING_BOX), cb = this.get(CONTENT_BOX), bbTempExpanding = _getWidgetClassName("tmp", "forcesize"), borderBoxSupported = this._bbs, heightReallyMinHeight = IE && IE < 7; if (borderBoxSupported) { cb.toggleClass(_getWidgetClassName(CONTENT, "expanded"), expand); } else { if (expand) { if (heightReallyMinHeight) { bb.addClass(bbTempExpanding); } cb.set(OFFSET_HEIGHT, bb.get(OFFSET_HEIGHT)); if (heightReallyMinHeight) { bb.removeClass(bbTempExpanding); } } else { cb.setStyle(HEIGHT, EMPTY_STR); } } }, /** * Helper method to collect the boundingBox and contentBox, set styles and append to the provided parentNode, if not * already a child. The owner document of the boundingBox, or the owner document of the contentBox will be used * as the document into which the Widget is rendered if a parentNode is node is not provided. If both the boundingBox and * the contentBox are not currently in the document, and no parentNode is provided, the widget will be rendered * to the current document's body. * * @method _renderBox * @private * @param {Node} parentNode The parentNode to render the widget to. If not provided, and both the boundingBox and * the contentBox are not currently in the document, the widget will be rendered to the current document's body. */ _renderBox: function(parentNode) { // TODO: Performance Optimization [ More effective algo to reduce Node refs, compares, replaces? ] var contentBox = this.get(CONTENT_BOX), boundingBox = this.get(BOUNDING_BOX), srcNode = this.get(SRC_NODE), defParentNode = this.DEF_PARENT_NODE, doc = (srcNode && srcNode.get(OWNER_DOCUMENT)) || boundingBox.get(OWNER_DOCUMENT) || contentBox.get(OWNER_DOCUMENT); // If srcNode (assume it's always in doc), have contentBox take its place (widget render responsible for re-use of srcNode contents) if (srcNode && !srcNode.compareTo(contentBox) && !contentBox.inDoc(doc)) { srcNode.replace(contentBox); } if (!boundingBox.compareTo(contentBox.get(PARENT_NODE)) && !boundingBox.compareTo(contentBox)) { // If contentBox box is already in the document, have boundingBox box take it's place if (contentBox.inDoc(doc)) { contentBox.replace(boundingBox); } boundingBox.appendChild(contentBox); } parentNode = parentNode || (defParentNode && Node.one(defParentNode)); if (parentNode) { parentNode.appendChild(boundingBox); } else if (!boundingBox.inDoc(doc)) { Node.one(BODY).insert(boundingBox, 0); } this._bbs = !(IE && IE < 8 && doc.compatMode != "BackCompat"); }, /** * Setter for the boundingBox attribute * * @method _setBB * @private * @param Node/String * @return Node */ _setBB: function(node) { return this._setBox(this.get(ID), node, this.BOUNDING_TEMPLATE); }, /** * Setter for the contentBox attribute * * @method _setCB * @private * @param {Node|String} node * @return Node */ _setCB: function(node) { return (this.CONTENT_TEMPLATE === null) ? this.get(BOUNDING_BOX) : this._setBox(null, node, this.CONTENT_TEMPLATE); }, /** * Returns the default value for the contentBox attribute. * * For the Widget class, this will be the srcNode if provided, otherwise null (resulting in * a new contentBox node instance being created) * * @method _defaultCB * @protected */ _defaultCB : function(node) { return this.get(SRC_NODE) || null; }, /** * Helper method to set the bounding/content box, or create it from * the provided template if not found. * * @method _setBox * @private * * @param {String} id The node's id attribute * @param {Node|String} node The node reference * @param {String} template HTML string template for the node * @return {Node} The node */ _setBox : function(id, node, template) { node = Node.one(node) || Node.create(template); if (!node.get(ID)) { node.set(ID, id || Y.guid()); } return node; }, /** * Initializes the UI state for the Widget's bounding/content boxes. * * @method _renderUI * @protected */ _renderUI: function() { this._renderBoxClassNames(); this._renderBox(this._parentNode); }, /** * Applies standard class names to the boundingBox and contentBox * * @method _renderBoxClassNames * @protected */ _renderBoxClassNames : function() { var classes = this._getClasses(), cl, boundingBox = this.get(BOUNDING_BOX), i; boundingBox.addClass(_getWidgetClassName()); // Start from Widget Sub Class for (i = classes.length-3; i >= 0; i--) { cl = classes[i]; boundingBox.addClass(cl.CSS_PREFIX || _getClassName(cl.NAME.toLowerCase())); } // Use instance based name for content box this.get(CONTENT_BOX).addClass(this.getClassName(CONTENT)); }, /** * Removes class names representative of the widget's loading state from * the boundingBox. * * @method _removeLoadingClassNames * @protected */ _removeLoadingClassNames: function () { var boundingBox = this.get(BOUNDING_BOX), contentBox = this.get(CONTENT_BOX); boundingBox.removeClass(_getWidgetClassName(LOADING)); boundingBox.removeClass(this.getClassName(LOADING)); contentBox.removeClass(_getWidgetClassName(LOADING)); contentBox.removeClass(this.getClassName(LOADING)); }, /** * Sets up DOM and CustomEvent listeners for the widget. * * @method _bindUI * @protected */ _bindUI: function() { this._bindAttrUI(this._BIND_UI_ATTRS); this._bindDOM(); }, /** * @method _unbindUI * @protected */ _unbindUI : function(boundingBox) { this._unbindDOM(boundingBox); }, /** * Sets up DOM listeners, on elements rendered by the widget. * * @method _bindDOM * @protected */ _bindDOM : function() { var oDocument = this.get(BOUNDING_BOX).get(OWNER_DOCUMENT); // TODO: Perf Optimization: Use Widget.getByNode delegation, to get by // with just one _onDocFocus subscription per sandbox, instead of one per widget this._hDocFocus = oDocument.on("focus", this._onDocFocus, this); // Fix for Webkit: // Document doesn't receive focus in Webkit when the user mouses // down on it, so the "focused" attribute won't get set to the // correct value. if (WEBKIT) { this._hDocMouseDown = oDocument.on("mousedown", this._onDocMouseDown, this); } }, /** * @method _unbindDOM * @protected */ _unbindDOM : function(boundingBox) { if (this._hDocFocus) { this._hDocFocus.detach(); } if (WEBKIT && this._hDocMouseDown) { this._hDocMouseDown.detach(); } }, /** * Updates the widget UI to reflect the attribute state. * * @method _syncUI * @protected */ _syncUI: function() { this._syncAttrUI(this._SYNC_UI_ATTRS); }, /** * Sets the height on the widget's bounding box element * * @method _uiSetHeight * @protected * @param {String | Number} val */ _uiSetHeight: function(val) { this._uiSetDim(HEIGHT, val); this._uiSizeCB((val !== EMPTY_STR && val !== AUTO)); }, /** * Sets the width on the widget's bounding box element * * @method _uiSetWidth * @protected * @param {String | Number} val */ _uiSetWidth: function(val) { this._uiSetDim(WIDTH, val); }, /** * @method _uiSetDim * @private * @param {String} dim The dimension - "width" or "height" * @param {Number | String} val The value to set */ _uiSetDim: function(dimension, val) { this.get(BOUNDING_BOX).setStyle(dimension, L.isNumber(val) ? val + this.DEF_UNIT : val); }, /** * Sets the visible state for the UI * * @method _uiSetVisible * @protected * @param {boolean} val */ _uiSetVisible: function(val) { this.get(BOUNDING_BOX).toggleClass(this.getClassName(HIDDEN), !val); }, /** * Sets the disabled state for the UI * * @protected * @param {boolean} val */ _uiSetDisabled: function(val) { this.get(BOUNDING_BOX).toggleClass(this.getClassName(DISABLED), val); }, /** * Sets the focused state for the UI * * @protected * @param {boolean} val * @param {string} src String representing the source that triggered an update to * the UI. */ _uiSetFocused: function(val, src) { var boundingBox = this.get(BOUNDING_BOX); boundingBox.toggleClass(this.getClassName(FOCUSED), val); if (src !== UI) { if (val) { boundingBox.focus(); } else { boundingBox.blur(); } } }, /** * Set the tabIndex on the widget's rendered UI * * @method _uiSetTabIndex * @protected * @param Number */ _uiSetTabIndex: function(index) { var boundingBox = this.get(BOUNDING_BOX); if (L.isNumber(index)) { boundingBox.set(TAB_INDEX, index); } else { boundingBox.removeAttribute(TAB_INDEX); } }, /** * @method _onDocMouseDown * @description "mousedown" event handler for the owner document of the * widget's bounding box. * @protected * @param {EventFacade} evt The event facade for the DOM focus event */ _onDocMouseDown: function (evt) { if (this._hasDOMFocus) { this._onDocFocus(evt); } }, /** * DOM focus event handler, used to sync the state of the Widget with the DOM * * @method _onDocFocus * @protected * @param {EventFacade} evt The event facade for the DOM focus event */ _onDocFocus: function (evt) { var bFocused = this.get(BOUNDING_BOX).contains(evt.target); // contains() checks invoking node also this._hasDOMFocus = bFocused; this._set(FOCUSED, bFocused, { src: UI }); }, /** * Generic toString implementation for all widgets. * * @method toString * @return {String} The default string value for the widget [ displays the NAME of the instance, and the unique id ] */ toString: function() { return this.constructor.NAME + "[" + this.get(ID) + "]"; }, /** * Default unit to use for dimension values * * @property DEF_UNIT * @type String */ DEF_UNIT : "px", /** * Default node to render the bounding box to. If not set, * will default to the current document body. * * @property DEF_PARENT_NODE * @type String | Node */ DEF_PARENT_NODE : null, /** * Property defining the markup template for content box. If your Widget doesn't * need the dual boundingBox/contentBox structure, set CONTENT_TEMPLATE to null, * and contentBox and boundingBox will both point to the same Node. * * @property CONTENT_TEMPLATE * @type String */ CONTENT_TEMPLATE : DIV, /** * Property defining the markup template for bounding box. * * @property BOUNDING_TEMPLATE * @type String */ BOUNDING_TEMPLATE : DIV, /** * @method _guid * @protected */ _guid : function() { return Y.guid(); }, /** * @method _validTabIndex * @protected * @param {Number} tabIndex */ _validTabIndex : function (tabIndex) { return (L.isNumber(tabIndex) || L.isNull(tabIndex)); }, /** * Binds after listeners for the list of attributes provided * * @method _bindAttrUI * @private * @param {Array} attrs */ _bindAttrUI : function(attrs) { var i, l = attrs.length; for (i = 0; i < l; i++) { this.after(attrs[i] + CHANGE, this._setAttrUI); } }, /** * Invokes the _uiSet=ATTR NAME> method for the list of attributes provided * * @method _syncAttrUI * @private * @param {Array} attrs */ _syncAttrUI : function(attrs) { var i, l = attrs.length, attr; for (i = 0; i < l; i++) { attr = attrs[i]; this[_UISET + _toInitialCap(attr)](this.get(attr)); } }, /** * @method _setAttrUI * @private * @param {EventFacade} e */ _setAttrUI : function(e) { this[_UISET + _toInitialCap(e.attrName)](e.newVal, e.src); }, /** * The default setter for the strings attribute. Merges partial sets * into the full string set, to allow users to partial sets of strings * * @method _strSetter * @protected * @param {Object} strings * @return {String} The full set of strings to set */ _strSetter : function(strings) { return Y.merge(this.get(STRINGS), strings); }, /** * Helper method to get a specific string value * * @deprecated Used by deprecated WidgetLocale implementations. * @method getString * @param {String} key * @return {String} The string */ getString : function(key) { return this.get(STRINGS)[key]; }, /** * Helper method to get the complete set of strings for the widget * * @deprecated Used by deprecated WidgetLocale implementations. * @method getString * @param {String} key * @return {String} The string */ getStrings : function() { return this.get(STRINGS); }, /** * The list of UI attributes to bind for Widget's _bindUI implementation * * @property _BIND_UI_ATTRS * @type Array * @private */ _BIND_UI_ATTRS : UI_ATTRS, /** * The list of UI attributes to sync for Widget's _syncUI implementation * * @property _SYNC_UI_ATTRS * @type Array * @private */ _SYNC_UI_ATTRS : UI_ATTRS.concat(TAB_INDEX), /** * Map of DOM events that should be fired as Custom Events by the * Widget instance. * * @property UI_EVENTS * @type Object */ UI_EVENTS: Y.Node.DOM_EVENTS, /** * Returns the node on which to bind delegate listeners. * * @method _getUIEventNode * @protected */ _getUIEventNode: function () { return this.get(BOUNDING_BOX); }, /** * Binds a delegated DOM event listener of the specified type to the * Widget's outtermost DOM element to facilitate the firing of a Custom * Event of the same type for the Widget instance. * * @private * @method _createUIEvent * @param type {String} String representing the name of the event */ _createUIEvent: function (type) { var uiEvtNode = this._getUIEventNode(), parentNode = uiEvtNode.get(PARENT_NODE), key = (Y.stamp(parentNode) + type), info = _delegates[key], handle; // For each Node instance: Ensure that there is only one delegated // event listener used to fire Widget UI events. if (!info) { handle = parentNode.delegate(type, function (evt) { var widget = Widget.getByNode(this); // Make the DOM event a property of the custom event // so that developers still have access to it. widget.fire(evt.type, { domEvent: evt }); }, "." + _getWidgetClassName()); _delegates[key] = info = { instances: {}, handle: handle }; } // Register this Widget as using this Node as a delegation container. info.instances[Y.stamp(this)] = 1; }, /** * Determines if the specified event is a UI event. * * @private * @method _isUIEvent * @param type {String} String representing the name of the event * @return {String} Event Returns the name of the UI Event, otherwise * undefined. */ _getUIEvent: function (type) { if (L.isString(type)) { var sType = type.replace(UI_EVENT_REGEX, UI_EVENT_REGEX_REPLACE), returnVal; if (this.UI_EVENTS[sType]) { returnVal = sType; } return returnVal; } }, /** * Sets up infastructure required to fire a UI event. * * @private * @method _initUIEvent * @param type {String} String representing the name of the event * @return {String} */ _initUIEvent: function (type) { var sType = this._getUIEvent(type), queue = this._uiEvtsInitQueue || {}; if (sType && !queue[sType]) { this._uiEvtsInitQueue = queue[sType] = 1; this.after(RENDER, function() { this._createUIEvent(sType); delete this._uiEvtsInitQueue[sType]; }); } }, // Override of "on" from Base to facilitate the firing of Widget events // based on DOM events of the same name/type (e.g. "click", "mouseover"). // Temporary solution until we have the ability to listen to when // someone adds an event listener (bug 2528230) on: function (type) { this._initUIEvent(type); return Widget.superclass.on.apply(this, arguments); }, // Override of "after" from Base to facilitate the firing of Widget events // based on DOM events of the same name/type (e.g. "click", "mouseover"). // Temporary solution until we have the ability to listen to when // someone adds an event listener (bug 2528230) after: function (type) { this._initUIEvent(type); return Widget.superclass.after.apply(this, arguments); }, // Override of "publish" from Base to facilitate the firing of Widget events // based on DOM events of the same name/type (e.g. "click", "mouseover"). // Temporary solution until we have the ability to listen to when // someone publishes an event (bug 2528230) publish: function (type, config) { var sType = this._getUIEvent(type); if (sType && config && config.defaultFn) { this._initUIEvent(sType); } return Widget.superclass.publish.apply(this, arguments); } }); Y.Widget = Widget; }, '3.1.2' ,{requires:['attribute', 'event-focus', 'base', 'node', 'classnamemanager', 'intl']}); YUI.add('widget-htmlparser', function(Y) { /** * Adds HTML Parser support to the base Widget class * * @module widget * @submodule widget-htmlparser * @for Widget */ var Widget = Y.Widget, Node = Y.Node, Lang = Y.Lang, SRC_NODE = "srcNode", CONTENT_BOX = "contentBox"; /** * Object hash, defining how attribute values are to be parsed from * markup contained in the widget's content box. e.g.: * 
     *   {
 *       // Set single Node references using selector syntax 
 *       // (selector is run through node.one)
 *       titleNode: "span.yui-title",
 *       // Set NodeList references using selector syntax 
 *       // (array indicates selector is to be run through node.all)
 *       listNodes: ["li.yui-item"],
 *       // Set other attribute types, using a parse function. 
 *       // Context is set to the widget instance.
 *       label: function(contentBox) {
 *           return contentBox.one("span.title").get("innerHTML");
 *       }
 *   }
 *
    * * @property Widget.HTML_PARSER * @type Object * @static */ Widget.HTML_PARSER = {}; /** * The build configuration for the Widget class. *

    * Defines the static fields which need to be aggregated, * when this class is used as the main class passed to * the Base.build method. *

    * @property _buildCfg * @type Object * @static * @final * @private */ Widget._buildCfg = { aggregates : ["HTML_PARSER"] }; /** * The DOM node to parse for configuration values, passed to the Widget's HTML_PARSER definition * * @attribute srcNode * @type String | Node * @writeOnce */ Widget.ATTRS[SRC_NODE] = { value: null, setter: Node.one, getter: "_getSrcNode", writeOnce: true }; Y.mix(Widget.prototype, { /** * @method _getSrcNode * @protected * @return {Node} The Node to apply HTML_PARSER to */ _getSrcNode : function(val) { return val || this.get(CONTENT_BOX); }, /** * @method _applyParsedConfig * @protected * @return {Object} The merged configuration literal */ _applyParsedConfig : function(node, cfg, parsedCfg) { return (parsedCfg) ? Y.mix(cfg, parsedCfg, false) : cfg; }, /** * Utilitity method used to apply the HTML_PARSER configuration for the * instance, to retrieve config data values. * * @method _applyParser * @protected * @param config {Object} User configuration object (will be populated with values from Node) */ _applyParser : function(config) { var widget = this, srcNode = widget.get(SRC_NODE), schema = widget._getHtmlParser(), parsedConfig, val; if (schema && srcNode) { Y.Object.each(schema, function(v, k, o) { val = null; if (Lang.isFunction(v)) { val = v.call(widget, srcNode); } else { if (Lang.isArray(v)) { val = srcNode.all(v[0]); } else { val = srcNode.one(v); } } if (val !== null && val !== undefined) { parsedConfig = parsedConfig || {}; parsedConfig[k] = val; } }); } config = widget._applyParsedConfig(srcNode, config, parsedConfig); }, /** * Gets the HTML_PARSER definition for this instance, by merging HTML_PARSER * definitions across the class hierarchy. * * @private * @method _getHtmlParser * @return {Object} HTML_PARSER definition for this instance */ _getHtmlParser : function() { // Removed caching for kweight. This is a private method // and only called once so don't need to cache HTML_PARSER var classes = this._getClasses(), parser = {}, i, p; for (i = classes.length - 1; i >= 0; i--) { p = classes[i].HTML_PARSER; if (p) { Y.mix(parser, p, true); } } return parser; } }); }, '3.1.2' ,{requires:['widget-base']}); YUI.add('widget', function(Y){}, '3.1.2' ,{use:['widget-base', 'widget-htmlparser' ]}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('arraylist', function(Y) { /** * Collection utilities beyond what is provided in the YUI core * @module collection * @submodule arraylist */ var YArray = Y.Array, YArray_each = YArray.each, ArrayListProto; /** * Generic ArrayList class for managing lists of items and iterating operations * over them. The targeted use for this class is for augmentation onto a * class that is responsible for managing multiple instances of another class * (e.g. NodeList for Nodes). The recommended use is to augment your class with * ArrayList, then use ArrayList.addMethod to mirror the API of the constituent * items on the list's API. * * The default implementation creates immutable lists, but mutability can be * provided via the arraylist-add submodule or by implementing mutation methods * directly on the augmented class's prototype. * * @class ArrayList * @constructor * @param items { Array } array of items this list will be responsible for */ function ArrayList( items ) { if ( items !== undefined ) { this._items = Y.Lang.isArray( items ) ? items : YArray( items ); } else { // ||= to support lazy initialization from augment this._items = this._items || []; } } ArrayListProto = { /** * Get an item by index from the list. Override this method if managing a * list of objects that have a different public representation (e.g. Node * instances vs DOM nodes). The iteration methods that accept a user * function will use this method for access list items for operation. * * @method item * @param i { Integer } index to fetch * @return { mixed } the item at the requested index */ item: function ( i ) { return this._items[i]; }, /** *

    Execute a function on each item of the list, optionally providing a * custom execution context. Default context is the item.

    * *

    The callback signature is callback( item, index ).

    * * @method each * @param fn { Function } the function to execute * @param context { mixed } optional override 'this' in the function * @return { ArrayList } this instance * @chainable */ each: function ( fn, context ) { YArray_each( this._items, function ( item, i ) { item = this.item( i ); fn.call( context || item, item, i, this ); }, this); return this; }, /** *

    Execute a function on each item of the list, optionally providing a * custom execution context. Default context is the item.

    * *

    The callback signature is callback( item, index ).

    * *

    Unlike each, if the callback returns true, the * iteratation will stop.

    * * @method some * @param fn { Function } the function to execute * @param context { mixed } optional override 'this' in the function * @return { Boolean } True if the function returned true on an item */ some: function ( fn, context ) { return YArray.some( this._items, function ( item, i ) { item = this.item( i ); return fn.call( context || item, item, i, this ); }, this); }, /** * Finds the first index of the needle in the managed array of items. * * @method indexOf * @param needle { mixed } The item to search for * @return { Integer } Array index if found. Otherwise -1 */ indexOf: function ( needle ) { return YArray.indexOf( this._items, needle ); }, /** * How many items are in this list? * * @method size * @return { Integer } Number of items in the list */ size: function () { return this._items.length; }, /** * Is this instance managing any items? * * @method isEmpty * @return { Boolean } true if 1 or more items are being managed */ isEmpty: function () { return !this.size(); } }; // Default implementation does not distinguish between public and private // item getter /** * Protected method for optimizations that may be appropriate for API * mirroring. Similar in functionality to item, but is used by * methods added with ArrayList.addMethod(). * * @method _item * @protected * @param i { Integer } Index of item to fetch * @return { mixed } The item appropriate for pass through API methods */ ArrayListProto._item = ArrayListProto.item; ArrayList.prototype = ArrayListProto; Y.mix( ArrayList, { /** *

    Adds a pass through method to dest (typically the prototype of a list * class) that calls the named method on each item in the list with * whatever parameters are passed in. Allows for API indirection via list * instances.

    * *

    Accepts a single string name or an array of string names.

    * * 
    list.each( function ( item ) {
     *     item.methodName( 1, 2, 3 );
     * } );
     * // becomes
     * list.methodName( 1, 2, 3 );
    * *

    Additionally, the pass through methods use the item retrieved by the * _item method in case there is any special behavior that is * appropriate for API mirroring.

    * * @method addMethod * @static * @param dest { Object } Object or prototype to receive the iterator method * @param name { String | Array } Name of method of methods to create */ addMethod: function ( dest, names ) { names = YArray( names ); YArray_each( names, function ( name ) { dest[ name ] = function () { var args = YArray( arguments, 0, true ), ret = []; YArray_each( this._items, function ( item, i ) { item = this._item( i ); var result = item[ name ].apply( item, args ); if ( result !== undefined && result !== item ) { ret.push( result ); } }, this); return ret.length ? ret : this; }; } ); } } ); Y.ArrayList = ArrayList; }, '3.1.2' ); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('widget-parent', function(Y) { /** * Extension enabling a Widget to be a parent of another Widget. * * @module widget-parent */ var Lang = Y.Lang; /** * Widget extension providing functionality enabling a Widget to be a * parent of another Widget. * * @class WidgetParent * @param {Object} config User configuration object. */ function Parent(config) { /** * Fires when a Widget is add as a child. The event object will have a * 'child' property that returns a reference to the child Widget, as well * as an 'index' property that returns a reference to the index specified * when the add() method was called. *

    * Subscribers to the "on" moment of this event, will be notified * before a child is added. *

    *

    * Subscribers to the "after" moment of this event, will be notified * after a child is added. *

    * * @event addChild * @preventable _defAddChildFn * @param {EventFacade} e The Event Facade */ this.publish("addChild", { defaultTargetOnly: true, defaultFn: this._defAddChildFn }); /** * Fires when a child Widget is removed. The event object will have a * 'child' property that returns a reference to the child Widget, as well * as an 'index' property that returns a reference child's ordinal position. *

    * Subscribers to the "on" moment of this event, will be notified * before a child is removed. *

    *

    * Subscribers to the "after" moment of this event, will be notified * after a child is removed. *

    * * @event removeChild * @preventable _defRemoveChildFn * @param {EventFacade} e The Event Facade */ this.publish("removeChild", { defaultTargetOnly: true, defaultFn: this._defRemoveChildFn }); // TO DO: Document ability to populate children via the constructor this._items = []; var children, handle; if (config && config.children) { children = config.children; handle = this.after("initializedChange", function (e) { this._add(children); handle.detach(); }); } // Widget method overlap Y.after(this._renderChildren, this, "renderUI"); Y.after(this._bindUIParent, this, "bindUI"); Y.before(this._destroyChildren, this, "destructor"); this.after("selectionChange", this._afterSelectionChange); this.after("selectedChange", this._afterParentSelectedChange); this.after("activeDescendantChange", this._afterActiveDescendantChange); this._hDestroyChild = this.after("*:destroy", this._afterDestroyChild); this.after("*:focusedChange", this._updateActiveDescendant); } Parent.ATTRS = { /** * @attribute defaultChildType * @type {String|Object} * * @description String representing the default type of the children * managed by this Widget. Can also supply default type as a constructor * reference. */ defaultChildType: { setter: function (val) { var returnVal = Y.Attribute.INVALID_VALUE, FnConstructor = Lang.isString(val) ? Y[val] : val; if (Lang.isFunction(FnConstructor)) { returnVal = FnConstructor; } return returnVal; } }, /** * @attribute activeDescendant * @type Widget * @readOnly * * @description Returns the Widget's currently focused descendant Widget. */ activeDescendant: { readOnly: true }, /** * @attribute multiple * @type Boolean * @default false * @writeOnce * * @description Boolean indicating if multiple children can be selected at * once. Whether or not multiple selection is enabled is always delegated * to the value of the multiple attribute of the root widget * in the object hierarchy. */ multiple: { value: false, validator: Lang.isBoolean, writeOnce: true, getter: function (value) { var root = this.get("root"); return (root && root != this) ? root.get("multiple") : value; } }, /** * @attribute selection * @type {Y.ArrayList|Widget} * @readOnly * * @description Returns the currently selected child Widget. If the * mulitple attribte is set to true will * return an Y.ArrayList instance containing the currently selected * children. If no children are selected, will return null. */ selection: { readOnly: true, setter: "_setSelection", getter: function (value) { var selection = Lang.isArray(value) ? (new Y.ArrayList(value)) : value; return selection; } }, selected: { setter: function (value) { // Enforces selection behavior on for parent Widgets. Parent's // selected attribute can be set to the following: // 0 - Not selected // 1 - Fully selected (all children are selected). In order for // all children to be selected, multiple selection must be // enabled. Therefore, you cannot set the "selected" attribute // on a parent Widget to 1 unless multiple selection is enabled. // 2 - Partially selected, meaning one ore more (but not all) // children are selected. var returnVal = value; if (value === 1 && !this.get("multiple")) { returnVal = Y.Attribute.INVALID_VALUE; } return returnVal; } } }; Parent.prototype = { /** * Destroy event listener for each child Widget, responsible for removing * the destroyed child Widget from the parent's internal array of children * (_items property). * * @method _afterDestroyChild * @protected * @param {EventFacade} event The event facade for the attribute change. */ _afterDestroyChild: function (event) { var child = event.target; if (child.get("parent") == this) { child.remove(); } }, /** * Attribute change listener for the selection * attribute, responsible for setting the value of the * parent's selected attribute. * * @method _afterSelectionChange * @protected * @param {EventFacade} event The event facade for the attribute change. */ _afterSelectionChange: function (event) { if (event.target == this && event.src != this) { var selection = event.newVal, selectedVal = 0; // Not selected if (selection) { selectedVal = 2; // Assume partially selected, confirm otherwise if ((selection instanceof Y.ArrayList) && (selection.size() === this.size())) { selectedVal = 1; // Fully selected } } this.set("selected", selectedVal, { src: this }); } }, /** * Attribute change listener for the activeDescendant * attribute, responsible for setting the value of the * parent's activeDescendant attribute. * * @method _afterActiveDescendantChange * @protected * @param {EventFacade} event The event facade for the attribute change. */ _afterActiveDescendantChange: function (event) { var parent = this.get("parent"); if (parent) { parent._set("activeDescendant", event.newVal); } }, /** * Attribute change listener for the selected * attribute, responsible for syncing the selected state of all children to * match that of their parent Widget. * * * @method _afterParentSelectedChange * @protected * @param {EventFacade} event The event facade for the attribute change. */ _afterParentSelectedChange: function (event) { var value = event.newVal; if (this == event.target && event.src != this && (value === 0 || value === 1)) { this.each(function (child) { // Specify the source of this change as the parent so that // value of the parent's "selection" attribute isn't // recalculated child.set("selected", value, { src: this }); }, this); } }, /** * Default setter for selection attribute changes. * * @method _setSelection * @protected * @param child {Widget|Array} Widget or Array of Widget instances. * @return {Widget|Array} Widget or Array of Widget instances. */ _setSelection: function (child) { var selection = null, selected; if (this.get("multiple") && !this.isEmpty()) { selected = []; this.each(function (v) { if (v.get("selected") > 0) { selected.push(v); } }); if (selected.length > 0) { selection = selected; } } else { if (child.get("selected") > 0) { selection = child; } } return selection; }, /** * Attribute change listener for the selected * attribute of child Widgets, responsible for setting the value of the * parent's selection attribute. * * @method _updateSelection * @protected * @param {EventFacade} event The event facade for the attribute change. */ _updateSelection: function (event) { var child = event.target, selection; if (child.get("parent") == this) { if (event.src != "_updateSelection") { selection = this.get("selection"); if (!this.get("multiple") && selection && event.newVal > 0) { // Deselect the previously selected child. // Set src equal to the current context to prevent // unnecessary re-calculation of the selection. selection.set("selected", 0, { src: "_updateSelection" }); } this._set("selection", child); } if (event.src == this) { this._set("selection", child, { src: this }); } } }, /** * Attribute change listener for the focused * attribute of child Widgets, responsible for setting the value of the * parent's activeDescendant attribute. * * @method _updateActiveDescendant * @protected * @param {EventFacade} event The event facade for the attribute change. */ _updateActiveDescendant: function (event) { var activeDescendant = (event.newVal === true) ? event.target : null; this._set("activeDescendant", activeDescendant); }, /** * Creates an instance of a child Widget using the specified configuration. * By default Widget instances will be created of the type specified * by the defaultChildType attribute. Types can be explicitly * defined via the type property of the configuration object * literal. * * @method _createChild * @protected * @param config {Object} Object literal representing the configuration * used to create an instance of a Widget. */ _createChild: function (config) { var defaultType = this.get("defaultChildType"), altType = config.type, child, Fn, FnConstructor; if (altType) { Fn = Lang.isString(altType) ? Y[altType] : altType; if (Lang.isFunction(Fn)) { FnConstructor = Fn; } } else if (defaultType) { FnConstructor = defaultType; } if (FnConstructor) { child = new FnConstructor(config); } else { Y.error("Could not create a child instance because its constructor is either undefined or invalid."); } return child; }, /** * Default addChild handler * * @method _defAddChildFn * @protected * @param event {EventFacade} The Event object * @param child {Widget} The Widget instance, or configuration * object for the Widget to be added as a child. * @param index {Number} Number representing the position at * which the child will be inserted. */ _defAddChildFn: function (event) { var child = event.child, index = event.index, children = this._items; if (child.get("parent")) { child.remove(); } if (Lang.isNumber(index)) { children.splice(index, 0, child); } else { children.push(child); } child._set("parent", this); child.addTarget(this); // Update index in case it got normalized after addition // (e.g. user passed in 10, and there are only 3 items, the actual index would be 3. We don't want to pass 10 around in the event facade). event.index = child.get("index"); // TO DO: Remove in favor of using event bubbling child.after("selectedChange", Y.bind(this._updateSelection, this)); }, /** * Default removeChild handler * * @method _defRemoveChildFn * @protected * @param event {EventFacade} The Event object * @param child {Widget} The Widget instance to be removed. * @param index {Number} Number representing the index of the Widget to * be removed. */ _defRemoveChildFn: function (event) { var child = event.child, index = event.index, children = this._items; if (child.get("focused")) { child.set("focused", false); } if (child.get("selected")) { child.set("selected", 0); } children.splice(index, 1); child.removeTarget(this); child._set("parent", null); }, /** * @method _add * @protected * @param child {Widget|Object} The Widget instance, or configuration * object for the Widget to be added as a child. * @param child {Array} Array of Widget instances, or configuration * objects for the Widgets to be added as a children. * @param index {Number} (Optional.) Number representing the position at * which the child should be inserted. * @description Adds a Widget as a child. If the specified Widget already * has a parent it will be removed from its current parent before * being added as a child. * @return {Widget|Array} Successfully added Widget or Array containing the * successfully added Widget instance(s). If no children where added, will * will return undefined. */ _add: function (child, index) { var children, oChild, returnVal; if (Lang.isArray(child)) { children = []; Y.each(child, function (v, k) { oChild = this._add(v, (index + k)); if (oChild) { children.push(oChild); } }, this); if (children.length > 0) { returnVal = children; } } else { if (child instanceof Y.Widget) { oChild = child; } else { oChild = this._createChild(child); } if (oChild && this.fire("addChild", { child: oChild, index: index })) { returnVal = oChild; } } return returnVal; }, /** * @method add * @param child {Widget|Object} The Widget instance, or configuration * object for the Widget to be added as a child. * @param child {Array} Array of Widget instances, or configuration * objects for the Widgets to be added as a children. * @param index {Number} (Optional.) Number representing the position at * which the child should be inserted. * @description Adds a Widget as a child. If the specified Widget already * has a parent it will be removed from its current parent before * being added as a child. * @return {Y.ArrayList} Y.ArrayList containing the successfully added * Widget instance(s). If no children where added, will return an empty * Y.ArrayList instance. */ add: function () { var added = this._add.apply(this, arguments), children = added ? (Lang.isArray(added) ? added : [added]) : []; return (new Y.ArrayList(children)); }, /** * @method remove * @param index {Number} (Optional.) Number representing the index of the * child to be removed. * @description Removes the Widget from its parent. Optionally, can remove * a child by specifying its index. * @return {Widget} Widget instance that was successfully removed, otherwise * undefined. */ remove: function (index) { var child = this._items[index], returnVal; if (child && this.fire("removeChild", { child: child, index: index })) { returnVal = child; } return returnVal; }, /** * @method removeAll * @description Removes all of the children from the Widget. * @return {Y.ArrayList} Y.ArrayList instance containing Widgets that were * successfully removed. If no children where removed, will return an empty * Y.ArrayList instance. */ removeAll: function () { var removed = [], child; Y.each(this._items.concat(), function () { child = this.remove(0); if (child) { removed.push(child); } }, this); return (new Y.ArrayList(removed)); }, /** * Selects the child at the given index (zero-based). * * @method selectChild * @param {Number} i the index of the child to be selected */ selectChild: function(i) { this.item(i).set('selected', 1); }, /** * Selects all children. * * @method selectAll */ selectAll: function () { this.set("selected", 1); }, /** * Deselects all children. * * @method deselectAll */ deselectAll: function () { this.set("selected", 0); }, /** * Updates the UI in response to a child being added. * * @method _uiAddChild * @protected * @param child {Widget} The child Widget instance to render. * @param parentNode {Object} The Node under which the * child Widget is to be rendered. */ _uiAddChild: function (child, parentNode) { child.render(parentNode); // TODO: Ideally this should be in Child's render UI. var childBB = child.get("boundingBox"), siblingBB, nextSibling = child.next(false), prevSibling; // Insert or Append to last child. // Avoiding index, and using the current sibling // state (which should be accurate), means we don't have // to worry about decorator elements which may be added // to the _childContainer node. if (nextSibling) { siblingBB = nextSibling.get("boundingBox"); siblingBB.insert(childBB, "before"); } else { prevSibling = child.previous(false); if (prevSibling) { siblingBB = prevSibling.get("boundingBox"); siblingBB.insert(childBB, "after"); } } }, /** * Updates the UI in response to a child being removed. * * @method _uiRemoveChild * @protected * @param child {Widget} The child Widget instance to render. */ _uiRemoveChild: function (child) { child.get("boundingBox").remove(); }, _afterAddChild: function (event) { var child = event.child; if (child.get("parent") == this) { this._uiAddChild(child, this._childrenContainer); } }, _afterRemoveChild: function (event) { var child = event.child; if (child.get("parent") == this) { this._uiRemoveChild(child); } }, /** * Sets up DOM and CustomEvent listeners for the parent widget. *

    * This method in invoked after bindUI is invoked for the Widget class * using YUI's aop infrastructure. *

    * * @method _bindUIParent * @protected */ _bindUIParent: function () { this.after("addChild", this._afterAddChild); this.after("removeChild", this._afterRemoveChild); }, /** * Renders all child Widgets for the parent. *

    * This method in invoked after renderUI is invoked for the Widget class * using YUI's aop infrastructure. *

    * @method _renderChildren * @protected */ _renderChildren: function () { /** *

    By default WidgetParent will render it's children to the parent's content box.

    * *

    If the children need to be rendered somewhere else, the _childrenContainer property * can be set to the Node which the children should be rendered to. This property should be * set before the _renderChildren method is invoked, ideally in your renderUI method, * as soon as you create the element to be rendered to.

    * * @protected * @property _childrenContainer * @value The content box * @type Node */ var renderTo = this._childrenContainer || this.get("contentBox"); this._childrenContainer = renderTo; this.each(function (child) { child.render(renderTo); }); }, /** * Destroys all child Widgets for the parent. *

    * This method is invoked before the destructor is invoked for the Widget * class using YUI's aop infrastructure. *

    * @method _destroyChildren * @protected */ _destroyChildren: function () { // Detach the handler responsible for removing children in // response to destroying them since: // 1) It is unnecessary/inefficient at this point since we are doing // a batch destroy of all children. // 2) Removing each child will affect our ability to iterate the // children since the size of _items will be changing as we // iterate. this._hDestroyChild.detach(); // Need to clone the _items array since this.each(function (child) { child.destroy(); }); } }; Y.augment(Parent, Y.ArrayList); Y.WidgetParent = Parent; }, '3.1.2' ,{requires:['widget', 'arraylist']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('widget-child', function(Y) { /** * Extension enabling a Widget to be a child of another Widget. * * @module widget-child */ var Lang = Y.Lang; /** * Widget extension providing functionality enabling a Widget to be a * child of another Widget. * * @class WidgetChild * @param {Object} config User configuration object. */ function Child() { // Widget method overlap Y.after(this._syncUIChild, this, "syncUI"); Y.after(this._bindUIChild, this, "bindUI"); } Child.ATTRS = { /** * @attribute selected * @type Number * @default 0 * * @description Number indicating if the Widget is selected. Possible * values are: *
    *
    0
    (Default) Not selected
    *
    1
    Fully selected
    *
    2
    Partially selected
    *
    */ selected: { value: 0, validator: Lang.isNumber }, /** * @attribute index * @type Number * @readOnly * * @description Number representing the Widget's ordinal position in its * parent Widget. */ index: { readOnly: true, getter: function () { var parent = this.get("parent"), index = -1; if (parent) { index = parent.indexOf(this); } return index; } }, /** * @attribute parent * @type Widget * @readOnly * * @description Retrieves the parent of the Widget in the object hierarchy. */ parent: { readOnly: true }, /** * @attribute depth * @type Number * @default -1 * @readOnly * * @description Number representing the depth of this Widget relative to * the root Widget in the object heirarchy. */ depth: { readOnly: true, getter: function () { var parent = this.get("parent"), root = this.get("root"), depth = -1; while (parent) { depth = (depth + 1); if (parent == root) { break; } parent = parent.get("parent"); } return depth; } }, /** * @attribute root * @type Widget * @readOnly * * @description Returns the root Widget in the object hierarchy. If the * ROOT_TYPE property is set, the search for the root Widget will be * constrained to parent Widgets of the specified type. */ root: { readOnly: true, getter: function () { var getParent = function (child) { var parent = child.get("parent"), FnRootType = child.ROOT_TYPE, criteria = parent; if (FnRootType) { criteria = (parent && (parent instanceof FnRootType)); } return (criteria ? getParent(parent) : child); }; return getParent(this); } } }; Child.prototype = { /** * Constructor reference used to determine the root of a Widget-based * object tree. *

    * Currently used to control the behavior of the root * attribute so that recursing up the object heirarchy can be constrained * to a specific type of Widget. Widget authors should set this property * to the constructor function for a given Widget implementation. *

    * * @property ROOT_TYPE * @type Object */ ROOT_TYPE: null, // Override of Widget's implementation of _getUIEventNode() to ensure that // all event listeners are bound to the Widget's topmost DOM element. // This ensures that the firing of each type of Widget UI event (click, // mousedown, etc.) is facilitated by a single, top-level, delegated DOM // event listener. _getUIEventNode: function () { var root = this.get("root"), returnVal; if (root) { returnVal = root.get("boundingBox"); } return returnVal; }, /** * @method next * @description Returns the Widget's next sibling. * @param {Boolean} circular Boolean indicating if the parent's first child * should be returned if the child has no next sibling. * @return {Widget} Widget instance. */ next: function (circular) { var parent = this.get("parent"), sibling; if (parent) { sibling = parent.item((this.get("index")+1)); } if (!sibling && circular) { sibling = parent.item(0); } return sibling; }, /** * @method previous * @description Returns the Widget's previous sibling. * @param {Boolean} circular Boolean indicating if the parent's last child * should be returned if the child has no previous sibling. * @return {Widget} Widget instance. */ previous: function (circular) { var parent = this.get("parent"), index = this.get("index"), sibling; if (parent && index > 0) { sibling = parent.item([(index-1)]); } if (!sibling && circular) { sibling = parent.item((parent.size() - 1)); } return sibling; }, // Override of Y.WidgetParent.remove() // Sugar implementation allowing a child to remove itself from its parent. remove: function (index) { var parent, removed; if (Lang.isNumber(index)) { removed = Y.WidgetParent.prototype.remove.apply(this, arguments); } else { parent = this.get("parent"); if (parent) { removed = parent.remove(this.get("index")); } } return removed; }, /** * @method isRoot * @description Determines if the Widget is the root Widget in the * object hierarchy. * @return {Boolean} Boolean indicating if Widget is the root Widget in the * object hierarchy. */ isRoot: function () { return (this == this.get("root")); }, /** * @method ancestor * @description Returns the Widget instance at the specified depth. * @param {number} depth Number representing the depth of the ancestor. * @return {Widget} Widget instance. */ ancestor: function (depth) { var root = this.get("root"), parent; if (this.get("depth") > depth) { parent = this.get("parent"); while (parent != root && parent.get("depth") > depth) { parent = parent.get("parent"); } } return parent; }, /** * Updates the UI to reflect the selected attribute value. * * @method _uiSetChildSelected * @protected * @param {number} selected The selected value to be reflected in the UI. */ _uiSetChildSelected: function (selected) { var box = this.get("boundingBox"), sClassName = this.getClassName("selected"); if (selected === 0) { box.removeClass(sClassName); } else { box.addClass(sClassName); } }, /** * Default attribute change listener for the selected * attribute, responsible for updating the UI, in response to * attribute changes. * * @method _afterChildSelectedChange * @protected * @param {EventFacade} event The event facade for the attribute change. */ _afterChildSelectedChange: function (event) { this._uiSetChildSelected(event.newVal); }, /** * Synchronizes the UI to match the WidgetChild state. *

    * This method is invoked after bindUI is invoked for the Widget class * using YUI's aop infrastructure. *

    * * @method _syncUIChild * @protected */ _syncUIChild: function () { this._uiSetChildSelected(this.get("selected")); }, /** * Binds event listeners responsible for updating the UI state in response * to WidgetChild related state changes. *

    * This method is invoked after bindUI is invoked for the Widget class * using YUI's aop infrastructure. *

    * @method _bindUIChild * @protected */ _bindUIChild: function () { this.after("selectedChange", this._afterChildSelectedChange); } }; Y.WidgetChild = Child; }, '3.1.2' ,{requires:['widget']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('plugin', function(Y) { /** * Provides the base Plugin class, which plugin developers should extend, when creating custom plugins * * @module plugin */ /** * The base class for all Plugin instances. * * @class Plugin.Base * @extends Base * @param {Object} config Configuration object with property name/value pairs. */ function Plugin(config) { Plugin.superclass.constructor.apply(this, arguments); } /** * Object defining the set of attributes supported by the Plugin.Base class * * @property Plugin.Base.ATTRS * @type Object * @static */ Plugin.ATTRS = { /** * The plugin's host object. * * @attribute host * @writeonce * @type Plugin.Host */ host : { writeOnce: true } }; /** * The string identifying the Plugin.Base class. Plugins extending * Plugin.Base should set their own NAME value. * * @property Plugin.Base.NAME * @type String * @static */ Plugin.NAME = 'plugin'; /** * The name of the property the the plugin will be attached to * when plugged into a Plugin Host. Plugins extending Plugin.Base, * should set their own NS value. * * @property Plugin.NS * @type String * @static */ Plugin.NS = 'plugin'; Y.extend(Plugin, Y.Base, { /** * The list of event handles for event listeners or AOP injected methods * applied by the plugin to the host object. * * @property _handles * @private * @type Array * @value null */ _handles: null, /** * Initializer lifecycle implementation. * * @method initializer * @param {Object} config Configuration object with property name/value pairs. */ initializer : function(config) { this._handles = []; }, /** * Destructor lifecycle implementation. * * Removes any event listeners or injected methods applied by the Plugin * * @method destructor */ destructor: function() { // remove all handles if (this._handles) { for (var i = 0, l = this._handles.length; i < l; i++) { this._handles[i].detach(); } } }, /** * Listens for the "on" moment of events fired by the host, * or injects code "before" a given method on the host. * * @method doBefore * * @param strMethod {String} The event to listen for, or method to inject logic before. * @param fn {Function} The handler function. For events, the "on" moment listener. For methods, the function to execute before the given method is executed. * @param context {Object} An optional context to call the handler with. The default context is the plugin instance. * @return handle {EventHandle} The detach handle for the handler. */ doBefore: function(strMethod, fn, context) { var host = this.get("host"), handle; if (strMethod in host) { // method handle = this.beforeHostMethod(strMethod, fn, context); } else if (host.on) { // event handle = this.onHostEvent(strMethod, fn, context); } return handle; }, /** * Listens for the "after" moment of events fired by the host, * or injects code "after" a given method on the host. * * @method doAfter * * @param strMethod {String} The event to listen for, or method to inject logic after. * @param fn {Function} The handler function. For events, the "after" moment listener. For methods, the function to execute after the given method is executed. * @param context {Object} An optional context to call the handler with. The default context is the plugin instance. * @return handle {EventHandle} The detach handle for the listener. */ doAfter: function(strMethod, fn, context) { var host = this.get("host"), handle; if (strMethod in host) { // method handle = this.afterHostMethod(strMethod, fn, context); } else if (host.after) { // event handle = this.afterHostEvent(strMethod, fn, context); } return handle; }, /** * Listens for the "on" moment of events fired by the host object. * * Listeners attached through this method will be detached when the plugin is unplugged. * * @method onHostEvent * @param {String | Object} type The event type. * @param {Function} fn The listener. * @param {Object} context The execution context. Defaults to the plugin instance. * @return handle {EventHandle} The detach handle for the listener. */ onHostEvent : function(type, fn, context) { var handle = this.get("host").after(type, fn, context || this); this._handles.push(handle); return handle; }, /** * Listens for the "after" moment of events fired by the host object. * * Listeners attached through this method will be detached when the plugin is unplugged. * * @method afterHostEvent * @param {String | Object} type The event type. * @param {Function} fn The listener. * @param {Object} context The execution context. Defaults to the plugin instance. * @return handle {EventHandle} The detach handle for the listener. */ afterHostEvent : function(type, fn, context) { var handle = this.get("host").after(type, fn, context || this); this._handles.push(handle); return handle; }, /** * Injects a function to be executed before a given method on host object. * * The function will be detached when the plugin is unplugged. * * @method beforeHostMethod * @param {String} The name of the method to inject the function before. * @param {Function} fn The function to inject. * @param {Object} context The execution context. Defaults to the plugin instance. * @return handle {EventHandle} The detach handle for the injected function. */ beforeHostMethod : function(strMethod, fn, context) { var handle = Y.Do.before(fn, this.get("host"), strMethod, context || this); this._handles.push(handle); return handle; }, /** * Injects a function to be executed after a given method on host object. * * The function will be detached when the plugin is unplugged. * * @method afterHostMethod * @param {String} The name of the method to inject the function after. * @param {Function} fn The function to inject. * @param {Object} context The execution context. Defaults to the plugin instance. * @return handle {EventHandle} The detach handle for the injected function. */ afterHostMethod : function(strMethod, fn, context) { var handle = Y.Do.after(fn, this.get("host"), strMethod, context || this); this._handles.push(handle); return handle; }, toString: function() { return this.constructor.NAME + '[' + this.constructor.NS + ']'; } }); Y.namespace("Plugin").Base = Plugin; }, '3.1.2' ,{requires:['base-base']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('event-simulate', function(Y) { (function() { /** * Synthetic DOM events * @module event-simulate * @requires event */ //shortcuts var L = Y.Lang, array = Y.Array, isFunction = L.isFunction, isString = L.isString, isBoolean = L.isBoolean, isObject = L.isObject, isNumber = L.isNumber, doc = Y.config.doc, //mouse events supported mouseEvents = { click: 1, dblclick: 1, mouseover: 1, mouseout: 1, mousedown: 1, mouseup: 1, mousemove: 1 }, //key events supported keyEvents = { keydown: 1, keyup: 1, keypress: 1 }, //HTML events supported uiEvents = { blur: 1, change: 1, focus: 1, resize: 1, scroll: 1, select: 1 }, //events that bubble by default bubbleEvents = { scroll: 1, resize: 1, reset: 1, submit: 1, change: 1, select: 1, error: 1, abort: 1 }; //all key and mouse events bubble Y.mix(bubbleEvents, mouseEvents); Y.mix(bubbleEvents, keyEvents); /* * Note: Intentionally not for YUIDoc generation. * Simulates a key event using the given event information to populate * the generated event object. This method does browser-equalizing * calculations to account for differences in the DOM and IE event models * as well as different browser quirks. Note: keydown causes Safari 2.x to * crash. * @method simulateKeyEvent * @private * @static * @param {HTMLElement} target The target of the given event. * @param {String} type The type of event to fire. This can be any one of * the following: keyup, keydown, and keypress. * @param {Boolean} bubbles (Optional) Indicates if the event can be * bubbled up. DOM Level 3 specifies that all key events bubble by * default. The default is true. * @param {Boolean} cancelable (Optional) Indicates if the event can be * canceled using preventDefault(). DOM Level 3 specifies that all * key events can be cancelled. The default * is true. * @param {Window} view (Optional) The view containing the target. This is * typically the window object. The default is window. * @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys * is pressed while the event is firing. The default is false. * @param {Boolean} altKey (Optional) Indicates if one of the ALT keys * is pressed while the event is firing. The default is false. * @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys * is pressed while the event is firing. The default is false. * @param {Boolean} metaKey (Optional) Indicates if one of the META keys * is pressed while the event is firing. The default is false. * @param {int} keyCode (Optional) The code for the key that is in use. * The default is 0. * @param {int} charCode (Optional) The Unicode code for the character * associated with the key being used. The default is 0. */ function simulateKeyEvent(target /*:HTMLElement*/, type /*:String*/, bubbles /*:Boolean*/, cancelable /*:Boolean*/, view /*:Window*/, ctrlKey /*:Boolean*/, altKey /*:Boolean*/, shiftKey /*:Boolean*/, metaKey /*:Boolean*/, keyCode /*:int*/, charCode /*:int*/) /*:Void*/ { //check target if (!target){ Y.error("simulateKeyEvent(): Invalid target."); } //check event type if (isString(type)){ type = type.toLowerCase(); switch(type){ case "textevent": //DOM Level 3 type = "keypress"; break; case "keyup": case "keydown": case "keypress": break; default: Y.error("simulateKeyEvent(): Event type '" + type + "' not supported."); } } else { Y.error("simulateKeyEvent(): Event type must be a string."); } //setup default values if (!isBoolean(bubbles)){ bubbles = true; //all key events bubble } if (!isBoolean(cancelable)){ cancelable = true; //all key events can be cancelled } if (!isObject(view)){ view = window; //view is typically window } if (!isBoolean(ctrlKey)){ ctrlKey = false; } if (!isBoolean(altKey)){ altKey = false; } if (!isBoolean(shiftKey)){ shiftKey = false; } if (!isBoolean(metaKey)){ metaKey = false; } if (!isNumber(keyCode)){ keyCode = 0; } if (!isNumber(charCode)){ charCode = 0; } //try to create a mouse event var customEvent /*:MouseEvent*/ = null; //check for DOM-compliant browsers first if (isFunction(doc.createEvent)){ try { //try to create key event customEvent = doc.createEvent("KeyEvents"); /* * Interesting problem: Firefox implemented a non-standard * version of initKeyEvent() based on DOM Level 2 specs. * Key event was removed from DOM Level 2 and re-introduced * in DOM Level 3 with a different interface. Firefox is the * only browser with any implementation of Key Events, so for * now, assume it's Firefox if the above line doesn't error. */ // @TODO: Decipher between Firefox's implementation and a correct one. customEvent.initKeyEvent(type, bubbles, cancelable, view, ctrlKey, altKey, shiftKey, metaKey, keyCode, charCode); } catch (ex /*:Error*/){ /* * If it got here, that means key events aren't officially supported. * Safari/WebKit is a real problem now. WebKit 522 won't let you * set keyCode, charCode, or other properties if you use a * UIEvent, so we first must try to create a generic event. The * fun part is that this will throw an error on Safari 2.x. The * end result is that we need another try...catch statement just to * deal with this mess. */ try { //try to create generic event - will fail in Safari 2.x customEvent = doc.createEvent("Events"); } catch (uierror /*:Error*/){ //the above failed, so create a UIEvent for Safari 2.x customEvent = doc.createEvent("UIEvents"); } finally { customEvent.initEvent(type, bubbles, cancelable); //initialize customEvent.view = view; customEvent.altKey = altKey; customEvent.ctrlKey = ctrlKey; customEvent.shiftKey = shiftKey; customEvent.metaKey = metaKey; customEvent.keyCode = keyCode; customEvent.charCode = charCode; } } //fire the event target.dispatchEvent(customEvent); } else if (isObject(doc.createEventObject)){ //IE //create an IE event object customEvent = doc.createEventObject(); //assign available properties customEvent.bubbles = bubbles; customEvent.cancelable = cancelable; customEvent.view = view; customEvent.ctrlKey = ctrlKey; customEvent.altKey = altKey; customEvent.shiftKey = shiftKey; customEvent.metaKey = metaKey; /* * IE doesn't support charCode explicitly. CharCode should * take precedence over any keyCode value for accurate * representation. */ customEvent.keyCode = (charCode > 0) ? charCode : keyCode; //fire the event target.fireEvent("on" + type, customEvent); } else { Y.error("simulateKeyEvent(): No event simulation framework present."); } } /* * Note: Intentionally not for YUIDoc generation. * Simulates a mouse event using the given event information to populate * the generated event object. This method does browser-equalizing * calculations to account for differences in the DOM and IE event models * as well as different browser quirks. * @method simulateMouseEvent * @private * @static * @param {HTMLElement} target The target of the given event. * @param {String} type The type of event to fire. This can be any one of * the following: click, dblclick, mousedown, mouseup, mouseout, * mouseover, and mousemove. * @param {Boolean} bubbles (Optional) Indicates if the event can be * bubbled up. DOM Level 2 specifies that all mouse events bubble by * default. The default is true. * @param {Boolean} cancelable (Optional) Indicates if the event can be * canceled using preventDefault(). DOM Level 2 specifies that all * mouse events except mousemove can be cancelled. The default * is true for all events except mousemove, for which the default * is false. * @param {Window} view (Optional) The view containing the target. This is * typically the window object. The default is window. * @param {int} detail (Optional) The number of times the mouse button has * been used. The default value is 1. * @param {int} screenX (Optional) The x-coordinate on the screen at which * point the event occured. The default is 0. * @param {int} screenY (Optional) The y-coordinate on the screen at which * point the event occured. The default is 0. * @param {int} clientX (Optional) The x-coordinate on the client at which * point the event occured. The default is 0. * @param {int} clientY (Optional) The y-coordinate on the client at which * point the event occured. The default is 0. * @param {Boolean} ctrlKey (Optional) Indicates if one of the CTRL keys * is pressed while the event is firing. The default is false. * @param {Boolean} altKey (Optional) Indicates if one of the ALT keys * is pressed while the event is firing. The default is false. * @param {Boolean} shiftKey (Optional) Indicates if one of the SHIFT keys * is pressed while the event is firing. The default is false. * @param {Boolean} metaKey (Optional) Indicates if one of the META keys * is pressed while the event is firing. The default is false. * @param {int} button (Optional) The button being pressed while the event * is executing. The value should be 0 for the primary mouse button * (typically the left button), 1 for the terciary mouse button * (typically the middle button), and 2 for the secondary mouse button * (typically the right button). The default is 0. * @param {HTMLElement} relatedTarget (Optional) For mouseout events, * this is the element that the mouse has moved to. For mouseover * events, this is the element that the mouse has moved from. This * argument is ignored for all other events. The default is null. */ function simulateMouseEvent(target /*:HTMLElement*/, type /*:String*/, bubbles /*:Boolean*/, cancelable /*:Boolean*/, view /*:Window*/, detail /*:int*/, screenX /*:int*/, screenY /*:int*/, clientX /*:int*/, clientY /*:int*/, ctrlKey /*:Boolean*/, altKey /*:Boolean*/, shiftKey /*:Boolean*/, metaKey /*:Boolean*/, button /*:int*/, relatedTarget /*:HTMLElement*/) /*:Void*/ { //check target if (!target){ Y.error("simulateMouseEvent(): Invalid target."); } //check event type if (isString(type)){ type = type.toLowerCase(); //make sure it's a supported mouse event if (!mouseEvents[type]){ Y.error("simulateMouseEvent(): Event type '" + type + "' not supported."); } } else { Y.error("simulateMouseEvent(): Event type must be a string."); } //setup default values if (!isBoolean(bubbles)){ bubbles = true; //all mouse events bubble } if (!isBoolean(cancelable)){ cancelable = (type != "mousemove"); //mousemove is the only one that can't be cancelled } if (!isObject(view)){ view = window; //view is typically window } if (!isNumber(detail)){ detail = 1; //number of mouse clicks must be at least one } if (!isNumber(screenX)){ screenX = 0; } if (!isNumber(screenY)){ screenY = 0; } if (!isNumber(clientX)){ clientX = 0; } if (!isNumber(clientY)){ clientY = 0; } if (!isBoolean(ctrlKey)){ ctrlKey = false; } if (!isBoolean(altKey)){ altKey = false; } if (!isBoolean(shiftKey)){ shiftKey = false; } if (!isBoolean(metaKey)){ metaKey = false; } if (!isNumber(button)){ button = 0; } //try to create a mouse event var customEvent /*:MouseEvent*/ = null; //check for DOM-compliant browsers first if (isFunction(doc.createEvent)){ customEvent = doc.createEvent("MouseEvents"); //Safari 2.x (WebKit 418) still doesn't implement initMouseEvent() if (customEvent.initMouseEvent){ customEvent.initMouseEvent(type, bubbles, cancelable, view, detail, screenX, screenY, clientX, clientY, ctrlKey, altKey, shiftKey, metaKey, button, relatedTarget); } else { //Safari //the closest thing available in Safari 2.x is UIEvents customEvent = doc.createEvent("UIEvents"); customEvent.initEvent(type, bubbles, cancelable); customEvent.view = view; customEvent.detail = detail; customEvent.screenX = screenX; customEvent.screenY = screenY; customEvent.clientX = clientX; customEvent.clientY = clientY; customEvent.ctrlKey = ctrlKey; customEvent.altKey = altKey; customEvent.metaKey = metaKey; customEvent.shiftKey = shiftKey; customEvent.button = button; customEvent.relatedTarget = relatedTarget; } /* * Check to see if relatedTarget has been assigned. Firefox * versions less than 2.0 don't allow it to be assigned via * initMouseEvent() and the property is readonly after event * creation, so in order to keep YAHOO.util.getRelatedTarget() * working, assign to the IE proprietary toElement property * for mouseout event and fromElement property for mouseover * event. */ if (relatedTarget && !customEvent.relatedTarget){ if (type == "mouseout"){ customEvent.toElement = relatedTarget; } else if (type == "mouseover"){ customEvent.fromElement = relatedTarget; } } //fire the event target.dispatchEvent(customEvent); } else if (isObject(doc.createEventObject)){ //IE //create an IE event object customEvent = doc.createEventObject(); //assign available properties customEvent.bubbles = bubbles; customEvent.cancelable = cancelable; customEvent.view = view; customEvent.detail = detail; customEvent.screenX = screenX; customEvent.screenY = screenY; customEvent.clientX = clientX; customEvent.clientY = clientY; customEvent.ctrlKey = ctrlKey; customEvent.altKey = altKey; customEvent.metaKey = metaKey; customEvent.shiftKey = shiftKey; //fix button property for IE's wacky implementation switch(button){ case 0: customEvent.button = 1; break; case 1: customEvent.button = 4; break; case 2: //leave as is break; default: customEvent.button = 0; } /* * Have to use relatedTarget because IE won't allow assignment * to toElement or fromElement on generic events. This keeps * YAHOO.util.customEvent.getRelatedTarget() functional. */ customEvent.relatedTarget = relatedTarget; //fire the event target.fireEvent("on" + type, customEvent); } else { Y.error("simulateMouseEvent(): No event simulation framework present."); } } /* * Note: Intentionally not for YUIDoc generation. * Simulates a UI event using the given event information to populate * the generated event object. This method does browser-equalizing * calculations to account for differences in the DOM and IE event models * as well as different browser quirks. * @method simulateHTMLEvent * @private * @static * @param {HTMLElement} target The target of the given event. * @param {String} type The type of event to fire. This can be any one of * the following: click, dblclick, mousedown, mouseup, mouseout, * mouseover, and mousemove. * @param {Boolean} bubbles (Optional) Indicates if the event can be * bubbled up. DOM Level 2 specifies that all mouse events bubble by * default. The default is true. * @param {Boolean} cancelable (Optional) Indicates if the event can be * canceled using preventDefault(). DOM Level 2 specifies that all * mouse events except mousemove can be cancelled. The default * is true for all events except mousemove, for which the default * is false. * @param {Window} view (Optional) The view containing the target. This is * typically the window object. The default is window. * @param {int} detail (Optional) The number of times the mouse button has * been used. The default value is 1. */ function simulateUIEvent(target /*:HTMLElement*/, type /*:String*/, bubbles /*:Boolean*/, cancelable /*:Boolean*/, view /*:Window*/, detail /*:int*/) /*:Void*/ { //check target if (!target){ Y.error("simulateUIEvent(): Invalid target."); } //check event type if (isString(type)){ type = type.toLowerCase(); //make sure it's a supported mouse event if (!uiEvents[type]){ Y.error("simulateUIEvent(): Event type '" + type + "' not supported."); } } else { Y.error("simulateUIEvent(): Event type must be a string."); } //try to create a mouse event var customEvent = null; //setup default values if (!isBoolean(bubbles)){ bubbles = (type in bubbleEvents); //not all events bubble } if (!isBoolean(cancelable)){ cancelable = (type == "submit"); //submit is the only one that can be cancelled } if (!isObject(view)){ view = window; //view is typically window } if (!isNumber(detail)){ detail = 1; //usually not used but defaulted to this } //check for DOM-compliant browsers first if (isFunction(doc.createEvent)){ //just a generic UI Event object is needed customEvent = doc.createEvent("UIEvents"); customEvent.initUIEvent(type, bubbles, cancelable, view, detail); //fire the event target.dispatchEvent(customEvent); } else if (isObject(doc.createEventObject)){ //IE //create an IE event object customEvent = doc.createEventObject(); //assign available properties customEvent.bubbles = bubbles; customEvent.cancelable = cancelable; customEvent.view = view; customEvent.detail = detail; //fire the event target.fireEvent("on" + type, customEvent); } else { Y.error("simulateUIEvent(): No event simulation framework present."); } } /** * Simulates the event with the given name on a target. * @param {HTMLElement} target The DOM element that's the target of the event. * @param {String} type The type of event to simulate (i.e., "click"). * @param {Object} options (Optional) Extra options to copy onto the event object. * @return {void} * @method simulate * @static */ Y.Event.simulate = function(target, type, options){ options = options || {}; if (mouseEvents[type]){ simulateMouseEvent(target, type, options.bubbles, options.cancelable, options.view, options.detail, options.screenX, options.screenY, options.clientX, options.clientY, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.button, options.relatedTarget); } else if (keyEvents[type]){ simulateKeyEvent(target, type, options.bubbles, options.cancelable, options.view, options.ctrlKey, options.altKey, options.shiftKey, options.metaKey, options.keyCode, options.charCode); } else if (uiEvents[type]){ simulateUIEvent(target, type, options.bubbles, options.cancelable, options.view, options.detail); } else { Y.error("simulate(): Event '" + type + "' can't be simulated."); } }; })(); }, '3.1.2' ,{requires:['event-base']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('node-event-simulate', function(Y) { /* * Functionality to simulate events. * @module node * @for Node * @submodule node-event-simulate */ /** * Simulates an event on the node. * @param {String} type The type of event to simulate (i.e., "click"). * @param {Object} options (Optional) Extra options to copy onto the event object. * @return {void} * @method simulate * @static */ Y.Node.prototype.simulate = function(type, options) { Y.Event.simulate(Y.Node.getDOMNode(this), type, options); }; }, '3.1.2' ,{requires:['node-base', 'event-simulate']}); /* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.1.2 build: 56 */ YUI.add('node-focusmanager', function(Y) { /** *

    The Focus Manager Node Plugin makes it easy to manage focus among * a Node's descendants. Primarily intended to help with widget development, * the Focus Manager Node Plugin can be used to improve the keyboard * accessibility of widgets.

    * *

    * When designing widgets that manage a set of descendant controls (i.e. buttons * in a toolbar, tabs in a tablist, menuitems in a menu, etc.) it is important to * limit the number of descendants in the browser's default tab flow. The fewer * number of descendants in the default tab flow, the easier it is for keyboard * users to navigate between widgets by pressing the tab key. When a widget has * focus it should provide a set of shortcut keys (typically the arrow keys) * to move focus among its descendants. *

    * *

    * To this end, the Focus Manager Node Plugin makes it easy to define a Node's * focusable descendants, define which descendant should be in the default tab * flow, and define the keys that move focus among each descendant. * Additionally, as the CSS * :focus * pseudo class is not supported on all elements in all * A-Grade browsers, * the Focus Manager Node Plugin provides an easy, cross-browser means of * styling focus. *

    * * @module node-focusmanager */ // Frequently used strings var ACTIVE_DESCENDANT = "activeDescendant", ID = "id", DISABLED = "disabled", TAB_INDEX = "tabIndex", FOCUSED = "focused", FOCUS_CLASS = "focusClass", CIRCULAR = "circular", UI = "UI", KEY = "key", ACTIVE_DESCENDANT_CHANGE = ACTIVE_DESCENDANT + "Change", HOST = "host", // Collection of keys that, when pressed, cause the browser viewport // to scroll. scrollKeys = { 37: true, 38: true, 39: true, 40: true }, clickableElements = { "a": true, "button": true, "input": true, "object": true }, // Library shortcuts Lang = Y.Lang, UA = Y.UA, /** * The NodeFocusManager class is a plugin for a Node instance. The class is used * via the plug method of Node * and should not be instantiated directly. * @namespace plugin * @class NodeFocusManager */ NodeFocusManager = function () { NodeFocusManager.superclass.constructor.apply(this, arguments); }; NodeFocusManager.ATTRS = { /** * Boolean indicating that one of the descendants is focused. * * @attribute focused * @readOnly * @default false * @type boolean */ focused: { value: false, readOnly: true }, /** * String representing the CSS selector used to define the descendant Nodes * whose focus should be managed. * * @attribute descendants * @type Y.NodeList */ descendants: { getter: function (value) { return this.get(HOST).all(value); } }, /** *

    Node, or index of the Node, representing the descendant that is either * focused or is focusable (tabIndex attribute is set to 0). * The value cannot represent a disabled descendant Node. Use a value of -1 * to remove all descendant Nodes from the default tab flow. * If no value is specified, the active descendant will be inferred using * the following criteria:

    *
      *
    1. Examining the tabIndex attribute of each descendant and * using the first descendant whose tabIndex attribute is set * to 0
      2. *
    2. If no default can be inferred then the value is set to either 0 or * the index of the first enabled descendant.
      3. *
    * * @attribute activeDescendant * @type Number */ activeDescendant: { setter: function (value) { var isNumber = Lang.isNumber, INVALID_VALUE = Y.Attribute.INVALID_VALUE, descendantsMap = this._descendantsMap, descendants = this._descendants, nodeIndex, returnValue, oNode; if (isNumber(value)) { nodeIndex = value; returnValue = nodeIndex; } else if ((value instanceof Y.Node) && descendantsMap) { nodeIndex = descendantsMap[value.get(ID)]; if (isNumber(nodeIndex)) { returnValue = nodeIndex; } else { // The user passed a reference to a Node that wasn't one // of the descendants. returnValue = INVALID_VALUE; } } else { returnValue = INVALID_VALUE; } if (descendants) { oNode = descendants.item(nodeIndex); if (oNode && oNode.get("disabled")) { // Setting the "activeDescendant" attribute to the index // of a disabled descendant is invalid. returnValue = INVALID_VALUE; } } return returnValue; } }, /** * Object literal representing the keys to be used to navigate between the * next/previous descendant. The format for the attribute's value is * { next: "down:40", previous: "down:38" }. The value for the * "next" and "previous" properties are used to attach * key event listeners. See * the Using the key Event section of * the Event documentation for more information on "key" event listeners. * * @attribute keys * @type Object */ keys: { value: { next: null, previous: null } }, /** * String representing the name of class applied to the focused active * descendant Node. Can also be an object literal used to define both the * class name, and the Node to which the class should be applied. If using * an object literal, the format is: * { className: "focus", fn: myFunction }. The function * referenced by the fn property in the object literal will be * passed a reference to the currently focused active descendant Node. * * @attribute focusClass * @type String|Object */ focusClass: { }, /** * Boolean indicating if focus should be set to the first/last descendant * when the end or beginning of the descendants has been reached. * * @attribute circular * @type Boolean */ circular: { value: true } }; Y.extend(NodeFocusManager, Y.Plugin.Base, { // Protected properties // Boolean indicating if the NodeFocusManager is active. _stopped: true, // NodeList representing the descendants selected via the // "descendants" attribute. _descendants: null, // Object literal mapping the IDs of each descendant to its index in the // "_descendants" NodeList. _descendantsMap: null, // Reference to the Node instance to which the focused class (defined // by the "focusClass" attribute) is currently applied. _focusedNode: null, // Number representing the index of the last descendant Node. _lastNodeIndex: 0, // Array of handles for event handlers used for a NodeFocusManager instance. _eventHandlers: null, // Protected methods /** * @method _initDescendants * @description Sets the tabIndex attribute of all of the * descendants to -1, except the active descendant, whose * tabIndex attribute is set to 0. * @protected */ _initDescendants: function () { var descendants = this.get("descendants"), descendantsMap = {}, nFirstEnabled = -1, nDescendants, nActiveDescendant = this.get(ACTIVE_DESCENDANT), oNode, sID, i = 0; if (Lang.isUndefined(nActiveDescendant)) { nActiveDescendant = -1; } if (descendants) { nDescendants = descendants.size(); for (i = 0; i < nDescendants; i++) { oNode = descendants.item(i); if (nFirstEnabled === -1 && !oNode.get(DISABLED)) { nFirstEnabled = i; } // If the user didn't specify a value for the // "activeDescendant" attribute try to infer it from // the markup. // Need to pass "2" when using "getAttribute" for IE to get // the attribute value as it is set in the markup. // Need to use "parseInt" because IE always returns the // value as a number, whereas all other browsers return // the attribute as a string when accessed // via "getAttribute". if (nActiveDescendant < 0 && parseInt(oNode.getAttribute(TAB_INDEX, 2), 10) === 0) { nActiveDescendant = i; } if (oNode) { oNode.set(TAB_INDEX, -1); } sID = oNode.get(ID); if (!sID) { sID = Y.guid(); oNode.set(ID, sID); } descendantsMap[sID] = i; } // If the user didn't specify a value for the // "activeDescendant" attribute and no default value could be // determined from the markup, then default to 0. if (nActiveDescendant < 0) { nActiveDescendant = 0; } oNode = descendants.item(nActiveDescendant); // Check to make sure the active descendant isn't disabled, // and fall back to the first enabled descendant if it is. if (!oNode || oNode.get(DISABLED)) { oNode = descendants.item(nFirstEnabled); nActiveDescendant = nFirstEnabled; } this._lastNodeIndex = nDescendants - 1; this._descendants = descendants; this._descendantsMap = descendantsMap; this.set(ACTIVE_DESCENDANT, nActiveDescendant); // Need to set the "tabIndex" attribute here, since the // "activeDescendantChange" event handler used to manage // the setting of the "tabIndex" attribute isn't wired up yet. if (oNode) { oNode.set(TAB_INDEX, 0); } } }, /** * @method _isDescendant * @description Determines if the specified Node instance is a descendant * managed by the Focus Manager. * @param node {Node} Node instance to be checked. * @return {Boolean} Boolean indicating if the specified Node instance is a * descendant managed by the Focus Manager. * @protected */ _isDescendant: function (node) { return (node.get(ID) in this._descendantsMap); }, /** * @method _removeFocusClass * @description Removes the class name representing focus (as specified by * the "focusClass" attribute) from the Node instance to which it is * currently applied. * @protected */ _removeFocusClass: function () { var oFocusedNode = this._focusedNode, focusClass = this.get(FOCUS_CLASS), sClassName; if (focusClass) { sClassName = Lang.isString(focusClass) ? focusClass : focusClass.className; } if (oFocusedNode && sClassName) { oFocusedNode.removeClass(sClassName); } }, /** * @method _detachKeyHandler * @description Detaches the "key" event handlers used to support the "keys" * attribute. * @protected */ _detachKeyHandler: function () { var prevKeyHandler = this._prevKeyHandler, nextKeyHandler = this._nextKeyHandler; if (prevKeyHandler) { prevKeyHandler.detach(); } if (nextKeyHandler) { nextKeyHandler.detach(); } }, /** * @method _preventScroll * @description Prevents the viewport from scolling when the user presses * the up, down, left, or right key. * @protected */ _preventScroll: function (event) { if (scrollKeys[event.keyCode]) { event.preventDefault(); } }, /** * @method _preventScroll * @description Fires the click event if the enter key is pressed while * focused on an HTML element that is not natively clickable. * @protected */ _fireClick: function (event) { var oTarget = event.target, sNodeName = oTarget.get("nodeName").toLowerCase(); if (event.keyCode === 13 && (!clickableElements[sNodeName] || (sNodeName === "a" && !oTarget.getAttribute("href")))) { oTarget.simulate("click"); } }, /** * @method _attachKeyHandler * @description Attaches the "key" event handlers used to support the "keys" * attribute. * @protected */ _attachKeyHandler: function () { this._detachKeyHandler(); var sNextKey = this.get("keys.next"), sPrevKey = this.get("keys.previous"), oNode = this.get(HOST), aHandlers = this._eventHandlers; if (sPrevKey) { this._prevKeyHandler = Y.on(KEY, Y.bind(this._focusPrevious, this), oNode, sPrevKey); } if (sNextKey) { this._nextKeyHandler = Y.on(KEY, Y.bind(this._focusNext, this), oNode, sNextKey); } // In Opera it is necessary to call the "preventDefault" method in // response to the user pressing the arrow keys in order to prevent // the viewport from scrolling when the user is moving focus among // the focusable descendants. if (UA.opera) { aHandlers.push(oNode.on("keypress", this._preventScroll, this)); } // For all browsers except Opera: HTML elements that are not natively // focusable but made focusable via the tabIndex attribute don't // fire a click event when the user presses the enter key. It is // possible to work around this problem by simplying dispatching a // click event in response to the user pressing the enter key. if (!UA.opera) { aHandlers.push(oNode.on("keypress", this._fireClick, this)); } }, /** * @method _detachEventHandlers * @description Detaches all event handlers used by the Focus Manager. * @protected */ _detachEventHandlers: function () { this._detachKeyHandler(); var aHandlers = this._eventHandlers; if (aHandlers) { Y.Array.each(aHandlers, function (handle) { handle.detach(); }); this._eventHandlers = null; } }, /** * @method _detachEventHandlers * @description Attaches all event handlers used by the Focus Manager. * @protected */ _attachEventHandlers: function () { var descendants = this._descendants, aHandlers, oDocument, handle; if (descendants && descendants.size()) { aHandlers = this._eventHandlers || []; oDocument = this.get(HOST).get("ownerDocument"); if (aHandlers.length === 0) { aHandlers.push(oDocument.on("focus", this._onDocFocus, this)); aHandlers.push(oDocument.on("mousedown", this._onDocMouseDown, this)); aHandlers.push( this.after("keysChange", this._attachKeyHandler)); aHandlers.push( this.after("descendantsChange", this._initDescendants)); aHandlers.push( this.after(ACTIVE_DESCENDANT_CHANGE, this._afterActiveDescendantChange)); // For performance: defer attaching all key-related event // handlers until the first time one of the specified // descendants receives focus. handle = this.after("focusedChange", Y.bind(function (event) { if (event.newVal) { this._attachKeyHandler(); // Detach this "focusedChange" handler so that the // key-related handlers only get attached once. handle.detach(); } }, this)); aHandlers.push(handle); } this._eventHandlers = aHandlers; } }, // Protected event handlers /** * @method _onDocMouseDown * @description "mousedown" event handler for the owner document of the * Focus Manager's Node. * @protected * @param event {Object} Object representing the DOM event. */ _onDocMouseDown: function (event) { var oHost = this.get(HOST), oTarget = event.target, bChildNode = oHost.contains(oTarget), node, getFocusable = function (node) { var returnVal = false; if (!node.compareTo(oHost)) { returnVal = this._isDescendant(node) ? node : getFocusable.call(this, node.get("parentNode")); } return returnVal; }; if (bChildNode) { // Check to make sure that the target isn't a child node of one // of the focusable descendants. node = getFocusable.call(this, oTarget); if (node) { oTarget = node; } else if (!node && this.get(FOCUSED)) { // The target was a non-focusable descendant of the root // node, so the "focused" attribute should be set to false. this._set(FOCUSED, false); this._onDocFocus(event); } } if (bChildNode && this._isDescendant(oTarget)) { // Fix general problem in Webkit: mousing down on a button or an // anchor element doesn't focus it. // For all browsers: makes sure that the descendant that // was the target of the mousedown event is now considered the // active descendant. this.focus(oTarget); } else if (UA.webkit && this.get(FOCUSED) && (!bChildNode || (bChildNode && !this._isDescendant(oTarget)))) { // Fix for Webkit: // Document doesn't receive focus in Webkit when the user mouses // down on it, so the "focused" attribute won't get set to the // correct value. // The goal is to force a blur if the user moused down on // either: 1) A descendant node, but not one that managed by // the FocusManager, or 2) an element outside of the // FocusManager this._set(FOCUSED, false); this._onDocFocus(event); } }, /** * @method _onDocFocus * @description "focus" event handler for the owner document of the * Focus Manager's Node. * @protected * @param event {Object} Object representing the DOM event. */ _onDocFocus: function (event) { var oTarget = this._focusTarget || event.target, bFocused = this.get(FOCUSED), focusClass = this.get(FOCUS_CLASS), oFocusedNode = this._focusedNode, bInCollection; if (this._focusTarget) { this._focusTarget = null; } if (this.get(HOST).contains(oTarget)) { // The target is a descendant of the root Node. bInCollection = this._isDescendant(oTarget); if (!bFocused && bInCollection) { // The user has focused a focusable descendant. bFocused = true; } else if (bFocused && !bInCollection) { // The user has focused a child of the root Node that is // not one of the descendants managed by this Focus Manager // so clear the currently focused descendant. bFocused = false; } } else { // The target is some other node in the document. bFocused = false; } if (focusClass) { if (oFocusedNode && (!oFocusedNode.compareTo(oTarget) || !bFocused)) { this._removeFocusClass(); } if (bInCollection && bFocused) { if (focusClass.fn) { oTarget = focusClass.fn(oTarget); oTarget.addClass(focusClass.className); } else { oTarget.addClass(focusClass); } this._focusedNode = oTarget; } } this._set(FOCUSED, bFocused); }, /** * @method _focusNext * @description Keydown event handler that moves focus to the next * enabled descendant. * @protected * @param event {Object} Object representing the DOM event. * @param activeDescendant {Number} Number representing the index of the * next descendant to be focused */ _focusNext: function (event, activeDescendant) { var nActiveDescendant = activeDescendant || this.get(ACTIVE_DESCENDANT), oNode; if (this._isDescendant(event.target) && (nActiveDescendant <= this._lastNodeIndex)) { nActiveDescendant = nActiveDescendant + 1; if (nActiveDescendant === (this._lastNodeIndex + 1) && this.get(CIRCULAR)) { nActiveDescendant = 0; } oNode = this._descendants.item(nActiveDescendant); if (oNode && oNode.get(DISABLED)) { this._focusNext(event, nActiveDescendant); } else { this.focus(nActiveDescendant); } } this._preventScroll(event); }, /** * @method _focusPrevious * @description Keydown event handler that moves focus to the previous * enabled descendant. * @protected * @param event {Object} Object representing the DOM event. * @param activeDescendant {Number} Number representing the index of the * next descendant to be focused. */ _focusPrevious: function (event, activeDescendant) { var nActiveDescendant = activeDescendant || this.get(ACTIVE_DESCENDANT), oNode; if (this._isDescendant(event.target) && nActiveDescendant >= 0) { nActiveDescendant = nActiveDescendant - 1; if (nActiveDescendant === -1 && this.get(CIRCULAR)) { nActiveDescendant = this._lastNodeIndex; } oNode = this._descendants.item(nActiveDescendant); if (oNode && oNode.get(DISABLED)) { this._focusPrevious(event, nActiveDescendant); } else { this.focus(nActiveDescendant); } } this._preventScroll(event); }, /** * @method _afterActiveDescendantChange * @description afterChange event handler for the * "activeDescendant" attribute. * @protected * @param event {Object} Object representing the change event. */ _afterActiveDescendantChange: function (event) { var oNode = this._descendants.item(event.prevVal); if (oNode) { oNode.set(TAB_INDEX, -1); } oNode = this._descendants.item(event.newVal); if (oNode) { oNode.set(TAB_INDEX, 0); } }, // Public methods initializer: function (config) { this.start(); }, destructor: function () { this.stop(); this.get(HOST).focusManager = null; }, /** * @method focus * @description Focuses the active descendant and sets the * focused attribute to true. * @param index {Number} Optional. Number representing the index of the * descendant to be set as the active descendant. * @param index {Node} Optional. Node instance representing the * descendant to be set as the active descendant. */ focus: function (index) { if (Lang.isUndefined(index)) { index = this.get(ACTIVE_DESCENDANT); } this.set(ACTIVE_DESCENDANT, index, { src: UI }); var oNode = this._descendants.item(this.get(ACTIVE_DESCENDANT)); if (oNode) { oNode.focus(); // In Opera focusing a