An event reported to a child component that originated from an
ancestor in the component hierarchy.

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.

AncestorListener

Interface to support notification when changes occur to a JComponent or one
of its ancestors.  These include movement and when the component becomes
visible or invisible, either by the setVisible() method or by being added
or removed from the component hierarchy.

CaretEvent is used to notify interested parties that
the text caret has changed in the event source.

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.

Listener for changes in the caret position of a text
component.

CellEditorListener defines the interface for an object that listens
to changes in a CellEditor

ChangeEvent is used to notify interested parties that
state has changed in the event source.

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.

Defines an object which listens for ChangeEvents.

Interface for document change notifications.  This provides
detailed information to Document observers about how the
Document changed.  It provides high level information such
as type of change and where it occurred, as well as the more
detailed structural changes (What Elements were inserted and
removed).

Describes changes made to a specific element.

Enumeration for document event types

Interface for an observer to register to receive notifications
of changes to a text document.

The default implementation of
the Document interface (AbstractDocument) supports asynchronous
mutations.  If this feature is used (i.e. mutations are made
from a thread other than the Swing event thread), the listeners
will be notified via the mutating thread.  This means that
if asynchronous updates are made, the implementation of this
interface must be threadsafe!

The DocumentEvent notification is based upon the JavaBeans
event model.  There is no guarantee about the order of delivery
to listeners, and all listeners must be notified prior to making
further mutations to the Document.  This means implementations
of the DocumentListener may not mutate the source of the event
(i.e. the associated Document).

A class that holds a list of EventListeners.  A single instance
can be used to hold all listeners (of all types) for the instance
using the list.  It is the responsiblity of the class using the
EventListenerList to provide type-safe API (preferably conforming
to the JavaBeans spec) and methods which dispatch event notification
methods to appropriate Event Listeners on the list.

The main benefits that this class provides are that it is relatively
cheap in the case of no listeners, and it provides serialization for
event-listener lists in a single place, as well as a degree of MT safety
(when used correctly).

Usage example:
   Say one is defining a class that sends out FooEvents, and one wants
to allow users of the class to register FooListeners and receive
notification when FooEvents occur.  The following should be added
to the class definition:


EventListenerList listenerList = new EventListenerList();
FooEvent fooEvent = null;

public void addFooListener(FooListener l) {
    listenerList.add(FooListener.class, l);
}

public void removeFooListener(FooListener l) {
    listenerList.remove(FooListener.class, l);
}


// Notify all listeners that have registered interest for
// notification on this event type.  The event instance
// is lazily created using the parameters passed into
// the fire method.

protected void fireFooXXX() {
    // Guaranteed to return a non-null array
    Object[] listeners = listenerList.getListenerList();
    // Process the listeners last to first, notifying
    // those that are interested in this event
    for (int i = listeners.length-2; i>=0; i-=2) {
        if (listeners[i]==FooListener.class) {
            // Lazily create the event:
            if (fooEvent == null)
                fooEvent = new FooEvent(this);
            ((FooListener)listeners[i+1]).fooXXX(fooEvent);
        }
    }
}
foo should be changed to the appropriate name, and fireFooXxx to the
appropriate method name.  One fire method should exist for each
notification method in the FooListener interface.

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.

HyperlinkEvent is used to notify interested parties that
something has happened with respect to a hypertext link.

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.

Defines the ENTERED, EXITED, and ACTIVATED event types, along
with their string representations, returned by toString().

HyperlinkListener

An abstract adapter class for receiving internal frame events.
The methods in this class are empty. This class exists as
convenience for creating listener objects, and is functionally
equivalent to the WindowAdapter class in the AWT.

See How to Write an Internal Frame Listener
in The Java Tutorial

An AWTEvent that adds support for
JInternalFrame objects as the event source.  This class has the
same event types as WindowEvent,
although different IDs are used.
Help on handling internal frame events
is in
How to Write an Internal Frame Listener,
a section in The Java Tutorial.

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 listener interface for receiving internal frame events.
This class is functionally equivalent to the WindowListener class
in the AWT.

See How to Write an Internal Frame Listener
in The Java Tutorial for further documentation.

Defines an event that encapsulates changes to a list.

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.

ListDataListener

An event that characterizes a change in selection. The change is limited to a
a single inclusive interval. The selection of at least one index within the
range will have changed. A decent ListSelectionModel implementation
will keep the range as small as possible. ListSelectionListeners will
generally query the source of the event for the new selected status of each
potentially changed row.

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 listener that's notified when a lists selection value
changes.

MenuDragMouseEvent is used to notify interested parties that
the menu element has received a MouseEvent forwarded to it
under drag conditions.

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.

Defines a menu mouse-drag listener.

MenuEvent is used to notify interested parties that
the menu which is the event source has been posted,
selected, or canceled.

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.

MenuKeyEvent is used to notify interested parties that
the menu element has received a KeyEvent forwarded to it
in a menu tree.

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.

MenuKeyListener

Defines a listener for menu events.

An empty implementation of the MouseInputListener interface, provided
as a convenience to simplify the task of creating listeners, by extending
and implementing only the methods of interest. This class also provides an
empty implementation of the MouseWheelListener interface, through
its extension from AWT's MouseAdapter.

A listener implementing all the methods in both the MouseListener and
MouseMotionListener interfaces.

PopupMenuEvent only contains the source of the event which is the JPoupMenu
sending the event

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 popup menu listener

RowSorterEvent provides notification of changes to
a RowSorter.  Two types of notification are possible:

Type.SORT_ORDER_CHANGED: indicates the sort order has
    changed.  This is typically followed by a notification of:
Type.SORTED: indicates the contents of the model have
    been transformed in some way.  For example, the contents may have
    been sorted or filtered.

RowSorterListeners are notified of changes to a
RowSorter.

This subclass of java.beans.PropertyChangeSupport is almost
identical in functionality. The only difference is if constructed with
SwingPropertyChangeSupport(sourceBean, true) it ensures
listeners are only ever notified on the Event Dispatch Thread.

TableColumnModelEvent is used to notify listeners that a table
column model has changed, such as a column was added, removed, or
moved.

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.

TableColumnModelListener defines the interface for an object that listens
to changes in a TableColumnModel.

TableModelEvent is used to notify listeners that a table model
has changed. The model event describes changes to a TableModel
and all references to rows and columns are in the co-ordinate
system of the model.
Depending on the parameters used in the constructors, the TableModelevent
can be used to specify the following types of changes:



TableModelEvent(source);              //  The data, ie. all rows changed
TableModelEvent(source, HEADER_ROW);  //  Structure change, reallocate TableColumns
TableModelEvent(source, 1);           //  Row 1 changed
TableModelEvent(source, 3, 6);        //  Rows 3 to 6 inclusive changed
TableModelEvent(source, 2, 2, 6);     //  Cell at (2, 6) changed
TableModelEvent(source, 3, 6, ALL_COLUMNS, INSERT); // Rows (3, 6) were inserted
TableModelEvent(source, 3, 6, ALL_COLUMNS, DELETE); // Rows (3, 6) were deleted

It is possible to use other combinations of the parameters, not all of them
are meaningful. By subclassing, you can add other information, for example:
whether the event WILL happen or DID happen. This makes the specification
of rows in DELETE events more useful but has not been included in
the swing package as the JTable only needs post-event notification.

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.

TableModelListener defines the interface for an object that listens
to changes in a TableModel.

An event used to identify a single path in a tree.  The source
returned by getSource will be an instance of JTree.

For further documentation and examples see
the following sections in The Java Tutorial:
How to Write a Tree Expansion Listener and
How to Write a Tree-Will-Expand Listener.

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 listener that's notified when a tree expands or collapses
a node.
For further documentation and examples see
How to Write a Tree Expansion Listener,
a section in The Java Tutorial.

Encapsulates information describing changes to a tree model, and
used to notify tree model listeners of the change.
For more information and examples see
How to Write a Tree Model Listener,
a section in The Java Tutorial.

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.

Defines the interface for an object that listens
to changes in a TreeModel.
For further information and examples see
How to Write a Tree Model Listener,
a section in The Java Tutorial.

An event that characterizes a change in the current
selection.  The change is based on any number of paths.
TreeSelectionListeners will generally query the source of
the event for the new selected status of each potentially
changed row.

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 listener that's notified when the selection in a TreeSelectionModel
changes.
For more information and examples see
How to Write a Tree Selection Listener,
a section in The Java Tutorial.

The listener that's notified when a tree expands or collapses
a node.
For further information and examples see
How to Write a Tree-Will-Expand Listener,
a section in The Java Tutorial.

An event indicating that an operation which can be undone has occurred.

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.

Interface implemented by a class interested in hearing about
undoable operations.