JButton object that draws a scaled Arrow in one of the cardinal directions.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Factory object that can vend Borders appropriate for the basic L & F.

Special thin border for rollover toolbar buttons.

Draws the border around the splitpane. To work correctly you should
also install a border on the divider (property SplitPaneDivider.border).

Button Listener

BasicButton implementation

BasicCheckboxMenuItem implementation

CheckboxUI implementation for BasicCheckboxUI

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Provides the basic look and feel for a JColorChooser.

The default editor for editable combo boxes. The editor is implemented as a JTextField.

A subclass of BasicComboBoxEditor that implements UIResource.
BasicComboBoxEditor doesn't implement UIResource
directly so that applications can safely override the
cellRenderer property with BasicListCellRenderer subclasses.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

ComboBox renderer

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

A subclass of BasicComboBoxRenderer that implements UIResource.
BasicComboBoxRenderer doesn't implement UIResource
directly so that applications can safely override the
cellRenderer property with BasicListCellRenderer subclasses.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Basic UI implementation for JComboBox.

The combo box is a compound component which means that it is an aggregate of
many simpler components. This class creates and manages the listeners
on the combo box and the combo box model. These listeners update the user
interface in response to changes in the properties and state of the combo box.

All event handling is handled by listener classes created with the
createxxxListener() methods and internal classes.
You can change the behavior of this class by overriding the
createxxxListener() methods and supplying your own
event listeners or subclassing from the ones supplied in this class.

For adding specific actions,
overide installKeyboardActions to add actions in response to
KeyStroke bindings. See the article How to Use Key Bindings

This is a basic implementation of the ComboPopup interface.

This class represents the ui for the popup portion of the combo box.

All event handling is handled by listener classes created with the
createxxxListener() methods and internal classes.
You can change the behavior of this class by overriding the
createxxxListener() methods and supplying your own
event listeners or subclassing from the ones supplied in this class.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Basic L&F for a minimized window on a desktop.

Basic L&F for a desktop.

Basic implementation of a file list.

Provides the look and feel for a JEditorPane.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Basic L&F implementation of a FileChooser.

Provides the look and feel implementation for
JFormattedTextField.

Support for providing html views for the swing components.
This translates a simple html string to a javax.swing.text.View
implementation that can render the html and provide the necessary
layout semantics.

Factory object that can vend Icons appropriate for the basic L & F.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

The class that manages a basic title bar

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

A basic L&F implementation of JInternalFrame.

A Windows L&F implementation of LabelUI.  This implementation
is completely static, i.e. there's only one UIView implementation
that's shared by all JLabel objects.

An extensible implementation of ListUI.

BasicListUI instances cannot be shared between multiple
lists.

A base class to use in creating a look and feel for Swing.

Each of the ComponentUIs provided by BasicLookAndFeel derives its behavior from the defaults
table. Unless otherwise noted each of the ComponentUI
implementations in this package document the set of defaults they
use. Unless otherwise noted the defaults are installed at the time
installUI is invoked, and follow the recommendations
outlined in LookAndFeel for installing defaults.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

A default L&F implementation of MenuBarUI.  This implementation
is a "combined" view/controller.

BasicMenuItem implementation

A default L&F implementation of MenuUI.  This implementation
is a "combined" view/controller.

   ------------------
   | i | message    |
   | c | message    |
   | o | message    |
   | n | message    |
   ------------------
   |     buttons    |
   |________________|

Provides the basic look and feel for a JOptionPane.
BasicMessagePaneUI provides a means to place an icon,
message and buttons into a Container.
Generally, the layout will look like:


       ------------------
       | i | message    |
       | c | message    |
       | o | message    |
       | n | message    |
       ------------------
       |     buttons    |
       |________________|
icon is an instance of Icon that is wrapped inside a
JLabel.  The message is an opaque object and is tested
for the following: if the message is a Component it is
added to the Container, if it is an Icon
it is wrapped inside a JLabel and added to the
Container otherwise it is wrapped inside a JLabel.

The above layout is used when the option pane's
ComponentOrientation property is horizontal, left-to-right.
The layout will be adjusted appropriately for other orientations.

The Container, message, icon, and buttons are all
determined from abstract methods.

ButtonAreaLayout behaves in a similar manner to
FlowLayout. It lays out all components from left to
right. If syncAllWidths is true, the widths of each
component will be set to the largest preferred size width.

This class should be treated as a "protected" inner class.
Instantiate it only within subclasses of BasicOptionPaneUI.

BasicPanel implementation

Provides the Windows look and feel for a password field.
The only difference from the standard text field is that
the view of the text is simply a string of the echo
character as specified in JPasswordField, rather than the
real text contained in the field.

A Basic L&F implementation of PopupMenuSeparatorUI.  This implementation
is a "combined" view/controller.

A Windows L&F implementation of PopupMenuUI.  This implementation
is a "combined" view/controller.

A Basic L&F implementation of ProgressBarUI.

BasicRadioButtonMenuItem implementation

RadioButtonUI implementation for BasicRadioButtonUI

Basic implementation of RootPaneUI, there is one shared between all
JRootPane instances.

Implementation of ScrollBarUI for the Basic Look and Feel

A default L&F implementation of ScrollPaneUI.

A Basic L&F implementation of SeparatorUI.  This implementation
is a "combined" view/controller.

A Basic L&F implementation of SliderUI.

The default Spinner UI delegate.

Divider used by BasicSplitPaneUI. Subclassers may wish to override
paint to do something more interesting.
The border effect is drawn in BasicSplitPaneUI, so if you don't like
that border, reset it there.
To conditionally drag from certain areas subclass mousePressed and
call super when you wish the dragging to begin.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

A Basic L&F implementation of the SplitPaneUI.

A Basic L&F implementation of TabbedPaneUI.

BasicTableHeaderUI implementation

BasicTableUI implementation

Provides the look and feel for a plain text editor.  In this
implementation the default UI is extended to act as a simple
view factory.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Basis of a look and feel for a JTextField.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

Provides the look and feel for a styled text editor.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

 Basis of a text components look-and-feel.  This provides the
basic editor view and controller services that may be useful
when creating a look-and-feel for an extension of
JTextComponent.

Most state is held in the associated JTextComponent
as bound properties, and the UI installs default values for the
various properties.  This default will install something for
all of the properties.  Typically, a LAF implementation will
do more however.  At a minimum, a LAF would generally install
key bindings.

This class also provides some concurrency support if the
Document associated with the JTextComponent is a subclass of
AbstractDocument.  Access to the View (or View hierarchy) is
serialized between any thread mutating the model and the Swing
event thread (which is expected to render, do model/view coordinate
translation, etc).  Any access to the root view should first
acquire a read-lock on the AbstractDocument and release that lock
in a finally block.

An important method to define is the getPropertyPrefix() method
which is used as the basis of the keys used to fetch defaults
from the UIManager.  The string should reflect the type of
TextUI (eg. TextField, TextArea, etc) without the particular
LAF part of the name (eg Metal, Motif, etc).

To build a view of the model, one of the following strategies
can be employed.


One strategy is to simply redefine the
ViewFactory interface in the UI.  By default, this UI itself acts
as the factory for View implementations.  This is useful
for simple factories.  To do this reimplement the
create(javax.swing.text.Element) method.

A common strategy for creating more complex types of documents
is to have the EditorKit implementation return a factory.  Since
the EditorKit ties all of the pieces necessary to maintain a type
of document, the factory is typically an important part of that
and should be produced by the EditorKit implementation.


Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

BasicToggleButton implementation

A Basic L&F implementation of ToolBarSeparatorUI.  This implementation
is a "combined" view/controller.

A Basic L&F implementation of ToolBarUI.  This implementation
is a "combined" view/controller.

Standard tool tip L&F.

The basic L&F for a hierarchical data structure.

BasicViewport implementation

The interface which defines the methods required for the implementation of the popup
portion of a combo box.

Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing.  As of 1.4, support for long term storage
of all JavaBeans™
has been added to the java.beans package.
Please see XMLEncoder.

The default layout manager for Popup menus and menubars.  This
class is an extension of BoxLayout which adds the UIResource tag
so that pluggable L&Fs can distinguish it from user-installed
layout managers on menus.