Differentiate events for multiple attached gwt widgets

I've been 开发者_JAVA技巧trying to make multiple Presenters "listen" to the same event but I which to make each event unique to the Presenter.

Ex. I create 3 Composite widgets each in one different tab. They get all attached to the same event at binding. Let's call it the "NewPrescriptionEvent". If this event is fired, all my 3 composites will try to DO the job. I only want one of them to do it.

The only way I found to do this is by creating a temp event id (an integer inside the event) which I check for each widget which is trying to respond to the event.

Code snippet

private class OnNewPrescription implements NewPrescriptionHandler {

    @Override
    public void onNewPrescription(NewPrescriptionEvent event, int dataObjectId) {

        if (getDataObject().getPatientId() == dataObjectId) {
        ...
        }
    }
}

During binding I do the usual:

eventBus.addHandler(NewPrescriptionEvent.TYPE, new OnNewPrescription());

The event:

public class NewPrescriptionEvent extends GwtEvent<NewPrescriptionHandler> {

    public static final GwtEvent.Type<NewPrescriptionHandler> TYPE = new GwtEvent.Type<NewPrescriptionHandler>();

    private int dataObjectId;

    public NewPrescriptionEvent(int dataObjectId) {
        this.dataObjectId = dataObjectId; 
    }

    @Override
    protected void dispatch(NewPrescriptionHandler handler) {
        handler.onNewPrescription(this, dataObjectId);      
    }

    @Override
    public GwtEvent.Type<NewPrescriptionHandler> getAssociatedType() {
        return TYPE;
    }
}

I was thinking that the TYPE need to be different each time but still be the same event. Does anyone have a suggestion?

Thx.

Is it the case that you have an arbitrary number of instances of the same presenter and all are listening to the same event type? And each of your presenters 'controls' a different entity an therefore should only react on events coming from that entity? If that's the case the only solution I see is to parametrize the event as you've done.

Sounds like the EventBus probably isn't the best approach here; this is one of the main problems I've personally had with the EventBus: all events are global, and it's hard to differentiate between different events of a given type.

A good set of rules for asynchronous event handling without a shared EventBus is:

• Communicate with child widgets via direct method calls.
• Communicate with a parent widget via callbacks/handlers/listeners.
• Avoid direct knowledge of sibling widgets (probably beside the point here)

So, the widget that contains the 3 tabs can attach callbacks to each tab that, when called, dispatches each event to its appropriate event handler (Presenters, in your case, I believe).

No global communication required, no knowledge of sources or destinations, only one event type, one reusable tab widget type, and the tab class stays simple. In principle, not too different from adding a ValueChangeHandler to a CheckBox (after all, one doesn't subscribe to check box events via the event bus, you just add a handler directly to the widget).

Rough sketch:

public class TabContainer implements IsWidget {
  public TabContainer() {
    tab1.addNewPrescriptionHandler(
        new NewPrescriptionEventHandler() {
          @Override
          public void handleNewPrescriptionEvent(NewPrescriptionEvent event) {
            handleTab1Event(event);
          }
        });
    tab2.addNewPrescriptionHandler(
        new NewPrescriptionEventHandler() {
          @Override
          public void handleNewPrescriptionEvent(NewPrescriptionEvent event) {
            handleTab2Event(event);
          }
        });
    ...
  }
}

And you might even be able to simplify that with some looping and pairing.

Going the other way, this container can also send events back the other way to your widgets from wherever else using the same principles.

Also, depending on what the Event class contains, you might not even need an Event class; you can define your callbacks and params however you want.

I think the title of the question is your answer.

You need different event types for each of the widgets.

You could try using addHandlerToSource(GwtEvent.Type<H> type, Object source, H handler) if you know the source to listen to.

Another possibility would be to extend EventBus to accept some kind of filter on registration.