Selecting Look & Feel
Selecting Look & Feel
One of the very interesting aspects of Swing is the
“Pluggable Look & Feel.” This allows your program to emulate the
look and feel of various operating environments. You can even do all sorts of
fancy things like dynamically changing the look and feel while the program is
executing. However, you generally just want to do one of two things, either
select the “cross platform” look and feel (which is Swing’s
“metal”), or select the look and feel for the system you are
currently on, so your Java program looks like it was created specifically for
that system. The code to select either of these behaviors is quite
simple—but you must execute it before you create any visual
components, because the components will be made based on the current look and
feel and will not be changed just because you happen to change the look and feel
midway during the program (that process is more complicated and uncommon, and is
relegated to Swing-specific books).
Actually, if you want to use the cross-platform
(“metal”) look and feel that is characteristic of Swing programs,
you don’t have to do anything—it’s the default. But if you
want instead to use the current operating environment’s look and feel, you
just insert the following code, typically at the beginning of your
main( ) but somehow before any components are
added:
try
{
UIManager.setLookAndFeel(UIManager.
getSystemLookAndFeelClassName());
}
catch(Exception
e) {}
You don’t need anything in the catch
clause because the UIManager will default to the cross-platform look and
feel if your attempts to set up any of the alternatives fail. However, during
debugging the exception can be quite useful so you may at least want to put a
print statement in the catch clause.
Here is a program that takes a command-line argument
to select a look and feel, and shows how several different components look under
the chosen look and feel:
//:
c13:LookAndFeel.java
//
Selecting different looks & feels.
import
javax.swing.*;
import
java.awt.*;
import
java.awt.event.*;
import
java.util.*;
import
com.bruceeckel.swing.*;
public
class
LookAndFeel
extends
JFrame {
String[] choices = {
"eeny",
"meeny",
"minie",
"moe",
"toe",
"you"
};
Component[] samples = {
new
JButton("JButton"),
new
JTextField("JTextField"),
new
JLabel("JLabel"),
new
JCheckBox("JCheckBox"),
new
JRadioButton("Radio"),
new
JComboBox(choices),
new
JList(choices),
};
public
LookAndFeel() {
super("Look
And Feel");
Container cp = getContentPane();
cp.setLayout(new
FlowLayout());
for(int
i = 0; i < samples.length; i++)
cp.add(samples[i]);
}
private
static
void
usageError() {
System.out.println(
"Usage:LookAndFeel
[cross|system|motif]");
System.exit(1);
}
public
static
void
main(String[] args) {
if(args.length
== 0) usageError();
if(args[0].equals("cross"))
{
try
{
UIManager.setLookAndFeel(UIManager.
getCrossPlatformLookAndFeelClassName());
}
catch(Exception
e) {
e.printStackTrace(System.err);
}
}
else
if(args[0].equals("system"))
{
try
{
UIManager.setLookAndFeel(UIManager.
getSystemLookAndFeelClassName());
}
catch(Exception
e) {
e.printStackTrace(System.err);
}
}
else
if(args[0].equals("motif"))
{
try
{
UIManager.setLookAndFeel("com.sun.java."+
"swing.plaf.motif.MotifLookAndFeel");
}
catch(Exception
e) {
e.printStackTrace(System.err);
}
}
else
usageError();
// Note the look & feel must
be set before
// any components are
created.
Console.run(new
LookAndFeel(), 300, 200);
}
}
///:~
You can see that one option is to explicitly specify a
string for a look and feel, as seen with MotifLookAndFeel. However, that
one and the default “metal” look and feel are the only ones that can
legally be used on any platform; even though there are strings for Windows and
Macintosh look and feels, those can only be used on their respective platforms
(these are produced when you call getSystemLookAndFeelClassName( )
and you’re on that particular platform).
It is also possible to create a custom look and feel
package, for example, if you are building a framework for a company that wants a
distinctive appearance. This is a big job and is far beyond the scope of this
book (in fact, you’ll discover it is beyond the scope of many dedicated
Swing books!)
|
