Class goog.events.EventTarget

code »
goog.Disposable
  └ goog.events.EventTarget
All implemented interfaces:
goog.disposable.IDisposable, goog.events.Listenable

An implementation of goog.events.Listenable with full W3C EventTarget-like support (capture/bubble mechanism, stopping event propagation, preventing default actions). You may subclass this class to turn your class into a Listenable. Unless propagation is stopped, an event dispatched by an EventTarget will bubble to the parent returned by getParentEventTarget. To set the parent, call setParentEventTarget. Subclasses that don't support changing the parent can override the setter to throw an error. Example usage:

   var source = new goog.events.EventTarget();
   function handleEvent(e) {
     alert('Type: ' + e.type + '; Target: ' + e.target);
   }
   source.listen('foo', handleEvent);
   // Or: goog.events.listen(source, 'foo', handleEvent);
   ...
   source.dispatchEvent('foo');  // will call handleEvent
   ...
   source.unlisten('foo', handleEvent);
   // Or: goog.events.unlisten(source, 'foo', handleEvent);
 

Constructor

goog.events.EventTarget ( )
Show:

Instance Methods

Defined in goog.events.EventTarget

code »addEventListener ( type, handler, opt_capture, opt_handlerScope )
Deprecated: Use #listen instead, when possible. Otherwise, use goog.events.listen if you are passing Object (instead of Function) as handler.

Adds an event listener to the event target. The same handler can only be added once per the type. Even if you add the same handler multiple times using the same type then it will only be called once when the event is dispatched.

Parameters
type: string
The type of the event to listen for.
handler: (function(?): ?|{handleEvent: function(?): ?}|null)
The function to handle the event. The handler can also be an object that implements the handleEvent method which takes the event object as argument.
opt_capture: boolean=
In DOM-compliant browsers, this determines whether the listener is fired during the capture or bubble phase of the event.
opt_handlerScope: Object=
Object in whose scope to call the listener.

Asserts that the event target instance is initialized properly.

code »dispatchEvent ( e )boolean
Parameters
e

Removes listeners from this object. Classes that extend EventTarget may need to override this method in order to remove references to DOM Elements and additional listeners.

code »fireListeners ( type, capture, eventObject )boolean
Parameters
type
capture
eventObject
code »getListener ( type, listener, capture, opt_listenerScope )(goog.events.ListenableKey|null)
Parameters
type
listener
capture
opt_listenerScope
code »getListeners ( type, capture )Array.<(goog.events.ListenableKey|null)>
Parameters
type
capture

Returns the parent of this event target to use for bubbling.

Returns
The parent EventTarget or null if there is no parent.
code »hasListener ( opt_type, opt_capture )boolean
Parameters
opt_type
opt_capture
code »listen ( type, listener, opt_useCapture, opt_listenerScope )(goog.events.ListenableKey|null)
Parameters
type
listener
opt_useCapture
opt_listenerScope
code »listenOnce ( type, listener, opt_useCapture, opt_listenerScope )(goog.events.ListenableKey|null)
Parameters
type
listener
opt_useCapture
opt_listenerScope
code »removeAllListeners ( opt_type )number
Parameters
opt_type
code »removeEventListener ( type, handler, opt_capture, opt_handlerScope )
Deprecated: Use #unlisten instead, when possible. Otherwise, use goog.events.unlisten if you are passing Object (instead of Function) as handler.

Removes an event listener from the event target. The handler must be the same object as the one added. If the handler has not been added then nothing is done.

Parameters
type: string
The type of the event to listen for.
handler: (function(?): ?|{handleEvent: function(?): ?}|null)
The function to handle the event. The handler can also be an object that implements the handleEvent method which takes the event object as argument.
opt_capture: boolean=
In DOM-compliant browsers, this determines whether the listener is fired during the capture or bubble phase of the event.
opt_handlerScope: Object=
Object in whose scope to call the listener.

Sets the parent of this event target to use for capture/bubble mechanism.

Parameters
parent: goog.events.EventTarget
Parent listenable (null if none).

Sets the target to be used for event.target when firing event. Mainly used for testing. For example, see goog.testing.events.mixinListenable.

Parameters
target: !Object
The target.
code »unlisten ( type, listener, opt_useCapture, opt_listenerScope )boolean
Parameters
type
listener
opt_useCapture
opt_listenerScope
code »unlistenByKey ( key )boolean
Parameters
key

Defined in goog.Disposable

code »<T> addOnDisposeCallback ( callback, opt_scope )

Invokes a callback function when this object is disposed. Callbacks are invoked in the order in which they were added.

Parameters
callback: function(this: T): ?
The callback function.
opt_scope: T=
An optional scope to call the callback in.
code »dispose ( )void

Disposes of the object. If the object hasn't already been disposed of, calls #disposeInternal. Classes that extend goog.Disposable should override #disposeInternal in order to delete references to COM objects, DOM nodes, and other disposable objects. Reentrant.

Returns
Nothing.
Deprecated: Use #isDisposed instead.
Returns
Whether the object has been disposed of.
Returns
Whether the object has been disposed of.

Associates a disposable object with this object so that they will be disposed together.

Parameters
disposable: goog.disposable.IDisposable
that will be disposed when this object is disposed.

Instance Properties

Defined in goog.events.EventTarget

The object to use for event.target. Useful when mixing in an EventTarget to another object.

Maps of event type to an array of listeners.

Parent event target, used during event bubbling. TODO(user): Change this to goog.events.Listenable. This currently breaks people who expect getParentEventTarget to return goog.events.EventTarget.

Defined in goog.Disposable

If monitoring the goog.Disposable instances is enabled, stores the creation stack trace of the Disposable instance.

Whether the object has been disposed of.

Callbacks to invoke when this object is disposed.

Static Functions

Dispatches the given event on the ancestorsTree.

Parameters
target: !Object
The target to dispatch on.
e: (goog.events.Event|Object|string)
The event object.
opt_ancestorsTree: Array.<goog.events.Listenable>=
The ancestors tree of the target, in reverse order from the closest ancestor to the root event target. May be null if the target has no ancestor.
Returns
If anyone called preventDefault on the event object (or if any of the listeners returns false) this will also return false.

Static Properties

An artificial cap on the number of ancestors you can have. This is mainly for loop detection.