<HTML>
<HEAD>
   <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
   <META NAME="GENERATOR" CONTENT="Mozilla/4.02 [en] (X11; U; SunOS 5.6 sun4u) [Netscape]">
   <TITLE>Metalworks</TITLE>
</HEAD>
<BODY>

<H1>
About Metalworks</H1>
Metalworks is a simple Swing-based simulated email application.  It shows off several features of Swing including: JInternalFrame, JTabbedPane, JFileChooser, JEditorPane and JRadioButtonMenuItem.  It is optimized to work with the Java Look & Feel and shows use of several Java L&F specific features including themes.
<H1>
Metalworks Features</H1>
The functionality of the Metalworks demo is minimal, and many controls are non-functional.  They are only intended to show how to construct the UI for such interfaces.  Things that do work in the Metalworks demo include:

<P>1. Choosing New from the File menu displays an email composition window..

<P>2. Choosing Open from the File menu brings up the file chooser.

<P>3. Choosing Preferences from the Edit menu will bring up a dialog.  Most of this dialog is only for show.

<P>4. Choosing About Metalworks from the help menu brings up a JOptionPane with a brief description of the application.

<P>5. Choosing Open Help Window from the Help menu brings up an internal frame which displays a set of HTML files containing all sorts of useful info.  Look through these for tips about using the Java Look and Feel.


<P>6. Selecting from the Theme menu allows you to change the color theme of the application.  The default theme (Steel) and several other demo themes are included.  One note that the themes can control the sizes, as well as the colors of many controls.  Also included with this release is the PropertiesMetalTheme class which allows you to read a theme's colors from a text file.  The Charcoal theme is an example of using this.</P>

&nbsp;

<P><A HREF="toc.html"><IMG SRC="back.gif" BORDER=0 NATURALSIZEFLAG="3" HEIGHT=22 WIDTH=42 ALIGN=BOTTOM>Back</A>
</BODY>
</HTML>
