| Methods Summary |
|---|
| public boolean | action(java.awt.Event evt, java.lang.Object what)
return false;
|
| public synchronized void | add(java.awt.PopupMenu popup)Adds the specified popup menu to the component.
if (popup.parent != null) {
popup.parent.remove(popup);
}
if (popups == null) {
popups = new Vector();
}
popups.addElement(popup);
popup.parent = this;
if (peer != null) {
if (popup.peer == null) {
popup.addNotify();
}
}
|
| public synchronized void | addComponentListener(java.awt.event.ComponentListener l)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.
if (l == null) {
return;
}
componentListener = AWTEventMulticaster.add(componentListener, l);
newEventsOnly = true;
|
| public synchronized void | addFocusListener(java.awt.event.FocusListener l)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.
if (l == null) {
return;
}
focusListener = AWTEventMulticaster.add(focusListener, l);
newEventsOnly = true;
// if this is a lightweight component, enable focus events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(AWTEvent.FOCUS_EVENT_MASK);
}
|
| public void | addHierarchyBoundsListener(java.awt.event.HierarchyBoundsListener l)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.
if (l == null) {
return;
}
boolean notifyAncestors;
synchronized (this) {
notifyAncestors =
(hierarchyBoundsListener == null &&
(eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) == 0);
hierarchyBoundsListener =
AWTEventMulticaster.add(hierarchyBoundsListener, l);
notifyAncestors = (notifyAncestors &&
hierarchyBoundsListener != null);
newEventsOnly = true;
}
if (notifyAncestors) {
synchronized (getTreeLock()) {
adjustListeningChildrenOnParent(
AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK, 1);
}
}
|
| public void | addHierarchyListener(java.awt.event.HierarchyListener l)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.
if (l == null) {
return;
}
boolean notifyAncestors;
synchronized (this) {
notifyAncestors =
(hierarchyListener == null &&
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) == 0);
hierarchyListener = AWTEventMulticaster.add(hierarchyListener, l);
notifyAncestors = (notifyAncestors && hierarchyListener != null);
newEventsOnly = true;
}
if (notifyAncestors) {
synchronized (getTreeLock()) {
adjustListeningChildrenOnParent(AWTEvent.HIERARCHY_EVENT_MASK,
1);
}
}
|
| public synchronized void | addInputMethodListener(java.awt.event.InputMethodListener l)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.
if (l == null) {
return;
}
inputMethodListener = AWTEventMulticaster.add(inputMethodListener, l);
newEventsOnly = true;
|
| public synchronized void | addKeyListener(java.awt.event.KeyListener l)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.
if (l == null) {
return;
}
keyListener = AWTEventMulticaster.add(keyListener, l);
newEventsOnly = true;
// if this is a lightweight component, enable key events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(AWTEvent.KEY_EVENT_MASK);
}
|
| public synchronized void | addMouseListener(java.awt.event.MouseListener l)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.
if (l == null) {
return;
}
mouseListener = AWTEventMulticaster.add(mouseListener,l);
newEventsOnly = true;
// if this is a lightweight component, enable mouse events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(AWTEvent.MOUSE_EVENT_MASK);
}
|
| public synchronized void | addMouseMotionListener(java.awt.event.MouseMotionListener l)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.
if (l == null) {
return;
}
mouseMotionListener = AWTEventMulticaster.add(mouseMotionListener,l);
newEventsOnly = true;
// if this is a lightweight component, enable mouse events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);
}
|
| public synchronized void | addMouseWheelListener(java.awt.event.MouseWheelListener l)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 {@link MouseWheelEvent}.
If l is null, no exception is thrown and no
action is performed.
if (l == null) {
return;
}
mouseWheelListener = AWTEventMulticaster.add(mouseWheelListener,l);
newEventsOnly = true;
dbg.println("Component.addMouseWheelListener(): newEventsOnly = " + newEventsOnly);
// if this is a lightweight component, enable mouse events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(AWTEvent.MOUSE_WHEEL_EVENT_MASK);
}
|
| public void | addNotify()Makes this Component displayable by connecting it to a
native screen resource.
This method is called internally by the toolkit and should
not be called directly by programs.
synchronized (getTreeLock()) {
ComponentPeer peer = this.peer;
if (peer == null || peer instanceof LightweightPeer){
if (peer == null) {
// Update both the Component's peer variable and the local
// variable we use for thread safety.
this.peer = peer = getToolkit().createComponent(this);
}
// This is a lightweight component which means it won't be
// able to get window-related events by itself. If any
// have been enabled, then the nearest native container must
// be enabled.
if (parent != null) {
long mask = 0;
if ((mouseListener != null) || ((eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0)) {
mask |= AWTEvent.MOUSE_EVENT_MASK;
}
if ((mouseMotionListener != null) ||
((eventMask & AWTEvent.MOUSE_MOTION_EVENT_MASK) != 0)) {
mask |= AWTEvent.MOUSE_MOTION_EVENT_MASK;
}
if ((mouseWheelListener != null ) ||
((eventMask & AWTEvent.MOUSE_WHEEL_EVENT_MASK) != 0)) {
mask |= AWTEvent.MOUSE_WHEEL_EVENT_MASK;
}
if (focusListener != null || (eventMask & AWTEvent.FOCUS_EVENT_MASK) != 0) {
mask |= AWTEvent.FOCUS_EVENT_MASK;
}
if (keyListener != null || (eventMask & AWTEvent.KEY_EVENT_MASK) != 0) {
mask |= AWTEvent.KEY_EVENT_MASK;
}
if (mask != 0) {
parent.proxyEnableEvents(mask);
}
}
} else {
// It's native. If the parent is lightweight it
// will need some help.
Container parent = this.parent;
if (parent != null && parent.peer instanceof LightweightPeer) {
nativeInLightFixer = new NativeInLightFixer();
}
}
invalidate();
int npopups = (popups != null? popups.size() : 0);
for (int i = 0 ; i < npopups ; i++) {
PopupMenu popup = (PopupMenu)popups.elementAt(i);
popup.addNotify();
}
if (dropTarget != null) dropTarget.addNotify(peer);
peerFont = getFont();
// Update stacking order
if (parent != null && parent.peer != null) {
ContainerPeer parentContPeer = (ContainerPeer) parent.peer;
// if our parent is lightweight and we are not
// we should call restack on nearest heavyweight
// container.
if (parentContPeer instanceof LightweightPeer
&& ! (peer instanceof LightweightPeer))
{
Container hwParent = getNativeContainer();
if (hwParent != null && hwParent.peer != null) {
parentContPeer = (ContainerPeer) hwParent.peer;
}
}
if (parentContPeer.isRestackSupported()) {
parentContPeer.restack();
}
}
if (hierarchyListener != null ||
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 ||
Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK)) {
HierarchyEvent e =
new HierarchyEvent(this, HierarchyEvent.HIERARCHY_CHANGED,
this, parent,
HierarchyEvent.DISPLAYABILITY_CHANGED |
((isRecursivelyVisible())
? HierarchyEvent.SHOWING_CHANGED
: 0));
dispatchEvent(e);
}
}
|
| public synchronized void | addPropertyChangeListener(java.beans.PropertyChangeListener listener)Adds a PropertyChangeListener to the listener list. The listener is
registered for all bound properties of this class, including the
following:
- this Component's font ("font")
- this Component's background color ("background")
- this Component's foreground color ("foreground")
- this Component's focusability ("focusable")
- this Component's focus traversal keys enabled state
("focusTraversalKeysEnabled")
- this Component's Set of FORWARD_TRAVERSAL_KEYS
("forwardFocusTraversalKeys")
- this Component's Set of BACKWARD_TRAVERSAL_KEYS
("backwardFocusTraversalKeys")
- this Component's Set of UP_CYCLE_TRAVERSAL_KEYS
("upCycleFocusTraversalKeys")
- this Component's preferred size ("preferredSize")
- this Component's minimum size ("minimumSize")
- this Component's maximum size ("maximumSize")
- this Component's name ("name")
Note that if this Component 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.
if (listener == null) {
return;
}
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(listener);
|
| public synchronized void | addPropertyChangeListener(java.lang.String propertyName, java.beans.PropertyChangeListener listener)Adds a PropertyChangeListener to the listener list for a specific
property. The specified property may be user-defined, or one of the
following:
- this Component's font ("font")
- this Component's background color ("background")
- this Component's foreground color ("foreground")
- this Component's focusability ("focusable")
- this Component's focus traversal keys enabled state
("focusTraversalKeysEnabled")
- this Component's Set of FORWARD_TRAVERSAL_KEYS
("forwardFocusTraversalKeys")
- this Component's Set of BACKWARD_TRAVERSAL_KEYS
("backwardFocusTraversalKeys")
- this Component's Set of UP_CYCLE_TRAVERSAL_KEYS
("upCycleFocusTraversalKeys")
Note that if this Component is inheriting a bound property, then no
event will be fired in response to a change in the inherited property.
If propertyName or listener is null,
no exception is thrown and no action is taken.
if (listener == null) {
return;
}
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(propertyName, listener);
|
| void | adjustListeningChildrenOnParent(long mask, int num)
if (parent != null) {
parent.adjustListeningChildren(mask, num);
}
|
| public void | applyComponentOrientation(java.awt.ComponentOrientation orientation)Sets the ComponentOrientation property of this component
and all components contained within it.
if (orientation == null) {
throw new NullPointerException();
}
setComponentOrientation(orientation);
|
| public boolean | areFocusTraversalKeysSet(int id)Returns whether the Set of focus traversal keys for the given focus
traversal operation has been explicitly defined for this Component. If
this method returns false, this Component is inheriting the
Set from an ancestor, or from the current KeyboardFocusManager.
if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH - 1) {
throw new IllegalArgumentException("invalid focus traversal key identifier");
}
return (focusTraversalKeys != null && focusTraversalKeys[id] != null);
|
| boolean | areInputMethodsEnabled()
// in 1.2, we assume input method support is required for all
// components that handle key events, but components can turn off
// input methods by calling enableInputMethods(false).
return ((eventMask & AWTEvent.INPUT_METHODS_ENABLED_MASK) != 0) &&
((eventMask & AWTEvent.KEY_EVENT_MASK) != 0 || keyListener != null);
|
| void | autoProcessMouseWheel(java.awt.event.MouseWheelEvent e)
|
| final void | autoTransferFocus(boolean clearOnFailure)
Component toTest = KeyboardFocusManager.
getCurrentKeyboardFocusManager().getFocusOwner();
if (toTest != this) {
if (toTest != null) {
toTest.autoTransferFocus(clearOnFailure);
}
return;
}
// the following code will execute only if this Component is the focus
// owner
if (!(isDisplayable() && isVisible() && isEnabled() && isFocusable())) {
doAutoTransfer(clearOnFailure);
return;
}
toTest = getParent();
while (toTest != null && !(toTest instanceof Window)) {
if (!(toTest.isDisplayable() && toTest.isVisible() &&
(toTest.isEnabled() || toTest.isLightweight()))) {
doAutoTransfer(clearOnFailure);
return;
}
toTest = toTest.getParent();
}
|
| public java.awt.Rectangle | bounds()
return new Rectangle(x, y, width, height);
|
| final boolean | canBeFocusOwner()Checks that this component meets the prerequesites to be focus owner:
- it is enabled, visible, focusable
- it's parents are all enabled and showing
- top-level window is focusable
- if focus cycle root has DefaultFocusTraversalPolicy then it also checks that this policy accepts
this component as focus owner
// - it is enabled, visible, focusable
if (!(isEnabled() && isDisplayable() && isVisible() && isFocusable())) {
return false;
}
// - it's parents are all enabled and showing
synchronized(getTreeLock()) {
if (parent != null) {
return parent.canContainFocusOwner(this);
}
}
return true;
|
| void | checkGD(java.lang.String stringID)Checks that this component's GraphicsDevice
idString matches the string argument.
if (graphicsConfig != null) {
if (!graphicsConfig.getDevice().getIDstring().equals(stringID)) {
throw new IllegalArgumentException(
"adding a container to a container on a different GraphicsDevice");
}
}
|
| public int | checkImage(java.awt.Image image, java.awt.image.ImageObserver observer)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.
return checkImage(image, -1, -1, observer);
|
| public int | checkImage(java.awt.Image image, int width, int height, java.awt.image.ImageObserver observer)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.
ComponentPeer peer = this.peer;
if (peer instanceof LightweightPeer) {
return (parent != null)
? parent.checkImage(image, width, height, observer)
: getToolkit().checkImage(image, width, height, observer);
} else {
return (peer != null)
? peer.checkImage(image, width, height, observer)
: getToolkit().checkImage(image, width, height, observer);
}
|
| boolean | checkWindowClosingException()
if (windowClosingException != null) {
if (this instanceof Dialog) {
((Dialog)this).interruptBlocking();
} else {
windowClosingException.fillInStackTrace();
windowClosingException.printStackTrace();
windowClosingException = null;
}
return true;
}
return false;
|
| void | clearCurrentFocusCycleRootOnHide()
/* do nothing */
|
| void | clearMostRecentFocusOwnerOnHide()
KeyboardFocusManager.clearMostRecentFocusOwner(this);
|
| protected java.awt.AWTEvent | coalesceEvents(java.awt.AWTEvent existingEvent, java.awt.AWTEvent newEvent)Potentially coalesce an event being posted with an existing
event. This method is called by EventQueue.postEvent
if an event with the same ID as the event to be posted is found in
the queue (both events must have this component as their source).
This method either returns a coalesced event which replaces
the existing event (and the new event is then discarded), or
null to indicate that no combining should be done
(add the second event to the end of the queue). Either event
parameter may be modified and returned, as the other one is discarded
unless null is returned.
This implementation of coalesceEvents coalesces
two event types: mouse move (and drag) events,
and paint (and update) events.
For mouse move events the last event is always returned, causing
intermediate moves to be discarded. For paint events, the new
event is coalesced into a complex RepaintArea in the peer.
The new AWTEvent is always returned.
int id = existingEvent.getID();
if (dbg.on) {
dbg.assertion(id == newEvent.getID() &&
existingEvent.getSource().equals(newEvent.getSource()));
}
switch (id) {
case Event.MOUSE_MOVE:
case Event.MOUSE_DRAG: {
MouseEvent e = (MouseEvent)existingEvent;
if (e.getModifiers() == ((MouseEvent)newEvent).getModifiers()) {
// Just return the newEvent, causing the old to be
// discarded.
return newEvent;
}
break;
}
case PaintEvent.PAINT:
case PaintEvent.UPDATE: {
if(peer != null && !(peer instanceof LightweightPeer)) {
// EventQueue.postEvent should use peer.coalescePaintEvent
return newEvent;
}
// This approach to coalescing paint events seems to be
// better than any heuristic for unioning rectangles.
PaintEvent existingPaintEvent = (PaintEvent) existingEvent;
PaintEvent newPaintEvent = (PaintEvent) newEvent;
Rectangle existingRect = existingPaintEvent.getUpdateRect();
Rectangle newRect = newPaintEvent.getUpdateRect();
if (dbg.on) {
dbg.println("Component::coalesceEvents : newEvent : nullPeer : x = " +
newRect.x + " y = " + newRect.y + " width = " + newRect.width +
" height = " + newRect.height);
}
if (existingRect.contains(newRect)) {
return existingEvent;
}
if (newRect.contains(existingRect)) {
return newEvent;
}
break;
}
}
return null;
|
| java.lang.String | constructComponentName()Constructs a name for this component. Called by getName
when the name is null.
return null; // For strict compliance with prior platform versions, a Component
// that doesn't set its name should return null from
// getName()
|
| public boolean | contains(int x, int y)Checks whether this component "contains" the specified point,
where x and y are defined to be
relative to the coordinate system of this component.
return inside(x, y);
|
| public boolean | contains(java.awt.Point p)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.
return contains(p.x, p.y);
|
| boolean | containsFocus()
return isFocusOwner();
|
| int | countHierarchyMembers()
return 1;
|
| void | createBufferStrategy(int numBuffers)Creates a new strategy for multi-buffering on this component.
Multi-buffering is useful for rendering performance. This method
attempts to create the best strategy available with the number of
buffers supplied. It will always create a BufferStrategy
with that number of buffers.
A page-flipping strategy is attempted first, then a blitting strategy
using accelerated buffers. Finally, an unaccelerated blitting
strategy is used.
Each time this method is called,
the existing buffer strategy for this component is discarded.
BufferCapabilities bufferCaps;
if (numBuffers > 1) {
// Try to create a page-flipping strategy
bufferCaps = new BufferCapabilities(
new ImageCapabilities(true), new ImageCapabilities(true),
BufferCapabilities.FlipContents.UNDEFINED);
try {
createBufferStrategy(numBuffers, bufferCaps);
return; // Success
} catch (AWTException e) {
// Failed
}
}
// Try a blitting (but still accelerated) strategy
bufferCaps = new BufferCapabilities(
new ImageCapabilities(true), new ImageCapabilities(true), null);
try {
createBufferStrategy(numBuffers, bufferCaps);
return; // Success
} catch (AWTException e) {
// Failed
}
// Try an unaccelerated blitting strategy
bufferCaps = new BufferCapabilities(
new ImageCapabilities(false), new ImageCapabilities(false), null);
try {
createBufferStrategy(numBuffers, bufferCaps);
return; // Success
} catch (AWTException e) {
// Failed
}
// Code should never reach here (an unaccelerated blitting
// strategy should always work)
throw new InternalError("Could not create a buffer strategy");
|
| void | createBufferStrategy(int numBuffers, java.awt.BufferCapabilities caps)Creates a new strategy for multi-buffering on this component with the
required buffer capabilities. This is useful, for example, if only
accelerated memory or page flipping is desired (as specified by the
buffer capabilities).
Each time this method
is called, the existing buffer strategy for this component is discarded.
// Check arguments
if (numBuffers < 1) {
throw new IllegalArgumentException(
"Number of buffers must be at least 1");
}
if (caps == null) {
throw new IllegalArgumentException("No capabilities specified");
}
// Destroy old buffers
if (bufferStrategy instanceof FlipBufferStrategy) {
((FlipBufferStrategy)bufferStrategy).destroyBuffers();
}
if (numBuffers == 1) {
bufferStrategy = new SingleBufferStrategy(caps);
} else {
// assert numBuffers > 1;
if (caps.isPageFlipping()) {
bufferStrategy = new FlipBufferStrategy(numBuffers, caps);
} else {
bufferStrategy = new BltBufferStrategy(numBuffers, caps);
}
}
|
| int | createHierarchyEvents(int id, java.awt.Component changed, java.awt.Container changedParent, long changeFlags, boolean enabledOnToolkit)
switch (id) {
case HierarchyEvent.HIERARCHY_CHANGED:
if (hierarchyListener != null ||
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 ||
enabledOnToolkit) {
HierarchyEvent e = new HierarchyEvent(this, id, changed,
changedParent,
changeFlags);
dispatchEvent(e);
return 1;
}
break;
case HierarchyEvent.ANCESTOR_MOVED:
case HierarchyEvent.ANCESTOR_RESIZED:
if (dbg.on) {
dbg.assertion(changeFlags == 0);
}
if (hierarchyBoundsListener != null ||
(eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 ||
enabledOnToolkit) {
HierarchyEvent e = new HierarchyEvent(this, id, changed,
changedParent);
dispatchEvent(e);
return 1;
}
break;
default:
if (dbg.on) {
dbg.assertion(false);
}
break;
}
return 0;
|
| public java.awt.Image | createImage(java.awt.image.ImageProducer producer)Creates an image from the specified image producer.
ComponentPeer peer = this.peer;
if ((peer != null) && ! (peer instanceof LightweightPeer)) {
return peer.createImage(producer);
}
return getToolkit().createImage(producer);
|
| public java.awt.Image | createImage(int width, int height)Creates an off-screen drawable image
to be used for double buffering.
ComponentPeer peer = this.peer;
if (peer instanceof LightweightPeer) {
if (parent != null) { return parent.createImage(width, height); }
else { return null;}
} else {
return (peer != null) ? peer.createImage(width, height) : null;
}
|
| public java.awt.image.VolatileImage | createVolatileImage(int width, int height)Creates a volatile off-screen drawable image
to be used for double buffering.
ComponentPeer peer = this.peer;
if (peer instanceof LightweightPeer) {
if (parent != null) {
return parent.createVolatileImage(width, height);
}
else { return null;}
} else {
return (peer != null) ?
peer.createVolatileImage(width, height) : null;
}
|
| public java.awt.image.VolatileImage | createVolatileImage(int width, int height, java.awt.ImageCapabilities caps)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.
// REMIND : check caps
return createVolatileImage(width, height);
|
| public void | deliverEvent(java.awt.Event e)
postEvent(e);
|
| public void | disable()
if (enabled) {
KeyboardFocusManager.clearMostRecentFocusOwner(this);
synchronized (getTreeLock()) {
enabled = false;
if (isFocusOwner()) {
// Don't clear the global focus owner. If transferFocus
// fails, we want the focus to stay on the disabled
// Component so that keyboard traversal, et. al. still
// makes sense to the user.
autoTransferFocus(false);
}
ComponentPeer peer = this.peer;
if (peer != null) {
peer.disable();
if (visible) {
updateCursorImmediately();
}
}
}
if (accessibleContext != null) {
accessibleContext.firePropertyChange(
AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
null, AccessibleState.ENABLED);
}
}
|
| protected final void | disableEvents(long eventsToDisable)Disables the events defined by the specified event mask parameter
from being delivered to this component.
long notifyAncestors = 0;
synchronized (this) {
if ((eventsToDisable & AWTEvent.HIERARCHY_EVENT_MASK) != 0 &&
hierarchyListener == null &&
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0) {
notifyAncestors |= AWTEvent.HIERARCHY_EVENT_MASK;
}
if ((eventsToDisable & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK)!=0 &&
hierarchyBoundsListener == null &&
(eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0) {
notifyAncestors |= AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK;
}
eventMask &= ~eventsToDisable;
}
if (notifyAncestors != 0) {
synchronized (getTreeLock()) {
adjustListeningChildrenOnParent(notifyAncestors, -1);
}
}
|
| public final void | dispatchEvent(java.awt.AWTEvent e)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.
dispatchEventImpl(e);
|
| void | dispatchEventImpl(java.awt.AWTEvent e)
int id = e.getID();
// Check that this component belongs to this app-context
AppContext compContext = appContext;
if (compContext != null && !compContext.equals(AppContext.getAppContext())) {
log.fine("Event " + e + " is being dispatched on the wrong AppContext");
}
/*
* 0. Set timestamp and modifiers of current event.
*/
EventQueue.setCurrentEventAndMostRecentTime(e);
/*
* 1. Pre-dispatchers. Do any necessary retargeting/reordering here
* before we notify AWTEventListeners.
*/
if (e instanceof SunDropTargetEvent) {
((SunDropTargetEvent)e).dispatch();
return;
}
if (!e.focusManagerIsDispatching) {
// Invoke the private focus retargeting method which provides
// lightweight Component support
if (e.isPosted) {
e = KeyboardFocusManager.retargetFocusEvent(e);
e.isPosted = true;
}
// Now, with the event properly targeted to a lightweight
// descendant if necessary, invoke the public focus retargeting
// and dispatching function
if (KeyboardFocusManager.getCurrentKeyboardFocusManager().
dispatchEvent(e))
{
return;
}
}
if (e instanceof FocusEvent && focusLog.isLoggable(Level.FINE)) {
focusLog.fine("" + e);
}
// MouseWheel may need to be retargeted here so that
// AWTEventListener sees the event go to the correct
// Component. If the MouseWheelEvent needs to go to an ancestor,
// the event is dispatched to the ancestor, and dispatching here
// stops.
if (id == MouseEvent.MOUSE_WHEEL &&
(!eventTypeEnabled(id)) &&
(peer != null && !peer.handlesWheelScrolling()) &&
(dispatchMouseWheelToAncestor((MouseWheelEvent)e)))
{
return;
}
/*
* 2. Allow the Toolkit to pass this to AWTEventListeners.
*/
Toolkit toolkit = Toolkit.getDefaultToolkit();
toolkit.notifyAWTEventListeners(e);
/*
* 3. If no one has consumed a key event, allow the
* KeyboardFocusManager to process it.
*/
if (!e.isConsumed()) {
if (e instanceof java.awt.event.KeyEvent) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().
processKeyEvent(this, (KeyEvent)e);
if (e.isConsumed()) {
return;
}
}
}
/*
* 4. Allow input methods to process the event
*/
if (areInputMethodsEnabled()
&& (
// We need to pass on InputMethodEvents since some host
// input method adapters send them through the Java
// event queue instead of directly to the component,
// and the input context also handles the Java composition window
((e instanceof InputMethodEvent) && !(this instanceof CompositionArea))
||
// Otherwise, we only pass on input and focus events, because
// a) input methods shouldn't know about semantic or component-level events
// b) passing on the events takes time
// c) isConsumed() is always true for semantic events.
(e instanceof InputEvent) || (e instanceof FocusEvent))) {
InputContext inputContext = getInputContext();
if (inputContext != null) {
inputContext.dispatchEvent(e);
if (e.isConsumed()) {
if (e instanceof FocusEvent && focusLog.isLoggable(Level.FINER)) {
focusLog.finer("3579: Skipping " + e);
}
return;
}
}
}
/*
* 5. Pre-process any special events before delivery
*/
switch(id) {
// Handling of the PAINT and UPDATE events is now done in the
// peer's handleEvent() method so the background can be cleared
// selectively for non-native components on Windows only.
// - Fred.Ecks@Eng.sun.com, 5-8-98
case KeyEvent.KEY_PRESSED:
case KeyEvent.KEY_RELEASED:
Container p = (Container)((this instanceof Container) ? this : parent);
if (p != null) {
p.preProcessKeyEvent((KeyEvent)e);
if (e.isConsumed()) {
return;
}
}
break;
case WindowEvent.WINDOW_CLOSING:
if (toolkit instanceof WindowClosingListener) {
windowClosingException = ((WindowClosingListener)
toolkit).windowClosingNotify((WindowEvent)e);
if (checkWindowClosingException()) {
return;
}
}
break;
default:
break;
}
/*
* 6. Deliver event for normal processing
*/
if (newEventsOnly) {
// Filtering needs to really be moved to happen at a lower
// level in order to get maximum performance gain; it is
// here temporarily to ensure the API spec is honored.
//
if (eventEnabled(e)) {
processEvent(e);
}
} else if (id == MouseEvent.MOUSE_WHEEL) {
// newEventsOnly will be false for a listenerless ScrollPane, but
// MouseWheelEvents still need to be dispatched to it so scrolling
// can be done.
autoProcessMouseWheel((MouseWheelEvent)e);
} else if (!(e instanceof MouseEvent && !postsOldMouseEvents())) {
//
// backward compatibility
//
Event olde = e.convertToOld();
if (olde != null) {
int key = olde.key;
int modifiers = olde.modifiers;
postEvent(olde);
if (olde.isConsumed()) {
e.consume();
}
// if target changed key or modifier values, copy them
// back to original event
//
switch(olde.id) {
case Event.KEY_PRESS:
case Event.KEY_RELEASE:
case Event.KEY_ACTION:
case Event.KEY_ACTION_RELEASE:
if (olde.key != key) {
((KeyEvent)e).setKeyChar(olde.getKeyEventChar());
}
if (olde.modifiers != modifiers) {
((KeyEvent)e).setModifiers(olde.modifiers);
}
break;
default:
break;
}
}
}
/*
* 8. Special handling for 4061116 : Hook for browser to close modal
* dialogs.
*/
if (id == WindowEvent.WINDOW_CLOSING && !e.isConsumed()) {
if (toolkit instanceof WindowClosingListener) {
windowClosingException =
((WindowClosingListener)toolkit).
windowClosingDelivered((WindowEvent)e);
if (checkWindowClosingException()) {
return;
}
}
}
/*
* 9. Allow the peer to process the event.
* Except KeyEvents, they will be processed by peer after
* all KeyEventPostProcessors
* (see DefaultKeyboardFocusManager.dispatchKeyEvent())
*/
if (!(e instanceof KeyEvent)) {
ComponentPeer tpeer = peer;
if (e instanceof FocusEvent && (tpeer == null || tpeer instanceof LightweightPeer)) {
// if focus owner is lightweight then its native container
// processes event
Component source = (Component)e.getSource();
if (source != null) {
Container target = source.getNativeContainer();
if (target != null) {
tpeer = target.getPeer();
}
}
}
if (tpeer != null) {
tpeer.handleEvent(e);
}
}
|
| boolean | dispatchMouseWheelToAncestor(java.awt.event.MouseWheelEvent e)
int newX, newY;
newX = e.getX() + getX(); // Coordinates take into account at least
newY = e.getY() + getY(); // the cursor's position relative to this
// Component (e.getX()), and this Component's
// position relative to its parent.
MouseWheelEvent newMWE;
if (dbg.on) {
dbg.println("Component.dispatchMouseWheelToAncestor");
dbg.println("orig event src is of " + e.getSource().getClass());
}
/* parent field for Window refers to the owning Window.
* MouseWheelEvents should NOT be propagated into owning Windows
*/
synchronized (getTreeLock()) {
Container anc = getParent();
while (anc != null && !anc.eventEnabled(e)) {
// fix coordinates to be relative to new event source
newX += anc.getX();
newY += anc.getY();
if (!(anc instanceof Window)) {
anc = anc.getParent();
}
else {
break;
}
}
if (dbg.on) dbg.println("new event src is " + anc.getClass());
if (anc != null && anc.eventEnabled(e)) {
// Change event to be from new source, with new x,y
// For now, just create a new event - yucky
newMWE = new MouseWheelEvent(anc, // new source
e.getID(),
e.getWhen(),
e.getModifiers(),
newX, // x relative to new source
newY, // y relative to new source
e.getClickCount(),
e.isPopupTrigger(),
e.getScrollType(),
e.getScrollAmount(),
e.getWheelRotation());
((AWTEvent)e).copyPrivateDataInto(newMWE);
anc.dispatchEventImpl(newMWE);
}
}
return true;
|
| private void | doAutoTransfer(boolean clearOnFailure)
if (clearOnFailure) {
if (!nextFocusHelper()) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().
clearGlobalFocusOwner();
}
} else {
transferFocus();
}
|
| public void | doLayout()Prompts the layout manager to lay out this component. This is
usually called when the component (more specifically, container)
is validated.
layout();
|
| private void | doSwingSerialization()This hack is for Swing serialization. It will invoke
the Swing package private method compWriteObjectNotify.
Package swingPackage = Package.getPackage("javax.swing");
// For Swing serialization to correctly work Swing needs to
// be notified before Component does it's serialization. This
// hack accomodates this.
//
// Swing classes MUST be loaded by the bootstrap class loader,
// otherwise we don't consider them.
for (Class klass = Component.this.getClass(); klass != null;
klass = klass.getSuperclass()) {
if (klass.getPackage() == swingPackage &&
klass.getClassLoader() == null) {
final Class swingClass = klass;
// Find the first override of the compWriteObjectNotify method
Method[] methods = (Method[])AccessController.doPrivileged(
new PrivilegedAction() {
public Object run() {
return swingClass.getDeclaredMethods();
}
});
for (int counter = methods.length - 1; counter >= 0;
counter--) {
final Method method = methods[counter];
if (method.getName().equals("compWriteObjectNotify")){
// We found it, use doPrivileged to make it accessible
// to use.
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
method.setAccessible(true);
return null;
}
});
// Invoke the method
try {
method.invoke(this, null);
} catch (IllegalAccessException iae) {
} catch (InvocationTargetException ite) {
}
// We're done, bail.
return;
}
}
}
}
|
| public void | enable()
if (!enabled) {
synchronized (getTreeLock()) {
enabled = true;
ComponentPeer peer = this.peer;
if (peer != null) {
peer.enable();
if (visible) {
updateCursorImmediately();
}
}
}
if (accessibleContext != null) {
accessibleContext.firePropertyChange(
AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
null, AccessibleState.ENABLED);
}
}
|
| public void | enable(boolean b)
if (b) {
enable();
} else {
disable();
}
|
| protected final void | enableEvents(long eventsToEnable)Enables the events defined by the specified event mask parameter
to be delivered to this component.
Event types are automatically enabled when a listener for
that event type is added to the component.
This method only needs to be invoked by subclasses of
Component which desire to have the specified event
types delivered to processEvent regardless of whether
or not a listener is registered.
long notifyAncestors = 0;
synchronized (this) {
if ((eventsToEnable & AWTEvent.HIERARCHY_EVENT_MASK) != 0 &&
hierarchyListener == null &&
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) == 0) {
notifyAncestors |= AWTEvent.HIERARCHY_EVENT_MASK;
}
if ((eventsToEnable & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 &&
hierarchyBoundsListener == null &&
(eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) == 0) {
notifyAncestors |= AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK;
}
eventMask |= eventsToEnable;
newEventsOnly = true;
}
// if this is a lightweight component, enable mouse events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(eventMask);
}
if (notifyAncestors != 0) {
synchronized (getTreeLock()) {
adjustListeningChildrenOnParent(notifyAncestors, 1);
}
}
|
| public void | enableInputMethods(boolean enable)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.
if (enable) {
if ((eventMask & AWTEvent.INPUT_METHODS_ENABLED_MASK) != 0)
return;
// If this component already has focus, then activate the
// input method by dispatching a synthesized focus gained
// event.
if (isFocusOwner()) {
InputContext inputContext = getInputContext();
if (inputContext != null) {
FocusEvent focusGainedEvent =
new FocusEvent(this, FocusEvent.FOCUS_GAINED);
inputContext.dispatchEvent(focusGainedEvent);
}
}
eventMask |= AWTEvent.INPUT_METHODS_ENABLED_MASK;
} else {
if ((eventMask & AWTEvent.INPUT_METHODS_ENABLED_MASK) != 0) {
InputContext inputContext = getInputContext();
if (inputContext != null) {
inputContext.endComposition();
inputContext.removeNotify(this);
}
}
eventMask &= ~AWTEvent.INPUT_METHODS_ENABLED_MASK;
}
|
| boolean | eventEnabled(java.awt.AWTEvent e)
return eventTypeEnabled(e.id);
|
| boolean | eventTypeEnabled(int type)
switch(type) {
case ComponentEvent.COMPONENT_MOVED:
case ComponentEvent.COMPONENT_RESIZED:
case ComponentEvent.COMPONENT_SHOWN:
case ComponentEvent.COMPONENT_HIDDEN:
if ((eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 ||
componentListener != null) {
return true;
}
break;
case FocusEvent.FOCUS_GAINED:
case FocusEvent.FOCUS_LOST:
if ((eventMask & AWTEvent.FOCUS_EVENT_MASK) != 0 ||
focusListener != null) {
return true;
}
break;
case KeyEvent.KEY_PRESSED:
case KeyEvent.KEY_RELEASED:
case KeyEvent.KEY_TYPED:
if ((eventMask & AWTEvent.KEY_EVENT_MASK) != 0 ||
keyListener != null) {
return true;
}
break;
case MouseEvent.MOUSE_PRESSED:
case MouseEvent.MOUSE_RELEASED:
case MouseEvent.MOUSE_ENTERED:
case MouseEvent.MOUSE_EXITED:
case MouseEvent.MOUSE_CLICKED:
if ((eventMask & AWTEvent.MOUSE_EVENT_MASK) != 0 ||
mouseListener != null) {
return true;
}
break;
case MouseEvent.MOUSE_MOVED:
case MouseEvent.MOUSE_DRAGGED:
if ((eventMask & AWTEvent.MOUSE_MOTION_EVENT_MASK) != 0 ||
mouseMotionListener != null) {
return true;
}
break;
case MouseEvent.MOUSE_WHEEL:
if ((eventMask & AWTEvent.MOUSE_WHEEL_EVENT_MASK) != 0 ||
mouseWheelListener != null) {
return true;
}
break;
case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
case InputMethodEvent.CARET_POSITION_CHANGED:
if ((eventMask & AWTEvent.INPUT_METHOD_EVENT_MASK) != 0 ||
inputMethodListener != null) {
return true;
}
break;
case HierarchyEvent.HIERARCHY_CHANGED:
if ((eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 ||
hierarchyListener != null) {
return true;
}
break;
case HierarchyEvent.ANCESTOR_MOVED:
case HierarchyEvent.ANCESTOR_RESIZED:
if ((eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0 ||
hierarchyBoundsListener != null) {
return true;
}
break;
case ActionEvent.ACTION_PERFORMED:
if ((eventMask & AWTEvent.ACTION_EVENT_MASK) != 0) {
return true;
}
break;
case TextEvent.TEXT_VALUE_CHANGED:
if ((eventMask & AWTEvent.TEXT_EVENT_MASK) != 0) {
return true;
}
break;
case ItemEvent.ITEM_STATE_CHANGED:
if ((eventMask & AWTEvent.ITEM_EVENT_MASK) != 0) {
return true;
}
break;
case AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED:
if ((eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0) {
return true;
}
break;
default:
break;
}
//
// Always pass on events defined by external programs.
//
if (type > AWTEvent.RESERVED_ID_MAX) {
return true;
}
return false;
|
| java.awt.Component | findUnderMouseInWindow(java.awt.PointerInfo pi)Assuming that mouse location is stored in PointerInfo passed
to this method, it finds a Component that is in the same
Window as this Component and is located under the mouse pointer.
If no such Component exists, null is returned.
NOTE: this method should be called under the protection of
tree lock, as it is done in Component.getMousePosition() and
Container.getMousePosition(boolean).
if (!isShowing()) {
return null;
}
Window win = getContainingWindow();
if (!Toolkit.getDefaultToolkit().getMouseInfoPeer().isWindowUnderMouse(win)) {
return null;
}
final boolean INCLUDE_DISABLED = true;
Point relativeToWindow = win.pointRelativeToComponent(pi.getLocation());
Component inTheSameWindow = win.findComponentAt(relativeToWindow.x,
relativeToWindow.y,
INCLUDE_DISABLED);
return inTheSameWindow;
|
| protected void | firePropertyChange(java.lang.String propertyName, java.lang.Object oldValue, java.lang.Object newValue)Support for reporting bound property changes for Object properties.
This method can be called when a bound property has changed and it will
send the appropriate PropertyChangeEvent to any registered
PropertyChangeListeners.
PropertyChangeSupport changeSupport = this.changeSupport;
if (changeSupport == null ||
(oldValue != null && newValue != null && oldValue.equals(newValue))) {
return;
}
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
|
| protected void | firePropertyChange(java.lang.String propertyName, boolean oldValue, boolean newValue)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.
PropertyChangeSupport changeSupport = this.changeSupport;
if (changeSupport == null || oldValue == newValue) {
return;
}
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
|
| protected void | firePropertyChange(java.lang.String propertyName, int oldValue, int newValue)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.
PropertyChangeSupport changeSupport = this.changeSupport;
if (changeSupport == null || oldValue == newValue) {
return;
}
changeSupport.firePropertyChange(propertyName, oldValue, newValue);
|
| public void | firePropertyChange(java.lang.String propertyName, byte oldValue, byte newValue)Reports a bound property change.
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Byte(oldValue), new Byte(newValue));
|
| public void | firePropertyChange(java.lang.String propertyName, char oldValue, char newValue)Reports a bound property change.
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Character(oldValue), new Character(newValue));
|
| public void | firePropertyChange(java.lang.String propertyName, short oldValue, short newValue)Reports a bound property change.
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Short(oldValue), new Short(newValue));
|
| public void | firePropertyChange(java.lang.String propertyName, long oldValue, long newValue)Reports a bound property change.
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Long(oldValue), new Long(newValue));
|
| public void | firePropertyChange(java.lang.String propertyName, float oldValue, float newValue)Reports a bound property change.
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Float(oldValue), new Float(newValue));
|
| public void | firePropertyChange(java.lang.String propertyName, double oldValue, double newValue)Reports a bound property change.
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Double(oldValue), new Double(newValue));
|
| public javax.accessibility.AccessibleContext | getAccessibleContext()Gets the AccessibleContext associated
with this Component.
The method implemented by this base
class returns null. Classes that extend Component
should implement this method to return the
AccessibleContext associated with the subclass.
return accessibleContext;
|
| int | getAccessibleIndexInParent()Gets the index of this object in its accessible parent.
If this object does not have an accessible parent, returns
-1.
synchronized (getTreeLock()) {
int index = -1;
Container parent = this.getParent();
if (parent != null && parent instanceof Accessible) {
Component ca[] = parent.getComponents();
for (int i = 0; i < ca.length; i++) {
if (ca[i] instanceof Accessible) {
index++;
}
if (this.equals(ca[i])) {
return index;
}
}
}
return -1;
}
|
| javax.accessibility.AccessibleStateSet | getAccessibleStateSet()Gets the current state set of this object.
synchronized (getTreeLock()) {
AccessibleStateSet states = new AccessibleStateSet();
if (this.isEnabled()) {
states.add(AccessibleState.ENABLED);
}
if (this.isFocusTraversable()) {
states.add(AccessibleState.FOCUSABLE);
}
if (this.isVisible()) {
states.add(AccessibleState.VISIBLE);
}
if (this.isShowing()) {
states.add(AccessibleState.SHOWING);
}
if (this.isFocusOwner()) {
states.add(AccessibleState.FOCUSED);
}
if (this instanceof Accessible) {
AccessibleContext ac = ((Accessible) this).getAccessibleContext();
if (ac != null) {
Accessible ap = ac.getAccessibleParent();
if (ap != null) {
AccessibleContext pac = ap.getAccessibleContext();
if (pac != null) {
AccessibleSelection as = pac.getAccessibleSelection();
if (as != null) {
states.add(AccessibleState.SELECTABLE);
int i = ac.getAccessibleIndexInParent();
if (i >= 0) {
if (as.isAccessibleChildSelected(i)) {
states.add(AccessibleState.SELECTED);
}
}
}
}
}
}
}
if (this instanceof javax.swing.JComponent) {
if (((javax.swing.JComponent) this).isOpaque()) {
states.add(AccessibleState.OPAQUE);
}
}
return states;
}
|
| public float | getAlignmentX()Returns the alignment along the x axis. This specifies how
the component would like to be aligned relative to other
components. The value should be a number between 0 and 1
where 0 represents alignment along the origin, 1 is aligned
the furthest away from the origin, 0.5 is centered, etc.
return CENTER_ALIGNMENT;
|
| public float | getAlignmentY()Returns the alignment along the y axis. This specifies how
the component would like to be aligned relative to other
components. The value should be a number between 0 and 1
where 0 represents alignment along the origin, 1 is aligned
the furthest away from the origin, 0.5 is centered, etc.
return CENTER_ALIGNMENT;
|
| java.awt.Image | getBackBuffer()
if (bufferStrategy != null) {
if (bufferStrategy instanceof BltBufferStrategy) {
BltBufferStrategy bltBS = (BltBufferStrategy)bufferStrategy;
return bltBS.getBackBuffer();
} else if (bufferStrategy instanceof FlipBufferStrategy) {
FlipBufferStrategy flipBS = (FlipBufferStrategy)bufferStrategy;
return flipBS.getBackBuffer();
}
}
return null;
|
| public java.awt.Color | getBackground()Gets the background color of this component.
Color background = this.background;
if (background != null) {
return background;
}
Container parent = this.parent;
return (parent != null) ? parent.getBackground() : null;
|
| public java.awt.Rectangle | getBounds()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 bounds();
|
| public java.awt.Rectangle | getBounds(java.awt.Rectangle rv)Stores the bounds of this component into "return value" rv and
return 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.
if (rv == null) {
return new Rectangle(getX(), getY(), getWidth(), getHeight());
}
else {
rv.setBounds(getX(), getY(), getWidth(), getHeight());
return rv;
}
|
| int | getBoundsOp()Should only be used in subclass getBounds to check that part of bounds
is actualy changing
assert Thread.holdsLock(getTreeLock());
return boundsOp;
|
| java.awt.image.BufferStrategy | getBufferStrategy()
if (bufferStrategy == null) {
createBufferStrategy(1);
}
return bufferStrategy;
|
| public java.awt.image.ColorModel | getColorModel()Gets the instance of ColorModel used to display
the component on the output device.
ComponentPeer peer = this.peer;
if ((peer != null) && ! (peer instanceof LightweightPeer)) {
return peer.getColorModel();
} else if (GraphicsEnvironment.isHeadless()) {
return ColorModel.getRGBdefault();
} // else
return getToolkit().getColorModel();
|
| public java.awt.Component | getComponentAt(int x, int y)Determines if this component or one of its immediate
subcomponents contains the (x, y) location,
and if so, returns the containing component. This method only
looks one level deep. If the point (x, y) is
inside a subcomponent that itself has subcomponents, it does not
go looking down the subcomponent tree.
The locate method of Component simply
returns the component itself if the (x, y)
coordinate location is inside its bounding box, and null
otherwise.
return locate(x, y);
|
| public java.awt.Component | getComponentAt(java.awt.Point p)Returns the component or subcomponent that contains the
specified point.
return getComponentAt(p.x, p.y);
|
| public synchronized java.awt.event.ComponentListener[] | getComponentListeners()Returns an array of all the component listeners
registered on this component.
return (ComponentListener[]) (getListeners(ComponentListener.class));
|
| public java.awt.ComponentOrientation | getComponentOrientation()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.
return componentOrientation;
|
| java.awt.Window | getContainingWindow()Returns the Window ancestor of the component.
return getContainingWindow(this);
|
| static java.awt.Window | getContainingWindow(java.awt.Component comp)Returns the Window ancestor of the component comp.
while (comp != null && !(comp instanceof Window)) {
comp = comp.getParent();
}
return (Window)comp;
|
| public java.awt.Cursor | getCursor()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.
Cursor cursor = this.cursor;
if (cursor != null) {
return cursor;
}
Container parent = this.parent;
if (parent != null) {
return parent.getCursor();
} else {
return Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
}
|
| public synchronized java.awt.dnd.DropTarget | getDropTarget()Gets the DropTarget associated with this
Component. return dropTarget;
|
| public java.awt.Container | getFocusCycleRootAncestor()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.
Container rootAncestor = this.parent;
while (rootAncestor != null && !rootAncestor.isFocusCycleRoot()) {
rootAncestor = rootAncestor.parent;
}
return rootAncestor;
|
| public synchronized java.awt.event.FocusListener[] | getFocusListeners()Returns an array of all the focus listeners
registered on this component.
return (FocusListener[]) (getListeners(FocusListener.class));
|
| public java.util.Set | getFocusTraversalKeys(int id)Returns the Set of focus traversal keys for a given traversal operation
for this Component. (See
setFocusTraversalKeys for a full description of each key.)
If a Set of traversal keys has not been explicitly defined for this
Component, then this Component's parent's Set is returned. If no Set
has been explicitly defined for any of this Component's ancestors, then
the current KeyboardFocusManager's default Set is returned.
if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH - 1) {
throw new IllegalArgumentException("invalid focus traversal key identifier");
}
return getFocusTraversalKeys_NoIDCheck(id);
|
| public boolean | getFocusTraversalKeysEnabled()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 focusTraversalKeysEnabled;
|
| final java.util.Set | getFocusTraversalKeys_NoIDCheck(int id)
// Okay to return Set directly because it is an unmodifiable view
Set keystrokes = (focusTraversalKeys != null)
? focusTraversalKeys[id]
: null;
if (keystrokes != null) {
return keystrokes;
} else {
Container parent = this.parent;
if (parent != null) {
return parent.getFocusTraversalKeys(id);
} else {
return KeyboardFocusManager.getCurrentKeyboardFocusManager().
getDefaultFocusTraversalKeys(id);
}
}
|
| public java.awt.Font | getFont()Gets the font of this component.
return getFont_NoClientCode();
|
| public java.awt.FontMetrics | getFontMetrics(java.awt.Font font)Gets the font metrics for the specified font.
FontMetrics result = (FontMetrics) metrics.get(font);
if (result != null) {
return result;
}
// REMIND: PlatformFont flag should be obsolete soon...
if (sun.font.FontManager.usePlatformFontMetrics()) {
if (peer != null &&
!(peer instanceof LightweightPeer)) {
result = peer.getFontMetrics(font);
metrics.put(font, result);
return result;
}
}
if (parent != null) {
// These are the lines that cost the big dollars. Calling
// parent.getGraphics triggers the construcion (at great
// expense) of a new Graphics object that is then quickly
// discarded. - Graham
Graphics g = parent.getGraphics();
if (g != null) {
try {
result = g.getFontMetrics(font);
metrics.put(font, result);
return result;
} finally {
g.dispose();
}
}
}
result = getToolkit().getFontMetrics(font);
metrics.put(font, result);
return result;
|
| final java.awt.Font | getFont_NoClientCode()
Font font = this.font;
if (font != null) {
return font;
}
Container parent = this.parent;
return (parent != null) ? parent.getFont_NoClientCode() : null;
|
| public java.awt.Color | getForeground()Gets the foreground color of this component.
Color foreground = this.foreground;
if (foreground != null) {
return foreground;
}
Container parent = this.parent;
return (parent != null) ? parent.getForeground() : null;
|
| public java.awt.Graphics | getGraphics()Creates a graphics context for this component. This method will
return null if this component is currently not
displayable.
if (peer instanceof LightweightPeer) {
// This is for a lightweight component, need to
// translate coordinate spaces and clip relative
// to the parent.
if (parent == null) return null;
Graphics g = parent.getGraphics();
if (g == null) return null;
if (g instanceof ConstrainableGraphics) {
((ConstrainableGraphics) g).constrain(x, y, width, height);
} else {
g.translate(x,y);
g.setClip(0, 0, width, height);
}
g.setFont(getFont());
return g;
} else {
ComponentPeer peer = this.peer;
return (peer != null) ? peer.getGraphics() : null;
}
|
| public java.awt.GraphicsConfiguration | getGraphicsConfiguration()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.
synchronized(getTreeLock()) {
if (graphicsConfig != null) {
return graphicsConfig;
} else if (getParent() != null) {
return getParent().getGraphicsConfiguration();
} else {
return null;
}
}
|
| public int | getHeight()Returns the current height of this component.
This method is preferable to writing
component.getBounds().heightcomponent.getSize().height because it
doesn't cause any heap allocations.
return height;
|
| public synchronized java.awt.event.HierarchyBoundsListener[] | getHierarchyBoundsListeners()Returns an array of all the hierarchy bounds listeners
registered on this component.
return (HierarchyBoundsListener[])
(getListeners(HierarchyBoundsListener.class));
|
| public synchronized java.awt.event.HierarchyListener[] | getHierarchyListeners()Returns an array of all the hierarchy listeners
registered on this component.
return (HierarchyListener[])(getListeners(HierarchyListener.class));
|
| public boolean | getIgnoreRepaint()
return ignoreRepaint;
|
| public java.awt.im.InputContext | getInputContext()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.
Container parent = this.parent;
if (parent == null) {
return null;
} else {
return parent.getInputContext();
}
|
| public synchronized java.awt.event.InputMethodListener[] | getInputMethodListeners()Returns an array of all the input method listeners
registered on this component.
return (InputMethodListener[]) (getListeners(InputMethodListener.class));
|
| public java.awt.im.InputMethodRequests | getInputMethodRequests()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 null;
|
| public synchronized java.awt.event.KeyListener[] | getKeyListeners()Returns an array of all the key listeners
registered on this component.
return (KeyListener[]) (getListeners(KeyListener.class));
|
| public T[] | getListeners(java.lang.Class listenerType)Returns an array of all the objects currently registered
as FooListeners
upon this Component.
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
Component 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.
EventListener l = null;
if (listenerType == ComponentListener.class) {
l = componentListener;
} else if (listenerType == FocusListener.class) {
l = focusListener;
} else if (listenerType == HierarchyListener.class) {
l = hierarchyListener;
} else if (listenerType == HierarchyBoundsListener.class) {
l = hierarchyBoundsListener;
} else if (listenerType == KeyListener.class) {
l = keyListener;
} else if (listenerType == MouseListener.class) {
l = mouseListener;
} else if (listenerType == MouseMotionListener.class) {
l = mouseMotionListener;
} else if (listenerType == MouseWheelListener.class) {
l = mouseWheelListener;
} else if (listenerType == InputMethodListener.class) {
l = inputMethodListener;
} else if (listenerType == PropertyChangeListener.class) {
return (T[])getPropertyChangeListeners();
}
return AWTEventMulticaster.getListeners(l, listenerType);
|
| public java.util.Locale | getLocale()Gets the locale of this component.
Locale locale = this.locale;
if (locale != null) {
return locale;
}
Container parent = this.parent;
if (parent == null) {
throw new IllegalComponentStateException("This component must have a parent in order to determine its locale");
} else {
return parent.getLocale();
}
|
| public java.awt.Point | getLocation()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 location();
|
| public java.awt.Point | getLocation(java.awt.Point rv)Stores the x,y origin of this component into "return value" rv
and return 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.
if (rv == null) {
return new Point(getX(), getY());
}
else {
rv.setLocation(getX(), getY());
return rv;
}
|
| public java.awt.Point | getLocationOnScreen()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.
synchronized (getTreeLock()) {
return getLocationOnScreen_NoTreeLock();
}
|
| final java.awt.Point | getLocationOnScreen_NoTreeLock()
if (peer != null && isShowing()) {
if (peer instanceof LightweightPeer) {
// lightweight component location needs to be translated
// relative to a native component.
Container host = getNativeContainer();
Point pt = host.peer.getLocationOnScreen();
for(Component c = this; c != host; c = c.getParent()) {
pt.x += c.x;
pt.y += c.y;
}
return pt;
} else {
Point pt = peer.getLocationOnScreen();
return pt;
}
} else {
throw new IllegalComponentStateException("component must be showing on the screen to determine its location");
}
|
| public java.awt.Dimension | getMaximumSize()Gets the maximum size of this component.
if (isMaximumSizeSet()) {
return new Dimension(maxSize);
}
return new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
|
| public java.awt.Dimension | getMinimumSize()Gets the mininimum size of this component.
return minimumSize();
|
| public synchronized java.awt.event.MouseListener[] | getMouseListeners()Returns an array of all the mouse listeners
registered on this component.
return (MouseListener[]) (getListeners(MouseListener.class));
|
| public synchronized java.awt.event.MouseMotionListener[] | getMouseMotionListeners()Returns an array of all the mouse motion listeners
registered on this component.
return (MouseMotionListener[]) (getListeners(MouseMotionListener.class));
|
| public java.awt.Point | getMousePosition()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 {@link Container#getMousePosition(boolean)} 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.
if (GraphicsEnvironment.isHeadless()) {
throw new HeadlessException();
}
PointerInfo pi = (PointerInfo)java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction() {
public Object run() {
return MouseInfo.getPointerInfo();
}
}
);
synchronized (getTreeLock()) {
Component inTheSameWindow = findUnderMouseInWindow(pi);
if (!isSameOrAncestorOf(inTheSameWindow, true)) {
return null;
}
return pointRelativeToComponent(pi.getLocation());
}
|
| public synchronized java.awt.event.MouseWheelListener[] | getMouseWheelListeners()Returns an array of all the mouse wheel listeners
registered on this component.
return (MouseWheelListener[]) (getListeners(MouseWheelListener.class));
|
| public java.lang.String | getName()Gets the name of the component.
if (name == null && !nameExplicitlySet) {
synchronized(this) {
if (name == null && !nameExplicitlySet)
name = constructComponentName();
}
}
return name;
|
| java.awt.Container | getNativeContainer()
Container p = parent;
while (p != null && p.peer instanceof LightweightPeer) {
p = p.getParent();
}
return p;
|
| public java.awt.Container | getParent()Gets the parent of this component.
return getParent_NoClientCode();
|
| final java.awt.Container | getParent_NoClientCode()
return parent;
|
| public java.awt.peer.ComponentPeer | getPeer()
return peer;
|
| public java.awt.Dimension | getPreferredSize()Gets the preferred size of this component.
return preferredSize();
|
| public synchronized java.beans.PropertyChangeListener[] | getPropertyChangeListeners()Returns an array of all the property change listeners
registered on this component.
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners();
|
| public synchronized java.beans.PropertyChangeListener[] | getPropertyChangeListeners(java.lang.String propertyName)Returns an array of all the listeners which have been associated
with the named property.
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners(propertyName);
|
| public java.awt.Dimension | getSize()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 size();
|
| public java.awt.Dimension | getSize(java.awt.Dimension rv)Stores the width/height of this component into "return value" rv
and return 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.
if (rv == null) {
return new Dimension(getWidth(), getHeight());
}
else {
rv.setSize(getWidth(), getHeight());
return rv;
}
|
| public java.awt.Toolkit | getToolkit()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 getToolkitImpl();
|
| final java.awt.Toolkit | getToolkitImpl()
ComponentPeer peer = this.peer;
if ((peer != null) && ! (peer instanceof LightweightPeer)){
return peer.getToolkit();
}
Container parent = this.parent;
if (parent != null) {
return parent.getToolkitImpl();
}
return Toolkit.getDefaultToolkit();
|
| public final java.lang.Object | getTreeLock()Gets this component's locking object (the object that owns the thread
sychronization monitor) for AWT component-tree and layout
operations.
return LOCK;
|
| public int | getWidth()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 width;
|
| public int | getX()Returns the current x coordinate of the components origin.
This method is preferable to writing
component.getBounds().x,
or component.getLocation().x because it doesn't
cause any heap allocations.
return x;
|
| public int | getY()Returns the current y coordinate of the components origin.
This method is preferable to writing
component.getBounds().y,
or component.getLocation().y because it
doesn't cause any heap allocations.
return y;
|
| public boolean | gotFocus(java.awt.Event evt, java.lang.Object what)
return false;
|
| public boolean | handleEvent(java.awt.Event evt)
switch (evt.id) {
case Event.MOUSE_ENTER:
return mouseEnter(evt, evt.x, evt.y);
case Event.MOUSE_EXIT:
return mouseExit(evt, evt.x, evt.y);
case Event.MOUSE_MOVE:
return mouseMove(evt, evt.x, evt.y);
case Event.MOUSE_DOWN:
return mouseDown(evt, evt.x, evt.y);
case Event.MOUSE_DRAG:
return mouseDrag(evt, evt.x, evt.y);
case Event.MOUSE_UP:
return mouseUp(evt, evt.x, evt.y);
case Event.KEY_PRESS:
case Event.KEY_ACTION:
return keyDown(evt, evt.key);
case Event.KEY_RELEASE:
case Event.KEY_ACTION_RELEASE:
return keyUp(evt, evt.key);
case Event.ACTION_EVENT:
return action(evt, evt.arg);
case Event.GOT_FOCUS:
return gotFocus(evt, evt.arg);
case Event.LOST_FOCUS:
return lostFocus(evt, evt.arg);
}
return false;
|
| public boolean | hasFocus()Returns true if this Component is the
focus owner. This method is obsolete, and has been replaced by
isFocusOwner().
return (KeyboardFocusManager.getCurrentKeyboardFocusManager().
getFocusOwner() == this);
|
| public void | hide()
isPacked = false;
if (visible) {
clearCurrentFocusCycleRootOnHide();
clearMostRecentFocusOwnerOnHide();
synchronized (getTreeLock()) {
visible = false;
if (containsFocus()) {
autoTransferFocus(true);
}
ComponentPeer peer = this.peer;
if (peer != null) {
peer.hide();
createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED,
this, parent,
HierarchyEvent.SHOWING_CHANGED,
Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
if (peer instanceof LightweightPeer) {
repaint();
}
updateCursorImmediately();
}
if (componentListener != null ||
(eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 ||
Toolkit.enabledOnToolkit(AWTEvent.COMPONENT_EVENT_MASK)) {
ComponentEvent e = new ComponentEvent(this,
ComponentEvent.COMPONENT_HIDDEN);
Toolkit.getEventQueue().postEvent(e);
}
}
Container parent = this.parent;
if (parent != null) {
parent.invalidate();
}
}
|
| public boolean | imageUpdate(java.awt.Image img, int infoflags, int x, int y, int w, int h)Repaints the component when the image has changed.
This imageUpdate method of an ImageObserver
is called when more information about an
image which had been previously requested using an asynchronous
routine such as the drawImage method of
Graphics becomes available.
See the definition of imageUpdate for
more information on this method and its arguments.
The imageUpdate method of Component
incrementally draws an image on the component as more of the bits
of the image are available.
If the system property awt.image.incrementaldraw
is missing or has the value true, the image is
incrementally drawn. If the system property has any other value,
then the image is not drawn until it has been completely loaded.
Also, if incremental drawing is in effect, the value of the
system property awt.image.redrawrate is interpreted
as an integer to give the maximum redraw rate, in milliseconds. If
the system property is missing or cannot be interpreted as an
integer, the redraw rate is once every 100ms.
The interpretation of the x, y,
width, and height arguments depends on
the value of the infoflags argument.
int rate = -1;
if ((infoflags & (FRAMEBITS|ALLBITS)) != 0) {
rate = 0;
} else if ((infoflags & SOMEBITS) != 0) {
if (isInc) {
rate = incRate;
if (rate < 0) {
rate = 0;
}
}
}
if (rate >= 0) {
repaint(rate, 0, 0, width, height);
}
return (infoflags & (ALLBITS|ABORT)) == 0;
|
| private static native void | initIDs()Initialize JNI field and method IDs
|
| void | initializeFocusTraversalKeys()
focusTraversalKeys = new Set[3];
|
| public boolean | inside(int x, int y)
return (x >= 0) && (x < width) && (y >= 0) && (y < height);
|
| public void | invalidate()Invalidates this component. This component 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.
synchronized (getTreeLock()) {
/* Nullify cached layout and size information.
* For efficiency, propagate invalidate() upwards only if
* some other component hasn't already done so first.
*/
valid = false;
if (!isPreferredSizeSet()) {
prefSize = null;
}
if (!isMinimumSizeSet()) {
minSize = null;
}
if (!isMaximumSizeSet()) {
maxSize = null;
}
if (parent != null && parent.valid) {
parent.invalidate();
}
}
|
| public boolean | isBackgroundSet()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 (background != null);
|
| public boolean | isCursorSet()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 (cursor != null);
|
| public boolean | isDisplayable()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 getPeer() != null;
|
| public boolean | isDoubleBuffered()Returns true if this component is painted to an offscreen image
("buffer") that's copied to the screen later. Component
subclasses that support double buffering should override this
method to return true if double buffering is enabled.
return false;
|
| public boolean | isEnabled()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 isEnabledImpl();
|
| final boolean | isEnabledImpl()
return enabled;
|
| public boolean | isFocusCycleRoot(java.awt.Container container)Returns whether the specified Container 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.
Container rootAncestor = getFocusCycleRootAncestor();
return (rootAncestor == container);
|
| public boolean | isFocusOwner()Returns true if this Component is the
focus owner.
return hasFocus();
|
| public boolean | isFocusTraversable()Returns whether this Component can become the focus
owner.
if (isFocusTraversableOverridden == FOCUS_TRAVERSABLE_UNKNOWN) {
isFocusTraversableOverridden = FOCUS_TRAVERSABLE_DEFAULT;
}
return focusable;
|
| final boolean | isFocusTraversableOverridden()
return (isFocusTraversableOverridden != FOCUS_TRAVERSABLE_DEFAULT);
|
| public boolean | isFocusable()Returns whether this Component can be focused.
return isFocusTraversable();
|
| public boolean | isFontSet()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 (font != null);
|
| public boolean | isForegroundSet()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 (foreground != null);
|
| public boolean | isLightweight()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 getPeer() instanceof LightweightPeer;
|
| public boolean | isMaximumSizeSet()Returns true if the maximum size has been set to a non-null
value otherwise returns false.
return maxSizeSet;
|
| public boolean | isMinimumSizeSet()Returns whether or not setMinimumSize has been
invoked with a non-null value.
return minSizeSet;
|
| public boolean | isOpaque()Returns true if this component is completely opaque, returns
false by default.
An opaque component paints every pixel within its
rectangular region. A non-opaque component paints only some of
its pixels, allowing the pixels underneath it to "show through".
A component that does not fully paint its pixels therefore
provides a degree of transparency. Only lightweight
components can be transparent.
Subclasses that guarantee to always completely paint their
contents should override this method and return true. All
of the "heavyweight" AWT components are opaque.
if (getPeer() == null) {
return false;
}
else {
return !isLightweight();
}
|
| public boolean | isPreferredSizeSet()Returns true if the preferred size has been set to a
non-null value otherwise returns false.
return prefSizeSet;
|
| boolean | isRecursivelyVisible()Determines whether this component will be displayed on the screen
if it's displayable.
return visible && (parent == null || parent.isRecursivelyVisible());
|
| boolean | isSameOrAncestorOf(java.awt.Component comp, boolean allowChildren)Overridden in Container. Must be called under TreeLock.
return comp == this;
|
| public boolean | isShowing()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.
if (visible && (peer != null)) {
Container parent = this.parent;
return (parent == null) || parent.isShowing();
}
return false;
|
| public boolean | isValid()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 (peer != null) && valid;
|
| public boolean | isVisible()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 visible;
|
| public boolean | keyDown(java.awt.Event evt, int key)
return false;
|
| public boolean | keyUp(java.awt.Event evt, int key)
return false;
|
| public void | layout()
|
| void | lightweightPaint(java.awt.Graphics g)Simulates the peer callbacks into java.awt for painting of
lightweight Components.
paint(g);
|
| void | lightweightPrint(java.awt.Graphics g)Simulates the peer callbacks into java.awt for printing of
lightweight Components.
print(g);
|
| public void | list()Prints a listing of this component to the standard system output
stream System.out.
list(System.out, 0);
|
| public void | list(java.io.PrintStream out)Prints a listing of this component to the specified output
stream.
list(out, 0);
|
| public void | list(java.io.PrintStream out, int indent)Prints out a list, starting at the specified indentation, to the
specified print stream.
for (int i = 0 ; i < indent ; i++) {
out.print(" ");
}
out.println(this);
|
| public void | list(java.io.PrintWriter out)Prints a listing to the specified print writer.
list(out, 0);
|
| public void | list(java.io.PrintWriter out, int indent)Prints out a list, starting at the specified indentation, to
the specified print writer.
for (int i = 0 ; i < indent ; i++) {
out.print(" ");
}
out.println(this);
|
| public java.awt.Component | locate(int x, int y)
return contains(x, y) ? this : null;
|
| public java.awt.Point | location()
return new Point(x, y);
|
| public boolean | lostFocus(java.awt.Event evt, java.lang.Object what)
return false;
|
| public java.awt.Dimension | minimumSize()
/* Avoid grabbing the lock if a reasonable cached size value
* is available.
*/
Dimension dim = minSize;
if (dim == null || !(isMinimumSizeSet() || isValid())) {
synchronized (getTreeLock()) {
minSize = (peer != null) ?
peer.minimumSize() :
size();
dim = minSize;
}
}
return new Dimension(dim);
|
| public boolean | mouseDown(java.awt.Event evt, int x, int y)
return false;
|
| public boolean | mouseDrag(java.awt.Event evt, int x, int y)
return false;
|
| public boolean | mouseEnter(java.awt.Event evt, int x, int y)
return false;
|
| public boolean | mouseExit(java.awt.Event evt, int x, int y)
return false;
|
| public boolean | mouseMove(java.awt.Event evt, int x, int y)
return false;
|
| public boolean | mouseUp(java.awt.Event evt, int x, int y)
return false;
|
| public void | move(int x, int y)
synchronized(getTreeLock()) {
setBoundsOp(ComponentPeer.SET_LOCATION);
setBounds(x, y, width, height);
}
|
| public void | nextFocus()
nextFocusHelper();
|
| boolean | nextFocusHelper()
Container rootAncestor = getFocusCycleRootAncestor();
Component comp = this;
while (rootAncestor != null &&
!(rootAncestor.isShowing() &&
rootAncestor.isFocusable() &&
rootAncestor.isEnabled()))
{
comp = rootAncestor;
rootAncestor = comp.getFocusCycleRootAncestor();
}
if (rootAncestor != null) {
FocusTraversalPolicy policy =
rootAncestor.getFocusTraversalPolicy();
Component toFocus = policy.getComponentAfter(rootAncestor, comp);
if (toFocus == null) {
toFocus = policy.getDefaultComponent(rootAncestor);
}
if (toFocus != null) {
if (focusLog.isLoggable(Level.FINER)) focusLog.finer("Next component " + toFocus);
boolean res = toFocus.requestFocus(false);
if (focusLog.isLoggable(Level.FINER)) focusLog.finer("Request focus returned " + res);
return res;
}
}
return false;
|
| private void | notifyNewBounds(boolean resized, boolean moved)
if (componentListener != null
|| (eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0
|| Toolkit.enabledOnToolkit(AWTEvent.COMPONENT_EVENT_MASK))
{
if (resized) {
ComponentEvent e = new ComponentEvent(this,
ComponentEvent.COMPONENT_RESIZED);
Toolkit.getEventQueue().postEvent(e);
}
if (moved) {
ComponentEvent e = new ComponentEvent(this,
ComponentEvent.COMPONENT_MOVED);
Toolkit.getEventQueue().postEvent(e);
}
} else
// Swing optimization. JComponent extends Container
if (this instanceof Container && ((Container)this).ncomponents > 0) {
boolean enabledOnToolkit =
Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK);
// Container.dispatchEventImpl will create
// HierarchyEvents
if (resized) {
((Container)this).createChildHierarchyEvents(
HierarchyEvent.ANCESTOR_RESIZED, 0, enabledOnToolkit);
}
if (moved) {
((Container)this).createChildHierarchyEvents(
HierarchyEvent.ANCESTOR_MOVED, 0, enabledOnToolkit);
}
}
|
| int | numListening(long mask)
if (dbg.on) {
// One mask or the other, but not neither or both.
dbg.assertion(mask == AWTEvent.HIERARCHY_EVENT_MASK ||
mask == AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK);
}
if ((mask == AWTEvent.HIERARCHY_EVENT_MASK &&
(hierarchyListener != null ||
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0)) ||
(mask == AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK &&
(hierarchyBoundsListener != null ||
(eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) != 0))) {
return 1;
} else {
return 0;
}
|
| public void | paint(java.awt.Graphics g)Paints this component.
This method is called when the contents of the component should
be painted; such as when the component is first being shown or
is damaged and in need of repair. The clip rectangle in the
Graphics parameter is set to the area
which needs to be painted.
Subclasses of Component that override this
method need not call super.paint(g).
For performance reasons, Components with zero width
or height aren't considered to need painting when they are first shown,
and also aren't considered to need repair.
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.
|
| public void | paintAll(java.awt.Graphics g)Paints this component and all of its subcomponents.
The origin of the graphics context, its
(0, 0) coordinate point, is the
top-left corner of this component. The clipping region of the
graphics context is the bounding rectangle of this component.
if (isShowing()) {
GraphicsCallback.PeerPaintCallback.getInstance().
runOneComponent(this, new Rectangle(0, 0, width, height),
g, g.getClip(),
GraphicsCallback.LIGHTWEIGHTS |
GraphicsCallback.HEAVYWEIGHTS);
}
|
| void | paintHeavyweightComponents(java.awt.Graphics g)Paints all the heavyweight subcomponents.
|
| protected java.lang.String | paramString()Returns a string representing the state of this component. This
method is intended to be used only for debugging purposes, and the
content and format of the returned string may vary between
implementations. The returned string may be empty but may not be
null.
String thisName = getName();
String str = (thisName != null? thisName : "") + "," + x + "," + y + "," + width + "x" + height;
if (!valid) {
str += ",invalid";
}
if (!visible) {
str += ",hidden";
}
if (!enabled) {
str += ",disabled";
}
return str;
|
| java.awt.Point | pointRelativeToComponent(java.awt.Point absolute)Translates absolute coordinates into coordinates in the coordinate
space of this component.
Point compCoords = getLocationOnScreen();
return new Point(absolute.x - compCoords.x,
absolute.y - compCoords.y);
|
| public boolean | postEvent(java.awt.Event e)
ComponentPeer peer = this.peer;
if (handleEvent(e)) {
e.consume();
return true;
}
Component parent = this.parent;
int eventx = e.x;
int eventy = e.y;
if (parent != null) {
e.translate(x, y);
if (parent.postEvent(e)) {
e.consume();
return true;
}
// restore coords
e.x = eventx;
e.y = eventy;
}
return false;
|
| boolean | postsOldMouseEvents()
return false;
|
| public java.awt.Dimension | preferredSize()
/* Avoid grabbing the lock if a reasonable cached size value
* is available.
*/
Dimension dim = prefSize;
if (dim == null || !(isPreferredSizeSet() || isValid())) {
synchronized (getTreeLock()) {
prefSize = (peer != null) ?
peer.preferredSize() :
getMinimumSize();
dim = prefSize;
}
}
return new Dimension(dim);
|
| public boolean | prepareImage(java.awt.Image image, java.awt.image.ImageObserver observer)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.
return prepareImage(image, -1, -1, observer);
|
| public boolean | prepareImage(java.awt.Image image, int width, int height, java.awt.image.ImageObserver observer)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.
ComponentPeer peer = this.peer;
if (peer instanceof LightweightPeer) {
return (parent != null)
? parent.prepareImage(image, width, height, observer)
: getToolkit().prepareImage(image, width, height, observer);
} else {
return (peer != null)
? peer.prepareImage(image, width, height, observer)
: getToolkit().prepareImage(image, width, height, observer);
}
|
| public void | print(java.awt.Graphics g)Prints this component. Applications should override this method
for components that must do special processing before being
printed or should be printed differently than they are painted.
The default implementation of this method calls the
paint method.
The origin of the graphics context, its
(0, 0) coordinate point, is the
top-left corner of this component. The clipping region of the
graphics context is the bounding rectangle of this component.
paint(g);
|
| public void | printAll(java.awt.Graphics g)Prints this component and all of its subcomponents.
The origin of the graphics context, its
(0, 0) coordinate point, is the
top-left corner of this component. The clipping region of the
graphics context is the bounding rectangle of this component.
if (isShowing()) {
GraphicsCallback.PeerPrintCallback.getInstance().
runOneComponent(this, new Rectangle(0, 0, width, height),
g, g.getClip(),
GraphicsCallback.LIGHTWEIGHTS |
GraphicsCallback.HEAVYWEIGHTS);
}
|
| void | printHeavyweightComponents(java.awt.Graphics g)Prints all the heavyweight subcomponents.
|
| protected void | processComponentEvent(java.awt.event.ComponentEvent e)Processes component events occurring on this component by
dispatching them to any registered
ComponentListener objects.
This method is not called unless component events are
enabled for this component. Component events are enabled
when one of the following occurs:
- A
ComponentListener object is registered
via addComponentListener.
- Component events are enabled via
enableEvents.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
ComponentListener listener = componentListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case ComponentEvent.COMPONENT_RESIZED:
listener.componentResized(e);
break;
case ComponentEvent.COMPONENT_MOVED:
listener.componentMoved(e);
break;
case ComponentEvent.COMPONENT_SHOWN:
listener.componentShown(e);
break;
case ComponentEvent.COMPONENT_HIDDEN:
listener.componentHidden(e);
break;
}
}
|
| protected void | processEvent(java.awt.AWTEvent e)Processes events occurring on this component. By default this
method calls the appropriate
process<event type>Event
method for the given class of event.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
if (e instanceof FocusEvent) {
processFocusEvent((FocusEvent)e);
} else if (e instanceof MouseEvent) {
switch(e.getID()) {
case MouseEvent.MOUSE_PRESSED:
case MouseEvent.MOUSE_RELEASED:
case MouseEvent.MOUSE_CLICKED:
case MouseEvent.MOUSE_ENTERED:
case MouseEvent.MOUSE_EXITED:
processMouseEvent((MouseEvent)e);
break;
case MouseEvent.MOUSE_MOVED:
case MouseEvent.MOUSE_DRAGGED:
processMouseMotionEvent((MouseEvent)e);
break;
case MouseEvent.MOUSE_WHEEL:
processMouseWheelEvent((MouseWheelEvent)e);
break;
}
} else if (e instanceof KeyEvent) {
processKeyEvent((KeyEvent)e);
} else if (e instanceof ComponentEvent) {
processComponentEvent((ComponentEvent)e);
} else if (e instanceof InputMethodEvent) {
processInputMethodEvent((InputMethodEvent)e);
} else if (e instanceof HierarchyEvent) {
switch (e.getID()) {
case HierarchyEvent.HIERARCHY_CHANGED:
processHierarchyEvent((HierarchyEvent)e);
break;
case HierarchyEvent.ANCESTOR_MOVED:
case HierarchyEvent.ANCESTOR_RESIZED:
processHierarchyBoundsEvent((HierarchyEvent)e);
break;
}
}
|
| protected void | processFocusEvent(java.awt.event.FocusEvent e)Processes focus events occurring on this component by
dispatching them to any registered
FocusListener objects.
This method is not called unless focus events are
enabled for this component. Focus events are enabled
when one of the following occurs:
- A
FocusListener object is registered
via addFocusListener.
- Focus events are enabled via
enableEvents.
If focus events are enabled for a Component,
the current KeyboardFocusManager determines
whether or not a focus event should be dispatched to
registered FocusListener objects. If the
events are to be dispatched, the KeyboardFocusManager
calls the Component's dispatchEvent
method, which results in a call to the Component's
processFocusEvent method.
If focus events are enabled for a Component, calling
the Component's dispatchEvent method
with a FocusEvent as the argument will result in a
call to the Component's processFocusEvent
method regardless of the current KeyboardFocusManager.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
FocusListener listener = focusListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case FocusEvent.FOCUS_GAINED:
listener.focusGained(e);
break;
case FocusEvent.FOCUS_LOST:
listener.focusLost(e);
break;
}
}
|
| protected void | processHierarchyBoundsEvent(java.awt.event.HierarchyEvent e)Processes hierarchy bounds events occurring on this component by
dispatching them to any registered
HierarchyBoundsListener objects.
This method is not called unless hierarchy bounds events
are enabled for this component. Hierarchy bounds events are enabled
when one of the following occurs:
- An
HierarchyBoundsListener object is registered
via addHierarchyBoundsListener.
- Hierarchy bounds events are enabled via
enableEvents.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
HierarchyBoundsListener listener = hierarchyBoundsListener;
if (listener != null) {
int id = e.getID();
switch (id) {
case HierarchyEvent.ANCESTOR_MOVED:
listener.ancestorMoved(e);
break;
case HierarchyEvent.ANCESTOR_RESIZED:
listener.ancestorResized(e);
break;
}
}
|
| protected void | processHierarchyEvent(java.awt.event.HierarchyEvent e)Processes hierarchy events occurring on this component by
dispatching them to any registered
HierarchyListener objects.
This method is not called unless hierarchy events
are enabled for this component. Hierarchy events are enabled
when one of the following occurs:
- An
HierarchyListener object is registered
via addHierarchyListener.
- Hierarchy events are enabled via
enableEvents.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
HierarchyListener listener = hierarchyListener;
if (listener != null) {
int id = e.getID();
switch (id) {
case HierarchyEvent.HIERARCHY_CHANGED:
listener.hierarchyChanged(e);
break;
}
}
|
| protected void | processInputMethodEvent(java.awt.event.InputMethodEvent e)Processes input method events occurring on this component by
dispatching them to any registered
InputMethodListener objects.
This method is not called unless input method events
are enabled for this component. Input method events are enabled
when one of the following occurs:
- An
InputMethodListener object is registered
via addInputMethodListener.
- Input method events are enabled via
enableEvents.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
InputMethodListener listener = inputMethodListener;
if (listener != null) {
int id = e.getID();
switch (id) {
case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
listener.inputMethodTextChanged(e);
break;
case InputMethodEvent.CARET_POSITION_CHANGED:
listener.caretPositionChanged(e);
break;
}
}
|
| protected void | processKeyEvent(java.awt.event.KeyEvent e)Processes key events occurring on this component by
dispatching them to any registered
KeyListener objects.
This method is not called unless key events are
enabled for this component. Key events are enabled
when one of the following occurs:
- A
KeyListener object is registered
via addKeyListener.
- Key events are enabled via
enableEvents.
If key events are enabled for a Component,
the current KeyboardFocusManager determines
whether or not a key event should be dispatched to
registered KeyListener objects. The
DefaultKeyboardFocusManager will not dispatch
key events to a Component that is not the focus
owner or is not showing.
As of J2SE 1.4, KeyEvents are redirected to
the focus owner. Please see the
Focus Specification
for further information.
Calling a Component's dispatchEvent
method with a KeyEvent as the argument will
result in a call to the Component's
processKeyEvent method regardless of the
current KeyboardFocusManager as long as the
component is showing, focused, and enabled, and key events
are enabled on it.
If the event parameter is null
the behavior is unspecified and may result in an
exception.
KeyListener listener = keyListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case KeyEvent.KEY_TYPED:
listener.keyTyped(e);
break;
case KeyEvent.KEY_PRESSED:
listener.keyPressed(e);
break;
case KeyEvent.KEY_RELEASED:
listener.keyReleased(e);
break;
}
}
|
| protected void | processMouseEvent(java.awt.event.MouseEvent e)Processes mouse events occurring on this component by
dispatching them to any registered
MouseListener objects.
This method is not called unless mouse events are
enabled for this component. Mouse events are enabled
when one of the following occurs:
- A
MouseListener object is registered
via addMouseListener.
- Mouse events are enabled via
enableEvents.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
MouseListener listener = mouseListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case MouseEvent.MOUSE_PRESSED:
listener.mousePressed(e);
break;
case MouseEvent.MOUSE_RELEASED:
listener.mouseReleased(e);
break;
case MouseEvent.MOUSE_CLICKED:
listener.mouseClicked(e);
break;
case MouseEvent.MOUSE_EXITED:
listener.mouseExited(e);
break;
case MouseEvent.MOUSE_ENTERED:
listener.mouseEntered(e);
break;
}
}
|
| protected void | processMouseMotionEvent(java.awt.event.MouseEvent e)Processes mouse motion events occurring on this component by
dispatching them to any registered
MouseMotionListener objects.
This method is not called unless mouse motion events are
enabled for this component. Mouse motion events are enabled
when one of the following occurs:
- A
MouseMotionListener object is registered
via addMouseMotionListener.
- Mouse motion events are enabled via
enableEvents.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
MouseMotionListener listener = mouseMotionListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case MouseEvent.MOUSE_MOVED:
listener.mouseMoved(e);
break;
case MouseEvent.MOUSE_DRAGGED:
listener.mouseDragged(e);
break;
}
}
|
| protected void | processMouseWheelEvent(java.awt.event.MouseWheelEvent e)Processes mouse wheel events occurring on this component by
dispatching them to any registered
MouseWheelListener objects.
This method is not called unless mouse wheel events are
enabled for this component. Mouse wheel events are enabled
when one of the following occurs:
- A
MouseWheelListener object is registered
via addMouseWheelListener.
- Mouse wheel events are enabled via
enableEvents.
For information on how mouse wheel events are dispatched, see
the class description for {@link MouseWheelEvent}.
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception.
MouseWheelListener listener = mouseWheelListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case MouseEvent.MOUSE_WHEEL:
listener.mouseWheelMoved(e);
break;
}
}
|
| private void | readObject(java.io.ObjectInputStream s)Reads the ObjectInputStream and if it isn't
null adds a listener to receive a variety
of events fired by the component.
Unrecognized keys or values will be ignored.
s.defaultReadObject();
privateKey = new Object();
appContext = AppContext.getAppContext();
if (componentSerializedDataVersion < 4) {
// These fields are non-transient and rely on default
// serialization. However, the default values are insufficient,
// so we need to set them explicitly for object data streams prior
// to 1.4.
focusable = true;
isFocusTraversableOverridden = FOCUS_TRAVERSABLE_UNKNOWN;
initializeFocusTraversalKeys();
focusTraversalKeysEnabled = true;
}
Object keyOrNull;
while(null != (keyOrNull = s.readObject())) {
String key = ((String)keyOrNull).intern();
if (componentListenerK == key)
addComponentListener((ComponentListener)(s.readObject()));
else if (focusListenerK == key)
addFocusListener((FocusListener)(s.readObject()));
else if (keyListenerK == key)
addKeyListener((KeyListener)(s.readObject()));
else if (mouseListenerK == key)
addMouseListener((MouseListener)(s.readObject()));
else if (mouseMotionListenerK == key)
addMouseMotionListener((MouseMotionListener)(s.readObject()));
else if (inputMethodListenerK == key)
addInputMethodListener((InputMethodListener)(s.readObject()));
else // skip value for unrecognized key
s.readObject();
}
// Read the component's orientation if it's present
Object orient = null;
try {
orient = s.readObject();
} catch (java.io.OptionalDataException e) {
// JDK 1.1 instances will not have this optional data.
// e.eof will be true to indicate that there is no more
// data available for this object.
// If e.eof is not true, throw the exception as it
// might have been caused by reasons unrelated to
// componentOrientation.
if (!e.eof) {
throw (e);
}
}
if (orient != null) {
componentOrientation = (ComponentOrientation)orient;
} else {
componentOrientation = ComponentOrientation.UNKNOWN;
}
try {
while(null != (keyOrNull = s.readObject())) {
String key = ((String)keyOrNull).intern();
if (hierarchyListenerK == key) {
addHierarchyListener((HierarchyListener)(s.readObject()));
}
else if (hierarchyBoundsListenerK == key) {
addHierarchyBoundsListener((HierarchyBoundsListener)
(s.readObject()));
}
else {
// skip value for unrecognized key
s.readObject();
}
}
} catch (java.io.OptionalDataException e) {
// JDK 1.1/1.2 instances will not have this optional data.
// e.eof will be true to indicate that there is no more
// data available for this object.
// If e.eof is not true, throw the exception as it
// might have been caused by reasons unrelated to
// hierarchy and hierarchyBounds listeners.
if (!e.eof) {
throw (e);
}
}
try {
while (null != (keyOrNull = s.readObject())) {
String key = ((String)keyOrNull).intern();
if (mouseWheelListenerK == key) {
addMouseWheelListener((MouseWheelListener)(s.readObject()));
}
else {
// skip value for unrecognized key
s.readObject();
}
}
} catch (java.io.OptionalDataException e) {
// pre-1.3 instances will not have this optional data.
// e.eof will be true to indicate that there is no more
// data available for this object.
// If e.eof is not true, throw the exception as it
// might have been caused by reasons unrelated to
// mouse wheel listeners
if (!e.eof) {
throw (e);
}
}
if (popups != null) {
int npopups = popups.size();
for (int i = 0 ; i < npopups ; i++) {
PopupMenu popup = (PopupMenu)popups.elementAt(i);
popup.parent = this;
}
}
|
| public synchronized void | remove(java.awt.MenuComponent popup)Removes the specified popup menu from the component.
if (popups != null) {
int index = popups.indexOf(popup);
if (index >= 0) {
PopupMenu pmenu = (PopupMenu)popup;
if (pmenu.peer != null) {
pmenu.removeNotify();
}
pmenu.parent = null;
popups.removeElementAt(index);
if (popups.size() == 0) {
popups = null;
}
}
}
|
| public synchronized void | removeComponentListener(java.awt.event.ComponentListener l)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.
if (l == null) {
return;
}
componentListener = AWTEventMulticaster.remove(componentListener, l);
|
| public synchronized void | removeFocusListener(java.awt.event.FocusListener l)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.
if (l == null) {
return;
}
focusListener = AWTEventMulticaster.remove(focusListener, l);
|
| public void | removeHierarchyBoundsListener(java.awt.event.HierarchyBoundsListener l)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.
if (l == null) {
return;
}
boolean notifyAncestors;
synchronized (this) {
notifyAncestors =
(hierarchyBoundsListener != null &&
(eventMask & AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) == 0);
hierarchyBoundsListener =
AWTEventMulticaster.remove(hierarchyBoundsListener, l);
notifyAncestors = (notifyAncestors &&
hierarchyBoundsListener == null);
}
if (notifyAncestors) {
synchronized (getTreeLock()) {
adjustListeningChildrenOnParent(
AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK, -1);
}
}
|
| public void | removeHierarchyListener(java.awt.event.HierarchyListener l)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.
if (l == null) {
return;
}
boolean notifyAncestors;
synchronized (this) {
notifyAncestors =
(hierarchyListener != null &&
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) == 0);
hierarchyListener =
AWTEventMulticaster.remove(hierarchyListener, l);
notifyAncestors = (notifyAncestors && hierarchyListener == null);
}
if (notifyAncestors) {
synchronized (getTreeLock()) {
adjustListeningChildrenOnParent(AWTEvent.HIERARCHY_EVENT_MASK,
-1);
}
}
|
| public synchronized void | removeInputMethodListener(java.awt.event.InputMethodListener l)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.
if (l == null) {
return;
}
inputMethodListener = AWTEventMulticaster.remove(inputMethodListener, l);
|
| public synchronized void | removeKeyListener(java.awt.event.KeyListener l)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.
if (l == null) {
return;
}
keyListener = AWTEventMulticaster.remove(keyListener, l);
|
| public synchronized void | removeMouseListener(java.awt.event.MouseListener l)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.
if (l == null) {
return;
}
mouseListener = AWTEventMulticaster.remove(mouseListener, l);
|
| public synchronized void | removeMouseMotionListener(java.awt.event.MouseMotionListener l)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.
if (l == null) {
return;
}
mouseMotionListener = AWTEventMulticaster.remove(mouseMotionListener, l);
|
| public synchronized void | removeMouseWheelListener(java.awt.event.MouseWheelListener l)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.
if (l == null) {
return;
}
mouseWheelListener = AWTEventMulticaster.remove(mouseWheelListener, l);
|
| public void | removeNotify()Makes this Component undisplayable by destroying it native
screen resource.
This method is called by the toolkit internally and should
not be called directly by programs. Code overriding
this method should call super.removeNotify as
the first line of the overriding method.
KeyboardFocusManager.clearMostRecentFocusOwner(this);
if (KeyboardFocusManager.getCurrentKeyboardFocusManager().
getPermanentFocusOwner() == this)
{
KeyboardFocusManager.getCurrentKeyboardFocusManager().
setGlobalPermanentFocusOwner(null);
}
synchronized (getTreeLock()) {
if (isFocusOwner() && !nextFocusHelper()) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().
clearGlobalFocusOwner();
}
int npopups = (popups != null? popups.size() : 0);
for (int i = 0 ; i < npopups ; i++) {
PopupMenu popup = (PopupMenu)popups.elementAt(i);
popup.removeNotify();
}
// If there is any input context for this component, notify
// that this component is being removed. (This has to be done
// before hiding peer.)
if ((eventMask & AWTEvent.INPUT_METHODS_ENABLED_MASK) != 0) {
InputContext inputContext = getInputContext();
if (inputContext != null) {
inputContext.removeNotify(this);
}
}
ComponentPeer p = peer;
if (p != null) {
if (bufferStrategy instanceof FlipBufferStrategy) {
((FlipBufferStrategy)bufferStrategy).destroyBuffers();
}
if (dropTarget != null) dropTarget.removeNotify(peer);
// Hide peer first to stop system events such as cursor moves.
if (visible) {
p.hide();
}
peer = null; // Stop peer updates.
peerFont = null;
Toolkit.getEventQueue().removeSourceEvents(this, false);
KeyboardFocusManager.getCurrentKeyboardFocusManager().
discardKeyEvents(this);
p.dispose();
}
if (hierarchyListener != null ||
(eventMask & AWTEvent.HIERARCHY_EVENT_MASK) != 0 ||
Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK)) {
HierarchyEvent e =
new HierarchyEvent(this, HierarchyEvent.HIERARCHY_CHANGED,
this, parent,
HierarchyEvent.DISPLAYABILITY_CHANGED |
((isRecursivelyVisible())
? HierarchyEvent.SHOWING_CHANGED
: 0));
dispatchEvent(e);
}
}
|
| public synchronized void | removePropertyChangeListener(java.beans.PropertyChangeListener listener)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.
if (listener == null || changeSupport == null) {
return;
}
changeSupport.removePropertyChangeListener(listener);
|
| public synchronized void | removePropertyChangeListener(java.lang.String propertyName, java.beans.PropertyChangeListener listener)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.
if (listener == null || changeSupport == null) {
return;
}
changeSupport.removePropertyChangeListener(propertyName, listener);
|
| public void | repaint()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.
repaint(0, 0, 0, width, height);
|
| public void | repaint(long tm)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.
repaint(tm, 0, 0, width, height);
|
| public void | repaint(int x, int y, int width, int height)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.
repaint(0, x, y, width, height);
|
| public void | repaint(long tm, int x, int y, int width, int height)Repaints the specified rectangle of this component within
tm milliseconds.
If this component is a lightweight component, this method causes
a call to this component's paint method.
Otherwise, this method causes a call to this component's
update method.
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.
if (this.peer instanceof LightweightPeer) {
// Needs to be translated to parent coordinates since
// a parent native container provides the actual repaint
// services. Additionally, the request is restricted to
// the bounds of the component.
if (parent != null) {
int px = this.x + ((x < 0) ? 0 : x);
int py = this.y + ((y < 0) ? 0 : y);
int pwidth = (width > this.width) ? this.width : width;
int pheight = (height > this.height) ? this.height : height;
parent.repaint(tm, px, py, pwidth, pheight);
}
} else {
if (isVisible() && (this.peer != null) &&
(width > 0) && (height > 0)) {
PaintEvent e = new PaintEvent(this, PaintEvent.UPDATE,
new Rectangle(x, y, width, height));
Toolkit.getEventQueue().postEvent(e);
}
}
|
| private void | repaintParentIfNeeded(int oldX, int oldY, int oldWidth, int oldHeight)
if (parent != null && peer instanceof LightweightPeer && isShowing()) {
// Have the parent redraw the area this component occupied.
parent.repaint(oldX, oldY, oldWidth, oldHeight);
// Have the parent redraw the area this component *now* occupies.
repaint();
}
|
| public void | requestFocus()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. Every effort will be made to honor the request; however, in
some cases it may be impossible to do so. Developers must never assume
that this Component is the focus owner until this Component receives a
FOCUS_GAINED event. If this request is denied because this Component's
top-level Window cannot become the focused Window, the request will be
remembered and will be granted when the Window is later focused by the
user.
This method cannot be used to set the focus owner to no Component at
all. Use KeyboardFocusManager.clearGlobalFocusOwner()
instead.
Because the focus behavior of this method is platform-dependent,
developers are strongly encouraged to use
requestFocusInWindow when possible.
requestFocusHelper(false, true);
|
| protected boolean | requestFocus(boolean temporary)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. Every effort will be made to honor the request; however, in
some cases it may be impossible to do so. Developers must never assume
that this component is the focus owner until this component receives a
FOCUS_GAINED event. If this request is denied because this component's
top-level window cannot become the focused window, the request will be
remembered and will be granted when the window is later focused by the
user.
This method returns a boolean value. If false is returned,
the request is guaranteed to fail. If true is
returned, the request will succeed unless it is vetoed, or an
extraordinary event, such as disposal of the component's peer, occurs
before the request can be granted by the native windowing system. Again,
while a return value of true indicates that the request is
likely to succeed, developers must never assume that this component is
the focus owner until this component receives a FOCUS_GAINED event.
This method cannot be used to set the focus owner to no component at
all. Use KeyboardFocusManager.clearGlobalFocusOwner
instead.
Because the focus behavior of this method is platform-dependent,
developers are strongly encouraged to use
requestFocusInWindow when possible.
Every effort will be made to ensure that FocusEvents
generated as a
result of this request will have the specified temporary value. However,
because specifying an arbitrary temporary state may not be implementable
on all native windowing systems, correct behavior for this method can be
guaranteed only for lightweight Components.
This method is not intended
for general use, but exists instead as a hook for lightweight component
libraries, such as Swing.
return requestFocusHelper(temporary, true);
|
| final boolean | requestFocusHelper(boolean temporary, boolean focusedWindowChangeAllowed)
if (isFocusable() && isVisible()) {
ComponentPeer peer = this.peer;
if (peer != null) {
boolean recursivelyInvisible = false;
Component window = this;
while (!(window instanceof Window)) {
if (!window.isVisible()) {
recursivelyInvisible = true;
}
window = window.parent;
}
if (window == null || !((Window)window).isFocusableWindow()) {
focusLog.finest("FAIL 1");
return false;
}
// Update most-recent map
KeyboardFocusManager.setMostRecentFocusOwner(this);
if (recursivelyInvisible) {
focusLog.finest("FAIL 1.5");
return false;
}
Component heavyweight = (peer instanceof LightweightPeer)
? getNativeContainer() : this;
if (heavyweight == null || !heavyweight.isVisible()) {
focusLog.finest("FAIL 2");
return false;
}
peer = heavyweight.peer;
if (peer == null) {
focusLog.finest("FAIL 3");
return false;
}
// Focus this Component
long time = EventQueue.getMostRecentEventTime();
boolean success = peer.requestFocus
(this, temporary, focusedWindowChangeAllowed, time);
if (!success) {
KeyboardFocusManager.getCurrentKeyboardFocusManager
(appContext).dequeueKeyEvents(time, this);
focusLog.finest("FAIL 4");
} else {
if (focusLog.isLoggable(Level.FINEST)) focusLog.finest("Pass for " + this);
}
return success;
}
}
focusLog.finest("FAIL 5");
return false;
|
| public boolean | requestFocusInWindow()Requests that this Component get the input focus, if this Component's
top-level ancestor is already the focused Window. This component must be
displayable, visible, and focusable for the request to be granted. Every
effort will be made to honor the request; however, in some cases it may
be impossible to do so. Developers must never assume that this Component
is the focus owner until this Component receives a FOCUS_GAINED event.
This method returns a boolean value. If false is returned,
the request is guaranteed to fail. If true is
returned, the request will succeed unless it is vetoed, or an
extraordinary event, such as disposal of the Component's peer, occurs
before the request can be granted by the native windowing system. Again,
while a return value of true indicates that the request is
likely to succeed, developers must never assume that this Component is
the focus owner until this Component receives a FOCUS_GAINED event.
This method cannot be used to set the focus owner to no Component at
all. Use KeyboardFocusManager.clearGlobalFocusOwner()
instead.
The focus behavior of this method can be implemented uniformly across
platforms, and thus developers are strongly encouraged to use this
method over requestFocus when possible. Code which relies
on requestFocus may exhibit different focus behavior on
different platforms.
return requestFocusHelper(false, false);
|
| protected boolean | requestFocusInWindow(boolean temporary)Requests that this Component get the input focus,
if this Component's
top-level ancestor is already the focused Window.
This component must be
displayable, visible, and focusable for the request to be granted. Every
effort will be made to honor the request; however, in some cases it may
be impossible to do so. Developers must never assume that this component
is the focus owner until this component receives a FOCUS_GAINED event.
This method returns a boolean value. If false is returned,
the request is guaranteed to fail. If true is
returned, the request will succeed unless it is vetoed, or an
extraordinary event, such as disposal of the component's peer, occurs
before the request can be granted by the native windowing system. Again,
while a return value of true indicates that the request is
likely to succeed, developers must never assume that this component is
the focus owner until this component receives a FOCUS_GAINED event.
This method cannot be used to set the focus owner to no component at
all. Use KeyboardFocusManager.clearGlobalFocusOwner
instead.
The focus behavior of this method can be implemented uniformly across
platforms, and thus developers are strongly encouraged to use this
method over requestFocus when possible. Code which relies
on requestFocus may exhibit different focus behavior on
different platforms.
Every effort will be made to ensure that FocusEvents
generated as a
result of this request will have the specified temporary value. However,
because specifying an arbitrary temporary state may not be implementable
on all native windowing systems, correct behavior for this method can be
guaranteed only for lightweight components. This method is not intended
for general use, but exists instead as a hook for lightweight component
libraries, such as Swing.
return requestFocusHelper(temporary, false);
|
| void | resetGC()Resets this Component's
GraphicsConfiguration back to a default
value. For most componenets, this is null.
Called from the Toolkit thread, so NO CLIENT CODE.
synchronized(getTreeLock()) {
graphicsConfig = null;
}
|
| public void | reshape(int x, int y, int width, int height)
synchronized (getTreeLock()) {
try {
setBoundsOp(ComponentPeer.SET_BOUNDS);
boolean resized = (this.width != width) || (this.height != height);
boolean moved = (this.x != x) || (this.y != y);
if (!resized && !moved) {
return;
}
int oldX = this.x;
int oldY = this.y;
int oldWidth = this.width;
int oldHeight = this.height;
this.x = x;
this.y = y;
this.width = width;
this.height = height;
if (resized) {
isPacked = false;
}
if (peer != null) {
// LightwightPeer is an empty stub so can skip peer.reshape
if (!(peer instanceof LightweightPeer)) {
reshapeNativePeer(x, y, width, height, getBoundsOp());
// Check peer actualy changed coordinates
resized = (oldWidth != this.width) || (oldHeight != this.height);
moved = (oldX != this.x) || (oldY != this.y);
}
if (resized) {
invalidate();
}
if (parent != null && parent.valid) {
parent.invalidate();
}
}
notifyNewBounds(resized, moved);
repaintParentIfNeeded(oldX, oldY, oldWidth, oldHeight);
} finally {
setBoundsOp(ComponentPeer.RESET_OPERATION);
}
}
|
| private void | reshapeNativePeer(int x, int y, int width, int height, int op)
// native peer might be offset by more than direct
// parent since parent might be lightweight.
int nativeX = x;
int nativeY = y;
for (Component c = parent;
(c != null) && (c.peer instanceof LightweightPeer);
c = c.parent)
{
nativeX += c.x;
nativeY += c.y;
}
peer.setBounds(nativeX, nativeY, width, height, op);
|
| public void | resize(int width, int height)
synchronized(getTreeLock()) {
setBoundsOp(ComponentPeer.SET_SIZE);
setBounds(x, y, width, height);
}
|
| public void | resize(java.awt.Dimension d)
setSize(d.width, d.height);
|
| public void | setBackground(java.awt.Color c)Sets the background color of this component.
The background color affects each component differently and the
parts of the component that are affected by the background color
may differ between operating systems.
Color oldColor = background;
ComponentPeer peer = this.peer;
background = c;
if (peer != null) {
c = getBackground();
if (c != null) {
peer.setBackground(c);
}
}
// This is a bound property, so report the change to
// any registered listeners. (Cheap if there are none.)
firePropertyChange("background", oldColor, c);
|
| public void | setBounds(int x, int y, int width, int height)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.
reshape(x, y, width, height);
|
| public void | setBounds(java.awt.Rectangle r)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
setBounds(r.x, r.y, r.width, r.height);
|
| void | setBoundsOp(int op)
assert Thread.holdsLock(getTreeLock());
if (op == ComponentPeer.RESET_OPERATION) {
boundsOp = ComponentPeer.DEFAULT_OPERATION;
} else
if (boundsOp == ComponentPeer.DEFAULT_OPERATION) {
boundsOp = op;
}
|
| public void | setComponentOrientation(java.awt.ComponentOrientation o)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
{@link #applyComponentOrientation applyComponentOrientation}.
ComponentOrientation oldValue = componentOrientation;
componentOrientation = o;
// This is a bound property, so report the change to
// any registered listeners. (Cheap if there are none.)
firePropertyChange("componentOrientation", oldValue, o);
// This could change the preferred size of the Component.
if (valid) {
invalidate();
}
|
| public void | setCursor(java.awt.Cursor cursor)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.
this.cursor = cursor;
updateCursorImmediately();
|
| public synchronized void | setDropTarget(java.awt.dnd.DropTarget dt)Associate a DropTarget with this component.
The Component will receive drops only if it
is enabled.
if (dt == dropTarget || (dropTarget != null && dropTarget.equals(dt)))
return;
DropTarget old;
if ((old = dropTarget) != null) {
if (peer != null) dropTarget.removeNotify(peer);
DropTarget t = dropTarget;
dropTarget = null;
try {
t.setComponent(null);
} catch (IllegalArgumentException iae) {
// ignore it.
}
}
// if we have a new one, and we have a peer, add it!
if ((dropTarget = dt) != null) {
try {
dropTarget.setComponent(this);
if (peer != null) dropTarget.addNotify(peer);
} catch (IllegalArgumentException iae) {
if (old != null) {
try {
old.setComponent(this);
if (peer != null) dropTarget.addNotify(peer);
} catch (IllegalArgumentException iae1) {
// ignore it!
}
}
}
}
|
| public void | setEnabled(boolean b)Enables or disables this component, depending on the value of the
parameter b. An enabled component can respond to user
input and generate events. Components are enabled initially by default.
Note: Disabling a lightweight component does not prevent it from
receiving MouseEvents.
enable(b);
|
| public void | setFocusTraversalKeys(int id, java.util.Set keystrokes)Sets the focus traversal keys for a given traversal operation for this
Component.
The default values for a Component's focus traversal keys are
implementation-dependent. Sun recommends that all implementations for a
particular native platform use the same default values. The
recommendations for Windows and Unix are listed below. These
recommendations are used in the Sun AWT implementations.
| Identifier |
Meaning |
Default |
| KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS |
Normal forward keyboard traversal |
TAB on KEY_PRESSED, CTRL-TAB on KEY_PRESSED |
| KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS |
Normal reverse keyboard traversal |
SHIFT-TAB on KEY_PRESSED, CTRL-SHIFT-TAB on KEY_PRESSED |
| KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS |
Go up one focus traversal cycle |
none |
To disable a traversal key, use an empty Set; Collections.EMPTY_SET is
recommended.
Using the AWTKeyStroke API, client code can specify on which of two
specific KeyEvents, KEY_PRESSED or KEY_RELEASED, the focus traversal
operation will occur. Regardless of which KeyEvent is specified,
however, all KeyEvents related to the focus traversal key, including the
associated KEY_TYPED event, will be consumed, and will not be dispatched
to any Component. It is a runtime error to specify a KEY_TYPED event as
mapping to a focus traversal operation, or to map the same event to
multiple default focus traversal operations.
If a value of null is specified for the Set, this Component inherits the
Set from its parent. If all ancestors of this Component have null
specified for the Set, then the current KeyboardFocusManager's default
Set is used.
if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH - 1) {
throw new IllegalArgumentException("invalid focus traversal key identifier");
}
setFocusTraversalKeys_NoIDCheck(id, keystrokes);
|
| public void | setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled)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.
boolean oldFocusTraversalKeysEnabled;
synchronized (this) {
oldFocusTraversalKeysEnabled = this.focusTraversalKeysEnabled;
this.focusTraversalKeysEnabled = focusTraversalKeysEnabled;
}
firePropertyChange("focusTraversalKeysEnabled",
oldFocusTraversalKeysEnabled,
focusTraversalKeysEnabled);
|
| final void | setFocusTraversalKeys_NoIDCheck(int id, java.util.Set keystrokes)
Set oldKeys;
synchronized (this) {
if (focusTraversalKeys == null) {
initializeFocusTraversalKeys();
}
if (keystrokes != null) {
for (Iterator iter = keystrokes.iterator(); iter.hasNext(); ) {
Object obj = iter.next();
if (obj == null) {
throw new IllegalArgumentException("cannot set null focus traversal key");
}
// Generates a ClassCastException if the element is not an
// AWTKeyStroke. This is desirable.
AWTKeyStroke keystroke = (AWTKeyStroke)obj;
if (keystroke.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
throw new IllegalArgumentException("focus traversal keys cannot map to KEY_TYPED events");
}
for (int i = 0; i < focusTraversalKeys.length; i++) {
if (i == id) {
continue;
}
if (getFocusTraversalKeys_NoIDCheck(i).contains(keystroke))
{
throw new IllegalArgumentException("focus traversal keys must be unique for a Component");
}
}
}
}
oldKeys = focusTraversalKeys[id];
focusTraversalKeys[id] = (keystrokes != null)
? Collections.unmodifiableSet(new HashSet(keystrokes))
: null;
}
firePropertyChange(focusTraversalKeyPropertyNames[id], oldKeys,
keystrokes);
|
| public void | setFocusable(boolean focusable)Sets the focusable state of this Component to the specified value. This
value overrides the Component's default focusability.
boolean oldFocusable;
synchronized (this) {
oldFocusable = this.focusable;
this.focusable = focusable;
}
isFocusTraversableOverridden = FOCUS_TRAVERSABLE_SET;
firePropertyChange("focusable", oldFocusable, focusable);
if (oldFocusable && !focusable) {
if (isFocusOwner()) {
autoTransferFocus(true);
}
KeyboardFocusManager.clearMostRecentFocusOwner(this);
}
|
| public void | setFont(java.awt.Font f)Sets the font of this component.
Font oldFont, newFont;
synchronized(getTreeLock()) {
synchronized (this) {
oldFont = font;
newFont = font = f;
}
ComponentPeer peer = this.peer;
if (peer != null) {
f = getFont();
if (f != null) {
peer.setFont(f);
peerFont = f;
}
}
}
// This is a bound property, so report the change to
// any registered listeners. (Cheap if there are none.)
firePropertyChange("font", oldFont, newFont);
// This could change the preferred size of the Component.
if (valid) {
invalidate();
}
|
| public void | setForeground(java.awt.Color c)Sets the foreground color of this component.
Color oldColor = foreground;
ComponentPeer peer = this.peer;
foreground = c;
if (peer != null) {
c = getForeground();
if (c != null) {
peer.setForeground(c);
}
}
// This is a bound property, so report the change to
// any registered listeners. (Cheap if there are none.)
firePropertyChange("foreground", oldColor, c);
|
| void | setGCFromPeer()
synchronized(getTreeLock()) {
if (peer != null) { // can't imagine how this will be false,
// but just in case
graphicsConfig = peer.getGraphicsConfiguration();
} else {
graphicsConfig = null;
}
}
|
| public void | setIgnoreRepaint(boolean ignoreRepaint)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.
this.ignoreRepaint = ignoreRepaint;
|
| public void | setLocale(java.util.Locale l)Sets the locale of this component. This is a bound property.
Locale oldValue = locale;
locale = l;
// This is a bound property, so report the change to
// any registered listeners. (Cheap if there are none.)
firePropertyChange("locale", oldValue, l);
// This could change the preferred size of the Component.
if (valid) {
invalidate();
}
|
| public void | setLocation(int x, int y)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.
move(x, y);
|
| public void | setLocation(java.awt.Point p)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.
setLocation(p.x, p.y);
|
| public void | setMaximumSize(java.awt.Dimension maximumSize)Sets the maximum size of this component to a constant
value. Subsequent calls to getMaximumSize will always
return this value. Setting the maximum size to null
restores the default behavior.
// If the maximum size was set, use it as the old value, otherwise
// use null to indicate we didn't previously have a set maximum
// size.
Dimension old;
if (maxSizeSet) {
old = this.maxSize;
}
else {
old = null;
}
this.maxSize = maximumSize;
maxSizeSet = (maximumSize != null);
firePropertyChange("maximumSize", old, maximumSize);
|
| public void | setMinimumSize(java.awt.Dimension minimumSize)Sets the minimum size of this component to a constant
value. Subsequent calls to getMinimumSize will always
return this value. Setting the minimum size to null
restores the default behavior.
Dimension old;
// If the minimum size was set, use it as the old value, otherwise
// use null to indicate we didn't previously have a set minimum
// size.
if (minSizeSet) {
old = this.minSize;
}
else {
old = null;
}
this.minSize = minimumSize;
minSizeSet = (minimumSize != null);
firePropertyChange("minimumSize", old, minimumSize);
|
| public void | setName(java.lang.String name)Sets the name of the component to the specified string.
String oldName;
synchronized(this) {
oldName = this.name;
this.name = name;
nameExplicitlySet = true;
}
firePropertyChange("name", oldName, name);
|
| public void | setPreferredSize(java.awt.Dimension preferredSize)Sets the preferred size of this component to a constant
value. Subsequent calls to getPreferredSize will always
return this value. Setting the preferred size to null
restores the default behavior.
Dimension old;
// If the preferred size was set, use it as the old value, otherwise
// use null to indicate we didn't previously have a set preferred
// size.
if (prefSizeSet) {
old = this.prefSize;
}
else {
old = null;
}
this.prefSize = preferredSize;
prefSizeSet = (preferredSize != null);
firePropertyChange("preferredSize", old, preferredSize);
|
| public void | setSize(int width, int height)Resizes this component so that it has width width
and height height.
resize(width, height);
|
| public void | setSize(java.awt.Dimension d)Resizes this component so that it has width d.width
and height d.height.
resize(d);
|
| public void | setVisible(boolean b)Shows or hides this component depending on the value of parameter
b.
show(b);
|
| public void | show()
if (!visible) {
synchronized (getTreeLock()) {
visible = true;
ComponentPeer peer = this.peer;
if (peer != null) {
peer.show();
createHierarchyEvents(HierarchyEvent.HIERARCHY_CHANGED,
this, parent,
HierarchyEvent.SHOWING_CHANGED,
Toolkit.enabledOnToolkit(AWTEvent.HIERARCHY_EVENT_MASK));
if (peer instanceof LightweightPeer) {
repaint();
}
updateCursorImmediately();
}
if (componentListener != null ||
(eventMask & AWTEvent.COMPONENT_EVENT_MASK) != 0 ||
Toolkit.enabledOnToolkit(AWTEvent.COMPONENT_EVENT_MASK)) {
ComponentEvent e = new ComponentEvent(this,
ComponentEvent.COMPONENT_SHOWN);
Toolkit.getEventQueue().postEvent(e);
}
}
Container parent = this.parent;
if (parent != null) {
parent.invalidate();
}
}
|
| public void | show(boolean b)
if (b) {
show();
} else {
hide();
}
|
| public java.awt.Dimension | size()
return new Dimension(width, height);
|
| public java.lang.String | toString()Returns a string representation of this component and its values.
return getClass().getName() + "[" + paramString() + "]";
|
| public void | transferFocus()Transfers the focus to the next component, as though this Component were
the focus owner.
nextFocus();
|
| public void | transferFocusBackward()Transfers the focus to the previous component, as though this Component
were the focus owner.
Container rootAncestor = getFocusCycleRootAncestor();
Component comp = this;
while (rootAncestor != null &&
!(rootAncestor.isShowing() &&
rootAncestor.isFocusable() &&
rootAncestor.isEnabled()))
{
comp = rootAncestor;
rootAncestor = comp.getFocusCycleRootAncestor();
}
if (rootAncestor != null) {
FocusTraversalPolicy policy =
rootAncestor.getFocusTraversalPolicy();
Component toFocus = policy.getComponentBefore(rootAncestor, comp);
if (toFocus == null) {
toFocus = policy.getDefaultComponent(rootAncestor);
}
if (toFocus != null) {
toFocus.requestFocus();
}
}
|
| public void | transferFocusUpCycle()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.
Container rootAncestor;
for (rootAncestor = getFocusCycleRootAncestor();
rootAncestor != null && !(rootAncestor.isShowing() &&
rootAncestor.isFocusable() &&
rootAncestor.isEnabled());
rootAncestor = rootAncestor.getFocusCycleRootAncestor()) {
}
if (rootAncestor != null) {
Container rootAncestorRootAncestor =
rootAncestor.getFocusCycleRootAncestor();
KeyboardFocusManager.getCurrentKeyboardFocusManager().
setGlobalCurrentFocusCycleRoot(
(rootAncestorRootAncestor != null)
? rootAncestorRootAncestor
: rootAncestor);
rootAncestor.requestFocus();
} else {
Container window =
(this instanceof Container) ? ((Container)this) : getParent();
while (window != null && !(window instanceof Window)) {
window = window.getParent();
}
if (window != null) {
Component toFocus = window.getFocusTraversalPolicy().
getDefaultComponent(window);
if (toFocus != null) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().
setGlobalCurrentFocusCycleRoot(window);
toFocus.requestFocus();
}
}
}
|
| public void | update(java.awt.Graphics g)Updates this component.
If this component is not a lightweight component, the
AWT calls the update method in response to
a call to repaint. You can assume that
the background is not cleared.
The update method of Component
calls this component's paint method to redraw
this component. This method is commonly overridden by subclasses
which need to do additional work in response to a call to
repaint.
Subclasses of Component that override this method should either
call super.update(g), or call paint(g)
directly from their update method.
The origin of the graphics context, its
(0, 0) coordinate point, is the
top-left corner of this component. The clipping region of the
graphics context is the bounding rectangle of this component.
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.
paint(g);
|
| final void | updateCursorImmediately()Updates the cursor. May not be invoked from the native
message pump.
if (peer instanceof LightweightPeer) {
Container nativeContainer = getNativeContainer();
if (nativeContainer == null) return;
ComponentPeer cPeer = nativeContainer.getPeer();
if (cPeer != null) {
cPeer.updateCursorImmediately();
}
} else if (peer != null) {
peer.updateCursorImmediately();
}
|
| public void | validate()Ensures that this component has a valid layout. This method is
primarily intended to operate on instances of Container.
if (!valid) {
synchronized (getTreeLock()) {
ComponentPeer peer = this.peer;
if (!valid && peer != null) {
Font newfont = getFont();
Font oldfont = peerFont;
if (newfont != oldfont && (oldfont == null
|| !oldfont.equals(newfont))) {
peer.setFont(newfont);
peerFont = newfont;
}
peer.layout();
}
}
valid = true;
}
|
| private void | writeObject(java.io.ObjectOutputStream s)Writes default serializable fields to stream. Writes
a variety of serializable listeners as optional data.
The non-serializable listeners are detected and
no attempt is made to serialize them.
doSwingSerialization();
s.defaultWriteObject();
AWTEventMulticaster.save(s, componentListenerK, componentListener);
AWTEventMulticaster.save(s, focusListenerK, focusListener);
AWTEventMulticaster.save(s, keyListenerK, keyListener);
AWTEventMulticaster.save(s, mouseListenerK, mouseListener);
AWTEventMulticaster.save(s, mouseMotionListenerK, mouseMotionListener);
AWTEventMulticaster.save(s, inputMethodListenerK, inputMethodListener);
s.writeObject(null);
s.writeObject(componentOrientation);
AWTEventMulticaster.save(s, hierarchyListenerK, hierarchyListener);
AWTEventMulticaster.save(s, hierarchyBoundsListenerK,
hierarchyBoundsListener);
s.writeObject(null);
AWTEventMulticaster.save(s, mouseWheelListenerK, mouseWheelListener);
s.writeObject(null);
|
