Interface QuickEventParams

The possible values,

EventDispatcher.argumentPassingIncludeEvent = ArgumentPassingMode.IncludeEvent;
EventDispatcher.argumentPassingExcludeEvent = ArgumentPassingMode.ExcludeEvent;

The global default value,

EventDispatcher.defaultArgumentPassingMode = ArgumentPassingMode.ExcludeEvent;

Let's see some examples. Assume we have the dispatcher

let dispatcher = new EventDispatcher();
// same as
let dispatcher = new EventDispatcher({ argumentPassingMode: EventDispatcher.argumentPassingExcludeEvent });
dispatcher.dispatch(3, "hello");

The listener will be invoked with the argument ("hello"), the event type is omitted since it's argumentPassingExcludeEvent.

apply

EventDispatcher, EventQueue

default

EventDispatcher.argumentPassingExcludeEvent

memberof

QuickEventParams

When argumentsAsArray is false, the listeners and getEvent receive the arguments as individual parameters. For example,

let dispatcher = new EventDispatcher();
// same as
let dispatcher = new EventDispatcher({ argumentsAsArray: false });
dispatcher.dispatch(a, b, c);
// The listener will be called as
myListener(a, b, c);

When argumentsAsArray is true, the listeners and getEvent receive the arguments as an array of which each elements are the arguments. For example,

let dispatcher = new EventDispatcher({ argumentsAsArray: true });
dispatcher.dispatch(a, b, c);
// The listener will be called as
myListener([ a, b, c ]);

Setting argumentsAsArray to true will slightly improve the performance.

apply

CallbackList, EventDispatcher, EventQueue

default

false

memberof

QuickEventParams

apply

CallbackList, EventDispatcher, EventQueue

default

the default implementation always returns true

memberof

QuickEventParams

example

// The event object we will dispatch looks like,
// MyEvent = {
//   type: int,
//   canceled: boolean
//};

// When construct the dispatcher, pass the parameter
// getEvent to indicate how to get the event type.
// Parameter canContinueInvoking checks if the dispatching can continue.
let dispatcher = new EventDispatcher({
  getEvent: e => e.type,

  canContinueInvoking: (e) => ! e.canceled
});

dispatcher.appendListener(3, (e) => {
  console.log("Got event 3");
  e.canceled = true;
});
dispatcher.appendListener(3, (e) => {
  console.log("Should not get this event 3");
});

// Dispatch the event.
// The first argument is MyEvent.
dispatcher.dispatch({ type: 3, canceled: false });

apply

EventDispatcher, EventQueue

default

the default implementation returns the first argument of getEvent

memberof

QuickEventParams

example

// The event object we will dispatch looks like,
// MyEvent = {
//   type: int,
//   message: string,
//   param: int
//};

// When construct the dispatcher, pass the parameter
// getEvent to indicate how to get the event type.
let dispatcher = new EventDispatcher({
  getEvent: (e) => e.type
});

// Add a listener.
// Note: the first argument is the event type of type int (same as the return type of getEvent), not MyEvent.
// e is the main event object.
// b is an extra parameter.
dispatcher.appendListener(3, (e, b) => {
  console.log("Got event 3");
  console.log("Event::type is", e.type);
  console.log("Event::message is", e.message);
  console.log("Event::param is", e.param);
  console.log("b is", b);
});

// Dispatch the event.
// The first argument is MyEvent.
dispatcher.dispatch({ type: 3, message: "Hello world", param: 38 }, true);

// Output:
// > Got event 3
// > Event::type is 3
// > Event::message is Hello world
// > Event::param is 38
// > b is true

apply

EventDispatcher, EventQueue

default

undefined

memberof

QuickEventParams