For tradition’s sake, let’s write a NotHelloWorld program as an applet. Before we do that, we want to point out that, from a programming point of view, an applet isn’t very strange. An applet is simply a Java class that extends the java.applet.Applet class. Note that although the java.applet package is not part of the AWT package, an applet is an AWT component, as the inheritance chain shown in Figure 10–1 illustrates. In this book, we will use Swing to implement applets. All of our applets will extend the JApplet class, the superclass for Swing applets. As you can see in Figure 10–1, JApplet is an immediate subclass of the ordinary Applet class.

Figure 10–1. Applet inheritance hierarchy

Note

If your applet contains Swing components, you must extend the JApplet class. Swing components inside a plain Applet don’t paint correctly.

Example 10–1 shows the code for an applet version of “Not Hello World”.

Notice how similar this is to the corresponding program from Chapter 7. However, because the applet lives inside a web page, there is no need to specify a method for exiting the applet.

 1. /*
 2.   The following HTML tags are required to display this applet in a browser:
 3.   <applet code="NotHelloWorldApplet.class" width="300" height="100">
 4.   </applet>
 5. */
 6.
 7. import javax.swing.*;
 8.
 9. public class NotHelloWorldApplet extends JApplet
10. {
11.    public void init()
12.    {
13.       JLabel label = new JLabel("Not a Hello, World applet", SwingConstants.CENTER);
14.       add(label);
15.    }
16. }

To execute the applet, you carry out two steps:

It is customary (but not necessary) to give the HTML file the same name as that of the applet class inside. So, following this tradition, we call the file NotHelloWorldApplet.html. Here are the contents of the file:

<applet code="NotHelloWorldApplet.class" width="300" height="300">
</applet>

Before you view the applet in a browser, it is a good idea to test it in the applet viewer program that is a part of the JDK. To use the applet viewer in our example, enter

appletviewer NotHelloWorldApplet.html

at the command line. The command-line argument for the applet viewer program is the name of the HTML file, not the class file. Figure 10–2 shows the applet viewer displaying this applet.

Figure 10–2. Viewing an applet in the applet viewer

Tip

You can also run applets from inside your editor or integrated environment. In Emacs, select JDE -> Run Applet from the menu. In Eclipse, you select Run -> Run as -> Java Applet from the menu.

Tip

Here is a weird trick to avoid the additional HTML file. Add an applet tag as a comment inside the source file:

/*
  <applet code="MyApplet.class" width="300" height="300">
  </applet>
*/
public class MyApplet extends JApplet
. . .

Then run the applet viewer with the source file as its command-line argument:

appletviewer NotHelloWorldApplet.java

We aren’t recommending this as standard practice, but it can come in handy if you want to minimize the number of files that you need to worry about during testing.

The applet viewer is good for the first stage of testing, but at some point you need to run your applets in a browser to see them in the same way a user might use them. In particular, the applet viewer program shows you only the applet, not the surrounding HTML text. If an HTML file contains multiple applet tags, the applet viewer pops up multiple windows.

To properly view the applet, you need a Java 2-enabled browser. After installing and configuring the Java Plug-in, simply load the HTML file into the browser (see Figure 10–3). If the applet doesn’t show up, your browser probably uses its built-in virtual machine, and you need to configure it to use the Java Plug-in instead.

Figure 10–3. Viewing an applet in a browser

Tip

If you make a change to your applet and recompile, you need to restart the browser so that it loads the new class files. Simply refreshing the HTML page will not load the new code. This is a hassle when you are debugging an applet. You can avoid the painful browser restart if you launch the Java console and issue the x command, which clears the classloader cache. Then you can reload the HTML page, and the new applet code is used. You can launch the Java console in Netscape and Mozilla from the menu. Under Windows, open the Java Plug-in console in the Windows control panel and request that the Java console be displayed.

Note

For older browsers (in particular, Netscape 4), you need to replace the applet tags with special object or embed tags in order to cause the browser to load the Plug-In. The page http://java.sun.com/j2se/5.0/docs/guide/plugin/developer_guide/html_converter.html describes this process and lets you download a tool that automates the web page conversion. With modern browsers, the conversion is no longer necessary.

It is easy to convert a graphical Java application (that is, an application that uses the AWT and that you can start with the java program launcher) into an applet that you can embed in a web page. Essentially, all of the user interface code can stay the same.

Here are the specific steps for converting an application to an applet.

Note

On page 520, you will see how to implement a program that is both an applet and an application.

As an example of this transformation, we will change the calculator application from Chapter 9 into an applet. In Figure 10–4, you can see how it looks, sitting inside a web page.

Figure 10–4. A calculator applet

Example 10–2 shows the HTML page. Note that there is some text in addition to the applet tags.

1. <html>
2.    <head><title>A Calculator</title></head>
3.    <body>
4.       <p>Here is a calculator, just in case you can't find yours.</p>
5.       <applet code="CalculatorApplet.class" width="180" height="180">
6.       </applet>
7.    </body>
8. </html>

Example 10–3 is the code for the applet. We introduced a subclass of JApplet, placed the initialization code into the init method, and removed the calls to setTitle, setSize, setDefaultCloseOperation, and setVisible. The CalculatorPanel class is taken from Chapter 9, and its code is omitted.

 1. import java.awt.*;
 2. import javax.swing.*;
 3.
 4. public class CalculatorApplet extends JApplet
 5. {
 6.    public void init()
 7.    {
 8.       CalculatorPanel panel = new CalculatorPanel();
 9.       add(panel);
10.    }
11. }

java.applet.Applet 1.0

Four methods in the Applet class give you the framework on which you build any serious applet: init, start, stop, and destroy. What follows is a short description of these methods, occasions when these methods are called, and the code you should place into them.

java.applet.Applet 1.0

Because applets are designed to be loaded from a remote site and then executed locally, security becomes vital. If a user enables Java in the browser, the browser will download all the applet code on the web page and execute it immediately. The user never gets a chance to confirm or to stop individual applets from running. For this reason, applets (unlike applications) are restricted in what they can do. The applet security manager throws a SecurityException whenever an applet attempts to violate one of the access rules.

What can applets do on all platforms? They can show images and play sounds, get keystrokes and mouse clicks from the user, and send user input back to the host from which they were loaded. That is enough functionality to show facts and figures or to get user input for placing an order. The restricted execution environment for applets is often called the “sandbox.” Applets playing in the “sandbox” cannot alter the user’s system or spy on it. In this chapter, we look only at applets that run inside the sandbox.

In particular, when running in the sandbox,

All this is possible only because applets are executed by the Java virtual machine and not directly by the CPU on the user’s computer. Because the virtual machine checks all critical instructions and program areas, a hostile (or poorly written) applet will almost certainly not be able to crash the computer, overwrite system memory, or change the privileges granted by the operating system.

These restrictions are too strong for some situations. For example, on a corporate intranet, you can certainly imagine an applet wanting to access local files. To allow for different levels of security under different situations, you can use signed applets. A signed applet carries with it a certificate that indicates the identity of the signer. Cryptographic techniques ensure that such a certificate cannot be forged. If you trust the signer, you can choose to give the applet additional rights. (We cover code signing in Volume 2.)

The point is that if you trust the signer of the applet, you can tell the browser to give the applet more privileges. You can, for example, give applets in your corporate intranet a higher level of trust than those from www.cracker.com. The configurable Java security model allows the continuum of privilege levels you need. You can give completely trusted applets the same privilege levels as local applications. Programs from vendors that are known to be somewhat flaky can be given access to some, but not all, privileges. Unknown applets can be restricted to the sandbox.

Note

Java Web Start applications (discussed later in this chapter) have a slightly more versatile sandbox. Some system resources can be accessed, provided the program user agrees.

To sum up, Java has three separate mechanisms for enforcing security:

Note

In contrast, the security model of the ActiveX technology by Microsoft relies solely on the third option. If you want to run an ActiveX control at all, you must trust it completely. That model works fine when you deal with a small number of trusted suppliers, but it simply does not scale up to the World Wide Web. If you use Internet Explorer, you will see the ActiveX mechanism at work. You’ll need to accept Sun’s certificate to install the Java Plug-in on Internet Explorer. The certificate tells you that the code came from Sun. It doesn’t tell you anything about the quality of the code. Once you accept the installation, the program runs without any further security checks.

An applet sits embedded in a web page, in a frame whose width is given by the width and height attributes in the applet tag. This can be quite limiting. Many programmers wonder whether they can have a pop-up window to make better use of the available space. It is indeed possible to create a pop-up frame. Here is a simple applet with a single button labeled Calculator. When you click on the button, a calculator pops up in a separate window.

The pop-up is easy to do. Simply use a JFrame, but don’t call setDefaultCloseOperation.

frame = new CalculatorFrame();
frame.setTitle("Calculator");
frame.setSize(200, 200);

When the user clicks the button, toggle the frame so that it is shown if it isn’t visible and hidden if it is. When you click on the calculator button, the dialog box pops up and floats over the web page. When you click on the button again, the calculator goes away.

JButton calcButton = new JButton("Calculator");
calcButton.addActionListener(new
   ActionListener()
   {

   public void actionPerformed(ActionEvent evt)
   {
      frame.setVisible(!frame.isVisible());
   }
});

There is, however, an issue that you need to consider before you put this applet on your web page. To see how the calculator looks to a potential user, load the web page from a browser, not the applet viewer. The calculator will be surrounded by a border with a warning message (see Figure 10–5).

Figure 10–5. A window that pops up over a browser

In early browser versions, that message was very ominous: “Untrusted Java Applet Window”. Every successive version of the JDK watered down the warning a bit—“Unauthenticated Java Applet Window”, or “Warning: Java Applet Window”. Now it is simply “Java Applet Window”.

This message is a security feature of all web browsers. The browser wants to make sure that your applet does not launch a window that the user might mistake for a local application. The fear is that an unsuspecting user could visit a web page, which automatically launches the applets on it, and mistakenly type in a password or credit card number, which the applet could send back to its host.

To avoid any possibility of shenanigans like this, all pop-up windows launched by an applet bear a warning label. You can configure the Java Plug-in to omit the warning message for pop-up windows that are spawned by signed applets.

Example 10–4 shows the code for the PopupCalculatorApplet class.

 1. import java.awt.*;
 2. import java.awt.event.*;
 3. import javax.swing.*;
 4.
 5. public class PopupCalculatorApplet extends JApplet
 6. {
 7.    public void init()
 8.    {
 9.       // create a frame with a calculator panel
10.
11.       final JFrame frame = new JFrame();
12.       frame.setTitle("Calculator");
13.       frame.setSize(200, 200);
14.       frame.add(new CalculatorPanel());
15.
16.       // add a button that pops up or hides the calculator
17.
18.       JButton calcButton = new JButton("Calculator");
19.       add(calcButton);
20.
21.       calcButton.addActionListener(new
22.          ActionListener()
23.          {
24.             public void actionPerformed(ActionEvent event)
25.             {
26.                frame.setVisible(!frame.isVisible());
27.             }
28.          });
29.    }
30. }

What follows are short discussions of the various attributes that you can (or must) use within the applet tag to position your applet. Readers familiar with HTML will recognize that many of these attributes are similar to those used with the img tag for image placement on a web page.

The following applet attributes tell the browser how to locate the applet code; here are short descriptions.

Note

In http://www.javaworld.com/javatips/jw-javatip80.html, Francis Lu uses JavaScript-to-Java communication to solve an age-old problem: to resize an applet so that it isn’t bound by hardcoded width and height attributes. This is a good example of the integration between Java and JavaScript. It also shows how messy it is to write JavaScript that works on multiple browsers.

If a web page containing an applet tag is viewed by a browser that is not aware of Java applets, then the browser ignores the unknown applet and param tags. All text between the <applet> and </applet> tags is displayed by the browser. Conversely, Java-aware browsers do not display any text between the <applet> and </applet> tags. You can display messages inside these tags for those poor folks that use a prehistoric browser. For example,

<applet code="CalculatorApplet.class" width="100" height="150">
   If your browser could show Java, you would see a calculator here.
</applet>

Of course, nowadays most browsers know about Java, but Java may be deactivated, perhaps by the user or by a paranoid system administrator. You can then use the alt attribute to display a message to these unfortunate souls.

<applet code="CalculatorApplet.class" width="100" height="150"
   alt="If your browser could show Java, you would see a calculator here">

The object tag is part of the HTML 4.0 standard, and the W3 consortium suggests that people use it instead of the applet tag. There are 35 different attributes to the object tag, most of which (such as onkeydown) are relevant only to people writing Dynamic HTML. The various positioning attributes such as align and height work exactly as they did for the applet tag. The key attribute in the object tag for your Java applets is the classid attribute. This attribute specifies the location of the object. Of course, object tags can load different kinds of objects, such as Java applets or ActiveX components like the Java Plug-in itself. In the codetype attribute, you specify the nature of the object. For example, Java applets have a code type of application/java. Here is an object tag to load a Java applet:

<object
   codetype="application/java"
   classid="java:CalculatorApplet.class"
   width="100" height="150">

Note that the classid attribute can be followed by a codebase attribute that works exactly as it did with the applet tag.

Just as applications can use command-line information, applets can use parameters that are embedded in the HTML file. This is done by the HTML tag called param along with attributes that you define. For example, suppose you want to let the web page determine the style of the font to use in your applet. You could use the following HTML tags:

<applet code="FontParamApplet.class" width="200" height="200">
   <param name="font" value="Helvetica"/>
</applet>

You then pick up the value of the parameter, using the getParameter method of the Applet class, as in the following example:

public class FontParamApplet extends JApplet
{
   public void init()
   {
      String fontName = getParameter("font");
      . . .
   }
   . . .
}

Note

You can call the getParameter method only in the init method of the applet, not in the constructor. When the applet constructor is executed, the parameters are not yet prepared. Because the layout of most nontrivial applets is determined by parameters, we recommend that you don’t supply constructors to applets. Simply place all initialization code into the init method.

Parameters are always returned as strings. You need to convert the string to a numeric type if that is what is called for. You do this in the standard way by using the appropriate method, such as parseInt of the Integer class.

For example, if we wanted to add a size parameter for the font, then the HTML code might look like this:

<applet code="FontParamApplet.class" width="200" height="200">
   <param name="font" value="Helvetica"/>
   <param name="size" value="24"/>
</applet>

The following source code shows how to read the integer parameter.

public class FontParamApplet extends JApplet
{
   public void init()
   {
      String fontName = getParameter("font");
      int fontSize = Integer.parseInt(getParameter("size"));
      . . .
    }
}

Note

The strings used when you define the parameters with the param tag and those used in the getParameter method must match exactly. In particular, both are case sensitive.

In addition to ensuring that the parameters match in your code, you should find out whether or not the size parameter was left out. You do this with a simple test for null. For example:

int fontsize;
String sizeString = getParameter("size");
if (sizeString == null) fontSize = 12;
else fontSize = Integer.parseInt(sizeString);

Here is a useful applet that uses parameters extensively. The applet draws a bar chart, shown in Figure 10–7.

Figure 10–7. A chart applet

This applet takes the labels and the heights of the bars from the param values in the HTML file. Here is what the HTML file for Figure 10–7 looks like:

<applet code="Chart.class" width="400" height="300">
   <param name="title" value="Diameters of the Planets"/>
   <param name="values" value="9"/>
   <param name="name.1" value="Mercury"/>
   <param name="name.2" value="Venus"/>
   <param name="name.3" value="Earth"/>
   <param name="name.4" value="Mars"/>
   <param name="name.5" value="Jupiter"/>
   <param name="name.6" value="Saturn"/>
   <param name="name.7" value="Uranus"/>
   <param name="name.8" value="Neptune"/>
   <param name="name.9" value="Pluto"/>
   <param name="value.1" value="3100"/>
   <param name="value.2" value="7500"/>
   <param name="value.3" value="8000"/>
   <param name="value.4" value="4200"/>
   <param name="value.5" value="88000"/>
   <param name="value.6" value="71000"/>
   <param name="value.7" value="32000"/>
   <param name="value.8" value="30600"/>
   <param name="value.9" value="1430"/>
</applet>

You could have set up an array of strings and an array of numbers in the applet, but there are two advantages to using the parameter mechanism instead. You can have multiple copies of the same applet on your web page, showing different graphs: just put two applet tags with different sets of parameters on the page. And you can change the data that you want to chart. Admittedly, the diameters of the planets will stay the same for quite some time, but suppose your web page contains a chart of weekly sales data. It is easy to update the web page because it is plain text. Editing and recompiling a Java file weekly is more tedious.

In fact, there are commercial JavaBeans components (beans) that make much fancier graphs than the one in our chart applet. If you buy one, you can drop it into your web page and feed it parameters without ever needing to know how the applet renders the graphs.

Example 10–5 is the source code of our chart applet. Note that the init method reads the parameters, and the paintComponent method draws the chart.

  1. import java.awt.*;
  2. import java.awt.font.*;
  3. import java.awt.geom.*;
  4. import javax.swing.*;
  5.
  6. public class Chart extends JApplet
  7. {
  8.    public void init()
  9.    {
 10.       String v = getParameter("values");
 11.       if (v == null) return;
 12.       int n = Integer.parseInt(v);
 13.       double[] values = new double[n];
 14.       String[] names = new String[n];
 15.       for (int i = 0; i < n; i++)
 16.       {
 17.          values[i] = Double.parseDouble(getParameter("value." + (i + 1)));
 18.          names[i] = getParameter("name." + (i + 1));
 19.       }
 20.
 21.       add(new ChartPanel(values, names, getParameter("title")));
 22.    }
 23. }
 24.
 25. /**
 26.    A panel that draws a bar chart.
 27. */
 28. class ChartPanel extends JPanel
 29. {
 30.    /**
 31.        Constructs a ChartPanel.
 32.        @param v the array of values for the chart
 33.        @param n the array of names for the values
 34.        @param t the title of the chart
 35.    */
 36.    public ChartPanel(double[] v, String[] n, String t)
 37.    {
 38.       values = v;
 39.       names = n;
 40.       title = t;
 41.    }
 42.
 43.    public void paintComponent(Graphics g)
 44.    {
 45.       super.paintComponent(g);
 46.       Graphics2D g2 = (Graphics2D) g;
 47.
 48.       // compute the minimum and maximum values
 49.       if (values == null) return;
 50.       double minValue = 0;
 51.       double maxValue = 0;
 52.       for (double v : values)
 53.       {
 54.          if (minValue > v) minValue = v;
 55.          if (maxValue < v) maxValue = v;
 56.       }
 57.       if (maxValue == minValue) return;
 58.
 59.       int panelWidth = getWidth();
 60.       int panelHeight = getHeight();
 61.
 62.       Font titleFont = new Font("SansSerif", Font.BOLD, 20);
 63.       Font labelFont = new Font("SansSerif", Font.PLAIN, 10);
 64.
 65.       // compute the extent of the title
 66.       FontRenderContext context = g2.getFontRenderContext();
 67.       Rectangle2D titleBounds = titleFont.getStringBounds(title, context);
 68.       double titleWidth = titleBounds.getWidth();
 69.       double top = titleBounds.getHeight();
 70.
 71.       // draw the title
 72.       double y = -titleBounds.getY(); // ascent
 73.       double x = (panelWidth - titleWidth) / 2;
 74.       g2.setFont(titleFont);
 75.       g2.drawString(title, (float) x, (float) y);
 76.
 77.       // compute the extent of the bar labels
 78.       LineMetrics labelMetrics = labelFont.getLineMetrics("", context);
 79.       double bottom = labelMetrics.getHeight();
 80.
 81.       y = panelHeight - labelMetrics.getDescent();
 82.       g2.setFont(labelFont);
 83.
 84.       // get the scale factor and width for the bars
 85.       double scale = (panelHeight - top - bottom) / (maxValue - minValue);
 86.       int barWidth = panelWidth / values.length;
 87.
 88.       // draw the bars
 89.       for (int i = 0; i < values.length; i++)
 90.       {
 91.          // get the coordinates of the bar rectangle
 92.          double x1 = i * barWidth + 1;
 93.          double y1 = top;
 94.          double height = values[i] * scale;
 95.          if (values[i] >= 0)
 96.             y1 += (maxValue - values[i]) * scale;
 97.          else
 98.          {
 99.             y1 += maxValue * scale;
100.             height = -height;
101.          }
102.
103.          // fill the bar and draw the bar outline
104.          Rectangle2D rect = new Rectangle2D.Double(x1, y1, barWidth - 2, height);
105.          g2.setPaint(Color.RED);
106.          g2.fill(rect);
107.          g2.setPaint(Color.BLACK);
108.          g2.draw(rect);
109.
110.          // draw the centered label below the bar
111.          Rectangle2D labelBounds = labelFont.getStringBounds(names[i], context);
112.
113.          double labelWidth = labelBounds.getWidth();
114.          x = x1 + (barWidth - labelWidth) / 2;
115.          g2.drawString(names[i], (float) x, (float) y);
116.       }
117.    }
118.
119.    private double[] values;
120.    private String[] names;
121.    private String title;
122. }

java.applet.Applet 1.0

A URL is really nothing more than a description of a resource on the Internet. For example, "http://java.sun.com/index.html" tells the browser to use the hypertext transfer protocol on the file index.html located at java.sun.com. Java has the class URL that encapsulates URLs. The simplest way to make a URL is to give a string to the URL constructor:

URL u = new URL("http://java.sun.com/index.html");

This is called an absolute URL because we specify the entire resource name. Another useful URL constructor is a relative URL.

URL data = new URL(u, "data/planets.dat");

This specifies the file planets.dat, located in the data subdirectory of the URL u.

A common way of obtaining a URL is to ask an applet where it came from, in particular:

To find the former, use the getDocumentBase method; to find the latter, use getCodeBase.

Note

In prior versions of the JDK, there was considerable confusion about these methods—see bug #4456393 on the Java bug parade (http://bugs.sun.com/bugdatabase/index.jsp). The documentation has finally been clarified in JDK 5.0.

Note

You can access secure web pages (https URLs) from applets and through the Java Plug-in—see http://java.sun.com/products/plugin/1.3/docs/https.html. This uses the SSL capabilities of the underlying browser.

You can retrieve images and audio files with the getImage and getAudioClip methods. For example:

Image cat = getImage(getCodeBase(), "images/cat.gif");
AudioClip meow = getAudioClip(getCodeBase(), "audio/meow.au");

Here, we use the getCodeBase method that returns the URL from which your applet code is loaded. The second argument of the method calls specifies where the image or audio clip is located, relative to the base document.

Note

The images and audio clips must be located on the same server that hosts the applet code. For security reasons, applets cannot access files on another server (“applets can only phone home”).

You saw in Chapter 7 how to display an image. To play an audio clip, simply invoke its play method. You can also call the play method of the Applet class without first loading the audio clip.

play(getCodeBase(), "audio/meow.au");

For faster downloading, multimedia objects can be stored in JAR files (see the section below). The getImage and getAudioClip/play methods automatically search the JAR files of the applet. If the image or audio file is contained in the JAR file, it is loaded immediately. Otherwise, the browser requests it from the web server.

java.net.URL 1.0

java.applet.Applet 1.0

A web page can contain more than one applet. If a web page contains multiple applets from the same codebase, they can communicate with each other. Naturally, this is an advanced technique that you probably will not need very often.

If you give name attributes to each applet in the HTML file, you can use the getApplet method of the AppletContext interface to get a reference to the applet. For example, if your HTML file contains the tag

<applet code="Chart.class" width="100" height="100" name="Chart1">

then the call

Applet chart1 = getAppletContext().getApplet("Chart1");

gives you a reference to the applet. What can you do with the reference? Provided you give the Chart class a method to accept new data and redraw the chart, you can call this method by making the appropriate cast.

((Chart) chart1).setData(3, "Earth", 9000);

You can also list all applets on a web page, whether or not they have a name attribute. The getApplets method returns an enumeration object. (You learn more about enumeration objects in Volume 2.) Here is a loop that prints the class names of all applets on the current page.

Enumeration e = getAppletContext().getApplets();
while (e.hasMoreElements())
{
   Object a = e.nextElement();
   System.out.println(a.getClass().getName());
}

An applet cannot communicate with an applet on a different web page.

You have access to two areas of the ambient browsers: the status line and the web page display area. Both use methods of the AppletContext class.

You can display a string in the status line at the bottom of the browser with the showStatus message, for example,

showStatus("Loading data . . . please wait");

Tip

In our experience, showStatus is of limited use. The browser is also using the status line, and, more often than not, it will overwrite your precious message with chatter like “Applet running.” Use the status line for fluff messages like “Loading data . . . please wait,” but not for something that the user cannot afford to miss.

You can tell the browser to show a different web page with the showDocument method. There are several ways to do this. The simplest is with a call to showDocument with one argument, the URL you want to show.

URL u = new URL("http://java.sun.com/index.html");
getAppletContext().showDocument(u);

The problem with this call is that it opens the new web page in the same window as your current page, thereby displacing your applet. To return to your applet, the user must click the Back button of the browser.

You can tell the browser to show the document in another window by giving a second parameter in the call to showDocument (see Table 10–2). If you supply the special string "_blank", the browser opens a new window with the document, instead of displacing the current document. More important, if you take advantage of the frame feature in HTML, you can split a browser window into multiple frames, each of which has a name. You can put your applet into one frame and have it show documents in other frames. We show you an example of how to do this in the next section.

Note

Sun’s applet viewer does not show web pages. The showDocument method is ignored in the applet viewer.

java.applet.Applet 1.2

java.applet.AppletContext 1.2

This applet takes advantage of the frame feature in HTML. We divide the screen vertically into two frames. The left frame contains a Java applet that shows a list of bookmarks. When you select any of the bookmarks, the applet tells the browser to display the corresponding web page (see Figure 10–8).

Figure 10–8. A bookmark applet

Example 10–6 shows the HTML file that defines the frames.

 1. <html>
 2.    <head>
 3.       <title>Bookmark Applet</title>
 4.    </head>
 5.    <frameset cols="320,*">
 6.       <frame name="left" src="Left.html"
 7.          marginheight="2" marginwidth="2"
 8.          scrolling="no" noresize="noresize"/>
 9.       <frame name="right" src="Right.html"
10.          marginheight="2" marginwidth="2"
11.          scrolling="yes" noresize="noresize"/>
12.    </frameset>
13. </html>

We do not go over the exact syntax elements. What is important is that each frame has two essential features: a name (given by the name attribute) and a URL (given by the src attribute). We could not think of any good names for the frames, so we simply named them "left" and "right".

The left frame uses the Left.html file (Example 10–7), which loads the applet into the left frame. It simply specifies the applet and the bookmarks. You can customize this file for your own web page by changing the bookmarks.

 1. <html>
 2.    <head><title>A Bookmark Applet</title></head>
 3.    <body>
 4.       <p>
 5.          Click on one of the radio buttons.
 6.          The corresponding web page
 7.          will be displayed in the frame on the right.
 8.       </p>
 9.       <applet code="Bookmark.class" width="290" height="300">
10.          <param name="link.1" value="http://java.sun.com"/>
11.          <param name="link.2" value="http://java.net"/>
12.          <param name="link.3" value="http://linuxtoday.com"/>
13.          <param name="link.4" value="http://www.horstmann.com"/>
14.          <param name="link.5" value="http://www.phptr.com"/>
15.          <param name="link.6" value="http://usps.com"/>
16.          <param name="link.7" value="http://www.cafeaulait.org"/>
17.       </applet>
18.    </body>
19. </html>

The right frame loads a dummy file that we called Right.html (Example 10–8). (Some browsers do not approve when you leave a frame blank, so we supply a dummy file for starters.)

1. <html>
2.    <head><title>Web pages will be displayed here.</title></head>
3.    <body>
4.       <p>Click on one of the radio buttons to the left.
5.       The corresponding web page will be displayed here.</p>
6.    </body>
7. </html>

The code for the bookmark applet that is given in Example 10–9 is simple. It reads the values of the parameters link.1, link.2, and so on, and turns each of them into a radio button. When you select one of the radio buttons, the showDocument method displays the corresponding page in the right frame.

 1. import java.awt.*;
 2. import java.awt.event.*;
 3. import java.applet.*;
 4. import java.util.*;
 5. import java.net.*;
 6. import javax.swing.*;
 7.
 8. public class Bookmark extends JApplet
 9. {
10.    public void init()
11.    {
12.       Box box = Box.createVerticalBox();
13.       ButtonGroup group = new ButtonGroup();
14.
15.       int i = 1;
16.       String urlString;
17.
18.       // read all link.n parameters
19.       while ((urlString = getParameter("link." + i)) != null)
20.       {
21.
22.          try
23.          {
24.             final URL url = new URL(urlString);
25.
26.             // make a radio button for each link
27.             JRadioButton button = new JRadioButton(urlString);
28.             box.add(button);
29.             group.add(button);
30.
31.             // selecting the radio button shows the URL in the "right" frame
32.             button.addActionListener(new
33.                ActionListener()
34.                {
35.                   public void actionPerformed(ActionEvent event)
36.                   {
37.                      AppletContext context = getAppletContext();
38.                      context.showDocument(url, "right");
39.                   }
40.                });
41.          }
42.          catch (MalformedURLException e)
43.          {
44.             e.printStackTrace();
45.          }
46.
47.          i++;
48.       }
49.
50.       add(box);
51.    }
52. }

Quite a few years ago, a Saturday Night Live skit poking fun at a television commercial showed a couple arguing about a white, gelatinous substance. The husband said, “It’s a dessert topping.” The wife said, “It’s a floor wax.” And the announcer concluded triumphantly, “It’s both!”

Well, in this section, we show you how to write a Java program that is both an applet and an application. That is, you can load the program with the applet viewer or a browser, or you can start it from the command line with the java program launcher. We are not sure how often this comes up—we found it interesting that this could be done at all and thought you would, too.

The screen shots in Figures 10–9 and 10–10 show the same program, launched from the command line as an application and viewed inside the applet viewer as an applet.

Figure 10–9. The calculator as an application

Figure 10–10. The calculator as an applet

Let us see how this can be done. Every class file has exactly one public class. For the applet viewer to launch it, that class must derive from Applet. For Java to start the application, it must have a static main method. So far, we have

class MyAppletApplication extends JApplet
{
   public void init() { . . . }
   . . .
   public static void main(String[] args) { . . . }
}

What can we put into main? Normally, we make an object of the class and invoke setVisible(true) on it. But this case is not so simple. You cannot call setVisible on a naked applet. The applet must be placed inside a frame.

To provide a frame, we create the class AppletFrame, like this:

public class AppletFrame extends JFrame
{
   public AppletFrame(Applet anApplet)
   {
      applet = anApplet;
      add(applet);
      . . .
   }
   . . .
}

The constructor of the frame puts the applet (which is a Component) inside the content pane of the frame.

In the main method of the applet/application, we construct and show an AppletFrame.

class MyAppletApplication extends JApplet
{
   public void init() { . . . }
   . . .
   public static void main(String args[])
   {
      AppletFrame frame = new AppletFrame(new MyAppletApplication());
      frame.setTitle("MyAppletApplication");
      frame.setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      frame.setVisible(true);
   }
}

When the applet starts, its init and start methods must be called. We achieve this by overriding the setVisible method of the AppletFrame class:

public void setVisible(boolean b)
{
   if (b)
   {
      applet.init();
      super.setVisible(true);
      applet.start();
   }
   else
   {
      applet.stop();
      super.setVisible(false);
      applet.destroy();
   }
}

There is one catch. If the program is started with the Java launcher and not the applet viewer, and it calls getAppletContext, it gets a null pointer because it has not been launched inside a browser. This causes a runtime crash whenever we have code like

getAppletContext().showStatus(message);

While we do not want to write a full-fledged browser, we do need to supply the bare minimum to make calls like this work. The call displays no message, but at least it will not crash the program. It turns out that all we need to do is implement two interfaces: AppletStub and AppletContext.

You have already seen applet contexts in action. They are responsible for fetching images and audio files and for displaying web pages. They can, however, politely refuse, and this is what our applet context will do. The major purpose of the AppletStub interface is to locate the applet context. Every applet has an applet stub (set with the setStub method of the Applet class).

In our case, AppletFrame implements both AppletStub and AppletContext. We supply the bare minimum functionality that is necessary to implement these two interfaces.

public class AppletFrame extends JFrame
   implements AppletStub, AppletContext
{
   . . .
   // AppletStub methods
   public boolean isActive() { return true; }
   public URL getDocumentBase() { return null; }
   public URL getCodeBase() { return null; }
   public String getParameter(String name) { return ""; }
   public AppletContext getAppletContext() { return this; }
   public void appletResize(int width, int height) {}

   // AppletContext methods
   public AudioClip getAudioClip(URL url) { return null; }
   public Image getImage(URL url) { return null; }
   public Applet getApplet(String name) { return null; }
   public Enumeration getApplets() { return null; }
   public void showDocument(URL url) {}
   public void showDocument(URL url, String target) {}
   public void showStatus(String status) {}
   public void setStream(String key, InputStream stream) {}
   public InputStream getStream(String key) { return null; }
   public Iterator getStreamKeys() { return null; }
}

Note

When you compile this file with the JDK 1.3 compiler, you will get a warning that the class java.awt.Window also has a method called isActive that has package visibility. Because our class is not in the same package as the Window class, it cannot override the Window.isActive method. That is fine with us—we want to supply a new isActive method for the AppletStub interface. And, interestingly enough, it is entirely legal to add a new method with the same signature to the subclass. Whenever the object is accessed through a Window reference inside the java.awt package, the package-visible Window.isActive method is called. But whenever the call is made through an AppletFrame or AppletStub reference, the AppletFrame.isActive method is called.

Next, the constructor of the frame class calls setStub on the applet to make itself its stub.

public AppletFrame(Applet anApplet)
{
   applet = anApplet
   Container contentPane = getContentPane();
   contentPane.add(applet);
   applet.setStub(this);
}

One final twist is possible. Suppose we want to use the calculator as an applet and application simultaneously. Rather than moving the methods of the CalculatorApplet class into the CalculatorAppletApplication class, we will just use inheritance. Here is the code for the class that does this.

public class CalculatorAppletApplication extends CalculatorApplet
{
   public static void main(String args[])
   {
      AppletFrame frame = new AppletFrame(new CalculatorApplet());
      . . .
   }
}

You can do this with any applet, not just with the calculator applet. All you do is derive a class MyAppletApplication from your applet class and pass a new MyApplet() object to the AppletFrame in the main method. The result is a class that is both an applet and an application.

Just for fun, we use the previously mentioned trick of adding the applet tag as a comment to the source file. Then you can invoke the applet viewer with the source file without requiring an additional HTML file.

Examples 10–10 and 10–11 list the code. You need to copy the CalculatorApplet.java file into the same directory to compile the program. Try running both the applet and the application:

appletviewer CalculatorAppletApplication.java
java CalculatorAppletApplication

 1. import java.awt.*;
 2. import java.awt.event.*;
 3. import java.applet.*;
 4. import java.io.*;
 5. import java.net.*;
 6. import java.util.*;
 7. import javax.swing.*;
 8.
 9. public class AppletFrame extends JFrame
10.    implements AppletStub, AppletContext
11. {
12.    public AppletFrame(Applet anApplet)
13.    {
14.       applet = anApplet;
15.       add(applet);
16.       applet.setStub(this);
17.    }
18.
19.    public void setVisible(boolean b)
20.    {
21.       if (b)
22.       {
23.          applet.init();
24.          super.setVisible(true);
25.          applet.start();
26.       }
27.       else
28.       {
29.          applet.stop();
30.          super.setVisible(false);
31.          applet.destroy();
32.       }
33.    }
34.
35.    // AppletStub methods
36.    public boolean isActive() { return true; }
37.    public URL getDocumentBase() { return null; }
38.    public URL getCodeBase() { return null; }
39.    public String getParameter(String name) { return ""; }
40.    public AppletContext getAppletContext() { return this; }
41.    public void appletResize(int width, int height) {}
42.
43.    // AppletContext methods
44.    public AudioClip getAudioClip(URL url) { return null; }
45.    public Image getImage(URL url) { return null; }
46.    public Applet getApplet(String name) { return null; }
47.    public Enumeration getApplets() { return null; }
48.    public void showDocument(URL url) {}
49.    public void showDocument(URL url, String target) {}
50.    public void showStatus(String status) {}
51.    public void setStream(String key, InputStream stream) {}
52.    public InputStream getStream(String key) { return null; }
53.    public Iterator getStreamKeys() { return null; }
54.
55.    private Applet applet;
56. }

 1. /*
 2.   The applet viewer reads the tags below if you call it with
 3.       appletviewer CalculatorAppletApplication.java (!)
 4.   No separate HTML file is required.
 5.   <applet code="CalculatorAppletApplication.class" width="200" height="200">
 6.   </applet>
 7. */
 8.
 9. import javax.swing.*;
10.
11. public class CalculatorAppletApplication
12.    extends CalculatorApplet
13. // It's an applet. It's an application. It's BOTH!
14. {
15.    public static void main(String[] args)
16.    {
17.       AppletFrame frame = new AppletFrame(new CalculatorApplet());
18.       frame.setTitle("CalculatorAppletApplication");
19.       frame.setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
20.       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
21.       frame.setVisible(true);
22.    }
23.
24.    public static final int DEFAULT_WIDTH = 200;
25.    public static final int DEFAULT_HEIGHT = 200;
26. }

You can package application programs, program components (sometimes called “beans”—see Chapter 8 of Volume 2), and code libraries into JAR files. For example, the runtime library of the JDK is contained in a very large file rt.jar.

A JAR file is simply a ZIP file that contains classes, other files that a program may need (such as icon images), and a manifest file that describes special features of the archive.

The manifest file is called MANIFEST.MF and is located in a special META-INF subdirectory of the JAR file. The minimum legal manifest is quite boring: just

Manifest-Version: 1.0

Complex manifests can have many more entries. The manifest entries are grouped into sections. The first section in the manifest is called the main section. It applies to the whole JAR file. Subsequent entries can specify properties of named entities such as individual files, packages, or URLs. Those entries must begin with a Name entry. Sections are separated by blank lines. For example,

To edit the manifest, place the lines that you want to add to the manifest into a text file. Then run

For example, to make a new JAR file with a manifest, run:

jar cfm MyArchive.jar manifest.mf com/mycompany/mypkg/*.class

To add items to the manifest of an existing JAR file, place the additions into a text file and use a command such as

jar ufm MyArchive.jar manifest-additions.mf

See http://java.sun.com/j2se/5.0/docs/guide/jar/jar.html for more information on the JAR and manifest file formats.

To package an application, place all files that your application needs into a JAR file and then add a manifest entry that specifies the main class of your program—the class that you would normally specify when invoking the java program launcher.

Make a file, say, mainclass.mf, containing a line such as

Main-Class: com/mycompany/mypkg/MainAppClass

Caution

The last line in the manifest must end with a newline character. Otherwise, the manifest will not be read correctly. It is a common error to produce a text file containing just the Main-Class line without a line terminator.

Do not add a .class extension to the main class name. Then run the jar command:

Users can now simply start the program as

java -jar MyProgram.jar

Depending on the operating system configuration, you may be able to launch the application by double-clicking on the JAR file icon.

Classes that are used in both applets and applications often use associated data files, such as

In Java, such an associated file is called a resource.

Note

In Windows, the term “resource” has a more specialized meaning. Windows resources also consist of images, button labels, and so on, but they are attached to the executable file and accessed by a standard programming interface. In contrast, Java resources are stored as separate files, not as part of class files. And it is up to each class to access and interpret the resource data.

For example, consider a class, AboutPanel, that displays a message such as the one in Figure 10–11.

Figure 10–11. Displaying a resource from a JAR file

Of course, the book title and copyright year in the panel will change for the next edition of the book. To make it easy to track this change, we want to put the text inside a file and not hardcode it as a string.

But where should you put a file such as about.txt? Of course, it would be convenient if you simply placed it with the rest of the program files, for example, in a JAR file.

The class loader knows how to search for class files until it has located them somewhere on the class path, or in an archive, or on a web server. The resource mechanism gives you the same convenience for files that aren’t class files. Here are the necessary steps:

The point is that the class loader remembers how to locate the class and it can then search for the associated resource in the same location.

For example, to make an icon with the image file about.gif, do the following:

URL url = AboutPanel.class.getResource("about.gif");
ImageIcon icon = new ImageIcon(url);

That means “locate the about.gif file at the same place where you find AboutPanel.class.”

To read in the file about.txt, you can use similar commands:

URL url = AboutPanel.class.getResource("about.txt");
InputStream stream = url.openStream();

Because this combination is so common, there is a convenient shortcut method: getResourceAsStream returns an InputStream, not a URL.

InputStream stream = AboutPanel.class.getResourceAsStream("about.txt");

To read from this stream, you need to know how to process input (see Chapter 12 for details). In the sample program, we read the stream a line at a time with the following instructions:

InputStream stream = AboutPanel.class.getResourceAsStream("about.txt");
Scanner in = Scanner.create(stream);
while (in.hasNext())
   textArea.append(in.nextLine() + "
");

The Core Java example files include a JAR file named ResourceTest.jar that contains all the class files for this example and the resource files about.gif and about.txt. This demonstrates that the program locates the resource file in the same location as the class file, namely, inside the JAR file. Example 10–12 shows the source code.

Tip

As you saw earlier in this chapter, applets can locate image and audio files with the getImage and getAudioClip methods—these methods automatically search JAR files. But to load other files from a JAR file, applets still need the getResourceAsStream method.

Instead of placing a resource file inside the same directory as the class file, you can place it in a subdirectory. You can use a hierarchical resource name such as

data/text/about.txt

This is a relative resource name, and it is interpreted relative to the package of the class that is loading the resource. Note that you must always use the / separator, regardless of the directory separator on the system that actually stores the resource files. For example, on the Windows file system, the resource loader automatically translates / to separators.

A resource name starting with a / is called an absolute resource name. It is located in the same way that a class inside a package would be located. For example, a resource

/corejava/title.txt

is located in the corejava directory (which may be a subdirectory of the class path, inside a JAR file, or, for applets, on a web server).

Automating the loading of files is all that the resource loading feature does. There are no standard methods for interpreting the contents of a resource file. Each program must have its own way of interpreting the contents of its resource files.

Another common application of resources is the internationalization of programs. Language-dependent strings, such as messages and user interface labels, are stored in resource files, with one file for each language. The internationalization API, which is discussed in Chapter 10 of Volume 2, supports a standard method for organizing and accessing these localization files.

 1. import java.awt.*;
 2. import java.awt.event.*;
 3. import java.io.*;
 4. import java.net.*;
 5. import java.util.*;
 6. import javax.swing.*;
 7.
 8. public class ResourceTest
 9. {
10.    public static void main(String[] args)
11.    {
12.       ResourceTestFrame frame = new ResourceTestFrame();
13.       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14.       frame.setVisible(true);
15.    }
16. }
17.
18. /**
19.    A frame with a panel that has components demonstrating
20.    resource access from a JAR file.
21. */
22. class ResourceTestFrame extends JFrame
23. {
24.    public ResourceTestFrame()
25.    {
26.       setTitle("ResourceTest");
27.       setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);
28.       add(new AboutPanel());
29.    }
30.
31.    public static final int DEFAULT_WIDTH = 300;
32.    public static final int DEFAULT_HEIGHT = 300;
33. }
34.
35. /**
36.    A panel with a text area and an "About" button. Pressing
37.    the button fills the text area with text from a resource.
38. */
39. class AboutPanel extends JPanel
40. {
41.    public AboutPanel()
42.    {
43.       setLayout(new BorderLayout());
44.
45.       // add text area
46.       textArea = new JTextArea();
47.       add(new JScrollPane(textArea), BorderLayout.CENTER);
48.
49.       // add About button
50.       URL aboutURL = AboutPanel.class.getResource("about.gif");
51.       JButton aboutButton = new JButton("About", new ImageIcon(aboutURL));
52.       aboutButton.addActionListener(new AboutAction());
53.       add(aboutButton, BorderLayout.SOUTH);
54.    }
55.
56.    private JTextArea textArea;
57.
58.    private class AboutAction implements ActionListener
59.    {
60.       public void actionPerformed(ActionEvent event)
61.       {
62.          InputStream stream = AboutPanel.class.getResourceAsStream("about.txt");
63.          Scanner in = new Scanner(stream);
64.          while (in.hasNext())
65.             textArea.append(in.nextLine() + "
");
66.       }
67.    }
68. }

java.lang.Class 1.0

We mentioned in Chapter 4 that you can seal a Java language package to ensure that no further classes can add themselves to it. You would want to seal a package if you use package-visible classes, methods, and fields in your code. Without sealing, other classes can place themselves into the same package and thereby gain access to its package-visible features.

For example, if you seal the package com.mycompany.util, then no class outside the sealed archive can be defined with the statement

package com.mycompany.util;

To achieve this, you put all classes of the package into a JAR file. By default, packages in a JAR file are not sealed. You can change that global default by placing the line

Sealed: true

into the main section of the manifest. For each individual package, you can specify whether you want the package sealed or not, by adding another section to the JAR file manifest, like this:

Name: com/mycompany/util/
Sealed: true

Name: com/mycompany/misc/
Sealed: false

To seal a package, make a text file with the manifest instructions. Then run the jar command in the usual way:

For a Java Web Start application to be granted full access to the local machine, the application must be digitally signed. (See Chapter 9 of Volume 2 for more information on digital signatures.) Just as with applets, an unsigned Java Web Start application that is downloaded from the Internet is inherently risky and runs in a sandbox, with minimal access to the local computer. However, with minimal security privileges, the JNLP API provides application developers some tools for accessing local resources.

For example, there are services to load and save files, but they are quite restrictive. The application can’t look at the file system and it can’t specify file names. Instead, a file dialog is popped up, and the program user selects the file. Before the file dialog is popped up, the program user is alerted and must agree to proceed (see Figure 10–15). Furthermore, the API doesn’t actually give the program access to a File object. In particular, the application has no way of finding out the file location. Thus, programmers are given the tools to implement standard “file open” and “file save” actions, but as much system information as possible is hidden from untrusted applications.

Figure 10–15. A Java Web Start security advisory

The API provides the following services:

To access a service, you use the ServiceManager, like this:

FileSaveService service = (FileSaveService) ServiceManager.lookup("javax.jnlp
.FileSaveService");

This call throws an UnavailableServiceException if the service is not available.

Note

You must include the file javaws.jar in the class path if you want to compile programs that use the JNLP API. That file is included in the jre/lib subdirectory of the JDK.

We now discuss the most useful JNLP services. To save a file, you provide suggestions for the initial path name and file extensions for the file dialog, the data to be saved, and a suggested file name. For example,

service.saveFileDialog(".", new String[] { "txt" }, data, "calc.txt");

The data must be delivered in an InputStream. That can be somewhat tricky to arrange. The program in Example 10–13 uses the following strategy:

You will learn more about streams in Chapter 12. For now, you can just gloss over the details in the sample program.

To read data from a file, you use the FileOpenService instead. Its openFileDialog receives suggestions for the initial path name and file extensions for the file dialog and returns a FileContents object. You can then call the getInputStream method to read the file data. If the user didn’t choose a file, then the openFileDialog method returns null.

FileOpenService service = (FileOpenService) ServiceManager.lookup("javax.jnlp
.FileOpenService");
FileContents contents =  service.openFileDialog(".", new String[] { "txt" });
if (contents != null)
{
   InputStream in = contents.getInputStream();
   . . .
}

To display a document on the default browser (similar to the showDocument method of an applet), use the BasicService interface. Note that some systems (in particular, many UNIX and Linux systems) may not have a default browser.

BasicService service = (BasicService) ServiceManager.lookup("javax.jnlp.BasicService");
if (service.isWebBrowserSupported())
   service.showDocument(url);
else . . .

A rudimentary PersistenceService lets an application store small amounts of configuration information and retrieve it when the application runs again. This service is necessary because an untrusted application cannot specify a location for a configuration file.

The mechanism is similar to HTTP cookies. The persistent store uses URLs as keys. The URLs don’t have to point to a real web resource. The service simply uses them as a convenient hierarchical naming scheme. For any given URL key, an application can store arbitrary binary data. (The store may restrict the size of the data block.)

So that applications are isolated from each other, a particular application can only use URL keys that start with its codebase (as specified in the JNLP file). For example, if an application is downloaded from http://myserver.com/apps, then it can only use keys of the form http://myserver.com/apps/subkey1/subkey2/... Attempts to access other keys will fail.

An application can call the getCodeBase method of the BasicService to find its codebase.

You create a new key with the create method of the PersistenceService.

URL url = new URL(codeBase, "mykey");
service.create(url, maxSize);

To access the information associated with a particular key, call the get method. That method returns a FileContents object through which you can read and write the key data. For example,

FileContents contents = service.get(url);
InputStream in = contents.getInputStream();
OutputStream out = contents.getOutputStream(true); // true = overwrite

Unfortunately, there is no convenient way to find out whether a key already exists or whether you need to create it. You can hope that the key exists and call get. If the call throws a FileNotFoundException, then you need to create the key.

Note

Starting with JDK 5.0, both Java Web Start applications and applets can print, using the normal printing API. A security dialog pops up, asking the user for permission to access the printer. For more information on the printing API, turn to the Advanced AWT chapter in Volume 2.

The program in Example 10–13 is a simple enhancement of the calculator application. This calculator has a virtual paper tape that keeps track of all calculations. You can save and load the calculation history. To demonstrate the persistent store, the application lets you set the frame title. If you run the application again, it retrieves your title choice from the persistent store (see Figure 10–16).

  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import java.io.*;
  4. import java.net.*;
  5. import javax.swing.*;
  6. import javax.swing.text.*;
  7. import javax.jnlp.*;
  8.
  9. /**
 10.    A calculator with a calculation history that can be
 11.    deployed as a Java Web Start application.
 12. */
 13. public class WebStartCalculator
 14. {
 15.    public static void main(String[] args)
 16.    {
 17.       CalculatorFrame frame = new CalculatorFrame();
 18.       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 19.       frame.setVisible(true);
 20.    }
 21. }
 22.
 23. /**
 24.    A frame with a calculator panel and a menu to load and
 25.    save the calculator history.
 26. */
 27. class CalculatorFrame extends JFrame
 28. {
 29.    public CalculatorFrame()
 30.    {
 31.       setTitle();
 32.       panel = new CalculatorPanel();
 33.       add(panel);
 34.
 35.       JMenu fileMenu = new JMenu("File");
 36.
 37.       JMenuItem openItem = fileMenu.add("Open");
 38.       openItem.addActionListener(new
 39.          ActionListener()
 40.          {
 41.             public void actionPerformed(ActionEvent event)
 42.             {
 43.                open();
 44.             }
 45.          });
 46.
 47.       JMenuItem saveItem = fileMenu.add("Save");
 48.       saveItem.addActionListener(new
 49.          ActionListener()
 50.          {
 51.             public void actionPerformed(ActionEvent event)
 52.             {
 53.                save();
 54.             }
 55.          });
 56.       JMenuBar menuBar = new JMenuBar();
 57.       menuBar.add(fileMenu);
 58.       setJMenuBar(menuBar);
 59.
 60.       pack();
 61.    }
 62.
 63.    /**
 64.       Gets the title from the persistent store or
 65.       asks the user for the title if there is no prior entry.
 66.    */
 67.    public void setTitle()
 68.    {
 69.       try
 70.       {
 71.          String title = null;
 72.
 73.          BasicService basic = (BasicService) ServiceManager.lookup("javax.jnlp
.BasicService");
 74.          URL codeBase = basic.getCodeBase();
 75.
 76.          PersistenceService service
 77.             = (PersistenceService) ServiceManager.lookup("javax.jnlp
.PersistenceService");
 78.          URL key = new URL(codeBase, "title");
 79.
 80.          try
 81.          {
 82.             FileContents contents = service.get(key);
 83.             InputStream in = contents.getInputStream();
 84.             BufferedReader reader = new BufferedReader(new InputStreamReader(in));
 85.             title = reader.readLine();
 86.          }
 87.          catch (FileNotFoundException e)
 88.          {
 89.             title = JOptionPane.showInputDialog("Please supply a frame title:");
 90.             if (title == null) return;
 91.
 92.             service.create(key, 100);
 93.             FileContents contents = service.get(key);
 94.             OutputStream out = contents.getOutputStream(true);
 95.             PrintStream printOut = new PrintStream(out);
 96.             printOut.print(title);
 97.          }
 98.          setTitle(title);
 99.       }
100.       catch (UnavailableServiceException e)
101.       {
102.          JOptionPane.showMessageDialog(this, e);
103.       }
104.       catch (MalformedURLException e)
105.       {
106.          JOptionPane.showMessageDialog(this, e);
107.       }
108.       catch (IOException e)
109.       {
110.          JOptionPane.showMessageDialog(this, e);
111.       }
112.    }
113.
114.    /**
115.       Opens a history file and updates the display.
116.    */
117.    public void open()
118.    {
119.       try
120.       {
121.          FileOpenService service
122.             = (FileOpenService) ServiceManager.lookup("javax.jnlp.FileOpenService");
123.          FileContents contents = service.openFileDialog(".", new String[] { "txt" });
124.
125.          JOptionPane.showMessageDialog(this, contents.getName());
126.          if (contents != null)
127.          {
128.             InputStream in = contents.getInputStream();
129.             BufferedReader reader = new BufferedReader(new InputStreamReader(in));
130.             String line;
131.             while ((line = reader.readLine()) != null)
132.             {
133.                panel.append(line);
134.                panel.append("
");
135.             }
136.          }
137.       }
138.       catch (UnavailableServiceException e)
139.       {
140.          JOptionPane.showMessageDialog(this, e);
141.       }
142.       catch (IOException e)
143.       {
144.          JOptionPane.showMessageDialog(this, e);
145.       }
146.    }
147.
148.    /**
149.       Saves the calculator history to a file.
150.    */
151.    public void save()
152.    {
153.       try
154.       {
155.          ByteArrayOutputStream out = new ByteArrayOutputStream();
156.          PrintStream printOut = new PrintStream(out);
157.          printOut.print(panel.getText());
158.          InputStream data = new ByteArrayInputStream(out.toByteArray());
159.          FileSaveService service
160.             = (FileSaveService) ServiceManager.lookup("javax.jnlp.FileSaveService");
161.          service.saveFileDialog(".", new String[] { "txt" }, data, "calc.txt");
162.       }
163.       catch (UnavailableServiceException e)
164.       {
165.          JOptionPane.showMessageDialog(this, e);
166.       }
167.       catch (IOException e)
168.       {
169.          JOptionPane.showMessageDialog(this, e);
170.       }
171.    }
172.
173.    private CalculatorPanel panel;
174. }
175.
176.
177. /**
178.    A panel with calculator buttons and a result display.
179. */
180. class CalculatorPanel extends JPanel
181. {
182.    /**
183.       Lays out the panel.
184.    */
185.    public CalculatorPanel()
186.    {
187.       setLayout(new BorderLayout());
188.
189.       result = 0;
190.       lastCommand = "=";
191.       start = true;
192.
193.       // add the display
194.
195.       display = new JTextArea(10, 20);
196.
197.       add(new JScrollPane(display), BorderLayout.NORTH);
198.
199.       ActionListener insert = new InsertAction();
200.       ActionListener command = new CommandAction();
201.
202.       // add the buttons in a 4 x 4 grid
203.
204.       panel = new JPanel();
205.       panel.setLayout(new GridLayout(4, 4));
206.
207.       addButton("7", insert);
208.       addButton("8", insert);
209.       addButton("9", insert);
210.       addButton("/", command);
211.
212.       addButton("4", insert);
213.       addButton("5", insert);
214.       addButton("6", insert);
215.       addButton("*", command);
216.
217.       addButton("1", insert);
218.       addButton("2", insert);
219.       addButton("3", insert);
220.       addButton("-", command);
221.
222.       addButton("0", insert);
223.       addButton(".", insert);
224.       addButton("=", command);
225.       addButton("+", command);
226.
227.       add(panel, BorderLayout.CENTER);
228.    }
229.
230.    /**
231.       Gets the history text.
232.       @return the calculator history
233.    */
234.    public String getText()
235.    {
236.       return display.getText();
237.    }
238.
239.    /**
240.       Appends a string to the history text.
241.       @param s the string to append
242.    */
243.    public void append(String s)
244.    {
245.       display.append(s);
246.    }
247.
248.    /**
249.       Adds a button to the center panel.
250.       @param label the button label
251.       @param listener the button listener
252.    */
253.    private void addButton(String label, ActionListener listener)
254.    {
255.       JButton button = new JButton(label);
256.       button.addActionListener(listener);
257.       panel.add(button);
258.    }
259.
260.    /**
261.       This action inserts the button action string to the
262.       end of the display text.
263.    */
264.    private class InsertAction implements ActionListener
265.    {
266.       public void actionPerformed(ActionEvent event)
267.       {
268.          String input = event.getActionCommand();
269.          start = false;
270.          display.append(input);
271.       }
272.    }
273.
274.    /**
275.       This action executes the command that the button
276.       action string denotes.
277.    */
278.    private class CommandAction implements ActionListener
279.    {
280.       public void actionPerformed(ActionEvent event)
281.       {
282.          String command = event.getActionCommand();
283.
284.          if (start)
285.          {
286.             if (command.equals("-"))
287.             {
288.                display.append(command);
289.                start = false;
290.             }
291.             else
292.                lastCommand = command;
293.          }
294.          else
295.          {
296.             try
297.             {
298.                int lines = display.getLineCount();
299.                int lineStart = display.getLineStartOffset(lines - 1);
300.                int lineEnd = display.getLineEndOffset(lines - 1);
301.                String value = display.getText(lineStart, lineEnd - lineStart);
302.                display.append(" ");
303.                display.append(command);
304.                calculate(Double.parseDouble(value));
305.                if (command.equals("="))
306.                   display.append("
" + result);
307.                lastCommand = command;
308.                display.append("
");
309.                start = true;
310.             }
311.             catch (BadLocationException e)
312.             {
313.                e.printStackTrace();
314.             }
315.          }
316.       }
317.    }
318.
319.    /**
320.       Carries out the pending calculation.
321.       @param x the value to be accumulated with the prior result.
322.    */
323.    public void calculate(double x)
324.    {
325.       if (lastCommand.equals("+")) result += x;
326.       else if (lastCommand.equals("-")) result -= x;
327.       else if (lastCommand.equals("*")) result *= x;
328.       else if (lastCommand.equals("/")) result /= x;
329.       else if (lastCommand.equals("=")) result = x;
330.    }
331.
332.    private JTextArea display;
333.    private JPanel panel;
334.    private double result;
335.    private String lastCommand;
336.    private boolean start;
337. }

javax.jnlp.ServiceManager

javax.jnlp.BasicService

javax.jnlp.FileContents

javax.jnlp.FileOpenService

javax.jnlp.FileSaveService

javax.jnlp.PersistenceService

Figure 10–16. The WebStartCalculator application

A property map is a data structure that stores key/value pairs. Property maps are often used for storing configuration information. Property maps have three particular characteristics:

The Java platform class that implements a property map is called Properties.

Property maps are useful in specifying configuration options for programs. For example,

Properties settings = new Properties();
settings.put("font", "Courier");

settings.put("size", "10");
settings.put("message", "Hello, World");

Use the store method to save this list of properties to a file. Here, we just save the property map in the file Myprog.properties. The second argument is a comment that is included in the file.

FileOutputStream out = new FileOutputStream("Myprog.properties");
settings.store(out, "Myprog Properties");

The sample set gives the following output.

#Myprog Properties
#Tue Jun 15 07:22:52  2004
font=Courier
size=10
message=Hello, World

To load the properties from a file, use

FileInputStream in = new FileInputStream("Myprog.properties");
settings.load(in);

We’ll put this technique to work so that your users can customize the NotHelloWorld program to their hearts’ content. We’ll allow them to specify the following in the configuration file CustomWorld.properties:

If the user doesn’t specify some of the settings, we will provide defaults.

The Properties class has two mechanisms for providing defaults. First, whenever you look up the value of a string, you can specify a default that should be used automatically when the key is not present.

String font = settings.getProperty("font", "Courier");

If there is a "font" property in the property table, then font is set to that string. Otherwise, font is set to "Courier".

If you find it too tedious to specify the default in every call to getProperty, then you can pack all the defaults into a secondary property map and supply that map in the constructor of your lookup table.

Properties defaultSettings = new Properties();
defaultSettings.put("font", "Courier");
defaultSettings.put("size", "10");
defaultSettings.put("color.red", "0");
. . .
Properties settings = new Properties(defaultSettings);
FileInputStream in = new FileInputStream("CustomWorld.properties");
settings.load(in);
. . .

Yes, you can even specify defaults to defaults if you give another property map parameter to the defaultSettings constructor, but it is not something one would normally do.

Example 10–14 is the customizable "Hello, Custom World" program. Just edit the .properties file to change the program’s appearance to the way you want (see Figure 10–17).

Figure 10–17. The customized Hello, World program

Note

Properties are simple tables without a hierarchical structure. It is common to introduce a fake hierarchy with key names such as window.main.color, window.main.title, and so on. But the Properties class has no methods that help organize such a hierarchy. If you store complex configuration information, you should use the Preferences class instead—see the next section.

Note

The Properties class extends the Hashtable class. That means that all Hashtable methods are available to Properties objects. Some methods are useful. For example, size returns the number of possible properties (well, it isn’t that nice—it doesn’t count the defaults). Similarly, keys returns an enumeration of all keys, except for the defaults. There is also a second method, called propertyNames, that returns all keys. The put method is downright dangerous. It doesn’t check that you put strings into the table.

Does the is-a rule for using inheritance apply here? Is every property map a hash table? Not really. That these are true is really just an implementation detail. Maybe it is better to think of a property map as having a hash table. But then the hash table should be a private instance variable. Actually, in this case, a property map uses two hash tables: one for the defaults and one for the nondefault values.

We think a better design would be the following:

class Properties
{
   public String getProperty(String) { . . . }
   public void put(String, String) { . . . }
   . . .
   private Hashtable nonDefaults;
   private Hashtable defaults;
}

We don’t want to tell you to avoid the Properties class in the Java library. Provided you are careful to put nothing but strings in it, it works just fine. But think twice before using “quick and dirty” inheritance in your own programs.

 1. import java.awt.*;
 2. import java.awt.event.*;
 3. import java.util.*;
 4. import java.io.*;
 5. import javax.swing.*;
 6.
 7. /**
 8.    This program demonstrates how to customize a "Hello, World"
 9.    program with a properties file.
10. */
11. public class CustomWorld
12. {
13.    public static void main(String[] args)
14.    {
15.       CustomWorldFrame frame = new CustomWorldFrame();
16.       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
17.       frame.setVisible(true);
18.    }
19. }
20.
21. /**
22.    This frame displays a message. The frame size, message text,
23.    font, and color are set in a properties file.
24. */
25. class CustomWorldFrame extends JFrame
26. {
27.    public CustomWorldFrame()
28.    {
29.       Properties defaultSettings = new Properties();
30.       defaultSettings.put("font", "Monospaced");
31.       defaultSettings.put("width", "300");
32.       defaultSettings.put("height", "200");
33.       defaultSettings.put("message", "Hello, World");
34.       defaultSettings.put("color.red", "0 50 50");
35.       defaultSettings.put("color.green", "50");
36.       defaultSettings.put("color.blue", "50");
37.       defaultSettings.put("ptsize", "12");
38.
39.       Properties settings = new Properties(defaultSettings);
40.       try
41.       {
42.          FileInputStream in = new FileInputStream("CustomWorld.properties");
43.          settings.load(in);
44.       }
45.       catch (IOException e)
46.       {
47.          e.printStackTrace();
48.       }
49.
50.       int red = Integer.parseInt(settings.getProperty("color.red"));
51.       int green = Integer.parseInt(settings.getProperty("color.green"));
52.       int blue = Integer.parseInt(settings.getProperty("color.blue"));
53.
54.       Color foreground = new Color(red, green, blue);
55.
56.       String name = settings.getProperty("font");
57.       int ptsize = Integer.parseInt(settings.getProperty("ptsize"));
58.       Font f = new Font(name, Font.BOLD, ptsize);
59.
60.       int hsize = Integer.parseInt(settings.getProperty("width"));
61.       int vsize = Integer.parseInt(settings.getProperty("height"));
62.       setSize(hsize, vsize);
63.       setTitle(settings.getProperty("message"));
64.
65.       JLabel label = new JLabel(settings.getProperty("message"), SwingConstants.CENTER);
66.       label.setFont(f);
67.       label.setForeground(foreground);
68.       add(label);
69.    }
70. }

java.util.Properties 1.0

Here’s another example of the ubiquity of the Properties set. Information about your system is stored in a Properties object that is returned by the static getProperties method of the System class:

Properties sysprops = System.getProperties();

To access a single property, call

String value = System.getProperty(key);

Applications that run without a security manager have complete access to this information, but applets and other untrusted programs can access only the following keys:

java.version
java.vendor
java.vendor.url
java.class.version
os.name
os.version
os.arch
file.separator
path.separator
line.separator
java.specification.version
java.vm.specification.version
java.vm.specification.vendor
java.vm.specification.name
java.vm.version
java.vm.vendor
java.vm.name

If an applet attempts to read another key (or all properties), then a security exception is thrown.

Note

You can find the names of the freely accessible system properties in the file security/java.policy in the directory of the Java run time.

The program in Example 10–15 prints out the key/value pairs in the Properties object that stores the system properties.

Here is an example of what you would see when you run the program. You can see all the values stored in this Properties object. (What you would get will, of course, reflect your machine’s settings.)

#System Properties
#Sat May 08 08:27:34 PDT 2004
java.runtime.name=Java(TM) 2 Runtime Environment, Standard Edition
sun.boot.library.path=/usr/local/jdk5.0/jre/lib/i386
java.vm.version=5.0
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
path.separator=:
java.vm.name=Java HotSpot(TM) Client VM
file.encoding.pkg=sun.io
user.country=US
sun.os.patch.level=unknown
java.vm.specification.name=Java Virtual Machine Specification
user.dir=/home/cay/books/cj5/corejava/v1/v1ch10/SystemInfo
java.runtime.version=5.0
java.awt.graphicsenv=sun.awt.X11GraphicsEnvironment
java.endorsed.dirs=/usr/local/jdk5.0/jre/lib/endorsed
os.arch=i386
java.io.tmpdir=/tmp
line.separator=

java.vm.specification.vendor=Sun Microsystems Inc.
os.name=Linux
java.library.path=/usr/local/jdk5.0/jre/lib/i386/client:/usr/local/jdk5.0/jre/lib/i386:
/usr/local/jdk5.0/jre/../lib/i386
java.specification.name=Java Platform API Specification
java.class.version=48.0
sun.management.compiler=HotSpot Client Compiler
java.util.prefs.PreferencesFactory=java.util.prefs.FileSystemPreferencesFactory
os.version=2.4.20-8
user.home=/home/cay
user.timezone=America/Los_Angeles
java.awt.printerjob=sun.print.PSPrinterJob
file.encoding=UTF-8
java.specification.version=5.0
java.class.path=.
user.name=cay
java.vm.specification.version=1.0
java.home=/usr/local/jdk5.0/jre
sun.arch.data.model=32
user.language=en
java.specification.vendor=Sun Microsystems Inc.
java.vm.info=mixed mode
java.version=5.0
java.ext.dirs=/usr/local/jdk5.0/jre/lib/ext
sun.boot.class.path=/usr/local/jdk5.0/jre/lib/rt.jar:/usr/local/jdk5.0/jre/lib/i18n.jar:
/usr/local/jdk5.0/jre/lib/sunrsasign.jar:/usr/local/jdk5.0/jre/lib/jsse.jar:/usr/local
/jdk5.0/jre/lib/jce.jar:/usr/local/jdk5.0/jre/lib/charsets.jar:/usr/local/jdk5.0/jre/classes
java.vendor=Sun Microsystems Inc.
file.separator=/
java.vendor.url.bug=http://java.sun.com/cgi-bin/bugreport.cgi
sun.io.unicode.encoding=UnicodeLittle
sun.cpu.endian=little
sun.cpu.isalist=

 1. import java.applet.*;
 2. import java.io.*;
 3. import java.util.*;
 4
 5. /**
 6.    This program prints out all system properties.
 7. */
 8. public class SystemInfo
 9. {
10.    public static void main(String args[])
11.    {
12.       try
13.       {
14.          Properties sysprops = System.getProperties();
15.          sysprops.store(System.out, "System Properties");
16.       }
17.       catch (IOException e)
18.       {
19.          e.printStackTrace();
20.       }
21.    }
22. }

java.lang.System 1.0

As you have seen, the Properties class makes it simple to load and save configuration information. However, using property files has a number of disadvantages.

Some operating systems have a central repository for configuration information. The best-known example is the registry in Microsoft Windows. The Preferences class of JDK 1.4 provides such a central repository in a platform-independent manner. In Windows, the Preferences class uses the registry for storage; on Linux, the information is stored in the local file system instead. Of course, the repository implementation is transparent to the programmer using the Preferences class.

The Preferences repository has a tree structure, with node path names such as /com/mycompany/myapp. As with package names, name clashes are avoided as long as programmers start the paths with reversed domain names. In fact, the designers of the API suggest that the configuration node paths match the package names in your program.

Each node in the repository has a separate table of key/value pairs that you can use to store numbers, strings, or byte arrays. No provision is made for storing serializable objects. The API designers felt that the serialization format is too fragile for long-term storage. Of course, if you disagree, you can save serialized objects in byte arrays.

For additional flexibility, there are multiple parallel trees. Each program user has one tree, and an additional tree, called the system tree, is available for settings that are common to all users. The Preferences class uses the operating system notion of the “current user” for accessing the appropriate user tree.

To access a node in the tree, start with the user or system root:

Preferences root = Preferences.userRoot();

or

Preferences root = Preferences.systemRoot();

Then access the node. You can simply provide a node path name:

Preferences node = root.node("/com/mycompany/myapp");

A convenient shortcut gets a node whose path name equals the package name of a class. Simply take an object of that class and call

Preferences node = Preferences.userNodeForPackage(obj.getClass());

or

Preferences node = Preferences.systemNodeForPackage(obj.getClass());

Typically, obj will be the this reference.

Once you have a node, you can access the key/value table with methods

String get(String key, String defval)
int getInt(String key, int defval)
long getLong(String key, long defval)
float getFloat(String key, float defval)
double getDouble(String key, double defval)
boolean getBoolean(String key, boolean defval)
byte[] getByteArray(String key, byte[] defval)

Note that you must specify a default value when reading the information, in case the repository data is not available. Defaults are required for several reasons. The data might be missing because the user never specified a preference. Certain resource-constrained platforms might not have a repository, and mobile devices might be temporarily disconnected from the repository.

Conversely, you can write data to the repository with put methods such as

put(String key, String value)
putInt(String key, int value)

and so on.

You can enumerate all keys stored in a node with the method

String[] keys

But there is currently no way to find out the type of the value of a particular key.

Central repositories such as the Windows registry traditionally suffer from two problems.

The Preferences class has a solution for the second problem. You can export the preferences of a subtree (or, less commonly, a single node) by calling the methods

void exportSubtree(OutputStream out)
void exportNode(OutputStream out)

The data are saved in XML format. You can import them into another repository by calling

void importPreferences(InputStream in)

Here is a sample file:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE preferences SYSTEM "http://java.sun.com/dtd/preferences.dtd">
<preferences EXTERNAL_XML_VERSION="1.0">
  <root type="user">
    <map/>
    <node name="com">
      <map/>
      <node name="horstmann">
        <map/>
        <node name="corejava">
          <map>
            <entry key="left" value="11"/>
            <entry key="top" value="9"/>
            <entry key="width" value="453"/>
            <entry key="height" value="365"/>
          </map>
        </node>
      </node>
    </node>
  </root>
</preferences>

If your program uses preferences, you should give your users the opportunity of exporting and importing them, so they can easily migrate their settings from one computer to another. The program in Example 10–16 demonstrates this technique. The program simply saves the position and size of the main window. Try resizing the window, then exit and restart the application. The window will be just like you left it when you exited.

  1. import java.awt.*;
  2. import java.awt.event.*;
  3. import java.io.*;
  4. import java.util.logging.*;
  5. import java.util.prefs.*;
  6. import javax.swing.*;
  7. import javax.swing.event.*;
  8.
  9. /**
 10.    A program to test preference settings. The program
 11.    remembers the frame position and size.
 12. */
 13. public class PreferencesTest
 14. {
 15.    public static void main(String[] args)
 16.    {
 17.       PreferencesFrame frame = new PreferencesFrame();
 18.       frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 19.       frame.setVisible(true);
 20.    }
 21. }
 22.
 23. /**
 24.    A frame that restores position and size from user
 25.    preferences and updates the preferences upon exit.
 26. */
 27. class PreferencesFrame extends JFrame
 28. {
 29.    public PreferencesFrame()
 30.    {
 31.       setTitle("PreferencesTest");
 32.
 33.       // get position, size from preferences
 34.
 35.       Preferences root = Preferences.userRoot();
 36.       final Preferences node = root.node("/com/horstmann/corejava");
 37.       int left = node.getInt("left", 0);
 38.       int top = node.getInt("top", 0);
 39.       int width = node.getInt("width", DEFAULT_WIDTH);
 40.       int height = node.getInt("height", DEFAULT_HEIGHT);
 41.       setBounds(left, top, width, height);
 42.
 43.       // set up file chooser that shows XML files
 44.
 45.       final JFileChooser chooser = new JFileChooser();
 46.       chooser.setCurrentDirectory(new File("."));
 47.
 48.       // accept all files ending with .xml
 49.       chooser.setFileFilter(new
 50.          javax.swing.filechooser.FileFilter()
 51.          {
 52.             public boolean accept(File f)
 53.             {
 54.                return f.getName().toLowerCase().endsWith(".xml") || f.isDirectory();
 55.             }
 56.             public String getDescription()
 57.             {
 58.                return "XML files";
 59.             }
 60.          });
 61.
 62.
 63.       // set up menus
 64.       JMenuBar menuBar = new JMenuBar();
 65.       setJMenuBar(menuBar);
 66.       JMenu menu = new JMenu("File");
 67.       menuBar.add(menu);
 68.
 69.       JMenuItem exportItem = new JMenuItem("Export preferences");
 70.       menu.add(exportItem);
 71.       exportItem.addActionListener(new
 72.          ActionListener()
 73.          {
 74.             public void actionPerformed(ActionEvent event)
 75.             {
 76.                if(chooser.showSaveDialog(PreferencesFrame.this) == JFileChooser
.APPROVE_OPTION)
 77.                {
 78.                   try
 79.                   {
 80.                      OutputStream out = new FileOutputStream(chooser.getSelectedFile());
 81.                      node.exportSubtree(out);
 82.                      out.close();
 83.                   }
 84.                   catch (Exception e)
 85.                   {
 86.                      e.printStackTrace();
 87.                   }
 88.                }
 89.             }
 90.          });
 91.
 92.       JMenuItem importItem = new JMenuItem("Import preferences");
 93.       menu.add(importItem);
 94.       importItem.addActionListener(new
 95.          ActionListener()
 96.          {
 97.             public void actionPerformed(ActionEvent event)
 98.             {
 99.                if(chooser.showOpenDialog(PreferencesFrame.this) == JFileChooser
.APPROVE_OPTION)
100.                {
101.                   try
102.                   {
103.                      InputStream in = new FileInputStream(chooser.getSelectedFile());
104.                      node.importPreferences(in);
105.                      in.close();
106.                   }
107.                   catch (Exception e)
108.                  {
109.                     e.printStackTrace();
110.                  }
111.               }
112.            }
113.         });
114.
115.       JMenuItem exitItem = new JMenuItem("Exit");
116.       menu.add(exitItem);
117.       exitItem.addActionListener(new
118.          ActionListener()
119.          {
120.             public void actionPerformed(ActionEvent event)
121.             {
122.                node.putInt("left", getX());
123.                node.putInt("top", getY());
124.                node.putInt("width", getWidth());
125.                node.putInt("height", getHeight());
126.                System.exit(0);
127.             }
128.          });
129.    }
130.    public static final int DEFAULT_WIDTH = 300;
131.    public static final int DEFAULT_HEIGHT = 200;
132. }

java.util.prefs.Preferences 1.4

This concludes our discussion of Java software deployment. In the next chapter, you learn how to use exceptions to tell your programs what to do when problems arise at run time. We also give you tips and techniques for testing and debugging so that not too many things will go wrong when your programs run.