Multi Events Handler (GWT)

Index: src/main/java/net/customware/gwt/presenter/client/DefaultEventBus.java
===================================================================
--- src/main/java/net/customware/gwt/presenter/client/DefaultEventBus.java (revision 70)
+++ src/main/java/net/customware/gwt/presenter/client/DefaultEventBus.java (working copy)
@@ -1,16 +1,236 @@
package net.customware.gwt.presenter.client;


-import com.google.gwt.event.shared.HandlerManager;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import com.google.gwt.event.shared.EventHandler;
+import com.google.gwt.event.shared.HandlerRegistration;
import com.google.inject.Inject;
import com.google.inject.Singleton;
+import net.customware.gwt.presenter.client.BaseEvent.Type;

@Singleton
-public class DefaultEventBus extends HandlerManager implements EventBus {
+public class DefaultEventBus implements EventBus {

@Inject
public DefaultEventBus() {
- super( null );
+ this(null,false);
}

+ /**
+ * Creates a handler manager with the given source. Handlers will be fired in
+ * the order that they are added.
+ *
+ * @param source the event source
+ */
+ public DefaultEventBus(Object source) {
+ this(source, false);
+ }
+
+ /**
+ * Creates an event bus with the given source, specifying the order in
+ * which handlers are fired.
+ *
+ * @param source the event source
+ * @param fireInReverseOrder true to fire handlers in reverse order
+ */
+ public DefaultEventBus(Object source, boolean fireInReverseOrder) {
+ registry = new HandlerRegistry();
+ this.source = source;
+ this.isReverseOrder = fireInReverseOrder;
+ }
+
+ /**
+ * Inner class used to actually contain the handlers.
+ */
+ private static class HandlerRegistry {
+ private final HashMap<BaseEvent.Type<?>, ArrayList<?>> map = new HashMap<BaseEvent.Type<?>, ArrayList<?>>();
+
+ private <H extends EventHandler> void addHandler(Type<H> type, H handler) {
+ ArrayList<H> l = get(type);
+ if (l == null) {
+ l = new ArrayList<H>();
+ map.put(type, l);
+ }
+ l.add(handler);
+ }
+
+ private <H extends EventHandler> void fireEvent(BaseEvent<H> event,
+ boolean isReverseOrder) {
+ Type<H> type = event.getAssociatedType();
+ int count = getHandlerCount(type);
+ if (isReverseOrder) {
+ for (int i = count - 1; i >= 0; i--) {
+ H handler = this.<H> getHandler(type, i);
+ event.dispatch(handler);
+ }
+ } else {
+ for (int i = 0; i < count; i++) {
+ H handler = this.<H> getHandler(type, i);
+ event.dispatch(handler);
+ }
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private <H> ArrayList<H> get(BaseEvent.Type<H> type) {
+ // This cast is safe because we control the puts.
+ return (ArrayList<H>) map.get(type);
+ }
+
+ private <H extends EventHandler> H getHandler(BaseEvent.Type<H> eventKey,
+ int index) {
+ ArrayList<H> l = get(eventKey);
+ return l.get(index);
+ }
+
+ private int getHandlerCount(BaseEvent.Type<?> eventKey) {
+ ArrayList<?> l = map.get(eventKey);
+ return l == null ? 0 : l.size();
+ }
+
+ private boolean isEventHandled(BaseEvent.Type<?> eventKey) {
+ return map.containsKey(eventKey);
+ }
+
+ private <H> void removeHandler(BaseEvent.Type<H> eventKey, H handler) {
+ ArrayList<H> l = get(eventKey);
+ boolean result = l.remove(handler);
+ if (l.size() == 0) {
+ map.remove(eventKey);
+ }
+ assert result : "Tried to remove unknown handler: " + handler + " from "
+ + eventKey;
+ }
+ }
+
+ private boolean isReverseOrder;
+
+ // map storing the actual handlers
+ private HandlerRegistry registry;
+
+ // source of the event.
+ private final Object source;
+
+
+ /**
+ * Adds a handle.
+ *
+ * @param <H> The type of handler
+ * @param type the event type associated with this handler
+ * @param handler the handler
+ * @return the handler registration, can be stored in order to remove the
+ * handler later
+ */
+ public <H extends EventHandler> HandlerRegistration addHandler(
+ BaseEvent.Type<H> type, final H handler) {
+ assert type != null : "Cannot add a handler with a null type";
+ assert handler != null : "Cannot add a null handler";
+ doAdd(type, handler);
+
+ return new BaseHandlerRegistration(this, type, handler);
+ }
+
+ /**
+ * Fires the given event to the handlers listening to the event's type.
+ *
+ * Note, any subclass should be very careful about overriding this method, as
+ * adds/removes of handlers will not be safe except within this
+ * implementation.
+ *
+ * @param event the event
+ */
+ public void fireEvent(BaseEvent<?> event) {
+ // If it not live we should revive it.
+ if (!event.isLive()) {
+ event.revive();
+ }
+ Object oldSource = event.getSource();
+ event.setSource(source);
+ registry.fireEvent(event, isReverseOrder);
+ if (oldSource == null) {
+ // This was my event, so I should kill it now that I'm done.
+ event.kill();
+ } else {
+ // Restoring the source for the next handler to use.
+ event.setSource(oldSource);
+ }
+ }
+
+ /**
+ * Gets the handler at the given index.
+ *
+ * @param <H> the event handler type
+ * @param index the index
+ * @param type the handler's event type
+ * @return the given handler
+ */
+ public <H extends EventHandler> H getHandler(BaseEvent.Type<H> type, int index) {
+ assert index < getHandlerCount(type) : "handlers for " + type.getClass()
+ + " have size: " + getHandlerCount(type)
+ + " so do not have a handler at index: " + index;
+ return registry.getHandler(type, index);
+ }
+
+ /**
+ * Gets the number of handlers listening to the event type.
+ *
+ * @param type the event type
+ * @return the number of registered handlers
+ */
+ public int getHandlerCount(Type<?> type) {
+ return registry.getHandlerCount(type);
+ }
+
+ /**
+ * Does this handler manager handle the given event type?
+ *
+ * @param e the event type
+ * @return whether the given event type is handled
+ */
+ public boolean isEventHandled(Type<?> e) {
+ return registry.isEventHandled(e);
+ }
+
+ /**
+ * Removes the given handler from the specified event type. Normally,
+ * applications should call {@link HandlerRegistration#removeHandler()}
+ * instead.
+ *
+ * @param <H> handler type
+ *
+ * @param type the event type
+ * @param handler the handler
+ * @deprecated This method is likely to be removed along with "listener"
+ * interfaces in a future release. If you have a reason it should
+ * be retained beyond that time, please add your comments to GWT
+ * <a href="http://code.google.com/p/google-web-toolkit/issues/detail?id=3102">issue 3102</a>
+ */
+ @Deprecated
+ public <H extends EventHandler> void removeHandler(BaseEvent.Type<H> type,
+ final H handler) {
+ doRemove(type, handler);
+ }
+
+ /**
+ * Not part of the public API, available only to allow visualization tools to
+ * be developed in gwt-incubator.
+ *
+ * @return a map of all handlers in this handler manager
+ */
+ Map<BaseEvent.Type<?>, ArrayList<?>> createHandlerInfo() {
+ return registry.map;
+ }
+
+ private <H extends EventHandler> void doAdd(BaseEvent.Type<H> type,
+ final H handler) {
+ registry.addHandler(type, handler);
+ }
+
+ private <H extends EventHandler> void doRemove(BaseEvent.Type<H> type,
+ final H handler) {
+ registry.removeHandler(type, handler);
+ }
+
}
Index: src/main/java/net/customware/gwt/presenter/client/EventBus.java
===================================================================
--- src/main/java/net/customware/gwt/presenter/client/EventBus.java (revision 70)
+++ src/main/java/net/customware/gwt/presenter/client/EventBus.java (working copy)
@@ -1,14 +1,13 @@
package net.customware.gwt.presenter.client;

import com.google.gwt.event.shared.EventHandler;
-import com.google.gwt.event.shared.GwtEvent;
import com.google.gwt.event.shared.HandlerRegistration;
-import com.google.gwt.event.shared.GwtEvent.Type;
+import net.customware.gwt.presenter.client.BaseEvent.Type;

public interface EventBus {
<H extends EventHandler> HandlerRegistration addHandler( Type<H> type, H handler );

- void fireEvent( GwtEvent<?> event );
+ void fireEvent( BaseEvent<?> event );

<H extends EventHandler> H getHandler( Type<H> type, int index );

Index: src/main/java/net/customware/gwt/presenter/client/place/PlaceChangedEvent.java
===================================================================
--- src/main/java/net/customware/gwt/presenter/client/place/PlaceChangedEvent.java (revision 70)
+++ src/main/java/net/customware/gwt/presenter/client/place/PlaceChangedEvent.java (working copy)
@@ -1,17 +1,17 @@
package net.customware.gwt.presenter.client.place;

-import com.google.gwt.event.shared.GwtEvent;
+import net.customware.gwt.presenter.client.BaseEvent;

/**
* This event is triggered when the request has changed manually (ie, not due to a
* {@link PlaceRequestEvent}). This allows the {@link PlaceManager} to keep
* track of the current location. Other classes may, but will typically not need
* to, implement {@link PlaceChangedHandler} to be informed of manual changes.
- *
+ *
* @author David Peterson
- *
+ *
*/
-public class PlaceChangedEvent extends GwtEvent<PlaceChangedHandler> {
+public class PlaceChangedEvent extends BaseEvent<PlaceChangedHandler> {

private static Type<PlaceChangedHandler> TYPE;

@@ -33,7 +33,7 @@
}

@Override
- public com.google.gwt.event.shared.GwtEvent.Type<PlaceChangedHandler> getAssociatedType() {
+ public BaseEvent.Type<PlaceChangedHandler> getAssociatedType() {
return getType();
}

Index: src/main/java/net/customware/gwt/presenter/client/place/PlaceRequestEvent.java
===================================================================
--- src/main/java/net/customware/gwt/presenter/client/place/PlaceRequestEvent.java (revision 70)
+++ src/main/java/net/customware/gwt/presenter/client/place/PlaceRequestEvent.java (working copy)
@@ -1,8 +1,8 @@
package net.customware.gwt.presenter.client.place;

-import com.google.gwt.event.shared.GwtEvent;
+import net.customware.gwt.presenter.client.BaseEvent;

-public class PlaceRequestEvent extends GwtEvent<PlaceRequestHandler> {
+public class PlaceRequestEvent extends BaseEvent<PlaceRequestHandler> {

private static Type<PlaceRequestHandler> TYPE;

Index: src/main/java/net/customware/gwt/presenter/client/PresenterRevealedEvent.java
===================================================================
--- src/main/java/net/customware/gwt/presenter/client/PresenterRevealedEvent.java (revision 70)
+++ src/main/java/net/customware/gwt/presenter/client/PresenterRevealedEvent.java (working copy)
@@ -1,8 +1,6 @@
package net.customware.gwt.presenter.client;

-import net.customware.gwt.presenter.client.Presenter;

-import com.google.gwt.event.shared.GwtEvent;

/**
* Presenters can send this event to the {@link EventBus} to notify other
@@ -10,17 +8,17 @@
* is particularly useful for situations where a presenter contains other
* presenters and wants needs to reveal itself when a child presenter is
* revealed.
- *
+ *
* @author David Peterson
- *
+ *
*/
-public class PresenterRevealedEvent extends GwtEvent<PresenterRevealedHandler> {
+public class PresenterRevealedEvent extends BaseEvent<PresenterRevealedHandler> {

- private static final GwtEvent.Type<PresenterRevealedHandler> TYPE = new GwtEvent.Type<PresenterRevealedHandler>();
+ private static final BaseEvent.Type<PresenterRevealedHandler> TYPE = new BaseEvent.Type<PresenterRevealedHandler>();

private Presenter presenter;

- public static GwtEvent.Type<PresenterRevealedHandler> getType() {
+ public static BaseEvent.Type<PresenterRevealedHandler> getType() {
return TYPE;
}

@@ -38,7 +36,7 @@
}

@Override
- public GwtEvent.Type<PresenterRevealedHandler> getAssociatedType() {
+ public BaseEvent.Type<PresenterRevealedHandler> getAssociatedType() {
return getType();
}