Adds an event listener

Compiles a selector string into a filter function to identify whether Nodes along the parent axis of an event's target should trigger event notification.

This function is memoized, so previously compiled filter functions are returned if the same selector string is provided.

This function may be useful when defining synthetic events for delegate handling.

Hosted as a property of the delegate method (e.g. Y.delegate.compileFilter).

<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>

Defines a new outside event to correspond with the given DOM event.

By default, the created synthetic event name will be the name of the event with "outside" appended (e.g. "click" becomes "clickoutside"). If you want a different name for the created Event, pass it as a second argument like so: <code>Y.Event.defineOutside(eventType, "yonderclick")</code>.

<p>Sets up event delegation on a container element. The delegated event will use a supplied selector or filtering function to test if the event references at least one node that should trigger the subscription callback.</p>

<p>Selector string filters will trigger the callback if the event originated from a node that matches it or is contained in a node that matches it. Function filters are called for each Node up the parent axis to the subscribing container node, and receive at each level the Node and the event object. The function should return true (or a truthy value) if that Node should trigger the subscription callback. Note, it is possible for filters to match multiple Nodes for a single event. In this case, the delegate callback will be executed for each matching Node.</p>

<p>For each matching Node, the callback will be executed with its 'this' object set to the Node matched by the filter (unless a specific context was provided during subscription), and the provided event's <code>currentTarget</code> will also be set to the matching Node. The containing Node from which the subscription was originally made can be referenced as <code>e.container</code>.

Removes an event listener. Supports the signature the event was bound with, but the preferred way to remove listeners is using the handle that is returned when using Y.on

The "flick" gesture is a specialized "move" that has some velocity and the movement always runs either x or y axis. The velocity is calculated with "distance" and "duration" arguments. If the calculated velocity is below than the minimum velocity, the given duration will be ignored and new duration will be created to make a valid flick gesture.

Generates an unique ID for the element if it does not already have one.

Finds the event in the window object, the caller's arguments, or in the arguments of another method in the callstack. This is executed automatically for events registered through the event manager, so the implementer should not normally need to execute this function at all.

Returns all listeners attached to the given element via addListener. Optionally, you can specify a specific type of event to return.

The "move" gesture simulate the movement of any direction between the straight line of start and end point for the given duration. The path argument is an object with "point", "xdist" and "ydist" properties. The "point" property is an array with x and y coordinations(relative to the top left corner of the target node element) while "xdist" and "ydist" properties are used for the distance along the x and y axis. A negative distance number can be used to drag either left or up direction.

If no arguments are given, it will simulate the default move, which is moving 200 pixels from the center of the element to the positive X-axis direction for 1 sec.

The "rotate" and "pinch" methods are essencially same with the exact same arguments. Only difference is the required parameters. The rotate method requires "rotation" parameter while the pinch method requires "startRadius" and "endRadius" parameters.

The "pinch" gesture can simulate various 2 finger gestures such as pinch, spread and/or rotation. The "startRadius" and "endRadius" are required. If endRadius is larger than startRadius, it becomes a spread gesture otherwise a pinch gesture.

Removes all listeners attached to the given element via addListener. Optionally, the node's children can also be purged. Optionally, you can specify a specific type of event to remove.

The "rotate" and "pinch" methods are essencially same with the exact same arguments. Only difference is the required parameters. The rotate method requires "rotation" parameter while the pinch method requires "startRadius" and "endRadius" parameters.

Simulates the event or gesture with the given name on a target.

Simulates the higher user level gesture of the given name on a target. This method generates a set of low level touch events(Apple specific gesture events as well for the iOS platforms) asynchronously. Note that gesture simulation is relying on Y.Event.simulate() method to generate the touch events under the hood. The Y.Event.simulate() method itself is a synchronous method.

Users are suggested to use Node.simulateGesture() method which basically calls this method internally. Supported gestures are tap, doubletap, press, move, flick, pinch and rotate.

The pinch gesture is used to simulate the pinching and spreading of two fingers. During a pinch simulation, rotation is also possible. Essentially pinch and rotate simulations share the same base implementation to allow both pinching and rotation at the same time. The only difference is pinch requires start and end option properties while rotate requires rotation option property.

The pinch and rotate gestures can be described as placing 2 fingers along a circle. Pinching and spreading can be described by start and end circles while rotation occurs on a single circle. If the radius of the start circle is greater than the end circle, the gesture becomes a pinch, otherwise it is a spread spread.

The "tap" gesture can be used for various single touch point gestures such as single tap, N number of taps, long press. The default is a single tap.