src/event.js

   1 var rformElems = /^(?:textarea|input|select)$/i,
   2         rtypenamespace = /^([^\.]*|)(?:\.(.+)|)$/,
   3         rkeyEvent = /^key/,
   4         rmouseEvent = /^(?:mouse|contextmenu)|click/,
   5         rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
   6
   7 /*
   8  * Helper functions for managing events -- not part of the public interface.
   9  * Props to Dean Edwards' addEvent library for many of the ideas.
  10  */
  11 jQuery.event = {
  12
  13         add: function( elem, types, handler, data, selector ) {
  14                 var elemData, eventHandle, events,
  15                         t, tns, type, namespaces, handleObj,
  16                         handleObjIn, handlers, special;
  17
  18                 // Don't attach events to noData or text/comment nodes (allow plain objects tho)
  19                 if ( elem.nodeType === 3 || elem.nodeType === 8 || !types || !handler || !(elemData = jQuery._data( elem )) ) {
  20                         return;
  21                 }
  22
  23                 // Caller can pass in an object of custom data in lieu of the handler
  24                 if ( handler.handler ) {
  25                         handleObjIn = handler;
  26                         handler = handleObjIn.handler;
  27                         selector = handleObjIn.selector;
  28                 }
  29
  30                 // Make sure that the handler has a unique ID, used to find/remove it later
  31                 if ( !handler.guid ) {
  32                         handler.guid = jQuery.guid++;
  33                 }
  34
  35                 // Init the element's event structure and main handler, if this is the first
  36                 events = elemData.events;
  37                 if ( !events ) {
  38                         elemData.events = events = {};
  39                 }
  40                 eventHandle = elemData.handle;
  41                 if ( !eventHandle ) {
  42                         elemData.handle = eventHandle = function( e ) {
  43                                 // Discard the second event of a jQuery.event.trigger() and
  44                                 // when an event is called after a page has unloaded
  45                                 return typeof jQuery !== "undefined" && (!e || jQuery.event.triggered !== e.type) ?
  46                                         jQuery.event.dispatch.apply( eventHandle.elem, arguments ) :
  47                                         undefined;
  48                         };
  49                         // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events
  50                         eventHandle.elem = elem;
  51                 }
  52
  53                 // Handle multiple events separated by a space
  54                 // jQuery(...).bind("mouseover mouseout", fn);
  55                 types = jQuery.trim( types ).split( " " );
  56                 for ( t = 0; t < types.length; t++ ) {
  57
  58                         tns = rtypenamespace.exec( types[t] ) || [];
  59                         type = tns[1];
  60                         namespaces = ( tns[2] || "" ).split( "." ).sort();
  61
  62                         // If event changes its type, use the special event handlers for the changed type
  63                         special = jQuery.event.special[ type ] || {};
  64
  65                         // If selector defined, determine special event api type, otherwise given type
  66                         type = ( selector ? special.delegateType : special.bindType ) || type;
  67
  68                         // Update special based on newly reset type
  69                         special = jQuery.event.special[ type ] || {};
  70
  71                         // handleObj is passed to all event handlers
  72                         handleObj = jQuery.extend({
  73                                 type: type,
  74                                 origType: tns[1],
  75                                 data: data,
  76                                 handler: handler,
  77                                 guid: handler.guid,
  78                                 selector: selector,
  79                                 needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
  80                                 namespace: namespaces.join(".")
  81                         }, handleObjIn );
  82
  83                         // Init the event handler queue if we're the first
  84                         handlers = events[ type ];
  85                         if ( !handlers ) {
  86                                 handlers = events[ type ] = [];
  87                                 handlers.delegateCount = 0;
  88
  89                                 // Only use addEventListener/attachEvent if the special events handler returns false
  90                                 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  91                                         // Bind the global event handler to the element
  92                                         if ( elem.addEventListener ) {
  93                                                 elem.addEventListener( type, eventHandle, false );
  94
  95                                         } else if ( elem.attachEvent ) {
  96                                                 elem.attachEvent( "on" + type, eventHandle );
  97                                         }
  98                                 }
  99                         }
 100
 101                         if ( special.add ) {
 102                                 special.add.call( elem, handleObj );
 103
 104                                 if ( !handleObj.handler.guid ) {
 105                                         handleObj.handler.guid = handler.guid;
 106                                 }
 107                         }
 108
 109                         // Add to the element's handler list, delegates in front
 110                         if ( selector ) {
 111                                 handlers.splice( handlers.delegateCount++, 0, handleObj );
 112                         } else {
 113                                 handlers.push( handleObj );
 114                         }
 115
 116                         // Keep track of which events have ever been used, for event optimization
 117                         jQuery.event.global[ type ] = true;
 118                 }
 119
 120                 // Nullify elem to prevent memory leaks in IE
 121                 elem = null;
 122         },
 123
 124         global: {},
 125
 126         // Detach an event or set of events from an element
 127         remove: function( elem, types, handler, selector, mappedTypes ) {
 128
 129                 var t, tns, type, origType, namespaces, origCount,
 130                         j, events, special, eventType, handleObj,
 131                         elemData = jQuery.hasData( elem ) && jQuery._data( elem );
 132
 133                 if ( !elemData || !(events = elemData.events) ) {
 134                         return;
 135                 }
 136
 137                 // Once for each type.namespace in types; type may be omitted
 138                 types = jQuery.trim( types ).split(" ");
 139                 for ( t = 0; t < types.length; t++ ) {
 140                         tns = rtypenamespace.exec( types[t] ) || [];
 141                         type = origType = tns[1];
 142                         namespaces = tns[2];
 143
 144                         // Unbind all events (on this namespace, if provided) for the element
 145                         if ( !type ) {
 146                                 for ( type in events ) {
 147                                         jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
 148                                 }
 149                                 continue;
 150                         }
 151
 152                         special = jQuery.event.special[ type ] || {};
 153                         type = ( selector? special.delegateType : special.bindType ) || type;
 154                         eventType = events[ type ] || [];
 155                         origCount = eventType.length;
 156                         namespaces = namespaces ? new RegExp("(^|\\.)" + namespaces.split(".").sort().join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
 157
 158                         // Remove matching events
 159                         for ( j = 0; j < eventType.length; j++ ) {
 160                                 handleObj = eventType[ j ];
 161
 162                                 if ( ( mappedTypes || origType === handleObj.origType ) &&
 163                                          ( !handler || handler.guid === handleObj.guid ) &&
 164                                          ( !namespaces || namespaces.test( handleObj.namespace ) ) &&
 165                                          ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
 166                                         eventType.splice( j--, 1 );
 167
 168                                         if ( handleObj.selector ) {
 169                                                 eventType.delegateCount--;
 170                                         }
 171                                         if ( special.remove ) {
 172                                                 special.remove.call( elem, handleObj );
 173                                         }
 174                                 }
 175                         }
 176
 177                         // Remove generic event handler if we removed something and no more handlers exist
 178                         // (avoids potential for endless recursion during removal of special event handlers)
 179                         if ( eventType.length === 0 && origCount !== eventType.length ) {
 180                                 if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
 181                                         jQuery.removeEvent( elem, type, elemData.handle );
 182                                 }
 183
 184                                 delete events[ type ];
 185                         }
 186                 }
 187
 188                 // Remove the expando if it's no longer used
 189                 if ( jQuery.isEmptyObject( events ) ) {
 190                         delete elemData.handle;
 191
 192                         // removeData also checks for emptiness and clears the expando if empty
 193                         // so use it instead of delete
 194                         jQuery._removeData( elem, "events" );
 195                 }
 196         },
 197
 198         // Events that are safe to short-circuit if no handlers are attached.
 199         // Native DOM events should not be added, they may have inline handlers.
 200         customEvent: {
 201                 "getData": true,
 202                 "setData": true,
 203                 "changeData": true
 204         },
 205
 206         trigger: function( event, data, elem, onlyHandlers ) {
 207                 // Don't do events on text and comment nodes
 208                 if ( elem && (elem.nodeType === 3 || elem.nodeType === 8) ) {
 209                         return;
 210                 }
 211
 212                 // Event object or event type
 213                 var cache, exclusive, i, cur, old, ontype, special, handle, eventPath, bubbleType,
 214                         type = event.type || event,
 215                         namespaces = [];
 216
 217                 // focus/blur morphs to focusin/out; ensure we're not firing them right now
 218                 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
 219                         return;
 220                 }
 221
 222                 if ( type.indexOf( "!" ) >= 0 ) {
 223                         // Exclusive events trigger only for the exact event (no namespaces)
 224                         type = type.slice(0, -1);
 225                         exclusive = true;
 226                 }
 227
 228                 if ( type.indexOf( "." ) >= 0 ) {
 229                         // Namespaced trigger; create a regexp to match event type in handle()
 230                         namespaces = type.split(".");
 231                         type = namespaces.shift();
 232                         namespaces.sort();
 233                 }
 234
 235                 if ( (!elem || jQuery.event.customEvent[ type ]) && !jQuery.event.global[ type ] ) {
 236                         // No jQuery handlers for this event type, and it can't have inline handlers
 237                         return;
 238                 }
 239
 240                 // Caller can pass in an Event, Object, or just an event type string
 241                 event = typeof event === "object" ?
 242                         // jQuery.Event object
 243                         event[ jQuery.expando ] ? event :
 244                         // Object literal
 245                         new jQuery.Event( type, event ) :
 246                         // Just the event type (string)
 247                         new jQuery.Event( type );
 248
 249                 event.type = type;
 250                 event.isTrigger = true;
 251                 event.exclusive = exclusive;
 252                 event.namespace = namespaces.join( "." );
 253                 event.namespace_re = event.namespace? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
 254                 ontype = type.indexOf( ":" ) < 0 ? "on" + type : "";
 255
 256                 // Handle a global trigger
 257                 if ( !elem ) {
 258
 259                         // TODO: Stop taunting the data cache; remove global events and always attach to document
 260                         cache = jQuery.cache;
 261                         for ( i in cache ) {
 262                                 if ( cache[ i ].events && cache[ i ].events[ type ] ) {
 263                                         jQuery.event.trigger( event, data, cache[ i ].handle.elem, true );
 264                                 }
 265                         }
 266                         return;
 267                 }
 268
 269                 // Clean up the event in case it is being reused
 270                 event.result = undefined;
 271                 if ( !event.target ) {
 272                         event.target = elem;
 273                 }
 274
 275                 // Clone any incoming data and prepend the event, creating the handler arg list
 276                 data = data != null ? jQuery.makeArray( data ) : [];
 277                 data.unshift( event );
 278
 279                 // Allow special events to draw outside the lines
 280                 special = jQuery.event.special[ type ] || {};
 281                 if ( special.trigger && special.trigger.apply( elem, data ) === false ) {
 282                         return;
 283                 }
 284
 285                 // Determine event propagation path in advance, per W3C events spec (#9951)
 286                 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
 287                 eventPath = [[ elem, special.bindType || type ]];
 288                 if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
 289
 290                         bubbleType = special.delegateType || type;
 291                         cur = rfocusMorph.test( bubbleType + type ) ? elem : elem.parentNode;
 292                         for ( old = elem; cur; cur = cur.parentNode ) {
 293                                 eventPath.push([ cur, bubbleType ]);
 294                                 old = cur;
 295                         }
 296
 297                         // Only add window if we got to document (e.g., not plain obj or detached DOM)
 298                         if ( old === (elem.ownerDocument || document) ) {
 299                                 eventPath.push([ old.defaultView || old.parentWindow || window, bubbleType ]);
 300                         }
 301                 }
 302
 303                 // Fire handlers on the event path
 304                 for ( i = 0; i < eventPath.length && !event.isPropagationStopped(); i++ ) {
 305
 306                         cur = eventPath[i][0];
 307                         event.type = eventPath[i][1];
 308
 309                         handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" );
 310                         if ( handle ) {
 311                                 handle.apply( cur, data );
 312                         }
 313                         // Note that this is a bare JS function and not a jQuery handler
 314                         handle = ontype && cur[ ontype ];
 315                         if ( handle && jQuery.acceptData( cur ) && handle.apply && handle.apply( cur, data ) === false ) {
 316                                 event.preventDefault();
 317                         }
 318                 }
 319                 event.type = type;
 320
 321                 // If nobody prevented the default action, do it now
 322                 if ( !onlyHandlers && !event.isDefaultPrevented() ) {
 323
 324                         if ( (!special._default || special._default.apply( elem.ownerDocument, data ) === false) &&
 325                                 !(type === "click" && jQuery.nodeName( elem, "a" )) && jQuery.acceptData( elem ) ) {
 326
 327                                 // Call a native DOM method on the target with the same name name as the event.
 328                                 // Can't use an .isFunction() check here because IE6/7 fails that test.
 329                                 // Don't do default actions on window, that's where global variables be (#6170)
 330                                 // IE<9 dies on focus/blur to hidden element (#1486)
 331                                 if ( ontype && elem[ type ] && ((type !== "focus" && type !== "blur") || event.target.offsetWidth !== 0) && !jQuery.isWindow( elem ) ) {
 332
 333                                         // Don't re-trigger an onFOO event when we call its FOO() method
 334                                         old = elem[ ontype ];
 335
 336                                         if ( old ) {
 337                                                 elem[ ontype ] = null;
 338                                         }
 339
 340                                         // Prevent re-triggering of the same event, since we already bubbled it above
 341                                         jQuery.event.triggered = type;
 342                                         elem[ type ]();
 343                                         jQuery.event.triggered = undefined;
 344
 345                                         if ( old ) {
 346                                                 elem[ ontype ] = old;
 347                                         }
 348                                 }
 349                         }
 350                 }
 351
 352                 return event.result;
 353         },
 354
 355         dispatch: function( event ) {
 356
 357                 // Make a writable jQuery.Event from the native event object
 358                 event = jQuery.event.fix( event || window.event );
 359
 360                 var i, j, cur, ret, selMatch, matched, matches, handleObj, sel, related,
 361                         handlers = ( (jQuery._data( this, "events" ) || {} )[ event.type ] || []),
 362                         delegateCount = handlers.delegateCount,
 363                         args = core_slice.call( arguments ),
 364                         run_all = !event.exclusive && !event.namespace,
 365                         special = jQuery.event.special[ event.type ] || {},
 366                         handlerQueue = [];
 367
 368                 // Use the fix-ed jQuery.Event rather than the (read-only) native event
 369                 args[0] = event;
 370                 event.delegateTarget = this;
 371
 372                 // Call the preDispatch hook for the mapped type, and let it bail if desired
 373                 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
 374                         return;
 375                 }
 376
 377                 // Determine handlers that should run if there are delegated events
 378                 // Avoid non-left-click bubbling in Firefox (#3861)
 379                 if ( delegateCount && !(event.button && event.type === "click") ) {
 380
 381                         for ( cur = event.target; cur != this; cur = cur.parentNode || this ) {
 382
 383                                 // Don't process clicks (ONLY) on disabled elements (#6911, #8165, #11382, #11764)
 384                                 if ( cur.disabled !== true || event.type !== "click" ) {
 385                                         selMatch = {};
 386                                         matches = [];
 387                                         for ( i = 0; i < delegateCount; i++ ) {
 388                                                 handleObj = handlers[ i ];
 389                                                 sel = handleObj.selector;
 390
 391                                                 if ( selMatch[ sel ] === undefined ) {
 392                                                         selMatch[ sel ] = handleObj.needsContext ?
 393                                                                 jQuery( sel, this ).index( cur ) >= 0 :
 394                                                                 jQuery.find( sel, this, null, [ cur ] ).length;
 395                                                 }
 396                                                 if ( selMatch[ sel ] ) {
 397                                                         matches.push( handleObj );
 398                                                 }
 399                                         }
 400                                         if ( matches.length ) {
 401                                                 handlerQueue.push({ elem: cur, matches: matches });
 402                                         }
 403                                 }
 404                         }
 405                 }
 406
 407                 // Add the remaining (directly-bound) handlers
 408                 if ( handlers.length > delegateCount ) {
 409                         handlerQueue.push({ elem: this, matches: handlers.slice( delegateCount ) });
 410                 }
 411
 412                 // Run delegates first; they may want to stop propagation beneath us
 413                 for ( i = 0; i < handlerQueue.length && !event.isPropagationStopped(); i++ ) {
 414                         matched = handlerQueue[ i ];
 415                         event.currentTarget = matched.elem;
 416
 417                         for ( j = 0; j < matched.matches.length && !event.isImmediatePropagationStopped(); j++ ) {
 418                                 handleObj = matched.matches[ j ];
 419
 420                                 // Triggered event must either 1) be non-exclusive and have no namespace, or
 421                                 // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace).
 422                                 if ( run_all || (!event.namespace && !handleObj.namespace) || event.namespace_re && event.namespace_re.test( handleObj.namespace ) ) {
 423
 424                                         event.data = handleObj.data;
 425                                         event.handleObj = handleObj;
 426
 427                                         ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
 428                                                         .apply( matched.elem, args );
 429
 430                                         if ( ret !== undefined ) {
 431                                                 event.result = ret;
 432                                                 if ( ret === false ) {
 433                                                         event.preventDefault();
 434                                                         event.stopPropagation();
 435                                                 }
 436                                         }
 437                                 }
 438                         }
 439                 }
 440
 441                 // Call the postDispatch hook for the mapped type
 442                 if ( special.postDispatch ) {
 443                         special.postDispatch.call( this, event );
 444                 }
 445
 446                 return event.result;
 447         },
 448
 449         // Includes some event props shared by KeyEvent and MouseEvent
 450         // *** attrChange attrName relatedNode srcElement  are not normalized, non-W3C, deprecated, will be removed in 1.8 ***
 451         props: "attrChange attrName relatedNode srcElement altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
 452
 453         fixHooks: {},
 454
 455         keyHooks: {
 456                 props: "char charCode key keyCode".split(" "),
 457                 filter: function( event, original ) {
 458
 459                         // Add which for key events
 460                         if ( event.which == null ) {
 461                                 event.which = original.charCode != null ? original.charCode : original.keyCode;
 462                         }
 463
 464                         return event;
 465                 }
 466         },
 467
 468         mouseHooks: {
 469                 props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
 470                 filter: function( event, original ) {
 471                         var eventDoc, doc, body,
 472                                 button = original.button,
 473                                 fromElement = original.fromElement;
 474
 475                         // Calculate pageX/Y if missing and clientX/Y available
 476                         if ( event.pageX == null && original.clientX != null ) {
 477                                 eventDoc = event.target.ownerDocument || document;
 478                                 doc = eventDoc.documentElement;
 479                                 body = eventDoc.body;
 480
 481                                 event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
 482                                 event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
 483                         }
 484
 485                         // Add relatedTarget, if necessary
 486                         if ( !event.relatedTarget && fromElement ) {
 487                                 event.relatedTarget = fromElement === event.target ? original.toElement : fromElement;
 488                         }
 489
 490                         // Add which for click: 1 === left; 2 === middle; 3 === right
 491                         // Note: button is not normalized, so don't use it
 492                         if ( !event.which && button !== undefined ) {
 493                                 event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
 494                         }
 495
 496                         return event;
 497                 }
 498         },
 499
 500         fix: function( event ) {
 501                 if ( event[ jQuery.expando ] ) {
 502                         return event;
 503                 }
 504
 505                 // Create a writable copy of the event object and normalize some properties
 506                 var i, prop,
 507                         originalEvent = event,
 508                         fixHook = jQuery.event.fixHooks[ event.type ] || {},
 509                         copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
 510
 511                 event = jQuery.Event( originalEvent );
 512
 513                 for ( i = copy.length; i; ) {
 514                         prop = copy[ --i ];
 515                         event[ prop ] = originalEvent[ prop ];
 516                 }
 517
 518                 // Fix target property, if necessary (#1925, IE 6/7/8 & Safari2)
 519                 if ( !event.target ) {
 520                         event.target = originalEvent.srcElement || document;
 521                 }
 522
 523                 // Target should not be a text node (#504, Safari)
 524                 if ( event.target.nodeType === 3 ) {
 525                         event.target = event.target.parentNode;
 526                 }
 527
 528                 // For mouse/key events, metaKey==false if it's undefined (#3368, #11328; IE6/7/8)
 529                 event.metaKey = !!event.metaKey;
 530
 531                 return fixHook.filter? fixHook.filter( event, originalEvent ) : event;
 532         },
 533
 534         special: {
 535                 load: {
 536                         // Prevent triggered image.load events from bubbling to window.load
 537                         noBubble: true
 538                 },
 539
 540                 focus: {
 541                         delegateType: "focusin"
 542                 },
 543                 blur: {
 544                         delegateType: "focusout"
 545                 },
 546
 547                 beforeunload: {
 548                         setup: function( data, namespaces, eventHandle ) {
 549                                 // We only want to do this special case on windows
 550                                 if ( jQuery.isWindow( this ) ) {
 551                                         this.onbeforeunload = eventHandle;
 552                                 }
 553                         },
 554
 555                         teardown: function( namespaces, eventHandle ) {
 556                                 if ( this.onbeforeunload === eventHandle ) {
 557                                         this.onbeforeunload = null;
 558                                 }
 559                         }
 560                 }
 561         },
 562
 563         simulate: function( type, elem, event, bubble ) {
 564                 // Piggyback on a donor event to simulate a different one.
 565                 // Fake originalEvent to avoid donor's stopPropagation, but if the
 566                 // simulated event prevents default then we do the same on the donor.
 567                 var e = jQuery.extend(
 568                         new jQuery.Event(),
 569                         event,
 570                         { type: type,
 571                                 isSimulated: true,
 572                                 originalEvent: {}
 573                         }
 574                 );
 575                 if ( bubble ) {
 576                         jQuery.event.trigger( e, null, elem );
 577                 } else {
 578                         jQuery.event.dispatch.call( elem, e );
 579                 }
 580                 if ( e.isDefaultPrevented() ) {
 581                         event.preventDefault();
 582                 }
 583         }
 584 };
 585
 586 // Some plugins are using, but it's undocumented/deprecated and will be removed.
 587 // The 1.7 special event interface should provide all the hooks needed now.
 588 jQuery.event.handle = jQuery.event.dispatch;
 589
 590 jQuery.removeEvent = document.removeEventListener ?
 591         function( elem, type, handle ) {
 592                 if ( elem.removeEventListener ) {
 593                         elem.removeEventListener( type, handle, false );
 594                 }
 595         } :
 596         function( elem, type, handle ) {
 597                 var name = "on" + type;
 598
 599                 if ( elem.detachEvent ) {
 600
 601                         // #8545, #7054, preventing memory leaks for custom events in IE6-8
 602                         // detachEvent needed property on element, by name of that event, to properly expose it to GC
 603                         if ( typeof elem[ name ] === "undefined" ) {
 604                                 elem[ name ] = null;
 605                         }
 606
 607                         elem.detachEvent( name, handle );
 608                 }
 609         };
 610
 611 jQuery.Event = function( src, props ) {
 612         // Allow instantiation without the 'new' keyword
 613         if ( !(this instanceof jQuery.Event) ) {
 614                 return new jQuery.Event( src, props );
 615         }
 616
 617         // Event object
 618         if ( src && src.type ) {
 619                 this.originalEvent = src;
 620                 this.type = src.type;
 621
 622                 // Events bubbling up the document may have been marked as prevented
 623                 // by a handler lower down the tree; reflect the correct value.
 624                 this.isDefaultPrevented = ( src.defaultPrevented || src.returnValue === false ||
 625                         src.getPreventDefault && src.getPreventDefault() ) ? returnTrue : returnFalse;
 626
 627         // Event type
 628         } else {
 629                 this.type = src;
 630         }
 631
 632         // Put explicitly provided properties onto the event object
 633         if ( props ) {
 634                 jQuery.extend( this, props );
 635         }
 636
 637         // Create a timestamp if incoming event doesn't have one
 638         this.timeStamp = src && src.timeStamp || jQuery.now();
 639
 640         // Mark it as fixed
 641         this[ jQuery.expando ] = true;
 642 };
 643
 644 function returnFalse() {
 645         return false;
 646 }
 647 function returnTrue() {
 648         return true;
 649 }
 650
 651 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
 652 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
 653 jQuery.Event.prototype = {
 654         preventDefault: function() {
 655                 this.isDefaultPrevented = returnTrue;
 656
 657                 var e = this.originalEvent;
 658                 if ( !e ) {
 659                         return;
 660                 }
 661
 662                 // if preventDefault exists run it on the original event
 663                 if ( e.preventDefault ) {
 664                         e.preventDefault();
 665
 666                 // otherwise set the returnValue property of the original event to false (IE)
 667                 } else {
 668                         e.returnValue = false;
 669                 }
 670         },
 671         stopPropagation: function() {
 672                 this.isPropagationStopped = returnTrue;
 673
 674                 var e = this.originalEvent;
 675                 if ( !e ) {
 676                         return;
 677                 }
 678                 // if stopPropagation exists run it on the original event
 679                 if ( e.stopPropagation ) {
 680                         e.stopPropagation();
 681                 }
 682                 // otherwise set the cancelBubble property of the original event to true (IE)
 683                 e.cancelBubble = true;
 684         },
 685         stopImmediatePropagation: function() {
 686                 this.isImmediatePropagationStopped = returnTrue;
 687                 this.stopPropagation();
 688         },
 689         isDefaultPrevented: returnFalse,
 690         isPropagationStopped: returnFalse,
 691         isImmediatePropagationStopped: returnFalse
 692 };
 693
 694 // Create mouseenter/leave events using mouseover/out and event-time checks
 695 jQuery.each({
 696         mouseenter: "mouseover",
 697         mouseleave: "mouseout"
 698 }, function( orig, fix ) {
 699         jQuery.event.special[ orig ] = {
 700                 delegateType: fix,
 701                 bindType: fix,
 702
 703                 handle: function( event ) {
 704                         var ret,
 705                                 target = this,
 706                                 related = event.relatedTarget,
 707                                 handleObj = event.handleObj,
 708                                 selector = handleObj.selector;
 709
 710                         // For mousenter/leave call the handler if related is outside the target.
 711                         // NB: No relatedTarget if the mouse left/entered the browser window
 712                         if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
 713                                 event.type = handleObj.origType;
 714                                 ret = handleObj.handler.apply( this, arguments );
 715                                 event.type = fix;
 716                         }
 717                         return ret;
 718                 }
 719         };
 720 });
 721
 722 // IE submit delegation
 723 if ( !jQuery.support.submitBubbles ) {
 724
 725         jQuery.event.special.submit = {
 726                 setup: function() {
 727                         // Only need this for delegated form submit events
 728                         if ( jQuery.nodeName( this, "form" ) ) {
 729                                 return false;
 730                         }
 731
 732                         // Lazy-add a submit handler when a descendant form may potentially be submitted
 733                         jQuery.event.add( this, "click._submit keypress._submit", function( e ) {
 734                                 // Node name check avoids a VML-related crash in IE (#9807)
 735                                 var elem = e.target,
 736                                         form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined;
 737                                 if ( form && !jQuery._data( form, "_submit_attached" ) ) {
 738                                         jQuery.event.add( form, "submit._submit", function( event ) {
 739                                                 event._submit_bubble = true;
 740                                         });
 741                                         jQuery._data( form, "_submit_attached", true );
 742                                 }
 743                         });
 744                         // return undefined since we don't need an event listener
 745                 },
 746
 747                 postDispatch: function( event ) {
 748                         // If form was submitted by the user, bubble the event up the tree
 749                         if ( event._submit_bubble ) {
 750                                 delete event._submit_bubble;
 751                                 if ( this.parentNode && !event.isTrigger ) {
 752                                         jQuery.event.simulate( "submit", this.parentNode, event, true );
 753                                 }
 754                         }
 755                 },
 756
 757                 teardown: function() {
 758                         // Only need this for delegated form submit events
 759                         if ( jQuery.nodeName( this, "form" ) ) {
 760                                 return false;
 761                         }
 762
 763                         // Remove delegated handlers; cleanData eventually reaps submit handlers attached above
 764                         jQuery.event.remove( this, "._submit" );
 765                 }
 766         };
 767 }
 768
 769 // IE change delegation and checkbox/radio fix
 770 if ( !jQuery.support.changeBubbles ) {
 771
 772         jQuery.event.special.change = {
 773
 774                 setup: function() {
 775
 776                         if ( rformElems.test( this.nodeName ) ) {
 777                                 // IE doesn't fire change on a check/radio until blur; trigger it on click
 778                                 // after a propertychange. Eat the blur-change in special.change.handle.
 779                                 // This still fires onchange a second time for check/radio after blur.
 780                                 if ( this.type === "checkbox" || this.type === "radio" ) {
 781                                         jQuery.event.add( this, "propertychange._change", function( event ) {
 782                                                 if ( event.originalEvent.propertyName === "checked" ) {
 783                                                         this._just_changed = true;
 784                                                 }
 785                                         });
 786                                         jQuery.event.add( this, "click._change", function( event ) {
 787                                                 if ( this._just_changed && !event.isTrigger ) {
 788                                                         this._just_changed = false;
 789                                                 }
 790                                                 // Allow triggered, simulated change events (#11500)
 791                                                 jQuery.event.simulate( "change", this, event, true );
 792                                         });
 793                                 }
 794                                 return false;
 795                         }
 796                         // Delegated event; lazy-add a change handler on descendant inputs
 797                         jQuery.event.add( this, "beforeactivate._change", function( e ) {
 798                                 var elem = e.target;
 799
 800                                 if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "_change_attached" ) ) {
 801                                         jQuery.event.add( elem, "change._change", function( event ) {
 802                                                 if ( this.parentNode && !event.isSimulated && !event.isTrigger ) {
 803                                                         jQuery.event.simulate( "change", this.parentNode, event, true );
 804                                                 }
 805                                         });
 806                                         jQuery._data( elem, "_change_attached", true );
 807                                 }
 808                         });
 809                 },
 810
 811                 handle: function( event ) {
 812                         var elem = event.target;
 813
 814                         // Swallow native change events from checkbox/radio, we already triggered them above
 815                         if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) {
 816                                 return event.handleObj.handler.apply( this, arguments );
 817                         }
 818                 },
 819
 820                 teardown: function() {
 821                         jQuery.event.remove( this, "._change" );
 822
 823                         return !rformElems.test( this.nodeName );
 824                 }
 825         };
 826 }
 827
 828 // Create "bubbling" focus and blur events
 829 if ( !jQuery.support.focusinBubbles ) {
 830         jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
 831
 832                 // Attach a single capturing handler while someone wants focusin/focusout
 833                 var attaches = 0,
 834                         handler = function( event ) {
 835                                 jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
 836                         };
 837
 838                 jQuery.event.special[ fix ] = {
 839                         setup: function() {
 840                                 if ( attaches++ === 0 ) {
 841                                         document.addEventListener( orig, handler, true );
 842                                 }
 843                         },
 844                         teardown: function() {
 845                                 if ( --attaches === 0 ) {
 846                                         document.removeEventListener( orig, handler, true );
 847                                 }
 848                         }
 849                 };
 850         });
 851 }
 852
 853 jQuery.fn.extend({
 854
 855         on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
 856                 var origFn, type;
 857
 858                 // Types can be a map of types/handlers
 859                 if ( typeof types === "object" ) {
 860                         // ( types-Object, selector, data )
 861                         if ( typeof selector !== "string" ) { // && selector != null
 862                                 // ( types-Object, data )
 863                                 data = data || selector;
 864                                 selector = undefined;
 865                         }
 866                         for ( type in types ) {
 867                                 this.on( type, selector, data, types[ type ], one );
 868                         }
 869                         return this;
 870                 }
 871
 872                 if ( data == null && fn == null ) {
 873                         // ( types, fn )
 874                         fn = selector;
 875                         data = selector = undefined;
 876                 } else if ( fn == null ) {
 877                         if ( typeof selector === "string" ) {
 878                                 // ( types, selector, fn )
 879                                 fn = data;
 880                                 data = undefined;
 881                         } else {
 882                                 // ( types, data, fn )
 883                                 fn = data;
 884                                 data = selector;
 885                                 selector = undefined;
 886                         }
 887                 }
 888                 if ( fn === false ) {
 889                         fn = returnFalse;
 890                 } else if ( !fn ) {
 891                         return this;
 892                 }
 893
 894                 if ( one === 1 ) {
 895                         origFn = fn;
 896                         fn = function( event ) {
 897                                 // Can use an empty set, since event contains the info
 898                                 jQuery().off( event );
 899                                 return origFn.apply( this, arguments );
 900                         };
 901                         // Use same guid so caller can remove using origFn
 902                         fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
 903                 }
 904                 return this.each( function() {
 905                         jQuery.event.add( this, types, fn, data, selector );
 906                 });
 907         },
 908         one: function( types, selector, data, fn ) {
 909                 return this.on( types, selector, data, fn, 1 );
 910         },
 911         off: function( types, selector, fn ) {
 912                 var handleObj, type;
 913                 if ( types && types.preventDefault && types.handleObj ) {
 914                         // ( event )  dispatched jQuery.Event
 915                         handleObj = types.handleObj;
 916                         jQuery( types.delegateTarget ).off(
 917                                 handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
 918                                 handleObj.selector,
 919                                 handleObj.handler
 920                         );
 921                         return this;
 922                 }
 923                 if ( typeof types === "object" ) {
 924                         // ( types-object [, selector] )
 925                         for ( type in types ) {
 926                                 this.off( type, selector, types[ type ] );
 927                         }
 928                         return this;
 929                 }
 930                 if ( selector === false || typeof selector === "function" ) {
 931                         // ( types [, fn] )
 932                         fn = selector;
 933                         selector = undefined;
 934                 }
 935                 if ( fn === false ) {
 936                         fn = returnFalse;
 937                 }
 938                 return this.each(function() {
 939                         jQuery.event.remove( this, types, fn, selector );
 940                 });
 941         },
 942
 943         bind: function( types, data, fn ) {
 944                 return this.on( types, null, data, fn );
 945         },
 946         unbind: function( types, fn ) {
 947                 return this.off( types, null, fn );
 948         },
 949
 950         live: function( types, data, fn ) {
 951                 jQuery( this.context ).on( types, this.selector, data, fn );
 952                 return this;
 953         },
 954         die: function( types, fn ) {
 955                 jQuery( this.context ).off( types, this.selector || "**", fn );
 956                 return this;
 957         },
 958
 959         delegate: function( selector, types, data, fn ) {
 960                 return this.on( types, selector, data, fn );
 961         },
 962         undelegate: function( selector, types, fn ) {
 963                 // ( namespace ) or ( selector, types [, fn] )
 964                 return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
 965         },
 966
 967         trigger: function( type, data ) {
 968                 return this.each(function() {
 969                         jQuery.event.trigger( type, data, this );
 970                 });
 971         },
 972         triggerHandler: function( type, data ) {
 973                 if ( this[0] ) {
 974                         return jQuery.event.trigger( type, data, this[0], true );
 975                 }
 976         },
 977
 978         hover: function( fnOver, fnOut ) {
 979                 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
 980         }
 981 });
 982
 983 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
 984         "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
 985         "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
 986
 987         // Handle event binding
 988         jQuery.fn[ name ] = function( data, fn ) {
 989                 if ( fn == null ) {
 990                         fn = data;
 991                         data = null;
 992                 }
 993
 994                 return arguments.length > 0 ?
 995                         this.on( name, null, data, fn ) :
 996                         this.trigger( name );
 997         };
 998
 999         if ( rkeyEvent.test( name ) ) {
1000                 jQuery.event.fixHooks[ name ] = jQuery.event.keyHooks;
1001         }
1002
1003         if ( rmouseEvent.test( name ) ) {
1004                 jQuery.event.fixHooks[ name ] = jQuery.event.mouseHooks;
1005         }
1006 });