Lines Matching refs:Event
3050 * By default a callback list will act like an event callback list and can be
3388 // the ready event fires. See #6781
3391 // Hold (or release) the ready event
3411 // If a normal DOM Ready event fired, decrement, and wait if need be
3428 * The ready event handler and self cleanup method
3441 // Catch cases where $(document).ready() is called after the browser event has already occurred.
3450 // Use the handy event callback
4084 jQuery.event = {
4112 // Init the element's event structure and main handler, if this is the first
4118 // Discard the second event of a jQuery.event.trigger() and
4119 // when an event is called after a page has unloaded
4120 return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type ?
4121 jQuery.event.dispatch.apply( elem, arguments ) : undefined;
4138 // If event changes its type, use the special event handlers for the changed type
4139 special = jQuery.event.special[ type ] || {};
4141 // If selector defined, determine special event api type, otherwise given type
4145 special = jQuery.event.special[ type ] || {};
4147 // handleObj is passed to all event handlers
4159 // Init the event handler queue if we're the first
4187 // Keep track of which events have ever been used, for event optimization
4188 jQuery.event.global[ type ] = true;
4193 // Detach an event or set of events from an element
4216 jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
4221 event.special[ type ] || {};
4246 // Remove generic event handler if we removed something and no more handlers exist
4247 // (avoids potential for endless recursion during removal of special event handlers)
4264 trigger: function( event, data, elem, onlyHandlers ) {
4268 type = hasOwn.call( event, "type" ) ? event.type : event,
4269 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
4279 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
4284 // Namespaced trigger; create a regexp to match event type in handle()
4291 // Caller can pass in a jQuery.Event object, Object, or just an event type string
4292 event = event[ jQuery.expando ] ?
4293 event :
4294 new jQuery.Event( type, typeof event === "object" && event );
4297 event.isTrigger = onlyHandlers ? 2 : 3;
4298 event.namespace = namespaces.join(".");
4299 event.namespace_re = event.namespace ?
4303 // Clean up the event in case it is being reused
4304 event.result = undefined;
4305 if ( !event.target ) {
4306 event.target = elem;
4309 // Clone any incoming data and prepend the event, creating the handler arg list
4311 [ event ] :
4312 jQuery.makeArray( data, [ event ] );
4315 special = jQuery.event.special[ type ] || {};
4320 // Determine event propagation path in advance, per W3C events spec (#9951)
4339 // Fire handlers on the event path
4341 while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
4343 event.type = i > 1 ?
4348 handle = ( data_priv.get( cur, "events" ) || {} )[ event.type ] && data_priv.get( cur, "handle" );
4356 event.result = handle.apply( cur, data );
4357 if ( event.result === false ) {
4358 event.preventDefault();
4362 event.type = type;
4365 if ( !onlyHandlers && !event.isDefaultPrevented() ) {
4370 // Call a native DOM method on the target with the same name name as the event.
4374 // Don't re-trigger an onFOO event when we call its FOO() method
4381 // Prevent re-triggering of the same event, since we already bubbled it above
4382 jQuery.event.triggered = type;
4384 jQuery.event.triggered = undefined;
4393 return event.result;
4396 dispatch: function( event ) {
4398 // Make a writable jQuery.Event from the native event object
4399 event = jQuery.event.fix( event );
4404 handlers = ( data_priv.get( this, "events" ) || {} )[ event.type ] || [],
4405 special = jQuery.event.special[ event.type ] || {};
4407 // Use the fix-ed jQuery.Event rather than the (read-only) native event
4408 args[0] = event;
4409 event.delegateTarget = this;
4412 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
4417 handlerQueue = jQuery.event.handlers.call( this, event, handlers );
4421 while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
4422 event.currentTarget = matched.elem;
4425 while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
4427 // Triggered event must either 1) have no namespace, or 2) have namespace(s)
4428 // a subset or equal to those in the bound event (both can have no namespace).
4429 if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
4431 event.handleObj = handleObj;
4432 event.data = handleObj.data;
4434 ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
4438 if ( (event.result = ret) === false ) {
4439 event.preventDefault();
4440 event.stopPropagation();
4449 special.postDispatch.call( this, event );
4452 return event.result;
4455 handlers: function( event, handlers ) {
4459 cur = event.target;
4464 if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
4469 if ( cur.disabled !== true || event.type !== "click" ) {
4501 // Includes some event props shared by KeyEvent and MouseEvent
4508 filter: function( event, original ) {
4511 if ( event.which == null ) {
4512 event.which = original.charCode != null ? original.charCode : original.keyCode;
4515 return event;
4521 filter: function( event, original ) {
4526 if ( event.pageX == null && original.clientX != null ) {
4527 eventDoc = event.target.ownerDocument || document;
4531 event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
4532 event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 );
4537 if ( !event.which && button !== undefined ) {
4538 event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
4541 return event;
4545 fix: function( event ) {
4546 if ( event[ jQuery.expando ] ) {
4547 return event;
4550 // Create a writable copy of the event object and normalize some properties
4552 type = event.type,
4553 originalEvent = event,
4564 event = new jQuery.Event( originalEvent );
4569 event[ prop ] = originalEvent[ prop ];
4574 if ( !event.target ) {
4575 event.target = document;
4580 if ( event.target.nodeType === 3 ) {
4581 event.target = event.target.parentNode;
4584 return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
4593 // Fire native event if possible so blur/focus sequence is correct
4612 // For checkbox, fire native event so checked state will be right
4621 _default: function( event ) {
4622 return jQuery.nodeName( event.target, "a" );
4627 postDispatch: function( event ) {
4631 if ( event.result !== undefined && event.originalEvent ) {
4632 event.originalEvent.returnValue = event.result;
4638 simulate: function( type, elem, event, bubble ) {
4639 // Piggyback on a donor event to simulate a different one.
4641 // simulated event prevents default then we do the same on the donor.
4643 new jQuery.Event(),
4644 event,
4652 jQuery.event.trigger( e, null, elem );
4654 jQuery.event.dispatch.call( elem, e );
4657 event.preventDefault();
4668 jQuery.Event = function( src, props ) {
4670 if ( !(this instanceof jQuery.Event) ) {
4671 return new jQuery.Event( src, props );
4674 // Event object
4688 // Event type
4693 // Put explicitly provided properties onto the event object
4698 // Create a timestamp if incoming event doesn't have one
4705 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
4707 jQuery.Event.prototype = {
4743 // Create mouseenter/leave events using mouseover/out and event-time checks
4751 jQuery.event.special[ orig ] = {
4755 handle: function( event ) {
4758 related = event.relatedTarget,
4759 handleObj = event.handleObj;
4764 event.type = handleObj.origType;
4766 event.type = fix;
4779 var handler = function( event ) {
4780 jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
4783 event.special[ fix ] = {
4852 fn = function( event ) {
4853 // Can use an empty set, since event contains the info
4854 jQuery().off( event );
4861 jQuery.event.add( this, types, fn, data, selector );
4870 // ( event ) dispatched jQuery.Event
4895 jQuery.event.remove( this, types, fn, selector );
4901 jQuery.event.trigger( type, data, this );
4907 return jQuery.event.trigger( type, data, elem, true );
5003 jQuery.event.add( dest, type, events[ type ][ i ] );
5173 special = jQuery.event.special,
5184 jQuery.event.remove( elem, type );
5186 // This is a shortcut to avoid jQuery.event.remove's overhead
7483 // Handle event binding
7937 jQuery.event,
8062 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
8063 fireGlobals = jQuery.event && s.global;
8067 jQuery.event.trigger("ajaxStart");
8153 // Send global event
8285 jQuery.event.trigger("ajaxStop");
