event-delegate-debug.js revision 7d1157dbcdfedd79881117578f3790d06a2cd317
279N/AYUI.add('event-delegate', function(Y) {
279N/A
279N/A/**
279N/A * Adds event delegation support to the library.
279N/A *
279N/A * @module event
279N/A * @submodule event-delegate
279N/A */
279N/A
279N/Avar Event = Y.Event,
279N/A Lang = Y.Lang,
279N/A
279N/A delegates = {},
279N/A
279N/A specialTypes = {
279N/A mouseenter: "mouseover",
279N/A mouseleave: "mouseout"
279N/A },
279N/A
279N/A resolveTextNode = function(n) {
279N/A try {
2578N/A if (n && 3 == n.nodeType) {
279N/A return n.parentNode;
279N/A }
279N/A } catch(e) { }
279N/A return n;
279N/A },
1506N/A
1506N/A delegateHandler = function(delegateKey, e, el) {
279N/A
279N/A var target = resolveTextNode((e.target || e.srcElement)),
279N/A tests = delegates[delegateKey],
844N/A spec,
1506N/A ename,
279N/A matched,
279N/A fn,
1258N/A ev;
279N/A
279N/A
279N/A var getMatch = function(el, selector, container) {
279N/A
279N/A var returnVal;
279N/A
1506N/A if (!el || el === container) {
279N/A returnVal = false;
279N/A }
279N/A else {
279N/A returnVal = Y.Selector.test(el, selector, container) ? el: getMatch(el.parentNode, selector, container);
279N/A }
840N/A
447N/A return returnVal;
447N/A
447N/A };
447N/A
447N/A
2578N/A for (spec in tests) {
447N/A
924N/A if (tests.hasOwnProperty(spec)) {
279N/A
279N/A ename = tests[spec];
279N/A fn = tests.fn;
279N/A matched = null;
447N/A
279N/A
1506N/A if (Y.Selector.test(target, spec, el)) {
1506N/A matched = target;
1506N/A }
279N/A else if (Y.Selector.test(target, ((spec.replace(/,/gi, " *,")) + " *"), el)) {
279N/A
447N/A // The target is a descendant of an element matching
279N/A // the selector, so crawl up to find the ancestor that
447N/A // matches the selector
279N/A
279N/A matched = getMatch(target, spec, el);
279N/A
279N/A }
279N/A
279N/A
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 || Y.config.win.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) {
Y.log('delegate: no spec, nothing to do', 'warn', 'event');
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) {
Y.log("Delegating a " + type + " event requires the event-mouseenter submodule.", "error", "Event");
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];
Y.log("DOM event listener associated with the " + ename + " Custom Event removed. Removing all " + ename + " listeners.", "info", "Event");
// 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) {
Y.log("No more listeners for the " + ename + " Custom Event. Removing its associated DOM event listener.", "info", "Event");
delegate.handle.detach();
}
}, ceHandle, "detach");
return ceHandle;
};
Y.delegate = Event.delegate;
}, '@VERSION@' ,{requires:['node-base']});