CreateCreates a new title border specifying the text of the title using the default border (etched) using the default text position (sitting on the top line) and default justification (leftleading) and using the default font and text color determined by the current look and feel. @param title a String containing the text of the title @return the TitledBorder object

Defines the data model used by components like Sliders and ProgressBars. Defines four interrelated integer properties: minimum maximum extent and value. These four integers define two nested ranges like this:

 minimum < value < value+extent < maximum 

The outer range is minimum maximum and the inner range is value value+extent. The inner range must lie within the outer one i.e. value must be less than or equal to maximum and value+extent must greater than or equal to minimum and maximum must be greater than or equal to minimum. There are a few features of this model that one might find a little surprising. These quirks exist for the convenience of the Swing BoundedRangeModel clients like like Slider and ScrollBar.

• The minimum and maximum set methods "correct" the other three properties to acommodate their new value argument. For example setting the model's minimum may change its maximum value and extent properties (in that order) to maintain the constraints specified above.
• The value and extent set methods "correct" their argument to fit within the limits defined by the other three properties. For example if value == maximum setExtent(10) would change the extent (back) to zero.
• The four BoundedRangeModel values are defined as Java Beans properties however Swing ChangeEvents are used to notify clients of changes rather than PropertyChangeEvents. This was done to keep the overhead of monitoring a BoundedRangeModel low. Changes are often reported at MouseDragged rates.

For an example of specifying custom bounded range models used by sliders see The Anatomy of a Swing-Based Program in The Java Tutorial. @version 1.19 0822 02/2602/9800 @author Hans Muller @see DefaultBoundedRangeModel

A lightweight container that uses a BoxLayout object as its layout manager. Box provides several class methods that are useful for containers using BoxLayout -- even non-Box containers.

The Box class can create several kinds of invisible components that affect layout: glue struts and rigid areas. If all the components your Box contains have a fixed size you might want to use a glue component (returned by createGlue) to control the components' positions. If you need a fixed amount of space between two components try using a strut (createHorizontalStrut or createVerticalStrut). If you need an invisible component that always takes up the same amount of space get it by invoking createRigidArea.

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. A future release of Swing will provide support for long term persistence. @see BoxLayout @author Timothy Prinzing @version 1.30 0934 03/0114/9800

Return the nth Accessible child of the object. @param i zero-based index of child @return the nth Accessible child of the object or null

Returns the number of accessible children in the object. If all of the children of this object implement Accessible thenthan this method should return the number of children of this object. @return the number of accessible children in the object = 0.

GetsGet the AccessibleComponent associated with this object if one exists. Otherwise return null. @return the component

GetsGet the index of this object in its accessible parent. @return the index of this object in its parent = 0; -1 if this object does not have an accessible parent. @see #getAccessibleParent

GetsGet the Accessible parent of this object. If the parent of this object implements Accessible this method should simply return getParent(). @return the Accessible parent of this object -- can be null if this object does not have an Accessible parent

GetsGet the state of this object. @return an instance of AccessibleStateSet containing the current state set of the object @see AccessibleState

GetsGet the background color of this object. @return the background color if supported of the object; otherwise null

GetsGet the Cursor of this object. @return the Cursor if supported of the object; otherwise null

GetsGet the Font of this object. @return the Font if supported for the object; otherwise null

GetsGet the FontMetrics of this object. @param f the Font @return the FontMetrics if supported the object; otherwise null @see #getFont

GetsGet the foreground color of this object. @return the foreground color if supported of the object; otherwise null

ReturnsReturn the locale of this object. @return the locale of this object

DeterminesDetermine if the object is enabled. @return true if object is enabled; otherwise false

DeterminesReturns whether this object can accept focus or not. @return true if object can accept focus; otherwise false

DeterminesDetermine if the object is showing. This is determined by checking the visibility of the object and ancestors of the object. Note: this will return true even if the object is obscured by another (for example it happens to be underneath a menu that was pulled down). @return true if object is showing; otherwise false

DeterminesDetermine if the object is visible. Note: this means that the object intends to be visible; however it may not in fact be showing on the screen because one of the objects that this object is contained by is not visible. To determine if an object is showing on the screen use isShowing(). @return true if object is visible; otherwise false

SetsSet the background color of this object. (For transparency see isOpaque.) @param c the new Color for the background null if@see noneComponent#isOpaque

Sets the bounds of this object in the form of a Rectangle object. The bounds specify this object's width height and location relative to its parent. @param rA a rectangle indicating this component's bounds

SetsSet the Cursor of this object. @param cursorc the new Cursor for the object null if none

SetsSet the enabled state of the object. @param b if true enables this object; otherwise disables it

SetsSet the Font of this object. @param f the new Font for the object null if none

SetsSet the foreground color of this object. @param c the new Color for the foreground null if none

Sets the location of the object relative to the parent. @param p the location to be set

Resizes this object so that it has width width and height. @param d - The dimension specifying the new size of the object.

SetsSet the visible state of the object. @param b if true shows this object; otherwise hides it

Adds the specified focus listener to receive focus events from this component. @param l the focus listener

ReturnsReturn the nth Accessible child of the object. @param i zero-based index of child @return the nth Accessible child of the object null if none

Returns the number of accessible children in the object. If all of the children of this object implement Accessible thenthan this method should return the number of children of this object. @return the number of accessible children in the object = 0.

GetsGet the AccessibleComponent associated with this object if one exists. Otherwise return null. @return the component

GetsGet the index of this object in its accessible parent. @return the index of this object in its parent = 0; -1 if this object does not have an accessible parent. @see #getAccessibleParent

Get the Accessible parent of this object. If the parent of this object implements Accessible this method should simply return getParent(). @return the Accessible parent of this object; -- can be null if this object does not have an Accessible parent

GetsGet the state of this object. @return an instance of AccessibleStateSet containing the current state set of the object @see AccessibleState

GetsGet the background color of this object. @return the background color if supported of the object; otherwise null

GetsGet the Cursor of this object. @return the Cursor if supported of the object; otherwise null

GetsGet the Font of this object. @return the Font if supported for the object; otherwise null

GetsGet the FontMetrics of this object. @param f the Font null if none @return the FontMetrics if supported the object; otherwise null @see #getFont

GetsGet the foreground color of this object. @return the foreground color if supported of the object; otherwise null

ReturnsReturn the locale of this object. @return the locale of this object

Returns the location of the object on the screen. @return location of object on screen; -- can be null if this object is not on the screen

DeterminesDetermine if the object is enabled. @return true if object is enabled; otherwise false

DeterminesDetermine if the object is showing. This is determined by checking the visibility of the object and ancestors of the object. Note: this will return true even if the object is obscured by another (for example it happens to be underneath a menu that was pulled down). @return true if object is showing; otherwise false

DeterminesDetermine if the object is visible. Note: this means that the object intends to be visible; however it may not in fact be showing on the screen because one of the objects that this object is contained by is not visible. To determine if an object is showing on the screen use isShowing(). @return true if object is visible; otherwise false

Removes the specified focus listener so it no longer receives focus events from this component. @param l the focus listener

SetsSet the background color of this object. (For transparency see isOpaque.) @param c the new Color for the background null if none @s JComponentsee Component#isOpaque

Sets the bounds of this object in the form of a Rectangle object. The bounds specify this object's width height and location relative to its parent. @param rA a rectangle indicating this component's bounds

Set the Cursor of this object. @param cursorc the new Cursor for the object null if none

SetsSet the enabled state of the object. @param b if true enables this object; otherwise disables it

SetsSet the Font of this object. @param f the new Font for the object null if none

SetsSet the foreground color of this object. @param c the new Color for the foreground null if none

Sets the location of the object relative to the parent. @param p the location to be set

Resizes this object so that it has width width and height. @param d - The dimension specifying the new size of the object.

SetsSet the visible state of the object. @param b if true shows this object; otherwise hides it

Gets the AccessibleContext associated with this ComponentBox.Filler. For box fillers the AccessibleContext takes the form of an CreatesAccessibleBoxFiller. aA new contextAccessibleAWTBoxFiller instance is created if necessary. @return an AccessibleBoxFiller that serves as the AccessibleContext of this ComponentBox.Filler.

GetGets the AccessibleContext associated with this JComponentBox. Creates aFor boxes the AccessibleContext takes the form of an AccessibleBox. A new contextAccessibleAWTBox instance is created if necessary. @return an AccessibleBox that serves as the AccessibleContext of this JComponentBox

A layout manager that allows multiple components to be layed out either vertically or horizontally. The components will not wrap so for example a vertical arrangement of components will stay vertically arranged when the frame is resized.

Nesting multiple panels with different combinations of horizontal and vertical gives an effect similar to GridBagLayout without the complexity. The diagram shows two panels arranged horizontally each of which contains 3 components arranged vertically.

The Box container uses BoxLayout (unlike JPanel which defaults to flow layout). You can nest multiple boxes and add components to them to get the arrangement you want.

The BoxLayout manager that places each of its managed components from left to right or from top to bottom. When you create a BoxLayout you specify whether its major axis is the X axis (which means left to right placement) or Y axis (top to bottom placement). Components are arranged from left to right (or top to bottom) in the same order as they were added to the container.

Instead of using BoxLayout directly many programs use the Box class. The Box class provides a lightweight container that uses a BoxLayout. Box also provides handy methods to help you use BoxLayout well.

BoxLayout attempts to arrange components at their preferred widths (for left to right layout) or heights (for top to bottom layout). For a left to right layout if not all the components are the same height BoxLayout attempts to make all the components as high as the highest component. If that's not possible for a particular component then BoxLayout aligns that component vertically according to the component's Y alignment. By default a component has an Y alignment of 0.5 which means that the vertical center of the component should have the same Y coordinate as the vertical centers of other components with 0.5 Y alignment.

Similarly for a vertical layout BoxLayout attempts to make all components in the column as wide as the widest component; if that fails it aligns them horizontally according to their X alignments.

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. A future release of Swing will provide support for long term persistence. @see Box @see Component#getAlignmentX @see Component#getAlignmentY @author Timothy Prinzing @version 1.20 1024 02/2002/9800

Specifies that components should be laid out top to buttombottom.

This class is used to create a multiple-exclusion scope for a set of buttons. Creating a set of buttons with the same ButtonGroup object means that turning "on" one of those buttons turns off all other buttons in the group.

A ButtonGroup can be used with setsany set of JButtonobjects that inherit from AbstractButton. Typically a button group contains instances of JRadioButton JRadioButtonMenuItem or JRadioButtonMenuItemJToggleButton. objectsIt wouldn't make sense to put an instance of JButton or JMenuItem in a button group because JButton and JMenuItem don't implement the selected state.

Initially all buttons in the group are unselected. Once any button is selected one button is always selected in the group. There is no way to turn a button programmatically to "off" in order to clear the button group. To give the appearance of "none selected" add an invisible radio button to the group and then programmatically select that button to turn off all the displayed radio buttons. For example a normal button with the label "none" could be wired to select the invisible radio button.

For examples and further information on using button groups see How to Use Radio Buttons 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. A future release of Swing will provide support for long term persistence. @version 1.22 0827 02/2802/9800 @author Jeff Dinkins

State Model for buttons. This model is used for checkboxescheck boxes and radiobuttonsradio buttons which are special kinds of buttons as well as for normal buttons. For checkboxescheck boxes and radiobuttonsradio buttons pressing the mouse selects the button. For normal buttons pressing the mouse "arms" the button. Releasing the mouse over the button then initiates a button press firing its action event. Releasing the mouse elsewhere disarms the button.

In use a UI will invoke #setSelected() when a mouse click occurs over a checkboxcheck box or radiobuttonradio button. It will invoke #setArmed when the mouse is pressed over a regular button and invoke #setPressed when the mouse is released. If the mouse travels outside the button in the meantime setArmed(false) will tell the button not to fire when it sees setPressed. (If the mouse travels back in the button will be rearmed.)

Note:
A button is triggered when it is both "armed" and "pressed".

@version 1.20 0823 02/2602/9800 @author Jeff Dinkins

Indicates if the button can be selected or pressed by an input device (such as a mouse pointer). (Checkbox-buttonsCheck boxes are selected regular buttons are "pressed".) @return true if the button is enabled and therefore selectable (or pressable)

Indicates if the button has been selected. Only needed for certain types of buttons - such as RadioButtonradio orbuttons and check Checkboxboxes. @return true if the button is selected

This interface defines the methods any general editor should be able to implement.

Having this interface enables complex components (the client of the editor) such as JList JTree and JTable to allow any generic editor to edit values in a table cell or tree cell etc. Without this generic editor interface JTable would have to know about specific editors such as JTextField JCheckBox JComboBox etc. In addition without this interface clients of editors such as JTable would not be able to work with any editors developed in the future by the user or a 3rd party ISV.

To use this interface a developer creating a new editor can have the new component implement the interface. Or the developer can choose a wrapper based approch and provide a companion object which implements the CellEditor interface (See JCellEditor for example). The wrapper approch is particularly useful if the user want to use a 3rd party ISV editor with JTable but the ISV didn't implement the CellEditor interface. The user can simply create an object that contains an instance of the 3rd party editor object and "translate" the CellEditor API into the 3rd party editor's API. @see javax.swing.event.CellEditorListener @version 1.16 0819 02/2602/9800 @author Alan Chung

Tell the editor to start editing using anEvent. It is up to the editor if it want to start editing in different states depending on the exact type of anEvent. For example with a text field editor if the event is a mouse event the editor might start editing with the cursor at the clicked point. If the event is a keyboard event it might want replace the value of the text field with that first key etc. anEvent is in the invoking component's coordinate system. A null value is a valid parameter for anEvent and it is up to the editor to determine what is the default starting state. For example a text field editor might want to select all the text and start editing if anEvent is null. The editor can assume the Component returned by getCellEditorComponent() is properly installed in the clients Component hierarchy before this method is called. The return value of shouldSelectCell() is a boolean indicating whether the editing cell should be selected or not. Typically the return value is true because is most cases the editing cell should be selected. However it is useful to return false to keep the selection from changing for some types of edits. eg. A table that contains a column of check boxes the user might want to be able to change those checkboxes without altering the selection. (See Netscape Communicator for just such an example) Of course it is up to the client of the editor to use the return value but it doesn't need to if it doesn't want to. @param anEvent the event the editor should use to start editing. @return true if the editor would like the editing cell to be selected @see #isCellEditable

This class is inserted in between cell renderers and the components that use them. It just exists to thwart the repaint() and invalidate() methods which would otherwise propogate up the tree when the renderer was configured. It's used by the implementations of JTable JTree and JList. For example here's how CellRendererPane is used in the code the paints each row in a JList:

 cellRendererPane = new CellRendererPane(); ... Component rendererComponent = renderer.getListCellRendererComponent(); renderer.configureListCellRenderer(dataModel.getElementAt(row) row); cellRendererPane.paintComponent(g rendererComponent this x y w h); 

A renderer component must override isShowing() and unconditionally return true to work correctly because the Swing paint does nothing for components with isShowing false.

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. A future release of Swing will provide support for long term persistence. @version 1.28 0932 03/0114/9800 @author Hans Muller

Get the AccessibleComponent associated with this object if one exists. Otherwise return null. @return the component

Set the background color of this object. (For transparency see isOpaque.) @param c the new Color for the background @see Component#isOpaque

GetGets the AccessibleContext associated with this CellRendererPane. For CellRendererPanes the AccessibleContext takes the form of an AccessibleCellRendererPane. A new AccessibleCellRendererPane instance is created if necessary. @return an AccessibleCellRendererPane that serves as the AccessibleContext of this CellRendererPane

The editor component used for JComboBox components. @version 1.8 0810 02/2602/9800 @author Arnaud Weber

Graphics subclass supporting graphics debugging. Overrides most methods from Graphics. DebugGraphics objects are rarely created by hand. They are most frequently created automatically when a JComponent's debugGraphicsOptions are changed using the setDebugGraphicsOptions() method.

NOTE: You must turn off double buffering to use DebugGraphics: RepaintManager repaintManager = RepaintManager.currentManager(component); repaintManager.setDoubleBufferingEnabled(false); @see JComponent#setDebugGraphicsOptions @see RepaintManager#currentManager @see RepaintManager#setDoubleBufferingEnabled @version 1.17 1019 02/2002/9800 @author Dave Karlton

A generic implementation of BoundedRangeModel.

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. A future release of Swing will provide support for long term persistence. @version 1.32 1035 02/2602/9800 @author David Kloba @author Hans Muller @see BoundedRangeModel

The default implementation of a Button component's data model.

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. A future release of Swing will provide support for long term persistence. @version 1.26 0832 02/2802/9800 @author Jeff Dinkins

The default editor for table and tree cells.

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. A future release of Swing will provide support for long term persistence. @version 1.36 0338 02/0802/00 @author Philip MilneAlan Chung @author AlanPhilip ChungMilne

The default model for combo boxes. @version 1.6 0911 02/0102/9800 @author Arnaud Weber @author Tom Santos

This is an implementaion of the DesktopManager. It currently implements a the basic behaviors for managing JInternalFrames in an arbitrary parent. JInternalFrames that are not children of a JDesktop will use this component to handle their desktop-like actions. @see JDesktopPane @see JInternalFrame @version 1.24 0441 02/2202/9900 @author David Kloba @author Steve Wilson

Removes the frame and if necessary the desktopIcon from it'sits parent.

Removes the desktopIcon from it'sits parent and adds it'sits frame to the parent.

Removes the frame from it'sits parent and adds it'sits desktopIcon to the parent.

Resizes the frame to fill it'sits parents bounds.

Restores the frame back to it'sits size and position prior to a maximizeFrame() call.

Normally this method will not be called. If it is it try to determine the appropriate parent from the desktopIcon of the frame. Will remove the desktopIcon from it'sits parent if it successfully adds the frame.

Default swing focus manager implementation. @version 1.14 0415 07/2213/99 @author Arnaud Weber

Renders an item in a list.

Implementation Note: This class overrides validate revalidate repaint and firePropertyChange solely to improve performance. If not overridden these frequently called methods would execute code paths that are unnecessary for the default list cell renderer. If you write your own renderer take care to weigh the benefits and drawbacks of overriding these methods.

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. A future release of Swing will provide support for long term persistence. @version 1.12 0417 02/2202/9900 @author Philip Milne @author Hans Muller

SupportOverridden for deferredperformance automatic layout. Calls invalidate() and then adds this components validateRoot to a list of components that need to be validated. Validation will occur after all currently pending events have been dispatched. In other words after this method is called the first validateRoot (if any) found when walking up the containment hierarchy of this component will be validated. By default JRootPane JScrollPane and JTextField return true from isValidateRoot(). This method will automatically be called on this component when a property value changes such that size location or internal layout of this component has been affectedreasons. ThisSee automatic updating differs from the AWT because programs generally no longer need to invoke validate() to get the contents of the GUI to update. Implementation @seeNote java.awt.Component#invalidatefor @seemore java.awtinformation.Container#validate @see #isValidateRoot @see RepaintManager#addInvalidComponent

Validates this containerOverridden for performance and all of its subcomponentsreasons. AWT uses validate to cause a container to laySee out its subcomponents again after the components it containsImplementation haveNote been addedfor more to or modifiedinformation. @see #validate @see Component#invalidate

This class implements the java.util.Vector API and notifies the ListDataListeners when changes occur. Presently it delegates to a Vector in a future release it will be a real Collection 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. A future release of Swing will provide support for long term persistence. @version 1.21 1026 02/0602/9800 @author Hans Muller

Default data model for list selections.

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. A future release of Swing will provide support for long term persistence. @version 1.52 0455 02/2202/9900 @author Philip Milne @author Hans Muller @see ListSelectionModel

Returns a clone of thethis selection recievermodel with the same selection. listenerLists are not duplicated. @exception CloneNotSupportedException if the receiverselection model does not both (a) implement the Cloneable interface and (b) define a clone method.

NotifyNotifies listeners that we have ended a series of adjustments.

NotifyNotifies ListSelectionListeners that the value of the selection in the closed interval firstIndex lastIndex has changed.

@param firstIndex Thethe first index in the interval. @param index1 ThelastIndex the last index in the interval. @param isAdjusting Truetrue if this is the final change in a series of them.adjustments @see EventListenerList

Returns the value of the leadAnchorNotificationEnabled flag. When leadAnchorNotificationEnabled is true the model generates notification events with bounds that cover all the changes to the selection plus the changes to the lead and anchor indices. Setting the flag to false causes a norrowingnarrowing of the event's bounds to include only the elements that have been selected or deselected since the last change. Either way the model continues to maintain the lead and anchor variables internally. The default is true. @return the value of the leadAnchorNotificationEnabled flag @see #setLeadAnchorNotificationEnabled(boolean)

SetSets the lead selection index ensuring that values between the anchor and the new lead are either all selected or all deselected. If the value at the anchor index is selected first clear all the values in the range [anchor oldLeadIndex] then select all the values values in the range [anchor newLeadIndex] where oldLeadIndex is the old leadIndex and newLeadIndex is the new one.

If the value at the anchor index is not selected do the same thing in reverse selecting values in the old range and deslecting values in the new one.

Generate a single event for this change and notify all listeners. For the purposes of generating minimal bounds in this event do the operation in a single pass; that way the first and last index inside the ListSelectionEvent that is broadcast will refer to cells that actually changed value because of this method. If instead this operation were done in two steps the effect on the selection state would be the same but two events would be generated and the bounds around the changed values would be wider including cells that had been first cleared only to later be set.

This method can be used in the mouseDragged() method of a UI class to extend a selection. @see #getLeadSelectionIndex @see #setAnchorSelectionIndex

Returns a string that displays and identifies this object's properties. @return a String representation of this object

A generic implementation of SingleSelectionModel.

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. A future release of Swing will provide support for long term persistence. @version 1.22 0925 02/0102/9800 @author Dave Moore

DesktopManager objects are owned by a JDesktopPane object. They are responsible for implementing L&F specific behaviors for the JDesktopPane. JInternalFrame implementations should delegate specific behaviors to the DesktopManager. For instance if a JInternalFrame was asked to iconify it should try:

 getDesktopPane().getDesktopManager().iconifyFrame(frame); 

This delegation allows each L&F to provide custom behaviors for desktop-specific actions. (For example how and where the internal frame's icon would appear.) @see JDesktopPane @see JInternalFrame @see JInternalFrame.JDesktopIcon @version 1.8 0810 02/2602/9800 @author David Kloba

Swing Focus Manager @version 1.9 0811 02/2602/9800 @author Arnaud Weber

An image filter that "disables" an image by turning it into a grayscale image and brightening the pixels in the image. Used by buttons to create an image for a disabled button. @author Jeff Dinkins @author Tom Ball @author Jim Graham @version 1.10 0812 02/2602/9800

An implementation of the Icon interface that paints Icons from Images. Images that are created from a URL or filename are preloaded using MediaTracker to monitor the loaded state of the image.

For further information and examples of using image icons see How to Use Icons 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. A future release of Swing will provide support for long term persistence. @version 1.33 0845 03/2815/9800 @author Jeff Dinkins @author Lynn Monsanto

Creates an ImageIcon from an image object. If the image has a "comment" property that is a string then the string is used as the description of this icon. @param image the image @see #getDescription @see java.awt.Image#getProperty

Creates an ImageIcon from the specified file. The image will be preloaded by using MediaTracker to monitor the loading state of the image. The specified String can be a file name or a file path. When specifying a path use the Internet-standard forward-slash ("/") as a separator. (The string is converted to an URL so the forward-slash works on all systems.) For example specify:

 new ImageIcon("images/myImage.gif") 

(The stringdescription is convertedinitialized to an URL so the forward-slash works on allfilename systemsstring.) @param filename a String specifying a filename or path @see #getDescription

Creates an ImageIcon from the specified URL. The image will be preloaded by using MediaTracker to monitor the loaded state of the image. The icon's description is initialized to be a string representation of the URL. @param location the URL for the image @see #getDescription

Creates an ImageIcon from the specified URL. The image will be preloaded by using MediaTracker to monitor the loaded state of the image. @param URLlocation the URL for the image @param description a brief textual description of the image @see #ImageIcon(String)

Creates an ImageIcon from an array of bytes which were read from an image file containing a supported image format such as GIF or JPEG. Normally this array is created by reading an image using Class.getResourceAsStream() but the byte array may also be statically stored in a class. If the resulting image has a "comment" property that is a string then the string is used as the description of this icon. @param imageData an array of pixels in an image format supported by the AWT Toolkit such as GIF or JPEG. @see java.awt.Toolkit#createImage @see #getDescription @see java.awt.Image#getProperty

GetGets the description of the image. This is meant to be a brief textual description of the object. For example it might be presented to a blind user to give an indication of the purpose of the image. The description may be null. @return a brief textual description of the image

GetGets the height of the Iconicon. @return the height in pixels of this icon

GetGets the width of the Iconicon. @return the width in pixels of this icon

Returns the Iconthis icon's Image. @return the Image object for this ImageIcon

Returns the status of the image loading operation. @return the loading status as defined by java.awt.MediaTracker. @see java.awt.MediaTracker#ABORTED @see java.awt.MediaTracker#ERRORED @see java.awt.MediaTracker#COMPLETE

ReturnReturns the umageimage observer for the image. @return the image observer which may be null

WaitLoads forthe image returning only when the image tois loaded. @param image the loadimage

Paints the Iconicon. The top-left corner of the icon is drawn at the point (x y) in the coordinate space of the graphics context g. If this icon has no image observer this method uses the c component as the observer. @param c the component to be used as the observer if this icon has no image observer @param g the graphics context @param x the X coordinate of the icon's top-left corner @param y the Y coordinate of the icon's top-left corner

SetSets the description of the image. This is meant to be a brief textual description of the object. For example it might be presented to a blind user to give an indication of the purpose of the image. @param description a brief textual description of the image

SetSets the image displayed by this icon. @param image the image

SetSets the image observer for the image. Set this property if the ImageIcon contains an animated GIF so the observer is notified to update its display. For example:

 icon = new ImageIcon(...) button.setIcon(icon); icon.setImageObserver(button); 

@param observer the image observer

Returns a string representation of the object. In general the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommendedthat all subclasses override this method. The toString method for class Object returns a string consisting of the name of the class of which the object is an instance the at-sign character `@' and the unsigned hexadecimal representation of the hash code of the object. In other words this method returns a string equal to the value of: getClass().getName() + '@' + Integerimage.toHexString(hashCode()) @return a string representation ofrepresenting thethis object.image

An extended version of java.applet.Applet that adds support for interposing input and painting behavior in frontthe ofJFC/Swing thecomponent appletsarchitecture. childrenYou (seecan glassPane)find supporttask-oriented for special childrendocumentation about using thatJApplet arein managedThe byJava aTutorial LayeredPanein (seethe rootPane)section andHow for Swingto Make MenuBarsApplets.

The JApplet class is slightly incompatible with java.applet.Applet. JApplet contains a JRootPane as it's only child. The contentPane should be the parent of any children of the JApplet. This is different than java.applet.Applet e.g. to add a child to an an java.applet.Applet you'd write:

 applet.add(child); 

However using JApplet you need to add the child to the JApplet's contentPane instead:

 applet.getContentPane().add(child); 

The same is true for setting LayoutManagers removing components listing children etc. All these methods should normally be sent to the contentPane() instead of the JApplet itself. The contentPane() will always be non-null. Attempting to set it to null will cause the JApplet to throw an exception. The default contentPane() will have a BorderLayout manager set on it.

Please see the JRootPane documentation for a complete description of the contentPane glassPane and layeredPane properties.

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JApplet key assignments.

Both Netscape Communicator and Internet Explorer 4.0 unconditionally print an error message to the Java console when an applet attempts to access the AWT system event queue. Swing applets do this once to check if access is permitted. To prevent the warning message in a production applet one can set a client property called "defeatSystemEventQueueCheck" on the JApplets RootPane to any non null value e.g: JRootPane rp = myJApplet.getRootPane(); rp.putClientProperty("defeatSystemEventQueueCheck" Boolean.TRUE); We hope that future versions of the browsers will not have this limitation and we'll be able to retire this hack. 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. A future release of Swing will provide support for long term persistence. @beaninfo attribute: isContainer true attribute: containerDelegate getContentPane description: Swing's Applet subclass. @version 1.38 0442 03/2214/9900 @author Arnaud Weber

Get the AccessibleComponent associated with this object if one exists. Otherwise return null. @return the component

Get the role of this object. @return an instance of AccessibleRole describing the role of the object @see AccessibleRole

Set the background color of this object. (For transparency see isOpaque.) @param c the new Color for the background @see Component#isOpaque

GetGets the AccessibleContext associated with this JApplet. For JApplets the AccessibleContext takes the form of an AccessibleJApplet. A new AccessibleJApplet instance is created if necessary. @return an AccessibleJApplet that serves as the AccessibleContext of this JApplet

An implementation of a "push" button. To create a set of mutually exclusive buttons create a ButtonGroup object and use its addSee methodHow to include the JButton objects in the group.Use SeeButtons Check HowBoxes to Useand Radio Buttons in The Java Tutorial for furtherinformation and examples of using documentationbuttons.

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JButton key assignments.

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. A future release of Swing will provide support for long term persistence. @beaninfo attribute: isContainer false description: An implementation of a \"push\" button. @version 1.73 0983 03/0114/9800 @author Jeff Dinkins @see ButtonGroup

TheThis class usedimplements toaccessibility support obtainfor the accessibleJButton class. role forIt provides thisan implementation of the Java Accessibility API appropriate to button user-interface objectelements.

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. A future release of Swing will provide support for long term persistence.

GetGets the AccessibleContext associated with this JComponentJButton. For JButtons the AccessibleContext takes the form of an AccessibleJButton. A new AccessibleJButton instance is created if necessary. @return an AccessibleJButton that serves as the AccessibleContext of this JComponentJButton @beaninfo expert: true description: The AccessibleContext associated with this Button.

NotificationOverrides JComponent.removeNotify to check if this component that it no longer has a parentbutton is currently set as the default button component.on When this method is invoked any KeyboardActionsthe RootPane and if so sets the setRootPane's up indefault button theto null to ensure the chainRootPane ofdoesn't parent components arehold onto an removed.invalid @seebutton #registerKeyboardActionreference.

An implementation of a CheckBoxcheck box -- an item that can be selected or deselected and which displays its state to the user. In a groupBy convention any number of checkboxescheck boxes in multiple checkboxesa group can be selected. See How to Use CheckBoxesButtonc Check Boxes and Radio Buttons in The Java Tutorial for furtherexamples and information on using documentationcheck boxes.

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JCheckBox key assignments.

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. A future release of Swing will provide support for long term persistence. @see JRadioButton @beaninfo attribute: isContainer false description: A component which can be selected or deselected. @version 1.46 0958 03/0114/9800 @author Jeff Dinkins

TheThis class usedimplements toaccessibility support obtainfor the accessibleJCheckBox class. It role forprovides an thisimplementation of the Java Accessibility API appropriate to check box user-interface objectelements.

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. A future release of Swing will provide support for long term persistence.

Creates an initially unselected checkboxcheck box button with no text no icon.

Creates an initially unselected checkboxcheck box with an icon. @param icon the Icon image to display

Creates a checkboxcheck box with an icon and specifies whether or not it is initially selected. @param icon the Icon image to display @param selected a boolean value indicating the initial selection state. If true the checkboxcheck box is selected

Creates an initially unselected checkboxcheck box with text. @param text the text of the checkboxcheck box.

Creates an initially unselected checkboxcheck box with the specified text and icon. @param text the text of the checkboxcheck box. @param icon the Icon image to display

Creates a checkboxcheck box with text and icon and specifies whether or not it is initially selected. @param text the text of the checkboxcheck box. @param icon the Icon image to display @param selected a boolean value indicating the initial selection state. If true the checkboxcheck box is selected

Creates a checkboxcheck box with text and specifies whether or not it is initially selected. @param text the text of the checkboxcheck box. @param selected a boolean value indicating the initial selection state. If true the checkboxcheck box is selected

GetGets the AccessibleContext associated with this JComponentJCheckBox. For JCheckBoxes the AccessibleContext takes the form of an AccessibleJCheckBox. A new AccessibleJCheckBox instance is created if necessary. @return an AccessibleJCheckBox that serves as the AccessibleContext of this JComponentJCheckBox @beaninfo expert: true description: The AccessibleContext associated with this CheckBox.

A menu item that can be selected or deselected. If selected the menu item typically appears with a checkmark next to it. If unselected or deselected the menu item appears without a checkmark. Like a regular menu item a checkboxcheck box menu item can have either text or a graphic icon associated with it or both.

Either isSelected/setSelected or getState/setState can be used to determine/specify the menu item's selection state. (The Swing-standardpreferred methods are isSelected and setSelected. These methodswhich work for all menus and buttons. The getState and setState methods exist for compatibility with other component sets.)

For further information and examples of using check box menu items see How to Use Menus a section in The Java Tutorial. For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JCheckBoxMenuItem key assignments.

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. A future release of Swing will provide support for long term persistence. @beaninfo attribute: isContainer false description: A menu item which can be selected or deselected. @version 1.40 1147 03/0214/9800 @author Georges Saab @author David Karlton

TheThis class usedimplements toaccessibility support obtainfor the accessibleJCheckBoxMenuItem class. It role forprovides an thisimplementation of the Java Accessibility API appropriate to checkbox menu item user-interface objectelements.

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. A future release of Swing will provide support for long term persistence.

Creates an initially unselected checkboxMenuItemcheck box menu item with no set text or icon.

Creates an initially unselected checkboxMenuItemcheck box menu item with an icon. @param icon the icon of the CheckBoxMenuItem.

Creates an initially unselected checkboxMenuItemcheck box menu item with text. @param text the text of the CheckBoxMenuItem

Creates an initially unselected checkboxMenuItemcheck box menu item with the specified text and icon. @param text the text of the CheckBoxMenuItem @param icon the icon of the CheckBoxMenuItem

Creates a checkboxMenuItemcheck box menu item with the specified text icon and selection state. @param text the text of the CheckBoxMenuItemcheck box menu item @param icon the icon of the CheckBoxMenuItemcheck box menu item @param b the selected state of the checkboxmenuitemcheck box menu item

Creates a checkboxMenuItemcheck box menu item with the specified text and selection state. @param text the text of the CheckBoxMenuItemcheck box menu item. @param b the selected state of the checkboxmenuitemcheck box menu item

GetGets the AccessibleContext associated with this JComponentJCheckBoxMenuItem. For JCheckBoxMenuItems the AccessibleContext takes the form of an AccessibleJCheckBoxMenuItem. A new AccessibleJCheckBoxMenuItem instance is created if necessary. @return an AccessibleJCheckBoxMenuItem that serves as the AccessibleContext of this JComponentAccessibleJCheckBoxMenuItem

Returns an array (length 1) containing the checkboxcheck box menu item label or null if the checkboxcheck box is not selected. @return an array containing 1one Object -- the text of the menu item -- if the item is selected; otherwise null

Sets the selected-state of the item. This method exists for AWT compatibility only. New code should use setSelected() instead. @param b a boolean value indicating the item's selected-state where true=selected @beaninfo description: The selection state of the Checkboxcheck box menu item hidden: true

JColorChooser provides a pane of controls designed to allow a user to manipulate and select a color. For information about using color choosers see How to Use Color Choosers a section in The Java Tutorial.

This class provides 3three levels of API:

1. A static convenience method which shows a modal color-chooser dialog and returns the color selected by the user.
2. A static convenience method for creating a color-chooser dialog where ActionListeners can be specified to be invoked when the user presses one of the dialog buttons.
3. The ability to create instances of JColorChooser panes directly (within any container). PropertyChange listeners can be added to detect when the current "color" property changes.

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. A future release of Swing will provide support for long term persistence. 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. A future release of Swing will provide support for long term persistence. @beaninfo attribute: isContainer false description: A component that supports selecting a Color. @version 1.22 0929 03/0114/9800 @author James Gosling @author Amy Fowler @author Steve Wilson

TheThis class usedimplements toaccessibility support obtainfor the accessibleJColorChooser class. It contextprovides foran implementation of the Java Accessibility API appropriate to color chooser thisuser-interface objectelements.

Creates a color chooser pane with the specified ColorSelectionModel. @param initialColor the initial color set in the chooser

Creates and returns a new dialog containing the specified ColorChooser` pane along with "OK" "Cancel" and "Reset" buttons. If the "OK" or "Cancel" buttons are pressed the dialog is automatically hidden (but not disposed). If the "Reset" button is pressed the color-chooser's color will be reset to the color which was set the last time show() was invoked on the dialog and the dialog will remain showing. @param c the parent component for the dialog @param title the title for the dialog @param modal a boolean. When true the remainder of the program is inactive until the dialog is closed. @param chooserPane the color-chooser to be placed inside the dialog @param okListener the ActionListener invoked when "OK" is pressed @param cancelListener the ActionListener invoked when "Cancel" is pressed

GetGets the AccessibleContext associated with this JColorChooser. For color choosers the AccessibleContext takes the form of an AccessibleJColorChooser. A new AccessibleJColorChooser instance is created if necessary. @return an AccessibleJColorChooser that serves as the AccessibleContext of this JColorChooser

Returns the name of the L&F class that renders this component. @return the string "ColorChooserUI" @see JComponent#getUIClassID @see UIDefaults#getUI

Returns a string representation of this JColorChooser. This method is intended to be used only for debugging purposes and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null. @return a string representation of this JColorChooser.

Removes the Color Panel specified. @exception IllegalArgumentException if panel is not in list of known chooser panels @param name a string that specifies the panel to be removed @return the color panel

Sets the current color of the color chooser to the specified color. This will fire a PropertyChangeEvent for the property named "color". @param color the color to be set in the color chooser @see JComponent#addPropertyChangeListener @beaninfo bound: false hidden: false description: The current color the chooser is to display.

Sets the current color of the color chooser to the specified RGB color. Note that the values of red green and blue should be between the numbers 0 and 255 inclusive. @param r an int specifying the amount of Red @param g an int specifying the amount of Green @param b an int specifying the amount of Blue @exception IllegalArgumentException if r g b values are out of range @see java.awt.Color

Sets the current preview panel. This will fire a PropertyChangeEvent for the property named "previewPanel". @param color the color to be set in the color chooser @see JComponent#addPropertyChangeListener @beaninfo bound: true hidden: true description: The UI component which displays the current color.

Shows a modal color-chooser dialog and blocks until the dialog is hidden. If the user presses the "OK" button then this method hides/disposes the dialog and returns the selected color. If the user presses the "Cancel" button or closes the dialog without pressing "OK" then this method hides/disposes the dialog and returns null. @param component the parent Component for the dialog @param title the String containing the dialog's title @param initialColor the initial Color set when the color-chooser is shown

Notification from the UIManager that the L&F has changed. Replaces the current UI object with the latest version from the UIManager. @see JComponent#updateUI

Swing'sA implementation ofcomponent that combines a ComboBoxbutton --or text field and a combinationdrop-down oflist. The user can select a text field andvalue from the drop-down list thatwhich letsappears at the user's eitherrequest. type in a value or select it from a list thatIf you make the combo box editable then the combo box isincludes a text field displayed wheninto which the user askscan fortype a itvalue. TheFor editing capability can also be disabled so thatexamples and information on using combo boxes see theHow JComboBox acts onlyto Use Combo asBoxes a drop downsection in listThe Java Tutorial.

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JComboBox key assignments.

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. A future release of Swing will provide support for long term persistence. @beaninfo attribute: isContainer false description: A combination of a text field and a drop-down list. @version 1.57 1079 03/0814/9800 @author Arnaud Weber

TheThis class usedimplements toaccessibility support obtainfor the accessibleJComboBox class. It role forprovides an thisimplementation of the Java Accessibility API appropriate to Combo Box user-interface objectelements.

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. A future release of Swing will provide support for long term persistence.

Get the AccessibleAction associated with this object. if oneIn the exists.implementation of the Java Accessibility API Otherwisefor this class return nullthis object which is responsible for implementing the AccessibleAction interface on behalf of itself. @return this object

Returns the number of Actions available in this object. IfThe there is moredefault than one the first onebehavior of a combo box is theto "default"have one action. @return 1 the number of Actions in this object

ReturnReturns the nth Accessible child of the object. The child at index zero represents the popup. If the combo box is editable the child at index one represents the editor. @param i zero-based index of child @return the nth Accessible child of the object

The interface that defines a KeySelectionManager. To qualify as a KeySelectionManager the class needs to implement the method that identifies the list index given a character and the combo box data model.

Creates a JComboBox with a default data model. The default data model is an empty list of objects. Use addItem to add items. By default the first item in the data model becomes selected. @see DefaultComboBoxModel

Creates a JComboBox that takes itsit's items from an existing ComboBoxModel. Since the ComboBoxModel is provided a combo box created using this constructor does not create a default combo box model and may impact how the insert remove and add methods behave. @param aModel the ComboBoxModel that provides the displayed list of items @see DefaultComboBoxModel

Creates a JComboBox that contains the elements in the specified array. By default the first item in the array (and therefore the data model) becomes selected. @param items an array of objects to insert into the combo box @see DefaultComboBoxModel

Creates a JComboBox that contains the elements in the specified Vector. By default the first item in the vector and therefore the data model) becomes selected. @param items an array of vectors to insert into the combo box @see DefaultComboBoxModel

Adds an ActionListener. The listener will receive an action event the user finishes making a selection. @param l the ActionListener that is to be notified

Adds an item to the item list. This method works only if the JComboBox uses the default data model. JComboBox uses the default data model when created with the empty constructor and no other model has been set.

Warning: Focus and keyboard navigation problems may arise if you add duplicate String objects. A workaround is to add new objects instead of String objects and make sure that the toString() method is defined. For example:

 comboBox.addItem(makeObj("Item 1")); comboBox.addItem(makeObj("Item 1")); ... private Object makeObj(final String item) { return new Object() { public String toString() { return item; } }; } 

@param anObject the Object to add to the list

Adds an ItemListener. aListener will receive an event when the selected item changes. @param aListener the ItemListener that is to be notified

Initializes the editor with the specified item. @param anEditor the ComboBoxEditor that displays the list item in the combo box field and allows it to be edited @param anItem the object to display and edit in the field

Returns an instance of the default key-selection manager. @return the KeySelectionManager currently used by the list @see #setKeySelectionManager

NotifyNotifies all listeners that have registered interest for notification on this event type. @param e the event of interest @see EventListenerList

NotifyNotifies all listeners that have registered interest for notification on this event type. @param e the event of interest @see EventListenerList

GetGets the AccessibleContext associated with this JComponentJComboBox. For combo boxes the AccessibleContext takes the form of an AccessibleJComboBox. A new AccessibleJComboBox instance is created if necessary. @return an AccessibleJComboBox that serves as the AccessibleContext of this JComponentJComboBox

Returns the action commnandcommand that is included in the event sent to action listeners. @return the string containing the "command" that is sent to action listeners.

Returns the editor used to paint and edit the selected item in the JComboBox field. @return the ComboBoxEditor that displays the selected item

Returns the list item at the specified index. If index is out of range (less than zero or greater than or equal to size) it will return null. @param index an intinteger indicating the list position where the first item starts at zero @return the Object at that list position; or null if out of range

Returns the number of items in the list. @return an intinteger equal to the number of items in the list

Returns the list's key-selection manager. @return the KeySelectionManager currently in use

Returns the maximum number of items the combo box can display without a scrollbar @return an intinteger specifying the maximum number of items that are displayed in the list before using a scrollbar

Returns the data model currently used by the JComboBox. @return the ComboBoxModel that provides the displayed list of items

Returns the renderer used to display the selected item in the JComboBox field. @return the ListCellRenderer that displays the selected item.

Returns the index of the currently selected item infirst item in the list that matches the listgiven item. The result is not always defined if the JComboBox box allows selected items that are not in the list. Returns -1 if there is no selected item or if the user specified an item which is not in the list. @return an intinteger specifying the currently selected list item where 0 specifies the first item in the list; or -1 if no item is selected or if the currently selected item is not in the list

Returns an array containing the selected item. This method is implemented for compatibility with ItemSelectable. @returns an array of Objects containing one element -- the selected item

Returns the name of the L&F class that renders this component. @return the string "ComboBoxUI" @see JComponent#getUIClassID @see UIDefaults#getUI

Causes the combo box to close its popup window. @see #setPopupVisible

Inserts an item into the item list at a given index. This method works only if the JComboBox uses the default data model. JComboBox uses the default data model when created with the empty constructor and no other model has been set. @param anObject the Object to add to the list @param index an intinteger specifying the position at which to add the item

Invoked when values have been removed from the data model. The "interval" includes the first and last values removed. @see javax.swing.event.ListDataListener

Returns true if the JComboBox is editable. By default a combo box is not editable. @return true if the JComboBox is editable else false

Returns true if the component can receive the focus. In this case the component returns false if it is editable so that the Editor object receives the focus instead of the component. @return true if the component can receive the focus else false.

DetermineDetermines the visibility of the popup.

Returns a string representation of this JComboBox. This method is intended to be used only for debugging purposes and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null. @return a string representation of this JComboBox.

Handles KeyEventsKeyEvents looking for the Tab key. If the Tab key is found the popup window is closed. @param e the KeyEvent containing the keyboard key that was pressed

Removes an ActionListener. @param l the ActionListener to remove

Removes all items from the item list. This method works only if the JComboBox uses the default data model. JComboBox uses the default data model when created with the empty constructor and no other model has been set.

Removes an item from the item list. This method works only if the JComboBox uses the default data model. JComboBox uses the default data model when created with the empty constructor and no other model has been set. @param anObject the object to remove from the item list

Removes the item at anIndex This method works only if the JComboBox uses the default data model. JComboBox uses the default data model when created with the empty constructor and no other model has been set. @param anIndex an int specifying the idex of the item to remove where 0 indicates the first item in the list

Removes an ItemListener. @param aListener the ItemListener to remove

This method is called when the selected item changes. Its default implementation notifies the item listeners.

Sets the action commnand that should be included in the event sent to action listeners. @param aCommand a string containing the "command" that is sent to action listeners. The; the same listener can then do different things depending on the command it receives.

Determines whether the JComboBox field is editable. An editable JComboBox allows the user to type into the field or selected an item from the list to initialize the field after which it can be edited. (The editing affects only the field the list item remains intact.) A non editable JComboBox displays the selected item inthein the field but the selection cannot be modified. @param aFlag a boolean value where true indicates that the field is editable @beaninfo bound: true preferred: true description: If true the user can type a new value in the combo box.

Sets the editor used to paint and edit the selected item in the JComboBox field. The editor is used only if the receiving JComboBox is editable. If not editable the combo box uses the renderer to paint the selected item. @param anEditor the ComboBoxEditor that displays the selected item @see #setRenderer @beaninfo bound: true expert: true description: The editor that combo box uses to edit the current value

Enables the combo box so that items can be selected. When the combo box is disabled items cannot be selected and values cannot be typed into its field (if it is editable). @param b a boolean value where true enables the component and false disables it @beaninfo bound: true preferred: true description: Whether the combo box is enabled.

When displaying the popup JComboBox choose to use a light weight popup if it fits. This method allows you to disable this feature. You have to do disable it if your application mixes light weight and heavy weights components. @beaninfo expert: true description: When set disables using light weight popups.

Sets the maximum number of rows the JComboBox displays. If the number of objects in the model is greater than count the combo box uses a scrollbar. @param count an intinteger specifying the maximum number of items to display in the list before using a scrollbar @beaninfo bound: true preferred: true description: The maximum number of rows the popup should have

Sets the data model that the JComboBox uses to obtain the list of items. @param aModel the ComboBoxModel that provides the displayed list of items @beaninfo bound: true description: Model that the combo box uses to get data to display.

SetSets the visiblityvisibility of the popup.

Sets the renderer that paints the item selected from the list in the JComboBox field. The renderer is used if the JComboBox is not editable. If it is editable the editor is used to render and edit the selected item.

The default renderer displays a string obtained by calling the selected object's toString method. Other renderers can handle graphic images and composite items.

To display the selected item aRenderer.getListCellRendererComponent is called passing the list object and an index of -1. @param aRenderer the ListCellRenderer that displays the selected item. @see #setEditor @beaninfo bound: true expert: true description: The renderer that paints the item selected in the list.

Selects the item at index anIndex. @param anIndex an intinteger specifying the list item to select where 0 specifies the first item in the list @exception IllegalArgumentException if anIndex <-1 or anIndex is greater than or equal to size @beaninfo preferred: true description: The item at index is selected.

Sets the selected item in the JComboBox by specifying the object in the list. If anObject is in the list the list displays with anObject selected. If the object does not exist in the list the default data model selects the first item in the list. @param anObject the list object to select @beaninfo preferred: true description: Sets the selected item in the JComboBox.

Sets the L&F object that renders this component. @param ui the ComboBoxUI L&F object @see UIDefaults#getUI @beaninfo expert: true description: The ComboBoxUI implementation that defines the combo box look and feel.

Causes the combo box to display its popup window. @see #setPopupVisible

Notification from the UIFactory that the L&F has changed. @see JComponent#updateUI

The base class for all Swing components except top-level containers. To use a component that inherits from JComponent you must place the component in a containment hierarchy whose root is a top-level Swing container. Top-level Swing containers -- such as JFrame JDialog and JApplet -- are specialized components that provide a place for other Swing components to paint themselves. For an explanation of containment hierarchies see Swing Components and the Containment Hierarchy a section in The Java Tutorial.

The JComponent class provides:

• The base class for both standard and custom components that use the Swing architecture.
• A "pluggable look and feel" (lL&fF) that can be specified by the programmer or (optionally) selected by the user at runtime. Components that areSee designedHow to beSet the combinedLook and extendedFeel in orderThe toJava createTutorial customfor componentsmore information.
• Comprehensive keystroke-handling thathandling. works with nestedSee the document components.Keyboard ActionBindings objectsin forSwing single-pointan control ofarticle in programThe actionsSwing initiatedConnection by multiple componentsfor more information.
• ASupport for tool tips -- border propertyshort descriptions that implicitlypop up defineswhen the component'scursor lingers over insetsa component. TheSee abilityHow to set theUse Tool preferredTips minimimin andThe maximumJava sizeTutorial for a componentmore information.
• ToolTips --Support shortfor descriptionsaccessibility. thatJComponent pop up whencontains all of the cursor lingersmethods over ain the component.Accessible Autoscrollinginterface --but automaticit scrollingdoesn't in a listactually implement the tableinterface. or tree that occurs whenThat is the responsibility of the userindividual is dragging theclasses that extend mouseJComponent.
• Simple easySupport for dialogcomponent-specific constructionproperties. using staticWith the methods#putClientProperty inand the#getClientProperty JOptionPane class that letmethods you can associate youname-object display information and query thepairs with any object that userdescends from JComponent.
• Slow-motionAn graphics rendering using debugGraphics so you can see what isinfrastructure for painting that includes double buffering and support for beingborders. displayed on screen andFor more information see whetherPainting orand notHow it isto Use beingBorders overwritten.both Supportof forwhich Accessibility.are Supportsections forin The internationalJava LocalizationTutorial.

For more information on these subjects see the Swing package description and The Java Tutorial section The JComponent 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. A future release of Swing will provide support for long term persistence. @see KeyStroke @see Action @see #setBorder @see #registerKeyboardAction @see JOptionPane @see #setDebugGraphicsOptions @see #setToolTipText @see #setAutoscrolls @version 2.111 03130 07/0809/0099 @author Hans Muller @author Arnaud Weber

Inner class of JComponent used to provide default support for accessibility. This class is not meant to be used directly by application developers but is instead meant only to be subclassed by component developers. Due to a restriction that protected inner classes cannot be subclassed outside of a package this inner class has been made public. When this restriction is lifted for JDK1.1.7 this class will be made protected. The class used to obtain the accessible role for this object.

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. A future release of Swing will provide support for long term persistence.

AddAdds a PropertyChangeListener to the listener list. @param listener Thethe PropertyChangeListener to be added

ReturnReturns the nth Accessible child of the object. @param i zero-based index of child @return the nth Accessible child of the object

GetGets the accessible description of this object. This should be a concise localized description of what this object is - what is it'sits meaning to the user. If the object has a tooltip the tooltip text may be an appropriate string to return assuming it contains a concise description of the object (instead of just the name of the object - e.g.for example a "Save" icon on a toolbar that had "save" as the tooltip text shouldn't return the tooltip text as the description but something like "Saves the current text document" instead). @return the localized description of the object -- can be null if this object does not have a description @see AccessibleContext#setAccessibleDescription

GetGets the accessible name of this object. This should almost never return java.awt.Component.getName() as that generally isn't a localized name and doesn't have meaning for the user. If the object is fundamentally a text object (e.g.such as a menu item) the accessible name should be the text of the object (e.g.for example "save"). If the object has a tooltip the tooltip text may also be an appropriate String to return. @return the localized name of the object -- can be null if this object does not have a name @see AccessibleContext#setAccessibleName

GetGets the role of this object. @return an instance of AccessibleRole describing the role of the object @see AccessibleRole

GetGets the state of this object. @return an instance of AccessibleStateSet containing the current state set of the object @see AccessibleState

RemoveRemoves a PropertyChangeListener from the listener list. This removes a PropertyChangeListener that was registered for all properties. @param listener Thethe PropertyChangeListener to be removed

Set the background color of this object. (For transparency see isOpaque.) @param c the new Color for the background @see JComponentComponent#isOpaque

Default JComponent constructor. This constructor does no initialization beyond calling the Container constructor e.g. For example the initial layout manager is null.

Registers listener so that it will receive AncestorEvents when it or any of its ancestors move or are made visible / invisible. Events are also sent when the component or its ancestors are added or removed from the Componentcontainment hierarchy This method will migrate to java.awt.Component in the next major JDK release @see AncestorEvent

NotificationNotifies to this component that it now has a parent component. When this method is invoked the chain of parent components is set up with KeyboardAction event listeners. @see #registerKeyboardAction

AddAdds a PropertyChangeListener to the listener list. The listener is registered for all properties.

A PropertyChangeEvent will get fired in response to setting a bound property e.g.such as setFont setBackground or setForeground. Note that if the current component is inheriting its foreground background or font from its container then no event will be fired in response to a change in the inherited property. This method will migrate to java.awt.Component in the next major JDK release @param listener Thethe PropertyChangeListener to be added

AddAdds a PropertyChangeListener for a specific property. The listener will be invoked only when a call on firePropertyChange names that specific property. If listener is null no exception is thrown and no action is performed. @param propertyName Thethe name of the property to listen on. @param listener Thethe PropertyChangeListener to be added

AddAdds a VetoableChangeListener to the listener list. The listener is registered for all properties. This method will migrate to java.awt.Component in the next major JDK release @param listener Thethe VetoableChangeListener to be added

Returns the Component's "visible rect rectangle" - the intersection of the visible rectangles for this component and all of its ancestors. The return value is stored in visibleRect. @see #getVisibleRect

GiveGives the UI delegate an opportunity to define the precise shape of this component for the sake of mouse processing. @return true if this component logically contains x y. @see java.awt.Component#contains(int int)

@deprecatedoverridden As of JDKto ensure Accessibility version 1.1 replaced by setEnabled(boolean).support

SupportSupports for reporting bound property changes. If oldValue and newValue are not equal and the PropertyChangeEvent listener list isn't empty then fire a PropertyChange event to each listener. This method has an overloaded method for each primitive type. For example here's how to write a bound property set method whose value is an int:

 public void setFoo(int newValue) { int oldValue = foo; foo = newValue; firePropertyChange("foo" oldValue newValue); } 

This method will migrate to java.awt.Component in the next major JDK release @param propertyName Thethe programmatic name of the property that was changed. @param oldValue Thethe old value of the property. @param newValue Thethe new value of the property. @see java.beans.PropertyChangeSupport

SupportSupports for reporting constrained property changes. This method can be called when a constrained property has changed and it will send the appropriate PropertyChangeEvent to any registered VetoableChangeListeners. This method will migrate to java.awt.Component in the next major JDK release @exception PropertyVetoException when the attempt to set the property is vetoed by the receiver.

GetGets the AccessibleContext associated with this JComponent. @return the AccessibleContext of this JComponent

ReturnReturns the object that will perform the action registered for a given keystroke. @return the ActionListener object invoked when the keystroke occurs @see #registerKeyboardAction

Overrides Container.getAlignmentX to return the vertical alignment. @return the value of the alignmentX property. @see #setAlignmentX @see java.awt.Component#getAlignmentX

Overrides Container.getAlignmentY to return the horizontal alignment. @return the value of the alignmentY property. @see #setAlignmentY @see java.awt.Component#getAlignmentY

Returns true if this component automatically scrolls its contents when dragged (when contained in a component that supports scrolling like JViewport). @see JViewport @see #setAutoscrolls

StoreStores the bounds of this component into "return value" rv and returnreturns rv. If rv is null a new Rectangle is allocated. This version of getBounds() is useful if the caller wants to avoid allocating a new Rectangle object on the heap. @param rv the return value modified to the componentscomponent's bounds @return rv

Returns the graphics object used to paint this component. If DebugGraphics is turned on we create a new DebugGraphics object if neccessarynecessary. otherwiseOtherwise we just configure the specified graphics objectsobject's foreground and font. @return Aa Graphics object configured for this component

ReturnReturns the condition that determines whether a registered action occurs in response to the specified keystroke.

For Java 2 platform v1.3 a KeyStroke can be associated with more than one condition. For example 'a' could be bound for the two conditions WHEN_FOCUSED and WHEN_IN_FOCUSED_WINDOW condition. @return the action-keystroke condition @see #registerKeyboardAction

ReturnReturns the current height of this component. This method is preferable to writing component.getBounds().height or component.getSize().height because it doesn't cause any heap allocations. This method will migrate to java.awt.Component in the next major JDK release @return the current height of this component.

If a border has been set on this component returns the border's insets; elseotherwise calls super.getInsets. @return the value of the insets property. @see #setBorder

Returns an Insets object containing this component's inset values. The passed-in Insets object will be reused if possible. Calling methods cannot assume that the same object will be returned however. All existing values within this object are overwritten. @param insets the Insets object which can be reused. @see #getInsets @beaninfo expert: true

StoreStores the x y origin of this component into "return value" rv and returnreturns rv. If rv is null a new Point is allocated. This version of getLocation() is useful if the caller wants to avoid allocating a new Point object on the heap. @param rv the return value modified to the componentscomponent's location @return rv

If the maximumSizemaximum size has been set to a non-null value just returnreturns it. If the UI delegatesdelegate's getMaximumSize() method returns a non null value then return that; otherwise defer to the componentscomponent's layout manager. @return the value of the maximumSize property. @see #setMaximumSize

If the minimumSizeminimum size has been set to a non-null value just returnreturns it. If the UI delegatesdelegate's getMinimumSize() method returns a non -null value then return that; otherwise defer to the componentscomponent's layout manager. @return the value of the minimumSize property. @see #setMinimumSize

ReturnReturns the next focusable component or null if the focus manager should choose the next focusable component automatically.

If the preferredSize has been set to a non-null value just returnreturns it. If the UI delegatesdelegate's getPreferredSize() method returns a non null then value then return that; otherwise defer to the componentscomponent's layout manager. @return the value of the preferredSize property. @see #setPreferredSize

ReturnReturns the KeyStrokes that will initiate registered actions. @return an array of KeyStroke objects @see #registerKeyboardAction

StoreStores the width/height of this component into "return value" rv and returnreturns rv. If rv is null a new Dimension object is allocated. This version of getSize() is useful if the caller wants to avoid allocating a new Dimension object on the heap. @param rv the return value modified to the componentscomponent's size @return rv

ReturnReturns the tooltip location in the receivingthis component's coordinate system. If null is returned Swing will choose a location. The default implementation returns null. @param event the MouseEvent that caused the ToolTipManager to show the tooltip.

ReturnReturns the tooltip string that has been set with setToolTipText(). @return the text of the tool tip @see #TOOL_TIP_TEXT_KEY

Returns the string to be used as the tooltip for event. By default this returns any string set using setToolTipText(). If a component provides more extensizeextensive API to support differing tooltips at different locations this method should be overridden.

Returns the top-level ancestor of this component (either the containing Window or Applet) or null if this component has not been added to any container. @return the top-level Container whichthat this component is in.

ReturnReturns the UIDefaults key used to look up the name of the swing.plaf.ComponentUI class that defines the look and feel for this component. Most applications will never need to call this method. Subclasses of JComponent that support pluggable look and feel should override this method to return a UIDefaults key that maps to the ComponentUI subclass that defines their look and feel. @return The UIDefaults key for a ComponentUI subclass. @see UIDefaults#getUI @beaninfo expert: true description: UIClassID

Returns the Component's "visible rectangle" - the intersection of this componentscomponent's visible rectangle:

 new Rectangle(0 0 getWidth() getHeight()); 

and all of its ancestors' visible Rectangles. @return the visible rectangle

ReturnReturns the current width of this component. This method is preferable to writing component.getBounds().width or component.getSize().width because it doesn't cause any heap allocations. This method will migrate to java.awt.Component in the next major JDK release @return the current width of this component.

ReturnReturns the current x coordinate of the componentscomponent's origin. This method is preferable to writing component.getBounds().x or component.getLocation().x because it doesn't cause any heap allocations. This method will migrate to java.awt.Component in the next major JDK release @return the current x coordinate of the componentscomponent's origin.

ReturnReturns the current y coordinate of the componentscomponent's origin. This method is preferable to writing component.getBounds().y or component.getLocation().y because it doesn't cause any heap allocations. This method will migrate to java.awt.Component in the next major JDK release @return the current y coordinate of the componentscomponent's origin.

SetSets the focus on the receiving component if it doesn't already have it. This method is for focus managers. youYou rarely want to call this method; use requestFocus() ensteadinstead.

Returns true if this Component has the keyboard focus. This method will migrate to java.awt.Component in the next major JDK release @return true if this Component has the keyboard focus.

ReturnReturns whether the receiving component should use a buffer to paint.

Returns true if this component is a lightweight i.e.that is if it doesn't have a native window system peer. This method will migrate to java.awt.Component in the next major JDK release @return true if this component is a lightweight

Override this method and return true if your JComponent manages focus. If your component manages focus the focus manager will handle your component's children. All key event will be sent to your key listener including TAB and SHIFT+TAB. CONTROL + TAB and CONTROL + SHIFT + TAB will move the focus to the next /or previous component.

Returns true if this component is completely opaque.

An opaque component paints every pixel within its rectangular regionbounds. A non-opaque component paints only somea subset of its pixels or none at all allowing the pixels underneath it to "show through". ATherefore a component that does not fully paint its pixels therefore provides a degree of transparency.

Subclasses that guarantee to always completely paint their contents should override this method and return true. This method will migrate to java.awt.Component in the next major JDK release @return true if this component is completely opaque. @see #setOpaque

Returns true if this component tiles its children i.e.-- that is if it can guarantee that the children will not overlap. The repainting system is substantially more efficient in this common case. JComponent subclasses that can't make this guarantee e.g.such as JLayeredPane should override this method to return false. @return true if this componentscomponent's children don't overlap

ReturnReturns whether the receiving component can obtain the focus by calling requestFocus. @see #setRequestFocusEnabled

This method is invoked by Swing to draw components. Applications should not invoke paint directly but should instead use the repaint method to schedule the component for redrawing.

This method actually delegates the work of painting to three protected methods: paintComponent paintBorder and paintChildren. They're called in the order listed to ensure that children appear on top of component itself. Generally speaking the component and its children should not paint in the insets area allocated to the border. Subclasses can just override this method as always. A subclass that just wants to specialize the UI (look and feel) delegatesdelegate's paint method should just override paintComponent. @see #paintComponent @see #paintBorder @see #paintChildren @see #getComponentGraphics @see #repaint

PaintPaints the component's border. @see #paint @see #setBorder

PaintPaints this component's children. If shouldUseBuffer is true no component ancestor has a buffer and the component children can use a buffer if they have one. Otherwise one ancestor has a buffer currently in use and children should not use a buffer to paint. @see #paint @see java.awt.Container#paint

If the UI delegate is non-null callcalls its paint method. We pass the delegate a copy of the Graphics object to protect the rest of the paint code from irrevocable changes (e.g.for example Graphics.translate()). @see #paint

PaintPaints the specified region now. This method will migrate to java.awt.Component in the next major JDK release

PaintPaints the specified region in this component and all of its descendants that overlap the region immediately.

It's rarely neccessarynecessary to call this method. In most cases it's more efficient to call repaint which defers the actual painting and can collapse redundant requests into a single paint call. This method is useful if one needs to update the display while the current event is being dispatched. @see #repaint

Returns a string representation of this JComponent. This method is intended to be used only for debugging purposes and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null. @return a string representation of this JComponent.

ProcessProcesses any key events that the component itself recognizes. This will beis called after the focus manager and any interested listeners have been given a chance to steal away the event. This method will only beis called isonly if the event has not yet been consumed. This method is called prior to the keyboard UI logic.

This method is implemented to do nothing. Subclasses would normally override this method if they process some key events themselves. If the event is processed it should be consumed.

OverrideOverrides processKeyEvent to process events.

AddAdds an arbitrary key/value "client property" to this component.

The get/putClientProperty methods provide access to a small per-instance hashtable. Callers can use get/putClientProperty to annotate components that were created by another module e.g. For example a layout manager might store per child constraints this way. For example:

 componentA.putClientProperty("to the left of" componentB); 

If value is null this method will remove the property. Changes to client properties are reported with PropertyChange events. The name of the property (for the sake of PropertyChange events) is key.toString().

The clientProperty dictionary is not intended to support large scale extensions to JComponent nor should be it considered an alternative to subclassing when designing a new component. @see #getClientProperty @see #addPropertyChangeListener

CallsThis registerKeyboardAction(ActionListenermethod String KeyStrokeis now condition)obsolete withplease use a nullcombination of getActionMap() and getInputMap() for similiar commandbehavior.

This method is now obsolete please use a combination of getActionMap() and getInputMap() for similiar behavior. For example to bind the KeyStroke aKeyStroke to the Action anAction now use:

 component.getInputMap().put(aKeyStroke aCommand); component.getActionMap().put(aCommmand anAction); 

The above assumes you want the binding to be applicable for WHEN_FOCUSED. To register bindings for other focus states use the getInputMap method that takes an integer.

Register a new keyboard action. anAction will be invoked if a key event matching aKeyStroke occurs and aCondition is verified. The KeyStroke object defines a particular combination of a keyboard key and one or more modifiers (alt shift ctrl meta).

The aCommand will be set in the delivered event if specified.

The Condition can be one of:

WHEN_FOCUSED

The action will be invoked only when the keystroke occurs while the component has the focus.

WHEN_IN_FOCUSED_WINDOW

The action will be invoked when the keystroke occurs while the component has the focus or if the component is in the window that has the focus. Note that the component need not be an immediate descendent of the window -- it can be anywhere in the window's containment hierarchy. In other words whenever any component in the window has the focus the action registered with this component is invoked.

WHEN_ANCESTOR_OF_FOCUSED_COMPONENT

The action will be invoked when the keystroke occurs while the component has the focus or if the component is an ancestor of the component that has the focus.

The combination of keystrokes and conditions lets you define high level (semantic) action events for a specified keystroke+modifier combination (using the KeyStroke class) and direct to a parent or child of a component that has the focus or to the component itself. In other words in any hierarchical structure of components an arbitrary key-combination can be immediately directed to the appropriate component in the hierarchy and cause a specific method to be invoked (usually by way of adapter objects).

If an action has already been registered for the receiving container with the same charCode and the same modifiers anAction will replace the action. @see KeyStroke

Unregisters listener so that it will no longer receive AncestorEvents This method will migrate to java.awt.Component in the next major JDK release @see #addAncestorListener

NotificationNotifies to this component that it no longer has a parent component. When this method is invoked any KeyboardActions set up in the the chain of parent components are removed. @see #registerKeyboardAction

RemoveRemoves a PropertyChangeListener from the listener list. This removes a PropertyChangeListener that was registered for all properties. This method will migrate to java.awt.Component in the next major JDK release @param listener Thethe PropertyChangeListener to be removed

RemoveRemoves a PropertyChangeListener for a specific property. If listener is null no exception is thrown and no action is performed. @param propertyName Thethe name of the property that was listened on. @param listener Thethe PropertyChangeListener to be removed

RemoveRemoves a VetoableChangeListener from the listener list. This removes a VetoableChangeListener that was registered for all properties. This method will migrate to java.awt.Component in the next major JDK release @param listener Thethe VetoableChangeListener to be removed

RequestRequests the focus for the component that should have the focus by default. The default implementation will recursively request the focus on the first component that is focus-traversable. @return false if the focus has not been set otherwise return true

SetSets focus on the receiving component if isRequestFocusEnabled returns true and the component doesn't already have focus.

UnregisterUnregisters all keyboardthe actionsbindings @seein #registerKeyboardActionthe first tier InputMaps and ActionMap. This has the effect of removing any local bindings and allowing the bindings defined in parent InputMap/ActionMaps (the UI is usually defined in the second tier) to persist.

SupportSupports for deferred automatic layout.

Calls invalidate() and then adds this componentscomponent's validateRoot to a list of components that need to be validated. Validation will occur after all currently pending events have been dispatched. In other words after this method is called the first validateRoot (if any) found when walking up the containment hierarchy of this component will be validated. By default JRootPane JScrollPane and JTextField return true from isValidateRoot().

This method will automatically be called on this component when a property value changes such that size location or internal layout of this component has been affected. This automatic updating differs from the AWT because programs generally no longer need to invoke validate() to get the contents of the GUI to update.

@see java.awt.Component#invalidate @see java.awt.Container#validate @see #isValidateRoot @see RepaintManager#addInvalidComponent

Forwards the scrollRectToVisible() message to the JComponent's parent. Components that can service the request such as a JViewport override this method and perform the scrolling. @see JViewport

SetSets the the vertical alignment. @see #getAlignmentX @beaninfo description: The preferred horizontal alignment of the component.

SetSets the the horizontal alignment. @see #getAlignmentY @beaninfo description: The preferred vertical alignment of the component.

If true this component will automatically scroll its contents when dragged if contained in a component that supports scrolling such as JViewport. @see JViewport @see #getAutoscrolls @beaninfo expert: true description: Whether this component automatically scrolls its contents when dragged.

Sets the border of this component. The Border object is responsible for defining the insets for the component (overriding any insets set directly on the component) and for optionally rendering any border decorations within the bounds of those insets. Borders should be used (rather than insets) for creating both decorative and non-decorative (e.g.such as margins and padding) regions for a swing component. Compound borders can be used to nest multiple borders within a single component.

This is a bound property. @param border the border to be rendered for this component @see Border @see CompoundBorder @beaninfo bound: true preferred: true attribute: visualUpdate true description: The component's border.

Enables or disables diagnostic information about every graphics operation performed within the component or one of its children. The value of debugOptions determines how the component should display this information:

• DebugGraphics.LOG_OPTION - causes a text message to be printed.
• DebugGraphics.FLASH_OPTION - causes the drawing to flash several times.
• DebugGraphics.BUFFERED_OPTION - creates an ExternalWindow that displays the operations performed on the View's offscreen buffer.

debug is bitwise OR'd into the current value. DebugGraphics.NONE_OPTION disables debugging. A value of 0 causes no changes to the debugging options. @beaninfo preferred: true enum: NONE_OPTION DebugGraphics.NONE_OPTION LOG_OPTION DebugGraphics.LOG_OPTION FLASH_OPTION DebugGraphics.FLASH_OPTION BUFFERED_OPTION DebugGraphics.BUFFERED_OPTION description: Diagnostic options for graphics operations.

SetSets whether the receiving component should use a buffer to paint. If set to true all the drawing from this component will be done in an offscreen painting buffer. The offscreen painting buffer will the be copied onto the screen. Swing's painting system always use a maximum of one double buffer. If a Component is buffered and one of its ancestor is also buffered the ancestor buffer will be used.

Sets whether or not this component is enabled. A component whichthat is enabled may respond to user input while a component whichthat is not enabled cannot respond to user input. Some components may alter their visual representation when they are disabled in order to provide feedback to the user that they cannot take input. @see java.awt.Component#isEnabled @beaninfo preferred: true bound: true attribute: visualUpdate true description: The enabled state of the component.

Sets the maximumSizemaximum size of this component to a constant value. Subsequent calls to getMaximumSize will always return this value; the componentscomponent's UI will not be asked to compute it. Setting the maximumSizemaximum size to null restores the default behavior. @see #getMaximumSize @beaninfo bound: true description: The maximum size of the component.

Sets the minimumSizeminimum size of this component to a constant value. Subsequent calls to getMinimumSize will always return this value; the componentscomponent's UI will not be asked to compute it. Setting the minimumSizeminimum size to null restores the default behavior. @see #getMinimumSize @beaninfo bound: true description: The minimum size of the component.

If true the components background will be filled withcomponent paints every pixel within its the background colorbounds. Otherwise the background is transparent and whatevercomponent may not paint some isor all of its pixels allowing the underneath willunderlying pixels to show through.

The default value of this property is false for JComponent. This is a JavaBeans boundHowever the default value for this property on most standard JComponent subclasses (such as JButton and JTree) is look-and-feel dependent. @see #isOpaque @beaninfo bound: true expert: true description: The component's opacity

SetSets the preferred size of the receiving component. ifIf preferredSize is null the UI will be asked for the preferred size. @beaninfo preferred: true bound: true description: The preferred size of the component.

SetSets whether the receiving component can obtain the focus by calling requestFocus. The default value is true. Note: Setting this property to false will not prevent the focus manager from setting the focus to this component it will prevent the component from getting the focus when the focus is requested explicitly. Override isFocusTraversable and return false if the component should never get the focus. @beaninfo expert: true description: Whether the component can obtain the focus by calling requestFocus.

Registers the text to display in a tool tip. The text displays when the cursor lingers over the component.

See How to Use Tool Tips in The Java Tutorial for further documentation. @param text Thethe string to display.; Ifif the text is null the tool tip is turned off for this component. @see #TOOL_TIP_TEXT_KEY @beaninfo preferred: true description: The text to display in a tool tip.

SetSets the look and feel delegate for this component. JComponent subclasses generally override this method to narrow the argument type e.g. For example in JSlider:

 public void setUI(SliderUI newUI) { super.setUI(newUI); } 

AdditionalyAdditionally JComponent subclasses must provide a getUI method that returns the correct type e.g. For example:

 public SliderUI getUI() { return (SliderUI)ui; } 

@see #updateUI @see UIManager#getLookAndFeel @see UIManager#getUI @beaninfo bound: true attribute: visualUpdate true description: The component's look and feel delegate.

UnregisterThis method is now obsolete. To unregister an existing binding you can either remove the binding from the ActionMap/InputMap or place a dummy binding the InputMap. Removing the binding from the InputMap allows bindings in parent InputMaps to be active whereas putting a dummy binding in the InputMap effectively disables the binding from ever happening.

Unregisters a keyboard action. @seeThis will remove the binding from the #registerKeyboardActionActionMap (if it exists) as well as the InputMaps.

Constant used by some of the apisAPIs to mean that no condition is defined.

Constant used for registerKeyboardAction() whichthat means that the comandcommand should be invoked when the receiving component is an ancestor of the focused component or is itself the focused component.

Constant used for registerKeyboardAction() whichthat means that the command should be invoked when the component has the focus.

Constant used for registerKeyboardAction() whichthat means that the command should be invoked when the receiving component is in the window that has the focus or is itself the focused component.

---The Accessibility SupportAccessibleContext associated ---with JComponent will contain all of the methods in interface Accessible though it won't actally implement the interface - that will be up to the individual objects which extendthis JComponent.

A container used to create a multiple-document interface or a virtual desktop. You create JInternalFrame objects and add them to the JDesktopPane. JDesktopPane extends JLayeredPane to manage the potentially overlapping internal frames. It also maintains a reference to an instance of DesktopManager that is set by the UI class for the current Look and Feel (L&F).

This class is normally used as the parent of JInternalFrames to provide a pluggable DesktopManager object to the JInternalFrames. The installUI of the L&F specific implementation is responsible for setting the desktopManager variable appropriately. When the parent of a JInternalFrame is a JDesktopPane it should delegate most of its behavior to the desktopManager (closing resizing etc).

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JDesktopPane key assignments. For further documentation and examples see How to Use Internal Frames 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. A future release of Swing will provide support for long term persistence. @see JInternalFrame @see JInternalFrame.JDesktopIcon @see DesktopManager @version 1.26 1036 03/1514/9800 @author David Kloba

TheThis class usedimplements toaccessibility support obtainfor the accessibleJDesktopPane class. It role forprovides an thisimplementation of the Java Accessibility API appropriate to desktop pane user-interface objectelements.

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. A future release of Swing will provide support for long term persistence.

GetGets the AccessibleContext associated with this JComponentJDesktopPane. For desktop panes the AccessibleContext takes the form of an AccessibleJDesktopPane. A new AccessibleJDesktopPane instance is created if necessary. @return an AccessibleJDesktopPane that serves as the AccessibleContext of this JComponentJDesktopPane

The main class for creating a dialog window. You can use this class to create a custom dialog or invoke the many staticclass methods in JOptionPane to create a variety of standard dialogs. For information about creating dialogs see The Java Tutorial section How to Make Dialogs.

The JDialog component contains a JRootPane as it'sits only child. The contentPane should be the parent of any children of the JDialog. From the older java.awt.Window object you would normally do something like this:

 dialog.add(child); 

Using JDialog the proper semantic is:

 dialog.getContentPane().add(child); 

The same priniciple holds true for setting layout managers removing components listing children etc. All these methods should normally be sent to the contentPane instead of to the JDialog. The contentPane is always non-null. Attempting to set it to null generates an exception. The default contentPane has a BorderLayout manager set on it.

Please see the JRootPane documentation for a complete description of the contentPane glassPane and layeredPane components.

NOTE: For 1.1 Modal dialogs are currently constrained to only allow lightweight popup menus (JPopupMenu JComboBox JMenuBar) because of window ownership limitations in AWT1.1. This creates the further limitation of not being able to mix Swing popup components with AWT heavyweight components in a modal dialog since the heavyweight components would always overlap the lightweights potentially obscuring the popup menu. (A heavyweight component uses a native-platform component (peer) component for its implementation -- AWT components are heavyweight components.) For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JDialog key assignments.

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. A future release of Swing will provide support for long term persistence. @see JOptionPane @see JRootPane @beaninfo attribute: isContainer true attribute: containerDelegate getContentPane description: A toplevel window for creating dialog boxes. @version 1.43 0451 03/2214/9900 @author David Kloba @author James Gosling @author Scott Violet

TheThis class usedimplements toaccessibility support obtainfor the AccessibleRoleJDialog forclass. It provides an implementation of the Java Accessibility API appropriate to dialog thisuser-interface objectelements.

Get the AccessibleComponent associated with this object if one exists. Otherwise return null. @return the component

Set the background color of this object. (For transparency see isOpaque.) @param c the new Color for the background @see Component#isOpaque

Creates a non-modal dialog without a title and without a specified Frame owner. A shared hidden frame will be set as the owner of the Dialogdialog.

Creates a non-modal dialog without a title with the specifed Dialog as its owner. @param owner the Dialog from which the dialog is displayed

Creates a non-modal dialog with the specified title and with the specified owner dialog. @param owner the Dialog from which the dialog is displayed @param title the String to display in the dialog's title bar

Creates a modal or non-modal dialog with the specified title and the specified owner frame. @param owner the dialogDialog from which the dialog is displayed @param title the String to display in the dialog's title bar @param modal true for a modal dialog false for one that allows othersother windows to be active at the same time

Creates a modal or non-modal dialog without a title and with the specified owner dialog.

@param owner the Dialog from which the dialog is displayed @param modal true for a modal dialog false for one that allows othersother windows to be active at the same time

Creates a non-modal dialog without a title with the specifed Frame as its owner. @param owner the Frame from which the dialog is displayed

Creates a non-modal dialog with the specified title and with the specified owner frame. @param owner the Frame from which the dialog is displayed @param title the String to display in the dialog's title bar

Creates a modal or non-modal dialog with the specified title and the specified owner frameFrame. All constructors defer to this one.

NOTE: Any popup components (JComboBox JPopupMenu JMenuBar) created within a modal dialog will be forced to be lightweight. @param owner the frameFrame from which the dialog is displayed @param title the String to display in the dialog's title bar @param modal true for a modal dialog false for one that allows othersother windows to be active at the same time

Creates a modal or non-modal dialog without a title and with the specified owner frameFrame. @param owner the Frame from which the dialog is displayed @param modal true for a modal dialog false for one that allows others windows to be active at the same time

By default children may not be added directly to a this component they must be added to its contentPane instead. For example:

 thisComponent.getContentPane().add(child) 

An attempt to add to directly to this component will cause an runtime exception to be thrown if rootPaneCheckingEnabled is true. Subclasses can disable this behavior. @param comp the Component to be enhanced @param constraints the constraints to be respected @param index the index (an integer) @see #setRootPaneCheckingEnabled @exception Error if called with rootPaneCheckingrootPaneCheckingEnabled true

Called by the constructor methods to create the default rootPane.

Called by the constructors to init the JDialog properly.

GetGets the AccessibleContext associated with this JDialog. For JDialogs the AccessibleContext takes the form of an AccessibleJDialog. A new AccessibleJDialog instance is created if necessary. @return an AccessibleJDialog that serves as the AccessibleContext of this JDialog

Returns the contentPane object for this dialog. @return the contentPane property @see #setContentPane @see RootPaneContainer#getContentPane

Returns the operation which occurs when the user initiates a "close" on this dialog. @return an intinteger indicating the window-close operation @see #setDefaultCloseOperation

Returns the glassPane object for this dialog. @return the glassPane property @see #setGlassPane @see RootPaneContainer#getGlassPane

Returns the layeredPane object for this dialog. @return the layeredPane property @see #setLayeredPane @see RootPaneContainer#getLayeredPane

Returns the rootPane object for this dialog. @see #setRootPane @see RootPaneContainer#getRootPane

Returns true if the methods add and setLayout should be checked. @return true if add and setLayout should be checked @see #addImpl @see #setLayout @see #setRootPaneCheckingEnabled

Returns a string representation of this JDialog. This method is intended to be used only for debugging purposes and the content and format of the returned string may vary between implementations. The returned string may be empty but may not be null. @return a string representation of this JDialog.

Sets the contentPane property. This method is called by the constructor. @param contentPane the contentPane object for this dialog @exception java.awt.IllegalComponentStateException (a runtime exception) if the content pane parameter is null @see #getContentPane @see RootPaneContainer#setContentPane @beaninfo hidden: true description: The client area of the dialog where child components are normally inserted.

Sets the operation which will happen by default when the user initiates a "close" on this dialog. The possible choices are:

• DO_NOTHING_ON_CLOSE - do not do anything - require the program to handle the operation in the windowClosing method of a registered WindowListener object.
• HIDE_ON_CLOSE - automatically hide the dialog after invoking any registered WindowListener objects
• DISPOSE_ON_CLOSE - automatically hide and dispose the dialog after invoking any registered WindowListener objects EXIT_ON_CLOSE - Exit the application by way of System.exit. Only use this in applications.

The value is set to HIDE_ON_CLOSE by default. @see #addWindowListener @see #getDefaultCloseOperation @beaninfo preferred: true description: The dialog's default close operation.

Sets the glassPane property. This method is called by the constructor. @param glassPane the glassPane object for this dialog @see #getGlassPane @see RootPaneContainer#setGlassPane @beaninfo hidden: true description: A transparent pane used for menu rendering.

Sets the layeredPane property. This method is called by the constructor. @param layeredPane the layeredPane object fornew thislayeredPane dialogproperty @exception java.awt.IllegalComponentStateException (a runtime exception) if the layered pane parameter is null @see #getLayeredPane @see RootPaneContainer#setLayeredPane @beaninfo hidden: true description: The pane which holds the various dialog layers.

By default the layout of this component may not be set the layout of its contentPane should be set instead. For example:

 thisComponent.getContentPane().setLayout(new BorderLayout()) 

An attempt to set the layout of this component will cause an runtime exception to be thrown if rootPaneCheckingEnabled is true. Subclasses can disable this behavior. @see #setRootPaneCheckingEnabled @param manager the LayoutManager @exception Error if called with rootPaneChecking true

Sets the rootPane property. This method is called by the constructor. @param root the rootPane object for this dialog @see #getRootPane @beaninfo hidden: true description: the RootPane object for this dialog.

If true then calls to add() and setLayout() will cause an exception to be thrown. @see #addImpl @see #setLayout @see #isRootPaneCheckingEnabled @beaninfo hidden: true description: Whether the add and setLayout methods throw exceptions when invoked.

JustCalls calls paint(g). This method was overridden to prevent an unneccessary call to clear the background.

A text component to edit various kinds of content. You can find how-to information and examples of using editor panes in Using Text Components a section in The Java Tutorial.

This component uses implementations of the EditorKit to accomplish its behavior. It effectively morphs into the proper kind of text editor for the kind of content it is given. The content type that editor is bound to at any given time is determined by the EditorKit currently installed. If the content is set to a new URL its type is used to determine the EditorKit that should be used to load the content.

By default the following types of content are known:

text/plain

Plain text which is the default the type given isn't recognized. The kit used in this case is an extension of DefaultEditorKit that produces a wrapped plain text view.

text/html

HTML text. The kit used in this case is the class javax.swing.text.html.HTMLEditorKit which provides htmlHTML 3.2 support.

text/rtf

RTF text. The kit used in this case is the class javax.swing.text.rtf.RTFEditorKit which provides a limited support of the Rich Text Format.

There are several ways to load content into this component.

1. The setText method can be used to initialize the component from a string. In this case the current EditorKit will be used and the content type will be expected to be of this type.
2. The read method can be used to initialize the component from a Reader. Note that if the content type is htmlHTML relative references (e.g. for things like images) can't be resolved unless the <base> tag is used or the Base property on HTMLDocument is set. In this case the current EditorKit will be used and the content type will be expected to be of this type.
3. The setPage method can be used to initialize the component from a URL. In this case the content type will be determined from the URL and the registered EditorKit for that content type will be set.

For the keyboard keys used by this component in the standard Look and Feel (L&F) renditions see the JEditorPane key assignments.

Some kinds of content may provide hyperlink support by generating hyperlink events. The htmlHTML EditorKit will generate hyperlink events if the JEditorPane is not editable (i.e. JEditorPane.setEditable(false); has been called). If htmlHTML frames are embedded in the document the typical response would be to change a portion of the current document. The following code fragment is a possible hyperlink listener implementation that treats htmlHTML frame events specially and simply displays any other activated hyperlinks.

   class Hyperactive implements HyperlinkListener {     public void hyperlinkUpdate(HyperlinkEvent e) {   if (e.getEventType() == HyperlinkEvent.EventType.ACTIVATED) {   JEditorPane pane = (JEditorPane) e.getSource();   if (e instanceof HTMLFrameHyperlinkEvent) {   HTMLFrameHyperlinkEvent evt = (HTMLFrameHyperlinkEvent)e;   HTMLDocument doc = (HTMLDocument)pane.getDocument();   doc.processHTMLFrameHyperlinkEvent(evt);   } else {   try {   pane.setPage(e.getURL());   } catch (Throwable t) {   t.printStackTrace();   }   }   }   }   } 

Culturally dependent information in some documents is handled through a mechanism called character encoding. Character encoding is an unambiguous mapping of the members of a character set (letters ideographs digits symbols or control functions) to specific numeric code values. It represents the way the file is stored. Example character encodings are ISO-8859-1 ISO-8859-5 Shift-jis Euc-jp and UTF-8. When the file is passed to an user agent (JEditorPane) it is converted to the document character set (ISO-10646 aka Unicode).

There are multiple ways to get a character set mapping to happen with JEditorPane.

1. One way is to specify the character set as a parameter of the MIME type. This will be established by a call to the setContentType method. If the content is loaded by the setPage method the content type will have been set according to the specification of the URL. It the file is loaded directly the content type would be expected to have been set prior to loading.
2. Another way the character set can be specified is in the document itself. This requires reading the document prior to determining the character set that is desired. To handle this it is expected that the EditorKit.read operation throw a ChangedCharSetException which will be caught. The read is then restarted with a new Reader that uses the character set specified in the ChangedCharSetException (which is an IOException).

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. A future release of Swing will provide support for long term persistence. @beaninfo attribute: isContainer false description: A text component to edit various types of content. @author Timothy Prinzing @version 1.76 0496 03/2214/9900

TheThis class usedimplements toaccessibility support obtainfor the accessibleJEditorPane class. It role forprovides an thisimplementation of the Java Accessibility API appropriate to editor pane user-interface objectelements.

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. A future release of Swing will provide support for long term persistence.

This class provides support for AccessibleHypertext and is used in instances where the EditorKit installed in this JEditorPane is an instance of HTMLEditorKit.

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. A future release of Swing will provide support for baseline for serialized form of Swing objects.

What's returned by AccessibleJEditorPaneHTML.getAccessibleText(). Provides support for AccessibleHypertext in case there is an HTML document being displayed in this JEditorPane.

ConstructsCreates a new JEditorPane. The document model is set to null.

Creates a JEditorPane based on a string containing a URL specification. @param url the URL @exception IOException if the URL is null or cannot be accessed

Creates a JEditorPane that has been initialized to the given text. This is a convenience constructor that calls the setContentType and setText methods. @param type mime type of the given text. @param text the text to initialize with.

Creates a JEditorPane based on a specified URL for input. @param initialPage the URL @exception IOException if the URL is null or cannot be accessed

Creates the default editor kit (PlainEditorKit) for when the component is first created. @return the editor kit

CreateCreates a handler for the given type from the default registry of editor kits. The registry is created if necessary. If the registered class has not yet been loaded an attempt is made to dynamically load the prototype of the kit for the given type. If the type was registered with a ClassLoader that ClassLoader will be used to load the prototype. If there was no registered ClassLoader Class.forName will be used to load the prototype.

Once a prototype EditorKit instance is successfully located it is cloned and the clone is returned. @param type the content type @return the editor kit or null if there is nothing registered for the given type.

Notifies all listeners that have registered interest for notification on this event type. This is normally called by the currently installed EditorKit if a content type that supports hyperlinks is currently active and there was activity with a link. The listener list is processed last to first. @param e the event @see EventListenerList

GetGets the AccessibleContext associated with this JEditorPane. For editor panes the AccessibleContext takes the form of an AccessibleJEditorPane. A new contextAccessibleJEditorPane instance is created if necessary. @return an AccessibleJEditorPane that serves as the AccessibleContext of this JEditorPane

Gets the type of content that this editor is currently set to deal with. This is defined to be the type associated with the currently installed EditorKit. @return the content type null if no editor kit set

Fetches the currently installed kit for handling content. createDefaultEditorKit() is called to set up a default if necessary. @return the editor kit