com.google.gwt.event.shared

## Class HandlerManager

- java.lang.Object
- - com.google.gwt.event.shared.HandlerManager

- All Implemented Interfaces:
    HasHandlers

      public class HandlerManager
      extends java.lang.Object
      implements HasHandlers

  Manager responsible for adding handlers to event sources and firing those handlers on passed in events. Primitive ancestor of `EventBus`, and used at the core of {com.google.gwt.user.client.ui.Widget}.

  While widget authors should continue to use `Widget.addDomHandler(EventHandler, com.google.gwt.event.dom.client.DomEvent.Type)` and `Widget.addHandler(EventHandler, com.google.gwt.event.shared.GwtEvent.Type)` , application developers are strongly discouraged from using a HandlerManager instance as a global event dispatch mechanism.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `HandlerManager(java.lang.Object source)` Creates a handler manager with a source to be set on all events fired via `fireEvent(GwtEvent)`.
    `HandlerManager(java.lang.Object source, boolean fireInReverseOrder)` Creates a handler manager with the given source, specifying the order in which handlers are fired.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `<H extends EventHandler> HandlerRegistration` | `addHandler(GwtEvent.Type<H> type, H handler)` Adds a handler.
    `void` | `fireEvent(GwtEvent<?> event)` Fires the given event to the handlers listening to the event's type.
    `<H extends EventHandler> H` | `getHandler(GwtEvent.Type<H> type, int index)` Gets the handler at the given index.
    `int` | `getHandlerCount(GwtEvent.Type<?> type)` Gets the number of handlers listening to the event type.
    `boolean` | `isEventHandled(GwtEvent.Type<?> e)` Does this handler manager handle the given event type?
    `<H extends EventHandler> void` | `removeHandler(GwtEvent.Type<H> type, H handler)` Removes the given handler from the specified event type.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### HandlerManager

          public HandlerManager(java.lang.Object source)

      Creates a handler manager with a source to be set on all events fired via `fireEvent(GwtEvent)`. Handlers will be fired in the order that they are added.
      Parameters:
        `source` - the default event source

    - #### HandlerManager

          public HandlerManager(java.lang.Object source,
                        boolean fireInReverseOrder)

      Creates a handler manager with the given source, specifying the order in which handlers are fired.
      Parameters:
        `source` - the event source
        `fireInReverseOrder` - true to fire handlers in reverse order

  - ### Method Detail

    - #### addHandler

          public <H extends EventHandler> HandlerRegistration addHandler(GwtEvent.Type<H> type,
                                                                H handler)

      Adds a handler.
      Type Parameters:
        `H` - The type of handler
      Parameters:
        `type` - the event type associated with this handler
        `handler` - the handler
      Returns:
        the handler registration, can be stored in order to remove the handler later

    - #### fireEvent

          public void fireEvent(GwtEvent<?> event)

      Fires the given event to the handlers listening to the event's type.

      Any exceptions thrown by handlers will be bundled into a `UmbrellaException` and then re-thrown after all handlers have completed. An exception thrown by a handler will not prevent other handlers from executing.

      Note, any subclass should be very careful about overriding this method, as adds/removes of handlers will not be safe except within this implementation.

      Specified by:
        `fireEvent` in interface `HasHandlers`
      Parameters:
        `event` - the event

    - #### getHandler

          public <H extends EventHandler> H getHandler(GwtEvent.Type<H> type,
                                              int index)

      Gets the handler at the given index.
      Type Parameters:
        `H` - the event handler type
      Parameters:
        `index` - the index
        `type` - the handler's event type
      Returns:
        the given handler

    - #### getHandlerCount

          public int getHandlerCount(GwtEvent.Type<?> type)

      Gets the number of handlers listening to the event type.
      Parameters:
        `type` - the event type
      Returns:
        the number of registered handlers

    - #### isEventHandled

          public boolean isEventHandled(GwtEvent.Type<?> e)

      Does this handler manager handle the given event type?
      Parameters:
        `e` - the event type
      Returns:
        whether the given event type is handled

    - #### removeHandler

          public <H extends EventHandler> void removeHandler(GwtEvent.Type<H> type,
                                                    H handler)

      Removes the given handler from the specified event type.
      Type Parameters:
        `H` - handler type
      Parameters:
        `type` - the event type
        `handler` - the handler