Each event has a set of browser events that fires it.  For example take

a look at the source of the HTMLTable Class in the gwt-user jar.  It
has the following constructor:

  public HTMLTable() {
    tableElem = DOM.createTable();
    bodyElem = DOM.createTBody();
    DOM.appendChild(tableElem, bodyElem);
    setElement(tableElem);
    sinkEvents(Event.ONCLICK);
  }

Basically, it is "sinking" only the ONCLICK event, and will ignore all
other events.   To 'sink' and event just means to react to any firings
of that event.  A full list of the various events are listed here:

http://code.google.com/webtoolkit/documentation/com.google.gwt.user.c...

So, for example, if you wanted the table to respond to ONDBLCLICK
events, all you need to do is extend the class of the table you want to

use (let's say FlexTable), so you would make the class:

public class HappyTable extends FlexTable {
        public HappyTable(){
                super();
                addTableListener(this);
                sinkEvents(Event.ONCLICK | Event.ONDBLCLICK |
Event.ONKEYDOWN);
        }
...

click, and key press events.  In the same code you would create an
onBrowser event method which would define what you want to do:

public void onBrowserEvent(Event event) {
                // Find out which cell was actually clicked.
                Element td = getEventTargetCell(event);
                if (td == null) {
                        return;
                }
                Element tr = DOM.getParent(td);
                Element body = DOM.getParent(tr);
                int row = DOM.getChildIndex(body, tr);
                int column = DOM.getChildIndex(tr, td);
                switch (DOM.eventGetType(event)) {
                case Event.ONCLICK: {
                        if (this.tableListeners != null) {
                                // Fire the event.
                                tableListeners.fireCellClicked(this,
row, column);
                        }
                        break;

                }
                case Event.ONDBLCLICK: {
                        if (this.tableListeners != null) {
                                // Fire the event.
                                tableListeners.fireCellDblClicked(this,
row, column);
                        }
                        break;
                }
                case Event.ONKEYDOWN: {
                        if (DOM.eventGetKeyCode(event) == KEY_UP) {
                                // Fire the event.
                                tableListeners.fireUpKey(this);
                        }
                        else if (DOM.eventGetKeyCode(event) ==
KEY_DOWN) {
                                // Fire the event.
                                tableListeners.fireDownKey(this);
                        }
                        break;
                }
                default: {
                        // Do nothing
                }

                }
        }

Because I was doing a variety of things with the table I created my own

listener interface, and listener collection which included double
clicks, but this is not necessary for simpler things.  Here it is
anyway (note that this implements all of clicks, dblclicks, and up/down

keys):

public interface HappyTableListener extends TableListener{

        public void onCellDblClicked(SourcesTableEvents sender, int
row, int
cell);
        public void onUpKey(SourcesTableEvents sender);
        public void onDownKey(SourcesTableEvents sender);

        public void fireCellClicked(SourcesTableEvents sender, int row,
int
cell) {
                for (Iterator it = iterator(); it.hasNext();) {
                        MyTableListener listener = (MyTableListener)
it.next();
                        listener.onCellClicked(sender, row, cell);
                }
        }

        public void fireCellDblClicked(SourcesTableEvents sender, int
row, int
cell) {
                for (Iterator it = iterator(); it.hasNext();) {
                        MyTableListener listener = (MyTableListener)
it.next();
                        listener.onCellDblClicked(sender, row, cell);
                }
        }

        public void fireUpKey(SourcesTableEvents sender) {
                for (Iterator it = iterator(); it.hasNext();) {
                        MyTableListener listener = (MyTableListener)
it.next();
                        listener.onUpKey(sender);
                }
        }
        public void fireDownKey(SourcesTableEvents sender) {
                for (Iterator it = iterator(); it.hasNext();) {
                        MyTableListener listener = (MyTableListener)
it.next();
                        listener.onDownKey(sender);
                }
        }