Events

Once we create a display and some widgets, and start up the application's message loop, where does the real work happen? It happens every time an event is read from the queue and dispatched to a widget. Most of the application logic is implemented as responses to user events.

The basic pattern is that you add a listener to some widget that you have created, and when the appropriate event occurs the listener code will be executed. This simple example is adapted from org.eclipse.swt.examples.helloworld.HelloWorld3:

   Display display = new Display ();
   Shell shell = new Shell (display);
   Label label = new Label (shell, SWT.CENTER);
   ...
   shell.addControlListener (new ControlAdapter () {
      public void controlResized (ControlEvent e) {
         label.setBounds (shell.getClientArea ());
      }
   });

For each type of listener, there is an interface that defines the listener (XyzListener), a class that provides event information (XyzEvent), and an API method to add the listener (addXyzListener). If there is more than one method defined in the listener interface then there is an adapter (XyzAdapter) that implements the listener interface and provides empty methods. All of the events, listeners, and adapters are defined in the package org.eclipse.swt.events.

The following tables summarize the events that are available and the widgets that support each event. Events can be split into two general categories: high level events which represent a logical operation on a control, and low level events which describe more specific user interactions. High level events may be represented by multiple low level events which may differ per platform. Low level events should generally only be used for custom widget implementations.

High level events

Low level events

Untyped events

In addition to the typed event system described above, SWT supports a low level, untyped widget event mechanism. The untyped mechanism relies on a constant to identify the event type and defines a generic listener that is supplied with this constant. This allows the listener to implement a "case style" listener. In the following snippet, we define a generic event handler and add several listeners to a shell.

   Shell shell = new Shell ();
   Listener listener = new Listener () {
      public void handleEvent (Event e) {
         switch (e.type) {
            case SWT.Resize:
               System.out.println ("Resize received");
               break;
            case SWT.Paint:
               System.out.println ("Paint received");
               break;
            default:
               System.out.println ("Unknown event received");
         }
      }
   };
   shell.addListener (SWT.Resize, listener);
   shell.addListener (SWT.Paint, listener);