# Uses of Package
javax.swing

Packages that use javax.swing
com.sun.tools.jconsole: This package contains the JConsole API.
java.awt: Contains all of the classes for creating user interfaces and for painting graphics and images.
java.awt.im.spi: Provides interfaces that enable the development of input methods that can be used with any Java runtime environment.
javax.swing: Provides a set of "lightweight" (all-Java language) components that, to the maximum degree possible, work the same on all platforms.
javax.swing.border: Provides classes and interface for drawing specialized borders around a Swing component.
javax.swing.colorchooser: Contains classes and interfaces used by the `JColorChooser` component.
javax.swing.event: Provides for events fired by Swing components.
javax.swing.filechooser: Contains classes and interfaces used by the `JFileChooser` component.
javax.swing.plaf: Provides one interface and many abstract classes that Swing uses to provide its pluggable look-and-feel capabilities.
javax.swing.plaf.basic: Provides user interface objects built according to the Basic look and feel.
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.
javax.swing.plaf.multi: Provides user interface objects that combine two or more look and feels.
javax.swing.plaf.nimbus: Provides user interface objects built according to the cross-platform Nimbus look and feel.
javax.swing.plaf.synth: Synth is a skinnable look and feel in which all painting is delegated.
javax.swing.table: Provides classes and interfaces for dealing with `javax.swing.JTable`.
javax.swing.text: Provides classes and interfaces that deal with editable and noneditable text components.
javax.swing.text.html: Provides the class `HTMLEditorKit` and supporting classes for creating HTML text editors.
javax.swing.tree: Provides classes and interfaces for dealing with `javax.swing.JTree`.

Classes in javax.swing used by com.sun.tools.jconsole
JPanel: `JPanel` is a generic lightweight container.
SwingWorker: An abstract class to perform lengthy GUI-interaction tasks in a background thread.

Classes in javax.swing used by java.awt
JMenuBar: An implementation of a menu bar.

Classes in javax.swing used by java.awt.im.spi
JFrame: An extended version of `java.awt.Frame` that adds support for the JFC/Swing component architecture.

Classes in javax.swing used by javax.swing
AbstractButton: Defines common behaviors for buttons and menu items.
AbstractButton.AccessibleAbstractButton: This class implements accessibility support for the `AbstractButton` class.
AbstractCellEditor: A base class for `CellEditors`, providing default implementations for the methods in the `CellEditor` interface except `getCellEditorValue()`.
AbstractListModel: The abstract definition for the data model that provides a `List` with its contents.
AbstractSpinnerModel: This class provides the ChangeListener part of the SpinnerModel interface that should be suitable for most concrete SpinnerModel implementations.
Action: The `Action` interface provides a useful extension to the `ActionListener` interface in cases where the same functionality may be accessed by several controls.
ActionMap: `ActionMap` provides mappings from `Object`s (called keys or `Action` names) to `Action`s.
BoundedRangeModel: Defines the data model used by components like `Slider`s and `ProgressBar`s.
Box: A lightweight container that uses a BoxLayout object as its layout manager.
ButtonGroup: This class is used to create a multiple-exclusion scope for a set of buttons.
ButtonModel: State model for buttons.
CellEditor: This interface defines the methods any general editor should be able to implement.
ComboBoxEditor: The editor component used for JComboBox components.
ComboBoxModel: A data model for a combo box.
ComponentInputMap: A `ComponentInputMap` is an `InputMap` associated with a particular `JComponent`.
DefaultButtonModel: The default implementation of a `Button` component's data model.
DefaultCellEditor.EditorDelegate: The protected `EditorDelegate` class.
DefaultListCellRenderer: Renders an item in a list.
DefaultRowSorter.ModelWrapper: `DefaultRowSorter.ModelWrapper` is responsible for providing the data that gets sorted by `DefaultRowSorter`.
DesktopManager: DesktopManager objects are owned by a JDesktopPane object.
DropMode: Drop modes, used to determine the method by which a component tracks and indicates a drop location during drag and drop.
FocusManager: This class has been obsoleted by the 1.4 focus APIs.
GroupLayout.Alignment: Enumeration of the possible ways `ParallelGroup` can align its children.
GroupLayout.Group: `Group` provides the basis for the two types of operations supported by `GroupLayout`: laying out components one after another (`SequentialGroup`) or aligned (`ParallelGroup`).
GroupLayout.ParallelGroup: A `Group` that aligns and sizes it's children.
GroupLayout.SequentialGroup: A `Group` that positions and sizes its elements sequentially, one after another.
Icon: A small fixed size picture, typically used to decorate components.
InputMap: `InputMap` provides a binding between an input event (currently only `KeyStroke`s are used) and an `Object`.
InputVerifier: This class provides the validation mechanism for Swing components.
InternalFrameFocusTraversalPolicy: A FocusTraversalPolicy which can optionally provide an algorithm for determining a JInternalFrame's initial Component.
JButton: An implementation of a "push" button.
JCheckBox: An implementation of a check box -- an item that can be selected or deselected, and which displays its state to the user.
JColorChooser: `JColorChooser` provides a pane of controls designed to allow a user to manipulate and select a color.
JComboBox: A component that combines a button or editable field and a drop-down list.
JComboBox.KeySelectionManager: The interface that defines a `KeySelectionManager`.
JComponent: The base class for all Swing components except top-level containers.
JComponent.AccessibleJComponent: Inner class of JComponent used to provide default support for accessibility.
JDesktopPane: A container used to create a multiple-document interface or a virtual desktop.
JDialog: The main class for creating a dialog window.
JEditorPane: A text component to edit various kinds of content.
JEditorPane.AccessibleJEditorPane: This class implements accessibility support for the `JEditorPane` class.
JFormattedTextField: `JFormattedTextField` extends `JTextField` adding support for formatting arbitrary values, as well as retrieving a particular object once the user has edited the text.
JFormattedTextField.AbstractFormatter: Instances of `AbstractFormatter` are used by `JFormattedTextField` to handle the conversion both from an Object to a String, and back from a String to an Object.
JFormattedTextField.AbstractFormatterFactory: Instances of `AbstractFormatterFactory` are used by `JFormattedTextField` to obtain instances of `AbstractFormatter` which in turn are used to format values.
JInternalFrame: A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
JInternalFrame.JDesktopIcon: This component represents an iconified version of a `JInternalFrame`.
JLabel: A display area for a short text string or an image, or both.
JLayeredPane: `JLayeredPane` adds depth to a JFC/Swing container, allowing components to overlap each other when needed.
JList: A component that displays a list of objects and allows the user to select one or more items.
JList.DropLocation: A subclass of `TransferHandler.DropLocation` representing a drop location for a `JList`.
JMenu: An implementation of a menu -- a popup window containing `JMenuItem`s that is displayed when the user selects an item on the `JMenuBar`.
JMenu.WinListener: A listener class that watches for a popup window closing.
JMenuBar: An implementation of a menu bar.
JMenuItem: An implementation of an item in a menu.
JMenuItem.AccessibleJMenuItem: This class implements accessibility support for the `JMenuItem` class.
JPanel: `JPanel` is a generic lightweight container.
JPopupMenu: An implementation of a popup menu -- a small window that pops up and displays a series of choices.
JRootPane: A lightweight container used behind the scenes by `JFrame`, `JDialog`, `JWindow`, `JApplet`, and `JInternalFrame`.
JScrollBar: An implementation of a scrollbar.
JScrollPane: Provides a scrollable view of a lightweight component.
JSeparator: `JSeparator` provides a general purpose component for implementing divider lines - most commonly used as a divider between menu items that breaks them up into logical groupings.
JSpinner: A single line input field that lets the user select a number or an object value from an ordered sequence.
JSpinner.DefaultEditor: A simple base class for more specialized editors that displays a read-only view of the model's current value with a `JFormattedTextField`.
JTable: The `JTable` is used to display and edit regular two-dimensional tables of cells.
JTable.DropLocation: A subclass of `TransferHandler.DropLocation` representing a drop location for a `JTable`.
JTable.PrintMode: Printing modes, used in printing `JTable`s.
JTextField: `JTextField` is a lightweight component that allows the editing of a single line of text.
JTextField.AccessibleJTextField: This class implements accessibility support for the `JTextField` class.
JToggleButton: An implementation of a two-state button.
JToggleButton.AccessibleJToggleButton: This class implements accessibility support for the `JToggleButton` class.
JToolTip: Used to display a "Tip" for a Component.
JTree: A control that displays a set of hierarchical data as an outline.
JTree.DropLocation: A subclass of `TransferHandler.DropLocation` representing a drop location for a `JTree`.
JTree.EmptySelectionModel: `EmptySelectionModel` is a `TreeSelectionModel` that does not allow anything to be selected.
JTree.TreeSelectionRedirector: Handles creating a new `TreeSelectionEvent` with the `JTree` as the source and passing it off to all the listeners.
JViewport: The "viewport" or "porthole" through which you see the underlying information.
JViewport.ViewListener: A listener for the view.
KeyStroke: A KeyStroke represents a key action on the keyboard, or equivalent input device.
LayoutStyle: `LayoutStyle` provides information about how to position components.
LayoutStyle.ComponentPlacement: `ComponentPlacement` is an enumeration of the possible ways two components can be placed relative to each other.
ListCellRenderer: Identifies components that can be used as "rubber stamps" to paint the cells in a JList.
ListModel: This interface defines the methods components like JList use to get the value of each cell in a list and the length of the list.
ListSelectionModel: This interface represents the current state of the selection for any of the components that display a list of values with stable indices.
LookAndFeel: `LookAndFeel`, as the name implies, encapsulates a look and feel.
MenuElement: Any component that can be placed into a menu should implement this interface.
MenuSelectionManager: A MenuSelectionManager owns the selection in menu hierarchy.
MutableComboBoxModel: A mutable version of `ComboBoxModel`.
Popup: Popups are used to display a `Component` to the user, typically on top of all the other `Component`s in a particular containment hierarchy.
PopupFactory: `PopupFactory`, as the name implies, is used to obtain instances of `Popup`s.
ProgressMonitor: A class to monitor the progress of some operation.
RepaintManager: This class manages repaint requests, allowing the number of repaints to be minimized, for example by collapsing multiple requests into a single repaint for members of a component tree.
RootPaneContainer: This interface is implemented by components that have a single JRootPane child: JDialog, JFrame, JWindow, JApplet, JInternalFrame.
RowFilter: `RowFilter` is used to filter out entries from the model so that they are not shown in the view.
RowFilter.ComparisonType: Enumeration of the possible comparison values supported by some of the default `RowFilter`s.
RowFilter.Entry: An `Entry` object is passed to instances of `RowFilter`, allowing the filter to get the value of the entry's data, and thus to determine whether the entry should be shown.
RowSorter: `RowSorter` provides the basis for sorting and filtering.
RowSorter.SortKey: SortKey describes the sort order for a particular column.
Scrollable: An interface that provides information to a scrolling container like JScrollPane.
ScrollPaneConstants: Constants used with the JScrollPane component.
ScrollPaneLayout: The layout manager used by `JScrollPane`.
SingleSelectionModel: A model that supports at most one indexed selection.
SizeRequirements: For the convenience of layout managers, calculates information about the size and position of components.
SortingFocusTraversalPolicy: A FocusTraversalPolicy that determines traversal order by sorting the Components of a focus traversal cycle based on a given Comparator.
SortOrder: SortOrder is an enumeration of the possible sort orderings.
SpinnerDateModel: A `SpinnerModel` for sequences of `Date`s.
SpinnerListModel: A simple implementation of `SpinnerModel` whose values are defined by an array or a `List`.
SpinnerModel: A model for a potentially unbounded sequence of object values.
SpinnerNumberModel: A `SpinnerModel` for sequences of numbers.
Spring: An instance of the `Spring` class holds three properties that characterize its behavior: the minimum, preferred, and maximum values.
SpringLayout.Constraints: A `Constraints` object holds the constraints that govern the way a component's size and position change in a container controlled by a `SpringLayout`.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.
SwingContainer: An annotation used to specify some swing-related information for the automatically generated `BeanInfo` classes.
SwingWorker.StateValue: Values for the `state` bound property.
ToolTipManager: Manages all the `ToolTips` in the system.
TransferHandler: This class is used to handle the transfer of a `Transferable` to and from Swing components.
TransferHandler.DropLocation: Represents a location where dropped data should be inserted.
TransferHandler.TransferSupport: This class encapsulates all relevant details of a clipboard or drag and drop transfer, and also allows for customizing aspects of the drag and drop experience.
UIDefaults: A table of defaults for Swing components.
UIDefaults.LazyValue: This class enables one to store an entry in the defaults table that isn't constructed until the first time it's looked up with one of the `getXXX(key)` methods.
UIManager.LookAndFeelInfo: Provides a little information about an installed `LookAndFeel` for the sake of configuring a menu or for initial application set up.
UnsupportedLookAndFeelException: An exception that indicates the requested look & feel management classes are not present on the user's system.
WindowConstants: Constants used to control the window-closing operation.

Classes in javax.swing used by javax.swing.border
Icon: A small fixed size picture, typically used to decorate components.

Classes in javax.swing used by javax.swing.colorchooser
Icon: A small fixed size picture, typically used to decorate components.
JColorChooser: `JColorChooser` provides a pane of controls designed to allow a user to manipulate and select a color.
JComponent: The base class for all Swing components except top-level containers.
JPanel: `JPanel` is a generic lightweight container.

Classes in javax.swing used by javax.swing.event
JComponent: The base class for all Swing components except top-level containers.
JInternalFrame: A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
MenuElement: Any component that can be placed into a menu should implement this interface.
MenuSelectionManager: A MenuSelectionManager owns the selection in menu hierarchy.
RowSorter: `RowSorter` provides the basis for sorting and filtering.

Classes in javax.swing used by javax.swing.filechooser
Icon: A small fixed size picture, typically used to decorate components.

Classes in javax.swing used by javax.swing.plaf
ActionMap: `ActionMap` provides mappings from `Object`s (called keys or `Action` names) to `Action`s.
ComponentInputMap: A `ComponentInputMap` is an `InputMap` associated with a particular `JComponent`.
Icon: A small fixed size picture, typically used to decorate components.
InputMap: `InputMap` provides a binding between an input event (currently only `KeyStroke`s are used) and an `Object`.
JButton: An implementation of a "push" button.
JComboBox: A component that combines a button or editable field and a drop-down list.
JComponent: The base class for all Swing components except top-level containers.
JFileChooser: `JFileChooser` provides a simple mechanism for the user to choose a file.
JLayer: `JLayer` is a universal decorator for Swing components which enables you to implement various advanced painting effects as well as receive notifications of all `AWTEvent`s generated within its borders.
JList: A component that displays a list of objects and allows the user to select one or more items.
JOptionPane: `JOptionPane` makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something.
JPopupMenu: An implementation of a popup menu -- a small window that pops up and displays a series of choices.
JSplitPane: `JSplitPane` is used to divide two (and only two) `Component`s.
JTabbedPane: A component that lets the user switch between a group of components by clicking on a tab with a given title and/or icon.
JTree: A control that displays a set of hierarchical data as an outline.
Popup: Popups are used to display a `Component` to the user, typically on top of all the other `Component`s in a particular containment hierarchy.

Classes in javax.swing used by javax.swing.plaf.basic
AbstractAction: This class provides default implementations for the JFC `Action` interface.
AbstractButton: Defines common behaviors for buttons and menu items.
AbstractListModel: The abstract definition for the data model that provides a `List` with its contents.
Action: The `Action` interface provides a useful extension to the `ActionListener` interface in cases where the same functionality may be accessed by several controls.
ActionMap: `ActionMap` provides mappings from `Object`s (called keys or `Action` names) to `Action`s.
BoxLayout: A layout manager that allows multiple components to be laid out either vertically or horizontally.
CellRendererPane: This class is inserted in between cell renderers and the components that use them.
ComboBoxEditor: The editor component used for JComboBox components.
ComboBoxModel: A data model for a combo box.
DesktopManager: DesktopManager objects are owned by a JDesktopPane object.
Icon: A small fixed size picture, typically used to decorate components.
JButton: An implementation of a "push" button.
JColorChooser: `JColorChooser` provides a pane of controls designed to allow a user to manipulate and select a color.
JComboBox: A component that combines a button or editable field and a drop-down list.
JComponent: The base class for all Swing components except top-level containers.
JDesktopPane: A container used to create a multiple-document interface or a virtual desktop.
JFileChooser: `JFileChooser` provides a simple mechanism for the user to choose a file.
JFrame: An extended version of `java.awt.Frame` that adds support for the JFC/Swing component architecture.
JInternalFrame: A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
JInternalFrame.JDesktopIcon: This component represents an iconified version of a `JInternalFrame`.
JLabel: A display area for a short text string or an image, or both.
JList: A component that displays a list of objects and allows the user to select one or more items.
JMenu: An implementation of a menu -- a popup window containing `JMenuItem`s that is displayed when the user selects an item on the `JMenuBar`.
JMenuBar: An implementation of a menu bar.
JMenuItem: An implementation of an item in a menu.
JOptionPane: `JOptionPane` makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something.
JPanel: `JPanel` is a generic lightweight container.
JPopupMenu: An implementation of a popup menu -- a small window that pops up and displays a series of choices.
JProgressBar: A component that visually displays the progress of some task.
JRootPane: A lightweight container used behind the scenes by `JFrame`, `JDialog`, `JWindow`, `JApplet`, and `JInternalFrame`.
JScrollBar: An implementation of a scrollbar.
JScrollPane: Provides a scrollable view of a lightweight component.
JSeparator: `JSeparator` provides a general purpose component for implementing divider lines - most commonly used as a divider between menu items that breaks them up into logical groupings.
JSlider: A component that lets the user graphically select a value by sliding a knob within a bounded interval.
JSpinner: A single line input field that lets the user select a number or an object value from an ordered sequence.
JSplitPane: `JSplitPane` is used to divide two (and only two) `Component`s.
JTabbedPane: A component that lets the user switch between a group of components by clicking on a tab with a given title and/or icon.
JTable: The `JTable` is used to display and edit regular two-dimensional tables of cells.
JTextField: `JTextField` is a lightweight component that allows the editing of a single line of text.
JToolBar: `JToolBar` provides a component that is useful for displaying commonly used `Action`s or controls.
JTree: A control that displays a set of hierarchical data as an outline.
JTree.DropLocation: A subclass of `TransferHandler.DropLocation` representing a drop location for a `JTree`.
KeyStroke: A KeyStroke represents a key action on the keyboard, or equivalent input device.
ListCellRenderer: Identifies components that can be used as "rubber stamps" to paint the cells in a JList.
ListModel: This interface defines the methods components like JList use to get the value of each cell in a list and the length of the list.
ListSelectionModel: This interface represents the current state of the selection for any of the components that display a list of values with stable indices.
LookAndFeel: `LookAndFeel`, as the name implies, encapsulates a look and feel.
MenuElement: Any component that can be placed into a menu should implement this interface.
MenuSelectionManager: A MenuSelectionManager owns the selection in menu hierarchy.
RootPaneContainer: This interface is implemented by components that have a single JRootPane child: JDialog, JFrame, JWindow, JApplet, JInternalFrame.
ScrollPaneConstants: Constants used with the JScrollPane component.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.
Timer: Fires one or more `ActionEvent`s at specified intervals.
UIDefaults: A table of defaults for Swing components.

Classes in javax.swing used by javax.swing.plaf.metal
AbstractAction: This class provides default implementations for the JFC `Action` interface.
AbstractButton: Defines common behaviors for buttons and menu items.
AbstractListModel: The abstract definition for the data model that provides a `List` with its contents.
Action: The `Action` interface provides a useful extension to the `ActionListener` interface in cases where the same functionality may be accessed by several controls.
ActionMap: `ActionMap` provides mappings from `Object`s (called keys or `Action` names) to `Action`s.
CellRendererPane: This class is inserted in between cell renderers and the components that use them.
ComboBoxEditor: The editor component used for JComboBox components.
ComboBoxModel: A data model for a combo box.
DefaultListCellRenderer: Renders an item in a list.
Icon: A small fixed size picture, typically used to decorate components.
JButton: An implementation of a "push" button.
JComboBox: A component that combines a button or editable field and a drop-down list.
JComponent: The base class for all Swing components except top-level containers.
JFileChooser: `JFileChooser` provides a simple mechanism for the user to choose a file.
JInternalFrame: A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
JLabel: A display area for a short text string or an image, or both.
JList: A component that displays a list of objects and allows the user to select one or more items.
JMenu: An implementation of a menu -- a popup window containing `JMenuItem`s that is displayed when the user selects an item on the `JMenuBar`.
JPanel: `JPanel` is a generic lightweight container.
JPopupMenu: An implementation of a popup menu -- a small window that pops up and displays a series of choices.
JScrollPane: Provides a scrollable view of a lightweight component.
JSlider: A component that lets the user graphically select a value by sliding a knob within a bounded interval.
JToolBar: `JToolBar` provides a component that is useful for displaying commonly used `Action`s or controls.
LayoutStyle: `LayoutStyle` provides information about how to position components.
ListCellRenderer: Identifies components that can be used as "rubber stamps" to paint the cells in a JList.
ListModel: This interface defines the methods components like JList use to get the value of each cell in a list and the length of the list.
LookAndFeel: `LookAndFeel`, as the name implies, encapsulates a look and feel.
MenuElement: Any component that can be placed into a menu should implement this interface.
ScrollPaneConstants: Constants used with the JScrollPane component.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.
UIDefaults: A table of defaults for Swing components.

Classes in javax.swing used by javax.swing.plaf.multi
JComboBox: A component that combines a button or editable field and a drop-down list.
JComponent: The base class for all Swing components except top-level containers.
JFileChooser: `JFileChooser` provides a simple mechanism for the user to choose a file.
JList: A component that displays a list of objects and allows the user to select one or more items.
JOptionPane: `JOptionPane` makes it easy to pop up a standard dialog box that prompts users for a value or informs them of something.
JPopupMenu: An implementation of a popup menu -- a small window that pops up and displays a series of choices.
JSplitPane: `JSplitPane` is used to divide two (and only two) `Component`s.
JTabbedPane: A component that lets the user switch between a group of components by clicking on a tab with a given title and/or icon.
JTree: A control that displays a set of hierarchical data as an outline.
LookAndFeel: `LookAndFeel`, as the name implies, encapsulates a look and feel.
Popup: Popups are used to display a `Component` to the user, typically on top of all the other `Component`s in a particular containment hierarchy.
UIDefaults: A table of defaults for Swing components.

Classes in javax.swing used by javax.swing.plaf.nimbus
JComponent: The base class for all Swing components except top-level containers.
LookAndFeel: `LookAndFeel`, as the name implies, encapsulates a look and feel.
Painter: A painting delegate.

Classes in javax.swing used by javax.swing.plaf.synth
AbstractButton: Defines common behaviors for buttons and menu items.
Icon: A small fixed size picture, typically used to decorate components.
JComponent: The base class for all Swing components except top-level containers.
JInternalFrame: A lightweight object that provides many of the features of a native frame, including dragging, closing, becoming an icon, resizing, title display, and support for a menu bar.
JPanel: `JPanel` is a generic lightweight container.
JSeparator: `JSeparator` provides a general purpose component for implementing divider lines - most commonly used as a divider between menu items that breaks them up into logical groupings.
JSlider: A component that lets the user graphically select a value by sliding a knob within a bounded interval.
LookAndFeel: `LookAndFeel`, as the name implies, encapsulates a look and feel.
ScrollPaneConstants: Constants used with the JScrollPane component.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.
UIDefaults: A table of defaults for Swing components.

Classes in javax.swing used by javax.swing.table
CellEditor: This interface defines the methods any general editor should be able to implement.
DefaultRowSorter: An implementation of `RowSorter` that provides sorting and filtering around a grid-based data model.
JComponent: The base class for all Swing components except top-level containers.
JComponent.AccessibleJComponent: Inner class of JComponent used to provide default support for accessibility.
JLabel: A display area for a short text string or an image, or both.
JTable: The `JTable` is used to display and edit regular two-dimensional tables of cells.
ListSelectionModel: This interface represents the current state of the selection for any of the components that display a list of values with stable indices.
RowSorter: `RowSorter` provides the basis for sorting and filtering.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.

Classes in javax.swing used by javax.swing.text
AbstractAction: This class provides default implementations for the JFC `Action` interface.
Action: The `Action` interface provides a useful extension to the `ActionListener` interface in cases where the same functionality may be accessed by several controls.
DropMode: Drop modes, used to determine the method by which a component tracks and indicates a drop location during drag and drop.
Icon: A small fixed size picture, typically used to decorate components.
JComponent: The base class for all Swing components except top-level containers.
JComponent.AccessibleJComponent: Inner class of JComponent used to provide default support for accessibility.
JEditorPane: A text component to edit various kinds of content.
JFormattedTextField: `JFormattedTextField` extends `JTextField` adding support for formatting arbitrary values, as well as retrieving a particular object once the user has edited the text.
JFormattedTextField.AbstractFormatter: Instances of `AbstractFormatter` are used by `JFormattedTextField` to handle the conversion both from an Object to a String, and back from a String to an Object.
JFormattedTextField.AbstractFormatterFactory: Instances of `AbstractFormatterFactory` are used by `JFormattedTextField` to obtain instances of `AbstractFormatter` which in turn are used to format values.
KeyStroke: A KeyStroke represents a key action on the keyboard, or equivalent input device.
Scrollable: An interface that provides information to a scrolling container like JScrollPane.
SizeRequirements: For the convenience of layout managers, calculates information about the size and position of components.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.
SwingContainer: An annotation used to specify some swing-related information for the automatically generated `BeanInfo` classes.
TransferHandler.DropLocation: Represents a location where dropped data should be inserted.

Classes in javax.swing used by javax.swing.text.html
AbstractAction: This class provides default implementations for the JFC `Action` interface.
Action: The `Action` interface provides a useful extension to the `ActionListener` interface in cases where the same functionality may be accessed by several controls.
Icon: A small fixed size picture, typically used to decorate components.
JEditorPane: A text component to edit various kinds of content.
SizeRequirements: For the convenience of layout managers, calculates information about the size and position of components.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.

Classes in javax.swing used by javax.swing.tree
CellEditor: This interface defines the methods any general editor should be able to implement.
DefaultListSelectionModel: Default data model for list selections.
Icon: A small fixed size picture, typically used to decorate components.
JComponent: The base class for all Swing components except top-level containers.
JLabel: A display area for a short text string or an image, or both.
JTextField: `JTextField` is a lightweight component that allows the editing of a single line of text.
JTree: A control that displays a set of hierarchical data as an outline.
Scrollable: An interface that provides information to a scrolling container like JScrollPane.
SwingConstants: A collection of constants generally used for positioning and orienting components on the screen.
Timer: Fires one or more `ActionEvent`s at specified intervals.