event-debug.js revision e275a18d7f6fd57baf841eb4c8f82d790c1ef6bd
/**
* DOM event listener abstraction layer
* @module event
*/
(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.
D = C.doc,
_ready = function(e) {
GLOBAL_ENV._ready();
};
if (!GLOBAL_ENV._ready) {
GLOBAL_ENV._ready = function() {
if (!GLOBAL_ENV.DOMReady) {
GLOBAL_ENV.DOMReady=true;
if (D.removeEventListener) {
}
}
};
// create custom event
// Internet Explorer: use the readyState of a defered script.
// 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.
try {
// throws an error if doc is not ready
GLOBAL_ENV._dri = null;
_ready();
} catch (ex) {
}
}, POLL_INTERVAL);
// FireFox, Opera, Safari 3+: These browsers provide a event for this
// moment.
} else {
}
/////////////////////////////////////////////////////////////
}
})();
(function() {
/**
* DOM event listener abstraction layer
* @module event
*/
yready = function() {
Y.fire('domready');
};
/**
* Executes the supplied callback when the DOM is first usable. This
* will execute immediately if called after the DOMReady event has
* fired. @todo the DOMContentReady event does not fire when the
* script is dynamically injected into the page. This means the
* DOMReady custom event will never fire in FireFox or Opera when the
* library is injected. It _will_ fire in Safari, and the IE
* implementation would allow for us to fire it if the defered script
* is not available. We want this to behave the same in all browsers.
* Is there a way to identify when the script has been injected
* instead of included inline? Is there a way to know whether the
* window onload event has fired without having had a listener attached
* to it when it did so?
*
* <p>The callback is a Event.Custom, so the signature is:</p>
* <p>type <string>, args <array>, customobject <object></p>
* <p>For DOMReady events, there are no fire argments, so the
* signature is:</p>
* <p>"DOMReady", [], obj</p>
*
*
* @event domready
* @for YUI
*
* @param {function} fn what to execute when the element is found.
* @optional context execution context
* @optional args 0..n arguments to send to the listener
*
*/
domready: {},
/**
* Use domready event instead. @see domready
* @event event:ready
* @for YUI
* @deprecated use 'domready' instead
*/
'event:ready': {
on: function() {
var a = Y.Array(arguments, 0, true);
a[0] = 'domready';
},
detach: function() {
var a = Y.Array(arguments, 0, true);
a[0] = 'domready';
return Y.unsubscribe.apply(Y, a);
}
}
});
Y.publish('domready', {
fireOnce: 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');
}
})();
(function() {
/**
* Custom event engine, DOM event listener abstraction layer, synthetic DOM
* events.
* @module event
*/
/**
* Wraps a DOM event, properties requiring browser abstraction are
* fixed here. Provids a security layer when required.
* @class EventFacade
* @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
},
*/
/**
* 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)
},
/**
* 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
* @method resolve
* @private
*/
resolve = function(n) {
if (!n) {
return null;
}
try {
n = n.parentNode;
}
} catch(ex) { }
};
// provide a single event with browser abstractions resolved
//
// include all properties for both browers?
// include only DOM2 spec properties?
// provide browser-specific facade?
//////////////////////////////////////////////////////
if (!x && 0 !== x) {
x = e.clientX || 0;
y = e.clientY || 0;
}
}
this._yuifacade = true;
/**
* 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;
//////////////////////////////////////////////////////
/**
* The keyCode for key events. Uses charCode if keyCode is not available
* @property keyCode
* @type int
*/
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
*/
/**
* The button that was pushed. Same as button.
* @property which
* @type int
*/
//////////////////////////////////////////////////////
/**
* Node reference for the targeted element
* @propery target
* @type Node
*/
/**
* Node reference for the element that the listener was attached to.
* @propery currentTarget
* @type Node
*/
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);
//////////////////////////////////////////////////////
// methods
/**
* Stops the propagation to the next bubble target
* @method stopPropagation
*/
this.stopPropagation = function() {
if (e.stopPropagation) {
e.stopPropagation();
} else {
e.cancelBubble = true;
}
if (wrapper) {
}
};
/**
* 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) {
} else {
this.stopPropagation();
}
if (wrapper) {
}
};
/**
* Prevents the event's default behavior
* @method preventDefault
*/
this.preventDefault = function() {
if (e.preventDefault) {
e.preventDefault();
} else {
e.returnValue = false;
}
if (wrapper) {
}
};
/**
* 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
*/
if (immediate) {
this.stopImmediatePropagation();
} else {
this.stopPropagation();
}
this.preventDefault();
};
};
})();
(function() {
/**
* DOM event listener abstraction layer
* @module event
*/
/**
* 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
*/
onLoad = function() {
},
onUnload = function() {
},
EVENT_READY = 'domready',
COMPAT_ARG = '~yui|2|compat~',
shouldIterate = function(o) {
try {
// Y.log('node? ' + (o instanceof Y.Node) + ', ' + ((o.size) ? o.size() : ' no size'));
// if (o instanceof Y.Node) {
// o.tagName ="adsf";
// }
return ( o && // o is something
typeof o !== "string" && // o is not a string
// o.length && // o is indexed
!o.tagName && // o is not an HTML element
!o.alert && // o is not a window
} 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 = {},
_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 = {};
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 2000@amp;20 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() {
var E = Y.Event;
if (!E._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
var a = Y.Array(id), i;
// Y.log('onAvailable registered for: ' + id);
id: a[i],
});
}
_retryCount = this.POLL_RETRYS;
// We want the first test to be immediate, but async
return new Y.EventHandle(); // @TODO by id needs a defered handle
},
/**
* 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} 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
},
/**
* Appends an event handler
*
* @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
* listener to.
* @param {Object} obj An arbitrary object that will be
* passed as a parameter to the handler
* @param {Boolean|object} args 0..n arguments to pass to the callback
* @return {Boolean} True if the action was successful or defered,
* false if one or more of the elements
* could not have the listener attached,
* or if the operation throws an exception.
* @static
*/
},
if (false === facade) {
key += 'native';
}
if (capture) {
key += 'capture';
}
if (!cewrapper) {
// create CE wrapper
//silent: true,
// host: this,
bubbles: false,
contextFn: function() {
}
});
// for later removeListener calls
};
// window load happens once
}
}
return cewrapper;
},
compat = true;
trimmedArgs.pop();
}
// 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)) {
// Y.log('collection: ' + el);
// Y.log('collection: ' + el.item(0) + ', ' + el.item(1));
handles=[];
args[2] = v;
});
// 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
// @TODO switch to using DOM directly here
// oEl = (compat) ? Y.DOM.byId(el) : Y.all(el);
if (oEl) {
} else {
}
// HTMLElement
} else {
// Y.log('no size: ' + oEl + ', ' + type);
}
// Not found = defer adding the event until the element is available
} else {
// Y.log(el + ' not found');
return this.onAvailable(el, function() {
// Y.log('lazy attach: ' + args);
}, E, true, false, compat);
}
}
// Element should be an html element or an array if we get here.
if (!el) {
return false;
}
// the custom event key is the uid for the element + type
// allow a node reference to Y.on to work with load time addEventListener check
// (Node currently only has the addEventListener interface and that may be
// removed).
}
// if the load is complete, fire immediately.
// all subscribers, including the current one
// will be notified.
fireNow = true;
}
}
// switched from obj to trimmedArgs[2] to deal with appened compat param
// context = trimmedArgs[2] || ((compat) ? el : Y.get(el));
// set the context as the second arg to subscribe
// remove the 'obj' param
// set context to the Node if not specified
if (fireNow) {
}
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|HTMLElement|Array|NodeList} el An id, an element
* the listener from.
* @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.
* @return {boolean} true if the unbind was successful, false * otherwise.
* @static
*/
compat = true;
// args.pop();
}
}
// The el argument can be a string
if (typeof el == "string") {
// el = (compat) ? Y.DOM.byId(el) : Y.all(el);
// The el argument can be an array of elements or element ids.
} else if (shouldIterate(el)) {
ok = true;
}
return ok;
}
}
if (ce) {
} 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
*/
},
/**
* 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) {
if (!id) {
}
return id;
},
/**
* 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
*/
/**
* hook up any deferred listeners
* @method _load
* @static
* @private
*/
_load: function(e) {
if (!_loadComplete) {
// Y.log('Load Complete', 'info', 'event');
_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
}
},
/**
* 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 (this.locked) {
return;
}
// Hold off if DOMReady has not fired and check current
// readyState to protect against the IE operation aborted
// issue.
this.startInterval();
return;
}
this.locked = true;
// Y.log.debug("poll");
// 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
if (!tryAgain) {
}
// onAvailable
notAvail = [];
if (ov === true) {
} else {
}
} else {
}
} else {
}
};
// onAvailable
// el = (item.compat) ? Y.DOM.byId(item.id) : Y.get(item.id);
if (el) {
// Y.log('avail: ' + el);
_avail[i] = null;
} else {
// Y.log('NOT avail: ' + el);
}
}
}
// onContentReady
// el = (item.compat) ? Y.DOM.byId(item.id) : Y.get(item.id);
if (el) {
// The element is available, but not necessarily ready
// @todo should we test parentNode.nextSibling?
_avail[i] = null;
}
} else {
}
}
}
if (tryAgain) {
// we may need to strip the nulled out items here
this.startInterval();
} else {
clearInterval(this._interval);
this._interval = null;
}
this.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
*/
// var oEl = (Y.Lang.isString(el)) ? Y.get(el) : el,
if (lis) {
}
}
}
}
},
/**
* 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 {Y.Custom.Event} the custom event wrapper for the DOM event(s)
* @static
*/
if (!evts) {
return null;
}
if (key) {
}
} else {
});
}
},
/**
* Removes all listeners registered by pe.event. Called
* automatically during the unload event.
* @method _unload
* @static
* @private
*/
_unload: function(e) {
var E = Y.Event;
v.detachAll();
delete _wrappers[k];
});
},
/**
* 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 {boolen} capture capture or bubble phase
* @static
* @private
*/
/**
* 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 {boolen} capture capture or bubble phase
* @static
* @private
*/
};
}();
onLoad();
} else {
}
// Process onAvailable/onContentReady items when when the DOM is ready in IE
}
})();
/**
* Executes the callback as soon as the specified element
* is detected in the DOM.
* @for YUI
* @event available
*/
}
};
/**
* 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)
* @for YUI
* @event contentready
*/
}
};
(function() {
CAPTURE_CONFIG = { capture: true },
NOOP = function(){},
// Opera implents capture phase events per spec rather than
// the more useful way it is implemented in other browsers:
// The event doesn't fire on a target unless there is a
// listener on an element in the target's ancestry. If a
// capture phase listener is added only to the element that
// will be the target of the event, the listener won't fire.
// To get around this, we register a NOOP listener on the
// element's parent.
_captureHack = function(type, o) {
if (p) {
}
};
/**
* Adds a DOM focus listener. Uses the focusin event in IE,
* and the capture phase otherwise so that
* the event propagates in a way that enables event delegation.
*
* Note: if you are registering this event on the intended target
* rather than an ancestor, the element must be in the DOM in
* order for it to work in Opera.
*
* @for YUI
* @event focus
*/
var a = Y.Array(arguments, 0, true);
_captureHack(type, o);
}
}
};
/**
* Adds a DOM blur listener. Uses the focusout event in IE,
* and the capture phase otherwise so that
* the event propagates in a way that enables event delegation.
*
* Note: if you are registering this event on the intended target
* rather than an ancestor, the element must be in the DOM
* at the time of registration in order for it to work in Opera.
*
* @for YUI
* @event blur
*/
var a = Y.Array(arguments, 0, true);
_captureHack(type, o);
}
}
};
})();
/**
* 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 {string} the function to execute
* @param id {string} the element(s) to bind
* @param spec {string} the keyCode and modifier specification
* @param o optional context object
* @param args 0..n additional arguments that should be provided
* to the listener.
* @return {Event.Handle} the detach handle
*/
var a = Y.Array(arguments, 0, true),
a[0] = 'keypress';
}
// key event type: 'down', 'up', or 'press'
// list of key codes optionally followed by modifiers
// the name of the custom event that will be created for the spec
// subscribe spec validator to the DOM event
// Y.log('keylistener: ' + e.keyCode);
// pass this section if any supplied keyCode
// is found
// Y.log('passed: ' + crit);
passed = true;
} else {
failed = true;
// Y.log('failed: ' + crit);
}
// only check modifier if no keyCode was specified
// or the keyCode check was successful. pass only
// if every modifier passes
// Y.log(crit + ": " + passed);
}
}
// fire spec custom event if spec if met
if (passed) {
}
}, id);
}
// subscribe supplied listener to custom event for spec validator
// remove element and spec.
a[0] = ename;
}
};
(function() {
delegates = {},
resolveTextNode = function(n) {
try {
if (n && 3 == n.nodeType) {
return n.parentNode;
}
} catch(e) { }
return n;
},
spec,
ev,
i;
if (nElements > 0) {
do {
if (!ev) {
}
}
}
while (i--);
}
}
}
},
},
});
/**
* Sets up a delegated listener container.
* @event delegate
* @param type {string} 'delegate'
* @param fn {string} the function to execute
* @param el {string|node} the element that is the delegation container
* @param delegateType {string} the event type to delegate
* @param spec {string} a selector that must match the target of the
* event.
* @return {Event.Handle} the detach handle
* @for YUI
*/
if (!spec) {
return false;
}
// identifier to target the container
// the custom event for the delegation spec
// the key to the listener for the event type and container
a = Y.Array(arguments, 0, true),
if (!(delegateKey in delegates)) {
}
else { // Node instance
}
});
}
else {
}
delegates[delegateKey] = {};
}
a[0] = ename;
// remove element, delegation spec and context object from the args
// subscribe to the custom event for the delegation spec
}
};
})();
(function() {
var detachHandle,
CE_NAME = 'window:resize',
handler = function(e) {
} else {
if (timerHandle) {
}
});
}
};
/**
* Firefox fires the window resize event once when the resize action
* finishes, other browsers fire the event periodically during the
* resize. This code uses timeout logic to simulate the Firefox
* behavior in other browsers.
* @event windowresize
* @for YUI
*/
// check for single window listener and add if needed
if (!detachHandle) {
}
var a = Y.Array(arguments, 0, true);
a[0] = CE_NAME;
}
};
})();
e.container = e.currentTarget;
e.currentTarget = node;
}
},
var relatedTarget = e.relatedTarget,
if (spec) {
var bReturnVal;
bReturnVal = true;
}
return bReturnVal;
});
}
else {
}
},
}),
eventConfig = {
}
if (!Y.getEvent(sEventName)) {
// Set up the listener on the container
}, el);
}
// Remove the element (and the spec--if defined) from the args
if (sSelector) {
}
else {
}
// Subscribe to the custom event for the delegation spec
}
};
/**
* Sets up a "mouseenter" listener—a listener that is called the first time
* the user's mouse enters the specified element(s). By passing a CSS selector
* as the fourth argument, can also be used to delegate a "mouseenter"
* event listener.
*
* @event mouseenter
* @param type {string} "mouseenter"
* @param fn {string} 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 {Event.Handle} the detach handle
* @for YUI
*/
/**
* Sets up a "mouseleave" listener—a listener that is called the first time
* the user's mouse leaves the specified element(s). By passing a CSS selector
* as the fourth argument, can also be used to delegate a "mouseleave"
* event listener.
*
* @event mouseleave
* @param type {string} "mouseleave"
* @param fn {string} 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 {Event.Handle} the detach handle
* @for YUI
*/