openfl

import Event from "./Event"; import IEventDispatcher from "./IEventDispatcher"; declare namespace openfl.events { /** * The EventDispatcher class is the base class for all classes that dispatch * events. The EventDispatcher class implements the IEventDispatcher interface * and is the base class for the DisplayObject class. The EventDispatcher * class allows any object on the display list to be an event target and as * such, to use the methods of the IEventDispatcher interface. * * Event targets are an important part of the Flash® Player and * Adobe® AIR® event model. The event target serves as * the focal point for how events flow through the display list hierarchy. * When an event such as a mouse click or a keypress occurs, Flash Player or * the AIR application dispatches an event object into the event flow from the * root of the display list. The event object then makes its way through the * display list until it reaches the event target, at which point it begins * its return trip through the display list. This round-trip journey to the * event target is conceptually divided into three phases: the capture phase * comprises the journey from the root to the last node before the event * target's node, the target phase comprises only the event target node, and * the bubbling phase comprises any subsequent nodes encountered on the return * trip to the root of the display list. * * In general, the easiest way for a user-defined class to gain event * dispatching capabilities is to extend EventDispatcher. If this is * impossible(that is, if the class is already extending another class), you * can instead implement the IEventDispatcher interface, create an * EventDispatcher member, and write simple hooks to route calls into the * aggregated EventDispatcher. * * @:event activate [broadcast event] Dispatched when the Flash Player or AIR * application gains operating system focus and becomes * active. This event is a broadcast event, which means that * it is dispatched by all EventDispatcher objects with a * listener registered for this event. For more information * about broadcast events, see the DisplayObject class. * @:event deactivate [broadcast event] Dispatched when the Flash Player or AIR * application operating loses system focus and is becoming * inactive. This event is a broadcast event, which means * that it is dispatched by all EventDispatcher objects with * a listener registered for this event. For more * information about broadcast events, see the DisplayObject * class. */ export class EventDispatcher implements IEventDispatcher { /** * Aggregates an instance of the EventDispatcher class. * * The EventDispatcher class is generally used as a base class, which * means that most developers do not need to use this constructor function. * However, advanced developers who are implementing the IEventDispatcher * interface need to use this constructor. If you are unable to extend the * EventDispatcher class and must instead implement the IEventDispatcher * interface, use this constructor to aggregate an instance of the * EventDispatcher class. * * @param target The target object for events dispatched to the * EventDispatcher object. This parameter is used when the * EventDispatcher instance is aggregated by a class that * implements IEventDispatcher; it is necessary so that the * containing object can be the target for events. Do not use * this parameter in simple cases in which a class extends * EventDispatcher. */ constructor (target?:IEventDispatcher); /** * Registers an event listener object with an EventDispatcher object so that * the listener receives notification of an event. You can register event * listeners on all nodes in the display list for a specific type of event, * phase, and priority. * * After you successfully register an event listener, you cannot change * its priority through additional calls to `addEventListener()`. * To change a listener's priority, you must first call * `removeListener()`. Then you can register the listener again * with the new priority level. * * Keep in mind that after the listener is registered, subsequent calls to * `addEventListener()` with a different `type` or * `useCapture` value result in the creation of a separate * listener registration. For example, if you first register a listener with * `useCapture` set to `true`, it listens only during * the capture phase. If you call `addEventListener()` again using * the same listener object, but with `useCapture` set to * `false`, you have two separate listeners: one that listens * during the capture phase and another that listens during the target and * bubbling phases. * * You cannot register an event listener for only the target phase or the * bubbling phase. Those phases are coupled during registration because * bubbling applies only to the ancestors of the target node. * * If you no longer need an event listener, remove it by calling * `removeEventListener()`, or memory problems could result. Event * listeners are not automatically removed from memory because the garbage * collector does not remove the listener as long as the dispatching object * exists(unless the `useWeakReference` parameter is set to * `true`). * * Copying an EventDispatcher instance does not copy the event listeners * attached to it.(If your newly created node needs an event listener, you * must attach the listener after creating the node.) However, if you move an * EventDispatcher instance, the event listeners attached to it move along * with it. * * If the event listener is being registered on a node while an event is * being processed on this node, the event listener is not triggered during * the current phase but can be triggered during a later phase in the event * flow, such as the bubbling phase. * * If an event listener is removed from a node while an event is being * processed on the node, it is still triggered by the current actions. After * it is removed, the event listener is never invoked again(unless * registered again for future processing). * * @param type The type of event. * @param useCapture Determines whether the listener works in the * capture phase or the target and bubbling phases. * If `useCapture` is set to * `true`, the listener processes the * event only during the capture phase and not in the * target or bubbling phase. If * `useCapture` is `false`, the * listener processes the event only during the * target or bubbling phase. To listen for the event * in all three phases, call * `addEventListener` twice, once with * `useCapture` set to `true`, * then again with `useCapture` set to * `false`. * @param priority The priority level of the event listener. The * priority is designated by a signed 32-bit integer. * The higher the number, the higher the priority. * All listeners with priority _n_ are processed * before listeners of priority _n_-1. If two or * more listeners share the same priority, they are * processed in the order in which they were added. * The default priority is 0. * @param useWeakReference Determines whether the reference to the listener * is strong or weak. A strong reference(the * default) prevents your listener from being * garbage-collected. A weak reference does not. * * Class-level member functions are not subject to * garbage collection, so you can set * `useWeakReference` to `true` * for class-level member functions without * subjecting them to garbage collection. If you set * `useWeakReference` to `true` * for a listener that is a nested inner function, * the function will be garbage-collected and no * longer persistent. If you create references to the * inner function(save it in another variable) then * it is not garbage-collected and stays * persistent. * @throws ArgumentError The `listener` specified is not a * function. */ addEventListener (type:string, listener:(event:object) => void, useCapture?:boolean, priority?:number, useWeakReference?:boolean):void; /** * Dispatches an event into the event flow. The event target is the * EventDispatcher object upon which the `dispatchEvent()` method * is called. * * @param event The Event object that is dispatched into the event flow. If * the event is being redispatched, a clone of the event is * created automatically. After an event is dispatched, its * `target` property cannot be changed, so you must * create a new copy of the event for redispatching to work. * @return A value of `true` if the event was successfully * dispatched. A value of `false` indicates failure or * that `preventDefault()` was called on the event. * @throws Error The event dispatch recursion limit has been reached. */ dispatchEvent (event:Event):boolean; /** * Checks whether the EventDispatcher object has any listeners registered for * a specific type of event. This allows you to determine where an * EventDispatcher object has altered handling of an event type in the event * flow hierarchy. To determine whether a specific event type actually * triggers an event listener, use `willTrigger()`. * * The difference between `hasEventListener()` and * `willTrigger()` is that `hasEventListener()` * examines only the object to which it belongs, whereas * `willTrigger()` examines the entire event flow for the event * specified by the `type` parameter. * * When `hasEventListener()` is called from a LoaderInfo * object, only the listeners that the caller can access are considered. * * @param type The type of event. * @return A value of `true` if a listener of the specified type * is registered; `false` otherwise. */ hasEventListener (type:string):boolean; /** * Removes a listener from the EventDispatcher object. If there is no * matching listener registered with the EventDispatcher object, a call to * this method has no effect. * * @param type The type of event. * @param useCapture Specifies whether the listener was registered for the * capture phase or the target and bubbling phases. If the * listener was registered for both the capture phase and * the target and bubbling phases, two calls to * `removeEventListener()` are required to * remove both, one call with `useCapture()` set * to `true`, and another call with * `useCapture()` set to `false`. */ removeEventListener (type:string, listener:(event:object) => void, useCapture?:boolean):void; toString ():string; /** * Checks whether an event listener is registered with this EventDispatcher * object or any of its ancestors for the specified event type. This method * returns `true` if an event listener is triggered during any * phase of the event flow when an event of the specified type is dispatched * to this EventDispatcher object or any of its descendants. * * The difference between the `hasEventListener()` and the * `willTrigger()` methods is that `hasEventListener()` * examines only the object to which it belongs, whereas the * `willTrigger()` method examines the entire event flow for the * event specified by the `type` parameter. * * When `willTrigger()` is called from a LoaderInfo object, * only the listeners that the caller can access are considered. * * @param type The type of event. * @return A value of `true` if a listener of the specified type * will be triggered; `false` otherwise. */ willTrigger (type:string):boolean; } } export default openfl.events.EventDispatcher;