286
Sf
simple-flask-coffee-sass-boilerplate / files
simple-flask-coffee-sass-boilerplate / bower_components / jquery / src / event.js
23.9 KB
1define([ 2 "./core", 3 "./var/strundefined", 4 "./var/rnotwhite", 5 "./var/hasOwn", 6 "./var/slice", 7 "./event/support", 8 "./data/var/data_priv", 9 10 "./core/init", 11 "./data/accepts", 12 "./selector" 13], function( jQuery, strundefined, rnotwhite, hasOwn, slice, support, data_priv ) { 14 15var 16 rkeyEvent = /^key/, 17 rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/, 18 rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 19 rtypenamespace = /^([^.]*)(?:\.(.+)|)$/; 20 21function returnTrue() { 22 return true; 23} 24 25function returnFalse() { 26 return false; 27} 28 29function safeActiveElement() { 30 try { 31 return document.activeElement; 32 } catch ( err ) { } 33} 34 35/* 36 * Helper functions for managing events -- not part of the public interface. 37 * Props to Dean Edwards' addEvent library for many of the ideas. 38 */ 39jQuery.event = { 40 41 global: {}, 42 43 add: function( elem, types, handler, data, selector ) { 44 45 var handleObjIn, eventHandle, tmp, 46 events, t, handleObj, 47 special, handlers, type, namespaces, origType, 48 elemData = data_priv.get( elem ); 49 50 // Don't attach events to noData or text/comment nodes (but allow plain objects) 51 if ( !elemData ) { 52 return; 53 } 54 55 // Caller can pass in an object of custom data in lieu of the handler 56 if ( handler.handler ) { 57 handleObjIn = handler; 58 handler = handleObjIn.handler; 59 selector = handleObjIn.selector; 60 } 61 62 // Make sure that the handler has a unique ID, used to find/remove it later 63 if ( !handler.guid ) { 64 handler.guid = jQuery.guid++; 65 } 66 67 // Init the element's event structure and main handler, if this is the first 68 if ( !(events = elemData.events) ) { 69 events = elemData.events = {}; 70 } 71 if ( !(eventHandle = elemData.handle) ) { 72 eventHandle = elemData.handle = function( e ) { 73 // Discard the second event of a jQuery.event.trigger() and 74 // when an event is called after a page has unloaded 75 return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type ? 76 jQuery.event.dispatch.apply( elem, arguments ) : undefined; 77 }; 78 } 79 80 // Handle multiple events separated by a space 81 types = ( types || "" ).match( rnotwhite ) || [ "" ]; 82 t = types.length; 83 while ( t-- ) { 84 tmp = rtypenamespace.exec( types[t] ) || []; 85 type = origType = tmp[1]; 86 namespaces = ( tmp[2] || "" ).split( "." ).sort(); 87 88 // There *must* be a type, no attaching namespace-only handlers 89 if ( !type ) { 90 continue; 91 } 92 93 // If event changes its type, use the special event handlers for the changed type 94 special = jQuery.event.special[ type ] || {}; 95 96 // If selector defined, determine special event api type, otherwise given type 97 type = ( selector ? special.delegateType : special.bindType ) || type; 98 99 // Update special based on newly reset type 100 special = jQuery.event.special[ type ] || {}; 101 102 // handleObj is passed to all event handlers 103 handleObj = jQuery.extend({ 104 type: type, 105 origType: origType, 106 data: data, 107 handler: handler, 108 guid: handler.guid, 109 selector: selector, 110 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 111 namespace: namespaces.join(".") 112 }, handleObjIn ); 113 114 // Init the event handler queue if we're the first 115 if ( !(handlers = events[ type ]) ) { 116 handlers = events[ type ] = []; 117 handlers.delegateCount = 0; 118 119 // Only use addEventListener if the special events handler returns false 120 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 121 if ( elem.addEventListener ) { 122 elem.addEventListener( type, eventHandle, false ); 123 } 124 } 125 } 126 127 if ( special.add ) { 128 special.add.call( elem, handleObj ); 129 130 if ( !handleObj.handler.guid ) { 131 handleObj.handler.guid = handler.guid; 132 } 133 } 134 135 // Add to the element's handler list, delegates in front 136 if ( selector ) { 137 handlers.splice( handlers.delegateCount++, 0, handleObj ); 138 } else { 139 handlers.push( handleObj ); 140 } 141 142 // Keep track of which events have ever been used, for event optimization 143 jQuery.event.global[ type ] = true; 144 } 145 146 }, 147 148 // Detach an event or set of events from an element 149 remove: function( elem, types, handler, selector, mappedTypes ) { 150 151 var j, origCount, tmp, 152 events, t, handleObj, 153 special, handlers, type, namespaces, origType, 154 elemData = data_priv.hasData( elem ) && data_priv.get( elem ); 155 156 if ( !elemData || !(events = elemData.events) ) { 157 return; 158 } 159 160 // Once for each type.namespace in types; type may be omitted 161 types = ( types || "" ).match( rnotwhite ) || [ "" ]; 162 t = types.length; 163 while ( t-- ) { 164 tmp = rtypenamespace.exec( types[t] ) || []; 165 type = origType = tmp[1]; 166 namespaces = ( tmp[2] || "" ).split( "." ).sort(); 167 168 // Unbind all events (on this namespace, if provided) for the element 169 if ( !type ) { 170 for ( type in events ) { 171 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 172 } 173 continue; 174 } 175 176 special = jQuery.event.special[ type ] || {}; 177 type = ( selector ? special.delegateType : special.bindType ) || type; 178 handlers = events[ type ] || []; 179 tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ); 180 181 // Remove matching events 182 origCount = j = handlers.length; 183 while ( j-- ) { 184 handleObj = handlers[ j ]; 185 186 if ( ( mappedTypes || origType === handleObj.origType ) && 187 ( !handler || handler.guid === handleObj.guid ) && 188 ( !tmp || tmp.test( handleObj.namespace ) ) && 189 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { 190 handlers.splice( j, 1 ); 191 192 if ( handleObj.selector ) { 193 handlers.delegateCount--; 194 } 195 if ( special.remove ) { 196 special.remove.call( elem, handleObj ); 197 } 198 } 199 } 200 201 // Remove generic event handler if we removed something and no more handlers exist 202 // (avoids potential for endless recursion during removal of special event handlers) 203 if ( origCount && !handlers.length ) { 204 if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 205 jQuery.removeEvent( elem, type, elemData.handle ); 206 } 207 208 delete events[ type ]; 209 } 210 } 211 212 // Remove the expando if it's no longer used 213 if ( jQuery.isEmptyObject( events ) ) { 214 delete elemData.handle; 215 data_priv.remove( elem, "events" ); 216 } 217 }, 218 219 trigger: function( event, data, elem, onlyHandlers ) { 220 221 var i, cur, tmp, bubbleType, ontype, handle, special, 222 eventPath = [ elem || document ], 223 type = hasOwn.call( event, "type" ) ? event.type : event, 224 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : []; 225 226 cur = tmp = elem = elem || document; 227 228 // Don't do events on text and comment nodes 229 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 230 return; 231 } 232 233 // focus/blur morphs to focusin/out; ensure we're not firing them right now 234 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 235 return; 236 } 237 238 if ( type.indexOf(".") >= 0 ) { 239 // Namespaced trigger; create a regexp to match event type in handle() 240 namespaces = type.split("."); 241 type = namespaces.shift(); 242 namespaces.sort(); 243 } 244 ontype = type.indexOf(":") < 0 && "on" + type; 245 246 // Caller can pass in a jQuery.Event object, Object, or just an event type string 247 event = event[ jQuery.expando ] ? 248 event : 249 new jQuery.Event( type, typeof event === "object" && event ); 250 251 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 252 event.isTrigger = onlyHandlers ? 2 : 3; 253 event.namespace = namespaces.join("."); 254 event.namespace_re = event.namespace ? 255 new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) : 256 null; 257 258 // Clean up the event in case it is being reused 259 event.result = undefined; 260 if ( !event.target ) { 261 event.target = elem; 262 } 263 264 // Clone any incoming data and prepend the event, creating the handler arg list 265 data = data == null ? 266 [ event ] : 267 jQuery.makeArray( data, [ event ] ); 268 269 // Allow special events to draw outside the lines 270 special = jQuery.event.special[ type ] || {}; 271 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 272 return; 273 } 274 275 // Determine event propagation path in advance, per W3C events spec (#9951) 276 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) 277 if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { 278 279 bubbleType = special.delegateType || type; 280 if ( !rfocusMorph.test( bubbleType + type ) ) { 281 cur = cur.parentNode; 282 } 283 for ( ; cur; cur = cur.parentNode ) { 284 eventPath.push( cur ); 285 tmp = cur; 286 } 287 288 // Only add window if we got to document (e.g., not plain obj or detached DOM) 289 if ( tmp === (elem.ownerDocument || document) ) { 290 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 291 } 292 } 293 294 // Fire handlers on the event path 295 i = 0; 296 while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) { 297 298 event.type = i > 1 ? 299 bubbleType : 300 special.bindType || type; 301 302 // jQuery handler 303 handle = ( data_priv.get( cur, "events" ) || {} )[ event.type ] && data_priv.get( cur, "handle" ); 304 if ( handle ) { 305 handle.apply( cur, data ); 306 } 307 308 // Native handler 309 handle = ontype && cur[ ontype ]; 310 if ( handle && handle.apply && jQuery.acceptData( cur ) ) { 311 event.result = handle.apply( cur, data ); 312 if ( event.result === false ) { 313 event.preventDefault(); 314 } 315 } 316 } 317 event.type = type; 318 319 // If nobody prevented the default action, do it now 320 if ( !onlyHandlers && !event.isDefaultPrevented() ) { 321 322 if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) && 323 jQuery.acceptData( elem ) ) { 324 325 // Call a native DOM method on the target with the same name name as the event. 326 // Don't do default actions on window, that's where global variables be (#6170) 327 if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) { 328 329 // Don't re-trigger an onFOO event when we call its FOO() method 330 tmp = elem[ ontype ]; 331 332 if ( tmp ) { 333 elem[ ontype ] = null; 334 } 335 336 // Prevent re-triggering of the same event, since we already bubbled it above 337 jQuery.event.triggered = type; 338 elem[ type ](); 339 jQuery.event.triggered = undefined; 340 341 if ( tmp ) { 342 elem[ ontype ] = tmp; 343 } 344 } 345 } 346 } 347 348 return event.result; 349 }, 350 351 dispatch: function( event ) { 352 353 // Make a writable jQuery.Event from the native event object 354 event = jQuery.event.fix( event ); 355 356 var i, j, ret, matched, handleObj, 357 handlerQueue = [], 358 args = slice.call( arguments ), 359 handlers = ( data_priv.get( this, "events" ) || {} )[ event.type ] || [], 360 special = jQuery.event.special[ event.type ] || {}; 361 362 // Use the fix-ed jQuery.Event rather than the (read-only) native event 363 args[0] = event; 364 event.delegateTarget = this; 365 366 // Call the preDispatch hook for the mapped type, and let it bail if desired 367 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 368 return; 369 } 370 371 // Determine handlers 372 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 373 374 // Run delegates first; they may want to stop propagation beneath us 375 i = 0; 376 while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) { 377 event.currentTarget = matched.elem; 378 379 j = 0; 380 while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) { 381 382 // Triggered event must either 1) have no namespace, or 383 // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). 384 if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) { 385 386 event.handleObj = handleObj; 387 event.data = handleObj.data; 388 389 ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) 390 .apply( matched.elem, args ); 391 392 if ( ret !== undefined ) { 393 if ( (event.result = ret) === false ) { 394 event.preventDefault(); 395 event.stopPropagation(); 396 } 397 } 398 } 399 } 400 } 401 402 // Call the postDispatch hook for the mapped type 403 if ( special.postDispatch ) { 404 special.postDispatch.call( this, event ); 405 } 406 407 return event.result; 408 }, 409 410 handlers: function( event, handlers ) { 411 var i, matches, sel, handleObj, 412 handlerQueue = [], 413 delegateCount = handlers.delegateCount, 414 cur = event.target; 415 416 // Find delegate handlers 417 // Black-hole SVG <use> instance trees (#13180) 418 // Avoid non-left-click bubbling in Firefox (#3861) 419 if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) { 420 421 for ( ; cur !== this; cur = cur.parentNode || this ) { 422 423 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) 424 if ( cur.disabled !== true || event.type !== "click" ) { 425 matches = []; 426 for ( i = 0; i < delegateCount; i++ ) { 427 handleObj = handlers[ i ]; 428 429 // Don't conflict with Object.prototype properties (#13203) 430 sel = handleObj.selector + " "; 431 432 if ( matches[ sel ] === undefined ) { 433 matches[ sel ] = handleObj.needsContext ? 434 jQuery( sel, this ).index( cur ) >= 0 : 435 jQuery.find( sel, this, null, [ cur ] ).length; 436 } 437 if ( matches[ sel ] ) { 438 matches.push( handleObj ); 439 } 440 } 441 if ( matches.length ) { 442 handlerQueue.push({ elem: cur, handlers: matches }); 443 } 444 } 445 } 446 } 447 448 // Add the remaining (directly-bound) handlers 449 if ( delegateCount < handlers.length ) { 450 handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) }); 451 } 452 453 return handlerQueue; 454 }, 455 456 // Includes some event props shared by KeyEvent and MouseEvent 457 props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), 458 459 fixHooks: {}, 460 461 keyHooks: { 462 props: "char charCode key keyCode".split(" "), 463 filter: function( event, original ) { 464 465 // Add which for key events 466 if ( event.which == null ) { 467 event.which = original.charCode != null ? original.charCode : original.keyCode; 468 } 469 470 return event; 471 } 472 }, 473 474 mouseHooks: { 475 props: "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "), 476 filter: function( event, original ) { 477 var eventDoc, doc, body, 478 button = original.button; 479 480 // Calculate pageX/Y if missing and clientX/Y available 481 if ( event.pageX == null && original.clientX != null ) { 482 eventDoc = event.target.ownerDocument || document; 483 doc = eventDoc.documentElement; 484 body = eventDoc.body; 485 486 event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); 487 event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); 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, copy, 507 type = event.type, 508 originalEvent = event, 509 fixHook = this.fixHooks[ type ]; 510 511 if ( !fixHook ) { 512 this.fixHooks[ type ] = fixHook = 513 rmouseEvent.test( type ) ? this.mouseHooks : 514 rkeyEvent.test( type ) ? this.keyHooks : 515 {}; 516 } 517 copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; 518 519 event = new jQuery.Event( originalEvent ); 520 521 i = copy.length; 522 while ( i-- ) { 523 prop = copy[ i ]; 524 event[ prop ] = originalEvent[ prop ]; 525 } 526 527 // Support: Cordova 2.5 (WebKit) (#13255) 528 // All events should have a target; Cordova deviceready doesn't 529 if ( !event.target ) { 530 event.target = document; 531 } 532 533 // Support: Safari 6.0+, Chrome < 28 534 // Target should not be a text node (#504, #13143) 535 if ( event.target.nodeType === 3 ) { 536 event.target = event.target.parentNode; 537 } 538 539 return fixHook.filter ? fixHook.filter( event, originalEvent ) : event; 540 }, 541 542 special: { 543 load: { 544 // Prevent triggered image.load events from bubbling to window.load 545 noBubble: true 546 }, 547 focus: { 548 // Fire native event if possible so blur/focus sequence is correct 549 trigger: function() { 550 if ( this !== safeActiveElement() && this.focus ) { 551 this.focus(); 552 return false; 553 } 554 }, 555 delegateType: "focusin" 556 }, 557 blur: { 558 trigger: function() { 559 if ( this === safeActiveElement() && this.blur ) { 560 this.blur(); 561 return false; 562 } 563 }, 564 delegateType: "focusout" 565 }, 566 click: { 567 // For checkbox, fire native event so checked state will be right 568 trigger: function() { 569 if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) { 570 this.click(); 571 return false; 572 } 573 }, 574 575 // For cross-browser consistency, don't fire native .click() on links 576 _default: function( event ) { 577 return jQuery.nodeName( event.target, "a" ); 578 } 579 }, 580 581 beforeunload: { 582 postDispatch: function( event ) { 583 584 // Support: Firefox 20+ 585 // Firefox doesn't alert if the returnValue field is not set. 586 if ( event.result !== undefined && event.originalEvent ) { 587 event.originalEvent.returnValue = event.result; 588 } 589 } 590 } 591 }, 592 593 simulate: function( type, elem, event, bubble ) { 594 // Piggyback on a donor event to simulate a different one. 595 // Fake originalEvent to avoid donor's stopPropagation, but if the 596 // simulated event prevents default then we do the same on the donor. 597 var e = jQuery.extend( 598 new jQuery.Event(), 599 event, 600 { 601 type: type, 602 isSimulated: true, 603 originalEvent: {} 604 } 605 ); 606 if ( bubble ) { 607 jQuery.event.trigger( e, null, elem ); 608 } else { 609 jQuery.event.dispatch.call( elem, e ); 610 } 611 if ( e.isDefaultPrevented() ) { 612 event.preventDefault(); 613 } 614 } 615}; 616 617jQuery.removeEvent = function( elem, type, handle ) { 618 if ( elem.removeEventListener ) { 619 elem.removeEventListener( type, handle, false ); 620 } 621}; 622 623jQuery.Event = function( src, props ) { 624 // Allow instantiation without the 'new' keyword 625 if ( !(this instanceof jQuery.Event) ) { 626 return new jQuery.Event( src, props ); 627 } 628 629 // Event object 630 if ( src && src.type ) { 631 this.originalEvent = src; 632 this.type = src.type; 633 634 // Events bubbling up the document may have been marked as prevented 635 // by a handler lower down the tree; reflect the correct value. 636 this.isDefaultPrevented = src.defaultPrevented || 637 src.defaultPrevented === undefined && 638 // Support: Android < 4.0 639 src.returnValue === false ? 640 returnTrue : 641 returnFalse; 642 643 // Event type 644 } else { 645 this.type = src; 646 } 647 648 // Put explicitly provided properties onto the event object 649 if ( props ) { 650 jQuery.extend( this, props ); 651 } 652 653 // Create a timestamp if incoming event doesn't have one 654 this.timeStamp = src && src.timeStamp || jQuery.now(); 655 656 // Mark it as fixed 657 this[ jQuery.expando ] = true; 658}; 659 660// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 661// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 662jQuery.Event.prototype = { 663 isDefaultPrevented: returnFalse, 664 isPropagationStopped: returnFalse, 665 isImmediatePropagationStopped: returnFalse, 666 667 preventDefault: function() { 668 var e = this.originalEvent; 669 670 this.isDefaultPrevented = returnTrue; 671 672 if ( e && e.preventDefault ) { 673 e.preventDefault(); 674 } 675 }, 676 stopPropagation: function() { 677 var e = this.originalEvent; 678 679 this.isPropagationStopped = returnTrue; 680 681 if ( e && e.stopPropagation ) { 682 e.stopPropagation(); 683 } 684 }, 685 stopImmediatePropagation: function() { 686 var e = this.originalEvent; 687 688 this.isImmediatePropagationStopped = returnTrue; 689 690 if ( e && e.stopImmediatePropagation ) { 691 e.stopImmediatePropagation(); 692 } 693 694 this.stopPropagation(); 695 } 696}; 697 698// Create mouseenter/leave events using mouseover/out and event-time checks 699// Support: Chrome 15+ 700jQuery.each({ 701 mouseenter: "mouseover", 702 mouseleave: "mouseout", 703 pointerenter: "pointerover", 704 pointerleave: "pointerout" 705}, function( orig, fix ) { 706 jQuery.event.special[ orig ] = { 707 delegateType: fix, 708 bindType: fix, 709 710 handle: function( event ) { 711 var ret, 712 target = this, 713 related = event.relatedTarget, 714 handleObj = event.handleObj; 715 716 // For mousenter/leave call the handler if related is outside the target. 717 // NB: No relatedTarget if the mouse left/entered the browser window 718 if ( !related || (related !== target && !jQuery.contains( target, related )) ) { 719 event.type = handleObj.origType; 720 ret = handleObj.handler.apply( this, arguments ); 721 event.type = fix; 722 } 723 return ret; 724 } 725 }; 726}); 727 728// Create "bubbling" focus and blur events 729// Support: Firefox, Chrome, Safari 730if ( !support.focusinBubbles ) { 731 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { 732 733 // Attach a single capturing handler on the document while someone wants focusin/focusout 734 var handler = function( event ) { 735 jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); 736 }; 737 738 jQuery.event.special[ fix ] = { 739 setup: function() { 740 var doc = this.ownerDocument || this, 741 attaches = data_priv.access( doc, fix ); 742 743 if ( !attaches ) { 744 doc.addEventListener( orig, handler, true ); 745 } 746 data_priv.access( doc, fix, ( attaches || 0 ) + 1 ); 747 }, 748 teardown: function() { 749 var doc = this.ownerDocument || this, 750 attaches = data_priv.access( doc, fix ) - 1; 751 752 if ( !attaches ) { 753 doc.removeEventListener( orig, handler, true ); 754 data_priv.remove( doc, fix ); 755 756 } else { 757 data_priv.access( doc, fix, attaches ); 758 } 759 } 760 }; 761 }); 762} 763 764jQuery.fn.extend({ 765 766 on: function( types, selector, data, fn, /*INTERNAL*/ one ) { 767 var origFn, type; 768 769 // Types can be a map of types/handlers 770 if ( typeof types === "object" ) { 771 // ( types-Object, selector, data ) 772 if ( typeof selector !== "string" ) { 773 // ( types-Object, data ) 774 data = data || selector; 775 selector = undefined; 776 } 777 for ( type in types ) { 778 this.on( type, selector, data, types[ type ], one ); 779 } 780 return this; 781 } 782 783 if ( data == null && fn == null ) { 784 // ( types, fn ) 785 fn = selector; 786 data = selector = undefined; 787 } else if ( fn == null ) { 788 if ( typeof selector === "string" ) { 789 // ( types, selector, fn ) 790 fn = data; 791 data = undefined; 792 } else { 793 // ( types, data, fn ) 794 fn = data; 795 data = selector; 796 selector = undefined; 797 } 798 } 799 if ( fn === false ) { 800 fn = returnFalse; 801 } else if ( !fn ) { 802 return this; 803 } 804 805 if ( one === 1 ) { 806 origFn = fn; 807 fn = function( event ) { 808 // Can use an empty set, since event contains the info 809 jQuery().off( event ); 810 return origFn.apply( this, arguments ); 811 }; 812 // Use same guid so caller can remove using origFn 813 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 814 } 815 return this.each( function() { 816 jQuery.event.add( this, types, fn, data, selector ); 817 }); 818 }, 819 one: function( types, selector, data, fn ) { 820 return this.on( types, selector, data, fn, 1 ); 821 }, 822 off: function( types, selector, fn ) { 823 var handleObj, type; 824 if ( types && types.preventDefault && types.handleObj ) { 825 // ( event ) dispatched jQuery.Event 826 handleObj = types.handleObj; 827 jQuery( types.delegateTarget ).off( 828 handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, 829 handleObj.selector, 830 handleObj.handler 831 ); 832 return this; 833 } 834 if ( typeof types === "object" ) { 835 // ( types-object [, selector] ) 836 for ( type in types ) { 837 this.off( type, selector, types[ type ] ); 838 } 839 return this; 840 } 841 if ( selector === false || typeof selector === "function" ) { 842 // ( types [, fn] ) 843 fn = selector; 844 selector = undefined; 845 } 846 if ( fn === false ) { 847 fn = returnFalse; 848 } 849 return this.each(function() { 850 jQuery.event.remove( this, types, fn, selector ); 851 }); 852 }, 853 854 trigger: function( type, data ) { 855 return this.each(function() { 856 jQuery.event.trigger( type, data, this ); 857 }); 858 }, 859 triggerHandler: function( type, data ) { 860 var elem = this[0]; 861 if ( elem ) { 862 return jQuery.event.trigger( type, data, elem, true ); 863 } 864 } 865}); 866 867return jQuery; 868});