Thinking in Java, 3rd ed. Revision 4.0

Programming within an applet is so restrictive that it's often referred to as being "inside the sandbox," since you always have someone-that is, the Java run-time security system-watching over you.

However, you can also step outside the sandbox and write regular applications rather than applets, in which case you can access the other features of your OS. We've been writing regular applications all along in this book, but they've been console applications without any graphical components. Swing can be used to build GUI interfaces for regular applications.

You can generally answer the question of what an applet is able to do by looking at what it is supposed to do: extend the functionality of a Web page in a browser. Since, as a Net surfer, you never really know if a Web page is from a friendly place or not, you want any code that it runs to be safe. So the biggest restrictions you'll notice are probably:

• An applet can't touch the local disk. This means writing or reading, since you wouldn't want an applet to read and transmit private information over the Internet without your permission. Writing is prevented, of course, since that would be an open invitation to a virus. Java offers digital signing for applets. Many applet restrictions are relaxed when you choose to allow signed applets (those signed by a trusted source) to have access to your machine. You'll see an example later in this chapter, as well as an example of Java Web Start, a way to safely send applications to a client over the Internet.
• Applets can take longer to display, since you must download the whole thing every time, including a separate server hit for each different class. Your browser can cache the applet, but there are no guarantees. Because of this, you should always package your applets in a JAR (Java ARchive) file that combines all the applet components (including other .class files as well as images and sounds) together into a single compressed file that can be downloaded in a single server transaction. "Digital signing" is available for each individual entry in the JAR file.

If you can live within the restrictions, applets have definite advantages, especially when building client/server or other networked applications:

• There is no installation issue. An applet has true platform independence (including the ability to easily play audio files, etc.), so you don't need to make any changes in your code for different platforms, nor does anyone have to perform any installation "tweaking." In fact, installation is automatic every time the user loads a Web page that contains applets, so updates happen silently and automatically. In traditional client/server systems, building and installing a new version of the client software is often a nightmare.
• You don't have to worry about bad code causing damage to someone's system, because of the security built into the core Java language and applet structure. This, along with the previous point, makes Java useful for so-called intranet client/server applications that live only within a company or restricted arena of operation where the user environment (Web browser and add-ins) can be specified and/or controlled.

Because applets are automatically integrated with HTML, you have a built-in platform-independent documentation system to support the applet. It's an interesting twist, since we're used to having the documentation part of the program rather than vice versa.

Libraries are often grouped according to their functionality. Some libraries, for example, are used as is, off the shelf. The standard Java library String and ArrayList classes are examples of these. Other libraries are designed specifically as building blocks to create other classes. A certain category of library is the application framework, whose goal is to help you build applications by providing a class or set of classes that produces the basic behavior that you need in every application of a particular type. Then, to customize the behavior to your own needs, you inherit from the application class and override the methods of interest. The application framework's default control mechanism will call your overridden methods at the appropriate time. An application framework is a good example of "separating the things that change from the things that stay the same," since it attempts to localize all the unique parts of a program in the overridden methods. (76)

Applets are built using an application framework. You inherit from class JApplet and override the appropriate methods. There are a few methods that control the creation and execution of an applet on a Web page:

With this information you are ready to create a simple applet:

//: c14:Applet1.java
// Very simple applet.
import javax.swing.*;
import java.awt.*;
 
public class Applet1 extends JApplet {
	public void init() {
		getContentPane().add(new JLabel("Applet!"));
	}
} ///:~

Note that applets are not required to have a main( ). That's all wired into the application framework; you put any startup code in init( ).

In this program, the only activity is putting a text label on the applet, via the JLabel class (the old AWT appropriated the name Label as well as other names of components, so you will often see a leading "J" used with Swing components). The constructor for this class takes a String and uses it to create the label. In the preceding program this label is placed on the form.

The init( ) method is responsible for putting all the components on the form using the add( ) method. You might think that you ought to be able to simply call add( ) by itself, and in fact that's the way it used to be in the old AWT. However, Swing requires that you add all components to the "content pane" of a form, so you must call getContentPane( ) as part of the add( ) process.

To run this program you must place it inside a Web page and view that page inside your Java-enabled Web browser. To place an applet inside a Web page, you put a special tag inside the HTML source for that Web page (77) to tell the page how to load and run the applet.

This process used to be very simple, when Java itself was simple and everyone was on the same bandwagon and incorporated the same Java support inside their Web browsers. Then you might have been able to get away with a very simple bit of HTML inside your Web page, like this:

<applet code=Applet1 width=100 height=50>
</applet>

Then along came the browser and language wars, and we (programmers and end users alike) lost. After awhile, Sun realized that we could no longer expect browsers to support the correct flavor of Java, and the only solution was to provide some kind of add-on that would conform to a browser's extension mechanism. By using the extension mechanism (which a browser vendor cannot disable-in an attempt to gain competitive advantage-without breaking all the third-party extensions), Sun guarantees that Java cannot be shut out of the Web browser by an antagonistic vendor.

With Internet Explorer, the extension mechanism is the ActiveX control, and with Netscape, it is the plug-in. In your HTML code, you must provide tags to support both, but you can automatically generate the necessary tags with the HTMLconverter tool that comes with the JDK download. Here's what the simplest resulting HTML page looks like for Applet1 after running HTMLconverter on the preceding applet tag:

<!--"CONVERTED_APPLET"-->
<!-- HTML CONVERTER -->
<OBJECT 
	classid = "clsid:CAFEEFAC-0014-0001-0000-ABCDEFFEDCBA"
	codebase = "http://java.sun.com/products/plugin/autodl/jinstall-1_4_1-windows-i586.cab#Version=1,4,1,0"
	WIDTH = 100 HEIGHT = 50 >
	<PARAM NAME = CODE VALUE = Applet1 >
	<PARAM NAME = "type" VALUE = "application/x-java-applet;jpi-version=1.4.1">
	<PARAM NAME = "scriptable" VALUE = "false">
	<COMMENT>
		<EMBED 
			type = "application/x-java-applet;jpi-version=1.4.1"
			CODE = Applet1
			WIDTH = 100
			HEIGHT = 50  
			scriptable = false 
			pluginspage = "http://java.sun.com/products/plugin/index.html#download">
			<NOEMBED>
			</NOEMBED>
		</EMBED>
	</COMMENT>
</OBJECT>
<!--
<APPLET CODE = Applet1 WIDTH = 100 HEIGHT = 50>
</APPLET>
-->
<!--"END_CONVERTED_APPLET"-->

Some of these lines were too long and had to be wrapped to fit on the page. The code in this book's source code (downloadable from www.BruceEckel.com) will work without having to worry about correcting line wraps.

The code value gives the name of the .class file where the applet resides. The width and height specify the initial size of the applet (in pixels, as before). There are other items you can place within the applet tag: a place to find other .class files on the Internet (codebase), alignment information (align), a special identifier that makes it possible for applets to communicate with each other (name), and applet parameters to provide information that the applet can retrieve. Parameters are in the form:

<param name="identifier" value = "information">

and there can be as many as you want.

The source code package for this book (freely downloadable at www.BruceEckel.com)provides an HTML page for each of the applets in this book, and thus many examples of the applet tag, all driven from the index.html file corresponding to this chapter's source code. You can find a full and current description of the details of placing applets in Web pages at java.sun.com.

Sun's JDK contains a tool called the Appletviewer that picks the <applet> tags out of the HTML file and runs the applets without displaying the surrounding HTML text. Because the Appletviewer ignores everything but APPLET tags, you can put those tags in the Java source file as comments:

// <applet code=MyApplet width=200 height=100></applet>

This way, you can run "appletviewer MyApplet.java" and you don't need to create tiny HTML files to run tests. For example, you can add the commented HTML tags to Applet1.java:

//: c14:Applet1b.java
// Embedding the applet tag for Appletviewer.
// <applet code=Applet1b width=100 height=50></applet>
import javax.swing.*;
import java.awt.*;
 
public class Applet1b extends JApplet {
	public void init() {
		getContentPane().add(new JLabel("Applet!"));
	}
} ///:~

Now you can invoke the applet with the command

appletviewer Applet1b.java

In this book, this form will be used for easy testing of applets. Shortly, you'll see another coding approach that will allow you to execute applets from the command line without the Appletviewer.

You can perform a simple test without any network connection by starting up your Web browser and opening the HTML file containing the applet tag. As the HTML file is loaded, the browser will discover the applet tag and go hunt for the .class file specified by the code value. Of course, it looks at the CLASSPATH to find out where to hunt, and if your .class file isn't in the CLASSPATH, then it will give an error message on the status line of the browser to the effect that it couldn't find that .class file.

When you want to try this out on your Web site, things are a little more complicated. First of all, you must have a Web site, which for most people means a third-party Internet Service Provider (ISP) at a remote location. Since the applet is just a file or set of files, the ISP does not have to provide any special support for Java. You must also have a way to move the HTML files and the .class files from your site to the correct directory on the ISP machine. This is typically done with a File Transfer Protocol (FTP) program, of which there are many different types available for free or as shareware. So it would seem that all you need to do is move the files to the ISP machine with FTP, then connect to the site and HTML file using your browser; if the applet comes up and works, then everything checks out, right?

Here's where you can get fooled. If the browser on the client machine cannot locate the .class file on the server, it will hunt through the CLASSPATH on your local machine. Thus, the applet might not be loading properly from the server, but to you it looks fine during your testing process because the browser finds it on your machine. When someone else connects, however, his or her browser can't find it. So when you're testing, make sure you erase the relevant .class files (or .jar file) on your local machine to verify that they exist in the proper location on the server.

One of the most insidious places where this happened to me is when I innocently placed an applet inside a package. After uploading the HTML file and applet, it turned out that the server path to the applet was confused because of the package name. However, my browser found it in the local CLASSPATH. So I was the only one who could properly load the applet. It's important to specify the full class name including the package in the CODE parameter of your applet tag. In many published applet examples, the applet is not put inside a package, but it's generally best to use packages in production code.

Although the code that turns programs into both applets and applications produces valuable results, if used everywhere it becomes distracting and wastes paper. Instead, the following display framework will be used for the Swing examples in the rest of this book:

//: com:bruceeckel:swing:Console.java
// Tool for running Swing demos from the
// console, both applets and JFrames.
package com.bruceeckel.swing;
import javax.swing.*;
import java.awt.event.*;
 
public class Console {
	// Create a title string from the class name:
	public static String title(Object o) {
		String t = o.getClass().toString();
		// Remove the word "class":
		if(t.indexOf("class") != -1)
			t = t.substring(6);
		return t;
	}
	public static void
	run(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
	}
	public static void
	run(JApplet applet, int width, int height) {
		JFrame frame = new JFrame(title(applet));
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.getContentPane().add(applet);
		frame.setSize(width, height);
		applet.init();
		applet.start();
		frame.setVisible(true);
	}
	public static void
	run(JPanel panel, int width, int height) {
		JFrame frame = new JFrame(title(panel));
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.getContentPane().add(panel);
		frame.setSize(width, height);
		frame.setVisible(true);
	}
} ///:~

This is a tool you may want to use yourself, so it's placed in the library com.bruceeckel.swing. The Console class consists entirely of static methods. The first is used to extract the class name (using RTTI) from any object and to remove the word "class," which is typically prepended by getClass( ). This uses the String methods indexOf( ) to determine whether the word "class" is there, and substring( ) to produce the new string without "class" or the trailing space. This name is used to label the window that is displayed by the run( ) methods.

setDefaultCloseOperation( ) causes a JFrame to exit a program when that JFrame is closed. The default behavior is to do nothing, so if you don't call setDefaultCloseOperation( ) or write the equivalent code for your JFrame, the application won't close.

The run( ) method is overloaded to work with JApplets, JPanels, and JFrames. Note that only if it's a JApplet are init( ) and start( ) called.

Now any applet can be run from the console by creating a main( ) containing a line like this:

Console.run(new MyClass(), 500, 300);

in which the last two arguments are the display width and height. Here's Applet1c.java modified to use Console:

//: c14:Applet1d.java
// Console runs applets from the command line.
// <applet code=Applet1d width=100 height=50></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class Applet1d extends JApplet {
	public void init() {
		getContentPane().add(new JLabel("Applet!"));
	}
	public static void main(String[] args) {
		Console.run(new Applet1d(), 100, 50);
	}
} ///:~

This allows the elimination of repeated code while providing the greatest flexibility in running the examples.

Applets use a default layout scheme: the BorderLayout (a number of the previous examples have changed the layout manager to FlowLayout). Without any other instruction, this takes whatever you add( ) to it and places it in the center, stretching the object all the way out to the edges.

However, there's more to the BorderLayout. This layout manager has the concept of four border regions and a center area. When you add something to a panel that's using a BorderLayout, you can use the overloaded add( ) method that takes a constant value as its first argument. This value can be any of the following:

If you don't specify an area to place the object, it defaults to CENTER.

Here's a simple example. The default layout is used, since JApplet defaults to BorderLayout:

//: c14:BorderLayout1.java
// Demonstrates BorderLayout.
//<applet code=BorderLayout1 width=300 height=250></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class BorderLayout1 extends JApplet {
	public void init() {
		Container cp = getContentPane();
		cp.add(BorderLayout.NORTH, new JButton("North"));
		cp.add(BorderLayout.SOUTH, new JButton("South"));
		cp.add(BorderLayout.EAST, new JButton("East"));
		cp.add(BorderLayout.WEST, new JButton("West"));
		cp.add(BorderLayout.CENTER, new JButton("Center"));
	}
	public static void main(String[] args) {
		Console.run(new BorderLayout1(), 300, 250);
	}
} ///:~

For every placement but CENTER, the element that you add is compressed to fit in the smallest amount of space along one dimension while it is stretched to the maximum along the other dimension. CENTER, however, spreads out in both dimensions to occupy the middle.

This simply "flows" the components onto the form, from left to right until the top space is full, then moves down a row and continues flowing.

Here's an example that sets the layout manager to FlowLayout and then places buttons on the form. You'll notice that with FlowLayout, the components take on their "natural" size. A JButton, for example, will be the size of its string.

//: c14:FlowLayout1.java
// Demonstrates FlowLayout.
// <applet code=FlowLayout1 width=300 height=250></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class FlowLayout1 extends JApplet {
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		for(int i = 0; i < 20; i++)
			cp.add(new JButton("Button " + i));
	}
	public static void main(String[] args) {
		Console.run(new FlowLayout1(), 300, 250);
	}
} ///:~

All components will be compacted to their smallest size in a FlowLayout, so you might get a little bit of surprising behavior. For example, because a JLabel will be the size of its string, attempting to right-justify its text yields an unchanged display when using FlowLayout.

A GridLayout allows you to build a table of components, and as you add them, they are placed left-to-right and top-to-bottom in the grid. In the constructor you specify the number of rows and columns that you need, and these are laid out in equal proportions.

//: c14:GridLayout1.java
// Demonstrates GridLayout.
// <applet code=GridLayout1 width=300 height=250></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class GridLayout1 extends JApplet {
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new GridLayout(7,3));
		for(int i = 0; i < 20; i++)
			cp.add(new JButton("Button " + i));
	}
	public static void main(String[] args) {
		Console.run(new GridLayout1(), 300, 250);
	}
} ///:~

In this case there are 21 slots but only 20 buttons. The last slot is left empty because no "balancing" goes on with a GridLayout.

The GridBagLayout provides you with tremendous control in deciding exactly how the regions of your window will lay themselves out and reformat themselves when the window is resized. However, it's also the most complicated layout manager, and is quite difficult to understand. It is intended primarily for automatic code generation by a GUI builder (GUI builders might use GridBagLayout instead of absolute placement). If your design is so complicated that you feel you need to use GridBagLayout, then you should be using a GUI builder tool to generate that design. If you feel you must know the intricate details, I'll refer you to Core Java 2, Volume 1, by Horstmann & Cornell (Prentice Hall, 2001), or a dedicated Swing book as a starting point.

It is also possible to set the absolute position of the graphical components in this way:

• Set a null layout manager for your Container: setLayout(null).
• Call setBounds( ) or reshape( ) (depending on the language version) for each component, passing a bounding rectangle in pixel coordinates. You can do this in the constructor or in paint( ), depending on what you want to achieve.

Some GUI builders use this approach extensively, but this is usually not the best way to generate code.

Because people had so much trouble understanding and working with GridBagLayout, Swing also includes BoxLayout, which gives you many of the benefits of GridBagLayout without the complexity, so you can often use it when you need to do hand-coded layouts (again, if your design becomes too complex, use a GUI builder that generates layouts for you). BoxLayout allows you to control the placement of components either vertically or horizontally, and to control the space between the components using something called "struts and glue." First, let's see how to use the BoxLayout directly, in the same way that the other layout managers have been demonstrated:

//: c14:BoxLayout1.java
// Vertical and horizontal BoxLayouts.
// <applet code=BoxLayout1 width=450 height=200></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class BoxLayout1 extends JApplet {
	public void init() {
		JPanel jpv = new JPanel();
		jpv.setLayout(new BoxLayout(jpv, BoxLayout.Y_AXIS));
		for(int i = 0; i < 5; i++)
			jpv.add(new JButton("jpv " + i));
		JPanel jph = new JPanel();
		jph.setLayout(new BoxLayout(jph, BoxLayout.X_AXIS));
		for(int i = 0; i < 5; i++)
			jph.add(new JButton("jph " + i));
		Container cp = getContentPane();
		cp.add(BorderLayout.EAST, jpv);
		cp.add(BorderLayout.SOUTH, jph);
	}
	public static void main(String[] args) {
		Console.run(new BoxLayout1(), 450, 200);
	}
} ///:~

The constructor for BoxLayout is a bit different than the other layout managers-you provide the Container that is to be controlled by the BoxLayout as the first argument, and the direction of the layout as the second argument.

To simplify matters, there's a special container called Box that uses BoxLayout as its native manager. The following example lays out components horizontally and vertically using Box, which has two static methods to create boxes with vertical and horizontal alignment:

//: c14:Box1.java
// Vertical and horizontal BoxLayouts.
// <applet code=Box1 width=450 height=200></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class Box1 extends JApplet {
	public void init() {
		Box bv = Box.createVerticalBox();
		for(int i = 0; i < 5; i++)
			bv.add(new JButton("bv " + i));
		Box bh = Box.createHorizontalBox();
		for(int i = 0; i < 5; i++)
			bh.add(new JButton("bh " + i));
		Container cp = getContentPane();
		cp.add(BorderLayout.EAST, bv);
		cp.add(BorderLayout.SOUTH, bh);
	}
	public static void main(String[] args) {
		Console.run(new Box1(), 450, 200);
	}
} ///:~

Once you have a Box, you pass it as a second argument when adding components to the content pane.

Struts add space, measured in pixels, between components. To use a strut, you simply add it between the addition of the components that you want spaced apart:

//: c14:Box2.java
// Adding struts.
// <applet code=Box2 width=450 height=300></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class Box2 extends JApplet {
	public void init() {
		Box bv = Box.createVerticalBox();
		for(int i = 0; i < 5; i++) {
			bv.add(new JButton("bv " + i));
			bv.add(Box.createVerticalStrut(i * 10));
		}
		Box bh = Box.createHorizontalBox();
		for(int i = 0; i < 5; i++) {
			bh.add(new JButton("bh " + i));
			bh.add(Box.createHorizontalStrut(i * 10));
		}
		Container cp = getContentPane();
		cp.add(BorderLayout.EAST, bv);
		cp.add(BorderLayout.SOUTH, bh);
	}
	public static void main(String[] args) {
		Console.run(new Box2(), 450, 300);
	}
} ///:~

Struts separate components by a fixed amount, but glue is the opposite; it separates components by as much as possible. Thus it's more of a "spring" than "glue" (and the design on which this was based was called "springs and struts," so the choice of the term is a bit mysterious).

//: c14:Box3.java
// Using Glue.
// <applet code=Box3 width=450 height=300></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class Box3 extends JApplet {
	public void init() {
		Box bv = Box.createVerticalBox();
		bv.add(new JLabel("Hello"));
		bv.add(Box.createVerticalGlue());
		bv.add(new JLabel("Applet"));
		bv.add(Box.createVerticalGlue());
		bv.add(new JLabel("World"));
		Box bh = Box.createHorizontalBox();
		bh.add(new JLabel("Hello"));
		bh.add(Box.createHorizontalGlue());
		bh.add(new JLabel("Applet"));
		bh.add(Box.createHorizontalGlue());
		bh.add(new JLabel("World"));
		bv.add(Box.createVerticalGlue());
		bv.add(bh);
		bv.add(Box.createVerticalGlue());
		getContentPane().add(bv);
	}
	public static void main(String[] args) {
		Console.run(new Box3(), 450, 300);
	}
} ///:~

A strut works in one direction, but a rigid area fixes the spacing between components in both directions:

//: c14:Box4.java
// Rigid areas are like pairs of struts.
// <applet code=Box4 width=450 height=300></applet>
import javax.swing.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class Box4 extends JApplet {
	public void init() {
		Box bv = Box.createVerticalBox();
		bv.add(new JButton("Top"));
		bv.add(Box.createRigidArea(new Dimension(120, 90)));
		bv.add(new JButton("Bottom"));
		Box bh = Box.createHorizontalBox();
		bh.add(new JButton("Left"));
		bh.add(Box.createRigidArea(new Dimension(160, 80)));
		bh.add(new JButton("Right"));
		bv.add(bh);
		getContentPane().add(bv);
	}
	public static void main(String[] args) {
		Console.run(new Box4(), 450, 300);
	}
} ///:~

You should be aware that rigid areas are a bit controversial. Since they use absolute values, some people feel that they cause more trouble than they are worth.

Swing is powerful; it can get a lot done with a few lines of code. The examples shown in this book are reasonably simple, and for learning purposes it makes sense to write them by hand. You can actually accomplish quite a bit by combining simple layouts. At some point, however, it stops making sense to hand-code GUI forms; it becomes too complicated and is not a good use of your programming time. The Java and Swing designers oriented the language and libraries to support GUI building tools, which have been created for the express purpose of making your programming experience easier. As long as you understand what's going on with layouts and how to deal with the events (described next), it's not particularly important that you actually know the details of how to lay out components by hand; let the appropriate tool do that for you (Java is, after all, designed to increase programmer productivity).

All Swing components include addXXXListener( ) and removeXXXListener( ) methods so that the appropriate types of listeners can be added and removed from each component. You'll notice that the "XXX" in each case also represents the argument for the method, for example, addMyListener(MyListener m). The following table includes the basic associated events, listeners, and methods, along with the basic components that support those particular events by providing the addXXXListener( ) and removeXXXListener( ) methods. You should keep in mind that the event model is designed to be extensible, so you may encounter other events and listener types that are not covered in this table.

You can see that each type of component supports only certain types of events. It turns out to be rather difficult to look up all the events supported by each component. A simpler approach is to modify the ShowMethods.java program from Chapter 10 so that it displays all the event listeners supported by any Swing component that you enter.

Chapter 10 introduced reflection and used that feature to look up methods for a particular class-either the entire list of methods or a subset of those whose names match a keyword that you provide. The magic of reflection is that it can automatically show you all the methods for a class without forcing you to walk up the inheritance hierarchy, examining the base classes at each level. Thus, it provides a valuable timesaving tool for programming; because the names of most Java methods are made nicely verbose and descriptive, you can search for the method names that contain a particular word of interest. When you find what you think you're looking for, check the JDK documentation.

However, by Chapter 10 you hadn't seen Swing, so the tool in that chapter was developed as a command-line application. Here is the more useful GUI version, specialized to look for the "addListener" methods in Swing components:

//: c14:ShowAddListeners.java
// Display the "addXXXListener" methods of any Swing class.
// <applet code=ShowAddListeners
// width=500 height=400></applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.reflect.*;
import java.util.regex.*;
import com.bruceeckel.swing.*;
 
public class ShowAddListeners extends JApplet {
	private JTextField name = new JTextField(25);
	private JTextArea results = new JTextArea(40, 65);
	private static Pattern addListener =
		Pattern.compile("(add\\w+?Listener\\(.*?\\))");
	private static Pattern qualifier =
		Pattern.compile("\\w+\\.");
	class NameL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			String nm = name.getText().trim();
			if(nm.length() == 0) {
				results.setText("No match");
				return;
			}
			Class klass;
			try {
				klass = Class.forName("javax.swing." + nm);
			} catch(ClassNotFoundException ex) {
				results.setText("No match");
				return;
			}
			Method[] methods = klass.getMethods();
			results.setText("");
			for(int i = 0; i < methods.length; i++) {
				Matcher matcher =
					addListener.matcher(methods[i].toString());
				if(matcher.find())
					results.append(qualifier.matcher(
						matcher.group(1)).replaceAll("") + "\n");
			}
		}
	}
	public void init() {
		NameL nameListener = new NameL();
		name.addActionListener(nameListener);
		JPanel top = new JPanel();
		top.add(new JLabel("Swing class name (press ENTER):"));
		top.add(name);
		Container cp = getContentPane();
		cp.add(BorderLayout.NORTH, top);
		cp.add(new JScrollPane(results));
		// Initial data and test:
		name.setText("JTextArea");
		nameListener.actionPerformed(
			new ActionEvent("", 0 ,""));
	}
	public static void main(String[] args) {
		Console.run(new ShowAddListeners(), 500,400);
	}
} ///:~

You enter the Swing class name that you want to look up in the name JTextField. The results are extracted using regular expressions, and displayed in a JTextArea.

You'll notice that there are no buttons or other components to indicate that you want the search to begin. That's because the JTextField is monitored by an ActionListener. Whenever you make a change and press ENTER, the list is immediately updated. If the text field isn't empty, it is used inside Class.forName( ) to try to look up the class. If the name is incorrect, Class.forName( ) will fail, which means that it throws an exception. This is trapped, and the JTextArea is set to "No match." But if you type in a correct name (capitalization counts), Class.forName( ) is successful, and getMethods( ) will return an array of Method objects.

Two regular expressions are used here. The first, addListener, looks for "add" followed by any word characters, followed by "Listener" and the argument list in parentheses. Notice that this whole regular expression is surrounded by non-escaped parentheses, which means it will be accessible as a regular expression "group" when it matches. Inside NameL.ActionPerformed( ), a Matcher is created by passing each Method object to the Pattern.matcher( ) method. When find( ) is called for this Matcher object, it returns true only if a match occurs, and in that case you can select the first matching parenthesized group by calling group(1). This string still contains qualifiers, so to strip them off the qualifier Pattern object is used just as it was in c09:ShowMethods.java.

At the end of init( ), an initial value is placed in name and the action event is run to provide a test with initial data.

This program is a convenient way to investigate the capabilities of a Swing component. Once you know which events a particular component supports, you don't need to look anything up to react to that event. You simply:

• Take the name of the event class and remove the word "Event." Add the word "Listener" to what remains. This is the listener interface you must implement in your inner class.
• Implement the interface above and write out the methods for the events you want to capture. For example, you might be looking for mouse movements, so you write code for the mouseMoved( ) method of the MouseMotionListener interface. (You must implement the other methods, of course, but there's often a shortcut for this, which you'll see soon.)
• Create an object of the listener class in Step 2. Register it with your component with the method produced by prefixing "add" to your listener name. For example, addMouseMotionListener( ).

Here are some of the listener interfaces:

This is not an exhaustive listing, partly because the event model allows you to create your own event types and associated listeners. Thus, you'll regularly come across libraries that have invented their own events, and the knowledge gained in this chapter will allow you to figure out how to use these events.

14-7-1-1. Using listener adapters for simplicity▲

class MyMouseListener extends MouseAdapter {
	public void mouseClicked(MouseEvent e) {
		// Respond to mouse click...
	}
}

class MyMouseListener extends MouseAdapter {
	public void MouseClicked(MouseEvent e) {
		// Respond to mouse click...
	}
}

To prove to yourself that these events are in fact being fired, and as an interesting experiment, it's worth creating an applet that tracks extra behavior in a JButton (in addition to whether it has been pressed). This example also shows you how to inherit your own button object because that's what is used as the target of all the events of interest. To do so, you can just inherit from Jbutton. (82)

The MyButton class is an inner class of TrackEvent, so MyButton can reach into the parent window and manipulate its text fields, which is what's necessary to be able to write the status information into the fields of the parent. Of course, this is a limited solution, since MyButton can be used only in conjunction with TrackEvent. This kind of code is sometimes called "highly coupled":

//: c14:TrackEvent.java
// Show events as they happen.
// <applet code=TrackEvent width=700 height=500></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.bruceeckel.swing.*;
 
public class TrackEvent extends JApplet {
	private HashMap h = new HashMap();
	private String[] event = {
		"focusGained", "focusLost", "keyPressed",
		"keyReleased", "keyTyped", "mouseClicked",
		"mouseEntered", "mouseExited", "mousePressed",
		"mouseReleased", "mouseDragged", "mouseMoved"
	};
	private MyButton
		b1 = new MyButton(Color.BLUE, "test1"),
		b2 = new MyButton(Color.RED, "test2");
	class MyButton extends JButton {
		void report(String field, String msg) {
			((JTextField)h.get(field)).setText(msg);
		}
		FocusListener fl = new FocusListener() {
			public void focusGained(FocusEvent e) {
				report("focusGained", e.paramString());
			}
			public void focusLost(FocusEvent e) {
				report("focusLost", e.paramString());
			}
		};
		KeyListener kl = new KeyListener() {
			public void keyPressed(KeyEvent e) {
				report("keyPressed", e.paramString());
			}
			public void keyReleased(KeyEvent e) {
				report("keyReleased", e.paramString());
			}
			public void keyTyped(KeyEvent e) {
				report("keyTyped", e.paramString());
			}
		};
		MouseListener ml = new MouseListener() {
			public void mouseClicked(MouseEvent e) {
				report("mouseClicked", e.paramString());
			}
			public void mouseEntered(MouseEvent e) {
				report("mouseEntered", e.paramString());
			}
			public void mouseExited(MouseEvent e) {
				report("mouseExited", e.paramString());
			}
			public void mousePressed(MouseEvent e) {
				report("mousePressed", e.paramString());
			}
			public void mouseReleased(MouseEvent e) {
				report("mouseReleased", e.paramString());
			}
		};
		MouseMotionListener mml = new MouseMotionListener() {
			public void mouseDragged(MouseEvent e) {
				report("mouseDragged", e.paramString());
			}
			public void mouseMoved(MouseEvent e) {
				report("mouseMoved", e.paramString());
			}
		};
		public MyButton(Color color, String label) {
			super(label);
			setBackground(color);
			addFocusListener(fl);
			addKeyListener(kl);
			addMouseListener(ml);
			addMouseMotionListener(mml);
		}
	}
	public void init() {
		Container c = getContentPane();
		c.setLayout(new GridLayout(event.length + 1, 2));
		for(int i = 0; i < event.length; i++) {
			JTextField t = new JTextField();
			t.setEditable(false);
			c.add(new JLabel(event[i], JLabel.RIGHT));
			c.add(t);
			h.put(event[i], t);
		}
		c.add(b1);
		c.add(b2);
	}
	public static void main(String[] args) {
		Console.run(new TrackEvent(), 700, 500);
	}
} ///:~

In the MyButton constructor, the button's color is set with a call to SetBackground( ). The listeners are all installed with simple method calls.

The TrackEvent class contains a HashMap to hold the strings representing the type of event and JTextFields where information about that event is held. Of course, these could have been created statically rather than putting them in a HashMap, but I think you'll agree that it's a lot easier to use and change. In particular, if you need to add or remove a new type of event in TrackEvent, you simply add or remove a string in the event array-everything else happens automatically.

When report( ) is called, it is given the name of the event and the parameter string from the event. It uses the HashMap h in the outer class to look up the actual JTextField associated with that event name and then places the parameter string into that field.

This example is fun to play with because you can really see what's going on with the events in your program.

Swing includes a number of different types of buttons. All buttons, check boxes, radio buttons, and even menu items are inherited from AbstractButton (which, since menu items are included, would probably have been better named "AbstractSelector" or something equally general). You'll see the use of menu items shortly, but the following example shows the various types of buttons available:

//: c14:Buttons.java
// Various Swing buttons.
// <applet code=Buttons width=350 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.plaf.basic.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;
 
public class Buttons extends JApplet {
	private JButton jb = new JButton("JButton");
	private BasicArrowButton
		up = new BasicArrowButton(BasicArrowButton.NORTH),
		down = new BasicArrowButton(BasicArrowButton.SOUTH),
		right = new BasicArrowButton(BasicArrowButton.EAST),
		left = new BasicArrowButton(BasicArrowButton.WEST);
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(jb);
		cp.add(new JToggleButton("JToggleButton"));
		cp.add(new JCheckBox("JCheckBox"));
		cp.add(new JRadioButton("JRadioButton"));
		JPanel jp = new JPanel();
		jp.setBorder(new TitledBorder("Directions"));
		jp.add(up);
		jp.add(down);
		jp.add(left);
		jp.add(right);
		cp.add(jp);
	}
	public static void main(String[] args) {
		Console.run(new Buttons(), 350, 100);
	}
} ///:~

This begins with the BasicArrowButton from javax.swing.plaf.basic, then continues with the various specific types of buttons. When you run the example, you'll see that the toggle button holds its last position, in or out. But the check boxes and radio buttons behave identically to each other, just clicking on or off (they are inherited from JToggleButton).

14-8-1-1. Button groups▲

//: c14:ButtonGroups.java
// Uses reflection to create groups
// of different types of AbstractButton.
// <applet code=ButtonGroups width=500 height=300></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import java.lang.reflect.*;
import com.bruceeckel.swing.*;
 
public class ButtonGroups extends JApplet {
	private static String[] ids = {
		"June", "Ward", "Beaver",
		"Wally", "Eddie", "Lumpy",
	};
	static JPanel makeBPanel(Class klass, String[] ids) {
		ButtonGroup bg = new ButtonGroup();
		JPanel jp = new JPanel();
		String title = klass.getName();
		title = title.substring(title.lastIndexOf('.') + 1);
		jp.setBorder(new TitledBorder(title));
		for(int i = 0; i < ids.length; i++) {
			AbstractButton ab = new JButton("failed");
			try {
				// Get the dynamic constructor method
				// that takes a String argument:
				Constructor ctor =
					klass.getConstructor(new Class[]{String.class});
				// Create a new object:
				ab = (AbstractButton)
					ctor.newInstance(new Object[] { ids[i] });
			} catch(Exception ex) {
				System.err.println("can't create " + klass);
			}
			bg.add(ab);
			jp.add(ab);
		}
		return jp;
	}
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(makeBPanel(JButton.class, ids));
		cp.add(makeBPanel(JToggleButton.class, ids));
		cp.add(makeBPanel(JCheckBox.class, ids));
		cp.add(makeBPanel(JRadioButton.class, ids));
	}
	public static void main(String[] args) {
		Console.run(new ButtonGroups(), 500, 300);
	}
} ///:~

You can use an Icon inside a JLabel or anything that inherits from AbstractButton (including JButton, JCheckBox, JRadioButton, and the different kinds of JMenuItem). Using Icons with JLabels is quite straightforward (you'll see an example later). The following example explores all the additional ways you can use Icons with buttons and their descendants.

You can use any gif files you want, but the ones used in this example are part of this book's code distribution, available at www.BruceEckel.com. To open a file and bring in the image, simply create an ImageIcon and hand it the file name. From then on, you can use the resulting Icon in your program.

//: c14:Faces.java
// Icon behavior in Jbuttons.
// <applet code=Faces width=400 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import com.bruceeckel.swing.*;
 
public class Faces extends JApplet {
	private static Icon[] faces;
	private JButton jb, jb2 = new JButton("Disable");
	private boolean mad = false;
	public void init() {
		faces = new Icon[] {
			new ImageIcon(getClass().getResource("Face0.gif")),
			new ImageIcon(getClass().getResource("Face1.gif")),
			new ImageIcon(getClass().getResource("Face2.gif")),
			new ImageIcon(getClass().getResource("Face3.gif")),
			new ImageIcon(getClass().getResource("Face4.gif")),
		};
		jb = new JButton("JButton", faces[3]);
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		jb.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				if(mad) {
					jb.setIcon(faces[3]);
					mad = false;
				} else {
					jb.setIcon(faces[0]);
					mad = true;
				}
				jb.setVerticalAlignment(JButton.TOP);
				jb.setHorizontalAlignment(JButton.LEFT);
			}
		});
		jb.setRolloverEnabled(true);
		jb.setRolloverIcon(faces[1]);
		jb.setPressedIcon(faces[2]);
		jb.setDisabledIcon(faces[4]);
		jb.setToolTipText("Yow!");
		cp.add(jb);
		jb2.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				if(jb.isEnabled()) {
					jb.setEnabled(false);
					jb2.setText("Enable");
				} else {
					jb.setEnabled(true);
					jb2.setText("Disable");
				}
			}
		});
		cp.add(jb2);
	}
	public static void main(String[] args) {
		Console.run(new Faces(), 400, 200);
	}
} ///:~

An Icon can be used as an argument for many different Swing component constructors, but you can also use setIcon( ) to add or change an Icon. This example also shows how a JButton (or any AbstractButton) can set the various different sorts of icons that appear when things happen to that button: when it's pressed, disabled, or "rolled over" (the mouse moves over it without clicking). You'll see that this gives the button a nice animated feel.

The previous example added a "tool tip" to the button. Almost all of the classes that you'll be using to create your user interfaces are derived from JComponent, which contains a method called setToolTipText(String). So, for virtually anything you place on your form, all you need to do is say (for an object jc of any JComponent-derived class):

jc.setToolTipText("My tip");

and when the mouse stays over that JComponent for a predetermined period of time, a tiny box containing your text will pop up next to the mouse.

This example shows the extra behavior that JTextFields are capable of:

//: c14:TextFields.java
// Text fields and Java events.
// <applet code=TextFields width=375 height=125></applet>
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.text.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
 
public class TextFields extends JApplet {
	private JButton
		b1 = new JButton("Get Text"),
		b2 = new JButton("Set Text");
	private JTextField
		t1 = new JTextField(30),
		t2 = new JTextField(30),
		t3 = new JTextField(30);
	private String s = new String();
	private UpperCaseDocument ucd = new UpperCaseDocument();
	public void init() {
		t1.setDocument(ucd);
		ucd.addDocumentListener(new T1());
		b1.addActionListener(new B1());
		b2.addActionListener(new B2());
		DocumentListener dl = new T1();
		t1.addActionListener(new T1A());
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(b1);
		cp.add(b2);
		cp.add(t1);
		cp.add(t2);
		cp.add(t3);
	}
	class T1 implements DocumentListener {
		public void changedUpdate(DocumentEvent e) {}
		public void insertUpdate(DocumentEvent e) {
			t2.setText(t1.getText());
			t3.setText("Text: "+ t1.getText());
		}
		public void removeUpdate(DocumentEvent e) {
			t2.setText(t1.getText());
		}
	}
	class T1A implements ActionListener {
		private int count = 0;
		public void actionPerformed(ActionEvent e) {
			t3.setText("t1 Action Event " + count++);
		}
	}
	class B1 implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if(t1.getSelectedText() == null)
				s = t1.getText();
			else
				s = t1.getSelectedText();
			t1.setEditable(true);
		}
	}
	class B2 implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			ucd.setUpperCase(false);
			t1.setText("Inserted by Button 2: " + s);
			ucd.setUpperCase(true);
			t1.setEditable(false);
		}
	}
	public static void main(String[] args) {
		Console.run(new TextFields(), 375, 125);
	}
}
 
class UpperCaseDocument extends PlainDocument {
	private boolean upperCase = true;
	public void setUpperCase(boolean flag) {
		upperCase = flag;
	}
	public void
	insertString(int offset, String str, AttributeSet attSet)
			throws BadLocationException {
		if(upperCase) str = str.toUpperCase();
		super.insertString(offset, str, attSet);
	}
} ///:~

The JTextField t3 is included as a place to report when the action listener for the JTextField t1 is fired. You'll see that the action listener for a JTextField is fired only when you press the "enter" key.

The JTextField t1 has several listeners attached to it. The T1 listener is a DocumentListener that responds to any change in the "document" (the contents of the JTextField, in this case).It automatically copies all text from t1 into t2. In addition, t1's document is set to a derived class of PlainDocument, called UpperCaseDocument, which forces all characters to uppercase. It automatically detects backspaces and performs the deletion, adjusting the caret and handling everything as you would expect.

JComponent contains a method called setBorder( ), which allows you to place various interesting borders on any visible component. The following example demonstrates a number of the different borders that are available, using a method called showBorder( ) that creates a JPanel and puts on the border in each case. Also, it uses RTTI to find the name of the border that you're using (stripping off all the path information), then puts that name in a JLabel in the middle of the panel:

//: c14:Borders.java
// Different Swing borders.
// <applet code=Borders width=500 height=300></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;
 
public class Borders extends JApplet {
	static JPanel showBorder(Border b) {
		JPanel jp = new JPanel();
		jp.setLayout(new BorderLayout());
		String nm = b.getClass().toString();
		nm = nm.substring(nm.lastIndexOf('.') + 1);
		jp.add(new JLabel(nm, JLabel.CENTER),
			BorderLayout.CENTER);
		jp.setBorder(b);
		return jp;
	}
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new GridLayout(2,4));
		cp.add(showBorder(new TitledBorder("Title")));
		cp.add(showBorder(new EtchedBorder()));
		cp.add(showBorder(new LineBorder(Color.BLUE)));
		cp.add(showBorder(
			new MatteBorder(5,5,30,30,Color.GREEN)));
		cp.add(showBorder(
			new BevelBorder(BevelBorder.RAISED)));
		cp.add(showBorder(
			new SoftBevelBorder(BevelBorder.LOWERED)));
		cp.add(showBorder(new CompoundBorder(
			new EtchedBorder(),
			new LineBorder(Color.RED))));
	}
	public static void main(String[] args) {
		Console.run(new Borders(), 500, 300);
	}
} ///:~

You can also create your own borders and put them inside buttons, labels, etc.-anything derived from JComponent.

Most of the time you'll just want to let a JScrollPane do its job, but you can also control which scroll bars are allowed-vertical, horizontal, both, or neither:

//: c14:JScrollPanes.java
// Controlling the scrollbars in a JScrollPane.
// <applet code=JScrollPanes width=300 height=725></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;
 
public class JScrollPanes extends JApplet {
	private JButton
		b1 = new JButton("Text Area 1"),
		b2 = new JButton("Text Area 2"),
		b3 = new JButton("Replace Text"),
		b4 = new JButton("Insert Text");
	private JTextArea
		t1 = new JTextArea("t1", 1, 20),
		t2 = new JTextArea("t2", 4, 20),
		t3 = new JTextArea("t3", 1, 20),
		t4 = new JTextArea("t4", 10, 10),
		t5 = new JTextArea("t5", 4, 20),
		t6 = new JTextArea("t6", 10, 10);
	private JScrollPane
		sp3 = new JScrollPane(t3,
			JScrollPane.VERTICAL_SCROLLBAR_NEVER,
			JScrollPane.HORIZONTAL_SCROLLBAR_NEVER),
		sp4 = new JScrollPane(t4,
			JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
			JScrollPane.HORIZONTAL_SCROLLBAR_NEVER),
		sp5 = new JScrollPane(t5,
			JScrollPane.VERTICAL_SCROLLBAR_NEVER,
			JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS),
		sp6 = new JScrollPane(t6,
			JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
			JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
	class B1L implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			t5.append(t1.getText() + "\n");
		}
	}
	class B2L implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			t2.setText("Inserted by Button 2");
			t2.append(": " + t1.getText());
			t5.append(t2.getText() + "\n");
		}
	}
	class B3L implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			String s = " Replacement ";
			t2.replaceRange(s, 3, 3 + s.length());
		}
	}
	class B4L implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			t2.insert(" Inserted ", 10);
		}
	}
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		// Create Borders for components:
		Border brd = BorderFactory.createMatteBorder(
			1, 1, 1, 1, Color.BLACK);
		t1.setBorder(brd);
		t2.setBorder(brd);
		sp3.setBorder(brd);
		sp4.setBorder(brd);
		sp5.setBorder(brd);
		sp6.setBorder(brd);
		// Initialize listeners and add components:
		b1.addActionListener(new B1L());
		cp.add(b1);
		cp.add(t1);
		b2.addActionListener(new B2L());
		cp.add(b2);
		cp.add(t2);
		b3.addActionListener(new B3L());
		cp.add(b3);
		b4.addActionListener(new B4L());
		cp.add(b4);
		cp.add(sp3);
		cp.add(sp4);
		cp.add(sp5);
		cp.add(sp6);
	}
	public static void main(String[] args) {
		Console.run(new JScrollPanes(), 300, 725);
	}
} ///:~

Using different arguments in the JScrollPane constructor controls the scrollbars that are available. This example also dresses things up a bit using borders.

The JTextPane control provides a great deal of support for editing, without much effort. The following example makes very simple use of this component, ignoring the bulk of the functionality of the class:

//: c14:TextPane.java
// The JTextPane control is a little editor.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
import com.bruceeckel.util.*;
 
public class TextPane extends JFrame {
	private JButton b = new JButton("Add Text");
	private JTextPane tp = new JTextPane();
	private static Generator sg =
		new Arrays2.RandStringGenerator(7);
	public TextPane() {
	    b.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				for(int i = 1; i < 10; i++)
					tp.setText(tp.getText() + sg.next() + "\n");
			}
		});
		Container cp = getContentPane();
		cp.add(new JScrollPane(tp));
		cp.add(BorderLayout.SOUTH, b);
	}
	public static void main(String[] args) {
		Console.run(new TextPane(), 475, 425);
	}
} ///:~

The button just adds randomly generated text. The intent of the JTextPane is to allow text to be edited in place, so you will see that there is no append( ) method. In this case (admittedly, a poor use of the capabilities of JTextPane), the text must be captured, modified, and placed back into the pane using setText( ).

As mentioned before, the default layout behavior of an applet is to use the BorderLayout. If you add something to the pane without specifying any details, it just fills the center of the pane out to the edges. However, if you specify one of the surrounding regions (NORTH, SOUTH, EAST, or WEST) as is done here, the component will fit itself into that region; in this case, the button will nest down at the bottom of the screen.

Notice the built-in features of JTextPane, such as automatic line wrapping. There are lots of other features that you can look up using the JDK documentation.

A check box provides a way to make a single on/off choice. It consists of a tiny box and a label. The box typically holds a little "x" (or some other indication that it is set) or is empty, depending on whether that item was selected.

You'll normally create a JCheckBox using a constructor that takes the label as an argument. You can get and set the state, and also get and set the label if you want to read or change it after the JCheckBox has been created.

Whenever a JCheckBox is set or cleared, an event occurs, which you can capture the same way you do a button: by using an ActionListener. The following example uses a JTextArea to enumerate all the check boxes that have been checked:

//: c14:CheckBoxes.java
// Using JCheckBoxes.
// <applet code=CheckBoxes width=200 height=200></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class CheckBoxes extends JApplet {
	private JTextArea t = new JTextArea(6, 15);
	private JCheckBox
		cb1 = new JCheckBox("Check Box 1"),
		cb2 = new JCheckBox("Check Box 2"),
		cb3 = new JCheckBox("Check Box 3");
	public void init() {
		cb1.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				trace("1", cb1);
			}
		});
		cb2.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				trace("2", cb2);
			}
		});
		cb3.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				trace("3", cb3);
			}
		});
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(new JScrollPane(t));
		cp.add(cb1);
		cp.add(cb2);
		cp.add(cb3);
	}
	private void trace(String b, JCheckBox cb) {
		if(cb.isSelected())
			t.append("Box " + b + " Set\n");
		else
			t.append("Box " + b + " Cleared\n");
		}
		public static void main(String[] args) {
			Console.run(new CheckBoxes(), 200, 200);
		}
	}
} ///:~

The trace( ) method sends the name of the selected JCheckBox and its current state to the JTextArea using append( ), so you'll see a cumulative list of the checkboxes that were selected and what their state is.

The concept of a radio button in GUI programming comes from pre-electronic car radios with mechanical buttons; when you push one in, any other button that was pressed pops out. Thus, it allows you to force a single choice among many.

All you need to do to set up an associated group of JRadioButtons is to add them to a ButtonGroup (you can have any number of ButtonGroups on a form). One of the buttons can optionally have its starting state set to true (using the second argument in the constructor). If you try to set more than one radio button to true, then only the final one set will be true.

Here's a simple example of the use of radio buttons. Note that you capture radio button events like all others:

//: c14:RadioButtons.java
// Using JRadioButtons.
// <applet code=RadioButtons width=200 height=100></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class RadioButtons extends JApplet {
	private JTextField t = new JTextField(15);
	private ButtonGroup g = new ButtonGroup();
	private JRadioButton
		rb1 = new JRadioButton("one", false),
		rb2 = new JRadioButton("two", false),
		rb3 = new JRadioButton("three", false);
	private ActionListener al = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			t.setText("Radio button " +
				((JRadioButton)e.getSource()).getText());
		}
	};
	public void init() {
		rb1.addActionListener(al);
		rb2.addActionListener(al);
		rb3.addActionListener(al);
		g.add(rb1); g.add(rb2); g.add(rb3);
		t.setEditable(false);
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(t);
		cp.add(rb1);
		cp.add(rb2);
		cp.add(rb3);
	}
	public static void main(String[] args) {
		Console.run(new RadioButtons(), 200, 100);
	}
} ///:~

To display the state, a text field is used. This field is set to non-editable because it's used only to display data, not to collect it. Thus it is an alternative to using a JLabel.

Like a group of radio buttons, a drop-down list is a way to force the user to select only one element from a group of possibilities. However, it's a more compact way to accomplish this, and it's easier to change the elements of the list without surprising the user. (You can change radio buttons dynamically, but that tends to be visibly jarring).

By default, JComboBox box is not like the combo box in Windows, which lets you select from a list or type in your own selection. To produce this behavior you must call setEditable( ). With a JComboBox box, you choose one and only one element from the list. In the following example, the JComboBox box starts with a certain number of entries, and then new entries are added to the box when a button is pressed.

//: c14:ComboBoxes.java
// Using drop-down lists.
// <applet code=ComboBoxes width=200 height=125></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class ComboBoxes extends JApplet {
	private String[] description = {
		"Ebullient", "Obtuse", "Recalcitrant", "Brilliant",
		"Somnescent", "Timorous", "Florid", "Putrescent"
	};
	private JTextField t = new JTextField(15);
	private JComboBox c = new JComboBox();
	private JButton b = new JButton("Add items");
	private int count = 0;
	public void init() {
		for(int i = 0; i < 4; i++)
			c.addItem(description[count++]);
		t.setEditable(false);
		b.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				if(count < description.length)
					c.addItem(description[count++]);
			}
		});
		c.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				t.setText("index: "+ c.getSelectedIndex() + "   " +
					((JComboBox)e.getSource()).getSelectedItem());
			}
		});
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(t);
		cp.add(c);
		cp.add(b);
	}
	public static void main(String[] args) {
		Console.run(new ComboBoxes(), 200, 125);
	}
} ///:~

The JTextField displays the "selected index," which is the sequence number of the currently selected element, as well as the text of the selected item in the combo box.

List boxes are significantly different from JComboBox boxes, and not just in appearance. While a JComboBox box drops down when you activate it, a JList occupies some fixed number of lines on a screen all the time and doesn't change. If you want to see the items in a list, you simply call getSelectedValues( ), which produces an array of String of the items that have been selected.

A JList allows multiple selection; if you control-click on more than one item (holding down the "control" key while performing additional mouse clicks), the original item stays highlighted and you can select as many as you want. If you select an item, then shift-click on another item, all the items in the span between the two are selected. To remove an item from a group, you can control-click it.

//: c14:List.java
// <applet code=List width=250 height=375></applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;
 
public class List extends JApplet {
	private String[] flavors = {
		"Chocolate", "Strawberry", "Vanilla Fudge Swirl",
		"Mint Chip", "Mocha Almond Fudge", "Rum Raisin",
		"Praline Cream", "Mud Pie"
	};
	private DefaultListModel lItems=new DefaultListModel();
	private JList lst = new JList(lItems);
	private JTextArea t =
		new JTextArea(flavors.length, 20);
	private JButton b = new JButton("Add Item");
	private ActionListener bl = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			if(count < flavors.length) {
				lItems.add(0, flavors[count++]);
			} else {
				// Disable, since there are no more
				// flavors left to be added to the List
				b.setEnabled(false);
			}
		}
	};
	private ListSelectionListener ll =
		new ListSelectionListener() {
			public void valueChanged(ListSelectionEvent e) {
				if(e.getValueIsAdjusting()) return;
				t.setText("");
				Object[] items=lst.getSelectedValues();
				for(int i = 0; i < items.length; i++)
					t.append(items[i] + "\n");
			}
		};
	private int count = 0;
	public void init() {
		Container cp = getContentPane();
		t.setEditable(false);
		cp.setLayout(new FlowLayout());
		// Create Borders for components:
		Border brd = BorderFactory.createMatteBorder(
			1, 1, 2, 2, Color.BLACK);
		lst.setBorder(brd);
		t.setBorder(brd);
		// Add the first four items to the List
		for(int i = 0; i < 4; i++)
			lItems.addElement(flavors[count++]);
		// Add items to the Content Pane for Display
		cp.add(t);
		cp.add(lst);
		cp.add(b);
		// Register event listeners
		lst.addListSelectionListener(ll);
		b.addActionListener(bl);
	}
	public static void main(String[] args) {
    	Console.run(new List(), 250, 375);
	}
} ///:~

You can see that borders have also been added to the lists.

If you just want to put an array of Strings into a JList, there's a much simpler solution; you pass the array to the JList constructor, and it builds the list automatically. The only reason for using the "list model" in the preceding example is so that the list could be manipulated during the execution of the program.

JLists do not automatically provide direct support for scrolling. Of course, all you need to do is wrap the JList in a JScrollPane, and the details are automatically managed for you.

The JTabbedPane allows you to create a "tabbed dialog," which has file-folder tabs running across one edge, and all you have to do is press a tab to bring forward a different dialog.

//: c14:TabbedPane1.java
// Demonstrates the Tabbed Pane.
// <applet code=TabbedPane1 width=350 height=200></applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class TabbedPane1 extends JApplet {
	private String[] flavors = {
		"Chocolate", "Strawberry", "Vanilla Fudge Swirl",
		"Mint Chip", "Mocha Almond Fudge", "Rum Raisin",
		"Praline Cream", "Mud Pie"
	};
	private JTabbedPane tabs = new JTabbedPane();
	private JTextField txt = new JTextField(20);
	public void init() {
		for(int i = 0; i < flavors.length; i++)
			tabs.addTab(flavors[i],
				new JButton("Tabbed pane " + i));
		tabs.addChangeListener(new ChangeListener() {
			public void stateChanged(ChangeEvent e) {
				txt.setText("Tab selected: " +
					tabs.getSelectedIndex());
			}
		});
		Container cp = getContentPane();
		cp.add(BorderLayout.SOUTH, txt);
		cp.add(tabs);
	}
	public static void main(String[] args) {
		Console.run(new TabbedPane1(), 350, 200);
	}
} ///:~

In Java, the use of some sort of "tabbed panel" mechanism is quite important, because in applet programming the use of pop-up dialogs is discouraged by automatically adding a little warning to any dialog that pops up out of an applet.

When you run the program, you'll see that the JTabbedPane automatically stacks the tabs if there are too many of them to fit on one row. You can see this by resizing the window when you run the program from the console command line.

Windowing environments commonly contain a standard set of message boxes that allow you to quickly post information to the user or to capture information from the user. In Swing, these message boxes are contained in JOptionPane. You have many different possibilities (some quite sophisticated), but the ones you'll most commonly use are probably the message dialog and confirmation dialog, invoked using the static JOptionPane.showMessageDialog( ) and JOptionPane. showConfirmDialog( ). The following example shows a subset of the message boxes available with JOptionPane:

//: c14:MessageBoxes.java
// Demonstrates JoptionPane.
// <applet code=MessageBoxes width=200 height=150></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class MessageBoxes extends JApplet {
	private JButton[] b = {
		new JButton("Alert"), new JButton("Yes/No"),
		new JButton("Color"), new JButton("Input"),
		new JButton("3 Vals")
	};
	private JTextField txt = new JTextField(15);
	private ActionListener al = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			String id = ((JButton)e.getSource()).getText();
			if(id.equals("Alert"))
				JOptionPane.showMessageDialog(null,
					"There's a bug on you!", "Hey!",
					JOptionPane.ERROR_MESSAGE);
			else if(id.equals("Yes/No"))
				JOptionPane.showConfirmDialog(null,
					"or no", "choose yes",
					JOptionPane.YES_NO_OPTION);
			else if(id.equals("Color")) {
				Object[] options = { "Red", "Green" };
				int sel = JOptionPane.showOptionDialog(
					null, "Choose a Color!", "Warning",
					JOptionPane.DEFAULT_OPTION,
					JOptionPane.WARNING_MESSAGE, null,
					options, options[0]);
			if(sel != JOptionPane.CLOSED_OPTION)
				txt.setText("Color Selected: " + options[sel]);
			} else if(id.equals("Input")) {
				String val = JOptionPane.showInputDialog(
					"How many fingers do you see?");
				txt.setText(val);
			} else if(id.equals("3 Vals")) {
				Object[] selections = {"First", "Second", "Third"};
				Object val = JOptionPane.showInputDialog(
					null, "Choose one", "Input",
					JOptionPane.INFORMATION_MESSAGE,
					null, selections, selections[0]);
				if(val != null)
					txt.setText(val.toString());
			}
		}
	};
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		for(int i = 0; i < b.length; i++) {
			b[i].addActionListener(al);
			cp.add(b[i]);
		}
		cp.add(txt);
	}
	public static void main(String[] args) {
		Console.run(new MessageBoxes(), 200, 200);
	}
} ///:~

To be able to write a single ActionListener, I've used the somewhat risky approach of checking the String labels on the buttons. The problem with this is that it's easy to get the label a little bit wrong, typically in capitalization, and this bug can be hard to spot.

Note that showOptionDialog( ) and showInputDialog( ) provide return objects that contain the value entered by the user.

Each component capable of holding a menu, including JApplet, JFrame, JDialog, and their descendants, has a setJMenuBar( ) method that accepts a JMenuBar (you can have only one JMenuBar on a particular component). You add JMenus to the JMenuBar, and JMenuItems to the JMenus. Each JMenuItem can have an ActionListener attached to it, to be fired when that menu item is selected.

Unlike a system that uses resources, with Java and Swing you must hand assemble all the menus in source code. Here is a very simple menu example:

//: c14:SimpleMenus.java
// <applet code=SimpleMenus width=200 height=75></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class SimpleMenus extends JApplet {
	private JTextField t = new JTextField(15);
	private ActionListener al = new ActionListener() {
		public void actionPerformed(ActionEvent e) {
			t.setText(((JMenuItem)e.getSource()).getText());
		}
	};
	private JMenu[] menus = {
		new JMenu("Winken"), new JMenu("Blinken"),
		new JMenu("Nod")
	};
	private JMenuItem[] items = {
		new JMenuItem("Fee"), new JMenuItem("Fi"),
		new JMenuItem("Fo"),  new JMenuItem("Zip"),
		new JMenuItem("Zap"), new JMenuItem("Zot"),
		new JMenuItem("Olly"), new JMenuItem("Oxen"),
		new JMenuItem("Free")
	};
	public void init() {
		for(int i = 0; i < items.length; i++) {
			items[i].addActionListener(al);
			menus[i % 3].add(items[i]);
		}
		JMenuBar mb = new JMenuBar();
		for(int i = 0; i < menus.length; i++)
			mb.add(menus[i]);
		setJMenuBar(mb);
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(t);
	}
	public static void main(String[] args) {
		Console.run(new SimpleMenus(), 200, 75);
	}
} ///:~

The use of the modulus operator in "i%3" distributes the menu items among the three JMenus. Each JMenuItem must have an ActionListener attached to it; here, the same ActionListener is used everywhere, but you'll usually need an individual one for each JMenuItem.

JMenuItem inherits AbstractButton, so it has some button-like behaviors. By itself, it provides an item that can be placed on a drop-down menu. There are also three types inherited from JMenuItem: JMenu to hold other JMenuItems (so you can have cascading menus); JCheckBoxMenuItem, which produces a checkmark to indicate whether that menu item is selected; and JRadioButtonMenuItem, which contains a radio button.

As a more sophisticated example, here are the ice cream flavors again, used to create menus. This example also shows cascading menus, keyboard mnemonics, JCheckBoxMenuItems, and the way you can dynamically change menus:

//: c14:Menus.java
// Submenus, checkbox menu items, swapping menus,
// mnemonics (shortcuts) and action commands.
// <applet code=Menus width=300 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
 
public class Menus extends JApplet {
	private String[] flavors = {
		"Chocolate", "Strawberry", "Vanilla Fudge Swirl",
		"Mint Chip", "Mocha Almond Fudge", "Rum Raisin",
		"Praline Cream", "Mud Pie"
	};
	private JTextField t = new JTextField("No flavor", 30);
	private JMenuBar mb1 = new JMenuBar();
	private JMenu
		f = new JMenu("File"),
		m = new JMenu("Flavors"),
		s = new JMenu("Safety");
	// Alternative approach:
	private JCheckBoxMenuItem[] safety = {
		new JCheckBoxMenuItem("Guard"),
		new JCheckBoxMenuItem("Hide")
	};
	private JMenuItem[] file = { new JMenuItem("Open") };
	// A second menu bar to swap to:
	private JMenuBar mb2 = new JMenuBar();
	private JMenu fooBar = new JMenu("fooBar");
	private JMenuItem[] other = {
		// Adding a menu shortcut (mnemonic) is very
		// simple, but only JMenuItems can have them
		// in their constructors:
		new JMenuItem("Foo", KeyEvent.VK_F),
		new JMenuItem("Bar", KeyEvent.VK_A),
		// No shortcut:
		new JMenuItem("Baz"),
	};
	private JButton b = new JButton("Swap Menus");
	class BL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JMenuBar m = getJMenuBar();
			setJMenuBar(m == mb1 ? mb2 : mb1);
			validate(); // Refresh the frame
		}
	}
	class ML implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JMenuItem target = (JMenuItem)e.getSource();
			String actionCommand = target.getActionCommand();
			if(actionCommand.equals("Open")) {
				String s = t.getText();
				boolean chosen = false;
				for(int i = 0; i < flavors.length; i++)
					if(s.equals(flavors[i])) chosen = true;
				if(!chosen)
					t.setText("Choose a flavor first!");
				else
					t.setText("Opening " + s + ". Mmm, mm!");
			}
		}
	}
	class FL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JMenuItem target = (JMenuItem)e.getSource();
			t.setText(target.getText());
		}
	}
	// Alternatively, you can create a different
	// class for each different MenuItem. Then you
	// Don't have to figure out which one it is:
	class FooL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			t.setText("Foo selected");
		}
	}
	class BarL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			t.setText("Bar selected");
		}
	}
	class BazL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			t.setText("Baz selected");
		}
	}
	class CMIL implements ItemListener {
		public void itemStateChanged(ItemEvent e) {
			JCheckBoxMenuItem target =
				(JCheckBoxMenuItem)e.getSource();
			String actionCommand = target.getActionCommand();
			if(actionCommand.equals("Guard"))
				t.setText("Guard the Ice Cream! " +
					"Guarding is " + target.getState());
			else if(actionCommand.equals("Hide"))
				t.setText("Hide the Ice Cream! " +
					"Is it hidden? " + target.getState());
		}
	}
	public void init() {
		ML ml = new ML();
		CMIL cmil = new CMIL();
		safety[0].setActionCommand("Guard");
		safety[0].setMnemonic(KeyEvent.VK_G);
		safety[0].addItemListener(cmil);
		safety[1].setActionCommand("Hide");
		safety[1].setMnemonic(KeyEvent.VK_H);
		safety[1].addItemListener(cmil);
		other[0].addActionListener(new FooL());
		other[1].addActionListener(new BarL());
		other[2].addActionListener(new BazL());
		FL fl = new FL();
		for(int i = 0; i < flavors.length; i++) {
			JMenuItem mi = new JMenuItem(flavors[i]);
			mi.addActionListener(fl);
			m.add(mi);
			// Add separators at intervals:
			if((i + 1) % 3 == 0)
				m.addSeparator();
		}
		for(int i = 0; i < safety.length; i++)
			s.add(safety[i]);
		s.setMnemonic(KeyEvent.VK_A);
		f.add(s);
		f.setMnemonic(KeyEvent.VK_F);
		for(int i = 0; i < file.length; i++) {
			file[i].addActionListener(fl);
			f.add(file[i]);
		}
		mb1.add(f);
		mb1.add(m);
		setJMenuBar(mb1);
		t.setEditable(false);
		Container cp = getContentPane();
		cp.add(t, BorderLayout.CENTER);
		// Set up the system for swapping menus:
		b.addActionListener(new BL());
		b.setMnemonic(KeyEvent.VK_S);
		cp.add(b, BorderLayout.NORTH);
		for(int i = 0; i < other.length; i++)
			fooBar.add(other[i]);
		fooBar.setMnemonic(KeyEvent.VK_B);
		mb2.add(fooBar);
	}
	public static void main(String[] args) {
		Console.run(new Menus(), 300, 100);
	}
} ///:~

In this program I placed the menu items into arrays and then stepped through each array calling add( ) for each JMenuItem. This makes adding or subtracting a menu item somewhat less tedious.

This program creates not one but two JMenuBars to demonstrate that menu bars can be actively swapped while the program is running. You can see how a JMenuBar is made up of JMenus, and each JMenu is made up of JMenuItems, JCheckBoxMenuItems, or even other JMenus (which produce submenus). When a JMenuBar is assembled, it can be installed into the current program with the setJMenuBar( ) method. Note that when the button is pressed, it checks to see which menu is currently installed by calling getJMenuBar( ), then it puts the other menu bar in its place.

When testing for "Open," notice that spelling and capitalization are critical, but Java signals no error if there is no match with "Open." This kind of string comparison is a source of programming errors.

The checking and unchecking of the menu items is taken care of automatically. The code handling the JCheckBoxMenuItems shows two different ways to determine what was checked: string matching (which, as mentioned above, isn't a very safe approach although you'll see it used) and matching on the event target object. As shown, the getState( ) method can be used to reveal the state. You can also change the state of a JCheckBoxMenuItem with setState( ).

The events for menus are a bit inconsistent and can lead to confusion: JMenuItems use ActionListeners, but JCheckBoxMenuItems use ItemListeners. The JMenu objects can also support ActionListeners, but that's not usually helpful. In general, you'll attach listeners to each JMenuItem, JCheckBoxMenuItem, or JRadioButtonMenuItem, but the example shows ItemListeners and ActionListeners attached to the various menu components.

Swing supports mnemonics, or "keyboard shortcuts," so you can select anything derived from AbstractButton (button, menu item, etc.) by using the keyboard instead of the mouse. These are quite simple; for JmenuItem, you can use the overloaded constructor that takes as a second argument the identifier for the key. However, most AbstractButtons do not have constructors like this, so the more general way to solve the problem is to use the setMnemonic( ) method. The preceding example adds mnemonics to the button and some of the menu items; shortcut indicators automatically appear on the components.

You can also see the use of setActionCommand( ). This seems a bit strange because in each case, the "action command" is exactly the same as the label on the menu component. Why not just use the label instead of this alternative string? The problem is internationalization. If you retarget this program to another language, you want to change only the label in the menu, and not change the code (which would no doubt introduce new errors). So to make this easy for code that checks the text string associated with a menu component, the "action command" can be immutable, but the menu label can change. All the code works with the "action command," so it's unaffected by changes to the menu labels. Note that in this program, not all the menu components are examined for their action commands, so those that aren't do not have their action command set.

The bulk of the work happens in the listeners. BL performs the JMenuBar swapping. In ML, the "figure out who rang" approach is taken by getting the source of the ActionEvent and casting it to a JMenuItem, then getting the action command string to pass it through a cascaded if statement.

The FL listener is simple even though it's handling all the different flavors in the flavor menu. This approach is useful if you have enough simplicity in your logic, but in general, you'll want to take the approach used with FooL, BarL, and BazL, in which each is attached to only a single menu component, so no extra detection logic is necessary, and you know exactly who called the listener. Even with the profusion of classes generated this way, the code inside tends to be smaller, and the process is more foolproof.

You can see that menu code quickly gets long-winded and messy. This is another case where the use of a GUI builder is the appropriate solution. A good tool will also handle the maintenance of the menus.

The most straightforward way to implement a JPopupMenu is to create an inner class that extends MouseAdapter, then add an object of that inner class to each component that you want to produce pop-up behavior:

//: c14:Popup.java
// Creating popup menus with Swing.
// <applet code=Popup width=300 height=200></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
 
public class Popup extends JApplet {
	private JPopupMenu popup = new JPopupMenu();
	private JTextField t = new JTextField(10);
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(t);
		ActionListener al = new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				t.setText(((JMenuItem)e.getSource()).getText());
			}
		};
		JMenuItem m = new JMenuItem("Hither");
		m.addActionListener(al);
		popup.add(m);
		m = new JMenuItem("Yon");
		m.addActionListener(al);
		popup.add(m);
		m = new JMenuItem("Afar");
		m.addActionListener(al);
		popup.add(m);
		popup.addSeparator();
		m = new JMenuItem("Stay Here");
		m.addActionListener(al);
		popup.add(m);
		PopupListener pl = new PopupListener();
		addMouseListener(pl);
		t.addMouseListener(pl);
	}
	class PopupListener extends MouseAdapter {
		public void mousePressed(MouseEvent e) {
			maybeShowPopup(e);
	}
	public void mouseReleased(MouseEvent e) {
		maybeShowPopup(e);
	}
	private void maybeShowPopup(MouseEvent e) {
		if(e.isPopupTrigger())
			popup.show(((JApplet)e.getComponent())
				.getContentPane(), e.getX(), e.getY());
		}
	}
	public static void main(String[] args) {
		Console.run(new Popup(), 300, 200);
	}
} ///:~

The same ActionListener is added to each JMenuItem, so that it fetches the text from the menu label and inserts it into the JTextField.

In a good GUI framework, drawing should be reasonably easy-and it is, in the Swing library. The problem with any drawing example is that the calculations that determine where things go are typically a lot more complicated that the calls to the drawing routines, and these calculations are often mixed together with the drawing calls, so it can seem that the interface is more complicated than it actually is.

For simplicity, consider the problem of representing data on the screen-here, the data will be provided by the built-in Math.sin( ) method, that produces a mathematical sine function. To make things a little more interesting, and to further demonstrate how easy it is to use Swing components, a slider will be placed at the bottom of the form to dynamically control the number of sine wave cycles that are displayed. In addition, if you resize the window, you'll see that the sine wave refits itself to the new window size.

Although any JComponent may be painted and thus used as a canvas, if you just want a straightforward drawing surface, you will typically inherit from a JPanel. The only method you need to override is paintComponent( ), which is called whenever that component must be repainted (you normally don't need to worry about this, because the decision is managed by Swing). When it is called, Swing passes a Graphics object to the method, and you can then use this object to draw or paint on the surface.

In the following example, all the intelligence concerning painting is in the SineDraw class; the SineWave class simply configures the program and the slider control. Inside SineDraw, the setCycles( ) method provides a hook to allow another object-the slider control, in this case-to control the number of cycles.

//: c14:SineWave.java
// Drawing with Swing, using a JSlider.
// <applet code=SineWave width=700 height=400></applet>
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
class SineDraw extends JPanel {
	private static final int SCALEFACTOR = 200;
	private int cycles;
	private int points;
	private double[] sines;
	private int[] pts;
	public SineDraw() { setCycles(5); }
	public void setCycles(int newCycles) {
		cycles = newCycles;
		points = SCALEFACTOR * cycles * 2;
		sines = new double[points];
		for(int i = 0; i < points; i++) {
			double radians = (Math.PI/SCALEFACTOR) * i;
			sines[i] = Math.sin(radians);
		}
		repaint();
	}
	public void paintComponent(Graphics g) {
		super.paintComponent(g);
		int maxWidth = getWidth();
		double hstep = (double)maxWidth/(double)points;
		int maxHeight = getHeight();
		pts = new int[points];
		for(int i = 0; i < points; i++)
			pts[i] =
				(int)(sines[i] * maxHeight/2 * .95 + maxHeight/2);
		g.setColor(Color.RED);
		for(int i = 1; i < points; i++) {
			int x1 = (int)((i - 1) * hstep);
			int x2 = (int)(i * hstep);
			int y1 = pts[i-1];
			int y2 = pts[i];
			g.drawLine(x1, y1, x2, y2);
		}
	}
}
 
public class SineWave extends JApplet {
	private SineDraw sines = new SineDraw();
	private JSlider adjustCycles = new JSlider(1, 30, 5);
	public void init() {
		Container cp = getContentPane();
		cp.add(sines);
		adjustCycles.addChangeListener(new ChangeListener() {
			public void stateChanged(ChangeEvent e) {
				sines.setCycles(
					((JSlider)e.getSource()).getValue());
			}
		});
		cp.add(BorderLayout.SOUTH, adjustCycles);
	}
	public static void main(String[] args) {
		Console.run(new SineWave(), 700, 400);
	}
} ///:~

All of the fields and arrays are used in the calculation of the sine wave points; cycles indicates the number of complete sine waves desired, points contains the total number of points that will be graphed, sines contains the sine function values, and pts contains the y-coordinates of the points that will be drawn on the JPanel. The setCycles( ) method creates the arrays according to the number of points needed and fills the sines array with numbers. By calling repaint( ) , setCycles( ) forces paintComponent( ) to be called so the rest of the calculation and redraw will take place.

The first thing you must do when you override paintComponent( ) is to call the base-class version of the method. Then you are free to do whatever you like; normally, this means using the Graphics methods that you can find in the documentation for java.awt.Graphics (in the JDK documentation from java.sun.com) to draw and paint pixels onto the JPanel. Here, you can see that almost all the code is involved in performing the calculations; the only two method calls that actually manipulate the screen are setColor( ) and drawLine( ). You will probably have a similar experience when creating your own program that displays graphical data; you'll spend most of your time figuring out what it is you want to draw, but the actual drawing process will be quite simple.

When I created this program, the bulk of my time was spent in getting the sine wave to display. Once I did that, I thought it would be nice to be able to dynamically change the number of cycles. My programming experiences when trying to do such things in other languages made me a bit reluctant to try this, but it turned out to be the easiest part of the project. I created a JSlider (the arguments are the left-most value of the JSlider, the right-most value, and the starting value, respectively, but there are other constructors as well) and dropped it into the JApplet. Then I looked at the JDK documentation and noticed that the only listener was the addChangeListener, which was triggered whenever the slider was changed enough for it to produce a different value. The only method for this was the obviously named stateChanged( ), which provided a ChangeEvent object so that I could look backward to the source of the change and find the new value. By calling the sines object's setCycles( ), the new value was incorporated and the JPanel redrawn.

In general, you will find that most of your Swing problems can be solved by following a similar process, and you'll find that it's generally quite simple, even if you haven't used a particular component before.

If your problem is more complex, there are other more sophisticated alternatives for drawing, including third-party JavaBeans components and the Java 2D API. These solutions are beyond the scope of this book, but you should look them up if your drawing code becomes too onerous.

A dialog box is a window that pops up out of another window. Its purpose is to deal with some specific issue without cluttering the original window with those details. Dialog boxes are heavily used in windowed programming environments, but less frequently used in applets.

To create a dialog box, you inherit from JDialog, which is just another kind of Window, like a JFrame. A JDialog has a layout manager (which defaults to BorderLayout), and you add event listeners to deal with events. One significant difference when the dialog window is closed is that you don't want to shut down the application. Instead, you release the resources used by the dialog's window by calling dispose( ). Here's a very simple example:

//: c14:Dialogs.java
// Creating and using Dialog Boxes.
// <applet code=Dialogs width=125 height=75></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
class MyDialog extends JDialog {
	public MyDialog(JFrame parent) {
		super(parent, "My dialog", true);
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(new JLabel("Here is my dialog"));
		JButton ok = new JButton("OK");
		ok.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				dispose(); // Closes the dialog
			}
		});
		cp.add(ok);
		setSize(150,125);
	}
}
 
public class Dialogs extends JApplet {
	private JButton b1 = new JButton("Dialog Box");
	private MyDialog dlg = new MyDialog(null);
	public void init() {
		b1.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				dlg.show();
			}
		});
		getContentPane().add(b1);
	}
	public static void main(String[] args) {
		Console.run(new Dialogs(), 125, 75);
	}
} ///:~

Once the JDialog is created, the show( ) method must be called to display and activate it. For the dialog to close, it must call dispose( ).

You'll see that anything that pops up out of an applet, including dialog boxes, is "untrusted." That is, you get a warning in the window that's been popped up. This is because, in concept, it would be possible to fool users into thinking that they're dealing with a regular native application and to get them to type in their credit card number, which then goes across the Web. An applet is always attached to a Web page and visible within your Web browser, while a dialog box is detached-so theoretically, it's possible. As a result, it is not so common to see an applet that uses a dialog box.

The following example is more complex; the dialog box is made up of a grid (using GridLayout) of a special kind of button that is defined here as class ToeButton. This button draws a frame around itself and, depending on its state, a blank, an "x," or an "o" in the middle. It starts out blank, and then depending on whose turn it is, changes to an "x" or an "o." However, it will also flip back and forth between "x" and "o" when you click on the button. (This makes the tic-tac-toe concept only slightly more annoying than it already is.) In addition, the dialog box can be set up for any number of rows and columns by changing numbers in the main application window.

//: c14:TicTacToe.java
// Dialog boxes and creating your own components.
// <applet code=TicTacToe width=200 height=100></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
 
public class TicTacToe extends JApplet {
	private JTextField
		rows = new JTextField("3"),
		cols = new JTextField("3");
	private static final int BLANK = 0, XX = 1, OO = 2;
	class ToeDialog extends JDialog {
		private int turn = XX; // Start with x's turn
		ToeDialog(int cellsWide, int cellsHigh) {
			setTitle("The game itself");
			Container cp = getContentPane();
			cp.setLayout(new GridLayout(cellsWide, cellsHigh));
			for(int i = 0; i < cellsWide * cellsHigh; i++)
				cp.add(new ToeButton());
			setSize(cellsWide * 50, cellsHigh * 50);
			setDefaultCloseOperation(DISPOSE_ON_CLOSE);
		}
		class ToeButton extends JPanel {
			private int state = BLANK;
			public ToeButton() { addMouseListener(new ML()); }
			public void paintComponent(Graphics g) {
				super.paintComponent(g);
				int
					x1 = 0, y1 = 0,
					x2 = getSize().width - 1,
					y2 = getSize().height - 1;
				g.drawRect(x1, y1, x2, y2);
				x1 = x2/4;
				y1 = y2/4;
				int wide = x2/2, high = y2/2;
				if(state == XX) {
					g.drawLine(x1, y1, x1 + wide, y1 + high);
					g.drawLine(x1, y1 + high, x1 + wide, y1);
				}
				if(state == OO)
					g.drawOval(x1, y1, x1 + wide/2, y1 + high/2);
			}
			class ML extends MouseAdapter {
				public void mousePressed(MouseEvent e) {
					if(state == BLANK) {
						state = turn;
						turn = (turn == XX ? OO : XX);
					}
					else
						state = (state == XX ? OO : XX);
					repaint();
				}
			}
		}
	}
	class BL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JDialog d = new ToeDialog(
				Integer.parseInt(rows.getText()),
				Integer.parseInt(cols.getText()));
			d.setVisible(true);
		}
	}
	public void init() {
		JPanel p = new JPanel();
		p.setLayout(new GridLayout(2,2));
		p.add(new JLabel("Rows", JLabel.CENTER));
		p.add(rows);
		p.add(new JLabel("Columns", JLabel.CENTER));
		p.add(cols);
		Container cp = getContentPane();
		cp.add(p, BorderLayout.NORTH);
		JButton b = new JButton("go");
		b.addActionListener(new BL());
		cp.add(b, BorderLayout.SOUTH);
	}
	public static void main(String[] args) {
		Console.run(new TicTacToe(), 200, 100);
	}
} ///:~

Because statics can only be at the outer level of the class, inner classes cannot have static data or nested classes.

The paintComponent( ) method draws the square around the panel and the "x" or the "o." This is full of tedious calculations, but it's straightforward.

A mouse click is captured by the MouseListener, which first checks to see if the panel has anything written on it. If not, the parent window is queried to find out whose turn it is, which establishes the state of the ToeButton. Via the inner class mechanism, the ToeButton then reaches back into the parent and changes the turn. If the button is already displaying an "x" or an "o," then that is flopped. You can see in these calculations the convenient use of the ternary if-else described in Chapter 3. After a state change, the ToeButton is repainted.

The constructor for ToeDialog is quite simple; It adds into a GridLayout as many buttons as you request, then resizes it for 50 pixels on a side for each button.

TicTacToe sets up the whole application by creating the JTextFields (for inputting the rows and columns of the button grid) and the "go" button with its ActionListener. When the button is pressed, the data in the JTextFields must be fetched, and, since they are in String form, turned into ints using the static Integer.parseInt( ) method.

Some operating systems have a number of special built-in dialog boxes to handle the selection of things such as fonts, colors, printers, and the like. Virtually all graphical operating systems support the opening and saving of files, so Java's JFileChooser encapsulates these for easy use.

The following application exercises two forms of JFileChooser dialogs, one for opening and one for saving. Most of the code should by now be familiar, and all the interesting activities happen in the action listeners for the two different button clicks:

//: c14:FileChooserTest.java
// Demonstration of File dialog boxes.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import com.bruceeckel.swing.*;
 
public class FileChooserTest extends JFrame {
	private JTextField
		filename = new JTextField(),
		dir = new JTextField();
	private JButton
		open = new JButton("Open"),
		save = new JButton("Save");
	public FileChooserTest() {
		JPanel p = new JPanel();
		open.addActionListener(new OpenL());
		p.add(open);
		save.addActionListener(new SaveL());
		p.add(save);
		Container cp = getContentPane();
		cp.add(p, BorderLayout.SOUTH);
		dir.setEditable(false);
		filename.setEditable(false);
		p = new JPanel();
		p.setLayout(new GridLayout(2,1));
		p.add(filename);
		p.add(dir);
		cp.add(p, BorderLayout.NORTH);
	}
	class OpenL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JFileChooser c = new JFileChooser();
			// Demonstrate "Open" dialog:
			int rVal = c.showOpenDialog(FileChooserTest.this);
			if(rVal == JFileChooser.APPROVE_OPTION) {
				filename.setText(c.getSelectedFile().getName());
				dir.setText(c.getCurrentDirectory().toString());
			}
			if(rVal == JFileChooser.CANCEL_OPTION) {
				filename.setText("You pressed cancel");
				dir.setText("");
			}
		}
	}
	class SaveL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			JFileChooser c = new JFileChooser();
			// Demonstrate "Save" dialog:
			int rVal = c.showSaveDialog(FileChooserTest.this);
			if(rVal == JFileChooser.APPROVE_OPTION) {
				filename.setText(c.getSelectedFile().getName());
				dir.setText(c.getCurrentDirectory().toString());
			}
			if(rVal == JFileChooser.CANCEL_OPTION) {
				filename.setText("You pressed cancel");
				dir.setText("");
			}
		}
	}
	public static void main(String[] args) {
		Console.run(new FileChooserTest(), 250, 110);
	}
} ///:~

Note that there are many variations you can apply to JFileChooser, including filters to narrow the file names that you will allow.

For an "open file" dialog, you call showOpenDialog( ), and for a "save file" dialog, you call showSaveDialog( ). These commands don't return until the dialog is closed. The JFileChooser object still exists, so you can read data from it. The methods getSelectedFile( ) and getCurrentDirectory( ) are two ways you can interrogate the results of the operation. If these return null, it means the user canceled out of the dialog.

Any component that can take text can also take HTML text, which it will reformat according to HTML rules. This means you can very easily add fancy text to a Swing component. For example:

//: c14:HTMLButton.java
// Putting HTML text on Swing components.
// <applet code=HTMLButton width=250 height=500></applet>
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import com.bruceeckel.swing.*;
 
public class HTMLButton extends JApplet {
	private JButton b = new JButton(
		"<html><b><font size=+2>" +
		"<center>Hello!<br><i>Press me now!");
	public void init() {
		b.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				getContentPane().add(new JLabel("<html>" +
					"<i><font size=+4>Kapow!"));
				// Force a re-layout to include the new label:
				validate();
			}
		});
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		cp.add(b);
	}
	public static void main(String[] args) {
		Console.run(new HTMLButton(), 200, 500);
	}
} ///:~

You must start the text with "<html>," and then you can use normal HTML tags. Note that you are not forced to include the normal closing tags.

The ActionListener adds a new JLabel to the form, which also contains HTML text. However, this label is not added during init( ), so you must call the container's validate( ) method in order to force a re-layout of the components (and thus the display of the new label).

You can also use HTML text for JTabbedPane, JMenuItem, JToolTip, JradioButton, and JCheckBox.

A slider (which has already been used in SineWave.java) allows the user to input data by moving a point back and forth, which is intuitive in some situations (volume controls, for example). A progress bar displays data in a relative fashion from "full" to "empty" so the user gets a perspective. My favorite example for these is to simply hook the slider to the progress bar so when you move the slider, the progress bar changes accordingly:

//: c14:Progress.java
// Using progress bars and sliders.
// <applet code=Progress width=300 height=200></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.event.*;
import javax.swing.border.*;
import com.bruceeckel.swing.*;
 
public class Progress extends JApplet {
	private JProgressBar pb = new JProgressBar();
	private JSlider sb =
		new JSlider(JSlider.HORIZONTAL, 0, 100, 60);
	public void init() {
		Container cp = getContentPane();
		cp.setLayout(new GridLayout(2,1));
		cp.add(pb);
		sb.setValue(0);
		sb.setPaintTicks(true);
		sb.setMajorTickSpacing(20);
		sb.setMinorTickSpacing(5);
		sb.setBorder(new TitledBorder("Slide Me"));
		pb.setModel(sb.getModel()); // Share model
		cp.add(sb);
	}
	public static void main(String[] args) {
		Console.run(new Progress(), 300, 200);
	}
} ///:~

The key to hooking the two components together is in sharing their model, in the line:

pb.setModel(sb.getModel());

Of course, you could also control the two using a listener, but this is more straightforward for simple situations.

The JProgressBar is fairly straightforward, but the JSlider has a lot of options, such as the orientation and major and minor tick marks. Notice how straightforward it is to add a titled border.

Using a JTree can be as simple as saying:

add(new JTree(new Object[] {"this", "that", "other"}));

This displays a primitive tree. The API for trees is vast, however-certainly one of the largest in Swing. It appears that you can do just about anything with trees, but more sophisticated tasks might require quite a bit of research and experimentation.

Fortunately, there is a middle ground provided in the library: the "default" tree components, which generally do what you need. So most of the time you can use these components, and only in special cases will you need to delve in and understand trees more deeply.

The following example uses the "default" tree components to display a tree in an applet. When you press the button, a new subtree is added under the currently selected node (if no node is selected, the root node is used):

//: c14:Trees.java
// Simple Swing tree. Trees can be vastly more complex.
// <applet code=Trees width=250 height=250></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.tree.*;
import com.bruceeckel.swing.*;
 
// Takes an array of Strings and makes the first
// element a node and the rest leaves:
class Branch {
	private DefaultMutableTreeNode r;
	public Branch(String[] data) {
		r = new DefaultMutableTreeNode(data[0]);
		for(int i = 1; i < data.length; i++)
			r.add(new DefaultMutableTreeNode(data[i]));
	}
	public DefaultMutableTreeNode node() { return r; }
}
 
public class Trees extends JApplet {
	private String[][] data = {
		{ "Colors", "Red", "Blue", "Green" },
		{ "Flavors", "Tart", "Sweet", "Bland" },
		{ "Length", "Short", "Medium", "Long" },
		{ "Volume", "High", "Medium", "Low" },
		{ "Temperature", "High", "Medium", "Low" },
		{ "Intensity", "High", "Medium", "Low" },
	};
	private static int i = 0;
	private DefaultMutableTreeNode root, child, chosen;
	private JTree tree;
	private DefaultTreeModel model;
	public void init() {
		Container cp = getContentPane();
		root = new DefaultMutableTreeNode("root");
		tree = new JTree(root);
		// Add it and make it take care of scrolling:
		cp.add(new JScrollPane(tree), BorderLayout.CENTER);
		// Capture the tree's model:
		model =(DefaultTreeModel)tree.getModel();
		JButton test = new JButton("Press me");
		test.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				if(i < data.length) {
					child = new Branch(data[i++]).node();
					// What's the last one you clicked?
					chosen = (DefaultMutableTreeNode)
					tree.getLastSelectedPathComponent();
					if(chosen == null)
						chosen = root;
					// The model will create the appropriate event.
					// In response, the tree will update itself:
					model.insertNodeInto(child, chosen, 0);
					// Puts the new node on the chosen node.
				}
			}
		});
		// Change the button's colors:
		test.setBackground(Color.BLUE);
		test.setForeground(Color.WHITE);
		JPanel p = new JPanel();
		p.add(test);
		cp.add(p, BorderLayout.SOUTH);
	}
	public static void main(String[] args) {
		Console.run(new Trees(), 250, 250);
	}
} ///:~

The first class, Branch, is a tool to take an array of String and build a DefaultMutableTreeNode with the first String as the root and the rest of the Strings in the array as leaves. Then node( ) can be called to produce the root of this "branch."

The Trees class contains a two-dimensional array of Strings, from which Branches can be made, and a static int i to count through this array. The DefaultMutableTreeNode objects hold the nodes, but the physical representation on screen is controlled by the JTree and its associated model, the DefaultTreeModel. Note that when the JTree is added to the applet, it is wrapped in a JScrollPane-this is all it takes to provide automatic scrolling.

The JTree is controlled through its model. When you make a change to the model, the model generates an event that causes the JTree to perform any necessary updates to the visible representation of the tree. In init( ), the model is captured by calling getModel( ). When the button is pressed, a new "branch" is created. Then the currently selected component is found (or the root is used if nothing is selected) and the model's insertNodeInto( ) method does all the work of changing the tree and causing it to be updated.

An example like the preceding one may give you what you need in a tree. However, trees have the power to do just about anything you can imagine-everywhere you see the word "default" in the preceding example, you can substitute your own class to get different behavior. But beware: Almost all of these classes have a large interface, so you could spend a lot of time struggling to understand the intricacies of trees. Despite this, it's a good design, and the alternatives are usually much worse.

Like trees, tables in Swing are vast and powerful. They are primarily intended to be the popular "grid" interface to databases via Java Database Connectivity (JDBC, discussed in Thinking in Enterprise Java), and thus they have a tremendous amount of flexibility, which you pay for in complexity. There's easily enough here to allow the creation of a full-blown spreadsheet application and could probably justify an entire book. However, it is also possible to create a relatively simple JTable if you understand the basics.

The JTable controls how the data is displayed, but the TableModel controls the data itself. So to create a JTable, you'll typically create a TableModel first. You can fully implement the TableModel interface, but it's simpler to inherit from the helper class AbstractTableModel:

//: c14:JTableDemo.java
// Simple demonstration of JTable.
// <applet code=Table width=350 height=200></applet>
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import javax.swing.table.*;
import javax.swing.event.*;
import com.bruceeckel.swing.*;
 
public class JTableDemo extends JApplet {
	private JTextArea txt = new JTextArea(4, 20);
	// The TableModel controls all the data:
	class DataModel extends AbstractTableModel {
		Object[][] data = {
			{"one", "two", "three", "four"},
			{"five", "six", "seven", "eight"},
			{"nine", "ten", "eleven", "twelve"},
		};
		// Prints data when table changes:
		class TML implements TableModelListener {
			public void tableChanged(TableModelEvent e) {
				txt.setText(""); // Clear it
				for(int i = 0; i < data.length; i++) {
					for(int j = 0; j < data[0].length; j++)
						txt.append(data[i][j] + " ");
					txt.append("\n");
				}
			}
		}
		public DataModel() { addTableModelListener(new TML());}
		public int getColumnCount() { return data[0].length; }
		public int getRowCount() { return data.length; }
		public Object getValueAt(int row, int col) {
			return data[row][col];
		}
		public void setValueAt(Object val, int row, int col) {
			data[row][col] = val;
			// Indicate the change has happened:
			fireTableDataChanged();
		}
		public boolean isCellEditable(int row, int col) {
			return true;
		}
	}
	public void init() {
		Container cp = getContentPane();
		JTable table = new JTable(new DataModel());
		cp.add(new JScrollPane(table));
		cp.add(BorderLayout.SOUTH, txt);
	}
	public static void main(String[] args) {
		Console.run(new JTableDemo(), 350, 200);
	}
} ///:~

DataModel contains an array of data, but you could also get the data from some other source such as a database. The constructor adds a TableModelListener that prints the array every time the table is changed. The rest of the methods follow the Beans naming convention (using "get" and "set" methods, which will be described later in this chapter) and are used by JTable when it wants to present the information in DataModel. AbstractTableModel provides default methods for setValueAt( ) and isCellEditable( ) that prevent changes to the data, so if you want to be able to edit the data, you must override these methods.

Once you have a TableModel, you only need to hand it to the JTable constructor. All the details of displaying, editing, and updating will be taken care of for you. This example also puts the JTable in a JScrollPane.

"Pluggable Look & Feel" allows your program to emulate the look and feel of various operating environments. You can even do all sorts of fancy things, like dynamically changing the look and feel while the program is executing. However, you generally just want to do one of two things: either select the "cross platform" look and feel (which is Swing's "metal"), or select the look and feel for the system you are currently on so your Java program looks like it was created specifically for that system (this is almost certainly the best choice in most cases, to avoid confounding the user). The code to select either of these behaviors is quite simple, but you must execute it before you create any visual components, because the components will be made based on the current look and feel, and will not be changed just because you happen to change the look and feel midway during the program (that process is more complicated and uncommon, and is relegated to Swing-specific books).

Actually, if you want to use the cross-platform ("metal") look and feel that is characteristic of Swing programs, you don't have to do anything-it's the default. But if you want instead to use the current operating environment's look and feel, you just insert the following code, typically at the beginning of your main( ), but at least before any components are added:

try {
	UIManager.setLookAndFeel(UIManager.
		getSystemLookAndFeelClassName());
} catch(Exception e) {
	throw new RuntimeException(e);
}

You don't need anything in the catch clause because the UIManager will default to the cross-platform look and feel if your attempts to set up any of the alternatives fail. However, during debugging the exception can be quite useful, so you may at least want see some results via the catch clause.

Here is a program that takes a command-line argument to select a look and feel, and shows how several different components look under the chosen look and feel:

//: c14:LookAndFeel.java
// Selecting different looks & feels.
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.bruceeckel.swing.*;
 
public class LookAndFeel extends JFrame {
	private String[] choices = {
		"eeny","meeny","Minnie","Mickey","Moe","Larry","Curly"
	};
	private Component[] samples = {
		new JButton("JButton"),
		new JTextField("JTextField"),
		new JLabel("JLabel"),
		new JCheckBox("JCheckBox"),
		new JRadioButton("Radio"),
		new JComboBox(choices),
		new JList(choices),
	};
	public LookAndFeel() {
		super("Look And Feel");
		Container cp = getContentPane();
		cp.setLayout(new FlowLayout());
		for(int i = 0; i < samples.length; i++)
			cp.add(samples[i]);
	}
	private static void usageError() {
		System.out.println(
			"Usage:LookAndFeel [cross|system|motif]");
		System.exit(1);
	}
	public static void main(String[] args) {
		if(args.length == 0) usageError();
		if(args[0].equals("cross")) {
			try {
				UIManager.setLookAndFeel(UIManager.
				getCrossPlatformLookAndFeelClassName());
			} catch(Exception e) {
				e.printStackTrace();
			}
		} else if(args[0].equals("system")) {
			try {
				UIManager.setLookAndFeel(UIManager.
					getSystemLookAndFeelClassName());
			} catch(Exception e) {
				e.printStackTrace();
			}
		} else if(args[0].equals("motif")) {
			try {
				UIManager.setLookAndFeel("com.sun.java."+
					"swing.plaf.motif.MotifLookAndFeel");
			} catch(Exception e) {
				e.printStackTrace();
			}
		} else usageError();
		// Note the look & feel must be set before
		// any components are created.
		Console.run(new LookAndFeel(), 300, 200);
	}
} ///:~