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 check 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 preferred methods are isSelected and setSelected, which 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.

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

@beaninfo
attribute: isContainer false description: A menu item which can be selected or deselected.
@version
1.55 12/19/03
@author
Georges Saab
@author
David Karlton
Creates an initially unselected check box menu item with no set text or icon.
Creates an initially unselected check box menu item with an icon.
Parameters
iconthe icon of the CheckBoxMenuItem.
Creates an initially unselected check box menu item with text.
Parameters
textthe text of the CheckBoxMenuItem
Creates a menu item whose properties are taken from the Action supplied.
@since
1.3
Creates an initially unselected check box menu item with the specified text and icon.
Parameters
textthe text of the CheckBoxMenuItem
iconthe icon of the CheckBoxMenuItem
Creates a check box menu item with the specified text and selection state.
Parameters
textthe text of the check box menu item.
bthe selected state of the check box menu item
Creates a check box menu item with the specified text, icon, and selection state.
Parameters
textthe text of the check box menu item
iconthe icon of the check box menu item
bthe selected state of the check box menu item
Identifies a change to having the border drawn, or having it not drawn.
Box-orientation constant used to specify the bottom of a box.
Ease-of-use constant for getAlignmentY. Specifies an alignment to the bottom of the component.
The central position in an area. Used for both compass-direction constants (NORTH, etc.) and box-orientation constants (TOP, etc.).
Ease-of-use constant for getAlignmentY and getAlignmentX. Specifies an alignment to the center of the component
Identifies a change to having the button paint the content area.
Identifies a change to the icon used when the button has been disabled.
Identifies a change to the icon used when the button has been disabled and selected.
Compass-direction east (right).
Identifies a change to having the border highlighted when focused, or not.
Horizontal orientation. Used for scrollbars and sliders.
Identifies a change in the button's horizontal alignment.
Identifies a change in the button's horizontal text position.
Identifies a change to the icon that represents the button.
Identifies the leading edge of text for use with left-to-right and right-to-left languages. Used by buttons and labels.
Box-orientation constant used to specify the left side of a box.
Ease-of-use constant for getAlignmentX. Specifies an alignment to the left side of the component.
Identifies a change in the button's margins.
Identifies a change to the button's mnemonic.
Identifies a change in the button model.
Identifies the next direction in a sequence.
@since
1.4
Compass-direction North (up).
Compass-direction north-east (upper right).
Compass-direction north west (upper left).
Identifies a change to the icon used when the button has been pressed.
Identifies the previous direction in a sequence.
@since
1.4
Box-orientation constant used to specify the right side of a box.
Ease-of-use constant for getAlignmentX. Specifies an alignment to the right side of the component.
Identifies a change from rollover enabled to disabled or back to enabled.
Identifies a change to the icon used when the cursor is over the button.
Identifies a change to the icon used when the cursor is over the button and it has been selected.
Identifies a change to the icon used when the button has been selected.
Compass-direction south (down).
Compass-direction south-east (lower right).
Compass-direction south-west (lower left).
Identifies a change in the button's text.
The comment to display when the cursor is over the component, also known as a "value tip", "flyover help", or "flyover label".
Box-orientation constant used to specify the top of a box.
Ease-of-use constant for getAlignmentY(). Specifies an alignment to the top of the component.
Identifies the trailing edge of text for use with left-to-right and right-to-left languages. Used by buttons and labels.
Constant used by some of the APIs to mean that no condition is defined.
Vertical orientation. Used for scrollbars and sliders.
Identifies a change in the button's vertical alignment.
Identifies a change in the button's vertical text position.
Compass-direction west (left).
Constant used for registerKeyboardAction that means that the command should be invoked when the receiving component is an ancestor of the focused component or is itself the focused component.
Constant used for registerKeyboardAction that means that the command should be invoked when the component has the focus.
Constant used for registerKeyboardAction that 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.
@deprecated
As of JDK version 1.1, should register this component as ActionListener on component which fires action events.
Appends the specified component to the end of this container. This is a convenience method for #addImpl .

Note: If a component has been added to a container that has been displayed, validate must be called on that container to display the new component. If multiple components are being added, you can improve efficiency by calling validate only once, after all the components have been added.

Parameters
compthe component to be added
Return
the component argument
Adds the specified component to this container at the given position. This is a convenience method for #addImpl .

Note: If a component has been added to a container that has been displayed, validate must be called on that container to display the new component. If multiple components are being added, you can improve efficiency by calling validate only once, after all the components have been added.

Parameters
compthe component to be added
indexthe position at which to insert the component, or -1 to append the component to the end
Return
the component comp
Adds the specified component to the end of this container. Also notifies the layout manager to add the component to this container's layout using the specified constraints object. This is a convenience method for #addImpl .

Note: If a component has been added to a container that has been displayed, validate must be called on that container to display the new component. If multiple components are being added, you can improve efficiency by calling validate only once, after all the components have been added.

Parameters
compthe component to be added
constraintsan object expressing layout contraints for this component
@since
JDK1.1
Adds the specified component to this container with the specified constraints at the specified index. Also notifies the layout manager to add the component to the this container's layout using the specified constraints object. This is a convenience method for #addImpl .

Note: If a component has been added to a container that has been displayed, validate must be called on that container to display the new component. If multiple components are being added, you can improve efficiency by calling validate only once, after all the components have been added.

Parameters
compthe component to be added
constraintsan object expressing layout contraints for this
indexthe position in the container's list at which to insert the component; -1 means insert at the end component
Adds the specified popup menu to the component.
Parameters
popupthe popup menu to be added to the component.
@since
JDK1.1
Adds the specified component to this container. This is a convenience method for #addImpl .

This method is obsolete as of 1.1. Please use the method add(Component, Object) instead.

Adds an ActionListener to the button.
Parameters
lthe ActionListener to be added
Registers listener so that it will receive AncestorEvents when it or any of its ancestors move or are made visible or invisible. Events are also sent when the component or its ancestors are added or removed from the containment hierarchy.
Parameters
listenerthe AncestorListener to register
See Also
Adds a ChangeListener to the button.
Parameters
lthe listener to be added
Adds the specified component listener to receive component events from this component. If listener l is null, no exception is thrown and no action is performed.
Adds the specified container listener to receive container events from this container. If l is null, no exception is thrown and no action is performed.
Parameters
lthe container listener
Adds the specified focus listener to receive focus events from this component when this component gains input focus. If listener l is null, no exception is thrown and no action is performed.
Parameters
lthe focus listener
@since
JDK1.1
Adds the specified hierarchy bounds listener to receive hierarchy bounds events from this component when the hierarchy to which this container belongs changes. If listener l is null, no exception is thrown and no action is performed.
Adds the specified hierarchy listener to receive hierarchy changed events from this component when the hierarchy to which this container belongs changes. If listener l is null, no exception is thrown and no action is performed.
Adds the specified input method listener to receive input method events from this component. A component will only receive input method events from input methods if it also overrides getInputMethodRequests to return an InputMethodRequests instance. If listener l is null, no exception is thrown and no action is performed.
Adds an ItemListener to the checkbox.
Parameters
lthe ItemListener to be added
Adds the specified key listener to receive key events from this component. If l is null, no exception is thrown and no action is performed.
Parameters
lthe key listener.
@since
JDK1.1
Adds a MenuDragMouseListener to the menu item.
Parameters
lthe MenuDragMouseListener to be added
Adds a MenuKeyListener to the menu item.
Parameters
lthe MenuKeyListener to be added
Adds the specified mouse listener to receive mouse events from this component. If listener l is null, no exception is thrown and no action is performed.
Parameters
lthe mouse listener
@since
JDK1.1
Adds the specified mouse motion listener to receive mouse motion events from this component. If listener l is null, no exception is thrown and no action is performed.
Adds the specified mouse wheel listener to receive mouse wheel events from this component. Containers also receive mouse wheel events from sub-components.

For information on how mouse wheel events are dispatched, see the class description for MouseWheelEvent .

If l is null, no exception is thrown and no action is performed.

Notifies 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.
Adds a PropertyChangeListener to the listener list. The listener is registered for all bound properties of this class, including the following:
  • this Container's font ("font")
  • this Container's background color ("background")
  • this Container's foreground color ("foreground")
  • this Container's focusability ("focusable")
  • this Container's focus traversal keys enabled state ("focusTraversalKeysEnabled")
  • this Container's Set of FORWARD_TRAVERSAL_KEYS ("forwardFocusTraversalKeys")
  • this Container's Set of BACKWARD_TRAVERSAL_KEYS ("backwardFocusTraversalKeys")
  • this Container's Set of UP_CYCLE_TRAVERSAL_KEYS ("upCycleFocusTraversalKeys")
  • this Container's Set of DOWN_CYCLE_TRAVERSAL_KEYS ("downCycleFocusTraversalKeys")
  • this Container's focus traversal policy ("focusTraversalPolicy")
  • this Container's focus-cycle-root state ("focusCycleRoot")
Note that if this Container is inheriting a bound property, then no event will be fired in response to a change in the inherited property.

If listener is null, no exception is thrown and no action is performed.

Adds a PropertyChangeListener to the listener list for a specific property. The specified property may be user-defined, or one of the following defaults:
  • this Container's font ("font")
  • this Container's background color ("background")
  • this Container's foreground color ("foreground")
  • this Container's focusability ("focusable")
  • this Container's focus traversal keys enabled state ("focusTraversalKeysEnabled")
  • this Container's Set of FORWARD_TRAVERSAL_KEYS ("forwardFocusTraversalKeys")
  • this Container's Set of BACKWARD_TRAVERSAL_KEYS ("backwardFocusTraversalKeys")
  • this Container's Set of UP_CYCLE_TRAVERSAL_KEYS ("upCycleFocusTraversalKeys")
  • this Container's Set of DOWN_CYCLE_TRAVERSAL_KEYS ("downCycleFocusTraversalKeys")
  • this Container's focus traversal policy ("focusTraversalPolicy")
  • this Container's focus-cycle-root state ("focusCycleRoot")
  • this Container's focus-traversal-policy-provider state("focusTraversalPolicyProvider")
  • this Container's focus-traversal-policy-provider state("focusTraversalPolicyProvider")
Note that if this Container is inheriting a bound property, then no event will be fired in response to a change in the inherited property.

If listener is null, no exception is thrown and no action is performed.

Parameters
propertyNameone of the property names listed above
listenerthe PropertyChangeListener to be added
Adds a VetoableChangeListener to the listener list. The listener is registered for all properties.
Parameters
listenerthe VetoableChangeListener to be added
Sets the ComponentOrientation property of this container and all components contained within it.
Parameters
othe new component orientation of this container and the components contained within it.
Throws
NullPointerExceptionif orientation is null.
@since
1.4
Returns whether the Set of focus traversal keys for the given focus traversal operation has been explicitly defined for this Container. If this method returns false, this Container is inheriting the Set from an ancestor, or from the current KeyboardFocusManager.
Parameters
idone of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
Return
true if the the Set of focus traversal keys for the given focus traversal operation has been explicitly defined for this Component; false otherwise.
Throws
IllegalArgumentExceptionif id is not one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
@since
1.4
@deprecated
As of JDK version 1.1, replaced by getBounds().
Returns the status of the construction of a screen representation of the specified image.

This method does not cause the image to begin loading. An application must use the prepareImage method to force the loading of an image.

Information on the flags returned by this method can be found with the discussion of the ImageObserver interface.

Parameters
imagethe Image object whose status is being checked
observerthe ImageObserver object to be notified as the image is being prepared
Return
the bitwise inclusive OR of ImageObserver flags indicating what information about the image is currently available
@since
JDK1.0
Returns the status of the construction of a screen representation of the specified image.

This method does not cause the image to begin loading. An application must use the prepareImage method to force the loading of an image.

The checkImage method of Component calls its peer's checkImage method to calculate the flags. If this component does not yet have a peer, the component's toolkit's checkImage method is called instead.

Information on the flags returned by this method can be found with the discussion of the ImageObserver interface.

Parameters
imagethe Image object whose status is being checked
widththe width of the scaled version whose status is to be checked
heightthe height of the scaled version whose status is to be checked
observerthe ImageObserver object to be notified as the image is being prepared
Return
the bitwise inclusive OR of ImageObserver flags indicating what information about the image is currently available
@since
JDK1.0
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.
Parameters
visibleRecta Rectangle computed as the intersection of all visible rectangles for this component and all of its ancestors -- this is the return value for this method
Gives 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
Checks whether this component "contains" the specified point, where the point's x and y coordinates are defined to be relative to the coordinate system of this component.
Parameters
pthe point
@since
JDK1.1
@deprecated
As of JDK version 1.1, replaced by getComponentCount().
Creates an image from the specified image producer.
Parameters
producerthe image producer
Return
the image produced
@since
JDK1.0
Creates an off-screen drawable image to be used for double buffering.
Parameters
widththe specified width
heightthe specified height
Return
an off-screen drawable image, which can be used for double buffering. The return value may be null if the component is not displayable. This will always happen if GraphicsEnvironment.isHeadless() returns true.
@since
JDK1.0
Returns the instance of JToolTip that should be used to display the tooltip. Components typically would not override this method, but it can be used to cause different tooltips to be displayed differently.
Return
the JToolTip used to display this toolTip
Creates a volatile off-screen drawable image to be used for double buffering.
Parameters
widththe specified width.
heightthe specified height.
Return
an off-screen drawable image, which can be used for double buffering. The return value may be null if the component is not displayable. This will always happen if GraphicsEnvironment.isHeadless() returns true.
@since
1.4
Creates a volatile off-screen drawable image, with the given capabilities. The contents of this image may be lost at any time due to operating system issues, so the image must be managed via the VolatileImage interface.
Parameters
widththe specified width.
heightthe specified height.
capsthe image capabilities
Return
a VolatileImage object, which can be used to manage surface contents loss and capabilities.
Throws
AWTExceptionif an image with the specified capabilities cannot be created
@since
1.4
@deprecated
As of JDK version 1.1, replaced by dispatchEvent(AWTEvent e)
@deprecated
As of JDK version 1.1, replaced by java.awt.Component.setEnabled(boolean).
Dispatches an event to this component or one of its sub components. Calls processEvent before returning for 1.1-style events which have been enabled for the Component.
Parameters
ethe event
Programmatically perform a "click". This does the same thing as if the user had pressed and released the button.
Programmatically perform a "click". This does the same thing as if the user had pressed and released the button. The button stays visually "pressed" for pressTime milliseconds.
Parameters
pressTimethe time to "hold down" the button, in milliseconds
Causes this container to lay out its components. Most programs should not call this method directly, but should invoke the validate method instead.
@deprecated
As of JDK version 1.1, replaced by java.awt.Component.setEnabled(boolean).
@deprecated
As of JDK version 1.1, replaced by setEnabled(boolean).
Enables or disables input method support for this component. If input method support is enabled and the component also processes key events, incoming events are offered to the current input method and will only be processed by the component or dispatched to its listeners if the input method does not consume them. By default, input method support is enabled.
Parameters
enabletrue to enable, false to disable
@since
1.2
Indicates whether some other object is "equal to" this one.

The equals method implements an equivalence relation on non-null object references:

  • It is reflexive: for any non-null reference value x, x.equals(x) should return true.
  • It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
  • It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
  • It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
  • For any non-null reference value x, x.equals(null) should return false.

The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.

Parameters
objthe reference object with which to compare.
Return
true if this object is the same as the obj argument; false otherwise.
Locates the visible child component that contains the specified position. The top-most child component is returned in the case where there is overlap in the components. If the containing child component is a Container, this method will continue searching for the deepest nested child component. Components which are not visible are ignored during the search.

The findComponentAt method is different from getComponentAt in that getComponentAt only searches the Container's immediate children; if the containing component is a Container, findComponentAt will search that child to find a nested component.

Parameters
xthe x coordinate
ythe y coordinate
Return
null if the component does not contain the position. If there is no child component at the requested point and the point is within the bounds of the container the container itself is returned.
@since
1.2
Locates the visible child component that contains the specified point. The top-most child component is returned in the case where there is overlap in the components. If the containing child component is a Container, this method will continue searching for the deepest nested child component. Components which are not visible are ignored during the search.

The findComponentAt method is different from getComponentAt in that getComponentAt only searches the Container's immediate children; if the containing component is a Container, findComponentAt will search that child to find a nested component.

Parameters
pthe point.
Return
null if the component does not contain the position. If there is no child component at the requested point and the point is within the bounds of the container the container itself is returned.
@since
1.2
Support for reporting bound property changes for boolean properties. This method can be called when a bound property has changed and it will send the appropriate PropertyChangeEvent to any registered PropertyChangeListeners.
Parameters
propertyNamethe property whose value has changed
oldValuethe property's previous value
newValuethe property's new value
Reports a bound property change.
Parameters
propertyNamethe programmatic name of the property that was changed
oldValuethe old value of the property (as a byte)
newValuethe new value of the property (as a byte)
@since
1.5
Reports a bound property change.
Parameters
propertyNamethe programmatic name of the property that was changed
oldValuethe old value of the property (as a double)
newValuethe new value of the property (as a double)
@since
1.5
Reports a bound property change.
Parameters
propertyNamethe programmatic name of the property that was changed
oldValuethe old value of the property (as a float)
newValuethe new value of the property (as a float)
@since
1.5
Support for reporting bound property changes for integer properties. This method can be called when a bound property has changed and it will send the appropriate PropertyChangeEvent to any registered PropertyChangeListeners.
Parameters
propertyNamethe property whose value has changed
oldValuethe property's previous value
newValuethe property's new value
Reports a bound property change.
Parameters
propertyNamethe programmatic name of the property that was changed
oldValuethe old value of the property (as a long)
newValuethe new value of the property (as a long)
@since
1.5
Reports a bound property change.
Parameters
propertyNamethe programmatic name of the property that was changed
oldValuethe old value of the property (as a short)
newValuethe old value of the property (as a short)
@since
1.5
Returns the KeyStroke which serves as an accelerator for the menu item.
Return
a KeyStroke object identifying the accelerator key
Gets the AccessibleContext associated with this JCheckBoxMenuItem. 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 AccessibleJCheckBoxMenuItem
Returns the currently set Action for this ActionEvent source, or null if no Action is set.
Return
the Action for this ActionEvent source, or null
@since
1.3
See Also
Returns the action command for this button.
Return
the action command for this button
Returns the object that will perform the action registered for a given keystroke.
Return
the ActionListener object invoked when the keystroke occurs
Returns an array of all the ActionListeners added to this AbstractButton with addActionListener().
Return
all of the ActionListeners added or an empty array if no listeners have been added
@since
1.4
Returns the ActionMap used to determine what Action to fire for particular KeyStroke binding. The returned ActionMap, unless otherwise set, will have the ActionMap from the UI set as the parent.
Return
the ActionMap containing the key/action bindings
@since
1.3
Overrides Container.getAlignmentX to return the vertical alignment.
Return
the value of the alignmentX property
Overrides Container.getAlignmentY to return the horizontal alignment.
Return
the value of the alignmentY property
Returns an array of all the ancestor listeners registered on this component.
Return
all of the component's AncestorListeners or an empty array if no ancestor listeners are currently registered
@since
1.4
Gets the autoscrolls property.
Return
the value of the autoscrolls property
Gets the background color of this component.
Return
this component's background color; if this component does not have a background color, the background color of its parent is returned
@since
JDK1.0
Returns the border of this component or null if no border is currently set.
Return
the border object for this component
See Also
Gets the bounds of this component in the form of a Rectangle object. The bounds specify this component's width, height, and location relative to its parent.
Return
a rectangle indicating this component's bounds
Stores the bounds of this component into "return value" rv and returns 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.
Parameters
rvthe return value, modified to the component's bounds
Return
rv; if rv is null return a newly created Rectangle with this component's bounds
Returns an array of all the ChangeListeners added to this AbstractButton with addChangeListener().
Return
all of the ChangeListeners added or an empty array if no listeners have been added
@since
1.4
Returns the runtime class of an object. That Class object is the object that is locked by static synchronized methods of the represented class.
Return
The java.lang.Class object that represents the runtime class of the object. The result is of type {@code Class} where X is the erasure of the static type of the expression on which getClass is called.
Returns the value of the property with the specified key. Only properties added with putClientProperty will return a non-null value.
Parameters
keythe being queried
Return
the value of this property or null
Gets the instance of ColorModel used to display the component on the output device.
Return
the color model used by this component
@since
JDK1.0
Returns the java.awt.Component used to paint this object. The returned component will be used to convert events and detect if an event is inside a menu component.
Return
the Component that paints this menu item
Gets the nth component in this container.
Parameters
nthe index of the component to get.
Return
the nth component in this container.
Throws
ArrayIndexOutOfBoundsExceptionif the nth value does not exist.
Locates the component that contains the x,y position. The top-most child component is returned in the case where there is overlap in the components. This is determined by finding the component closest to the index 0 that claims to contain the given point via Component.contains(), except that Components which have native peers take precedence over those which do not (i.e., lightweight Components).
Parameters
xthe x coordinate
ythe y coordinate
Return
null if the component does not contain the position. If there is no child component at the requested point and the point is within the bounds of the container the container itself is returned; otherwise the top-most child is returned.
@since
JDK1.1
Gets the component that contains the specified point.
Parameters
pthe point.
Return
returns the component that contains the point, or null if the component does not contain the point.
@since
JDK1.1
Gets the number of components in this panel.
Return
the number of components in this panel.
@since
JDK1.1
See Also
Returns an array of all the component listeners registered on this component.
Return
all of this comonent's ComponentListeners or an empty array if no component listeners are currently registered
@since
1.4
Retrieves the language-sensitive orientation that is to be used to order the elements or text within this component. LayoutManager and Component subclasses that wish to respect orientation should call this method to get the component's orientation before performing layout or drawing.
@author
Laura Werner, IBM
Returns JPopupMenu that assigned for this component. If this component does not have a JPopupMenu assigned to it and getInheritsPopupMenu is true, this will return getParent().getComponentPopupMenu() (assuming the parent is valid.)
Return
JPopupMenu assigned for this component or null if no popup assigned
@since
1.5
Gets all the components in this container.
Return
an array of all the components in this container.
Returns the z-order index of the component inside the container. The higher a component is in the z-order hierarchy, the lower its index. The component with the lowest z-order index is painted last, above all other child components.
Parameters
compthe component being queried
Return
the z-order index of the component; otherwise returns -1 if the component is null
@since
1.5
Returns 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
Returns an array of all the container listeners registered on this container.
Return
all of this container's ContainerListeners or an empty array if no container listeners are currently registered
@since
1.4
Gets the cursor set in the component. If the component does not have a cursor set, the cursor of its parent is returned. If no cursor is set in the entire hierarchy, Cursor.DEFAULT_CURSOR is returned.
@since
JDK1.1
See Also
Returns the state of graphics debugging.
Return
a bitwise OR'd flag of zero or more of the following options:
  • 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.
  • DebugGraphics.NONE_OPTION disables debugging.
  • A value of 0 causes no changes to the debugging options.
Returns the default locale used to initialize each JComponent's locale property upon creation. The default locale has "AppContext" scope so that applets (and potentially multiple lightweight applications running in a single VM) can have their own setting. An applet can safely alter its default locale because it will have no affect on other applets (or the browser).
Return
the default Locale.
@since
1.4
Returns the icon used by the button when it's disabled. If no disabled icon has been set this will forward the call to the look and feel to construct an appropriate disabled Icon.

Some look and feels might not render the disabled Icon, in which case they will ignore this.

Return
the disabledIcon property
Returns the icon used by the button when it's disabled and selected. If no disabled selection icon has been set, this will forward the call to the LookAndFeel to construct an appropriate disabled Icon from the selection icon if it has been set and to getDisabledIcon() otherwise.

Some look and feels might not render the disabled selected Icon, in which case they will ignore this.

Returns the character, as an index, that the look and feel should provide decoration for as representing the mnemonic character.
Return
index representing mnemonic character
@since
1.4
Gets the DropTarget associated with this Component.
Returns the Container which is the focus cycle root of this Component's focus traversal cycle. Each focus traversal cycle has only a single focus cycle root and each Component which is not a Container belongs to only a single focus traversal cycle. Containers which are focus cycle roots belong to two cycles: one rooted at the Container itself, and one rooted at the Container's nearest focus-cycle-root ancestor. For such Containers, this method will return the Container's nearest focus-cycle- root ancestor.
Return
this Component's nearest focus-cycle-root ancestor
@since
1.4
Returns an array of all the focus listeners registered on this component.
Return
all of this component's FocusListeners or an empty array if no component listeners are currently registered
@since
1.4
Returns the Set of focus traversal keys for a given traversal operation for this Container. (See setFocusTraversalKeys for a full description of each key.)

If a Set of traversal keys has not been explicitly defined for this Container, then this Container's parent's Set is returned. If no Set has been explicitly defined for any of this Container's ancestors, then the current KeyboardFocusManager's default Set is returned.

Parameters
idone of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
Return
the Set of AWTKeyStrokes for the specified operation. The Set will be unmodifiable, and may be empty. null will never be returned.
Throws
IllegalArgumentExceptionif id is not one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
@since
1.4
Returns whether focus traversal keys are enabled for this Component. Components for which focus traversal keys are disabled receive key events for focus traversal keys. Components for which focus traversal keys are enabled do not see these events; instead, the events are automatically converted to traversal operations.
Return
whether focus traversal keys are enabled for this Component
@since
1.4
Returns the focus traversal policy that will manage keyboard traversal of this Container's children, or null if this Container is not a focus cycle root. If no traversal policy has been explicitly set for this Container, then this Container's focus-cycle-root ancestor's policy is returned.
Return
this Container's focus traversal policy, or null if this Container is not a focus cycle root.
@since
1.4
Gets the font of this component.
Return
this component's font; if a font has not been set for this component, the font of its parent is returned
@since
JDK1.0
See Also
Gets the FontMetrics for the specified Font.
Parameters
fontthe font for which font metrics is to be obtained
Return
the font metrics for font
Throws
NullPointerExceptionif font is null
@since
1.5
Gets the foreground color of this component.
Return
this component's foreground color; if this component does not have a foreground color, the foreground color of its parent is returned
@since
JDK1.0
@beaninfo
bound: true
Returns this component's graphics context, which lets you draw on a component. Use this method get a Graphics object and then invoke operations on that object to draw on the component.
Return
this components graphics context
Gets the GraphicsConfiguration associated with this Component. If the Component has not been assigned a specific GraphicsConfiguration, the GraphicsConfiguration of the Component object's top-level container is returned. If the Component has been created, but not yet added to a Container, this method returns null.
Return
the GraphicsConfiguration used by this Component or null
@since
1.3
Returns 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.
Return
the current height of this component
Returns an array of all the hierarchy bounds listeners registered on this component.
Return
all of this component's HierarchyBoundsListeners or an empty array if no hierarchy bounds listeners are currently registered
@since
1.4
Returns an array of all the hierarchy listeners registered on this component.
Return
all of this component's HierarchyListeners or an empty array if no hierarchy listeners are currently registered
@since
1.4
Returns the horizontal alignment of the icon and text.
Return
the horizontalAlignment property, one of the following values:
  • SwingConstants.RIGHT (the default)
  • SwingConstants.LEFT
  • SwingConstants.CENTER
  • SwingConstants.LEADING
  • SwingConstants.TRAILING
Returns the horizontal position of the text relative to the icon.
Return
the horizontalTextPosition property, one of the following values:
  • SwingConstants.RIGHT
  • SwingConstants.LEFT
  • SwingConstants.CENTER
  • SwingConstants.LEADING
  • SwingConstants.TRAILING (the default)
Returns the default icon.
Return
the default Icon
See Also
Returns the amount of space between the text and the icon displayed in this button.
Return
an int equal to the number of pixels between the text and the icon.
@since
1.4
Return
whether or not paint messages received from the operating system should be ignored.
@since
1.4
Returns true if the JPopupMenu should be inherited from the parent.
@since
1.5
Gets the input context used by this component for handling the communication with input methods when text is entered in this component. By default, the input context used for the parent component is returned. Components may override this to return a private input context.
Return
the input context used by this component; null if no context can be determined
@since
1.2
Returns the InputMap that is used when the component has focus. This is convenience method for getInputMap(WHEN_FOCUSED).
Return
the InputMap used when the component has focus
@since
JDK1.3
Returns the InputMap that is used during condition.
Parameters
conditionone of WHEN_IN_FOCUSED_WINDOW, WHEN_FOCUSED, WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
Return
the InputMap for the specified condition
@since
1.3
Returns an array of all the input method listeners registered on this component.
Return
all of this component's InputMethodListeners or an empty array if no input method listeners are currently registered
@since
1.4
Gets the input method request handler which supports requests from input methods for this component. A component that supports on-the-spot text input must override this method to return an InputMethodRequests instance. At the same time, it also has to handle input method events.
Return
the input method request handler for this component, null by default
@since
1.2
Returns the input verifier for this component.
Return
the inputVerifier property
@since
1.3
See Also
If a border has been set on this component, returns the border's insets; otherwise calls super.getInsets.
Return
the value of the insets property
See Also
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. If insets is null, this will allocate a new one.
Parameters
insetsthe Insets object, which can be reused
Return
the Insets object
@beaninfo
expert: true
See Also
Returns an array of all the ItemListeners added to this AbstractButton with addItemListener().
Return
all of the ItemListeners added or an empty array if no listeners have been added
@since
1.4
Returns an array of all the key listeners registered on this component.
Return
all of this component's KeyListeners or an empty array if no key listeners are currently registered
@since
1.4
Returns the label text.
Return
a String containing the label
@deprecated
- Replaced by getText
Gets the layout manager for this container.
Returns an array of all the objects currently registered as FooListeners upon this JComponent. FooListeners are registered using the addFooListener method.

You can specify the listenerType argument with a class literal, such as FooListener.class. For example, you can query a JComponent c for its mouse listeners with the following code:

MouseListener[] mls = (MouseListener[])(c.getListeners(MouseListener.class));
If no such listeners exist, this method returns an empty array.
Parameters
listenerTypethe type of listeners requested; this parameter should specify an interface that descends from java.util.EventListener
Return
an array of all objects registered as FooListeners on this component, or an empty array if no such listeners have been added
Throws
ClassCastExceptionif listenerType doesn't specify a class or interface that implements java.util.EventListener
@since
1.3
Gets the locale of this component.
Return
this component's locale; if this component does not have a locale, the locale of its parent is returned
Throws
IllegalComponentStateExceptionif the Component does not have its own locale and has not yet been added to a containment hierarchy such that the locale can be determined from the containing parent
@since
JDK1.1
See Also
Gets the location of this component in the form of a point specifying the component's top-left corner. The location will be relative to the parent's coordinate space.

Due to the asynchronous nature of native event handling, this method can return outdated values (for instance, after several calls of setLocation() in rapid succession). For this reason, the recommended method of obtaining a component's position is within java.awt.event.ComponentListener.componentMoved(), which is called after the operating system has finished moving the component.

Return
an instance of Point representing the top-left corner of the component's bounds in the coordinate space of the component's parent
@since
JDK1.1
Stores the x,y origin of this component into "return value" rv and returns 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.
Parameters
rvthe return value, modified to the component's location
Return
rv
Gets the location of this component in the form of a point specifying the component's top-left corner in the screen's coordinate space.
Return
an instance of Point representing the top-left corner of the component's bounds in the coordinate space of the screen
Throws
IllegalComponentStateExceptionif the component is not showing on the screen
Returns the margin between the button's border and the label.
Return
an Insets object specifying the margin between the botton's border and the label
See Also
If the maximum size has been set to a non-null value just returns it. If the UI delegate's getMaximumSize method returns a non-null value then return that; otherwise defer to the component's layout manager.
Return
the value of the maximumSize property
Returns an array of all the MenuDragMouseListeners added to this JMenuItem with addMenuDragMouseListener().
Return
all of the MenuDragMouseListeners added or an empty array if no listeners have been added
@since
1.4
Returns an array of all the MenuKeyListeners added to this JMenuItem with addMenuKeyListener().
Return
all of the MenuKeyListeners added or an empty array if no listeners have been added
@since
1.4
If the minimum size has been set to a non-null value just returns it. If the UI delegate's getMinimumSize method returns a non-null value then return that; otherwise defer to the component's layout manager.
Return
the value of the minimumSize property
Returns the keyboard mnemonic from the the current model.
Return
the keyboard mnemonic from the model
Returns the model that this button represents.
Return
the model property
See Also
Returns an array of all the mouse listeners registered on this component.
Return
all of this component's MouseListeners or an empty array if no mouse listeners are currently registered
@since
1.4
Returns an array of all the mouse motion listeners registered on this component.
Return
all of this component's MouseMotionListeners or an empty array if no mouse motion listeners are currently registered
@since
1.4
Returns the position of the mouse pointer in this Component's coordinate space if the Component is directly under the mouse pointer, otherwise returns null. If the Component is not showing on the screen, this method returns null even if the mouse pointer is above the area where the Component would be displayed. If the Component is partially or fully obscured by other Components or native windows, this method returns a non-null value only if the mouse pointer is located above the unobscured part of the Component.

For Containers it returns a non-null value if the mouse is above the Container itself or above any of its descendants. Use if you need to exclude children.

Sometimes the exact mouse coordinates are not important, and the only thing that matters is whether a specific Component is under the mouse pointer. If the return value of this method is null, mouse pointer is not directly above the Component.

Return
mouse coordinates relative to this Component, or null
Throws
HeadlessExceptionif GraphicsEnvironment.isHeadless() returns true
@since
1.5
Returns the position of the mouse pointer in this Container's coordinate space if the Container is under the mouse pointer, otherwise returns null. This method is similar to with the exception that it can take the Container's children into account. If allowChildren is false, this method will return a non-null value only if the mouse pointer is above the Container directly, not above the part obscured by children. If allowChildren is true, this method returns a non-null value if the mouse pointer is above Container or any of its descendants.
Parameters
allowChildrentrue if children should be taken into account
Return
mouse coordinates relative to this Component, or null
Throws
HeadlessExceptionif GraphicsEnvironment.isHeadless() returns true
@since
1.5
Returns an array of all the mouse wheel listeners registered on this component.
Return
all of this component's MouseWheelListeners or an empty array if no mouse wheel listeners are currently registered
@since
1.4
Gets the amount of time (in milliseconds) required between mouse press events for the button to generate the corresponding action events.
Return
the amount of time required between mouse press events to generate corresponding action events
@since
1.4
Gets the name of the component.
Return
this component's name
@since
JDK1.1
See Also
In release 1.4, the focus subsystem was rearchitected. For more information, see How to Use the Focus Subsystem, a section in The Java Tutorial.

Returns the Component set by a prior call to setNextFocusableComponent(Component) on this JComponent.

Return
the Component that will follow this JComponent in the focus traversal cycle, or null if none has been explicitly specified
@deprecated
As of 1.4, replaced by FocusTraversalPolicy.
Gets the parent of this component.
Return
the parent container of this component
@since
JDK1.0
@deprecated
As of JDK version 1.1, programs should not directly manipulate peers; replaced by boolean isDisplayable().
Returns the preferred location to display the popup menu in this component's coordinate system. It is up to the look and feel to honor this propery, some may choose to ignore it. If null is truend the look and feel will choose a suitable location.
Parameters
eventthe MouseEvent that triggered the popup to be shown, or null if popup was is not being shown as the result of a mouse event
Return
Locatino to display the JPopupMenu.
@since
1.5
If the preferredSize has been set to a non-null value just returns it. If the UI delegate's getPreferredSize method returns a non null value then return that; otherwise defer to the component's layout manager.
Return
the value of the preferredSize property
Returns the pressed icon for the button.
Return
the pressedIcon property
Returns an array of all the property change listeners registered on this component.
Return
all of this component's PropertyChangeListeners or an empty array if no property change listeners are currently registered
@since
1.4
Returns an array of all the listeners which have been associated with the named property.
Return
all of the PropertyChangeListeners associated with the named property; if no such listeners have been added or if propertyName is null, an empty array is returned
@since
1.4
Returns the KeyStrokes that will initiate registered actions.
Return
an array of KeyStroke objects
Returns the rollover icon for the button.
Return
the rolloverIcon property
Returns the rollover selection icon for the button.
Return
the rolloverSelectedIcon property
Returns the JRootPane ancestor for this component.
Return
the JRootPane that contains this component, or null if no JRootPane is found
Returns the selected icon for the button.
Return
the selectedIcon property
Returns an array (length 1) containing the check box menu item label or null if the check box is not selected.
Return
an array containing one Object -- the text of the menu item -- if the item is selected; otherwise null
Returns the size of this component in the form of a Dimension object. The height field of the Dimension object contains this component's height, and the width field of the Dimension object contains this component's width.
Return
a Dimension object that indicates the size of this component
@since
JDK1.1
See Also
Stores the width/height of this component into "return value" rv and returns 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.
Parameters
rvthe return value, modified to the component's size
Return
rv
Returns the selected-state of the item. This method exists for AWT compatibility only. New code should use isSelected() instead.
Return
true if the item is selected
This method returns an array containing the sub-menu components for this menu component.
Return
an array of MenuElements
Returns the button's text.
Return
the buttons text
See Also
Gets the toolkit of this component. Note that the frame that contains a component controls which toolkit is used by that component. Therefore if the component is moved from one frame to another, the toolkit it uses may change.
Return
the toolkit of this component
@since
JDK1.0
Returns the tooltip location in this component's coordinate system. If null is returned, Swing will choose a location. The default implementation returns null.
Parameters
eventthe MouseEvent that caused the ToolTipManager to show the tooltip
Return
always returns null
Returns the tooltip string that has been set with setToolTipText.
Return
the text of the tool tip
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 extensive 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 that this component is in, or null if not in any container
Gets the transferHandler property.
Return
the value of the transferHandler property
@since
1.4
Gets this component's locking object (the object that owns the thread sychronization monitor) for AWT component-tree and layout operations.
Return
this component's locking object
Returns the L&F object that renders this component.
Return
the ButtonUI object
See Also
Returns the name of the L&F class that renders this component.
Return
"CheckBoxMenuItemUI"
Returns the value that indicates whether the input verifier for the current focus owner will be called before this component requests focus.
Return
value of the verifyInputWhenFocusTarget property
@since
1.3
Returns the vertical alignment of the text and icon.
Return
the verticalAlignment property, one of the following values:
  • SwingConstants.CENTER (the default)
  • SwingConstants.TOP
  • SwingConstants.BOTTOM
Returns the vertical position of the text relative to the icon.
Return
the verticalTextPosition property, one of the following values:
  • SwingConstants.CENTER (the default)
  • SwingConstants.TOP
  • SwingConstants.BOTTOM
Returns an array of all the vetoable change listeners registered on this component.
Return
all of the component's VetoableChangeListeners or an empty array if no vetoable change listeners are currently registered
@since
1.4
Returns the Component's "visible rectangle" - the intersection of this component's visible rectangle, new Rectangle(0, 0, getWidth(), getHeight()), and all of its ancestors' visible rectangles.
Return
the visible rectangle
Returns 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.
Return
the current width of this component
Returns the current x coordinate of the component's origin. This method is preferable to writing component.getBounds().x, or component.getLocation().x because it doesn't cause any heap allocations.
Return
the current x coordinate of the component's origin
Returns the current y coordinate of the component's origin. This method is preferable to writing component.getBounds().y, or component.getLocation().y because it doesn't cause any heap allocations.
Return
the current y coordinate of the component's origin
@deprecated
As of JDK version 1.1, replaced by processFocusEvent(FocusEvent).
Requests that this Component get the input focus, and that this Component's top-level ancestor become the focused Window. This component must be displayable, visible, and focusable for the request to be granted.

This method is intended for use by focus implementations. Client code should not use this method; instead, it should use requestFocusInWindow().

@deprecated
As of JDK version 1.1 replaced by processEvent(AWTEvent).
Returns true if this Component is the focus owner. This method is obsolete, and has been replaced by isFocusOwner().
Return
true if this Component is the focus owner; false otherwise
@since
1.2
Returns a hash code value for the object. This method is supported for the benefit of hashtables such as those provided by java.util.Hashtable.

The general contract of hashCode is:

  • Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
  • If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
  • It is not required that if two objects are unequal according to the method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the JavaTM programming language.)

Return
a hash code value for this object.
@deprecated
As of JDK version 1.1, replaced by setVisible(boolean).
This is overridden to return false if the current Icon's Image is not equal to the passed in Image img.
Parameters
imgthe Image to be compared
infoflagsflags used to repaint the button when the image is updated and which determine how much is to be painted
xthe x coordinate
ythe y coordinate
wthe width
hthe height
@deprecated
As of JDK version 1.1, replaced by getInsets().
@deprecated
As of JDK version 1.1, replaced by contains(int, int).
Invalidates the container. The container and all parents above it are marked as needing to be laid out. This method can be called often, so it needs to execute quickly.
Checks if the component is contained in the component hierarchy of this container.
Parameters
cthe component
Return
true if it is an ancestor; false otherwise.
@since
JDK1.1
Returns whether the menu item is "armed".
Return
true if the menu item is armed, and it can be selected
See Also
Returns whether the background color has been explicitly set for this Component. If this method returns false, this Component is inheriting its background color from an ancestor.
Return
true if the background color has been explicitly set for this Component; false otherwise.
@since
1.4
Gets the borderPainted property.
Return
the value of the borderPainted property
Gets the contentAreaFilled property.
Return
the contentAreaFilled property
Returns whether the cursor has been explicitly set for this Component. If this method returns false, this Component is inheriting its cursor from an ancestor.
Return
true if the cursor has been explicitly set for this Component; false otherwise.
@since
1.4
Determines whether this component is displayable. A component is displayable when it is connected to a native screen resource.

A component is made displayable either when it is added to a displayable containment hierarchy or when its containment hierarchy is made displayable. A containment hierarchy is made displayable when its ancestor window is either packed or made visible.

A component is made undisplayable either when it is removed from a displayable containment hierarchy or when its containment hierarchy is made undisplayable. A containment hierarchy is made undisplayable when its ancestor window is disposed.

Return
true if the component is displayable, false otherwise
@since
1.2
Returns whether this component should use a buffer to paint.
Return
true if this component is double buffered, otherwise false
Determines whether this component is enabled. An enabled component can respond to user input and generate events. Components are enabled initially by default. A component may be enabled or disabled by calling its setEnabled method.
Return
true if the component is enabled, false otherwise
@since
JDK1.0
See Also
Returns whether this Component can be focused.
Return
true if this Component is focusable; false otherwise.
@since
1.4
See Also
Returns whether this Container is the root of a focus traversal cycle. Once focus enters a traversal cycle, typically it cannot leave it via focus traversal unless one of the up- or down-cycle keys is pressed. Normal traversal is limited to this Container, and all of this Container's descendants that are not descendants of inferior focus cycle roots. Note that a FocusTraversalPolicy may bend these restrictions, however. For example, ContainerOrderFocusTraversalPolicy supports implicit down-cycle traversal.
Return
whether this Container is the root of a focus traversal cycle
@since
1.4
Returns whether the specified Container is the focus cycle root of this Container's focus traversal cycle. Each focus traversal cycle has only a single focus cycle root and each Container which is not a focus cycle root belongs to only a single focus traversal cycle. Containers which are focus cycle roots belong to two cycles: one rooted at the Container itself, and one rooted at the Container's nearest focus-cycle-root ancestor. This method will return true for both such Containers in this case.
Parameters
containerthe Container to be tested
Return
true if the specified Container is a focus-cycle- root of this Container; false otherwise
@since
1.4
Returns true if this Component is the focus owner.
Return
true if this Component is the focus owner; false otherwise
@since
1.4
Gets the paintFocus property.
Return
the paintFocus property
Returns whether this Component can become the focus owner.
Return
true if this Component is focusable; false otherwise
@since
JDK1.1
@deprecated
As of 1.4, replaced by isFocusable().
See Also
Returns whether this container provides focus traversal policy. If this property is set to true then when keyboard focus manager searches container hierarchy for focus traversal policy and encounters this container before any other container with this property as true or focus cycle roots then its focus traversal policy will be used instead of focus cycle root's policy.
Return
true if this container provides focus traversal policy, false otherwise
@since
1.5
@beaninfo
bound: true
Returns whether the focus traversal policy has been explicitly set for this Container. If this method returns false, this Container will inherit its focus traversal policy from an ancestor.
Return
true if the focus traversal policy has been explicitly set for this Container; false otherwise.
@since
1.4
Returns whether the font has been explicitly set for this Component. If this method returns false, this Component is inheriting its font from an ancestor.
Return
true if the font has been explicitly set for this Component; false otherwise.
@since
1.4
Returns whether the foreground color has been explicitly set for this Component. If this method returns false, this Component is inheriting its foreground color from an ancestor.
Return
true if the foreground color has been explicitly set for this Component; false otherwise.
@since
1.4
A lightweight component doesn't have a native toolkit peer. Subclasses of Component and Container, other than the ones defined in this package like Button or Scrollbar, are lightweight. All of the Swing components are lightweights.

This method will always return false if this component is not displayable because it is impossible to determine the weight of an undisplayable component.

Return
true if this component has a lightweight peer; false if it has a native peer or no peer
@since
1.2
Returns true if this component is lightweight, that is, if it doesn't have a native window system peer.
Return
true if this component is lightweight
In release 1.4, the focus subsystem was rearchitected. For more information, see How to Use the Focus Subsystem, a section in The Java Tutorial.

Changes this JComponent's focus traversal keys to CTRL+TAB and CTRL+SHIFT+TAB. Also prevents SortingFocusTraversalPolicy from considering descendants of this JComponent when computing a focus traversal cycle.

@deprecated
As of 1.4, replaced by Component.setFocusTraversalKeys(int, Set) and Container.setFocusCycleRoot(boolean).
Returns true if the maximum size has been set to a non-null value otherwise returns false.
Return
true if maximumSize is non-null, false otherwise
@since
1.5
Returns whether or not setMinimumSize has been invoked with a non-null value.
Return
true if setMinimumSize has been invoked with a non-null value.
@since
1.5
Returns true if this component is completely opaque.

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

Subclasses that guarantee to always completely paint their contents should override this method and return true.

Return
true if this component is completely opaque
See Also
Returns true if this component tiles its children -- 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, such as JLayeredPane, should override this method to return false.
Return
always returns true
Returns true if the component is currently painting a tile. If this method returns true, paint will be called again for another tile. This method returns false if you are not painting a tile or if the last tile is painted. Use this method to keep some state you might need between tiles.
Return
true if the component is currently painting a tile, false otherwise
Returns true if the preferred size has been set to a non-null value otherwise returns false.
Return
true if setPreferredSize has been invoked with a non-null value.
@since
1.5
Returns true if this JComponent should get focus; otherwise returns false.

Please see How to Use the Focus Subsystem, a section in The Java Tutorial, for more information.

Return
true if this component should get focus, otherwise returns false
Gets the rolloverEnabled property.
Return
the value of the rolloverEnabled property
Returns the state of the button. True if the toggle button is selected, false if it's not.
Return
true if the toggle button is selected, otherwise false
Determines whether this component is showing on screen. This means that the component must be visible, and it must be in a container that is visible and showing.
Return
true if the component is showing, false otherwise
@since
JDK1.0
See Also
Determines whether this component is valid. A component is valid when it is correctly sized and positioned within its parent container and all its children are also valid. In order to account for peers' size requirements, components are invalidated before they are first shown on the screen. By the time the parent container is fully realized, all its components will be valid.
Return
true if the component is valid, false otherwise
@since
JDK1.0
If this method returns true, revalidate calls by descendants of this component will cause the entire tree beginning with this root to be validated. Returns false by default. JScrollPane overrides this method and returns true.
Determines whether this component should be visible when its parent is visible. Components are initially visible, with the exception of top level components such as Frame objects.
Return
true if the component is visible, false otherwise
@since
JDK1.0
See Also
@deprecated
As of JDK version 1.1, replaced by processKeyEvent(KeyEvent).
@deprecated
As of JDK version 1.1, replaced by processKeyEvent(KeyEvent).
@deprecated
As of JDK version 1.1, replaced by doLayout().
Prints a listing of this component to the standard system output stream System.out.
@since
JDK1.0
Prints a listing of this component to the specified output stream.
Parameters
outa print stream
@since
JDK1.0
Prints a listing of this container to the specified output stream. The listing starts at the specified indentation.

The immediate children of the container are printed with an indentation of indent+1. The children of those children are printed at indent+2 and so on.

Parameters
outa print stream
indentthe number of spaces to indent
@since
JDK1.0
Prints a listing to the specified print writer.
Parameters
outthe print writer to print to
@since
JDK1.1
Prints out a list, starting at the specified indentation, to the specified print writer.

The immediate children of the container are printed with an indentation of indent+1. The children of those children are printed at indent+2 and so on.

Parameters
outa print writer
indentthe number of spaces to indent
@since
JDK1.1
@deprecated
As of JDK version 1.1, replaced by getComponentAt(int, int).
@deprecated
As of JDK version 1.1, replaced by getLocation().
@deprecated
As of JDK version 1.1, replaced by processFocusEvent(FocusEvent).
Called by the MenuSelectionManager when the MenuElement is selected or unselected.
Parameters
isIncludedtrue if this menu item is on the part of the menu path that changed, false if this menu is part of the a menu path that changed, but this particular part of that path is still the same
@deprecated
As of JDK version 1.1, replaced by getMinimumSize().
@deprecated
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
@deprecated
As of JDK version 1.1, replaced by processMouseMotionEvent(MouseEvent).
@deprecated
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
@deprecated
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
@deprecated
As of JDK version 1.1, replaced by processMouseMotionEvent(MouseEvent).
@deprecated
As of JDK version 1.1, replaced by processMouseEvent(MouseEvent).
@deprecated
As of JDK version 1.1, replaced by setLocation(int, int).
@deprecated
As of JDK version 1.1, replaced by transferFocus().
Wakes up a single thread that is waiting on this object's monitor. If any threads are waiting on this object, one of them is chosen to be awakened. The choice is arbitrary and occurs at the discretion of the implementation. A thread waits on an object's monitor by calling one of the wait methods.

The awakened thread will not be able to proceed until the current thread relinquishes the lock on this object. The awakened thread will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened thread enjoys no reliable privilege or disadvantage in being the next thread to lock this object.

This method should only be called by a thread that is the owner of this object's monitor. A thread becomes the owner of the object's monitor in one of three ways:

  • By executing a synchronized instance method of that object.
  • By executing the body of a synchronized statement that synchronizes on the object.
  • For objects of type Class, by executing a synchronized static method of that class.

Only one thread at a time can own an object's monitor.

Throws
IllegalMonitorStateExceptionif the current thread is not the owner of this object's monitor.
Wakes up all threads that are waiting on this object's monitor. A thread waits on an object's monitor by calling one of the wait methods.

The awakened threads will not be able to proceed until the current thread relinquishes the lock on this object. The awakened threads will compete in the usual manner with any other threads that might be actively competing to synchronize on this object; for example, the awakened threads enjoy no reliable privilege or disadvantage in being the next thread to lock this object.

This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.

Throws
IllegalMonitorStateExceptionif the current thread is not the owner of this object's monitor.
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) delegate's paint method should just override paintComponent.

Parameters
gthe Graphics context in which to paint
Paints this component and all of its subcomponents.

The origin of the graphics context, its (00) coordinate point, is the top-left corner of this component. The clipping region of the graphics context is the bounding rectangle of this component.

Parameters
gthe graphics context to use for painting
@since
JDK1.0
See Also
Paints each of the components in this container.
Parameters
gthe graphics context.
Paints the specified region in this component and all of its descendants that overlap the region, immediately.

It's rarely necessary 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.

Parameters
xthe x value of the region to be painted
ythe y value of the region to be painted
wthe width of the region to be painted
hthe height of the region to be painted
See Also
Paints the specified region now.
Parameters
ra Rectangle containing the region to be painted
@deprecated
As of JDK version 1.1, replaced by dispatchEvent(AWTEvent).
@deprecated
As of JDK version 1.1, replaced by getPreferredSize().
Prepares an image for rendering on this component. The image data is downloaded asynchronously in another thread and the appropriate screen representation of the image is generated.
Parameters
imagethe Image for which to prepare a screen representation
observerthe ImageObserver object to be notified as the image is being prepared
Return
true if the image has already been fully prepared; false otherwise
@since
JDK1.0
Prepares an image for rendering on this component at the specified width and height.

The image data is downloaded asynchronously in another thread, and an appropriately scaled screen representation of the image is generated.

Parameters
imagethe instance of Image for which to prepare a screen representation
widththe width of the desired screen representation
heightthe height of the desired screen representation
observerthe ImageObserver object to be notified as the image is being prepared
Return
true if the image has already been fully prepared; false otherwise
@since
JDK1.0
Invoke this method to print the component. This method will result in invocations to printComponent, printBorder and printChildren. It is not recommended that you override this method, instead override one of the previously mentioned methods. This method sets the component's state such that the double buffer will not be used, eg painting will be done directly on the passed in Graphics.
Parameters
gthe Graphics context in which to paint
Invoke this method to print the component. This method invokes print on the component.
Parameters
gthe Graphics context in which to paint
Prints each of the components in this container.
Parameters
gthe graphics context.
Processes a key event forwarded from the MenuSelectionManager and changes the menu selection, if necessary, by using MenuSelectionManager's API.

Note: you do not have to forward the event to sub-components. This is done automatically by the MenuSelectionManager.

Parameters
ea KeyEvent
paththe MenuElement path array
managerthe MenuSelectionManager
Handles mouse drag in a menu.
Parameters
ea MenuDragMouseEvent object
Handles a keystroke in a menu.
Parameters
ea MenuKeyEvent object
Processes a mouse event forwarded from the MenuSelectionManager and changes the menu selection, if necessary, by using the MenuSelectionManager's API.

Note: you do not have to forward the event to sub-components. This is done automatically by the MenuSelectionManager.

Parameters
ea MouseEvent
paththe MenuElement path array
managerthe MenuSelectionManager
Adds 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. 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.

Parameters
keythe new client property key
valuethe new client property value; if null this method will remove the property
This method is now obsolete, please use a combination of getActionMap() and getInputMap() for similiar behavior.
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 aCondition 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.

Parameters
anActionthe Action to be registered
aCommandthe command to be set in the delivered event
aKeyStrokethe KeyStroke to bind to the action
aConditionthe condition that needs to be met, see above
See Also
Removes the specified component from this container. This method also notifies the layout manager to remove the component from this container's layout via the removeLayoutComponent method.
Parameters
compthe component to be removed
See Also
Removes the component, specified by index, from this container. This method also notifies the layout manager to remove the component from this container's layout via the removeLayoutComponent method.
Parameters
indexthe index of the component to be removed
@since
JDK1.1
See Also
Removes the specified popup menu from the component.
Parameters
popupthe popup menu to be removed
@since
JDK1.1
Removes an ActionListener from the button. If the listener is the currently set Action for the button, then the Action is set to null.
Parameters
lthe listener to be removed
Removes all the components from this container. This method also notifies the layout manager to remove the components from this container's layout via the removeLayoutComponent method.
See Also
Unregisters listener so that it will no longer receive AncestorEvents.
Parameters
listenerthe AncestorListener to be removed
Removes a ChangeListener from the button.
Parameters
lthe listener to be removed
Removes the specified component listener so that it no longer receives component events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Removes the specified container listener so it no longer receives container events from this container. If l is null, no exception is thrown and no action is performed.
Parameters
lthe container listener
Removes the specified focus listener so that it no longer receives focus events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Parameters
lthe focus listener
@since
JDK1.1
Removes the specified hierarchy bounds listener so that it no longer receives hierarchy bounds events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Removes the specified hierarchy listener so that it no longer receives hierarchy changed events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Removes the specified input method listener so that it no longer receives input method events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Removes an ItemListener from the button.
Parameters
lthe ItemListener to be removed
Removes the specified key listener so that it no longer receives key events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Parameters
lthe key listener
@since
JDK1.1
Removes a MenuDragMouseListener from the menu item.
Parameters
lthe MenuDragMouseListener to be removed
Removes a MenuKeyListener from the menu item.
Parameters
lthe MenuKeyListener to be removed
Removes the specified mouse listener so that it no longer receives mouse events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Parameters
lthe mouse listener
@since
JDK1.1
Removes the specified mouse motion listener so that it no longer receives mouse motion events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If listener l is null, no exception is thrown and no action is performed.
Removes the specified mouse wheel listener so that it no longer receives mouse wheel events from this component. This method performs no function, nor does it throw an exception, if the listener specified by the argument was not previously added to this component. If l is null, no exception is thrown and no action is performed.
Notifies 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.
Removes a PropertyChangeListener from the listener list. This method should be used to remove PropertyChangeListeners that were registered for all bound properties of this class.

If listener is null, no exception is thrown and no action is performed.

Removes a PropertyChangeListener from the listener list for a specific property. This method should be used to remove PropertyChangeListeners that were registered for a specific bound property.

If propertyName or listener is null, no exception is thrown and no action is taken.

Removes a VetoableChangeListener from the listener list. This removes a VetoableChangeListener that was registered for all properties.
Parameters
listenerthe VetoableChangeListener to be removed
Repaints this component.

If this component is a lightweight component, this method causes a call to this component's paint method as soon as possible. Otherwise, this method causes a call to this component's update method as soon as possible.

Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.

@since
JDK1.0
Repaints the specified rectangle of this component.

If this component is a lightweight component, this method causes a call to this component's paint method as soon as possible. Otherwise, this method causes a call to this component's update method as soon as possible.

Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.

Parameters
xthe x coordinate
ythe y coordinate
widththe width
heightthe height
@since
JDK1.0
Repaints the component. If this component is a lightweight component, this results in a call to paint within tm milliseconds.

Note: For more information on the paint mechanisms utilitized by AWT and Swing, including information on how to write the most efficient painting code, see Painting in AWT and Swing.

Parameters
tmmaximum time in milliseconds before update
@since
JDK1.0
Adds the specified region to the dirty region list if the component is showing. The component will be repainted after all of the currently pending events have been dispatched.
Parameters
tmthis parameter is not used
xthe x value of the dirty region
ythe y value of the dirty region
widththe width of the dirty region
heightthe height of the dirty region
Adds the specified region to the dirty region list if the component is showing. The component will be repainted after all of the currently pending events have been dispatched.
Parameters
ra Rectangle containing the dirty region
In release 1.4, the focus subsystem was rearchitected. For more information, see How to Use the Focus Subsystem, a section in The Java Tutorial.

Requests focus on this JComponent's FocusTraversalPolicy's default Component. If this JComponent is a focus cycle root, then its FocusTraversalPolicy is used. Otherwise, the FocusTraversalPolicy of this JComponent's focus-cycle-root ancestor is used.

@deprecated
As of 1.4, replaced by FocusTraversalPolicy.getDefaultComponent(Container).requestFocus()
Requests that this Component gets the input focus. Refer to Component.requestFocus() for a complete description of this method.

Note that the use of this method is discouraged because its behavior is platform dependent. Instead we recommend the use of requestFocusInWindow() . If you would like more information on focus, see

Requests that this Component gets the input focus. Refer to Component.requestFocus(boolean) for a complete description of this method.

Note that the use of this method is discouraged because its behavior is platform dependent. Instead we recommend the use of requestFocusInWindow(boolean) . If you would like more information on focus, see How to Use the Focus Subsystem, a section in The Java Tutorial.

Parameters
temporaryboolean indicating if the focus change is temporary
Return
false if the focus change request is guaranteed to fail; true if it is likely to succeed
@since
1.4
Requests that this Component gets the input focus. Refer to Component.requestFocusInWindow() for a complete description of this method.

If you would like more information on focus, see How to Use the Focus Subsystem, a section in The Java Tutorial.

Return
false if the focus change request is guaranteed to fail; true if it is likely to succeed
@since
1.4
Unregisters all the bindings in the 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.
Parameters
xthe new horizontal location
ythe new vertical location
wthe new width
hthe new height
@deprecated
As of JDK 5, replaced by Component.setBounds(int, int, int, int).

Moves and resizes this component.

@deprecated
As of JDK version 1.1, replaced by setSize(Dimension).
@deprecated
As of JDK version 1.1, replaced by setSize(int, int).
Supports deferred automatic layout.

Calls invalidate and then adds this component'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.

Forwards the scrollRectToVisible() message to the JComponent's parent. Components that can service the request, such as JViewport, override this method and perform the scrolling.
Parameters
aRectthe visible Rectangle
See Also
Sets the key combination which invokes the menu item's action listeners without navigating the menu hierarchy. It is the UI's responsibility to install the correct action. Note that when the keyboard accelerator is typed, it will work whether or not the menu is currently displayed.
Parameters
keyStrokethe KeyStroke which will serve as an accelerator
@beaninfo
description: The keystroke combination which will invoke the JMenuItem's actionlisteners without navigating the menu hierarchy bound: true preferred: true
Sets the Action for the ActionEvent source. The new Action replaces any previously set Action but does not affect ActionListeners independently added with addActionListener. If the Action is already a registered ActionListener for the button, it is not re-registered.

A side-effect of setting the Action is that the ActionEvent source's properties are immediately set from the values in the Action (performed by the method configurePropertiesFromAction) and subsequently updated as the Action's properties change (via a PropertyChangeListener created by the method createActionPropertyChangeListener.

Parameters
athe Action for the AbstractButton, or null
@since
1.3
@beaninfo
bound: true attribute: visualUpdate true description: the Action instance connected with this ActionEvent source
Sets the action command for this button.
Parameters
actionCommandthe action command for this button
Sets the ActionMap to am. This does not set the parent of the am to be the ActionMap from the UI (if there was one), it is up to the caller to have done this.
Parameters
amthe new ActionMap
@since
1.3
Sets the the vertical alignment.
Parameters
alignmentXthe new vertical alignment
@beaninfo
description: The preferred horizontal alignment of the component.
Sets the the horizontal alignment.
Parameters
alignmentYthe new horizontal alignment
@beaninfo
description: The preferred vertical alignment of the component.
Identifies the menu item as "armed". If the mouse button is released while it is over this item, the menu's action event will fire. If the mouse button is released elsewhere, the event will not fire and the menu item will be disarmed.
Parameters
btrue to arm the menu item so it can be selected
@beaninfo
description: Mouse release will fire an action event hidden: true
Sets the autoscrolls property. If true mouse dragged events will be synthetically generated when the mouse is dragged outside of the component's bounds and mouse motion has paused (while the button continues to be held down). The synthetic events make it appear that the drag gesture has resumed in the direction established when the component's boundary was crossed. Components that support autoscrolling must handle mouseDragged events by calling scrollRectToVisible with a rectangle that contains the mouse event's location. All of the Swing components that support item selection and are typically displayed in a JScrollPane (JTable, JList, JTree, JTextArea, and JEditorPane) already handle mouse dragged events in this way. To enable autoscrolling in any other component, add a mouse motion listener that calls scrollRectToVisible. For example, given a JPanel, myPanel:
 MouseMotionListener doScrollRectToVisible = new MouseMotionAdapter() {
     public void mouseDragged(MouseEvent e) {
        Rectangle r = new Rectangle(e.getX(), e.getY(), 1, 1);
        ((JPanel)e.getSource()).scrollRectToVisible(r);
    }
 };
 myPanel.addMouseMotionListener(doScrollRectToVisible);
 
The default value of the autoScrolls property is false.
Parameters
autoscrollsif true, synthetic mouse dragged events are generated when the mouse is dragged outside of a component's bounds and the mouse button continues to be held down; otherwise false
@beaninfo
expert: true description: Determines if this component automatically scrolls its contents when dragged.
Sets the background color of this component.
Parameters
bgthe desired background Color
@beaninfo
preferred: true bound: true attribute: visualUpdate true description: The background color of the component.
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 (such as margins and padding) regions for a swing component. Compound borders can be used to nest multiple borders within a single component.

Although technically you can set the border on any object that inherits from JComponent, the look and feel implementation of many standard Swing components doesn't work well with user-set borders. In general, when you want to set a border on a standard Swing component other than JPanel or JLabel, we recommend that you put the component in a JPanel and set the border on the JPanel.

This is a bound property.

Parameters
borderthe border to be rendered for this component
@beaninfo
bound: true preferred: true attribute: visualUpdate true description: The component's border.
Sets the borderPainted property. If true and the button has a border, the border is painted. The default value for the borderPainted property is true.
Parameters
bif true and border property is not null, the border is painted
@beaninfo
bound: true attribute: visualUpdate true description: Whether the border should be painted.
Moves and resizes this component. The new location of the top-left corner is specified by x and y, and the new size is specified by width and height.
Parameters
xthe new x-coordinate of this component
ythe new y-coordinate of this component
widththe new width of this component
heightthe new height of this component
@since
JDK1.1
Moves and resizes this component to conform to the new bounding rectangle r. This component's new position is specified by r.x and r.y, and its new size is specified by r.width and r.height
Parameters
rthe new bounding rectangle for this component
@since
JDK1.1
Sets the language-sensitive orientation that is to be used to order the elements or text within this component. Language-sensitive LayoutManager and Component subclasses will use this property to determine how to lay out and draw components.

At construction time, a component's orientation is set to ComponentOrientation.UNKNOWN, indicating that it has not been specified explicitly. The UNKNOWN orientation behaves the same as ComponentOrientation.LEFT_TO_RIGHT.

To set the orientation of a single component, use this method. To set the orientation of an entire component hierarchy, use applyComponentOrientation .

@author
Laura Werner, IBM
@beaninfo
bound: true
Sets the JPopupMenu for this JComponent. The UI is responsible for registering bindings and adding the necessary listeners such that the JPopupMenu will be shown at the appropriate time. When the JPopupMenu is shown depends upon the look and feel: some may show it on a mouse event, some may enable a key binding.

If popup is null, and getInheritsPopupMenu returns true, then getComponentPopupMenu will be delegated to the parent. This provides for a way to make all child components inherit the popupmenu of the parent.

This is a bound property.

Parameters
popup- the popup that will be assigned to this component may be null
@beaninfo
bound: true preferred: true description: Popup to show
@since
1.5
Moves the specified component to the specified z-order index in the container. The z-order determines the order that components are painted; the component with the highest z-order paints first and the component with the lowest z-order paints last. Where components overlap, the component with the lower z-order paints over the component with the higher z-order.

If the component is a child of some other container, it is removed from that container before being added to this container. The important difference between this method and java.awt.Container.add(Component, int) is that this method doesn't call removeNotify on the component while removing it from its previous container unless necessary and when allowed by the underlying native windowing system. This way, if the component has the keyboard focus, it maintains the focus when moved to the new position.

This property is guaranteed to apply only to lightweight non-Container components.

Note: Not all platforms support changing the z-order of heavyweight components from one container into another without the call to removeNotify. There is no way to detect whether a platform supports this, so developers shouldn't make any assumptions.

Parameters
compthe component to be moved
indexthe position in the container's list to insert the component, where getComponentCount() appends to the end
Throws
NullPointerExceptionif comp is null
IllegalArgumentExceptionif comp is one of the container's parents
IllegalArgumentExceptionif index is not in the range [0, getComponentCount()] for moving between containers, or not in the range [0, getComponentCount()-1] for moving inside a container
IllegalArgumentExceptionif adding a container to itself
IllegalArgumentExceptionif adding a Window to a container
@since
1.5
Sets the contentAreaFilled property. If true the button will paint the content area. If you wish to have a transparent button, such as an icon only button, for example, then you should set this to false. Do not call setOpaque(false). The default value for the the contentAreaFilled property is true.

This function may cause the component's opaque property to change.

The exact behavior of calling this function varies on a component-by-component and L&F-by-L&F basis.

Parameters
bif true, the content should be filled; if false the content area is not filled
@beaninfo
bound: true attribute: visualUpdate true description: Whether the button should paint the content area or leave it transparent.
Sets the cursor image to the specified cursor. This cursor image is displayed when the contains method for this component returns true for the current cursor location, and this Component is visible, displayable, and enabled. Setting the cursor of a Container causes that cursor to be displayed within all of the container's subcomponents, except for those that have a non-null cursor.
Parameters
cursorOne of the constants defined by the Cursor class; if this parameter is null then this component will inherit the cursor of its parent
@since
JDK1.1
Enables or disables diagnostic information about every graphics operation performed within the component or one of its children.
Parameters
debugOptionsdetermines how the component should display the information; one of the following options:
  • 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.
  • DebugGraphics.NONE_OPTION disables debugging.
  • A value of 0 causes no changes to the debugging options.
debugOptions is bitwise OR'd into the current value
@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.
Sets the default locale used to initialize each JComponent's locale property upon creation. The initial value is the VM's default locale. The default locale has "AppContext" scope so that applets (and potentially multiple lightweight applications running in a single VM) can have their own setting. An applet can safely alter its default locale because it will have no affect on other applets (or the browser).
Parameters
lthe desired default Locale for new components.
@since
1.4
Sets the disabled icon for the button.
Parameters
disabledIconthe icon used as the disabled image
@beaninfo
bound: true attribute: visualUpdate true description: The disabled icon for the button.
Sets the disabled selection icon for the button.
Parameters
disabledSelectedIconthe icon used as the disabled selection image
@beaninfo
bound: true attribute: visualUpdate true description: The disabled selection icon for the button.
Provides a hint to the look and feel as to which character in the text should be decorated to represent the mnemonic. Not all look and feels may support this. A value of -1 indicates either there is no mnemonic, the mnemonic character is not contained in the string, or the developer does not wish the mnemonic to be displayed.

The value of this is updated as the properties relating to the mnemonic change (such as the mnemonic itself, the text...). You should only ever have to call this if you do not wish the default character to be underlined. For example, if the text was 'Save As', with a mnemonic of 'a', and you wanted the 'A' to be decorated, as 'Save As', you would have to invoke setDisplayedMnemonicIndex(5) after invoking setMnemonic(KeyEvent.VK_A).

Parameters
indexIndex into the String to underline
Throws
IllegalArgumentExceptionwill be thrown if index is >= length of the text, or < -1
@since
1.4
@beaninfo
bound: true attribute: visualUpdate true description: the index into the String to draw the keyboard character mnemonic at
Sets whether the this 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. Swings painting system always uses 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.
Parameters
aFlagif true, set this component to be double buffered
Associate a DropTarget with this component. The Component will receive drops only if it is enabled.
Parameters
dtThe DropTarget
See Also
Enables or disables the menu item.
Parameters
btrue to enable the item
@beaninfo
description: Does the component react to user interaction bound: true preferred: true
Sets the focusable state of this Component to the specified value. This value overrides the Component's default focusability.
Parameters
focusableindicates whether this Component is focusable
@since
1.4
@beaninfo
bound: true
See Also
Sets whether this Container is the root of a focus traversal cycle. Once focus enters a traversal cycle, typically it cannot leave it via focus traversal unless one of the up- or down-cycle keys is pressed. Normal traversal is limited to this Container, and all of this Container's descendants that are not descendants of inferior focus cycle roots. Note that a FocusTraversalPolicy may bend these restrictions, however. For example, ContainerOrderFocusTraversalPolicy supports implicit down-cycle traversal.

The alternative way to specify the traversal order of this Container's children is to make this Container a focus traversal policy provider.

Parameters
focusCycleRootindicates whether this Container is the root of a focus traversal cycle
@since
1.4
@beaninfo
bound: true
Sets the paintFocus property, which must be true for the focus state to be painted. The default value for the paintFocus property is true. Some look and feels might not paint focus state; they will ignore this property.
Parameters
bif true, the focus state should be painted
@beaninfo
bound: true attribute: visualUpdate true description: Whether focus should be painted
Sets the focus traversal keys for a given traversal operation for this Component. Refer to java.awt.Component#setFocusTraversalKeys for a complete description of this method.
Parameters
idone of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, or KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS
keystrokesthe Set of AWTKeyStroke for the specified operation
Throws
IllegalArgumentExceptionif id is not one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, or KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or if keystrokes contains null, or if any Object in keystrokes is not an AWTKeyStroke, or if any keystroke represents a KEY_TYPED event, or if any keystroke already maps to another focus traversal operation for this Component
@since
1.5
@beaninfo
bound: true
Sets whether focus traversal keys are enabled for this Component. Components for which focus traversal keys are disabled receive key events for focus traversal keys. Components for which focus traversal keys are enabled do not see these events; instead, the events are automatically converted to traversal operations.
Parameters
focusTraversalKeysEnabledwhether focus traversal keys are enabled for this Component
@since
1.4
@beaninfo
bound: true
Sets the focus traversal policy that will manage keyboard traversal of this Container's children, if this Container is a focus cycle root. If the argument is null, this Container inherits its policy from its focus- cycle-root ancestor. If the argument is non-null, this policy will be inherited by all focus-cycle-root children that have no keyboard- traversal policy of their own (as will, recursively, their focus-cycle- root children).

If this Container is not a focus cycle root, the policy will be remembered, but will not be used or inherited by this or any other Containers until this Container is made a focus cycle root.

Parameters
policythe new focus traversal policy for this Container
@since
1.4
@beaninfo
bound: true
Sets whether this container will be used to provide focus traversal policy. Container with this property as true will be used to acquire focus traversal policy instead of closest focus cycle root ancestor.
Parameters
provideindicates whether this container will be used to provide focus traversal policy
@since
1.5
@beaninfo
bound: true
Sets the font for this component.
Parameters
fontthe desired Font for this component
@beaninfo
preferred: true bound: true attribute: visualUpdate true description: The font for the component.
Sets the foreground color of this component.
Parameters
fgthe desired foreground Color
@beaninfo
preferred: true bound: true attribute: visualUpdate true description: The foreground color of the component.
Sets the horizontal alignment of the icon and text.
Parameters
alignmentone of the following values:
  • SwingConstants.RIGHT (the default)
  • SwingConstants.LEFT
  • SwingConstants.CENTER
  • SwingConstants.LEADING
  • SwingConstants.TRAILING
@beaninfo
bound: true enum: LEFT SwingConstants.LEFT CENTER SwingConstants.CENTER RIGHT SwingConstants.RIGHT LEADING SwingConstants.LEADING TRAILING SwingConstants.TRAILING attribute: visualUpdate true description: The horizontal alignment of the icon and text.
Sets the horizontal position of the text relative to the icon.
Parameters
textPositionone of the following values:
  • SwingConstants.RIGHT
  • SwingConstants.LEFT
  • SwingConstants.CENTER
  • SwingConstants.LEADING
  • SwingConstants.TRAILING (the default)
Throws
IllegalArgumentExceptionif textPosition is not one of the legal values listed above
@beaninfo
bound: true enum: LEFT SwingConstants.LEFT CENTER SwingConstants.CENTER RIGHT SwingConstants.RIGHT LEADING SwingConstants.LEADING TRAILING SwingConstants.TRAILING attribute: visualUpdate true description: The horizontal position of the text relative to the icon.
Sets the button's default icon. This icon is also used as the "pressed" and "disabled" icon if there is no explicitly set pressed icon.
Parameters
defaultIconthe icon used as the default image
@beaninfo
bound: true attribute: visualUpdate true description: The button's default icon
If both the icon and text properties are set, this property defines the space between them.

The default value of this property is 4 pixels.

This is a JavaBeans bound property.

@since
1.4
@beaninfo
bound: true attribute: visualUpdate true description: If both the icon and text properties are set, this property defines the space between them.
Sets whether or not paint messages received from the operating system should be ignored. This does not affect paint events generated in software by the AWT, unless they are an immediate response to an OS-level paint message.

This is useful, for example, if running under full-screen mode and better performance is desired, or if page-flipping is used as the buffer strategy.

Sets whether or not getComponentPopupMenu should delegate to the parent if this component does not have a JPopupMenu assigned to it.

The default value for this is false, but some JComponent subclasses that are implemented as a number of JComponents may set this to true.

This is a bound property.

Parameters
valuewhether or not the JPopupMenu is inherited
@beaninfo
bound: true description: Whether or not the JPopupMenu is inherited
@since
1.5
Sets the InputMap to use under the condition condition to map. A null value implies you do not want any bindings to be used, even from the UI. This will not reinstall the UI InputMap (if there was one). condition has one of the following values:
  • WHEN_IN_FOCUSED_WINDOW
  • WHEN_FOCUSED
  • WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
If condition is WHEN_IN_FOCUSED_WINDOW and map is not a ComponentInputMap, an IllegalArgumentException will be thrown. Similarly, if condition is not one of the values listed, an IllegalArgumentException will be thrown.
Parameters
conditionone of the values listed above
mapthe InputMap to use for the given condition
Throws
IllegalArgumentExceptionif condition is WHEN_IN_FOCUSED_WINDOW and map is not an instance of ComponentInputMap; or if condition is not one of the legal values specified above
@since
1.3
Sets the input verifier for this component.
Parameters
inputVerifierthe new input verifier
@since
1.3
@beaninfo
bound: true description: The component's input verifier.
See Also
Sets the label text.
Parameters
labela String containing the text
@deprecated
- Replaced by setText(text)
@beaninfo
bound: true description: Replace by setText(text)
Sets the layout manager for this container, refer to for a complete description of this method.
Parameters
mgrthe specified layout manager
@since
1.5
Sets the locale of this component. This is a bound property.
Parameters
lthe locale to become this component's locale
@since
JDK1.1
See Also
Moves this component to a new location. The top-left corner of the new location is specified by the x and y parameters in the coordinate space of this component's parent.
Parameters
xthe x-coordinate of the new location's top-left corner in the parent's coordinate space
ythe y-coordinate of the new location's top-left corner in the parent's coordinate space
@since
JDK1.1
Moves this component to a new location. The top-left corner of the new location is specified by point p. Point p is given in the parent's coordinate space.
Parameters
pthe point defining the top-left corner of the new location, given in the coordinate space of this component's parent
@since
JDK1.1
Sets space for margin between the button's border and the label. Setting to null will cause the button to use the default margin. The button's default Border object will use this value to create the proper margin. However, if a non-default border is set on the button, it is that Border object's responsibility to create the appropriate margin space (else this property will effectively be ignored).
Parameters
mthe space between the border and the label
@beaninfo
bound: true attribute: visualUpdate true description: The space between the button's border and the label.
Sets the maximum size of this component to a constant value. Subsequent calls to getMaximumSize will always return this value; the component's UI will not be asked to compute it. Setting the maximum size to null restores the default behavior.
Parameters
maximumSizea Dimension containing the desired maximum allowable size
@beaninfo
bound: true description: The maximum size of the component.
Sets the minimum size of this component to a constant value. Subsequent calls to getMinimumSize will always return this value; the component's UI will not be asked to compute it. Setting the minimum size to null restores the default behavior.
Parameters
minimumSizethe new minimum size of this component
@beaninfo
bound: true description: The minimum size of the component.
This method is now obsolete, please use setMnemonic(int) to set the mnemonic for a button. This method is only designed to handle character values which fall between 'a' and 'z' or 'A' and 'Z'.
Parameters
mnemonica char specifying the mnemonic value
@beaninfo
bound: true attribute: visualUpdate true description: the keyboard character mnemonic
Sets the keyboard mnemonic on the current model. The mnemonic is the key which when combined with the look and feel's mouseless modifier (usually Alt) will activate this button if focus is contained somewhere within this button's ancestor window.

A mnemonic must correspond to a single key on the keyboard and should be specified using one of the VK_XXX keycodes defined in java.awt.event.KeyEvent. Mnemonics are case-insensitive, therefore a key event with the corresponding keycode would cause the button to be activated whether or not the Shift modifier was pressed.

If the character defined by the mnemonic is found within the button's label string, the first occurrence of it will be underlined to indicate the mnemonic to the user.

Parameters
mnemonicthe key code which represents the mnemonic
@beaninfo
bound: true attribute: visualUpdate true description: the keyboard character mnemonic
Sets the model that this button represents.
Parameters
newModelthe new ButtonModel
@beaninfo
bound: true description: Model that the Button uses.
See Also
Sets the amount of time (in milliseconds) required between mouse press events for the button to generate the corresponding action events. After the initial mouse press occurs (and action event generated) any subsequent mouse press events which occur on intervals less than the threshhold will be ignored and no corresponding action event generated. By default the threshhold is 0, which means that for each mouse press, an action event will be fired, no matter how quickly the mouse clicks occur. In buttons where this behavior is not desirable (for example, the "OK" button in a dialog), this threshhold should be set to an appropriate positive value.
Parameters
threshholdthe amount of time required between mouse press events to generate corresponding action events
Throws
IllegalArgumentExceptionif threshhold < 0
@since
1.4
Sets the name of the component to the specified string.
Parameters
namethe string that is to be this component's name
@since
JDK1.1
See Also
In release 1.4, the focus subsystem was rearchitected. For more information, see How to Use the Focus Subsystem, a section in The Java Tutorial.

Overrides the default FocusTraversalPolicy for this JComponent's focus traversal cycle by unconditionally setting the specified Component as the next Component in the cycle, and this JComponent as the specified Component's previous Component in the cycle.

Parameters
aComponentthe Component that should follow this JComponent in the focus traversal cycle
@deprecated
As of 1.4, replaced by FocusTraversalPolicy
If true the component paints every pixel within its bounds. Otherwise, the component may not paint some or all of its pixels, allowing the underlying pixels to show through.

The default value of this property is false for JComponent. However, the default value for this property on most standard JComponent subclasses (such as JButton and JTree) is look-and-feel dependent.

Parameters
isOpaquetrue if this component should be opaque
@beaninfo
bound: true expert: true description: The component's opacity
See Also
Sets the preferred size of this component. If preferredSize is null, the UI will be asked for the preferred size.
@beaninfo
preferred: true bound: true description: The preferred size of the component.
Sets the pressed icon for the button.
Parameters
pressedIconthe icon used as the "pressed" image
@beaninfo
bound: true attribute: visualUpdate true description: The pressed icon for the button.
Provides a hint as to whether or not this JComponent should get focus. This is only a hint, and it is up to consumers that are requesting focus to honor this property. This is typically honored for mouse operations, but not keyboard operations. For example, look and feels could verify this property is true before requesting focus during a mouse operation. This would often times be used if you did not want a mouse press on a JComponent to steal focus, but did want the JComponent to be traversable via the keyboard. If you do not want this JComponent focusable at all, use the setFocusable method instead.

Please see How to Use the Focus Subsystem, a section in The Java Tutorial, for more information.

Parameters
requestFocusEnabledindicates whether you want this JComponent to be focusable or not
Sets the rolloverEnabled property, which must be true for rollover effects to occur. The default value for the rolloverEnabled property is false. Some look and feels might not implement rollover effects; they will ignore this property.
Parameters
bif true, rollover effects should be painted
@beaninfo
bound: true attribute: visualUpdate true description: Whether rollover effects should be enabled.
Sets the rollover icon for the button.
Parameters
rolloverIconthe icon used as the "rollover" image
@beaninfo
bound: true attribute: visualUpdate true description: The rollover icon for the button.
Sets the rollover selected icon for the button.
Parameters
rolloverSelectedIconthe icon used as the "selected rollover" image
@beaninfo
bound: true attribute: visualUpdate true description: The rollover selected icon for the button.
Sets the state of the button. Note that this method does not trigger an actionEvent. Call doClick to perform a programatic action change.
Parameters
btrue if the button is selected, otherwise false
Sets the selected icon for the button.
Parameters
selectedIconthe icon used as the "selected" image
@beaninfo
bound: true attribute: visualUpdate true description: The selected icon for the button.
Resizes this component so that it has width d.width and height d.height.
Parameters
dthe dimension specifying the new size of this component
@since
JDK1.1
See Also
Resizes this component so that it has width width and height height.
Parameters
widththe new width of this component in pixels
heightthe new height of this component in pixels
@since
JDK1.1
See Also
Sets the selected-state of the item. This method exists for AWT compatibility only. New code should use setSelected() instead.
Parameters
ba boolean value indicating the item's selected-state, where true=selected
@beaninfo
description: The selection state of the check box menu item hidden: true
Sets the button's text.
Parameters
textthe string used to set the text
@beaninfo
bound: true preferred: true attribute: visualUpdate true description: The button's text.
See Also
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.

Parameters
textthe string to display; if the text is null, the tool tip is turned off for this component
@beaninfo
preferred: true description: The text to display in a tool tip.
Sets the transferHandler property, which is null if the component does not support data transfer operations.

If newHandler is not null, and the system property suppressSwingDropSupport is not true, this will install a DropTarget on the JComponent. The default for the system property is false, so that a DropTarget will be added.

Please see How to Use Drag and Drop and Data Transfer, a section in The Java Tutorial, for more information.

Parameters
newHandlermechanism for transfer of data to and from the component
@since
1.4
@beaninfo
bound: true hidden: true description: Mechanism for transfer of data to and from the component
Sets the L&F object that renders this component.
Parameters
uithe ButtonUI L&F object
@beaninfo
bound: true hidden: true attribute: visualUpdate true description: The UI object that implements the LookAndFeel.
See Also
Sets the look and feel object that renders this component.
Parameters
uithe JMenuItemUI L&F object
@beaninfo
bound: true hidden: true attribute: visualUpdate true description: The UI object that implements the Component's LookAndFeel.
Sets the value to indicate whether input verifier for the current focus owner will be called before this component requests focus. The default is true. Set to false on components such as a Cancel button or a scrollbar, which should activate even if the input in the current focus owner is not "passed" by the input verifier for that component.
Parameters
verifyInputWhenFocusTargetvalue for the verifyInputWhenFocusTarget property
@since
1.3
@beaninfo
bound: true description: Whether the Component verifies input before accepting focus.
Sets the vertical alignment of the icon and text.
Parameters
alignmentone of the following values:
  • SwingConstants.CENTER (the default)
  • SwingConstants.TOP
  • SwingConstants.BOTTOM
@beaninfo
bound: true enum: TOP SwingConstants.TOP CENTER SwingConstants.CENTER BOTTOM SwingConstants.BOTTOM attribute: visualUpdate true description: The vertical alignment of the icon and text.
Sets the vertical position of the text relative to the icon.
Parameters
textPositionone of the following values:
  • SwingConstants.CENTER (the default)
  • SwingConstants.TOP
  • SwingConstants.BOTTOM
@beaninfo
bound: true enum: TOP SwingConstants.TOP CENTER SwingConstants.CENTER BOTTOM SwingConstants.BOTTOM attribute: visualUpdate true description: The vertical position of the text relative to the icon.
Makes the component visible or invisible. Overrides Component.setVisible.
Parameters
aFlagtrue to make the component visible; false to make it invisible
@beaninfo
attribute: visualUpdate true
@deprecated
As of JDK version 1.1, replaced by setVisible(boolean).
@deprecated
As of JDK version 1.1, replaced by setVisible(boolean).
@deprecated
As of JDK version 1.1, replaced by getSize().
Returns a string representation of this component and its values.
Return
a string representation of this component
@since
JDK1.0
Transfers the focus to the next component, as though this Component were the focus owner.
@since
JDK1.1
Transfers the focus down one focus traversal cycle. If this Container is a focus cycle root, then the focus owner is set to this Container's default Component to focus, and the current focus cycle root is set to this Container. If this Container is not a focus cycle root, then no focus traversal operation occurs.
Transfers the focus up one focus traversal cycle. Typically, the focus owner is set to this Component's focus cycle root, and the current focus cycle root is set to the new focus owner's focus cycle root. If, however, this Component's focus cycle root is a Window, then the focus owner is set to the focus cycle root's default Component to focus, and the current focus cycle root is unchanged.
This 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. This will remove the binding from the ActionMap (if it exists) as well as the InputMaps.

Calls paint. Doesn't clear the background but see ComponentUI.update, which is called by paintComponent.
Parameters
gthe Graphics context in which to paint
Resets the UI property with a value from the current look and feel.
Validates this container and all of its subcomponents.

The validate method is used to cause a container to lay out its subcomponents again. It should be invoked when this container's subcomponents are modified (added to or removed from the container, or layout-related information changed) after the container has been displayed.

Causes current thread to wait until another thread invokes the method or the method for this object. In other words, this method behaves exactly as if it simply performs the call wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method. The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait();
         ... // Perform action appropriate to condition
     }
 
This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.
Throws
IllegalMonitorStateExceptionif the current thread is not the owner of the object's monitor.
InterruptedExceptionif another thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.
Causes current thread to wait until either another thread invokes the method or the method for this object, or a specified amount of time has elapsed.

The current thread must own this object's monitor.

This method causes the current thread (call it T) to place itself in the wait set for this object and then to relinquish any and all synchronization claims on this object. Thread T becomes disabled for thread scheduling purposes and lies dormant until one of four things happens:

  • Some other thread invokes the notify method for this object and thread T happens to be arbitrarily chosen as the thread to be awakened.
  • Some other thread invokes the notifyAll method for this object.
  • Some other thread interrupts thread T.
  • The specified amount of real time has elapsed, more or less. If timeout is zero, however, then real time is not taken into consideration and the thread simply waits until notified.
The thread T is then removed from the wait set for this object and re-enabled for thread scheduling. It then competes in the usual manner with other threads for the right to synchronize on the object; once it has gained control of the object, all its synchronization claims on the object are restored to the status quo ante - that is, to the situation as of the time that the wait method was invoked. Thread T then returns from the invocation of the wait method. Thus, on return from the wait method, the synchronization state of the object and of thread T is exactly as it was when the wait method was invoked.

A thread can also wake up without being notified, interrupted, or timing out, a so-called spurious wakeup. While this will rarely occur in practice, applications must guard against it by testing for the condition that should have caused the thread to be awakened, and continuing to wait if the condition is not satisfied. In other words, waits should always occur in loops, like this one:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }
 
(For more information on this topic, see Section 3.2.3 in Doug Lea's "Concurrent Programming in Java (Second Edition)" (Addison-Wesley, 2000), or Item 50 in Joshua Bloch's "Effective Java Programming Language Guide" (Addison-Wesley, 2001).

If the current thread is interrupted by another thread while it is waiting, then an InterruptedException is thrown. This exception is not thrown until the lock status of this object has been restored as described above.

Note that the wait method, as it places the current thread into the wait set for this object, unlocks only this object; any other objects on which the current thread may be synchronized remain locked while the thread waits.

This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.

Parameters
timeoutthe maximum time to wait in milliseconds.
Throws
IllegalArgumentExceptionif the value of timeout is negative.
IllegalMonitorStateExceptionif the current thread is not the owner of the object's monitor.
InterruptedExceptionif another thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.
Causes current thread to wait until another thread invokes the method or the method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.

This method is similar to the wait method of one argument, but it allows finer control over the amount of time to wait for a notification before giving up. The amount of real time, measured in nanoseconds, is given by:

 1000000*timeout+nanos

In all other respects, this method does the same thing as the method of one argument. In particular, wait(0, 0) means the same thing as wait(0).

The current thread must own this object's monitor. The thread releases ownership of this monitor and waits until either of the following two conditions has occurred:

  • Another thread notifies threads waiting on this object's monitor to wake up either through a call to the notify method or the notifyAll method.
  • The timeout period, specified by timeout milliseconds plus nanos nanoseconds arguments, has elapsed.

The thread then waits until it can re-obtain ownership of the monitor and resumes execution.

As in the one argument version, interrupts and spurious wakeups are possible, and this method should always be used in a loop:

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout, nanos);
         ... // Perform action appropriate to condition
     }
 
This method should only be called by a thread that is the owner of this object's monitor. See the notify method for a description of the ways in which a thread can become the owner of a monitor.
Parameters
timeoutthe maximum time to wait in milliseconds.
nanosadditional time, in nanoseconds range 0-999999.
Throws
IllegalArgumentExceptionif the value of timeout is negative or the value of nanos is not in the range 0-999999.
IllegalMonitorStateExceptionif the current thread is not the owner of this object's monitor.
InterruptedExceptionif another thread interrupted the current thread before or while the current thread was waiting for a notification. The interrupted status of the current thread is cleared when this exception is thrown.