GWT Custom Event Handler

Question

Can someone give me an example of creating a custom set of an Event and a Handler. Say you have a Person object that you want your widgets to know if it got updated.

Answer 1

Thanks for all the responses. Zakness came the closest to giving me the answer I needed, however, I came up with a slightly simpler model.

My main goal was to avoid using a static variable to my main data structure. I also hit the problem of trying to figure out if that main data structure was successfully retrieved from the database at the time of trying to access it and what to do when it's not (i.e. when it's null).

After watching the Google Web Toolkit Architecture: Best Practices For Architecting Your GWT App video from Google IO, the Event Bus idea seemed perfect.

I'll post my solution here in case it helps anyone else out.

---

First, create the Handler class. Note the reference to the Event class already:

public interface CategoryChangeHandler extends EventHandler {
    void onCategoryChange(CategoryChangeEvent event);
}

Now on to the Event class. This gave me the most trouble:

public class CategoryChangeEvent extends GwtEvent<CategoryChangeHandler> {

    private final List<Category> category;

    public CategoryChangeEvent(List<Category> category) {
        super();
        this.category = category;
    }

    public static final Type<CategoryChangeHandler> TYPE = new Type<CategoryChangeHandler>();

    @Override
    protected void dispatch(CategoryChangeHandler handler) {
        handler.onCategoryChange(this);
    }

    @Override
    public com.google.gwt.event.shared.GwtEvent.Type<CategoryChangeHandler> getAssociatedType() {
        return TYPE;
    }

    public List<Category> getCategories(){
        return category;
    }

}

Now I am able to use these Handler and Event classes like so when this main data structure gets reloaded:

This code got the data structure and want to notify everyone who is listening that it got updated:

CategoryChangeEvent event = new CategoryChangeEvent(result);
eventBus.fireEvent(event);

This code is an implementation of the Event

public class PopulateCategoryHandler implements CategoryChangeHandler {

    @Override
    public void onCategoryChange(CategoryChangeEvent event) {
        tearDownCategories();

        List<Category> categories = event.getCategories();
        populateCategories(categories); 
    }

}

Answer 2

Create custom GWT events using the HandlerManger shouldn't be this hard, take a look at the example GwtEventBus @ NingZhang.info it is real intuitive. The key classes used are:

• com.google.gwt.event.shared.HandlerManager
• com.google.gwt.event.shared.GwtEvent
• com.google.gwt.event.shared.EventHandler

Answer 3

Here is an example of this over on Alex Reid's blog, including a link to an operational code example. The example fills in some of the fuzzy bits and, along with Nick's example here, helps clarify getting started with architecting an event bus in your gwt application.

Answer 4

I think that the most complete and detailed example is in this article

It contains also an example project that shows exactly how to properly use define custom events and use GWT's HandlerManager class.

Answer 5

Here's a pretty comprehensive example of creating a custom event, taken verbatim from the GwtEventSystem Wiki (when the event system was still in GWT's incubator).

This is an event that is triggered when the user becomes happy.

Define a new event class. You can add arbitrary metadata in the event class. For simplicity, we will not include any here though.

public class HappyEvent extends GwtEvent {
  ...
}

Define a new handler and marker interface for the event class.

interface HappyHandler extends EventHandler {
  public void onHappiness(HappyEvent event);
}

interface HasHappyEvents {
  public HandlerRegistration addHappyHandler(HappyHandler handler);
}

Add a unique event type

class HappyEvent extends AbstractEvent{
  public static AbstractEvent.Key KEY = new AbstractEvent.Key(){...}

  public GwtEvent.Key getKey(){
    return KEY; 
  }
  ...
}

Wire up the handler's fire method

class HappyEvent extends GwtEvent {
  static Key<HappyEvent,HappyHandler> KEY = new Key<HappyEvent,HappyHandler>(){
    protected void fire(HappyHandler handler, HappyEvent event) {
       handler.onHappiness(event);
    };
   ...
}

Answer 6

Sounds like you want PropertyChange* support. Have a look at gwtx. Google 'gwt PropertyChange' and you will get multiple blogs that explain how to use it.