# 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:Public Protected Private

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

code »assertInitialized_ ( )

Asserts that the event target instance is initialized properly.

code »dispatchEvent ( e ) ⇒ `boolean`

Parameters
e

code »disposeInternal ( )

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

code »getParentEventTarget ( ) ⇒ `goog.events.EventTarget`

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.

code »setParentEventTarget ( parent )

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

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

code »setTargetForTesting ( target )

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.

code »getDisposed ( ) ⇒ `boolean`
Deprecated: Use `#isDisposed` instead.

Returns
Whether the object has been disposed of.

code »isDisposed ( ) ⇒ `boolean`

Returns
Whether the object has been disposed of.

code »registerDisposable ( disposable )

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`

code »actualEventTarget_ : `!Object`

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

code »eventTargetListeners_ : `!goog.events.ListenerMap`

Maps of event type to an array of listeners.

code »parentEventTarget_ : `goog.events.EventTarget`

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`

code »creationStack : `string`

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

code »disposed_ : `boolean`

Whether the object has been disposed of.

code »onDisposeCallbacks_ : `Array`

Callbacks to invoke when this object is disposed.

## Static Functions

code »goog.events.EventTarget.dispatchEventInternal_ ( target, e, opt_ancestorsTree ) ⇒ `boolean`

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

code »goog.events.EventTarget.MAX_ANCESTORS_ : `number`

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

code »goog.events.EventTarget.superClass_ : `goog.Disposable.prototype`