EventDispatcher

Type class

Universal Event Dispatcher.

Sources

EventDispatcher can be used (imported) via one of the following packages.

TypeScript

/**
 * Import from: "core.ts"
 * Use like: am4core.EventDispatcher
 */
import * as am4core from "@amcharts/amcharts4/core";

JavaScript

/**
 * Include via: <script src="core.js"></script>
 * Access items like: am4core.EventDispatcher
 */

Inheritance

EventDispatcher does not extend any other symbol.

EventDispatcher is extended by TargetedEventDispatcher.

Properties

EventDispatcher does not have any properties.

Methods

#constructor()

Returns EventDispatcher

Constructor

#copyFrom(source: this)

Returns void

Copies all dispatcher parameters, including listeners, from another event dispatcher.

#disable()

Returns void

Disable dispatching of events until re-enabled by enable().

#disableType(type: Key,
amount: number)

Returns void

Disable dispatching of events for a certain event type.

Optionally, can set how many dispatches to skip before automatically re-enabling the dispatching.

#dispatch(type: Key,
event: T[""])

Returns void

Shelves the event to be dispatched within next update cycle.

#dispatchImmediately(type: Key,
event: T[""])

Returns void

Dispatches an event immediately without waiting for next cycle.

#dispose()

Returns void

Dispose (destroy) this object.

#enable()

Returns void

Enable dispatching of events if they were previously disabled by disable().

#enableType(type: Key)

Returns void

Enable dispatching particular event, if it was disabled before by disableType().

#has(type: Key,
callback?: (this: C, event: T[""]) => void,
context?: C)

Returns boolean

Checks if there's already a listener with specific parameters.

#hasListeners()

Returns boolean

Checks if this particular event dispatcher has any listeners set.

#hasListenersByType(type: Key)

Returns boolean

Checks if this particular event dispatcher has any particular listeners set.

#isDisposed()

Returns boolean

Returns if this object has been already disposed.

#isEnabled(type: Key)

Returns boolean

Checks if dispatching for particular event type is enabled.

#off(type: Key,
callback?: (this: C, event: T[""]) => void,
context?: C)

Returns void

Removes the event listener with specific parameters.

#on(type: Key,
callback: (this: C, event: T[""]) => void,
context?: C,
shouldClone: boolean)

Returns IDisposer

Creates an event listener to be invoked on a specific event type.

series.events.on("hidden", (ev) => {
  console.log("Series hidden: " + ev.target.name);
}, this);

series.events.on("hidden", function(ev) {
  console.log("Series hidden: " + ev.target.name);
}, this);

{
  // ...
  "series": [{
    // ...
    "events": {
    	"hidden": function(ev) {
    	  console.log("Series hidden: " + ev.target.name);
    	}
    }
  }]
}

The above will invoke our custom event handler whenever series we put event on is hidden.

#onAll(callback: (this: C, type: Key, event: T[""]) => void,
context?: C,
shouldClone: boolean)

Returns IDisposer

Creates an event listener to be invoked on any event.

#once(type: Key,
callback: (this: C, event: T[""]) => void,
context?: C,
shouldClone: boolean)

Returns IDisposer

Creates an event listener to be invoked on a specific event type once.

Once the event listener is invoked, it is automatically disposed.

series.events.on("hidden", (ev) => {
  console.log("Series hidden: " + ev.target.name);
}, this);

series.events.on("hidden", function(ev) {
  console.log("Series hidden: " + ev.target.name);
}, this);

{
  // ...
  "series": [{
    // ...
    "events": {
    	"hidden": function(ev) {
    	  console.log("Series hidden: " + ev.target.name);
    	}
    }
  }]
}

The above will invoke our custom event handler the first time series we put event on is hidden.

Events

EventDispatcher does not have any events.