comt: comparison src/cm/media/js/lib/yui/yui3-3.15.0/build/event-base/event-base-debug.js

Mercurial Mercurial > comt / comparison

summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help

src/cm/media/js/lib/yui/yui3-3.15.0/build/event-base/event-base-debug.js

changeset 602

e16a97fb364a

equal deleted inserted replaced

-:d334a616c023
+:e16a97fb364a
+YUI.add('event-base', function (Y, NAME) {
+/*
+* DOM event listener abstraction layer
+* @module event
+* @submodule event-base
+*/
+/**
+* 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 (YUI.Env.DOMReady) {
+Y.fire('domready');
+} else {
+Y.Do.before(function() { Y.fire('domready'); }, YUI.Env, '_ready');
+}
+/**
+* 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 {CustomEvent} the custom event wrapper for this DOM event
+*/
+var ua = Y.UA,
+EMPTY = {},
+/**
+* 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) {
+if (!n) {
+return n;
+}
+try {
+if (n && 3 == n.nodeType) {
+n = n.parentNode;
+}
+} catch(e) {
+return null;
+}
+return Y.one(n);
+},
+DOMEventFacade = function(ev, currentTarget, wrapper) {
+this._event = ev;
+this._currentTarget = currentTarget;
+this._wrapper = wrapper || EMPTY;
+// if not lazy init
+this.init();
+};
+Y.extend(DOMEventFacade, Object, {
+init: function() {
+var e = this._event,
+overrides = this._wrapper.overrides,
+x = e.pageX,
+y = e.pageY,
+c,
+currentTarget = this._currentTarget;
+this.altKey   = e.altKey;
+this.ctrlKey  = e.ctrlKey;
+this.metaKey  = e.metaKey;
+this.shiftKey = e.shiftKey;
+this.type     = (overrides && overrides.type) || e.type;
+this.clientX  = e.clientX;
+this.clientY  = e.clientY;
+this.pageX = x;
+this.pageY = y;
+// charCode is unknown in keyup, keydown. keyCode is unknown in keypress.
+// FF 3.6 - 8+? pass 0 for keyCode in keypress events.
+// Webkit, FF 3.6-8+?, and IE9+? pass 0 for charCode in keydown, keyup.
+// Webkit and IE9+? duplicate charCode in keyCode.
+// Opera never sets charCode, always keyCode (though with the charCode).
+// IE6-8 don't set charCode or which.
+// All browsers other than IE6-8 set which=keyCode in keydown, keyup, and
+// which=charCode in keypress.
+//
+// Moral of the story: (e.which || e.keyCode) will always return the
+// known code for that key event phase. e.keyCode is often different in
+// keypress from keydown and keyup.
+c = e.keyCode || e.charCode;
+if (ua.webkit && (c in webkitKeymap)) {
+c = webkitKeymap[c];
+}
+this.keyCode = c;
+this.charCode = c;
+// Fill in e.which for IE - implementers should always use this over
+// e.keyCode or e.charCode.
+this.which = e.which || e.charCode || c;
+// this.button = e.button;
+this.button = this.which;
+this.target = resolve(e.target);
+this.currentTarget = resolve(currentTarget);
+this.relatedTarget = resolve(e.relatedTarget);
+if (e.type == "mousewheel" || e.type == "DOMMouseScroll") {
+this.wheelDelta = (e.detail) ? (e.detail * -1) : Math.round(e.wheelDelta / 80) || ((e.wheelDelta < 0) ? -1 : 1);
+}
+if (this._touch) {
+this._touch(e, currentTarget, this._wrapper);
+}
+},
+stopPropagation: function() {
+this._event.stopPropagation();
+this._wrapper.stopped = 1;
+this.stopped = 1;
+},
+stopImmediatePropagation: function() {
+var e = this._event;
+if (e.stopImmediatePropagation) {
+e.stopImmediatePropagation();
+} else {
+this.stopPropagation();
+}
+this._wrapper.stopped = 2;
+this.stopped = 2;
+},
+preventDefault: function(returnValue) {
+var e = this._event;
+e.preventDefault();
+if (returnValue) {
+e.returnValue = returnValue;
+}
+this._wrapper.prevented = 1;
+this.prevented = 1;
+},
+halt: function(immediate) {
+if (immediate) {
+this.stopImmediatePropagation();
+} else {
+this.stopPropagation();
+}
+this.preventDefault();
+}
+});
+DOMEventFacade.resolve = resolve;
+Y.DOM2EventFacade = DOMEventFacade;
+Y.DOMEventFacade = DOMEventFacade;
+/**
+* The native event
+* @property _event
+* @type {DOMEvent}
+* @private
+*/
+/**
+The name of the event (e.g. "click")
+@property type
+@type {String}
+**/
+/**
+`true` if the "alt" or "option" key is pressed.
+@property altKey
+@type {Boolean}
+**/
+/**
+`true` if the shift key is pressed.
+@property shiftKey
+@type {Boolean}
+**/
+/**
+`true` if the "Windows" key on a Windows keyboard, "command" key on an
+Apple keyboard, or "meta" key on other keyboards is pressed.
+@property metaKey
+@type {Boolean}
+**/
+/**
+`true` if the "Ctrl" or "control" key is pressed.
+@property ctrlKey
+@type {Boolean}
+**/
+/**
+* The X location of the event on the page (including scroll)
+* @property pageX
+* @type {Number}
+*/
+/**
+* The Y location of the event on the page (including scroll)
+* @property pageY
+* @type {Number}
+*/
+/**
+* The X location of the event in the viewport
+* @property clientX
+* @type {Number}
+*/
+/**
+* The Y location of the event in the viewport
+* @property clientY
+* @type {Number}
+*/
+/**
+* The keyCode for key events.  Uses charCode if keyCode is not available
+* @property keyCode
+* @type {Number}
+*/
+/**
+* The charCode for key events.  Same as keyCode
+* @property charCode
+* @type {Number}
+*/
+/**
+* The button that was pushed. 1 for left click, 2 for middle click, 3 for
+* right click.  This is only reliably populated on `mouseup` events.
+* @property button
+* @type {Number}
+*/
+/**
+* The button that was pushed.  Same as button.
+* @property which
+* @type {Number}
+*/
+/**
+* Node reference for the targeted element
+* @property target
+* @type {Node}
+*/
+/**
+* Node reference for the element that the listener was attached to.
+* @property currentTarget
+* @type {Node}
+*/
+/**
+* Node reference to the relatedTarget
+* @property relatedTarget
+* @type {Node}
+*/
+/**
+* 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 {Number}
+*/
+/**
+* Stops the propagation to the next bubble target
+* @method stopPropagation
+*/
+/**
+* Stops the propagation to the next bubble target and
+* prevents any additional listeners from being exectued
+* on the current target.
+* @method stopImmediatePropagation
+*/
+/**
+* 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).
+*/
+/**
+* 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
+*/
+(function() {
+/**
+* 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.
+* @module event
+* @main 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,
+config = Y.config,
+win = config.win,
+add = YUI.Env.add,
+remove = YUI.Env.remove,
+onLoad = function() {
+YUI.Env.windowLoaded = true;
+Y.Event._load();
+remove(win, "load", onLoad);
+},
+onUnload = function() {
+Y.Event._unload();
+},
+EVENT_READY = 'domready',
+COMPAT_ARG = '~yui|2|compat~',
+shouldIterate = function(o) {
+try {
+// TODO: See if there's a more performant way to return true early on this, for the common case
+return (o && typeof o !== "string" && Y.Lang.isNumber(o.length) && !o.tagName && !Y.DOM.isWindow(o));
+} catch(ex) {
+Y.log("collection check failure", "warn", "event");
+return false;
+}
+},
+// aliases to support DOM event subscription clean up when the last
+// subscriber is detached. deleteAndClean overrides the DOM event's wrapper
+// CustomEvent _delete method.
+_ceProtoDelete = Y.CustomEvent.prototype._delete,
+_deleteAndClean = function(s) {
+var ret = _ceProtoDelete.apply(this, arguments);
+if (!this.hasSubs()) {
+Y.Event._clean(this);
+}
+return ret;
+},
+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 CustomEvent
+* @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(Event._poll, 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.
+*
+* <p>The callback is executed with a single parameter:
+* the custom object parameter, if provided.</p>
+*
+* @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; i<a.length; i=i+1) {
+_avail.push({
+id:         a[i],
+fn:         fn,
+obj:        p_obj,
+override:   p_override,
+checkReady: checkContent,
+compat:     compat
+});
+}
+_retryCount = this.POLL_RETRYS;
+// We want the first test to be immediate, but async
+setTimeout(Event._poll, 0);
+availHandle = new Y.EventHandle({
+_delete: function() {
+// set by the event system for lazy DOM listeners
+if (availHandle.handle) {
+availHandle.handle.detach();
+return;
+}
+var i, j;
+// otherwise try to remove the onAvailable listener(s)
+for (i = 0; i < a.length; i++) {
+for (j = 0; j < _avail.length; j++) {
+if (a[i] === _avail[j].id) {
+_avail.splice(j, 1);
+}
+}
+}
+}
+});
+return availHandle;
+},
+/**
+* Works the same way as onAvailable, but additionally checks the
+* state of sibling elements to determine if the content of the
+* available element is safe to modify.
+*
+* <p>The callback is executed with a single parameter:
+* the custom object parameter, if provided.</p>
+*
+* @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}   obj an optional object to be passed back as
+*                   a parameter to fn.
+* @param {boolean|object}  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, obj, override, compat) {
+return Event.onAvailable(id, fn, obj, 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,
+emitFacade: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 == win && type == "load") {
+// window load happens once
+cewrapper.fireOnce = true;
+_windowLoadKey = key;
+}
+cewrapper._delete = _deleteAndClean;
+_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, conf) {
+var compat,
+handles, oEl, cewrapper, context,
+fireNow = false, ret,
+type = args[0],
+fn = args[1],
+el = args[2] || win,
+facade = conf && conf.facade,
+capture = conf && conf.capture,
+overrides = conf && conf.overrides;
+if (args[args.length-1] === COMPAT_ARG) {
+compat = true;
+}
+if (!fn || !fn.call) {
+Y.log(type + " attach call failed, invalid callback", "error", "event");
+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.slice(), conf));
+});
+// 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, conf);
+}
+}
+if (oEl) {
+el = oEl;
+// Not found = defer adding the event until the element is available
+} else {
+ret = Event.onAvailable(el, function() {
+ret.handle = Event._attach(args, conf);
+}, Event, true, false, compat);
+return ret;
+}
+}
+// Element should be an html element or node
+if (!el) {
+Y.log("unable to attach event " + type, "warn", "event");
+return false;
+}
+if (Y.Node && Y.instanceOf(el, Y.Node)) {
+el = Y.Node.getDOMNode(el);
+}
+cewrapper = Event._createWrapper(el, type, capture, compat, facade);
+if (overrides) {
+Y.mix(cewrapper.overrides, overrides);
+}
+if (el == 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<l; ++i) {
+args[2] = el[i];
+ok = ( Y.Event.detach.apply(Y.Event, args) && ok );
+}
+return ok;
+}
+if (!type || !fn || !fn.call) {
+return Event.purgeElement(el, false, type);
+}
+id = 'event:' + Y.stamp(el) + type;
+ce = _wrappers[id];
+if (ce) {
+return ce.detach(fn);
+} else {
+return false;
+}
+},
+/**
+* Finds the event in the window object, the caller's arguments, or
+* in the arguments of another method in the callstack.  This is
+* executed automatically for events registered through the event
+* manager, so the implementer should not normally need to execute
+* this function at all.
+* @method getEvent
+* @param {Event} e the event parameter from the handler
+* @param {HTMLElement} el the element the listener was attached to
+* @return {Event} the event
+* @static
+*/
+getEvent: function(e, el, noFacade) {
+var ev = e || win.event;
+return (noFacade) ? ev :
+new Y.DOMEventFacade(ev, el, _wrappers['event:' + Y.stamp(el) + e.type]);
+},
+/**
+* Generates an unique ID for the element if it does not already
+* have one.
+* @method generateId
+* @param el the element to create the id for
+* @return {string} the resulting id of the element
+* @static
+*/
+generateId: function(el) {
+return Y.DOM.generateID(el);
+},
+/**
+* We want to be able to use getElementsByTagName as a collection
+* to attach a group of events to.  Unfortunately, different
+* browsers return different types of collections.  This function
+* tests to determine if the object is array-like.  It will also
+* fail if the object is an array, but is empty.
+* @method _isValidCollection
+* @param o the object to test
+* @return {boolean} true if the object is array-like and populated
+* @deprecated was not meant to be used directly
+* @static
+* @private
+*/
+_isValidCollection: shouldIterate,
+/**
+* hook up any deferred listeners
+* @method _load
+* @static
+* @private
+*/
+_load: function(e) {
+if (!_loadComplete) {
+_loadComplete = true;
+// Just in case DOMReady did not go off for some reason
+// E._ready();
+if (Y.fire) {
+Y.fire(EVENT_READY);
+}
+// Available elements may not have been detected before the
+// window load event fires. Try to find them now so that the
+// the user is more likely to get the onAvailable notifications
+// before the window load notification
+Event._poll();
+}
+},
+/**
+* Polling function that runs before the onload event fires,
+* attempting to attach to DOM Nodes as soon as they are
+* available
+* @method _poll
+* @static
+* @private
+*/
+_poll: function() {
+if (Event.locked) {
+return;
+}
+if (Y.UA.ie && !YUI.Env.DOMReady) {
+// Hold off if DOMReady has not fired and check current
+// readyState to protect against the IE operation aborted
+// issue.
+Event.startInterval();
+return;
+}
+Event.locked = true;
+// keep trying until after the page is loaded.  We need to
+// check the page load state prior to trying to bind the
+// elements so that we can be certain all elements have been
+// tested appropriately
+var i, len, item, el, notAvail, executeItem,
+tryAgain = !_loadComplete;
+if (!tryAgain) {
+tryAgain = (_retryCount > 0);
+}
+// onAvailable
+notAvail = [];
+executeItem = function (el, item) {
+var context, ov = item.override;
+try {
+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 : []);
+}
+} catch (e) {
+Y.log("Error in available or contentReady callback", 'error', 'event');
+}
+};
+// onAvailable
+for (i=0,len=_avail.length; i<len; ++i) {
+item = _avail[i];
+if (item && !item.checkReady) {
+// el = (item.compat) ? Y.DOM.byId(item.id) : Y.one(item.id);
+el = (item.compat) ? Y.DOM.byId(item.id) : Y.Selector.query(item.id, null, true);
+if (el) {
+executeItem(el, item);
+_avail[i] = null;
+} else {
+notAvail.push(item);
+}
+}
+}
+// onContentReady
+for (i=0,len=_avail.length; i<len; ++i) {
+item = _avail[i];
+if (item && item.checkReady) {
+// el = (item.compat) ? Y.DOM.byId(item.id) : Y.one(item.id);
+el = (item.compat) ? Y.DOM.byId(item.id) : Y.Selector.query(item.id, null, true);
+if (el) {
+// The element is available, but not necessarily ready
+// @todo should we test parentNode.nextSibling?
+if (_loadComplete || (el.get && el.get('nextSibling')) || el.nextSibling) {
+executeItem(el, item);
+_avail[i] = null;
+}
+} else {
+notAvail.push(item);
+}
+}
+}
+_retryCount = (notAvail.length === 0) ? 0 : _retryCount - 1;
+if (tryAgain) {
+// we may need to strip the nulled out items here
+Event.startInterval();
+} else {
+clearInterval(Event._interval);
+Event._interval = null;
+}
+Event.locked = false;
+return;
+},
+/**
+* Removes all listeners attached to the given element via addListener.
+* Optionally, the node's children can also be purged.
+* Optionally, you can specify a specific type of event to remove.
+* @method purgeElement
+* @param {HTMLElement} el the element to purge
+* @param {boolean} recurse recursively purge this element's children
+* as well.  Use with caution.
+* @param {string} type optional type of listener to purge. If
+* left out, all listeners will be removed
+* @static
+*/
+purgeElement: function(el, recurse, type) {
+// var oEl = (Y.Lang.isString(el)) ? Y.one(el) : el,
+var oEl = (Y.Lang.isString(el)) ?  Y.Selector.query(el, null, true) : el,
+lis = Event.getListeners(oEl, type), i, len, children, child;
+if (recurse && oEl) {
+lis = lis || [];
+children = Y.Selector.query('*', oEl);
+len = children.length;
+for (i = 0; i < len; ++i) {
+child = Event.getListeners(children[i], type);
+if (child) {
+lis = lis.concat(child);
+}
+}
+}
+if (lis) {
+for (i = 0, len = lis.length; i < len; ++i) {
+lis[i].detachAll();
+}
+}
+},
+/**
+* Removes all object references and the DOM proxy subscription for
+* a given event for a DOM node.
+*
+* @method _clean
+* @param wrapper {CustomEvent} Custom event proxy for the DOM
+*                  subscription
+* @private
+* @static
+* @since 3.4.0
+*/
+_clean: function (wrapper) {
+var key    = wrapper.key,
+domkey = wrapper.domkey;
+remove(wrapper.el, wrapper.type, wrapper.fn, wrapper.capture);
+delete _wrappers[key];
+delete Y._yuievt.events[key];
+if (_el_events[domkey]) {
+delete _el_events[domkey][key];
+if (!Y.Object.size(_el_events[domkey])) {
+delete _el_events[domkey];
+}
+}
+},
+/**
+* Returns all listeners attached to the given element via addListener.
+* Optionally, you can specify a specific type of event to return.
+* @method getListeners
+* @param el {HTMLElement|string} the element or element id to inspect
+* @param type {string} optional type of listener to return. If
+* left out, all listeners will be returned
+* @return {CustomEvent} the custom event wrapper for the DOM event(s)
+* @static
+*/
+getListeners: function(el, type) {
+var ek = Y.stamp(el, true), evts = _el_events[ek],
+results=[] , key = (type) ? 'event:' + ek + type : null,
+adapters = _eventenv.plugins;
+if (!evts) {
+return null;
+}
+if (key) {
+// look for synthetic events
+if (adapters[type] && adapters[type].eventDef) {
+key += '_synth';
+}
+if (evts[key]) {
+results.push(evts[key]);
+}
+// get native events as well
+key += 'native';
+if (evts[key]) {
+results.push(evts[key]);
+}
+} else {
+Y.each(evts, function(v, k) {
+results.push(v);
+});
+}
+return (results.length) ? results : null;
+},
+/**
+* Removes all listeners registered by pe.event.  Called
+* automatically during the unload event.
+* @method _unload
+* @static
+* @private
+*/
+_unload: function(e) {
+Y.each(_wrappers, function(v, k) {
+if (v.type == 'unload') {
+v.fire(e);
+}
+v.detachAll();
+});
+remove(win, "unload", onUnload);
+},
+/**
+* Adds a DOM event directly without the caching, cleanup, context adj, etc
+*
+* @method nativeAdd
+* @param {HTMLElement} el      the element to bind the handler to
+* @param {string}      type   the type of event handler
+* @param {function}    fn      the callback to invoke
+* @param {Boolean}      capture capture or bubble phase
+* @static
+* @private
+*/
+nativeAdd: add,
+/**
+* Basic remove listener
+*
+* @method nativeRemove
+* @param {HTMLElement} el      the element to bind the handler to
+* @param {string}      type   the type of event handler
+* @param {function}    fn      the callback to invoke
+* @param {Boolean}      capture capture or bubble phase
+* @static
+* @private
+*/
+nativeRemove: remove
+};
+}();
+Y.Event = Event;
+if (config.injected || YUI.Env.windowLoaded) {
+onLoad();
+} else {
+add(win, "load", onLoad);
+}
+// Process onAvailable/onContentReady items when when the DOM is ready in IE
+if (Y.UA.ie) {
+Y.on(EVENT_READY, Event._poll);
+// In IE6 and below, detach event handlers when the page is unloaded in
+// order to try and prevent cross-page memory leaks. This isn't done in
+// other browsers because a) it's not necessary, and b) it breaks the
+// back/forward cache.
+if (Y.UA.ie < 7) {
+try {
+add(win, "unload", onUnload);
+} catch(e) {
+Y.log("Registering unload listener failed.", "warn", "event-base");
+}
+}
+}
+Event.Custom = Y.CustomEvent;
+Event.Subscriber = Y.Subscriber;
+Event.Target = Y.EventTarget;
+Event.Handle = Y.EventHandle;
+Event.Facade = Y.EventFacade;
+Event._poll();
+}());
+/**
+* DOM event listener abstraction layer
+* @module event
+* @submodule event-base
+*/
+/**
+* Executes the callback as soon as the specified element
+* is detected in the DOM.  This function expects a selector
+* string for the element(s) to detect.  If you already have
+* an element reference, you don't need this event.
+* @event available
+* @param type {string} 'available'
+* @param fn {function} the callback function to execute.
+* @param el {string} an selector for 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.available = {
+on: function(type, fn, id, o) {
+var a = arguments.length > 4 ?  Y.Array(arguments, 4, true) : null;
+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).
+* This function expects a selector
+* string for the element(s) to detect.  If you already have
+* an element reference, you don't need this event.
+* @event contentready
+* @param type {string} 'contentready'
+* @param fn {function} the callback function to execute.
+* @param el {string} an selector for 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) : null;
+return Y.Event.onContentReady.call(Y.Event, id, fn, o, a);
+}
+};
+}, '@VERSION@', {"requires": ["event-custom-base"]});

comt