1 var fcleanup = function( nm ) {
2 return nm.replace(/[^\w\s\.\|`]/g, function( ch ) {
8 * A number of helper functions used for managing events.
9 * Many of the ideas behind this code originated from
10 * Dean Edwards' addEvent library.
14 // Bind an event to an element
15 // Original by Dean Edwards
16 add: function( elem, types, handler, data ) {
17 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
21 // For whatever reason, IE has trouble passing the window object
22 // around, causing it to be cloned in the process
23 if ( elem.setInterval && ( elem !== window && !elem.frameElement ) ) {
27 // Make sure that the function being executed has a unique ID
28 if ( !handler.guid ) {
29 handler.guid = this.guid++;
32 // if data is passed, bind to handler
33 if ( data !== undefined ) {
34 // Create temporary function pointer to original handler
37 // Create unique handler function, wrapped around original handler
38 handler = this.proxy( fn );
40 // Store data in unique handler
44 // Init the element's event structure
45 var events = jQuery.data( elem, "events" ) || jQuery.data( elem, "events", {} ),
46 handle = jQuery.data( elem, "handle" ), eventHandle;
49 eventHandle = function() {
50 // Handle the second event of a trigger and when
51 // an event is called after a page has unloaded
52 return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
53 jQuery.event.handle.apply( eventHandle.elem, arguments ) :
57 handle = jQuery.data( elem, "handle", eventHandle );
60 // Add elem as a property of the handle function
61 // This is to prevent a memory leak with non-native
65 // Handle multiple events separated by a space
66 // jQuery(...).bind("mouseover mouseout", fn);
67 types = types.split( /\s+/ );
69 while ( (type = types[ i++ ]) ) {
70 // Namespaced event handlers
71 var namespaces = type.split(".");
72 type = namespaces.shift();
73 handler.type = namespaces.slice(0).sort().join(".");
75 // Get the current list of functions bound to this event
76 var handlers = events[ type ],
77 special = this.special[ type ] || {};
81 // Init the event handler queue
83 handlers = events[ type ] = {};
85 // Check for a special event handler
86 // Only use addEventListener/attachEvent if the special
87 // events handler returns false
88 if ( !special.setup || special.setup.call( elem, data, namespaces, handler) === false ) {
89 // Bind the global event handler to the element
90 if ( elem.addEventListener ) {
91 elem.addEventListener( type, handle, false );
92 } else if ( elem.attachEvent ) {
93 elem.attachEvent( "on" + type, handle );
99 var modifiedHandler = special.add.call( elem, handler, data, namespaces, handlers );
100 if ( modifiedHandler && jQuery.isFunction( modifiedHandler ) ) {
101 modifiedHandler.guid = modifiedHandler.guid || handler.guid;
102 handler = modifiedHandler;
106 // Add the function to the element's handler list
107 handlers[ handler.guid ] = handler;
109 // Keep track of which events have been used, for global triggering
110 this.global[ type ] = true;
113 // Nullify elem to prevent memory leaks in IE
120 // Detach an event or set of events from an element
121 remove: function( elem, types, handler ) {
122 // don't do events on text and comment nodes
123 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
127 var events = jQuery.data( elem, "events" ), ret, type, fn;
130 // Unbind all events for the element
131 if ( types === undefined || (typeof types === "string" && types.charAt(0) === ".") ) {
132 for ( type in events ) {
133 this.remove( elem, type + (types || "") );
136 // types is actually an event object here
138 handler = types.handler;
142 // Handle multiple events separated by a space
143 // jQuery(...).unbind("mouseover mouseout", fn);
144 types = types.split(/\s+/);
146 while ( (type = types[ i++ ]) ) {
147 // Namespaced event handlers
148 var namespaces = type.split(".");
149 type = namespaces.shift();
150 var all = !namespaces.length,
151 cleaned = jQuery.map( namespaces.slice(0).sort(), fcleanup ),
152 namespace = new RegExp("(^|\\.)" + cleaned.join("\\.(?:.*\\.)?") + "(\\.|$)"),
153 special = this.special[ type ] || {};
155 if ( events[ type ] ) {
156 // remove the given handler for the given type
158 fn = events[ type ][ handler.guid ];
159 delete events[ type ][ handler.guid ];
161 // remove all handlers for the given type
163 for ( var handle in events[ type ] ) {
164 // Handle the removal of namespaced events
165 if ( all || namespace.test( events[ type ][ handle ].type ) ) {
166 delete events[ type ][ handle ];
171 if ( special.remove ) {
172 special.remove.call( elem, namespaces, fn);
175 // remove generic event handler if no more handlers exist
176 for ( ret in events[ type ] ) {
180 if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
181 if ( elem.removeEventListener ) {
182 elem.removeEventListener( type, jQuery.data( elem, "handle" ), false );
183 } else if ( elem.detachEvent ) {
184 elem.detachEvent( "on" + type, jQuery.data( elem, "handle" ) );
188 delete events[ type ];
194 // Remove the expando if it's no longer used
195 for ( ret in events ) {
199 var handle = jQuery.data( elem, "handle" );
203 jQuery.removeData( elem, "events" );
204 jQuery.removeData( elem, "handle" );
209 // bubbling is internal
210 trigger: function( event, data, elem /*, bubbling */ ) {
211 // Event object or event type
212 var type = event.type || event,
213 bubbling = arguments[3];
216 event = typeof event === "object" ?
217 // jQuery.Event object
218 event[expando] ? event :
220 jQuery.extend( jQuery.Event(type), event ) :
221 // Just the event type (string)
224 if ( type.indexOf("!") >= 0 ) {
225 event.type = type = type.slice(0, -1);
226 event.exclusive = true;
229 // Handle a global trigger
231 // Don't bubble custom events when global (to avoid too much overhead)
232 event.stopPropagation();
233 // Only trigger if we've ever bound an event for it
234 if ( this.global[ type ] ) {
235 jQuery.each( jQuery.cache, function() {
236 if ( this.events && this.events[type] ) {
237 jQuery.event.trigger( event, data, this.handle.elem );
243 // Handle triggering a single element
245 // don't do events on text and comment nodes
246 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
250 // Clean up in case it is reused
251 event.result = undefined;
254 // Clone the incoming data, if any
255 data = jQuery.makeArray( data );
256 data.unshift( event );
259 event.currentTarget = elem;
261 // Trigger the event, it is assumed that "handle" is a function
262 var handle = jQuery.data( elem, "handle" );
264 handle.apply( elem, data );
267 var nativeFn, nativeHandler;
269 if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
270 nativeFn = elem[ type ];
271 nativeHandler = elem[ "on" + type ];
273 // prevent IE from throwing an error for some elements with some event types, see #3533
276 var isClick = jQuery.nodeName(elem, "a") && type === "click";
278 // Trigger the native events (except for clicks on links)
279 if ( !bubbling && nativeFn && !event.isDefaultPrevented() && !isClick ) {
280 this.triggered = true;
283 // prevent IE from throwing an error for some hidden elements
286 // Handle triggering native .onfoo handlers
287 } else if ( nativeHandler && elem[ "on" + type ].apply( elem, data ) === false ) {
288 event.result = false;
291 this.triggered = false;
293 if ( !event.isPropagationStopped() ) {
294 var parent = elem.parentNode || elem.ownerDocument;
296 jQuery.event.trigger( event, data, parent, true );
301 handle: function( event ) {
302 // returned undefined or false
305 event = arguments[0] = jQuery.event.fix( event || window.event );
306 event.currentTarget = this;
308 // Namespaced event handlers
309 var namespaces = event.type.split(".");
310 event.type = namespaces.shift();
312 // Cache this now, all = true means, any handler
313 all = !namespaces.length && !event.exclusive;
315 var namespace = new RegExp("(^|\\.)" + namespaces.slice(0).sort().join("\\.(?:.*\\.)?") + "(\\.|$)");
317 handlers = ( jQuery.data(this, "events") || {} )[ event.type ];
319 for ( var j in handlers ) {
320 var handler = handlers[ j ];
322 // Filter the functions by class
323 if ( all || namespace.test(handler.type) ) {
324 // Pass in a reference to the handler function itself
325 // So that we can later remove it
326 event.handler = handler;
327 event.data = handler.data;
329 var ret = handler.apply( this, arguments );
331 if ( ret !== undefined ) {
333 if ( ret === false ) {
334 event.preventDefault();
335 event.stopPropagation();
339 if ( event.isImmediatePropagationStopped() ) {
349 props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
351 fix: function( event ) {
352 if ( event[ expando ] ) {
356 // store a copy of the original event object
357 // and "clone" to set read-only properties
358 var originalEvent = event;
359 event = jQuery.Event( originalEvent );
361 for ( var i = this.props.length, prop; i; ) {
362 prop = this.props[ --i ];
363 event[ prop ] = originalEvent[ prop ];
366 // Fix target property, if necessary
367 if ( !event.target ) {
368 event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
371 // check if target is a textnode (safari)
372 if ( event.target.nodeType === 3 ) {
373 event.target = event.target.parentNode;
376 // Add relatedTarget, if necessary
377 if ( !event.relatedTarget && event.fromElement ) {
378 event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
381 // Calculate pageX/Y if missing and clientX/Y available
382 if ( event.pageX == null && event.clientX != null ) {
383 var doc = document.documentElement, body = document.body;
384 event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
385 event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
388 // Add which for key events
389 if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) ) {
390 event.which = event.charCode || event.keyCode;
393 // Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
394 if ( !event.metaKey && event.ctrlKey ) {
395 event.metaKey = event.ctrlKey;
398 // Add which for click: 1 === left; 2 === middle; 3 === right
399 // Note: button is not normalized, so don't use it
400 if ( !event.which && event.button !== undefined ) {
401 event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
407 proxy: function( fn, proxy, thisObject ) {
408 if ( proxy !== undefined && !jQuery.isFunction( proxy ) ) {
413 // FIXME: Should proxy be redefined to be applied with thisObject if defined?
414 proxy = proxy || function() {
415 return fn.apply( thisObject !== undefined ? thisObject : this, arguments );
418 // Set the guid of unique handler to the same of original handler, so it can be removed
419 proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
421 // So proxy can be declared as an argument
427 // Make sure the ready event is setup
428 setup: jQuery.bindReady,
429 teardown: function() {}
433 add: function( proxy, data, namespaces, live ) {
434 jQuery.extend( proxy, data || {} );
436 proxy.guid += data.selector + data.live;
437 jQuery.event.add( this, data.live, liveHandler, data );
441 remove: function( namespaces ) {
442 if ( namespaces.length ) {
443 var remove = 0, name = new RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
445 jQuery.each( (jQuery.data(this, "events").live || {}), function() {
446 if ( name.test(this.type) ) {
452 jQuery.event.remove( this, namespaces[0], liveHandler );
459 setup: function( data, namespaces, fn ) {
460 // We only want to do this special case on windows
461 if ( this.setInterval ) {
462 this.onbeforeunload = fn;
467 teardown: function( namespaces, fn ) {
468 if ( this.onbeforeunload === fn ) {
469 this.onbeforeunload = null;
476 jQuery.Event = function( src ) {
477 // Allow instantiation without the 'new' keyword
478 if ( !this.preventDefault ) {
479 return new jQuery.Event( src );
483 if ( src && src.type ) {
484 this.originalEvent = src;
485 this.type = src.type;
491 // timeStamp is buggy for some events on Firefox(#3843)
492 // So we won't rely on the native value
493 this.timeStamp = now();
496 this[ expando ] = true;
499 function returnFalse() {
502 function returnTrue() {
506 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
507 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
508 jQuery.Event.prototype = {
509 preventDefault: function() {
510 this.isDefaultPrevented = returnTrue;
512 var e = this.originalEvent;
517 // if preventDefault exists run it on the original event
518 if ( e.preventDefault ) {
521 // otherwise set the returnValue property of the original event to false (IE)
522 e.returnValue = false;
524 stopPropagation: function() {
525 this.isPropagationStopped = returnTrue;
527 var e = this.originalEvent;
531 // if stopPropagation exists run it on the original event
532 if ( e.stopPropagation ) {
535 // otherwise set the cancelBubble property of the original event to true (IE)
536 e.cancelBubble = true;
538 stopImmediatePropagation: function() {
539 this.isImmediatePropagationStopped = returnTrue;
540 this.stopPropagation();
542 isDefaultPrevented: returnFalse,
543 isPropagationStopped: returnFalse,
544 isImmediatePropagationStopped: returnFalse
547 // Checks if an event happened on an element within another element
548 // Used in jQuery.event.special.mouseenter and mouseleave handlers
549 var withinElement = function( event ) {
550 // Check if mouse(over|out) are still within the same parent element
551 var parent = event.relatedTarget;
553 // Traverse up the tree
554 while ( parent && parent !== this ) {
555 // Firefox sometimes assigns relatedTarget a XUL element
556 // which we cannot access the parentNode property of
558 parent = parent.parentNode;
560 // assuming we've left the element since we most likely mousedover a xul element
566 if ( parent !== this ) {
567 // set the correct event type
568 event.type = event.data;
570 // handle event if we actually just moused on to a non sub-element
571 jQuery.event.handle.apply( this, arguments );
576 // In case of event delegation, we only need to rename the event.type,
577 // liveHandler will take care of the rest.
578 delegate = function( event ) {
579 event.type = event.data;
580 jQuery.event.handle.apply( this, arguments );
583 // Create mouseenter and mouseleave events
585 mouseenter: "mouseover",
586 mouseleave: "mouseout"
587 }, function( orig, fix ) {
588 jQuery.event.special[ orig ] = {
589 setup: function( data ) {
590 jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
592 teardown: function( data ) {
593 jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
599 if ( !jQuery.support.submitBubbles ) {
601 jQuery.event.special.submit = {
602 setup: function( data, namespaces, fn ) {
603 if ( this.nodeName.toLowerCase() !== "form" ) {
604 jQuery.event.add(this, "click.specialSubmit." + fn.guid, function( e ) {
605 var elem = e.target, type = elem.type;
607 if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
608 return trigger( "submit", this, arguments );
612 jQuery.event.add(this, "keypress.specialSubmit." + fn.guid, function( e ) {
613 var elem = e.target, type = elem.type;
615 if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
616 return trigger( "submit", this, arguments );
622 remove: function( namespaces, fn ) {
623 jQuery.event.remove( this, "click.specialSubmit" + (fn ? "."+fn.guid : "") );
624 jQuery.event.remove( this, "keypress.specialSubmit" + (fn ? "."+fn.guid : "") );
630 // change delegation, happens here so we have bind.
631 if ( !jQuery.support.changeBubbles ) {
633 var formElems = /textarea|input|select/i;
635 function getVal( elem ) {
636 var type = elem.type, val = elem.value;
638 if ( type === "radio" || type === "checkbox" ) {
641 } else if ( type === "select-multiple" ) {
642 val = elem.selectedIndex > -1 ?
643 jQuery.map( elem.options, function( elem ) {
644 return elem.selected;
648 } else if ( elem.nodeName.toLowerCase() === "select" ) {
649 val = elem.selectedIndex;
655 function testChange( e ) {
656 var elem = e.target, data, val;
658 if ( !formElems.test( elem.nodeName ) || elem.readOnly ) {
662 data = jQuery.data( elem, "_change_data" );
665 if ( val === data ) {
669 // the current data will be also retrieved by beforeactivate
670 if ( e.type !== "focusout" || elem.type !== "radio" ) {
671 jQuery.data( elem, "_change_data", val );
674 if ( elem.type !== "select" && (data != null || val) ) {
676 return jQuery.event.trigger( e, arguments[1], this );
680 jQuery.event.special.change = {
682 focusout: testChange,
684 click: function( e ) {
685 var elem = e.target, type = elem.type;
687 if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
688 return testChange.call( this, e );
692 // Change has to be called before submit
693 // Keydown will be called before keypress, wich is used in submit-event delegation
694 keydown: function( e ) {
695 var elem = e.target, type = elem.type;
697 if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
698 (e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
699 type === "select-multiple" ) {
700 return testChange.call( this, e );
704 // Beforeactivate happens also before the previous element is blurred
705 // with this event you can't trigger a change event, but you can store
706 // information/focus[in] is not needed anymore
707 beforeactivate: function( e ) {
710 if ( elem.nodeName.toLowerCase() === "input" && elem.type === "radio" ) {
711 jQuery.data( elem, "_change_data", getVal(elem) );
715 setup: function( data, namespaces, fn ) {
716 for ( var type in changeFilters ) {
717 jQuery.event.add( this, type + ".specialChange." + fn.guid, changeFilters[type] );
720 return formElems.test( this.nodeName );
722 remove: function( namespaces, fn ) {
723 for ( var type in changeFilters ) {
724 jQuery.event.remove( this, type + ".specialChange" + (fn ? "."+fn.guid : ""), changeFilters[type] );
727 return formElems.test( this.nodeName );
731 var changeFilters = jQuery.event.special.change.filters;
735 function trigger( type, elem, args ) {
737 return jQuery.event.handle.apply( elem, args );
740 // Create "bubbling" focus and blur events
741 if ( document.addEventListener ) {
742 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
743 jQuery.event.special[ fix ] = {
745 this.addEventListener( orig, handler, true );
747 teardown: function() {
748 this.removeEventListener( orig, handler, true );
752 function handler( e ) {
753 e = jQuery.event.fix( e );
755 return jQuery.event.handle.call( this, e );
760 jQuery.each(["bind", "one"], function( i, name ) {
761 jQuery.fn[ name ] = function( type, data, fn, thisObject ) {
762 // Handle object literals
763 if ( typeof type === "object" ) {
764 for ( var key in type ) {
765 this[ name ](key, data, type[key], fn);
770 if ( jQuery.isFunction( data ) ) {
775 fn = thisObject === undefined ? fn : jQuery.event.proxy( fn, thisObject );
776 var handler = name === "one" ? jQuery.event.proxy( fn, function( event ) {
777 jQuery( this ).unbind( event, handler );
778 return fn.apply( this, arguments );
780 return type === "unload" ? this.one(type, data, handler, thisObject) : this.each(function() {
781 jQuery.event.add( this, type, handler, data );
787 unbind: function( type, fn ) {
788 // Handle object literals
789 if ( typeof type === "object" && !type.preventDefault ) {
790 for ( var key in type ) {
791 this.unbind(key, type[key]);
796 return this.each(function() {
797 jQuery.event.remove( this, type, fn );
800 trigger: function( type, data ) {
801 return this.each(function() {
802 jQuery.event.trigger( type, data, this );
806 triggerHandler: function( type, data ) {
808 var event = jQuery.Event( type );
809 event.preventDefault();
810 event.stopPropagation();
811 jQuery.event.trigger( event, data, this[0] );
816 toggle: function( fn ) {
817 // Save reference to arguments for access in closure
818 var args = arguments, i = 1;
820 // link all the functions, so any of them can unbind this click handler
821 while ( i < args.length ) {
822 jQuery.event.proxy( fn, args[ i++ ] );
825 return this.click( jQuery.event.proxy( fn, function( event ) {
826 // Figure out which function to execute
827 var lastToggle = ( jQuery.data( this, 'lastToggle' + fn.guid ) || 0 ) % i;
828 jQuery.data( this, 'lastToggle' + fn.guid, lastToggle + 1 );
830 // Make sure that clicks stop
831 event.preventDefault();
833 // and execute the function
834 return args[ lastToggle ].apply( this, arguments ) || false;
838 hover: function( fnOver, fnOut ) {
839 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
842 live: function( type, data, fn, thisObject ) {
843 if ( jQuery.isFunction( data ) ) {
844 if ( fn !== undefined ) {
850 jQuery( this.context ).bind( liveConvert( type, this.selector ), {
851 data: data, selector: this.selector, live: type
856 die: function( type, fn ) {
857 jQuery( this.context ).unbind( liveConvert( type, this.selector ), fn ? { guid: fn.guid + this.selector + type } : null );
862 function liveHandler( event ) {
863 var stop = true, elems = [], selectors = [], args = arguments,
864 related, match, fn, elem, j, i, data,
865 live = jQuery.extend({}, jQuery.data( this, "events" ).live);
869 if ( fn.live === event.type ||
870 fn.altLive && jQuery.inArray(event.type, fn.altLive) > -1 ) {
873 if ( !(data.beforeFilter && data.beforeFilter[event.type] &&
874 !data.beforeFilter[event.type](event)) ) {
875 selectors.push( fn.selector );
882 match = jQuery( event.target ).closest( selectors, event.currentTarget );
884 for ( i = 0, l = match.length; i < l; i++ ) {
887 elem = match[i].elem;
890 if ( match[i].selector === fn.selector ) {
891 // Those two events require additional checking
892 if ( fn.live === "mouseenter" || fn.live === "mouseleave" ) {
893 related = jQuery( event.relatedTarget ).closest( fn.selector )[0];
896 if ( !related || related !== elem ) {
897 elems.push({ elem: elem, fn: fn });
903 for ( i = 0, l = elems.length; i < l; i++ ) {
905 event.currentTarget = match.elem;
906 event.data = match.fn.data;
907 if ( match.fn.apply( match.elem, args ) === false ) {
916 function liveConvert( type, selector ) {
917 return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "&")].join(".");
920 jQuery.each( ("blur focus load resize scroll unload click dblclick " +
921 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
922 "change select submit keydown keypress keyup error").split(" "), function( i, name ) {
924 // Handle event binding
925 jQuery.fn[ name ] = function( fn ) {
926 return fn ? this.bind( name, fn ) : this.trigger( name );
929 if ( jQuery.fnAttr ) {
930 jQuery.fnAttr[ name ] = true;
934 // Prevent memory leaks in IE
935 // Window isn't included so as not to unbind existing unload events
937 // - http://isaacschlueter.com/2006/10/msie-memory-leaks/
938 if ( window.attachEvent && !window.addEventListener ) {
939 window.attachEvent("onunload", function() {
940 for ( var id in jQuery.cache ) {
941 if ( jQuery.cache[ id ].handle ) {
942 // Try/Catch is to handle iframes being unloaded, see #4280
944 jQuery.event.remove( jQuery.cache[ id ].handle.elem );