--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cm/media/js/lib/yui/yui_3.10.3/build/event-synthetic/event-synthetic.js Tue Jul 16 14:29:46 2013 +0200
@@ -0,0 +1,841 @@
+/*
+YUI 3.10.3 (build 2fb5187)
+Copyright 2013 Yahoo! Inc. All rights reserved.
+Licensed under the BSD License.
+http://yuilibrary.com/license/
+*/
+
+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 e {EventFacade|DOMEventFacade|Object|any} (see description)
+ * @param arg* {any} 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);
+ 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("hover", 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.10.3', {"requires": ["node-base", "event-custom-complex"]});