Chapter 16. Swing

Swing is Java’s graphical user interface toolkit. The javax.swing package (and its numerous subpackages) contain classes representing interface items such as windows, buttons, combo boxes, trees, tables, and menus—everything you need to build a modern, rich client-side application.

Swing is part of a larger collection of software called the Java Foundation Classes (JFC), which includes the following APIs:

JFC is one of the largest and most complex parts of the standard Java platform, so it shouldn’t be any surprise that we’ll take several chapters to discuss it. In fact, we won’t even get to talk about all of it, just the most important parts—Swing and the 2D API. Here’s the lay of the land:

We can’t cover the full functionality of Swing in this book; if you want the whole story, see Java Swing by Marc Loy, Robert Eckstein, Dave Wood, Brian Cole, and James Elliott (O’Reilly). Instead, we’ll cover the basic tools you are most likely to use and show some examples of what can be done with some of the more advanced features. Figure 16-1 shows the user interface component classes of the javax.swing package.

To understand Swing, it helps to understand its predecessor, AWT. As its name suggests, AWT is an abstraction. Like the rest of Java, it was designed to be portable; its functionality is the same for all Java implementations. However, people generally expect their applications to have a consistent look and feel and that is usually different on different platforms. So AWT was designed to provide the same functionality on all platforms, yet have the appearance of a native application. The idea is that you could choose to write your code under Windows, then run it on an X Window System or a Macintosh and get more or less the native look and feel on each platform for free.To achieve platform binding, AWT uses interchangeable toolkits that interact with the host windowing system to display user interface components. This shields the Java application from the details of its environment in which it’s running and keeps the APIs pure. Let’s say you ask AWT to create a button. When your application or applet runs, a toolkit appropriate to the host environment renders the button appropriately: on Windows, you can get a button that looks like other Windows buttons; on a Macintosh, you can get a Mac button; and so on.

AWT had some serious shortcomings, however. The worst was that the use of platform-specific toolkits meant that AWT applications might be subtly incompatible on different platforms. Furthermore, AWT lacked advanced user interface components, such as trees and grids, which were not common to all environments. AWT provided the desired look and feel, but limited the features and true portability of Java GUI applications.

Swing takes a fundamentally different approach. Instead of using native toolkits to supply interface items, such as buttons and combo boxes, components in Swing are implemented in Java itself. This means that, whatever platform you’re using, by default a Swing button (for example) looks the same. However, Swing also provides a powerful, pluggable look-and-feel API that allows the native operating system appearance to be rendered at the Java level. Working purely in Java makes Swing much less prone to platform-specific bugs, which were a problem for AWT. It also means that Swing components are much more flexible and can be extended and modified in your applications in ways that native components could never be.

User interface components in the javax.swing package
Figure 16-1. User interface components in the javax.swing package

Working with user interface components in Swing is meant to be easy. When building a user interface for your application, you’ll be working with a large set of prefabricated components. It’s easy to assemble a collection of user interface components (buttons, text areas, etc.) and arrange them inside containers to build complex layouts. However, when necessary, you can build upon these simple components to make entirely new kinds of interface gadgets that are completely portable and reusable.

Swing uses layout managers to arrange components inside containers and control their sizing and positioning. Layout managers define a strategy for arranging components instead of specifying absolute positions. For example, you can define a user interface with a collection of buttons and text areas and be reasonably confident that it will always display correctly, even if the user resizes the application window. It doesn’t matter what platform or user interface look-and-feel you’re using; the layout manager should still position them sensibly with respect to each other.

The next two chapters contain examples using most of the components in the javax.swing package. Before we dive into those examples, we need to spend some time talking about the concepts Swing uses for creating and handling user interfaces. This material should get you up to speed on GUI concepts and how they are used in Java.

Components

A component is the fundamental user interface object in Java. Everything you see on the display in a Java application is a component. This includes things like windows, panels, buttons, checkboxes, scrollbars, lists, menus, and text fields. To be used, a component usually must be placed in a container. Container objects group components, arrange them for display using a layout manager, and associate them with a particular display device. All Swing components are derived from the abstract javax.swing.JComponent class, as you saw in Figure 16-1. For example, the JButton class is a subclass of AbstractButton, which is itself a subclass of the JComponent class.

JComponent is the root of the Swing component hierarchy, but it descends from the AWT Container class. At this bottom level, Swing is based on AWT, so our conversation occasionally delves into the AWT package. Container’s superclass is Component, the root of all AWT components, and Component’s superclass is, finally, Object. Because JComponent inherits from Container, it has the capabilities of both a component and a container.

AWT and Swing, then, have parallel hierarchies. The root of AWT’s hierarchy is Component, while Swing’s components are based on JComponent. You’ll find similar classes in both hierarchies, such as Button and JButton, List, and JList. But Swing is much more than a replacement for AWT—it contains sophisticated components as well as a real implementation of the Model-View-Controller (MVC) paradigm, which we’ll discuss later.

For the sake of simplicity, we can split the functionality of the JComponent class into two categories: appearance and behavior. The JComponent class contains methods and variables that control an object’s general appearance. This includes basic attributes, such as its visibility, its current size and location, and certain common graphical defaults, such as font and background color, used by different subclasses in different ways. The JComponent class also contains graphics and event-handling methods, which are overridden by subclasses to produce all of the different kinds of widgets that we will see.

When a component is first displayed, it’s associated with a particular display device. The JComponent class encapsulates access to its display area on that device. It includes tools for rendering graphics, for working with off-screen resources, and for receiving user input. Under the covers, JComponent makes heavy use of the Java 2D API to handle things like font smoothing, rendering optimizations, and rendering hints. With recent versions of Java (6 and later), rendering speed and quality are often indistinguishable from native applications on popular operating systems.

When we talk about a component’s behavior, we mean the way it responds to user-driven events. When the user performs an action (such as pressing the mouse button) within a component’s display area, a Swing thread delivers an event object that describes what happened. The event is delivered to objects that have registered themselves as listeners for that type of event from that component. For example, when the user clicks on a button, the button generates an ActionEvent object. To receive those events, an object registers with the button as an ActionListener.

Events are delivered by invoking designated event handler methods within the receiving object (the “listener”). A listener object receives specific types of events through methods of its listener interfaces (for example, through the actionPerformed() method of the ActionListener interface) for the types of events in which it is interested. Specific types of events cover different categories of component user interaction. For example, MouseEvents describe activities of the mouse within a component’s area, KeyEvents describe keypresses, and higher-level events (such as ActionEvents) indicate that a user interface component has done its job.

We will describe events thoroughly in this chapter because they are so fundamental to the way in which user interfaces function in Java. But they aren’t limited to building user interfaces; they are an important interobject communications mechanism, which may be used by completely nongraphical parts of an application, as well. They are particularly important in the context of JavaBeans, which uses events as a generalized change-notification mechanism.

Swing’s event architecture is very flexible. Instead of requiring every component to listen for and handle events for its own bit of the user interface, an application may register arbitrary event “handler” objects to receive the events for one or more components and “glue” those events to the correct application logic. A container might, for example, process some of the events relating to its child components.

In the graphical realm, the primary responsibility of a container is to lay out the components it contains visually, within its borders. A component informs its container when it does something that might affect other components in the container, such as changing its size or visibility. The container then tells its layout manager that it is time to rearrange the child components.

As we mentioned, Swing components are all fundamentally derived from Container. This doesn’t mean that all Swing components can meaningfully contain arbitrary GUI elements within themselves. It does mean that the container-component relationship is built in at a low level. Containers can manage and arrange JComponent objects without knowing what they are or what they are doing. Components can be swapped and replaced with new versions easily and combined into composite user interface objects that can be treated as individual components themselves. This lends itself well to building larger, reusable user interface items.

Peers and Look-and-Feel

Swing components are sometimes referred to as peerless, or lightweight. These terms refer to the relationship that AWT has (and Swing does not have, respectively) with the native toolkits for rendering components on each platform. To get native components on the screen, AWT utilizes a set of peer objects that bridge the gap from pure Java to the host operating system.

At some level, of course, all our components have to talk to objects that contain native methods to interact with the host operating environment; the difference is at what level this occurs. AWT uses a set of peer interfaces. The peer interface makes it possible for a pure Java-language graphic component to use a corresponding real component—the peer object—in the native environment. With AWT, you don’t generally deal directly with peer interfaces or the objects behind them; peer handling is encapsulated within the Component class.

AWT relies heavily on peers. For example, if you create a window and add eight buttons to it, AWT creates nine peers for you—one for the window and one for each of the buttons. As an application programmer, you don’t have to worry about the peers, but they are always lurking under the surface, doing the real work of interacting with the operating system’s windowing toolkit.

In Swing, by contrast, most components are peerless, or lightweight. This means that Swing components don’t have any direct interaction with the underlying windowing system. They draw themselves in their parent container and respond to user events in pure Java, with no native code involved. In Swing, only the top-level (lowest API level) windows interact with the windowing system. These Swing containers descend from AWT counterparts, and, thus, still have peers. In Swing, if you create a window and add eight buttons to it, only one peer is created—for the window. Because it has fewer interactions with the underlying windowing system than AWT, Swing is less vulnerable to the peculiarities of any particular platform.

With lightweight components, it is easy to change their appearance. Because each component draws itself instead of relying on a peer, it can decide at runtime how to render itself. Accordingly, Swing supports different look-and-feel schemes, which can be changed at runtime. (A look-and-feel is the collected appearance of components in an application.) Look-and-feels based on Windows, Macintosh, and Motif are available (though licensing issues may encumber their use on various platforms), as well as several entirely original Java creations, including Metal, Synth and Nimbus. Metal is the default cross-platform look-and-feel. It has a flat minimalist aesthetic and is very functional but, at this point, appears dated when compared to current versions of popular desktop environments. Synth makes Java applications “skinnable” at a high level using an XML descriptor file and images as resources. Java SE 6 update 10 introduced Nimbus, the first Java look-and-feel that is aesthetically on par with modern desktop operating systems such as OS X and Windows. Nimbus is vector-based, which allows components to be smoothly scaled for use on the new generation of high-density displays. If you want a consistent cross-platform look-and-feel, Nimbus is the best option.

The MVC Framework

Before continuing our discussion of GUI concepts, we want to make a brief aside and talk about the MVC framework. As we’ve discussed, MVC is a method of building reusable components that logically separates the structure, presentation, and behavior of a component into separate pieces. MVC is primarily concerned with building user interface components, but the basic ideas can be applied to many design issues; its principles can be seen throughout Java.

The fundamental idea behind MVC is the separation of the data model for an item from its presentation. For example, we can draw different representations of the data in a spreadsheet (e.g., bar graphs, pie charts). The data is the model; the particular representation is the view. A single model can have many views that present the data differently. A user interface component’s controller defines and governs its behavior. Typically, this includes changes to the model, which, in turn, cause the view(s) to change. For a checkbox component, the data model could be a single Boolean variable, indicating whether it’s checked or not. The behavior for handling mouse-click events would alter the model, and the view would examine that data when it draws the on-screen representation.

The way in which Swing objects communicate, by passing events from sources to listeners, is part of this MVC concept of separation. Event listeners are “observers” (controllers) and event sources are “observables” (models).[38] When an observable changes or performs a function, it notifies all its observers of the activity.

Swing components explicitly support MVC. Each component is actually composed of two pieces. One piece, called the UI-delegate, is responsible for the “view” and “controller” roles. It takes care of drawing the component and responding to user events. The second piece is the data model itself. This separation makes it possible for multiple Swing components to share a single data model. For example, a read-only text box and a drop-down list box could use the same list of strings as a data model.

Painting

In an event-driven environment such as Swing, components can be asked to draw themselves at any time. In a more procedural programming environment, you might expect a component to be involved in drawing only when first created or when it changes its appearance. In Java, however, components act in a way that is closely tied to the underlying behavior of the display environment. For example, when you obscure a component with another window and then reexpose it, a Swing thread may ask the component to redraw itself.

Swing asks a component to draw itself by calling its paint() method. paint() may be called at any time, but in practice, it’s called when the object is first made visible, whenever it changes its appearance, or whenever some tragedy in the display system messes up its area. Because paint() can’t generally make any assumptions about why it was called, it must redraw the component’s entire display. The system may limit the drawing if only part of the component needs to be redrawn, but you don’t have to worry about this. Swing is fairly smart and will do everything it can to avoid asking components to redraw themselves (including using “backing store” where applicable).

A component never calls its paint() method directly. Instead, if a component requires redrawing, it requests a call to paint() by invoking repaint(). The repaint() method asks Swing to schedule the component for repainting. At some point after that, a call to paint() occurs. Swing is allowed to manage these requests in whatever way is most efficient. If there are too many requests to handle, or if there are multiple requests for the same component, the thread can collapse a number of repaint requests into a single call to paint(). This means that you don’t normally know exactly when paint() is called in response to a repaint(); all you can expect is that it happens at least once, after you request it.

Calling repaint() is normally an implicit request to be updated as soon as possible. Another form of repaint() allows you to specify a time period within which you would like an update, giving the system more flexibility in scheduling the request. The system tries to repaint the component within the time you specify, but if you happen to make more than one repaint request within that time period, the system may simply condense them to carry out a single update within the time you specified. An application performing simple animation could use this method to govern its refresh rate (by specifying a period that is the inverse of the desired frame rate).

As we’ve mentioned, Swing components can act as containers holding other components. Because every Swing component does its own drawing, Swing components are responsible for telling any contained components to draw themselves. Fortunately, this is all taken care of for you by a component’s default paint() method. If you override this method, however, you have to make sure to call the superclass’s implementation like this:

    public void paint(Graphics g) {
        super.paint(g);
        ...
    }

There’s a cleaner way around this problem. All Swing components have a method called paintComponent(). While paint() is responsible for drawing the component as well as its contained components, paintComponent()’s sole responsibility is drawing the component itself. If you override paintComponent() instead of paint(), you won’t have to worry about drawing contained components.

Both paint() and paintComponent() receive a single argument: a Graphics object. The Graphics object represents the component’s graphics context. It corresponds to the area of the screen on which the component can draw and provides the methods for performing primitive drawing and image manipulation. (We’ll look at the Graphics class in detail in Chapter 18.)

Enabling and Disabling Components

Standard Swing components can be turned on and off by calling the setEnabled() method. When a component such as a JButton or JTextField is disabled, it becomes “ghosted” or “greyed out” and doesn’t respond to user input.

For example, let’s see how to create a component that can be used only once. This requires getting ahead of the story; we won’t explain some aspects of this example until later. Earlier, we said that a JButton generates an ActionEvent when it is pressed. This event is delivered to the listeners’ actionPerformed() method. The following code disables the component that generated the event:

    public boolean void actionPerformed(ActionEvent e ) {
        ((JComponent)e.getSource()).setEnabled(false);
    }

This code calls getSource() to find out which component generated the event. We cast the result to JComponent because we don’t necessarily know what kind of component we’re dealing with; it might not be a button, because other kinds of components can generate action events. Once we know which component generated the event, we disable it.

You can also disable an entire container. Disabling a JPanel, for instance, disables all the components it contains.

Focus, Please

In order to receive keyboard events, a component has to have keyboard focus. The component with the focus is the currently selected component on the screen and is usually highlighted visually. It receives all keyboard event information until the focus changes to a new component. Typically, a component receives focus when the user clicks on it with the mouse or navigates to it using the keyboard. A component can ask for focus with the JComponent ’s requestFocus() method. You can configure whether a given component is eligible to receive focus with the setFocusable() method. By default, most components, including things such as buttons and checkboxes, are “focusable.” To make an entire window and its components nonfocusable, use the Window setFocusableWindowState() method.

The control of focus is often at the heart of the user’s experience with an application. Especially with text entry fields and forms, users are accustomed to a smooth transfer of focus with the use of keyboard navigation cues (e.g., Tab and Shift-Tab for forward and backward field navigation). The management of focus in a large GUI with many components could be complex. Fortunately, in Java 1.4 and later, Swing handles almost all this behavior for you, so, in general, you don’t have to implement code to specify how focus is transferred. Java 1.4 introduced an entirely new focus subsystem. The flexible KeyboardFocusManager API provides the expected common behavior by default and allows customization via FocusTraversalPolicy objects. We’ll discuss focus-related events later in this chapter and focus navigation more in Chapter 18.

Other Component Methods

The JComponent class is very large; it has to provide the base-level functionality for all the various kinds of Java GUI objects. It inherits a lot of functionality from its parent Container and Component classes. We don’t have room to document every method of the JComponent class here, but we’ll flesh out our discussion by covering some of the more important ones:

Container getParent(), String getName(), void setName(String name)

Get or assign the String name of this component. Naming a component is useful for debugging. The name is returned by toString().

void setVisible(boolean visible)

Make the component visible or invisible within its container. If you change the component’s visibility, the container’s layout manager automatically lays out its visible components.

Color getForeground(), void setForeground(Color c), void setBackground(Color c), Color getBackground()

Get and set the foreground and background colors for this component. The foreground color of any component is the default color used for drawing. For example, it is the color used for text in a text field as well as the default drawing color for the Graphics object passed to the component’s paint() and paintComponent() methods. The background color is used to fill the component’s area when it is cleared by the default implementation of update().

Dimension getSize(), void setSize(int width, int height)

Get and set the current size of the component. Note that a layout manager may change the size of a component even after you’ve set its size yourself. To change the size a component “wants” to be, use setPreferredSize(). There are other methods in JComponent to set its location, but this is normally the job of a layout manager.

Dimension getPreferredSize(), void setPreferredSize(Dimension preferredSize)

Use these methods to examine or set the preferred size of a component. Layout managers attempt to set components to their preferred sizes. If you change a component’s preferred size, you must call the method revalidate() on the component to get it laid out again.

Cursor getCursor(), void setCursor(Cursor cursor)

Get or set the type of cursor (mouse pointer) used when the mouse is over this component’s area. For example:

    JComponent myComponent = ...;
    Cursor crossHairs =
        Cursor.getPredefinedCursor( Cursor.CROSSHAIR_CURSOR );
    myComponent.setCursor( crossHairs );

Containers

A container is a kind of component that holds and manages other components. Three of the most useful general container types are JFrame, JPanel, and JApplet. A JFrame is a top-level window on your display. JFrame is derived from java.awt.Window, which is pretty much the same but lacks a border (JWindow is the swing version of Window). A JPanel is a generic container element that groups components inside JFrames and other JPanels. The JApplet class is a kind of container that provides the foundation for applets that run inside web browsers. Like other containers, a JApplet can hold other user-interface components. You can also use the JComponent class directly, like a JPanel, to hold components inside another container. With the exception of JFrame, JWindow, JApplet, and JDialog (another window-like container), which are derived from AWT components, all the components and containers in Swing are lightweight.

A container maintains the list of “child” components it manages and has methods for dealing with those components. Note that this child relationship refers to a visual hierarchy, not a subclass/superclass hierarchy. By themselves, most components aren’t very useful until they are added to a container and displayed. The add() method of the Container class adds a component to the container. Thereafter, this component can be displayed in the container’s display area and positioned by its layout manager. You can remove a component from a container with the remove() method.

Layout Managers

A layout manager is an object that controls the placement and sizing of components within the display area of a container. A layout manager is like a window manager in a display system; it controls where the components go and how big they are. Every container has a default layout manager, but you can install a new one by calling the container’s setLayout() method.

Swing comes with a few layout managers that implement common layout schemes. The default layout manager for a JPanel is a FlowLayout, which tries to place objects at their preferred size from left to right and top to bottom in the container. The default for a JFrame is a BorderLayout, which places objects at specific locations within the window, such as NORTH, SOUTH, and CENTER. Another layout manager, GridLayout, arranges components in a rectangular grid. The most general (and difficult to use) layout manager is GridBagLayout, which lets you do the kinds of things you can do with HTML tables. (We’ll get into the details of all these layout managers in Chapter 19.)

When you add a component to a container using a simple layout manager, you’ll often use the version of add() that takes a single Component as an argument. However, if you’re using a layout manager that uses “constraints,” such as BorderLayout or GridBagLayout, you must specify additional information about where to put the new component. For that, you can use the version that takes a constraint object. Here’s how to place a component at the top edge of a container that uses a BorderLayout manager:

    myContainer.add(myComponent, BorderLayout.NORTH);

In this case, the constraint object is the static member variable NORTH. GridBagLayout uses a much more complex constraint object to specify positioning.

Insets

Insets specify a container’s margins; the space specified by the container’s insets won’t be used by a layout manager. Insets are described by an Insets object, which has four public int fields: top, bottom, left, and right. You normally don’t need to worry about the insets; the container sets them automatically, taking into account extras like the menu bar that may appear at the top of a frame. To find the insets, call the component’s getInsets() method, which returns an Insets object.

Z-Ordering (Stacking Components)

With the standard layout managers, components are not allowed to overlap. However, if you use custom-built layout managers or absolute positioning, components within a container may overlap. If they do, the order in which components were added to a container matters. When components overlap, they are “stacked” in the order in which they were added: the first component added to the container is on top, and the last is on the bottom. To give you more control over stacking, two additional forms of the add() method take an extra integer argument that lets you specify the component’s exact position in the container’s stacking order. Again, you don’t normally need to think about this, but it’s nice to know for the sake of completeness that it’s there.

The revalidate() and doLayout() Methods

A layout manager arranges the components in a container only when it is asked to do so. Several things can mess up a container after it’s initially laid out:

  • Changing its size

  • Resizing or moving one of its child components

  • Adding, showing, removing, or hiding a child component

Any of these actions cause the container to be marked invalid. This means that it needs to have its child components readjusted by its layout manager. In most cases, Swing readjusts the layout automatically. All components, not just containers, maintain a notion of when they are valid or invalid. If the size, location, or internal layout of a Swing component changes, its revalidate() method is automatically called. Internally, the revalidate() method first calls the method invalidate() to mark the component and all its enclosing containers as invalid. It then validates the tree. Validation descends the hierarchy, starting at the nearest validation root container, recursively validating each child. Validating a child Container means invoking its doLayout() method, which asks the layout manager to do its job and then notes that the Container has been reorganized by setting its state to valid again. A validation root is a container that can accommodate children of any size such as JScrollPane (and, hence, can accommodate any possible changes in its child hierarchy without upsetting its own parents).

There are a few cases in which you may need to tell Swing to fix things manually. One example is when you change the preferred size of a component (as opposed to its actual onscreen size). To clean up the layout, call the revalidate() method. For example, if you have a small JPanel—say, a keypad holding some buttons—and you change the preferred size of the JPanel by calling its setPreferredSize() method, you should also call revalidate() on the panel or its immediate container. The layout manager of the panel then rearranges its buttons to fit inside its new area.

Managing Components

There are a few additional tools of the Container class we should mention:

Component[] getComponents()

Returns the container’s components in an array.

void list(PrintWriter out, int indent)

Generates a list of the components in this container and writes them to the specified PrintWriter.

Component getComponentAt(int x, int y)

Tells you what component is at the specified coordinates in the container’s coordinate system.

Listening for Components

You can use the ContainerListener interface to automate setting up a container’s new components. A container that implements this interface can receive an event whenever it gains or loses a component. This facility makes it easy for a container to micromanage its components.

Windows, Frames and Splash Screens

Windows and frames are the top-level containers for Java components. A JWindow is simply a plain, graphical screen that displays in your windowing system. Windows have no frills; they are mainly suitable for pop-up windows and in situations where drop-down components such as menus and combo boxes extend outside their parent frame. JFrame, on the other hand, is a subclass of JWindow that has a titlebar, window-managed buttons (close, minimize, etc.), and border. You can drag a frame around on the screen and resize it, using the ordinary controls for your windowing environment. Figure 16-2 shows a JFrame on the left and a JWindow on the right.

All other Swing components and containers must be held, at some level, inside a JWindow or JFrame. Applets are a kind of Container. Even applets must be housed in a frame or window, though normally you don’t see an applet’s parent frame because it is part of (or simply is) the browser or appletviewer displaying the applet.

A frame and a window
Figure 16-2. A frame and a window

JFrames and JWindows are the only components that can be displayed without being added or attached to another Container. After creating a JFrame or JWindow, you can call the setVisible() method to display it. The following short application creates a JFrame and a JWindow and displays them side by side, just as in Figure 16-2.

    //file: TopLevelWindows.java
    import javax.swing.*;

    public class TopLevelWindows {
      public static void main(String[] args) {
        JFrame frame = new JFrame("The Frame");
        frame.setSize(300, 300);
        frame.setLocation(100, 100);

        JWindow window = new JWindow();
        window.setSize(300, 300);
        window.setLocation(500, 100);

        frame.setVisible(true);
        window.setVisible(true);
      }
    }

The JFrame constructor can take a String argument that supplies a title, displayed in the JFrame’s titlebar. (Or you can create the JFrame with no title and call setTitle() to supply the title later.) The JFrame’s size and location on your desktop are determined by the calls to setSize() and setLocation(). After creating the JFrame, we create a JWindow in almost exactly the same way. The JWindow doesn’t have a titlebar, so there are no arguments to the JWindow constructor.

Once the JFrame and JWindow are set up, we call setVisible(true) to get them on the screen. The setVisible() method returns immediately, without blocking. Fortunately, our application does not exit, even though we’ve reached the end of the main() method, because the windows are still visible. You can close the JFrame by clicking on the close button in the titlebar. JFrame’s default behavior is to hide itself when you click on the box by calling setVisible(false). You can alter this behavior by calling the setDefaultCloseOperation() method or by adding an event listener, which we’ll cover later. Because we haven’t arranged any other means here, you will need to hit Ctrl-C or whatever keystroke kills a process on your machine in order to stop execution of the TopLevelWindows application.

Use of a SplashScreen, which is an AWT class used to control a specialized container, is the preferred way to display a start-up screen for Swing applications. Prior to Java 1.6, applications were forced to use Window or JWindow for this purpose, but these are suboptimal solutions for a splash screen because they are only displayed after the JVM, AWT, and Swing libraries are initialized. The new splash screen object allows you to specify an image file in your application jar’s manifest (see Chapter 3) that will be displayed immediately after launch without having to wait for the JVM to initialize. Specifying a splash screen image in your jar manifest is trivial.

Manifest-Version: 1.0
Main-Class: MangoMango1
SplashScreen-Image: ripe_mango.png

No code is required to display a splash screen. The ripe_mango.png image will appear centered on the screen until the first AWT or Swing window is shown by the MangoMango1 application. Supported image types are GIF, JPEG, and PNG.

Other Methods for Controlling Frames

The setLocation() method of the Component class can be used on a JFrame or JWindow to set its position on the screen. The x and y coordinates are relative to the screen’s origin (the top-left corner).

You can use the toFront() and toBack() methods to place a JFrame or JWindow in front of, or behind, other windows. By default, a user is allowed to resize a JFrame, but you can prevent resizing by calling setResizable(false) before showing the JFrame.

On most systems, frames can be “iconified”—that is, they can be shrunk down and represented by a little icon image. You can get and set a frame’s icon image by calling getIconImage() and setIconImage(). As you can with all components, you can set the cursor by calling the setCursor() method.

Content Panes

Windows and frames have a little more structure than simple containers. Specifically, to support some of the fancier GUI features that require overlaying graphics (such as pop ups and menus), windows and frames actually consist of a number of separate overlapping container “panes” (as in glass) with names such as the root pane, layered pane, and glass pane. The primary pane of interest is usually the content pane. The content pane is just a Container that covers the visible area of the JFrame or JWindow; it is the container to which we want to add child components.

For convenience, JFrame and JWindow delegate methods such as add() and setLayout() to their ContentPane. In other words, calling myFrame.add(component) is equivalent to calling myFrame.getContentPane().add(component).

    //file: MangoMango1.java
    import java.awt.*;
    import javax.swing.*;

    public class MangoMango1 {
      public static void main(String[] args) {
        JFrame frame = new JFrame("The Frame");
     // The three methods below are delegated to the frame's ContentPane.
        frame.setLayout(new FlowLayout());
        frame.add(new JLabel("Mango"));
        frame.add(new JButton("Mango"));

        frame.setLocation(100, 100);
        frame.pack();
        frame.setVisible(true);
      }
    }

The call to JFrame’s pack() method tells the frame window to resize itself to the minimum size required to hold all its components. Instead of having to determine the size of the JFrame, pack tells it to be “just big enough.” If you do want to set the absolute size of the JFrame yourself, call setSize() instead.

We’ll cover labels and buttons in Chapter 17 and layouts in Chapter 19.

Desktop Integration

One of the focuses of Java 6 was improving desktop integration so that Swing apps can stand toe-to-toe with native apps. The new desktop features provide access to the system tray, browser, email client and file/application associations.

The Desktop class in java.awt provides the ability to:

The Desktop class has a very simple API. The following example opens the default browser and navigates to the Duke Lemur Center’s home page.

    //file: DisplayLemur.java
    import java.awt.*;
    import java.io.*;
    import java.net.*;

    public class DisplayLemur {
        public static void main(String[] args) {
            URI uri = null;
            try {
                uri = new URI("http://lemur.duke.edu");
                Desktop.getDesktop().browse(uri);
            } catch(IOException ioe) {
                System.out.println("Cannot browse to " + uri);
            } catch(URISyntaxException use) {
                System.out.println("The URI " + uri + " is malformed");
            } 
        }
    }

All the aforementioned desktop features are similarly available as single method calls on the Desktop singleton: open(File file), edit(File file), print(File file), and mail(URI mailtoURI).

The SystemTray class, also found in java.awt, provides access to the area of the desktop that allows menu items to perform actions on currently running programs. On Windows, this is the Taskbar Status Area. On OS X, it’s the Menu Extras area on the right of the system menu. On GNOME, it’s the Notification Area.

The following example creates a TrayIcon, places it in the SystemTray, and attaches a single menu item. Selecting the menu item will cause a greeting dialog to appear.

    import java.awt.*;
    import java.awt.event.*;
    import java.awt.image.*;
    import javax.swing.*;

    public class AlohaTray {
    
        public static void main(String[] args) throws AWTException {
            MenuItem greetItem = new MenuItem("Greet me");
            
            // Listen for a menu selection and display a greeting dialog
            greetItem.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    JOptionPane.showMessageDialog(null, "Aloha!");
                    System.exit(0);
                }
            });
            
            // Create the TrayIcon's PopupMenu and add the MenuItem
            PopupMenu popup = new PopupMenu();
            popup.add(greetItem);
            
            // Create the TrayIcon and add it to the SystemTray
            TrayIcon trayIcon = new TrayIcon(getIconImage(), 
                "A friendly greeting", popup);
            SystemTray.getSystemTray().add(trayIcon);
        }
        
        // Grabbing a default Swing icon for the SystemTray
        private static Image getIconImage() {
            Icon icon = UIManager.getIcon("OptionPane.informationIcon");
            BufferedImage image = new BufferedImage(icon.getIconWidth(), 
                icon.getIconHeight(), BufferedImage.TYPE_INT_ARGB);
            icon.paintIcon(null, image.getGraphics(), 0, 0);
            return image;        
        }
    }

Events

We’ve spent a lot of time discussing the different kinds of objects in Swing—components, containers, and special containers such as frames and windows. Now it’s time to discuss interobject communication in detail.

Swing objects communicate by sending events. The way we talk about events—“firing” them and “handling” them—makes it sound as if they are part of some special Java language feature. But they aren’t. An event is simply an ordinary Java object that is delivered to its receiver by invoking an ordinary Java method. Everything else, however interesting, is purely convention. The entire Java event mechanism is really just a set of conventions for the kinds of descriptive objects that should be delivered; these conventions prescribe when, how, and to whom events should be delivered.

Events are sent from a single source object to one or more listeners. A listener implements prescribed event-handling methods that enable it to receive a type of event. It then registers itself with a source of that kind of event. Sometimes an adapter object may be interposed between the event source and the listener, but in any case, registration of a listener is always established before any events are delivered.

An event object is an instance of a subclass of java.util.EventObject; it holds information about something that’s happened to its source. The EventObject parent class itself serves mainly to identify event objects; the only information it contains is a reference to the event source (the object that sent the event). Components don’t normally send or receive EventObjects as such; they work with subclasses that provide more specific information.

AWTEvent is a subclass of java.awt.EventObject; further subclasses of AWTEvent provide information about specific event types. Swing has events of its own that descend directly from EventObject. For the most part, you’ll just be working with specific event subclasses from the AWT or Swing packages.

ActionEvents correspond to a decisive “action” that a user has taken with the component, such as clicking a button or pressing Enter. An ActionEvent carries the name of an action to be performed (the action command) by the program. MouseEvents are generated when a user uses the mouse within a component’s area. They describe the state of the mouse and therefore carry such information as the x and y coordinates and the state of your mouse buttons at the time the MouseEvent was created.

ActionEvent operates at a higher semantic level than MouseEvent: an ActionEvent lets us know that a component has performed its job; a MouseEvent simply confers a lot of information about the mouse at a given time. You could figure out that somebody clicked on a JButton by examining mouse events, but it is simpler to work with action events. The precise meaning of an event can also depend on the context in which it is received.

Event Receivers and Listener Interfaces

An event is delivered by passing it as an argument to the receiving object’s event handler method. ActionEvents, for example, are always delivered to a method called actionPerformed() in the receiver:

    public void actionPerformed( ActionEvent e ) {
        ...
    }

For each type of event, a corresponding listener interface prescribes the method(s) it must provide to receive those events. In this case, any object that receives ActionEvents must implement the ActionListener interface:

    public interface ActionListener extends
    java.util.EventListener {
        public void actionPerformed( ActionEvent e );
    }

All listener interfaces are subinterfaces of java.util.EventListener, which is an empty interface. It exists only to help Java-based tools such as IDEs identify listener interfaces.

Listener interfaces are required for a number of reasons. First, they help to identify objects that can receive a given type of event—they make event hookups “strongly typed.” Event listener interfaces allow us to give the event handler methods friendly, descriptive names and still make it easy for documentation, tools, and humans to recognize them in a class. Next, listener interfaces are useful because several methods can be specified for an event receiver. For example, the FocusListener interface contains two methods:

    abstract void focusGained( FocusEvent e );
    abstract void focusLost( FocusEvent e );

Although these methods each take a FocusEvent as an argument, they correspond to different reasons (contexts) for firing the event—in this case, whether the FocusEvent means that focus was received or lost. In this case, you could also figure out what happened by inspecting the event; all AWTEvents contain a constant specifying the event’s type. But by using two methods, the FocusListener interface saves you the effort: if focusGained() is called, you know the event type was FOCUS_GAINED.

Similarly, the MouseListener interface defines five methods for receiving mouse events (and MouseMotionListener defines two more), each of which gives you some additional information about why the event occurred. In general, the listener interfaces group sets of related event handler methods; the method called in any given situation provides a context for the information in the event object.

There can be more than one listener interface for dealing with a particular kind of event. For example, the MouseListener interface describes methods for receiving MouseEvents when the mouse enters or exits an area or a mouse button is pressed or released. MouseMotionListener is an entirely separate interface that describes methods to get mouse events when the mouse is moved (no buttons pressed) or dragged (buttons pressed). By separating mouse events into these two categories, Java lets you be a little more selective about the circumstances under which you want to receive MouseEvents. You can register as a listener for mouse events without receiving mouse motion events; because mouse motion events are extremely common, you don’t want to handle them if you don’t need to.

Two simple patterns govern the naming of Swing event listener interfaces and handler methods:

  • Event handler methods are public methods that return type void and take a single event object (a subclass of java.util.EventObject) as an argument.[39]

  • Listener interfaces are subclasses of java.util.EventListener that are named with the suffix “Listener”—for example, MouseListener and ActionListener.

These may seem obvious, but they are nonetheless important because they are our first hint of a design pattern governing how to build components that work with events.

Event Sources

The previous section described the machinery an event receiver uses to listen for events. In this section, we’ll describe how a receiver tells an event source to send it events as they occur.

To receive events, an eligible listener must register itself with an event source. It does this by calling an “add listener” method in the event source and passing a reference to itself. (Thus, this scheme implements a callback facility.) For example, the Swing JButton class is a source of ActionEvents. Here’s how a TheReceiver object might register to receive these events:

    // receiver of ActionEvents
    class TheReceiver implements ActionListener
    {
       // source of ActionEvents
       JButton theButton = new JButton("Belly");

       TheReceiver() {
          ...
          theButton.addActionListener( this );
       }

       public void actionPerformed( ActionEvent e ) {
          // Belly Button pushed...
       }

TheReciever makes a call to the button’s addActionListener() to receive ActionEvents from the button when they occur. It passes the reference this to register itself as an ActionListener.

To manage its listeners, an ActionEvent source (like the JButton) always implements two methods:

    // ActionEvent source
    public void addActionListener(ActionListener listener) {
        ...
    }
    public void removeActionListener(ActionListener listener) {
        ...
    }

The removeActionListener() method removes the listener from the list so that it will not receive future events of that kind. Swing components supply implementations of both methods; normally, you won’t need to implement them yourself. It’s important to pay attention to how your application uses event sources and listeners. It’s OK to throw away an event source without removing its listeners, but it isn’t necessarily OK to throw away listeners without removing them from the source first because the event source might maintain references to them, preventing them from being garbage-collected.

You may be expecting some kind of “event source” interface listing these two methods and identifying an object as a source of this event type, but there isn’t one. There are no event source interfaces in the current conventions. If you are analyzing a class and trying to determine what events it generates, you have to look for the paired add and remove methods. For example, the presence of the addActionListener() and removeActionListener() methods define the object as a source of ActionEvents. If you happen to be a human being, you can simply look at the documentation, but if the documentation isn’t available, or if you’re writing a program that needs to analyze a class (a process called reflection), you can look for this design pattern. (The java.beans.Introspector utility class can do this for you.)

A source of FooEvent events for the FooListener interface must implement a pair of add/remove methods:

  • addFooListener(FooListener listener )

  • removeFooListener(FooListener listener )

If an event source can support only one event listener (unicast delivery), the add listener method can throw the java.util.TooManyListenersException.

What do all the naming patterns up to this point accomplish? For one thing, they make it possible for automated tools and integrated development environments to divine sources of particular events. Tools that work with JavaBeans will use the Java reflection and introspection APIs to search for these kinds of design patterns and identify the events that can be fired by a component.

At a more concrete level, it also means that event hookups are strongly typed, just like the rest of Java. So it’s impossible to accidentally hook up the wrong kind of components; for example, you can’t register to receive ItemEvents from a JButton because a button doesn’t have an addItemListener() method. Java knows at compile time what types of events can be delivered to whom.

Event Delivery

Swing and AWT events are multicast; every event is associated with a single source but can be delivered to any number of receivers. When an event is fired, it is delivered individually to each listener on the list (see Figure 16-3).

Event delivery
Figure 16-3. Event delivery

There are no guarantees about the order in which events are delivered. Nor are there any guarantees about what happens if you register yourself more than once with an event source; you may or may not get the event more than once. Similarly, you should assume that every listener receives the same event data. In general, events are immutable; they can’t be changed by their listeners.

To be complete, we could say that event delivery is synchronous with respect to the event source, but that is because the event delivery is really just the invocation of a normal Java method. The source of the event calls the handler method of each listener. However, listeners shouldn’t assume that all the events will be sent in the same thread unless they are AWT/Swing events, which are always sent serially by a global event dispatcher thread.

Event Types

All the events used by Swing GUI components are subclasses of java.util.EventObject. You can use or subclass any of the EventObject types for use in your own components. We describe the important event types here.

The events and listeners that are used by Swing fall into two packages: java.awt.event and javax.swing.event. As we’ve discussed, the structure of components has changed significantly between AWT and Swing. The event mechanism, however, is fundamentally the same, so the events and listeners in java.awt.event are used by Swing components. In addition, Swing has added event types and listeners in the package javax.swing.event.

java.awt.event.ComponentEvent is the base class for events that can be fired by any component. This includes events that provide notification when a component changes its dimensions or visibility, as well as the other event types for mouse operations and keypresses. ContainerEvents are fired by containers when components are added or removed.

The java.awt.event.InputEvent Class

MouseEvents, which track the state of the mouse, and KeyEvents, which are fired when the user uses the keyboard, are kinds of java.awt.event.InputEvents. When the user presses a key or moves the mouse within a component’s area, the events are generated with that component identified as the source.

Input events and GUI events are processed in a special event queue that is managed by Swing. This gives Swing control over how all its events are delivered. First, under some circumstances, a sequence of the same type of event may be compressed into a single event. This is done to make some event types more efficient—in particular, mouse events and some special internal events used to control repainting. Perhaps more important to us, input events are delivered with extra information that lets listeners decide if the component itself should act on the event.

Mouse and Key Modifiers on InputEvents

InputEvents come with a set of flags for special modifiers. These let you detect whether the Shift, Control, or Alt keys were held down during a mouse button or keypress, and, in the case of a mouse button press, distinguish which mouse button was involved. The following are the flag values contained in java.awt.event.InputEvent:

SHIFT_MASK

Shift key with event

CTRL_MASK

Control key with event

ALT_MASK

Windows Alt key or Mac Option/Alt with event; equivalent to BUTTON2_MASK

META_MASK

Mac Command key with event; equivalent to BUTTON3_MASK

BUTTON1_MASK

Mouse Button 1

BUTTON2_MASK

Mouse Button 2; equivalent to ALT_MASK

BUTTON3_MASK

Mouse Button 3; equivalent to META_MASK

To check for one or more flags, evaluate the bitwise AND of the complete set of modifiers and the flag or flags you’re interested in. The complete set of modifiers involved in the event is returned by the InputEvent’s getModifiers() method:

    public void mousePressed (MouseEvent e) {
        int mods = e.getModifiers();
        if ((mods & InputEvent.SHIFT_MASK) != 0) {
            // shifted Mouse Button press
        }
    }

The three BUTTON flags can determine which mouse button was pressed on a two- or three-button mouse. BUTTON2_MASK is equivalent to ALT_MASK, and BUTTON3_MASK is equivalent to META_MASK. This means that pushing the second mouse button is equivalent to pressing the first (or only) button with the Alt key depressed, and the third button is equivalent to the first with the “Meta” key depressed. These provide some minimal portability even for systems that don’t provide multibutton mice. However, for the most common uses of these buttons—pop-up menus—you don’t have to write explicit code; Swing provides special support that automatically maps to the correct gesture in each environment (see the PopupMenu class in Chapter 17).

Mouse-wheel events

Java 1.4 added support for the mouse wheel, which is a scrolling device in place of a middle mouse button. By default, Swing handles mouse-wheel movement for scrollable components, so you should not have to write explicit code to handle this. Mouse-wheel events are handled a little differently from other events because the conventions for using the mouse wheel don’t always require the mouse to be over a scrolling component. If the immediate target component of a mouse-wheel event is not registered to receive it, a search is made for the first enclosing container that wants to consume the event. This allows components enclosed in ScrollPanes to operate as expected.

If you wish to explicitly handle mouse-wheel events, you can register to receive them using the MouseWheelListener interface shown in Table 16-1 in the next section. Mouse-wheel events encapsulate information about the amount of scrolling and the type of scroll unit, which on most systems may be configured externally to be fine-grained scroll units or large blocks. If you want a physical measure of how far the wheel was turned, you can get that with the getWheelRotation() method, which returns a number of clicks.

Focus Events

As we mentioned earlier, focus handling is largely done automatically in Swing applications and we’ll discuss it further in Chapter 18. However, understanding how focus events are handled will help you understand and customize components.

As we described, a component can make itself eligible to receive focus using the JComponent setFocusable() method (Windows may use setFocusableWindowState()). A component normally receives focus when the user clicks on it with the mouse. It can also programmatically request focus using the requestFocus() or requestFocusInWindow() methods. The requestFocusInWindow() method acts just like requestFocus() except that it does not ask for transfer across windows. (There are currently limitations on some platforms that prevent focus transfer from native applications to Java applications, so using requestFocusInWindow() guarantees portability by adding this restriction.)

Although a component can request focus explicitly, the only way to verify when a component has received or lost focus is by using the FocusListener interface (see Tables 16-1 and 16-2). You can use this interface to customize the behavior of your component when it is ready for input (e.g., the TextField’s blinking cursor). Also, input components often respond to the loss of focus by committing their changes. For example, JTextFields and other components can be arranged to validate themselves when the user attempts to move to a new field and to prevent the focus change until the field is valid (as we’ll see in Chapter 18).

Assuming that there is currently no focus, the following sequence of events happens when a component receives focus:

    WINDOW_ACTIVATED
    WINDOW_GAINED_FOCUS
    FOCUS_GAINED

The first two are WindowEvents delivered to the component’s containing Window, and the third is a FocusEvent that is sent to the component itself. If a component in another window subsequently receives focus, the following complementary sequence will occur:

    FOCUS_LOST
    WINDOW_FOCUS_LOST
    WINDOW_DEACTIVATED

These events carry a certain amount of context with them. The receiving component can determine the component and window from which the focus is being transferred. The yielding component and window are called “opposites” and are available with the FocusEventgetOppositeComponent() and WindowEvent getOppositeWindow() methods. If the opposite is part of a native non-Java application, then these values may be null.

Focus gained and lost events may also be marked as “temporary,” as determined by the FocusEvent isTemporary() method. The concept of a temporary focus change is used for components such as pop-up menus, scrollbars, and window manipulation where control is expected to return to the primary component later. The distinction is made for components to “commit” or validate data upon losing focus. No commit should happen on a temporary loss of focus.

Event Summary

Tables 16-1 and 16-2 summarize commonly used Swing events, which Swing components fire them, and the methods of the listener interfaces that receive them. The events and listeners are divided between the packages java.awt.event and javax.swing.event.

Table 16-1. Swing component and container events

Event

Fired by

Listener interface

Handler methods

java.awt.event.ComponentEvent

All components

ComponentListener

componentResized()

componentMoved()

componentShown()

componentHidden()

java.awt.event.FocusEvent

All components

FocusListener

focusGained()

focusLost()

java.awt.event.KeyEvent

All components

KeyListener

keyTyped()

keyPressed()

keyReleased()

java.awt.event.MouseEvent

All components

MouseListener

mouseClicked()

mousePressed()

mouseReleased()

mouseEntered()

mouseExited()

   

MouseMotionListener

mouseDragged()

mouseMoved()

java.awt.event.ContainerEvent

All containers

ContainerListener

componentAdded()

componentRemoved()

Table 16-2. Component-specific swing events

Event

Fired by

Listener interface

Handler method

java.awt.event.ActionEvent

JButton

JCheckBoxMenuItem

JComboBox

JFileChooser

JList

JRadioButtonMenuItem

JTextField

JToggleButton

ActionListener

actionPerformed()

java.awt.event.AdjustmentEvent

JScrollBar

Adjustment-Listener

adjustmentValue-Changed()

javax.swing.event.CaretEvent

JTextComponent

CaretListener

caretUpdate()

javax.swing.event.HyperlinkEvent

JEditorPane

JTextPane

Hyperlink-Listener

hyperlinkUpdate()

java.awt.event.InternalFrameEvent

JInternalFrame

InternalFrame-Listener

internalFrame-Activated()

internalFrame-Closed()

internalFrame-Closing()

internalFrame-Deactivated()

internalFrame-Deiconified()

internalFrame-Iconified()

internalFrame-Opened()

java.awt.event.ItemEvent

JCheckBoxMenuItem

JComboBox

JRadioButtonMenuItem

JToggleButton

ItemListener

itemStateChanged()

javax.swing.event.ListDataEvent

ListModel

ListDataListener

contentsChanged()

intervalAdded()

intervalRemoved()

javax.swing.event.ListSelectionEvent

JList

ListSelectionModel

ListSelection-Listener

valueChanged()

JMenu

javax.swing.event.PopupMenuEvent

JPopupMenu

PopupMenu-Listener

popupMenuCanceled()

popupMenuWill-BecomeInvisible()

popupMenuWill-BecomeVisible()

JMenuItem

JMenuItem

javax.swing.event.TableColumnModelEvent

TableColumnModel [a]

TableColumn-ModelListener

columnAdded()

columnMargin-Changed()

columnMoved()

columnRemoved()

columnSelection-Changed()

javax.swing.event.TableModelEvent

TableModel

TableModel-Listener

tableChanged()

javax.swing.event.TreeExpansionEvent

Jtree

TreeExpansion-Listener

treeCollapsed()

treeExpanded()

javax.swing.event.TreeModelEvent

TreeModel

TreeModel-Listener

treeNodesChanged()

treeNodesInserted()

treeNodesRemoved()

treeStructure-Changed()

javax.swing.event.TreeSelectionEvent

JTree

TreeSelectionModel

TreeSelection-Listener

valueChanged()

javax.swing.event.UndoableEditEvent

javax.swing.text.Document

UndoableEdit-Listener

undoableEdit-Happened()

java.awt.event.WindowEvent

JDialog

JFrame

JWindow

WindowListener

windowOpened()

windowClosing()

windowClosed()

windowIconified()

windowDeiconified()

windowActivated()

windowDeactivated()

[a] The TableColumnModel class breaks with convention in the names of the methods that add listeners. They are addColumnModelListener() and removeColumnModelListener().

In Swing, a component’s model and view are distinct. Strictly speaking, components don’t fire events; models do. When you press a JButton, for example, it’s actually the button’s data model that fires an ActionEvent, not the button itself. But JButton has a convenience method for registering ActionListeners; this method passes its argument through to register the listener with the button model. In many cases (as with JButtons), you don’t have to deal with the data model separately from the view, so we can speak loosely of the component itself firing the events. InputEvents are, of course, generated by the native input system and fired for the appropriate component, although the listener responds as though they’re generated by the component.

Adapter Classes

It’s not ideal to have your application components implement a bunch of listener interfaces and receive events directly. Sometimes it’s not even possible. Being an event receiver forces you to modify or subclass your objects to implement the appropriate event listener interfaces and add the code necessary to handle the events. And because we are talking about Swing events here, a more subtle issue is that you would be, of necessity, building GUI logic into parts of your application that shouldn’t have to know anything about the GUI. Let’s look at an example.

In Figure 16-4, we drew the plans for our Vegomatic food processor. We made our Vegomatic object implement the ActionListener interface so that it can receive events directly from the three JButton components: Chop, Puree, and Frappe. The problem is that our Vegomatic object now has to know more than how to mangle food. It also has to be aware that it is driven by three controls—specifically, buttons that send action commands—and be aware of which methods it should invoke for those commands. Our boxes labeling the GUI and application code overlap in an unwholesome way. If the marketing people should later want to add or remove buttons or perhaps just change the names, we have to be careful. We may have to modify the logic in our Vegomatic object. All is not well.

An alternative is to place an adapter class between our event source and receiver. An adapter is a simple object whose sole purpose is to map an incoming event to an outgoing method.

Figure 16-5 shows a better design that uses three adapter classes, one for each button. The implementation of the first adapter might look like:

    class VegomaticAdapter1 implements ActionListener {
        Vegomatic vegomatic;
        VegomaticAdapter1 ( Vegomatic vegomatic ) {
            this.vegomatic = vegomatic;
        }
        public void actionPerformed( ActionEvent e ) {
            vegomatic.chopFood();
        }
    }
Implementing the ActionListener interface directly
Figure 16-4. Implementing the ActionListener interface directly
Implementing the ActionListener interface using adapter classes
Figure 16-5. Implementing the ActionListener interface using adapter classes

So somewhere in the code where we build our GUI, we could register our listener like this:

    Vegomatic theVegomatic = ...;
    Button chopButton = ...;

    // make the hookup
    chopButton.addActionListener( new VegomaticAdapter1(theVegomatic) );

Instead of registering itself (this) as the Button’s listener, the adapter registers the Vegomatic object (theVegomatic). In this way, the adapter acts as an intermediary, hooking up an event source (the button) with an event receiver (the virtual chopper).

We have completely separated the messiness of our GUI from the application code. However, we have added three new classes to our application, none of which does very much. Is that good? It depends on your vantage point.

Under different circumstances, our buttons may have been able to share a common adapter class that was simply instantiated with different parameters. Various tradeoffs can be made between size, efficiency, and elegance of code. Adapter classes will often be generated automatically by development tools. The way we’ve named our adapter classes VegomaticAdapter1, VegomaticAdapter2, and VegomaticAdapter3 hints at this. More often, when handcoding, you’ll use an anonymous inner class, as we’ll see in the next section. At the other extreme, we can forsake Java’s strong typing and use the Reflection API to create a completely dynamic hookup between an event source and its listener.

Dummy Adapters

Many listener interfaces contain more than one event handler method. Unfortunately, this means that to register yourself as interested in any one of those events, you must implement the whole listener interface. To accomplish this, you might find yourself typing dummy “stubbed-out” methods to complete the interface. There is nothing wrong with this, but it is a bit tedious. To save you some trouble, AWT and Swing provide some helper classes that implement these dummy methods for you. For each of the most common listener interfaces containing more than one method, there is an adapter class containing the stubbed methods. You can use the adapter class as a base class for your own adapters. When you need a class to patch together your event source and listener, you can subclass the adapter and override only the methods you want.

For example, the MouseAdapter class implements the MouseListener interface and provides the following minimalist implementation:

    public void mouseClicked(MouseEvent e) {};
    public void mousePressed(MouseEvent e) {};
    public void mouseReleased(MouseEvent e) {};
    public void mouseEntered(MouseEvent e) {};
    public void mouseExited(MouseEvent e) {};

This isn’t a tremendous time saver; it’s simply a bit of sugar. The primary advantage comes into play when we use the MouseAdapter as the base for our own adapter in an anonymous inner class. For example, suppose we want to catch a mousePressed() event in some component and blow up a building. We can use the following to make the hookup:

    someComponent.addMouseListener( new MouseAdapter() {
        public void MousePressed(MouseEvent e) {
            building.blowUp();
        }
    } );

We’ve taken artistic liberties with the formatting, but it’s pretty readable. Moreover, we’ve avoided creating stub methods for the four unused event handler methods. Writing adapters is common enough that it’s nice to avoid typing those extra few lines and perhaps stave off the onset of carpal tunnel syndrome for a few more hours. Remember that any time you use an inner class, the compiler is generating a class for you, so the messiness you’ve saved in your source still exists in the output classes.

The AWT Robot!

This topic may not be of immediate use to everyone, but sometimes an API is just interesting enough that it deserves mentioning. In Java 1.3, a class with the intriguing name java.awt.Robot was added. The AWT robot provides an API for generating input events such as keystrokes and mouse gestures programmatically. It could be used to build automated GUI testing tools and the like. The following example uses the Robot class to move the mouse to the upper-left area of the screen and perform a series of events corresponding to a double-click. On most Windows systems, this opens up the My Computer folder that lives in that region of the screen.

    public class RobotExample
    {
        public static void main( String [] args ) throws Exception
        {
            Robot r = new Robot();
            r.mouseMove(35,35);
            r.mousePress( InputEvent.BUTTON1_MASK );
            r.mouseRelease( InputEvent.BUTTON1_MASK );
            Thread.sleep(50);
            r.mousePress( InputEvent.BUTTON1_MASK );
            r.mouseRelease( InputEvent.BUTTON1_MASK );
        }
    }

In addition to its magic fingers, the AWT robot also has eyes! You can use the Robot class to capture an image of the screen or a rectangular portion of it by using the createScreenCapture() method. (Note that you can get the exact dimensions of the screen from the AWT’s getScreenSize() method.)

Java 5.0 added a correspondingly useful API, java.awt.MouseInfo, which allows the gathering of mouse movement information from anywhere on the screen (not restricted to the area within the Java application’s windows). The combination of Robot and MouseInfo should make it easier to record and play back events occurring anywhere on the screen from within Java.

Multithreading in Swing

An important compromise was made early in the design of Swing relating to speed, GUI consistency, and thread safety. To provide maximum performance and simplicity in the common case, Swing does not explicitly synchronize access to most Swing component methods. This means that most Swing components are, technically, not threadsafe for multithreaded applications. Now don’t panic: it’s not as bad as it sounds because there is a plan. All event processing in AWT/Swing is handled by a single system thread using a single system event queue. The queue serves two purposes. First, it eliminates thread safety issues by making all GUI modifications happen in a single thread. Second, the queue imposes a strict ordering of all activity in Swing. Because painting is handled in Swing using events, all screen updating is also ordered with respect to all event handling.

What this means for you is that multithreaded programs need to be careful about how they update Swing components after they are realized (added to a visible container). If you make arbitrary modifications to Swing components from your own threads, you run the risk of malformed rendering on the screen and inconsistent behavior.

There are several conditions under which it is always safe to modify a Swing component. First, Swing components can be modified before they are realized. The term realized originates from the days when the component would have created its peer object. It is the point when it is added to a visible container or when it is made visible in the case of a window. Most of our examples in this book set up GUI components in their main() method, add them to a JFrame, and then, as their final action, cause the JFrame to be displayed using setVisible(). This setup style is safe because components are not realized until the container is made visible. Actually, that last sentence is not entirely true. Technically, components can also be realized by the JFrame() pack() method. However, because no GUI is shown until the container is made visible, it is unlikely that any GUI activity can be mishandled.

Second, it’s safe to modify Swing components from code that is already running from the system event handler’s thread. Because all events are processed by the event queue, the methods of all Swing event listeners are normally invoked by the system event-handling thread. This means that event handler methods and, transitively, any methods called from those methods during the lifetime of that call, can freely modify Swing GUI components because they are already running in the system event-dispatching thread. If unsure of whether some bit of code will ever be called outside the normal event thread, you can use the static method SwingUtilities.isEventDispatchThread() to test the identity of the current thread. You can then perform your activity using the event-queue mechanism we’ll talk about next.

Finally, Swing components can be safely modified when the API documentation explicitly says that the method is threadsafe. Many important methods of Swing components are explicitly documented as threadsafe. These include the JComponent repaint() and revalidate() methods, many methods of Swing text components, and all listener add and remove methods.

If you can’t meet any of the requirements for thread safety listed previously, you can use a simple API to get the system event queue to perform arbitrary activities for you on the event-handling thread. This is accomplished using the invokeAndWait() or invokeLater() static methods of the javax.swing.SwingUtilities class:

public static void invokeLater(Runnable doRun)

Use this method to ask Swing to execute the run() method of the specified Runnable.

public static void invokeAndWait(Runnable doRun)throwsInterruptedException,InvocationTargetException

This method is just like invokeLater() except that it waits until the run() method has completed before returning.

You can put any activities you want inside a Runnable object and cause the event dispatcher to perform them using these methods. Often you’ll use an inner class; for example:

    SwingUtilities.invokeLater( new Runnable() {
        public void run() {
            MyComponent.setVisible(false);
        }
    } );

Java 7 introduced the SwingWorker class to assist in situations where you have a background process that needs to update a Swing UI after the process is complete or incrementally as it’s running. In the former case, it’s a simple matter of subclassing SwingWorker, and putting your long-running code in doInBackground() and your UI update code in done().

    package learning;

    import java.awt.BorderLayout;
    import java.awt.event.ActionEvent;
    import java.awt.event.ActionListener;
    
    import javax.swing.*;

    public class MysteryOfTheUniverse extends JFrame {
    
        JTextArea textArea;
        JButton solveButton;
        
        public MysteryOfTheUniverse() {
            super("Mystery of the Universe Solver");
            
            setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
            setSize(300, 300);
            
            textArea = new JTextArea();
            
            solveButton = new JButton("Solve Mystery");
            solveButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent ae) {
                    solveButton.setEnabled(false); 
                    solveMysteryOfTheUniverse();
                }
            });

            add(solveButton, BorderLayout.NORTH);
            add(new JScrollPane(textArea));
            add(new JButton("Click me! I'm not blocking."), 
                BorderLayout.SOUTH);
        }

        public void solveMysteryOfTheUniverse() {
            (new MysteryWorker()).execute();
        }

        class MysteryWorker extends SwingWorker<String, Object> {
           
            @Override
            public String doInBackground() {

                // Thinking for 4 seconds, but not blocking the UI
                try {
                    Thread.currentThread().sleep(4000);
                } catch (InterruptedException ignore) {}   

                solveButton.setEnabled(true); 

                return "Egg salad";
            }

            @Override
            protected void done() {
                try {
                    textArea.setText(get());
                } catch (Exception ignore) {}
            }
        }

        public static void main(String[] args) {
            new MysteryOfTheUniverse().setVisible(true);
        }
    }

When you click the Solve button, the application spends four seconds solving the mystery of the universe. If we weren’t using SwingWorker, the event dispatch thread would block, making the Click Me button at the bottom of the screen unclickable. Thanks to SwingWorker, the UI remains usable during the time the background task is executing. Don’t trust us. Try it!

SwingWorker can be used in more complex situations such as incremental updates of a progress bar. See SwingWorker’s JavaDoc introduction for an example of this usage.

You may find that you won’t have to use the event dispatcher or SwingWorker in simple GUI applications because most activity happens in response to user interface events where it is safe to modify components. However, consider these caveats when you create threads to perform long-running tasks such as loading data or communicating over the network.



[38] In Chapter 11, we described the Observer class and Observable interface of the java.util package. Swing doesn’t use these classes directly, but it does use exactly the same design pattern for handling event sources and listeners.

[39] This rule is not complete. The JavaBeans conventions (see Chapter 22) allows event handler methods to take additional arguments when absolutely necessary and also to throw checked exceptions.