| |
| Package Name | Comment | | javax.swing |
swing package
Provides a set of "lightweight"
(all-Java language) components that,
to the maximum degree possible, work the same on all platforms.
For a programmer's guide to using these components, see
Creating
a GUI with JFC/Swing, a trail in The Java Tutorial.
For other resources, see
Related Documentation.
In general Swing is not thread safe. All Swing components and related
classes, unless otherwise documented, must be accessed on the event
dispatching thread.
Typical Swing applications do processing in response to an event
generated from a user gesture. For example, clicking on a {@code
JButton} notifies all {@code ActionListeners} added to the {@code
JButton}. As all events generated from a user gesture are
dispatched on the event dispatching thread, most developers are not
impacted by the restriction.
Where the impact lies, however, is in constructing and showing a
Swing application. Calls to an application's {@code main} method,
or methods in {@code Applet}, are not invoked on the event
dispatching thread. As such, care must be taken to transfer control
to the event dispatching thread when constructing and showing an
application or applet. The preferred way to transfer control and begin
working with Swing is to use {@code invokeLater}. The {@code
invokeLater} method schedules a {@code Runnable} to be processed on
the event dispatching thread. The following two examples work equally
well for transferring control and starting up a Swing application:
public class MyApp implements Runnable {
public void run() {
// Invoked on the event dispatching thread.
// Construct and show GUI.
}
public static void main(String[] args) {
SwingUtilities.invokeLater(new MyApp(args));
}
}
Or:
public class MyApp {
MyApp(String[] args) {
// Invoked on the event dispatching thread. Do any initialization
// here.
}
public void show() {
// Show the UI.
}
public static void main(final String[] args) {
// Schedule a job for the event-dispatching thread:
// creating and showing this application's GUI.
SwingUtilities.invokeLater(new Runnable() {
public void run() {
new MyApp(args).show();
}
});
}
}
This restriction also applies to models attached to Swing components.
For example, if a {@code TableModel} is attached to a {@code
JTable}, the {@code TableModel} should only be modified on the
event dispatching thread. If you modify the model on a separate
thread you run the risk of exceptions and possible display
corruption.
As all events are delivered on the event dispatching thread, care must
be taken in event processing. In particular, a long running task, such
as network io or computational intensive processing, executed on the
event dispatching thread blocks the event dispatching thread from
dispatching any other events. While the event dispatching thread is
blocked the application is completely unresponsive to user
input. Refer to {@link SwingWorker} for the preferred way to do such
processing when working with Swing.
More information on this topic can be found in the
Swing tutorial,
in particular the section on
How to Use Threads.
For overviews, tutorials, examples, guides, and other documentation, please see:
@serial exclude
| | javax.swing.border |
Provides classes and interface for drawing
specialized borders around a Swing component.
You can subclass these classes to create customized borders
for your components instead of using the default borders
provided by the look-and-feel being used.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.colorchooser |
Contains classes and interfaces used by the JColorChooser
component.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
This document forms the complete API specification. For overviews, tutorials,
examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.event |
Provides for events fired by Swing components. It contains
event classes and corresponding event listener interfaces for events
fired by Swing components in addition to those events in the
java.awt.event package.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.filechooser |
Contains classes and interfaces used by the JFileChooser component.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
This document forms the complete API specification. For overviews, tutorials,
examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.plaf |
Provides one interface and many abstract classes that
Swing uses to provide its pluggable look-and-feel capabilities. Its
classes are subclassed and implemented by look and feel UIs
such as Basic and the Java look and feel (Metal).
This package is only used by developers who
cannot create a new look and feel by subclassing existing
look-and-feel components (such as those provided
by the javax.swing.plaf.basic and
javax.swing.plaf.metal packages).
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
@since 1.2
@serial exclude
| | javax.swing.plaf.basic |
Provides user interface objects built according to the
Basic look and feel. The Basic look and feel provides default
behavior used by many look and feel packages.
It contains components, layout managers,
events, event listeners, and adapters.
You can subclass the classes in
this package to create your own customized look and feel.
These classes are designed to be used while the
corresponding LookAndFeel class has been
installed
(UIManager.setLookAndFeel(new XXXLookAndFeel())).
Using them while a different LookAndFeel is installed
may produce unexpected results, including exceptions.
Additionally, changing the LookAndFeel
maintained by the UIManager without updating the
corresponding ComponentUI of any
JComponents may also produce unexpected results,
such as the wrong colors showing up, and is generally not
encouraged.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
@since 1.2
@serial exclude
| | javax.swing.plaf.metal |
Provides user interface objects built according to
the Java look and feel (once codenamed Metal),
which is the default look and feel.
These classes are designed to be used while the
corresponding LookAndFeel class has been
installed
(UIManager.setLookAndFeel(new XXXLookAndFeel())).
Using them while a different LookAndFeel is installed
may produce unexpected results, including exceptions.
Additionally, changing the LookAndFeel
maintained by the UIManager without updating the
corresponding ComponentUI of any
JComponents may also produce unexpected results,
such as the wrong colors showing up, and is generally not
encouraged.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
@since 1.2
@serial exclude
| | javax.swing.plaf.multi |
Provides user interface objects that combine two or more look and feels.
When a component asks
for its UI, this look and feel returns a
multiplexing UI that handles all communications with both the
default look and feel and one or more auxiliary look and feels.
For example, if
a user combines an auxiliary audio look and feel
with the Motif look and feel,
the JButton.getUI method
would return an instance of MultiButtonUI,
which would handle both a
MotifButtonUI and an AudioButtonUI.
For more information, see
Using
the Multiplexing Look and Feel.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
@since 1.2
@serial exclude
| | javax.swing.plaf.synth |
Synth is a skinnable look and feel in which all painting is
delegated. Synth does not provide a default look. In
order to use Synth you need to specify a
file, or
provide a {@link
javax.swing.plaf.synth.SynthStyleFactory}. Both
configuration options require an
understanding of the synth architecture, which is described
below, as well as an understanding of Swing's architecture.
Unless otherwise specified null is not a legal value to any of
the methods defined in the synth package and if passed in will
result in a NullPointerException.
Synth
Each {@link javax.swing.plaf.ComponentUI} implementation in Synth associates
itself with one {@link
javax.swing.plaf.synth.SynthStyle} per {@link
javax.swing.plaf.synth.Region}, most
Components only have one Region and
therefor only one SynthStyle.
SynthStyle
is used to access all style related properties: fonts, colors
and other Component properties. In addition
SynthStyles are used to obtain
{@link javax.swing.plaf.synth.SynthPainter}s for painting the background, border,
focus and other portions of a Component. The ComponentUIs obtain
SynthStyles from a
{@link javax.swing.plaf.synth.SynthStyleFactory}.
A SynthStyleFactory
can be provided directly by way of
{@link javax.swing.plaf.synth.SynthLookAndFeel#setStyleFactory(javax.swing.plaf.synth.SynthStyleFactory)},
or indirectly by way of
{@link javax.swing.plaf.synth.SynthLookAndFeel#load}. The
following example uses the SynthLookAndFeel.load()
method to configure a SynthLookAndFeel and sets it
as the current look and feel:
SynthLookAndFeel laf = new SynthLookAndFeel();
laf.load(MyClass.class.getResourceAsStream("laf.xml"), MyClass.class);
UIManager.setLookAndFeel(laf);
Many JComponents are broken down into smaller
pieces and identified by the type safe enumeration in
{@link javax.swing.plaf.synth.Region}. For example, a JTabbedPane
consists of a Region for the
JTabbedPane ({@link
javax.swing.plaf.synth.Region#TABBED_PANE}), the content
area ({@link
javax.swing.plaf.synth.Region#TABBED_PANE_CONTENT}), the
area behind the tabs ({@link
javax.swing.plaf.synth.Region#TABBED_PANE_TAB_AREA}), and the
tabs ({@link
javax.swing.plaf.synth.Region#TABBED_PANE_TAB}). Each
Region of each
JComponent will have a
SynthStyle. This allows
you to customize individual pieces of each region of each
JComponent.
Many of the Synth methods take a {@link javax.swing.plaf.synth.SynthContext}. This
is used to provide information about the current
Component and includes: the
{@link javax.swing.plaf.synth.SynthStyle} associated with the current
{@link javax.swing.plaf.synth.Region}, the state of the Component
as a bitmask (refer to {@link
javax.swing.plaf.synth.SynthConstants} for the valid
states), and a {@link javax.swing.plaf.synth.Region} identifying the portion of
the Component being painted.
All text rendering by non-JTextComponents is
delegated to a {@link
javax.swing.plaf.synth.SynthGraphicsUtils}, which is
obtained using the {@link javax.swing.plaf.synth.SynthStyle} method
{@link javax.swing.plaf.synth.SynthStyle#getGraphicsUtils}. You can
customize text rendering
by supplying your own {@link javax.swing.plaf.synth.SynthGraphicsUtils}.
Notes on specific components
JTree
Synth provides a region for the cells of a tree:
Region.TREE_CELL. To specify the colors of the
renderer you'll want to provide a style for the
TREE_CELL region. The following illustrates this:
<style id="treeCellStyle">
<opaque value="TRUE"/>
<state>
<color value="WHITE" type="TEXT_FOREGROUND"/>
<color value="RED" type="TEXT_BACKGROUND"/>
</state>
<state value="SELECTED">
<color value="RED" type="TEXT_FOREGROUND"/>
<color value="WHITE" type="BACKGROUND"/>
</state>
</style>
<bind style="treeCellStyle" type="region" key="TreeCell"/>
This specifies a color combination of red on white, when
selected, and white on red when not selected. To see the
background you need to specify that labels are not opaque. The
following XML fragment does that:
<style id="labelStyle">
<opaque value="FALSE"/>
</style>
<bind style="labelStyle" type="region" key="Label"/>
JList and JTable
The colors that the renderers for JList and JTable use are
specified by way of the list and table Regions. The following
XML fragment illustrates how to specify red on white, when
selected, and white on red when not selected:
<style id="style">
<opaque value="TRUE"/>
<state>
<color value="WHITE" type="TEXT_FOREGROUND"/>
<color value="RED" type="TEXT_BACKGROUND"/>
<color value="RED" type="BACKGROUND"/>
</state>
<state value="SELECTED">
<color value="RED" type="TEXT_FOREGROUND"/>
<color value="WHITE" type="TEXT_BACKGROUND"/>
</state>
</style>
<bind style="style" type="region" key="Table"/>
<bind style="style" type="region" key="List"/>
| | javax.swing.table |
Provides classes and interfaces for dealing with
javax.swing.JTable.
JTable is Swing's grid or tabular view for
constructing user interfaces for tabular data structures inside
an application. Use this package if you want control over how tables
are constructed, updated, and rendered, as well as how data associated
with the tables are viewed and managed.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.text |
Provides classes and interfaces that deal with editable
and noneditable text components. Examples of text components are text
fields and text areas, of which password fields and document editors
are special instantiations. Features that are supported by this
package include selection/highlighting, editing, style,
and key mapping.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.text.html |
Provides the class HTMLEditorKit and supporting classes
for creating HTML text editors.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Package Specification
@since 1.2
@serial exclude
| | javax.swing.text.html.parser |
Provides the default HTML parser, along with support classes.
As the stream is parsed,
the parser notifies a delegate,
which must implement
the HTMLEditorKit.ParserCallback interface.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
@see javax.swing.text.html.HTMLEditorKit.ParserCallback
@since 1.2
@serial exclude
| | javax.swing.text.rtf |
Provides a class (RTFEditorKit) for creating Rich-Text-Format
text editors.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
@since 1.2
@serial exclude
| | javax.swing.tree |
Provides classes and interfaces for dealing with
javax.swing.JTree. You use these classes and interfaces if you want
control over how trees are constructed, updated, and rendered, as well
as how data associated with the tree nodes are viewed and managed.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
| | javax.swing.undo |
Allows developers to provide support for undo/redo
in applications such as text editors.
Note:
Most of the Swing API is not thread safe.
For details, see
Threads and Swing,
a section in
The Java Tutorial.
Related Documentation
For overviews, tutorials, examples, guides, and tool documentation, please see:
@since 1.2
@serial exclude
|
|