src/event/trigger.js

define( [

    "../core",

    "../var/document",

    "../data/var/dataPriv",

    "../data/var/acceptData",

    "../var/hasOwn",

    "../event"

], function( jQuery, document, dataPriv, acceptData, hasOwn ) {

"use strict";

var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;

jQuery.extend( jQuery.event, {

    trigger: function( event, data, elem, onlyHandlers ) {

        var i, cur, tmp, bubbleType, ontype, handle, special,

            eventPath = [ elem || document ],

            type = hasOwn.call( event, "type" ) ? event.type : event,

            namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];

        cur = tmp = elem = elem || document;

        // Don't do events on text and comment nodes

        if ( elem.nodeType === 3 || elem.nodeType === 8 ) {

            return;

        }

        // focus/blur morphs to focusin/out; ensure we're not firing them right now

        if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {

            return;

        }

        if ( type.indexOf( "." ) > -1 ) {

            // Namespaced trigger; create a regexp to match event type in handle()

            namespaces = type.split( "." );

            type = namespaces.shift();

            namespaces.sort();

        }

        ontype = type.indexOf( ":" ) < 0 && "on" + type;

        // Caller can pass in a jQuery.Event object, Object, or just an event type string

        event = event[ jQuery.expando ] ?

            event :

            new jQuery.Event( type, typeof event === "object" && event );

        // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)

        event.isTrigger = onlyHandlers ? 2 : 3;

        event.namespace = namespaces.join( "." );

        event.rnamespace = event.namespace ?

            new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :

            null;

        // Clean up the event in case it is being reused

        event.result = undefined;

        if ( !event.target ) {

            event.target = elem;

        }

        // Clone any incoming data and prepend the event, creating the handler arg list

        data = data == null ?

            [ event ] :

            jQuery.makeArray( data, [ event ] );

        // Allow special events to draw outside the lines

        special = jQuery.event.special[ type ] || {};

        if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {

            return;

        }

        // Determine event propagation path in advance, per W3C events spec (#9951)

        // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)

        if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {

            bubbleType = special.delegateType || type;

            if ( !rfocusMorph.test( bubbleType + type ) ) {

                cur = cur.parentNode;

            }

            for ( ; cur; cur = cur.parentNode ) {

                eventPath.push( cur );

                tmp = cur;

            }

            // Only add window if we got to document (e.g., not plain obj or detached DOM)

            if ( tmp === ( elem.ownerDocument || document ) ) {

                eventPath.push( tmp.defaultView || tmp.parentWindow || window );

            }

        }

        // Fire handlers on the event path

        i = 0;

        while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {

            event.type = i > 1 ?

                bubbleType :

                special.bindType || type;

            // jQuery handler

            handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&

                dataPriv.get( cur, "handle" );

            if ( handle ) {

                handle.apply( cur, data );

            }

            // Native handler

            handle = ontype && cur[ ontype ];

            if ( handle && handle.apply && acceptData( cur ) ) {

                event.result = handle.apply( cur, data );

                if ( event.result === false ) {

                    event.preventDefault();

                }

            }

        }

        event.type = type;

        // If nobody prevented the default action, do it now

        if ( !onlyHandlers && !event.isDefaultPrevented() ) {

            if ( ( !special._default ||

                special._default.apply( eventPath.pop(), data ) === false ) &&

                acceptData( elem ) ) {

                // Call a native DOM method on the target with the same name as the event.

                // Don't do default actions on window, that's where global variables be (#6170)

                if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {

                    // Don't re-trigger an onFOO event when we call its FOO() method

                    tmp = elem[ ontype ];

                    if ( tmp ) {

                        elem[ ontype ] = null;

                    }

                    // Prevent re-triggering of the same event, since we already bubbled it above

                    jQuery.event.triggered = type;

                    elem[ type ]();

                    jQuery.event.triggered = undefined;

                    if ( tmp ) {

                        elem[ ontype ] = tmp;

                    }

                }

            }

        }

        return event.result;

    },

    // Piggyback on a donor event to simulate a different one

    // Used only for `focus(in | out)` events

    simulate: function( type, elem, event ) {

        var e = jQuery.extend(

            new jQuery.Event(),

            event,

            {

                type: type,

                isSimulated: true

            }

        );

        jQuery.event.trigger( e, null, elem );

    }

} );

jQuery.fn.extend( {

    trigger: function( type, data ) {

        return this.each( function() {

            jQuery.event.trigger( type, data, this );

        } );

    },

    triggerHandler: function( type, data ) {

        var elem = this[ 0 ];

        if ( elem ) {

            return jQuery.event.trigger( type, data, elem, true );

        }

    }

} );

return jQuery;

} );