In Part I of this short course you will:
- Find out
about the need for JavaTM
Foundation Classes (JFC)-Swing and its advantages over the
Abstract Window Toolkit (AWT)
- Learn about
the JFC-Swing Controls
- Learn about
the JFC-Swing Layout Managers
Course Outline
Sun Microsystems is leveraging the technology of NetscapeTM Communications, IBM, and Lighthouse
Design (now owned by Sun) to create a set of Graphical User
Interface (GUI) classes that integrate with JDKTM 1.1.5+, are standard with the Java ® 2
platform and provide a more polished look and feel than the standard
AWT component set. The collection of APIs coming out of this effort,
called the Java Foundation Classes (JFC), allows developers to build
full-featured enterprise-ready applications.
JFC is composed of five APIs: AWT, JavaTM 2D, Accessibility, Drag and Drop, and
Swing. The AWT components refer to the AWT as it exists in JDK
versions 1.1.2 and later. Java 2D is a graphics API based on
technology licensed from IBM/Taligent. It is currently available
with the Java® 2 Platform (and not usable with JDK 1.1). The
Accessibility API provides assistive technologies, like screen
magnifiers, for use with the various pieces of JFC. Drag and Drop
support is part of the next JavaBeanTM generation, "Glasgow," and is also
available with the Java® 2 platform.
Swing includes a component set that is targeted at forms-based
applications. Loosely based on Netscape's acclaimed Internet
Foundation Classes (IFC), the Swing components have had the most
immediate impact on Java development. They provide a set of
well-groomed widgets and a framework to specify how GUIs are
visually presented, independent of platform. At the time this was
written, the Swing release is at 1.1 (FCS).
Though the Swing widgets were based heavily on IFC, the two APIs
bear little resemblance to one another from the perspective of a
developer. The look and feel of some Swing widgets and their
rendering is primarily what descended from IFC, although you may
notice some other commonalties.
The AWT 1.1 widgets and event model are still present for the
Swing widgets. However, the 1.0 event model does not work with Swing
widgets. The Swing widgets simply extend AWT by adding a new set of
components, the JComponents, and a group of related support
classes. As with AWT, Swing components are all JavaBeans and
participate in the JavaBeans event model.
A subset of Swing widgets is analogous to the basic AWT widgets.
In some cases, the Swing versions are simply lightweight components,
rather than peer-based components. The lightweight component
architecture was introduced in AWT 1.1. It allows components to
exist without native operating system widgets. Instead, they
participate in the Model/View/Controller (MVC) architecture, which
will be described in Part II of this course. Swing also contains
some new widgets such as trees, tabbed panes, and splitter panes
that will greatly improve the look and functionality of GUIs.
Swing can expand and simplify your development of cross-platform
applications. The Swing collection consists of seventeen packages,
each of which has its own distinct purpose. As you'll learn in this
short course, these packages make it relatively easy for you to put
together a variety of applications that have a high degree of
sophistication and user friendliness.
javax.swing
- The high
level swing package primarily consists of components, adapters,
default component models, and interfaces for all the delegates and
models.
javax.swing.border
- The border
package declares the
Border interface and classes,
which define specific border rendering styles.
javax.swing.colorchooser
- The
colorchooser package contains support classes for the color
chooser component.
javax.swing.event
- The event
package is for the Swing-specific event types and listeners. In
addition to the
java.awt.event types, Swing
components can generate their own event types.
javax.swing.filechooser
- The
filechooser package contains support classes for the file chooser
component.
javax.swing.plaf.*
- The
pluggable look-and-feel (PLAF) packages contain the User Interface
(UI) classes (delegates) which implement the different
look-and-feel aspects for Swing components. There are also PLAF
packages under the
javax.swing.plaf hierarchy.
javax.swing.table
- The table
package contains the support interfaces and classes the Swing
table component.
javax.swing.text
- The text
package contains the support classes for the Swing document
framework.
javax.swing.text.html.*
- The
text.html package contains the support classes for an HTML version
3.2 renderer and parser.
javax.swing.text.rtf
- The
text.rtf package contains the support classes for a basic Rich
Text Format (RTF) renderer.
javax.swing.tree
- The tree
package contains the interfaces and classes which support the
Swing tree component.
javax.swing.undo
- The undo
package provides the support classes for implementing undo/redo
capabilities in a GUI.
javax.accessibility
- The JFC
Accessibility package is included with the Swing classes. However,
its usage is not discussed here.
This section describes how to use the various Swing widgets. The
Swing component hierarchy is shown in two parts for comparison with
AWT. Part 1 of the component hierarchy is similar to that of AWT.
However, there are over twice as many components in Swing as in AWT.
Part 2 shows the expanded Swing component set. This group of
components appeals most to developers, as it provides a much richer
set of widgets to use.
Component Hierarchy: Part 1--AWT Similar
Component Hierarchy: Part 2--New And Expanded Components
The first widget to discuss is JPanel. It is a
lightweight Panel object offering built-in support for
double buffering. When buffering is enabled, through the
constructor, all the drawing operations of components within the
panel will be drawn to an off-screen drawing area prior to being
drawn to the screen. The JPanel class is used in most
of the examples in this section.
The second component, Icon, isn't really a component
at all. However, you can use it with almost all Swing
components.
An Icon is used to describe fixed-size pictures, or
glyphs. Typically, you embed icons in a JButton or
other JComponent. Objects that can act as icons
implement the Icon interface, shown below. It contains
a paintIcon() method that specifies a drawing origin.
You render the picture specified in the paintIcon()
method in a rectangle whose size cannot exceed a rectangle with an
origin at (x, y), a width of
getIconWidth(), and a height of
getIconHeight(). The Component parameter
to paintIcon() is not usually used, unless you need to
specify additional information, such as a font or color.
public interface Icon {
void paintIcon(
Component c, Graphics g, int x, int y);
int getIconWidth();
int getIconHeight();
}
The ImageIcon class is an implementation of
Icon that creates an Icon from an
Image.
Icon tinyPicture = new ImageIcon("TinyPicture.gif");
Alternatively, the ImageIcon constructor can take an
Image or URL object or byte array as its
parameter, with an optional String description
parameter. One nice thing about ImageIcon is it checks
a cache before retrieving the image file.
Swing uses ImageIcon rather than Image
for two reasons:
- An
Image loads asynchronously, creating the need to
monitor the loading process (with
MediaTracker).
- An
Image is not serializable.
In addition to using ImageIcon, you can implement
the interface yourself to create your own icons:
public class RedOval implements Icon {
public void paintIcon (Component c, Graphics g,
int x, int y) {
g.setColor(Color.red);
g.drawOval (x, y, getIconWidth(), getIconHeight());
}
public int getIconWidth() {
return 10;
}
public int getIconHeight() {
return 10;
}
}
A JLabel is a single line label similar to
java.awt.Label. Additional functionality that a
JLabel has is the ability to:
- Add an
Icon
- Set the
vertical and horizontal position of text relative to the
Icon
- Set the
relative position of contents within component
public class LabelPanel extends JPanel {
public LabelPanel() {
// Create and add a JLabel
JLabel plainLabel = new JLabel("Plain Small Label");
add(plainLabel);
// Create a 2nd JLabel
JLabel fancyLabel = new JLabel("Fancy Big Label");
// Instantiate a Font object to use for the label
Font fancyFont =
new Font("Serif", Font.BOLD | Font.ITALIC, 32);
// Associate the font with the label
fancyLabel.setFont(fancyFont);
// Create an Icon
Icon tigerIcon = new ImageIcon("SmallTiger.gif");
// Place the Icon in the label
fancyLabel.setIcon(tigerIcon);
// Align the text to the right of the Icon
fancyLabel.setHorizontalAlignment(JLabel.RIGHT);
// Add to panel
add(fancyLabel);
}
}
A JButton can be instantiated and used in a GUI just
like a java.awt.Button. It behaves like an AWT 1.1
Button, notifying ActionListener list
elements when pushed.
public class ButtonPanel extends JPanel {
public ButtonPanel () {
JButton myButton = new JButton("Tiger");
add(myButton);
}
}
Also, the JButton has support for an embedded
Icon, specified in the constructor, or via the
setIcon() method. This creates an image button; here,
with the label Tiger:
public class ButtonPanel extends JPanel {
public ButtonPanel() {
Icon tigerIcon = new ImageIcon("SmallTiger.gif");
JButton myButton = new JButton("Tiger", tigerIcon);
add(myButton);
}
}
Magercises
- Installing
Swing and SwingSet Demonstration
- Creating
Your First JFC Application
- Creating
Buttons With Icons
While the AbstractButton isn't a class you use
directly, several of the more common JComponent classes
inherit much of their shared behavior from this object. For
instance, the icon usage methods getIcon() and
setIcon() come from AbstractButton. (The
methods are also available elsewhere.) Some of the other common
features are listed below:
setMnemonic()
- Add a keyboard accelerator to a text label, use the
VK_* constants from KeyEvent to specify
the key
doClick()
- Programmatically, select the button
setDisabledIcon(),
setDisabledSelectedIcon(),
setPressedIcon(), setRolloverIcon(),
setRolloverSelectedIcon(),
setSelectedIcon() - Change the displayed
Icon, based on the button state (in addition to
setIcon())
setVerticalAlignment(),
setHorizontalAlignemnt() - Anchors icon/text in
different areas of button
setVerticalTextPosition(),
setHorizontalTextPosition() - Positions text in
different areas around icon. Both
setXXXAlignment() and
setYYYTextPosition() rely on the
SwingConstants interface for the area placement
settings.
Note: The upcoming Swing 1.1.1 release includes
the ability to specify label text in HTML by preceding the content
with <html>. This will allow you to have multi-line button
labels without having to customize the user interface.
A JCheckBox is similar to an AWT
Checkbox that is not in a CheckboxGroup.
Although Swing provides a default graphic to signify
JCheckBox selection, you also can specify your own
Icon objects for both the checked and unchecked state.
public class CheckboxPanel extends JPanel {
Icon unchecked = new ToggleIcon (false);
Icon checked = new ToggleIcon (true);
public CheckboxPanel() {
// Set the layout for the JPanel
setLayout(new GridLayout(2, 1));
// Create checkbox with its state
// initialized to true
JCheckBox cb1 = new JCheckBox("Choose Me", true);
cb1.setIcon(unchecked);
cb1.setSelectedIcon(checked);
// Create checkbox with its state
// initialized to false
JCheckBox cb2 = new JCheckBox(
"No Choose Me", false);
cb2.setIcon(unchecked);
cb2.setSelectedIcon(checked);
add(cb1);
add(cb2);
}
class ToggleIcon implements Icon {
boolean state;
public ToggleIcon (boolean s) {
state = s;
}
public void paintIcon (Component c, Graphics g,
int x, int y) {
int width = getIconWidth();
int height = getIconHeight();
g.setColor (Color.black);
if (state)
g.fillRect (x, y, width, height);
else
g.drawRect (x, y, width, height);
}
public int getIconWidth() {
return 10;
}
public int getIconHeight() {
return 10;
}
}
}
In AWT, radio buttons are checkboxes that belong to the same
CheckboxGroup; which ensures that only one checkbox is
selected at a time. Swing has a separate widget called a
JRadioButton. Each JRadioButton is added
to a ButtonGroup so the group behaves as a set of radio
buttons. Like CheckboxGroup, ButtonGroup
is a functional object that has no visual representation.
public class RadioButtonPanel extends JPanel {
public RadioButtonPanel() {
// Set the layout to a GridLayout
setLayout(new GridLayout(4,1));
// Declare a radio button
JRadioButton radioButton;
// Instantiate a ButtonGroup for functional
// association among radio buttons
ButtonGroup rbg = new ButtonGroup();
// Create a label for the group
JLabel label = new JLabel("Annual Salary: ");
label.setFont(new Font(
"SansSerif", Font.BOLD, 14));
add(label);
// Add a new radio button to the pane
radioButton = new JRadioButton("$45,000");
add (radioButton);
// set key accelerator
radioButton.setMnemonic (KeyEvent.VK_4);
// Add the button to the ButtonGroup
rbg.add (radioButton);
// Set this radio button to be the default
radioButton.setSelected(true);
// Set up two more radio buttons
radioButton = new JRadioButton("$60,000");
radioButton.setMnemonic (KeyEvent.VK_6);
add (radioButton);
rbg.add (radioButton);
radioButton = new JRadioButton("$75,000");
radioButton.setMnemonic (KeyEvent.VK_7);
add (radioButton);
rbg.add (radioButton);
}
}
Technically speaking, you can add JCheckBox or
JToggleButton (described next) components to a
CheckboxGroup. At most, one will be selected while in
the group.
The JToggleButton class is the parent to both
JCheckBox and JRadioButton. It doesn't
have an AWT equivalent. The JToggleButton works like a
Button that stays pressed in when toggled on. When a
JToggleButton is toggled off, you cannot tell it from a
regular Button or JButton class.
public class ToggleButtonPanel extends JPanel {
public ToggleButtonPanel() {
// Set the layout to a GridLayout
setLayout(new GridLayout(4,1, 10, 10));
add (new JToggleButton ("Fe"));
add (new JToggleButton ("Fi"));
add (new JToggleButton ("Fo"));
add (new JToggleButton ("Fum"));
}
}
Like the AWT 1.1 ScrollPane,
JScrollPane handles automatic horizontal and vertical
scrolling of content. It lays out components using a
ScrollPaneLayout, described in more detail under Swing
Layouts. The key thing to know when using a
JScrollPane is that Swing provides a
JViewport for adding the object to scroll.
To get a handle to the viewport, JScrollPane has a
getViewport() method. Then, to add a component to the
viewport, the JViewport class has an add
method.
JViewport vport = someScrollPane.getViewport();
vport.add(someComponent);
Or, more commonly, the two lines are combined:
someScrollPane.getViewport().add(someComponent);
Another option is to provide the component to scroll to the
constructor:
JScrollPane pane = new JScrollPane(someComponent);
public class ScrollPanel extends JPanel {
public ScrollPanel() {
setLayout(new BorderLayout());
Icon bigTiger = new ImageIcon("BigTiger.gif");
JLabel tigerLabel = new JLabel(bigTiger);
JScrollPane scrollPane =
new JScrollPane(tigerLabel);
add(scrollPane, BorderLayout.CENTER);
}
}
The JViewport offers a view into a much larger area
then can be seen without it. It can be either used within the
JScrollPane component or as a standalone widget, where
you control all the scrolling functionality yourself. Normally, you
wouldn't want to do all the scrolling functionality yourself, but
the capability is available. (Besides JScrollPane,
JViewport is used internally within the Swing text
components to handle scrolling of text.)
Magercise
- Using
Toggles
JTextComponent is a generalized text class that
contains all the features you would expect from a simple editor.
Some of its methods include:
copy()
cut()
paste()
getSelectedText()
setSelectionStart()
setSelectionEnd()
selectAll()
replaceSelection()
getText()
setText()
setEditable()
setCaretPosition()
Although you won't instantiate a JTextComponent
object directly, you will often use these methods, many of which are
not available in AWT text widgets.
JTextComponent objects in Swing can be placed in a
panel in a fashion nearly identical to AWT text widgets.
There are three basic subclasses of JTextComponent:
JTextField, JTextArea, and
JEditorPane. JPasswordField and
JTextPane are sub-subclasses that are also of interest.
If you want your users to be able to see content that exceeds the
screen display area, you must place the component inside of a
JScrollPane to support scrolling to the extra content.
Other than having to add a JTextArea to a
JScrollPane for scrolling, JTextField and
JTextArea behave very similarly to their AWT
counterparts: java.awt.TextField and
java.awt.TextArea:
// Instantiate a new TextField
JTextField tf = new JTextField();
// Instantiate a new TextArea
JTextArea ta = new JTextArea();
// Initialize the text of each
tf.setText("TextField");
ta.setText("JTextArea\n Allows Multiple Lines");
add(tf);
add(new JScrollPane(ta));
The JTextField also supports setting of text
justification with setHorizontalAlignment(). The three
available settings are LEFT, CENTER, and
RIGHT, where LEFT is the default.
JTextPane is a full-featured text editor that
supports formatted text, word wrap, and image display. It uses a
linked list of objects that implement the Style
interface to specify formatting and supplies some convenience
methods for formatting text. A more detailed discussion of
JTextPane usage, and the javax.swing.text
package, is included in Part II of this course.
JTextPane tp = new JTextPane();
MutableAttributeSet attr = new SimpleAttributeSet();
StyleConstants.setFontFamily(attr, "Serif");
StyleConstants.setFontSize(attr, 18);
StyleConstants.setBold(attr, true);
tp.setCharacterAttributes(attr, false);
add(new JScrollPane(tp));
public class TextPanel extends JPanel {
public TextPanel() {
// Set the layout to a BorderLayout
setLayout(new BorderLayout());
// Create the three basic text components
JTextField textField = new JTextField();
JTextArea textArea = new JTextArea();
JTextPane textPane = new JTextPane();
//Set the textpane's font properties
MutableAttributeSet attr =
new SimpleAttributeSet();
StyleConstants.setFontFamily(attr, "Serif");
StyleConstants.setFontSize(attr, 18);
StyleConstants.setBold(attr, true);
textPane.setCharacterAttributes(attr, false);
add(textField, BorderLayout.NORTH);
add(new JScrollPane(textArea),
BorderLayout.CENTER);
add(new JScrollPane(textPane), BorderLayout.SOUTH);
}
}
The JPasswordField is a JTextField that
refuses to display its contents openly. By default, the mask
character is the asterisk ('*'). However, you can change this with
the setEchoChar() method. Unlike
java.awt.TextField, an echo character of
(char)0 does not unset the mask.
class PasswordPanel extends JPanel {
PasswordPanel() {
JPasswordField pass1 = new JPasswordField(20);
JPasswordField pass2 = new JPasswordField(20);
pass2.setEchoChar ('?');
add(pass1);
add(pass2);
}
}
The JEditorPane class is a specialized
JTextComponent for displaying and editing HTML 3.2 tags
or some other format like RTF (rich text format), as determined by
the input. It is not meant to provide a full-fledged browser, but a
lightweight HTML viewer, usually for the purpose of displaying help
text. You either construct the pane with a URL parameter (via a
String or URL), or change pages with the
setPage() method. For HTML content, links within the
HTML page are traversable with the help of a
HyperlinkListener.
public class Browser extends JPanel {
Browser() {
setLayout (new BorderLayout (5, 5));
final JEditorPane jt = new JEditorPane();
final JTextField input =
new JTextField("http://java.sun.com");
// make read-only
jt.setEditable(false);
// follow links
jt.addHyperlinkListener(new HyperlinkListener () {
public void hyperlinkUpdate(
final HyperlinkEvent e) {
if (e.getEventType() ==
HyperlinkEvent.EventType.ACTIVATED) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
// Save original
Document doc = jt.getDocument();
try {
URL url = e.getURL();
jt.setPage(url);
input.setText (url.toString());
} catch (IOException io) {
JOptionPane.showMessageDialog (
Browser.this, "Can't follow link",
"Invalid Input",
JOptionPane.ERROR_MESSAGE);
jt.setDocument (doc);
}
}
});
}
}
});
JScrollPane pane = new JScrollPane();
pane.setBorder (
BorderFactory.createLoweredBevelBorder());
pane.getViewport().add(jt);
add(pane, BorderLayout.CENTER);
input.addActionListener (new ActionListener() {
public void actionPerformed (ActionEvent e) {
try {
jt.setPage (input.getText());
} catch (IOException ex) {
JOptionPane.showMessageDialog (
Browser.this, "Invalid URL",
"Invalid Input",
JOptionPane.ERROR_MESSAGE);
}
}
});
add (input, BorderLayout.SOUTH);
}
}
To activate the hyperlinks within the JEditorPane,
event handling code is provided. Also, if you only want to display
HTML, remember to setEditable(false) to make the editor
read-only.
JScrollBar offers a lightweight version of the
java.awt.Scrollbar component.
public class ScrollbarPanel extends JPanel {
public ScrollbarPanel() {
setLayout(new BorderLayout());
JScrollBar scrollBar1 = new JScrollBar (
JScrollBar.VERTICAL, 0, 5, 0, 100);
add(scrollBar1, BorderLayout.EAST);
JScrollBar scrollBar2 = new JScrollBar (
JScrollBar.HORIZONTAL, 0, 5, 0, 100);
add(scrollBar2, BorderLayout.SOUTH);
}
}
JSlider functions like a JScrollBar;
however, it adds the ability to display major and minor tick marks,
as well as display a Border
around the slider.
public class SliderPanel extends JPanel {
public SliderPanel() {
setLayout(new BorderLayout());
JSlider slider1 =
new JSlider (JSlider.VERTICAL, 0, 100, 50);
slider1.setPaintTicks(true);
slider1.setMajorTickSpacing(10);
slider1.setMinorTickSpacing(2);
add(slider1, BorderLayout.EAST);
JSlider slider2 =
new JSlider (JSlider.VERTICAL, 0, 100, 50);
slider2.setPaintTicks(true);
slider2.setMinorTickSpacing(5);
add(slider2, BorderLayout.WEST);
JSlider slider3 =
new JSlider (JSlider.HORIZONTAL, 0, 100, 50);
slider3.setPaintTicks(true);
slider3.setMajorTickSpacing(10);
add(slider3, BorderLayout.SOUTH);
JSlider slider4 =
new JSlider (JSlider.HORIZONTAL, 0, 100, 50);
slider4.setBorder(
BorderFactory.createLineBorder(Color.blue));
add(slider4, BorderLayout.NORTH);
}
}
In addition to plain tick marks, with JSlider you
can place labels along the axis as either a serious of numbers or
components. For numeric labels, by just calling setPaintLabels
(true), the slider will generate and use a series of labels
based on the major tick spacing. So, if the slider range is 0 to 100
with tick spacing of 10, the slider would then have labels of 0, 10,
20, ... 100. On the other hand, if you want to generate the labels
yourself, you can provide a Hashtable of labels. The
hashtable key would be the Integer value of the
position. The hashtable value would be a Component to
use for display of the label. The following demonstrates both:
public class SliderPanel2 extends JPanel {
public SliderPanel2() {
setLayout(new BorderLayout());
JSlider right, bottom;
right = new JSlider(JSlider.VERTICAL, 1, 9, 3);
Hashtable h = new Hashtable();
h.put (new Integer (1), new JLabel("Mercury"));
h.put (new Integer (2), new JLabel("Venus"));
h.put (new Integer (3), new JLabel("Earth"));
h.put (new Integer (4), new JLabel("Mars"));
h.put (new Integer (5), new JLabel("Jupiter"));
h.put (new Integer (6), new JLabel("Saturn"));
h.put (new Integer (7), new JLabel("Uranus"));
h.put (new Integer (8), new JLabel("Neptune"));
h.put (new Integer (9), new JLabel("Pluto"));
right.setLabelTable (h);
right.setPaintLabels (true);
right.setInverted (true);
bottom =
new JSlider(JSlider.HORIZONTAL, 0, 100, 25);
bottom.setMajorTickSpacing (10);
bottom.setPaintLabels (true);
add(right, BorderLayout.EAST);
add(bottom, BorderLayout.SOUTH);
}
}
The JProgressBar component allows you to display a
progress bar to reflect the status of an operation. The general
format of using a JProgressBar is as follows:
- Initialize
the
JProgressBar: JProgressBar progressBar = new JProgressBar();
progressBar.setMinimum(0);
progressBar.setMaximum(numberSubOperations);
- Repeat each
time you want to perform an operation:
progressBar.setValue(progressBar.getMinimum());
for (int i = 0; i < numberSubOperations; i++) {
// Perform sub-operation i
// Update bar value in event thread
// Where runner is created outside for loop
SwingUtilities.invokeAndWait(runner);
}
- Outside the
for-loop, create the
Runnable object Runnable runner = new Runnable() {
public void run() {
int value = progressBar.getValue();
progressBar.setValue(value+1);
}
};
Often, you will want to set up an operation to execute in a
thread and have the operation monitored by a progress bar. This
allows the user to cancel the operation if it is taking too long.
(The ProgressMonitorInputStream class provides this
type of behavior for reading input streams.)
To demonstrate JProgressBar, an example follows. The
stepping thread simply counts up, displaying the current count in a
JTextField. In addition, the bar displays the current
value by setting its stringPainted property to true
with progressBar.setStringPainted(true).
public class ProgressBarPanel extends JPanel {
Thread loadThread;
Object lock = new Object();
boolean shouldStop=false;
JTextField progressTextField;
JProgressBar progressBar;
public ProgressBarPanel() {
setLayout(new BorderLayout());
progressTextField = new JTextField();
add(progressTextField, BorderLayout.NORTH);
JPanel bottomPanel = new JPanel();
progressBar = new JProgressBar();
progressBar.setStringPainted(true);
bottomPanel.setLayout(new GridLayout(0,1));
bottomPanel.add(progressBar);
bottomPanel.add(new JLabel("Load Status"));
JPanel buttonPanel = new JPanel();
JButton startButton = new JButton("Start");
buttonPanel.add(startButton);
startButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
startLoading();
}
});
JButton stopButton = new JButton("Stop");
buttonPanel.add(stopButton);
stopButton.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
stopLoading();
}
});
bottomPanel.add(buttonPanel);
add(bottomPanel, BorderLayout.SOUTH);
}
public void startLoading() {
if(loadThread == null) {
loadThread = new LoadThread();
shouldStop = false;
loadThread.start();
}
}
public void stopLoading() {
synchronized(lock) {
shouldStop = true;
lock.notify();
}
}
class LoadThread extends Thread {
public void run () {
int min = 0;
int max = 100;
progressBar.setValue(min);
progressBar.setMinimum(min);
progressBar.setMaximum(max);
Runnable runner = new Runnable() {
public void run() {
int value = progressBar.getValue();
value++;
progressBar.setValue(value);
progressTextField.setText (""+value);
}
};
for (int i=min;i<=max;i++) {
try {
SwingUtilities.invokeAndWait(runner);
} catch (InvocationTargetException e) {
break;
} catch (InterruptedException e) {
// Ignore Exception
}
synchronized(lock) {
if(shouldStop)
break;
try {
lock.wait(100);
} catch (InterruptedException e) {
// Ignore Exception
}
}
}
loadThread = null;
}
}
}
The JComboBox works like AWT's Choice
component, but renames some methods and offers an editable option.
For times when a fixed-list of choices isn't enough, you can offer a
JComboBox with a list of default choices, but still
permit the entry of another value. The nicest part about this
control is that when the user presses the key for the first letter
of an entry, it changes the highlighted selection. You can enhance
this behavior by providing your own
KeySelectionManager, a public inner class of
JComboBox.
public class ComboPanel extends JPanel {
String choices[] = {
"Mercury", "Venus", "Earth",
"Mars", "Jupiter", "Saturn",
"Uranus","Neptune", "Pluto"};
public ComboPanel() {
JComboBox combo1 = new JComboBox();
JComboBox combo2 = new JComboBox();
for (int i=0;i<choices.length;i++) {
combo1.addItem (choices[i]);
combo2.addItem (choices[i]);
}
combo2.setEditable(true);
combo2.setSelectedItem("X");
combo2.setMaximumRowCount(4);
add(combo1);
add(combo2);
}
}
There is more to JComboBox than just a few new
methods and editability. Details are included in Part II of this
course, after the Model/View/Controller (MVC) Architecture has been
explained.
The JList component has both an easy (non-MVC)
implementation and a more complicated view. For the MVC-view, you'll
see an example in Part II of this course with
JComboBox. For now, you'll see how to display a list of
String objects, just like an AWT List
component. Thankfully, it has gotten much easier. To add a
String[] (or Vector) of elements to a
JList, just tell the constructor or use the
setListData() method.
There is one major difference between List and
JList. JList doesn't directly support
scrolling. You need to place the JList within a
JScrollPane object, and let it deal with the scrolling.
public class ListPanel extends JPanel {
String label [] = {"Cranberry", "Orange",
"Banana", "Kiwi", "Blueberry",
"Pomegranate", "Apple", "Pear",
"Watermelon", "Raspberry", "Snozberry"
};
public ListPanel() {
setLayout (new BorderLayout());
JList list = new JList(label);
JScrollPane pane = new JScrollPane(list);
add(pane, BorderLayout.CENTER);
}
}
The javax.swing.border package consists of several
objects to draw borders around components. They all implement the
Border interface, which consists of three methods:
public Insets
getBorderInsets(Component c)
Defines the drawable area
necessary to draw the border
public boolean
isBorderOpaque()
Defines if the border area is opaque or
transparent
public void
paintBorder (Component c, Graphics g, int x, int y, int width, int
height)
Defines how to draw the border within the
specified area. The routine should only draw into the area
requested with getBorderInsets().
The border behavior is defined for JComponent, so
all subclasses inherit the behavior.
Swing provides nine borders, and you can create your own if none
of them meets your needs:
AbstractBorder
- An abstract class that implements the Border
interface, but does nothing
BevelBorder
- A 3D border that may be raised or lowered
CompoundBorder
- A border that can nest multiple borders
EmptyBorder
- A border where you specify the reserved space for an
undrawn border
EtchedBorder
- A border that appears as a groove, instead of raised or
lowered
LineBorder
- A border for single color borders, with arbitrary
thickness
MatteBorder
- A border that permits tiling of an icon or color
SoftBevelBorder
- A 3D border with softened corners
TitledBorder
- A border that permits title strings in arbitrary
locations
You can create a border object directly from the appropriate
class constructor or ask a BorderFactory to create the
border for you, with methods like
createBevelBorder(type) and
createTitledBorder("TItle"). When using
BorderFactory, multiple requests to create the same
border return the same object.
public class BorderPanel extends JPanel {
class MyBorder implements Border {
Color color;
public MyBorder (Color c) {
color = c;
}
public void paintBorder (Component c, Graphics g,
int x, int y, int width, int height) {
Insets insets = getBorderInsets(c);
g.setColor (color);
g.fillRect (x, y, 2, height);
g.fillRect (x, y, width, 2);
g.setColor (color.darker());
g.fillRect (x+width-insets.right, y, 2, height);
g.fillRect (x, y+height-insets.bottom, width, 2);
}
public boolean isBorderOpaque() {
return false;
}
public Insets getBorderInsets(Component c) {
return new Insets (2, 2, 2, 2);
}
}
public BorderPanel() {
setLayout (new GridLayout (4, 3, 5, 5));
JButton b = new JButton("Empty");
b.setBorder (new EmptyBorder (1,1,1,1));
add(b);
b = new JButton ("Etched");
b.setBorder (new EtchedBorder ());
add(b);
b = new JButton ("ColorizedEtched");
b.setBorder (new EtchedBorder (Color.red,
Color.green));
add(b);
b = new JButton ("Titled/Line");
b.setBorder(new TitledBorder (
new TitledBorder(
LineBorder.createGrayLineBorder(),
"Hello"),
"World",
TitledBorder.RIGHT,
TitledBorder.BOTTOM));
add(b);
b = new JButton ("Bevel Up");
b.setBorder(new BevelBorder(BevelBorder.RAISED));
add(b);
b = new JButton ("Bevel Down");
b.setBorder(new BevelBorder(BevelBorder.LOWERED));
add(b);
b = new JButton ("Soft Bevel Up");
b.setBorder(
new SoftBevelBorder(SoftBevelBorder.RAISED));
add(b);
b = new JButton ("Soft Bevel Down");
b.setBorder(
new SoftBevelBorder(SoftBevelBorder.LOWERED));
add(b);
b = new JButton ("Matte");
b.setBorder(
new MatteBorder(5, 10, 5, 10, Color.red));
add(b);
b = new JButton ("Matte Icon");
Icon icon = new ImageIcon ("SmallTiger.gif");
b.setBorder(new MatteBorder(10, 10, 10, 10, icon));
add(b);
b = new JButton ("ColorizedBezel");
b.setBorder(new BevelBorder(BevelBorder.RAISED,
Color.red, Color.pink));
add(b);
b = new JButton ("My/Compound");
b.setBorder(new CompoundBorder(
new MyBorder(Color.red),
new CompoundBorder (new MyBorder(Color.green),
new MyBorder(Color.blue))));
add(b);
}
}
You can change the border of any JComponent object
with the setBorder() method.
Magercise
- Using
Borders
The menuing model used in Swing is nearly identical to that used
in AWT. There are three key exceptions:
- The menu
classes (
JMenuItem, JCheckBoxMenuItem,
JMenu, and JMenuBar) are all subclasses
of JComponent. They are not off in their own
independent class hierarchy. As a result of this, you can place a
JMenuBar within any Container, including
Applet. [The JApplet class has a
setJMenuBar() method to add a
JMenuBar.]
- There is a
new menu class,
JRadioButtonMenuItem, to provide a
set of mutually exclusive checkboxes on a menu, when placed within
a ButtonGroup.
- Also, you
can associate an
Icon object with any
JMenuItem.
public class MenuTester extends JFrame
implements ActionListener {
public void actionPerformed (ActionEvent e) {
System.out.println (e.getActionCommand());
}
public MenuTester() {
super ("Menu Example");
JMenuBar jmb = new JMenuBar();
JMenu file = new JMenu ("File");
JMenuItem item;
file.add (item = new JMenuItem ("New"));
item.addActionListener (this);
file.add (item = new JMenuItem ("Open"));
item.addActionListener (this);
file.addSeparator();
file.add (item = new JMenuItem ("Close"));
item.addActionListener (this);
jmb.add (file);
JMenu edit = new JMenu ("Edit");
edit.add (item = new JMenuItem ("Copy"));
item.addActionListener (this);
Icon tigerIcon = new ImageIcon("SmallTiger.gif");
edit.add (item =
new JMenuItem ("Woods", tigerIcon));
item.setHorizontalTextPosition (JMenuItem.LEFT);
item.addActionListener (this);
edit.add (item =
new JMenuItem ("Woods", tigerIcon));
item.addActionListener (this);
jmb.add (edit);
JMenu choice = new JMenu ("Choices");
JCheckBoxMenuItem check =
new JCheckBoxMenuItem ("Toggle");
check.addActionListener (this);
choice.add (check);
ButtonGroup rbg = new ButtonGroup();
JRadioButtonMenuItem rad =
new JRadioButtonMenuItem ("Choice 1");
choice.add (rad);
rbg.add (rad);
rad.addActionListener (this);
rad = new JRadioButtonMenuItem ("Choice 2");
choice.add (rad);
rbg.add (rad);
rad.addActionListener (this);
rad = new JRadioButtonMenuItem ("Choice 3");
choice.add (rad);
rbg.add (rad);
rad.addActionListener (this);
jmb.add (choice);
setJMenuBar (jmb);
}
}
The JSeparator object is the menu separator control.
The image below shows the separator under the File menu from the
example above.
Because Swing menu objects are truly components, you can use
JSeparator outside of menus, too. However, normally you
just add them to a JMenu with
addSeparator().
The JPopupMenu component allows you to associate
context-sensitive menus with any JComponent. They work
similarly to the AWT PopupMenu class, with an
addSeparator() method to add a separator bar.
public class PopupPanel extends JPanel {
JPopupMenu popup = new JPopupMenu ();
public PopupPanel() {
JMenuItem item;
popup.add (item = new JMenuItem ("Cut"));
popup.add (item = new JMenuItem ("Copy"));
popup.add (item = new JMenuItem ("Paste"));
popup.addSeparator();
popup.add (item = new JMenuItem ("Select All"));
popup.setInvoker (this);
addMouseListener (new MouseAdapter() {
public void mousePressed (MouseEvent e) {
if (e.isPopupTrigger()) {
popup.show (e.getComponent(),
e.getX(), e.getY());
}
}
public void mouseReleased (MouseEvent e) {
if (e.isPopupTrigger()) {
popup.show (e.getComponent(),
e.getX(), e.getY());
}
}
});
}
}
The Window class hierarchy is a little different
when the Swing window classes are added.
As the diagram shows, they all subclass Window, not
JComponent. This means they are not
lightweight, have a peer, and cannot be transparent.
The JFrame class is the replacement for AWT's
Frame class. In addition to the ability to add a
java.awt.MenuBar via setMenuBar(), you can
add a JMenuBar to a JFrame via
setJMenuBar().
The other difference of the JFrame class is shared
with the JWindow and JDialog classes. No
longer do you just add() components to each directly or
setLayout() to change the LayoutManager.
Now, you must get what's called a content pane, then add
components to that or change its layout.
public class FrameTester {
public static void main (String args[]) {
JFrame f = new JFrame ("JFrame Example");
Container c = f.getContentPane();
c.setLayout (new FlowLayout());
for (int i = 0; i < 5; i++) {
c.add (new JButton ("No"));
c.add (new Button ("Batter"));
}
c.add (new JLabel ("Swing"));
f.setSize (300, 200);
f.show();
}
}
The reason you have to get a content pane is because the inside
of a window is now composed of a JRootPane, which no
longer shields you from the inner workings of the
Window, as AWT did.
One other difference between JFrame and
Frame is JFrame has a property that
defines the default close operation. With Frame,
nothing happens, by default, if you try to close the frame. On the
other hand, JFrame will hide itself when you try to
close it. The setDefaultCloseOperation() method lets
you define three operations that can happen when the user tries to
close a JFrame:
DO_NOTHING_ON_CLOSE:
The AWT Frame behavior
HIDE_ON_CLOSE:
The default behavior. When user tries to close the window, the
window will be hidden. You can then setVisible(true)
to reshow it.
DISPOSE_ON_CLOSE:
When user tries to close window, it will be disposed.
Both HIDE_ON_CLOSE and DISPOSE_ON_CLOSE
perform their operations last, in case an event listener needs to
use the information from the closing event.
A JRootPane is a container that consists of two
objects, a glass pane and a layered pane. The glass pane is
initially invisible, so all you see is the layered pane. The layered
pane also consists of two objects, an optional menu bar and a
content pane. You work with the content pane just like you would the
inside of a Window, Dialog, or
Frame in AWT. The way the glass pane works is if you
place a component in it, this component will always display in front
of the content pane. This allows things like popup menus and tool
tip text to work properly. The layering effect is done with the help
of the new JLayeredPane component, explained next.
Normally, the only difference in coding is changing all lines
like:
aFrame.setLayout (new FlowLayout());
aFrame.add(aComponent);
to new lines accessing the content pane:
aFrame.getContentPane().setLayout (new FlowLayout());
aFrame.getContentPane().add(aComponent);
The rest of the panes are accessed with similar methods, though
are rarely accessed directly. The layout management of all these
panes is done through a custom layout manager.
Container getContentPane();
setContentPane (Container);
Component getGlassPane();
setGlassPane (Component);
JLayeredPane getLayeredPane();
setLayeredPane (JLayeredPane);
JMenuBar getMenuBar();
setMenuBar (JMenuBar);
The JLayeredPane container keeps its children in
layers to define an order to paint its components. When you add a
component to the pane, you specify which layer you want it in:
layeredPane.add (component, new Integer(5));
The default layer is the value
JLayeredPane.DEFAULT_LAYER. You can add or subtract
values from this value to have things appear above or below,
layerwise. The LayoutManager of the pane determines
what happens with the layers. Using FlowLayout or
GridLayout as the layout only reorders the components
as they are added; they will not be drawn on top of each other. For
an example of actually drawing overlaid components, see the
examples subdirectory that comes with the Swing
release.
For applets to properly handle the Swing component set, your
applets need to subclass JApplet instead of
Applet. JApplet is a special subclass of
Applet that adds support for JMenuBar and
handles the painting support required by Swing child components
(along with any other necessary tasks like accessibility support).
Also, like JFrame, JApplet has a
JContentPane to add components into, instead of
directly to the applet. Another difference is the default
LayoutManager: in JApplet it is
BorderLayout, while in Applet it has
always been FlowLayout.
public class AppTester extends JApplet {
public void init () {
Container c = getContentPane();
JButton jb = new JButton ("Default");
c.add (jb, BorderLayout.WEST);
jb = new JButton ("LayoutManager");
c.add (jb, BorderLayout.CENTER);
jb = new JButton ("is");
c.add (jb, BorderLayout.EAST);
jb = new JButton ("BorderLayout: " +
(c.getLayout() instanceof BorderLayout));
c.add (jb, BorderLayout.SOUTH);
}
}
The LayoutManager is actually a custom subclass of
BorderLayout. This subclassing ensures that when a
component with no constraints is added, the subclass maps the
component to the CENTER area.
A tooltip is a context-sensitive text string that is
displayed in a popup window when the mouse rests over a particular
object on the screen. Swing provides the JToolTip class
to support this; however, you will rarely use it directly. To create
a tooltip, you only need to call the setToolTipText()
method of JComponent.
public class TooltipPanel extends JPanel {
public TooltipPanel() {
JButton myButton = new JButton("Hello");
myButton.setToolTipText ("World");
add(myButton);
}
}
The JToolBar control offers a container that
displays its components in a toolbar fashion, across or down, in one
row or column, depending upon the area of the screen it is placed
in. Certain user-interface models permit floatable
toolbars; the default user-interface is one that supports floating.
In order to disable the floatable capability, just call the
setFloatable() method. It is possible that a particular
user interface may ignore this setting.
// Disabling floating
aToolBar.setFloatable (false);
When JToolBar is considered floatable, this means a
user can drag it to another area of the screen, or place it in a
window external from the original container.
To demonstrate a JToolBar, take a look at the
following example. As it demonstrates, there are no restrictions on
what components appear within the toolbar. However, it works best if
they are all the same type and size.
public class ToolbarPanel extends JPanel {
ToolbarPanel() {
setLayout (new BorderLayout());
JToolBar toolbar = new JToolBar();
JButton myButton = new JButton("Hello");
toolbar.add(myButton);
Icon tigerIcon = new ImageIcon("SmallTiger.gif");
myButton = new JButton(tigerIcon);
toolbar.add(myButton);
toolbar.addSeparator();
toolbar.add (new Checkbox ("Not"));
add (toolbar, BorderLayout.NORTH);
toolbar = new JToolBar();
Icon icon = new AnOvalIcon(Color.red);
myButton = new JButton(icon);
toolbar.add(myButton);
icon = new AnOvalIcon(Color.blue);
myButton = new JButton(icon);
toolbar.add(myButton);
icon = new AnOvalIcon(Color.green);
myButton = new JButton(icon);
toolbar.add(myButton);
toolbar.addSeparator();
icon = new AnOvalIcon(Color.magenta);
myButton = new JButton(icon);
toolbar.add(myButton);
add (toolbar, BorderLayout.SOUTH);
}
class AnOvalIcon implements Icon {
Color color;
public AnOvalIcon (Color c) {
color = c;
}
public void paintIcon (Component c, Graphics g,
int x, int y) {
g.setColor(color);
g.fillOval (
x, y, getIconWidth(), getIconHeight());
}
public int getIconWidth() {
return 20;
}
public int getIconHeight() {
return 10;
}
}
}
After dragging around the toolbar, the user may just leave it
looking a little different than you originally planned:
Magercise
- Using
Menus, Toolbars, and Tool Tips
The JTabbedPane component offers a tabbed control
for quick accessibility to multiple panels. If you ever tried to use
CardLayout in JDK 1.0/1.1, you'll appreciate this:
JTabbedPane adds the necessary support for changing
from one card to the next. After creating the control, you add cards
to it with the addTab() method. There are three forms
for the addTab() method. One offers a quick way to
associate a JToolTip to a tab, while the others only
permit text, an Icon, or both. Any
Component subclass can be the object added to each
card.
addTab(String
title, Component component) - Create new tab with
title as tab label and component shown within
tab when selected.
addTab(String
title, Icon icon, Component component) - Adds an options
icon to be associated with the title for the
tab. Either may be null.
addTab(String
title, Icon icon, Component component, String tip) - Adds
tip as the tooltip for the tab.
public class TabbedPanel extends JPanel {
String tabs[] = {"One", "Two", "Three", "Four"};
public JTabbedPane tabbedPane = new JTabbedPane();
public TabbedPanel() {
setLayout (new BorderLayout());
for (int i=0;i<tabs.length;i++)
tabbedPane.addTab (tabs[i], null,
createPane (tabs[i]));
tabbedPane.setSelectedIndex(0);
add (tabbedPane, BorderLayout.CENTER);
}
JPanel createPane(String s) {
JPanel p = new JPanel();
p.add(new JLabel(s));
return p;
}
}
The JSplitPane control offers user-controlled
resizing of two components within a container.
You can place a JSplitPane within a
JSplitPane for control of more then two components,
and, you can control whether the splitting happens vertically or
horizontally.
The setContinuousLayout property causes each pane to
be updated continuously as the splitter is dragged, when set to
true.
You can move the divider programmatically by setting the
dividerLocation property to a floating point value
between 0.0 and 1.0 to indicate a percentage of the screen or to an
integer value for an absolute position.
The following screenshots demonstrate a JSplitPane
between a JTree and a JList. (Note that
the scrollbars in the pictures are there because the components are
included in a JScrollPane; it is not a result of the
JSplitPane.
The arrows on the splitter bar are obtained by setting the
oneTouchExpandable property of the
JSplitPane to true. Pressing them will
fully push the splitter in the direction of the arrow, or return it
to its previous position.
Note that the splitter bar will not move past the
minimumSize of either component if it can avoid it. In
many cases it is desirable to call the following:
comp.setMinimumSize(new Dimension(0,0));
on each component to allow full movement of the splitter bar.
public class JSplitPanel extends JPanel {
public JSplitPanel() {
setLayout(new BorderLayout());
JTree tree = new JTree();
String[] items = {"a", "two", "three",
"four", "five", "six", "seven"};
JList list = new JList(items);
JScrollPane left = new JScrollPane(tree);
JScrollPane right = new JScrollPane(list);
left.setMinimumSize(new Dimension(0,0));
right.setMinimumSize(new Dimension(0,0));
JSplitPane pane = new JSplitPane(
JSplitPane.HORIZONTAL_SPLIT, left, right);
pane.setDividerLocation(0.5);
pane.setOneTouchExpandable(true);
add(pane, BorderLayout.CENTER);
}
}
There are four primary Swing layout managers, two are built into
components (ScrollPaneLayout and
ViewportLayout) and the remaining two
(BoxLayout and OverlayLayout) are used
like the ones from java.awt. The BoxLayout
also happens to be built into the Box component.
The BoxLayout layout manager allows you to arrange
components along either an x-axis or y-axis. For instance, in a
y-axis BoxLayout, components are arranged from top to
bottom in the order in which they are added.
Unlike GridLayout, BoxLayout allows
components to occupy different amounts of space along the primary
axis. A JTextField in a top-to-bottom
BoxLayout can take much less space than a
JTextArea.
Along the non-primary axis, BoxLayout attempts to
make all components as tall as the tallest component (for
left-to-right BoxLayouts) or as wide as the widest
component (for top-to-bottom BoxLayouts). If a
component cannot increase to this size, BoxLayout looks
at its Y-alignment property or X-alignment property to determine how
to place it within the available space. By default,
JComponent objects inherit an alignment of 0.5
indicating that they will be centered. You can override the
getAlignmentX() and getAlignmentY()
methods of Container to specify a different default
alignment. JButton for instance specifies left
alignment.
To create a BoxLayout, you must specify two
parameters:
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
The first parameter specifies the container and the second the
major axis of the BoxLayout. Components can then be
added as they are in a GridLayout or
FlowLayout:
add(myComponent);
class BoxLayoutTest extends JPanel {
BoxLayoutTest() {
// Set the layout to a y-axis BoxLayout
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
// Create three components
TextField textField = new TextField();
TextArea textArea = new TextArea(4, 20);
JButton button = new JButton(
"Tiger", new ImageIcon("SmallTiger.gif"));
// Add the three components to the BoxLayout
add(new JLabel("TextField:"));
add(textField);
add(new JLabel("TextArea:"));
add(textArea);
add(new JLabel("Button:"));
add(button);
}}
The Box class is a convenience container whose
default layout manager is a BoxLayout. Rather than
subclassing JPanel as above, the previous example could
have subclassed the Box class. In addition to being a
BoxLayout container, Box has some very
useful static methods for arranging components in a
BoxLayout. These methods create non-visual components
that act as fillers and spacers.
createVerticalStrut(int) |
Returns
a fixed height component used for spacing |
createHorizontalStrut(int) |
Returns
a fixed width component used for spacing |
createVerticalGlue() |
Returns
a component whose height expands to absorb excess space
between components |
createHorizontalGlue() |
Returns
a component whose width expands to absorb excess space between
components |
createGlue() |
Returns
a component whose height will expand for a y-axis box and
whose width will expand for an x-axis Box |
createRigidArea(Dimension) |
Returns
a fixed height, fixed width component used for
spacing |
Now, rather than using labels to space components out as above,
you could use struts and glue:
public class TestBox extends Box {
TestBox() {
super(BoxLayout.Y_AXIS);
// Create the three basic text components
TextField textField = new TextField();
TextArea textArea = new TextArea(4, 20);
JButton button = new JButton("Tiger", new
ImageIcon("SmallTiger.gif"));
// Separate the three components
// by struts for spacing
add(createVerticalStrut(8));
add(textField);
add(createVerticalGlue());
add(textArea);
add(createVerticalGlue());
add(button);
add(createVerticalStrut(8));
}
}
The struts will appear as top and bottom margins and the glue
will expand to fill space when the Box is heightened.
Magercise
- Using
BoxLayout
The ScrollPaneLayout is the layout manager used by a
JScrollPane. You do not need to create one, nor
associate it to the JScrollPane. That is done for you
automatically. The layout defines nine different areas for the
JScrollPane:
- one
JViewport - in the center for the content
- two
JScrollBar objects - one each for horizontal and
vertical scrolling
- two
JViewport objects - one for a column headers, the
other row
- four
Component objects - one for each of the
corners
The JScrollPane constants to specify the
corners are: LOWER_LEFT_CORNER,
LOWER_RIGHT_CORNER, UPPER_LEFT_CORNER,
UPPER_RIGHT_CORNER.
The center viewport portion of this layout is of primary interest
for simple layouts. A JViewport is itself a container
object that can hold components. This allows for some very flexible
arrangements. JViewport contains its own layout
manager, ViewportLayout.
ViewportLayout is the layout manager used by a
JViewport. You should never need to use the layout
directly, as it is automatically associated with a
JViewport object, and positions the internal component
for you based upon the JViewport properties.
While this may seem like quite a bit for Swing, there is much
more to see, do, and learn. To follow the latest Swing-related
happenings, be sure to visit Sun's online technical resource The Swing
Connection. Certain topics you should be sure not to miss:
Copyright © 1998-1999 MageLang
Institute. All Rights Reserved.
Requires login
