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.
You create a HandlerManager and now you have to create an Event and a Handler. How would you define those classes so that you can subscribe and fire events?
Most of the Events are DOM based, while I want to create some custom events and handlers that I can fire outside of any browser-based event.
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).
ReplyDeleteThis 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);
};
...
}
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.
ReplyDeleteMy 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);
}
}
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.
ReplyDeleteI think that the most complete and detailed example is in this article
ReplyDeleteIt contains also an example project that shows exactly how to properly use define custom events and use GWT's HandlerManager class.
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:
ReplyDeletecom.google.gwt.event.shared.HandlerManager
com.google.gwt.event.shared.GwtEvent
com.google.gwt.event.shared.EventHandler
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.
ReplyDeleteYou might want to have a look at the ValueChangeHandler and ValueChangeEvent in GWT 1.6. Those might work for what you're trying to do.
ReplyDeleteOne additional comment: if you try do to something similar to react in a main application to an event fired from a custom GUI component (like a composite etc.), I think you have to wire the main app explicitly to handle the component's event:
ReplyDeleteyourComponent.addHandler(this, YourEvent.TYPE);
where "this" is the class that implements your custom handler interface.