implements IEventDispatcher, for when you can't subclass EventDispatcher directly

100%

implements IEventDispatcher, for when you can't subclass EventDispatcher directly

✓ Published0🌍 Public

Last edited Aug 10, 2010

Created on Aug 10, 2010

This example shows how to implement the Flash `IEventDispatcher` interface in a custom class when subclassing `EventDispatcher` directly is not possible. It demonstrates a composition pattern where the class creates an internal `EventDispatcher` instance, passing itself as the target in the constructor. All required interface methods—`addEventListener`, `removeEventListener`, `dispatchEvent`, `hasEventListener`, and `willTrigger`—are delegated to this private `dispatcher` object, forwarding calls with the appropriate parameters. The code uses ActionScript 3’s `flash.events.IEventDispatcher` and `flash.events.EventDispatcher` APIs, with no external data or rendering involved.

AI-generated description

Similar vizzes

Loading thumbnail…

An eventing mechanism for Swift

This example demonstrates an eventing mechanism for Swift, showing how to create type-safe events with multiple handlers and automatic cleanup. It defines an `Event<T>` class that manages a collection of handler wrappers, allowing observers to subscribe and unsubscribe dynamically. The implementation uses the `Disposable` protocol for tear-down logic and the `Invocable` private protocol to abstract handler invocation, with `EventHandlerWrapper` holding a weak reference to the target to prevent retain cycles. The code highlights Swift’s protocol-oriented and generics features, as well as curried instance methods, to build a reusable notification system without relying on external libraries.

CColinEberhardt

55% match

Loading thumbnail…

callNextFrame for as3

This code sample demonstrates a deferred-call pattern for ActionScript 3, showing how to queue functions and execute them on the next animation frame. It uses the `Event.ENTER_FRAME` event to schedule callbacks, adding a listener when the queue is first populated and removing it after the pending calls are flushed. The `callNextFrame` method stores each callback and optional arguments in an array, and the `onEnterForCallNextFrame` handler shifts through the queue, applying each function with `Function.apply`. The implementation relies on the `Event` class and `IEventDispatcher` methods `addEventListener` and `removeEventListener` to trigger the batch processing.

RRandomEtc

52% match

Loading thumbnail…

Gist c4276ed96ff4bd575933c7ad390a7a92

This example demonstrates a custom event-dispatch loop using the D3 dispatch module. It creates a `dispatch` object with a `foo` event, registers a handler, and then triggers that event 3,000 times via `dispatch.call`. The handler checks whether the passed argument is `undefined` and prints a message if so. The page displays the total number of times the handler was called. The code relies on `d3_dispatch.dispatch` and the `on`/`call` methods to manage custom event flow, with no external data source.

HHypercubed

52% match

Loading thumbnail…

Fork of Dispatching Events Example

This example demonstrates a custom D3 chart component that emits events to communicate changes. The Circle component renders an SVG circle that, when clicked, dispatches an `input` event with a new random radius value. The main script listens for this event and calls the circle’s update method, which uses a transition to animate the radius to the new size. The code uses D3’s `create` and `select` functions, along with the `dispatch` and `property` methods, to implement a reusable event-driven pattern. The circle’s cursor is set to a pointer to indicate interactivity.

Ssriramvsharma

51% match

Loading thumbnail…

Hello Reactor

This example demonstrates a minimal event-driven communication system built with JavaScript. It shows how two listeners attached to the same `'big bang'` event respond to a dispatched payload, with one listener logging a fixed message and the other printing the passed arguments. The code defines a custom `Reactor` class and an `Event` class, showcasing manual event registration, callback storage, and dispatch logic. The implementation relies on JavaScript's array `forEach` method to invoke all registered callbacks with the spread `...eventArgs` syntax. The data originates from a hardcoded dispatch call passing the values `135`, `'test'`, and `[1, 2, 3]`.

MMAKIO135

46% match

Loading thumbnail…

Dispatching Events Example

A circle rendered as an SVG element changes its radius in response to clicks, demonstrating how chart instances can emit and handle custom events. Clicking the circle triggers a click handler in the Circle component, which dispatches an `input` event with a random value and a `detail` property. The main script listens for this event using D3’s `select().on()`, reads the radius from `event.target.value`, and calls the `update()` method to animate the radius via a D3 transition. The example uses `d3.create`, `d3.select`, and `transition.attr`, based on the Observable chart pattern.

CCurran Kelleher

44% match

Loading thumbnail…

Gist fed523040b43046b27a52290d26c4ceb

This example visualizes the structure of a small React component hierarchy through a static code excerpt, showing how typed props and event handlers are passed between parent and child components. The code uses the Flow type checker to define an `onSubmit` prop as a `Function`, with class `A` passing its `handleSomeEvent` method to component `B` via a prop. The rendering approach is purely textual, relying on the explicit Flow annotations and JSX syntax to illustrate data flow rather than any graphical output. It demonstrates type-safe callback propagation in a React/Flow environment, though no runtime visualization or data processing library appears in the snippet.

CCaged

42% match

Loading thumbnail…

Using the equivalent of php trait

This example demonstrates how to apply PHP-like traits to JavaScript objects using a custom `addMixin` function. It shows a flexible method for copying property descriptors from multiple source objects onto a target object, enabling code reuse without traditional inheritance. The function leverages `Object.keys`, `Object.getOwnPropertyDescriptor`, and `Object.defineProperties` to transfer both regular and enumerable symbol-based properties. The implementation is adapted from Caleb Porzio’s approach, and the mixin.js file contains the complete logic for this composition pattern.

NNaoray

42% match