Proyectos de Subversion Moodle

YUI.add('event-synthetic', function (Y, NAME) {

/**

 * Define new DOM events that can be subscribed to from Nodes.

 *

 * @module event

 * @submodule event-synthetic

 */

var CustomEvent = Y.CustomEvent,

    DOMMap   = Y.Env.evt.dom_map,

    toArray  = Y.Array,

    YLang    = Y.Lang,

    isObject = YLang.isObject,

    isString = YLang.isString,

    isArray  = YLang.isArray,

    query    = Y.Selector.query,

    noop     = function () {};

/**

 * <p>The triggering mechanism used by SyntheticEvents.</p>

 *

 * <p>Implementers should not instantiate these directly.  Use the Notifier

 * provided to the event's implemented <code>on(node, sub, notifier)</code> or

 * <code>delegate(node, sub, notifier, filter)</code> methods.</p>

 *

 * @class SyntheticEvent.Notifier

 * @constructor

 * @param handle {EventHandle} the detach handle for the subscription to an

 *              internal custom event used to execute the callback passed to

 *              on(..) or delegate(..)

 * @param emitFacade {Boolean} take steps to ensure the first arg received by

 *              the subscription callback is an event facade

 * @private

 * @since 3.2.0

 */

function Notifier(handle, emitFacade) {

    this.handle     = handle;

    this.emitFacade = emitFacade;

}

/**

 * <p>Executes the subscription callback, passing the firing arguments as the

 * first parameters to that callback. For events that are configured with

 * emitFacade=true, it is common practice to pass the triggering DOMEventFacade

 * as the first parameter.  Barring a proper DOMEventFacade or EventFacade

 * (from a CustomEvent), a new EventFacade will be generated.  In that case, if

 * fire() is called with a simple object, it will be mixed into the facade.

 * Otherwise, the facade will be prepended to the callback parameters.</p>

 *

 * <p>For notifiers provided to delegate logic, the first argument should be an

 * object with a "currentTarget" property to identify what object to

 * default as 'this' in the callback.  Typically this is gleaned from the

 * DOMEventFacade or EventFacade, but if configured with emitFacade=false, an

 * object must be provided.  In that case, the object will be removed from the

 * callback parameters.</p>

 *

 * <p>Additional arguments passed during event subscription will be

 * automatically added after those passed to fire().</p>

 *

 * @method fire

 * @param {EventFacade|DOMEventFacade|any} e (see description)

 * @param {any[]} [arg*] additional arguments received by all subscriptions

 * @private

 */

Notifier.prototype.fire = function (e) {

    // first arg to delegate notifier should be an object with currentTarget

    var args     = toArray(arguments, 0, true),

        handle   = this.handle,

        ce       = handle.evt,

        sub      = handle.sub,

        thisObj  = sub.context,

        delegate = sub.filter,

        event    = e || {},

        ret;

    if (this.emitFacade) {

        if (!e || !e.preventDefault) {

            event = ce._getFacade();

            if (isObject(e) && !e.preventDefault) {

                Y.mix(event, e, true);

                args[0] = event;

            } else {

                args.unshift(event);

            }

        }

        event.type    = ce.type;

        event.details = args.slice();

        if (delegate) {

            event.container = ce.host;

        }

    } else if (delegate && isObject(e) && e.currentTarget) {

        args.shift();

    }

    sub.context = thisObj || event.currentTarget || ce.host;

    ret = ce.fire.apply(ce, args);

    // have to handle preventedFn and stoppedFn manually because

    // Notifier CustomEvents are forced to emitFacade=false

    if (e.prevented && ce.preventedFn) {

        ce.preventedFn.apply(ce, args);

    }

    if (e.stopped && ce.stoppedFn) {

        ce.stoppedFn.apply(ce, args);

    }

    sub.context = thisObj; // reset for future firing

    // to capture callbacks that return false to stopPropagation.

    // Useful for delegate implementations

    return ret;

};

/**

 * Manager object for synthetic event subscriptions to aggregate multiple synths on the

 * same node without colliding with actual DOM subscription entries in the global map of

 * DOM subscriptions.  Also facilitates proper cleanup on page unload.

 *

 * @class SynthRegistry

 * @constructor

 * @param el {HTMLElement} the DOM element

 * @param yuid {String} the yuid stamp for the element

 * @param key {String} the generated id token used to identify an event type +

 *                     element in the global DOM subscription map.

 * @private

 */

function SynthRegistry(el, yuid, key) {

    this.handles = [];

    this.el      = el;

    this.key     = key;

    this.domkey  = yuid;

}

SynthRegistry.prototype = {

    constructor: SynthRegistry,

    // A few object properties to fake the CustomEvent interface for page

    // unload cleanup.  DON'T TOUCH!

    type      : '_synth',

    fn        : noop,

    capture   : false,

    /**

     * Adds a subscription from the Notifier registry.

     *

     * @method register

     * @param handle {EventHandle} the subscription

     * @since 3.4.0

     */

    register: function (handle) {

        handle.evt.registry = this;

        this.handles.push(handle);

    },

    /**

     * Removes the subscription from the Notifier registry.

     *

     * @method _unregisterSub

     * @param sub {Subscription} the subscription

     * @since 3.4.0

     */

    unregister: function (sub) {

        var handles = this.handles,

            events = DOMMap[this.domkey],

            i;

        for (i = handles.length - 1; i >= 0; --i) {

            if (handles[i].sub === sub) {

                handles.splice(i, 1);

                break;

            }

        }

        // Clean up left over objects when there are no more subscribers.

        if (!handles.length) {

            delete events[this.key];

            if (!Y.Object.size(events)) {

                delete DOMMap[this.domkey];

            }

        }

    },

    /**

     * Used by the event system's unload cleanup process.  When navigating

     * away from the page, the event system iterates the global map of element

     * subscriptions and detaches everything using detachAll().  Normally,

     * the map is populated with custom events, so this object needs to

     * at least support the detachAll method to duck type its way to

     * cleanliness.

     *

     * @method detachAll

     * @private

     * @since 3.4.0

     */

    detachAll : function () {

        var handles = this.handles,

            i = handles.length;

        while (--i >= 0) {

            handles[i].detach();

        }

    }

};

/**

 * <p>Wrapper class for the integration of new events into the YUI event

 * infrastructure.  Don't instantiate this object directly, use

 * <code>Y.Event.define(type, config)</code>.  See that method for details.</p>

 *

 * <p>Properties that MAY or SHOULD be specified in the configuration are noted

 * below and in the description of <code>Y.Event.define</code>.</p>

 *

 * @class SyntheticEvent

 * @constructor

 * @param cfg {Object} Implementation pieces and configuration

 * @since 3.1.0

 * @in event-synthetic

 */

function SyntheticEvent() {

    this._init.apply(this, arguments);

}

Y.mix(SyntheticEvent, {

    Notifier: Notifier,

    SynthRegistry: SynthRegistry,

    /**

     * Returns the array of subscription handles for a node for the given event

     * type.  Passing true as the third argument will create a registry entry

     * in the event system's DOM map to host the array if one doesn't yet exist.

     *

     * @method getRegistry

     * @param node {Node} the node

     * @param type {String} the event

     * @param create {Boolean} create a registration entry to host a new array

     *                  if one doesn't exist.

     * @return {Array}

     * @static

     * @protected

     * @since 3.2.0

     */

    getRegistry: function (node, type, create) {

        var el     = node._node,

            yuid   = Y.stamp(el),

            key    = 'event:' + yuid + type + '_synth',

            events = DOMMap[yuid];

        if (create) {

            if (!events) {

                events = DOMMap[yuid] = {};

            }

            if (!events[key]) {

                events[key] = new SynthRegistry(el, yuid, key);

            }

        }

        return (events && events[key]) || null;

    },

    /**

     * Alternate <code>_delete()</code> method for the CustomEvent object

     * created to manage SyntheticEvent subscriptions.

     *

     * @method _deleteSub

     * @param sub {Subscription} the subscription to clean up

     * @private

     * @since 3.2.0

     */

    _deleteSub: function (sub) {

        if (sub && sub.fn) {

            var synth = this.eventDef,

                method = (sub.filter) ? 'detachDelegate' : 'detach';

            this._subscribers = [];

            if (CustomEvent.keepDeprecatedSubs) {

                this.subscribers = {};

            }

            synth[method](sub.node, sub, this.notifier, sub.filter);

            this.registry.unregister(sub);

            delete sub.fn;

            delete sub.node;

            delete sub.context;

        }

    },

    prototype: {

        constructor: SyntheticEvent,

        /**

         * Construction logic for the event.

         *

         * @method _init

         * @protected

         */

        _init: function () {

            var config = this.publishConfig || (this.publishConfig = {});

            // The notification mechanism handles facade creation

            this.emitFacade = ('emitFacade' in config) ?

                                config.emitFacade :

                                true;

            config.emitFacade  = false;

        },

        /**

         * <p>Implementers MAY provide this method definition.</p>

         *

         * <p>Implement this function if the event supports a different

         * subscription signature.  This function is used by both

         * <code>on()</code> and <code>delegate()</code>.  The second parameter

         * indicates that the event is being subscribed via

         * <code>delegate()</code>.</p>

         *

         * <p>Implementations must remove extra arguments from the args list

         * before returning.  The required args for <code>on()</code>

         * subscriptions are</p>

         * <pre><code>[type, callback, target, context, argN...]</code></pre>

         *

         * <p>The required args for <code>delegate()</code>

         * subscriptions are</p>

         *

         * <pre><code>[type, callback, target, filter, context, argN...]</code></pre>

         *

         * <p>The return value from this function will be stored on the

         * subscription in the '_extra' property for reference elsewhere.</p>

         *

         * @method processArgs

         * @param args {Array} parmeters passed to Y.on(..) or Y.delegate(..)

         * @param delegate {Boolean} true if the subscription is from Y.delegate

         * @return {any}

         */

        processArgs: noop,

        /**

         * <p>Implementers MAY override this property.</p>

         *

         * <p>Whether to prevent multiple subscriptions to this event that are

         * classified as being the same.  By default, this means the subscribed

         * callback is the same function.  See the <code>subMatch</code>

         * method.  Setting this to true will impact performance for high volume

         * events.</p>

         *

         * @property preventDups

         * @type {Boolean}

         * @default false

         */

        //preventDups  : false,

        /**

         * <p>Implementers SHOULD provide this method definition.</p>

         *

         * Implementation logic for subscriptions done via <code>node.on(type,

         * fn)</code> or <code>Y.on(type, fn, target)</code>.  This

         * function should set up the monitor(s) that will eventually fire the

         * event.  Typically this involves subscribing to at least one DOM

         * event.  It is recommended to store detach handles from any DOM

         * subscriptions to make for easy cleanup in the <code>detach</code>

         * method.  Typically these handles are added to the <code>sub</code>

         * object.  Also for SyntheticEvents that leverage a single DOM

         * subscription under the hood, it is recommended to pass the DOM event

         * object to <code>notifier.fire(e)</code>.  (The event name on the

         * object will be updated).

         *

         * @method on

         * @param node {Node} the node the subscription is being applied to

         * @param sub {Subscription} the object to track this subscription

         * @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to

         *              trigger the execution of the subscribers

         */

        on: noop,

        /**

         * <p>Implementers SHOULD provide this method definition.</p>

         *

         * <p>Implementation logic for detaching subscriptions done via

         * <code>node.on(type, fn)</code>.  This function should clean up any

         * subscriptions made in the <code>on()</code> phase.</p>

         *

         * @method detach

         * @param node {Node} the node the subscription was applied to

         * @param sub {Subscription} the object tracking this subscription

         * @param notifier {SyntheticEvent.Notifier} the Notifier used to

         *              trigger the execution of the subscribers

         */

        detach: noop,

        /**

         * <p>Implementers SHOULD provide this method definition.</p>

         *

         * <p>Implementation logic for subscriptions done via

         * <code>node.delegate(type, fn, filter)</code> or

         * <code>Y.delegate(type, fn, container, filter)</code>.  Like with

         * <code>on()</code> above, this function should monitor the environment

         * for the event being fired, and trigger subscription execution by

         * calling <code>notifier.fire(e)</code>.</p>

         *

         * <p>This function receives a fourth argument, which is the filter

         * used to identify which Node's are of interest to the subscription.

         * The filter will be either a boolean function that accepts a target

         * Node for each hierarchy level as the event bubbles, or a selector

         * string.  To translate selector strings into filter functions, use

         * <code>Y.delegate.compileFilter(filter)</code>.</p>

         *

         * @method delegate

         * @param node {Node} the node the subscription is being applied to

         * @param sub {Subscription} the object to track this subscription

         * @param notifier {SyntheticEvent.Notifier} call notifier.fire(..) to

         *              trigger the execution of the subscribers

         * @param filter {String|Function} Selector string or function that

         *              accepts an event object and returns null, a Node, or an

         *              array of Nodes matching the criteria for processing.

         * @since 3.2.0

         */

        delegate       : noop,

        /**

         * <p>Implementers SHOULD provide this method definition.</p>

         *

         * <p>Implementation logic for detaching subscriptions done via

         * <code>node.delegate(type, fn, filter)</code> or

         * <code>Y.delegate(type, fn, container, filter)</code>.  This function

         * should clean up any subscriptions made in the

         * <code>delegate()</code> phase.</p>

         *

         * @method detachDelegate

         * @param node {Node} the node the subscription was applied to

         * @param sub {Subscription} the object tracking this subscription

         * @param notifier {SyntheticEvent.Notifier} the Notifier used to

         *              trigger the execution of the subscribers

         * @param filter {String|Function} Selector string or function that

         *              accepts an event object and returns null, a Node, or an

         *              array of Nodes matching the criteria for processing.

         * @since 3.2.0

         */

        detachDelegate : noop,

        /**

         * Sets up the boilerplate for detaching the event and facilitating the

         * execution of subscriber callbacks.

         *

         * @method _on

         * @param args {Array} array of arguments passed to

         *              <code>Y.on(...)</code> or <code>Y.delegate(...)</code>

         * @param delegate {Boolean} true if called from

         * <code>Y.delegate(...)</code>

         * @return {EventHandle} the detach handle for this subscription

         * @private

         * since 3.2.0

         */

        _on: function (args, delegate) {

            var handles  = [],

                originalArgs = args.slice(),

                extra    = this.processArgs(args, delegate),

                selector = args[2],

                method   = delegate ? 'delegate' : 'on',

                nodes, handle;

            // Can't just use Y.all because it doesn't support window (yet?)

            nodes = (isString(selector)) ?

                query(selector) :

                toArray(selector || Y.one(Y.config.win));

            if (!nodes.length && isString(selector)) {

                handle = Y.on('available', function () {

                    Y.mix(handle, Y[method].apply(Y, originalArgs), true);

                }, selector);

                return handle;

            }

            Y.Array.each(nodes, function (node) {

                var subArgs = args.slice(),

                    filter;

                node = Y.one(node);

                if (node) {

                    if (delegate) {

                        filter = subArgs.splice(3, 1)[0];

                    }

                    // (type, fn, el, thisObj, ...) => (fn, thisObj, ...)

                    subArgs.splice(0, 4, subArgs[1], subArgs[3]);

                    if (!this.preventDups ||

                        !this.getSubs(node, args, null, true))

                    {

                        handles.push(this._subscribe(node, method, subArgs, extra, filter));

                    }

                }

            }, this);

            return (handles.length === 1) ?

                handles[0] :

                new Y.EventHandle(handles);

        },

        /**

         * Creates a new Notifier object for use by this event's

         * <code>on(...)</code> or <code>delegate(...)</code> implementation

         * and register the custom event proxy in the DOM system for cleanup.

         *

         * @method _subscribe

         * @param node {Node} the Node hosting the event

         * @param method {String} "on" or "delegate"

         * @param args {Array} the subscription arguments passed to either

         *              <code>Y.on(...)</code> or <code>Y.delegate(...)</code>

         *              after running through <code>processArgs(args)</code> to

         *              normalize the argument signature

         * @param extra {any} Extra data parsed from

         *              <code>processArgs(args)</code>

         * @param filter {String|Function} the selector string or function

         *              filter passed to <code>Y.delegate(...)</code> (not

         *              present when called from <code>Y.on(...)</code>)

         * @return {EventHandle}

         * @private

         * @since 3.2.0

         */

        _subscribe: function (node, method, args, extra, filter) {

            var dispatcher = new Y.CustomEvent(this.type, this.publishConfig),

                handle     = dispatcher.on.apply(dispatcher, args),

                notifier   = new Notifier(handle, this.emitFacade),

                registry   = SyntheticEvent.getRegistry(node, this.type, true),

                sub        = handle.sub;

            sub.node   = node;

            sub.filter = filter;

            if (extra) {

                this.applyArgExtras(extra, sub);

            }

            Y.mix(dispatcher, {

                eventDef     : this,

                notifier     : notifier,

                host         : node,       // I forget what this is for

                currentTarget: node,       // for generating facades

                target       : node,       // for generating facades

                el           : node._node, // For category detach

                _delete      : SyntheticEvent._deleteSub

            }, true);

            handle.notifier = notifier;

            registry.register(handle);

            // Call the implementation's "on" or "delegate" method

            this[method](node, sub, notifier, filter);

            return handle;

        },

        /**

         * <p>Implementers MAY provide this method definition.</p>

         *

         * <p>Implement this function if you want extra data extracted during

         * processArgs to be propagated to subscriptions on a per-node basis.

         * That is to say, if you call <code>Y.on('xyz', fn, xtra, 'div')</code>

         * the data returned from processArgs will be shared

         * across the subscription objects for all the divs.  If you want each

         * subscription to receive unique information, do that processing

         * here.</p>

         *

         * <p>The default implementation adds the data extracted by processArgs

         * to the subscription object as <code>sub._extra</code>.</p>

         *

         * @method applyArgExtras

         * @param extra {any} Any extra data extracted from processArgs

         * @param sub {Subscription} the individual subscription

         */

        applyArgExtras: function (extra, sub) {

            sub._extra = extra;

        },

        /**

         * Removes the subscription(s) from the internal subscription dispatch

         * mechanism.  See <code>SyntheticEvent._deleteSub</code>.

         *

         * @method _detach

         * @param args {Array} The arguments passed to

         *                  <code>node.detach(...)</code>

         * @private

         * @since 3.2.0

         */

        _detach: function (args) {

            // Can't use Y.all because it doesn't support window (yet?)

            // TODO: Does Y.all support window now?

            var target = args[2],

                els    = (isString(target)) ?

                            query(target) : toArray(target),

                node, i, len, handles, j;

            // (type, fn, el, context, filter?) => (type, fn, context, filter?)

            args.splice(2, 1);

            for (i = 0, len = els.length; i < len; ++i) {

                node = Y.one(els[i]);

                if (node) {

                    handles = this.getSubs(node, args);

                    if (handles) {

                        for (j = handles.length - 1; j >= 0; --j) {

                            handles[j].detach();

                        }

                    }

                }

            }

        },

        /**

         * Returns the detach handles of subscriptions on a node that satisfy a

         * search/filter function.  By default, the filter used is the

         * <code>subMatch</code> method.

         *

         * @method getSubs

         * @param node {Node} the node hosting the event

         * @param args {Array} the array of original subscription args passed

         *              to <code>Y.on(...)</code> (before

         *              <code>processArgs</code>

         * @param filter {Function} function used to identify a subscription

         *              for inclusion in the returned array

         * @param first {Boolean} stop after the first match (used to check for

         *              duplicate subscriptions)

         * @return {EventHandle[]} detach handles for the matching subscriptions

         */

        getSubs: function (node, args, filter, first) {

            var registry = SyntheticEvent.getRegistry(node, this.type),

                handles  = [],

                allHandles, i, len, handle;

            if (registry) {

                allHandles = registry.handles;

                if (!filter) {

                    filter = this.subMatch;

                }

                for (i = 0, len = allHandles.length; i < len; ++i) {

                    handle = allHandles[i];

                    if (filter.call(this, handle.sub, args)) {

                        if (first) {

                            return handle;

                        } else {

                            handles.push(allHandles[i]);

                        }

                    }

                }

            }

            return handles.length && handles;

        },

        /**

         * <p>Implementers MAY override this to define what constitutes a

         * "same" subscription.  Override implementations should

         * consider the lack of a comparator as a match, so calling

         * <code>getSubs()</code> with no arguments will return all subs.</p>

         *

         * <p>Compares a set of subscription arguments against a Subscription

         * object to determine if they match.  The default implementation

         * compares the callback function against the second argument passed to

         * <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>

         *

         * @method subMatch

         * @param sub {Subscription} the existing subscription

         * @param args {Array} the calling arguments passed to

         *                  <code>Y.on(...)</code> etc.

         * @return {Boolean} true if the sub can be described by the args

         *                  present

         * @since 3.2.0

         */

        subMatch: function (sub, args) {

            // Default detach cares only about the callback matching

            return !args[1] || sub.fn === args[1];

        }

    }

}, true);

Y.SyntheticEvent = SyntheticEvent;

/**

 * <p>Defines a new event in the DOM event system.  Implementers are

 * responsible for monitoring for a scenario whereby the event is fired.  A

 * notifier object is provided to the functions identified below.  When the

 * criteria defining the event are met, call notifier.fire( [args] ); to

 * execute event subscribers.</p>

 *

 * <p>The first parameter is the name of the event.  The second parameter is a

 * configuration object which define the behavior of the event system when the

 * new event is subscribed to or detached from.  The methods that should be

 * defined in this configuration object are <code>on</code>,

 * <code>detach</code>, <code>delegate</code>, and <code>detachDelegate</code>.

 * You are free to define any other methods or properties needed to define your

 * event.  Be aware, however, that since the object is used to subclass

 * SyntheticEvent, you should avoid method names used by SyntheticEvent unless

 * your intention is to override the default behavior.</p>

 *

 * <p>This is a list of properties and methods that you can or should specify

 * in the configuration object:</p>

 *

 * <dl>

 *   <dt><code>on</code></dt>

 *       <dd><code>function (node, subscription, notifier)</code> The

 *       implementation logic for subscription.  Any special setup you need to

 *       do to create the environment for the event being fired--E.g. native

 *       DOM event subscriptions.  Store subscription related objects and

 *       state on the <code>subscription</code> object.  When the

 *       criteria have been met to fire the synthetic event, call

 *       <code>notifier.fire(e)</code>.  See Notifier's <code>fire()</code>

 *       method for details about what to pass as parameters.</dd>

 *

 *   <dt><code>detach</code></dt>

 *       <dd><code>function (node, subscription, notifier)</code> The

 *       implementation logic for cleaning up a detached subscription. E.g.

 *       detach any DOM subscriptions added in <code>on</code>.</dd>

 *

 *   <dt><code>delegate</code></dt>

 *       <dd><code>function (node, subscription, notifier, filter)</code> The

 *       implementation logic for subscription via <code>Y.delegate</code> or

 *       <code>node.delegate</code>.  The filter is typically either a selector

 *       string or a function.  You can use

 *       <code>Y.delegate.compileFilter(selectorString)</code> to create a

 *       filter function from a selector string if needed.  The filter function

 *       expects an event object as input and should output either null, a

 *       matching Node, or an array of matching Nodes.  Otherwise, this acts

 *       like <code>on</code> DOM event subscriptions.  Store subscription

 *       related objects and information on the <code>subscription</code>

 *       object.  When the criteria have been met to fire the synthetic event,

 *       call <code>notifier.fire(e)</code> as noted above.</dd>

 *

 *   <dt><code>detachDelegate</code></dt>

 *       <dd><code>function (node, subscription, notifier)</code> The

 *       implementation logic for cleaning up a detached delegate subscription.

 *       E.g. detach any DOM delegate subscriptions added in

 *       <code>delegate</code>.</dd>

 *

 *   <dt><code>publishConfig</code></dt>

 *       <dd>(Object) The configuration object that will be used to instantiate

 *       the underlying CustomEvent. See Notifier's <code>fire</code> method

 *       for details.</dd>

 *

 *   <dt><code>processArgs</code></dt

 *       <dd>

 *          <p><code>function (argArray, fromDelegate)</code> Optional method

 *          to extract any additional arguments from the subscription

 *          signature.  Using this allows <code>on</code> or

 *          <code>delegate</code> signatures like

 *          <code>node.on(&quot;hover&quot;, overCallback,

 *          outCallback)</code>.</p>

 *          <p>When processing an atypical argument signature, make sure the

 *          args array is returned to the normal signature before returning

 *          from the function.  For example, in the "hover" example

 *          above, the <code>outCallback</code> needs to be <code>splice</code>d

 *          out of the array.  The expected signature of the args array for

 *          <code>on()</code> subscriptions is:</p>

 *          <pre>

 *              <code>[type, callback, target, contextOverride, argN...]</code>

 *          </pre>

 *          <p>And for <code>delegate()</code>:</p>

 *          <pre>

 *              <code>[type, callback, target, filter, contextOverride, argN...]</code>

 *          </pre>

 *          <p>where <code>target</code> is the node the event is being

 *          subscribed for.  You can see these signatures documented for

 *          <code>Y.on()</code> and <code>Y.delegate()</code> respectively.</p>

 *          <p>Whatever gets returned from the function will be stored on the

 *          <code>subscription</code> object under

 *          <code>subscription._extra</code>.</p></dd>

 *   <dt><code>subMatch</code></dt>

 *       <dd>

 *           <p><code>function (sub, args)</code>  Compares a set of

 *           subscription arguments against a Subscription object to determine

 *           if they match.  The default implementation compares the callback

 *           function against the second argument passed to

 *           <code>Y.on(...)</code> or <code>node.detach(...)</code> etc.</p>

 *       </dd>

 * </dl>

 *

 * @method define

 * @param type {String} the name of the event

 * @param config {Object} the prototype definition for the new event (see above)

 * @param force {Boolean} override an existing event (use with caution)

 * @return {SyntheticEvent} the subclass implementation instance created to

 *              handle event subscriptions of this type

 * @static

 * @for Event

 * @since 3.1.0

 * @in event-synthetic

 */

Y.Event.define = function (type, config, force) {

    var eventDef, Impl, synth;

    if (type && type.type) {

        eventDef = type;

        force = config;

    } else if (config) {

        eventDef = Y.merge({ type: type }, config);

    }

    if (eventDef) {

        if (force || !Y.Node.DOM_EVENTS[eventDef.type]) {

            Impl = function () {

                SyntheticEvent.apply(this, arguments);

            };

            Y.extend(Impl, SyntheticEvent, eventDef);

            synth = new Impl();

            type = synth.type;

            Y.Node.DOM_EVENTS[type] = Y.Env.evt.plugins[type] = {

                eventDef: synth,

                on: function () {

                    return synth._on(toArray(arguments));

                },

                delegate: function () {

                    return synth._on(toArray(arguments), true);

                },

                detach: function () {

                    return synth._detach(toArray(arguments));

                }

            };

        }

    } else if (isString(type) || isArray(type)) {

        Y.Array.each(toArray(type), function (t) {

            Y.Node.DOM_EVENTS[t] = 1;

        });

    }

    return synth;

};

}, '3.18.1', {"requires": ["node-base", "event-custom-complex"]});