| Method from java.awt.Component Detail: |
|---|
 public boolean action(Event evt,
Object what) {
return false;
}
Deprecated! As - of JDK version 1.1,
should register this component as ActionListener on component
which fires action events.
|
public void add(PopupMenu popup) {
synchronized (getTreeLock()) {
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();
}
}
}
} Adds the specified popup menu to the component. |
public synchronized void addComponentListener(ComponentListener l) {
if (l == null) {
return;
}
componentListener = AWTEventMulticaster.add(componentListener, l);
newEventsOnly = true;
} |
public synchronized void addFocusListener(FocusListener l) {
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(HierarchyBoundsListener l) {
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(HierarchyListener l) {
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(InputMethodListener l) {
if (l == null) {
return;
}
inputMethodListener = AWTEventMulticaster.add(inputMethodListener, l);
newEventsOnly = true;
} |
public synchronized void addKeyListener(KeyListener l) {
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(MouseListener l) {
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(MouseMotionListener l) {
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(MouseWheelListener l) {
if (l == null) {
return;
}
mouseWheelListener = AWTEventMulticaster.add(mouseWheelListener,l);
newEventsOnly = true;
// if this is a lightweight component, enable mouse events
// in the native container.
if (peer instanceof LightweightPeer) {
parent.proxyEnableEvents(AWTEvent.MOUSE_WHEEL_EVENT_MASK);
}
} Adds the specified mouse wheel listener to receive mouse wheel events
from this component. Containers also receive mouse wheel events from
sub-components.
For information on how mouse wheel events are dispatched, see
the class description for MouseWheelEvent .
If l is null, no exception is thrown and no
action is performed.
Refer to AWT Threading Issues for details on AWT's threading model. |
public void addNotify() {
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 = getContainer();
if (parent != null && parent.isLightweight()) {
relocateComponent();
if (!parent.isRecursivelyVisibleUpToHeavyweightContainer())
{
peer.setVisible(false);
}
}
}
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();
if (getContainer() != null && !isAddNotifyComplete) {
getContainer().increaseComponentCount(this);
}
// Update stacking order
updateZOrder();
if (!isAddNotifyComplete) {
mixOnShowing();
}
isAddNotifyComplete = true;
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);
}
}
} 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.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void addPropertyChangeListener(PropertyChangeListener listener) {
synchronized (getObjectLock()) {
if (listener == null) {
return;
}
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(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. |
public void addPropertyChangeListener(String propertyName,
PropertyChangeListener listener) {
synchronized (getObjectLock()) {
if (listener == null) {
return;
}
if (changeSupport == null) {
changeSupport = new PropertyChangeSupport(this);
}
changeSupport.addPropertyChangeListener(propertyName, 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. |
void adjustListeningChildrenOnParent(long mask,
int num) {
if (parent != null) {
parent.adjustListeningChildren(mask, num);
}
} |
public void applyComponentOrientation(ComponentOrientation orientation) {
if (orientation == null) {
throw new NullPointerException();
}
setComponentOrientation(orientation);
} Sets the ComponentOrientation property of this component
and all components contained within it.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
void applyCompoundShape(Region shape) {
checkTreeLock();
if (!areBoundsValid()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this + "; areBoundsValid = " + areBoundsValid());
}
return;
}
if (!isLightweight()) {
ComponentPeer peer = getPeer();
if (peer != null) {
// The Region class has some optimizations. That's why
// we should manually check whether it's empty and
// substitute the object ourselves. Otherwise we end up
// with some incorrect Region object with loX being
// greater than the hiX for instance.
if (shape.isEmpty()) {
shape = Region.EMPTY_REGION;
}
// Note: the shape is not really copied/cloned. We create
// the Region object ourselves, so there's no any possibility
// to modify the object outside of the mixing code.
// Nullifying compoundShape means that the component has normal shape
// (or has no shape at all).
if (shape.equals(getNormalShape())) {
if (this.compoundShape == null) {
return;
}
this.compoundShape = null;
peer.applyShape(null);
} else {
if (shape.equals(getAppliedShape())) {
return;
}
this.compoundShape = shape;
Point compAbsolute = getLocationOnWindow();
if (mixingLog.isLoggable(PlatformLogger.FINER)) {
mixingLog.fine("this = " + this +
"; compAbsolute=" + compAbsolute + "; shape=" + shape);
}
peer.applyShape(shape.getTranslatedRegion(-compAbsolute.x, -compAbsolute.y));
}
}
}
} Applies the shape to the component |
void applyCurrentShape() {
checkTreeLock();
if (!areBoundsValid()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this + "; areBoundsValid = " + areBoundsValid());
}
return; // Because applyCompoundShape() ignores such components anyway
}
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this);
}
applyCompoundShape(calculateCurrentShape());
} |
final boolean areBoundsValid() {
Container cont = getContainer();
return cont == null || cont.isValid() || cont.getLayout() == null;
} Check whether we can trust the current bounds of the component.
The return value of false indicates that the container of the
component is invalid, and therefore needs to be layed out, which would
probably mean changing the bounds of its children.
Null-layout of the container or absence of the container mean
the bounds of the component are final and can be trusted. |
public boolean areFocusTraversalKeysSet(int id) {
if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH - 1) {
throw new IllegalArgumentException("invalid focus traversal key identifier");
}
return (focusTraversalKeys != null && focusTraversalKeys[id] != null);
} 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. |
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(MouseWheelEvent e) {
} |
public Rectangle bounds() {
return new Rectangle(x, y, width, height);
} Deprecated! As - of JDK version 1.1,
replaced by getBounds().
|
final boolean canBeFocusOwner() {
// It is enabled, visible, focusable.
if (isEnabled() && isDisplayable() && isVisible() && isFocusable()) {
return true;
}
return false;
} |
final boolean canBeFocusOwnerRecursively() {
// - it is enabled, visible, focusable
if (!canBeFocusOwner()) {
return false;
}
// - it's parents are all enabled and showing
synchronized(getTreeLock()) {
if (parent != null) {
return parent.canContainFocusOwner(this);
}
}
return true;
} 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 |
void checkGD(String stringID) {
if (graphicsConfig != null) {
if (!graphicsConfig.getDevice().getIDstring().equals(stringID)) {
throw new IllegalArgumentException(
"adding a container to a container on a different GraphicsDevice");
}
}
} Checks that this component's GraphicsDevice
idString matches the string argument. |
public int checkImage(Image image,
ImageObserver observer) {
return checkImage(image, -1, -1, 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. |
public int checkImage(Image image,
int width,
int height,
ImageObserver observer) {
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);
}
} 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. |
final void checkTreeLock() {
if (!Thread.holdsLock(getTreeLock())) {
throw new IllegalStateException("This function should be called while holding treeLock");
}
} |
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 AWTEvent coalesceEvents(AWTEvent existingEvent,
AWTEvent newEvent) {
return null;
} 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. |
String constructComponentName() {
return null; // For strict compliance with prior platform versions, a Component
// that doesn't set its name should return null from
// getName()
} Constructs a name for this component. Called by getName
when the name is null. |
public boolean contains(Point p) {
return contains(p.x, p.y);
} Checks whether this component "contains" the specified point,
where the point's x and y coordinates are defined
to be relative to the coordinate system of this component. |
public boolean contains(int x,
int y) {
return inside(x, 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. |
boolean containsFocus() {
return isFocusOwner();
} |
int countHierarchyMembers() {
return 1;
} |
void createBufferStrategy(int numBuffers) {
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");
} 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. |
void createBufferStrategy(int numBuffers,
BufferCapabilities caps) throws AWTException {
// 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 != null) {
bufferStrategy.dispose();
}
if (numBuffers == 1) {
bufferStrategy = new SingleBufferStrategy(caps);
} else {
SunGraphicsEnvironment sge = (SunGraphicsEnvironment)
GraphicsEnvironment.getLocalGraphicsEnvironment();
if (!caps.isPageFlipping() && sge.isFlipStrategyPreferred(peer)) {
caps = new ProxyCapabilities(caps);
}
// assert numBuffers > 1;
if (caps.isPageFlipping()) {
bufferStrategy = new FlipSubRegionBufferStrategy(numBuffers, caps);
} else {
bufferStrategy = new BltSubRegionBufferStrategy(numBuffers, 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, dispose will be invoked on the existing
BufferStrategy. |
int createHierarchyEvents(int id,
Component changed,
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 (eventLog.isLoggable(PlatformLogger.FINE)) {
if (changeFlags != 0) {
eventLog.fine("Assertion (changeFlags == 0) failed");
}
}
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:
// assert false
if (eventLog.isLoggable(PlatformLogger.FINE)) {
eventLog.fine("This code must never be reached");
}
break;
}
return 0;
} |
public Image createImage(ImageProducer producer) {
ComponentPeer peer = this.peer;
if ((peer != null) && ! (peer instanceof LightweightPeer)) {
return peer.createImage(producer);
}
return getToolkit().createImage(producer);
} Creates an image from the specified image producer. |
public Image createImage(int width,
int height) {
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;
}
} Creates an off-screen drawable image
to be used for double buffering. |
public VolatileImage createVolatileImage(int width,
int height) {
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;
}
} Creates a volatile off-screen drawable image
to be used for double buffering. |
public VolatileImage createVolatileImage(int width,
int height,
ImageCapabilities caps) throws AWTException {
// REMIND : check caps
return createVolatileImage(width, height);
} 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. |
public void deliverEvent(Event e) {
postEvent(e);
} Deprecated! As - of JDK version 1.1,
replaced by dispatchEvent(AWTEvent e).
|
public void disable() {
if (enabled) {
KeyboardFocusManager.clearMostRecentFocusOwner(this);
synchronized (getTreeLock()) {
enabled = false;
// A disabled lw container is allowed to contain a focus owner.
if ((isFocusOwner() || (containsFocus() && !isLightweight())) &&
KeyboardFocusManager.isAutoFocusTransferEnabled())
{
// 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.
transferFocus(false);
}
ComponentPeer peer = this.peer;
if (peer != null) {
peer.setEnabled(false);
if (visible) {
updateCursorImmediately();
}
}
}
if (accessibleContext != null) {
accessibleContext.firePropertyChange(
AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
null, AccessibleState.ENABLED);
}
}
} Deprecated! As - of JDK version 1.1,
replaced by setEnabled(boolean).
|
protected final void disableEvents(long eventsToDisable) {
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);
}
}
} Disables the events defined by the specified event mask parameter
from being delivered to this component. |
public final void dispatchEvent(AWTEvent e) {
dispatchEventImpl(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. |
void dispatchEventImpl(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())) {
if (eventLog.isLoggable(PlatformLogger.FINE)) {
eventLog.fine("Event " + e + " is being dispatched on the wrong AppContext");
}
}
if (eventLog.isLoggable(PlatformLogger.FINEST)) {
eventLog.finest("{0}", e);
}
/*
* 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(PlatformLogger.FINEST)) {
focusLog.finest("" + 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
if(((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(PlatformLogger.FINEST)) {
focusLog.finest("3579: Skipping " + e);
}
return;
}
}
}
} else {
// When non-clients get focus, we need to explicitly disable the native
// input method. The native input method is actually not disabled when
// the active/passive/peered clients loose focus.
if (id == FocusEvent.FOCUS_GAINED) {
InputContext inputContext = getInputContext();
if (inputContext != null && inputContext instanceof sun.awt.im.InputContext) {
((sun.awt.im.InputContext)inputContext).disableNativeIM();
}
}
}
/*
* 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()) {
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("Pre-process consumed event");
}
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(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 (eventLog.isLoggable(PlatformLogger.FINEST)) {
eventLog.finest("dispatchMouseWheelToAncestor");
eventLog.finest("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 (eventLog.isLoggable(PlatformLogger.FINEST)) {
eventLog.finest("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.getXOnScreen(),
e.getYOnScreen(),
e.getClickCount(),
e.isPopupTrigger(),
e.getScrollType(),
e.getScrollAmount(),
e.getWheelRotation(),
e.getPreciseWheelRotation());
((AWTEvent)e).copyPrivateDataInto(newMWE);
// When dispatching a wheel event to
// ancestor, there is no need trying to find descendant
// lightweights to dispatch event to.
// If we dispatch the event to toplevel ancestor,
// this could encolse the loop: 6480024.
anc.dispatchEventToSelf(newMWE);
if (newMWE.isConsumed()) {
e.consume();
}
return true;
}
}
return false;
} |
public void doLayout() {
layout();
} Prompts the layout manager to lay out this component. This is
usually called when the component (more specifically, container)
is validated. |
public void enable() {
if (!enabled) {
synchronized (getTreeLock()) {
enabled = true;
ComponentPeer peer = this.peer;
if (peer != null) {
peer.setEnabled(true);
if (visible) {
updateCursorImmediately();
}
}
}
if (accessibleContext != null) {
accessibleContext.firePropertyChange(
AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
null, AccessibleState.ENABLED);
}
}
} Deprecated! As - of JDK version 1.1,
replaced by setEnabled(boolean).
|
public void enable(boolean b) {
if (b) {
enable();
} else {
disable();
}
} Deprecated! As - of JDK version 1.1,
replaced by setEnabled(boolean).
|
protected final void enableEvents(long eventsToEnable) {
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);
}
}
} 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. |
public void enableInputMethods(boolean enable) {
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;
}
} 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. |
boolean eventEnabled(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;
} |
Component findUnderMouseInWindow(PointerInfo pi) {
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;
} 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). |
protected void firePropertyChange(String propertyName,
Object oldValue,
Object newValue) {
PropertyChangeSupport changeSupport;
synchronized (getObjectLock()) {
changeSupport = this.changeSupport;
}
if (changeSupport == null ||
(oldValue != null && newValue != null && oldValue.equals(newValue))) {
return;
}
changeSupport.firePropertyChange(propertyName, oldValue, 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. |
protected void firePropertyChange(String propertyName,
boolean oldValue,
boolean newValue) {
PropertyChangeSupport changeSupport = this.changeSupport;
if (changeSupport == null || oldValue == newValue) {
return;
}
changeSupport.firePropertyChange(propertyName, oldValue, 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. |
protected void firePropertyChange(String propertyName,
int oldValue,
int newValue) {
PropertyChangeSupport changeSupport = this.changeSupport;
if (changeSupport == null || oldValue == newValue) {
return;
}
changeSupport.firePropertyChange(propertyName, oldValue, 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. |
public void firePropertyChange(String propertyName,
byte oldValue,
byte newValue) {
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, Byte.valueOf(oldValue), Byte.valueOf(newValue));
} Reports a bound property change. |
public void firePropertyChange(String propertyName,
char oldValue,
char newValue) {
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, new Character(oldValue), new Character(newValue));
} Reports a bound property change. |
public void firePropertyChange(String propertyName,
short oldValue,
short newValue) {
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, Short.valueOf(oldValue), Short.valueOf(newValue));
} Reports a bound property change. |
public void firePropertyChange(String propertyName,
long oldValue,
long newValue) {
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, Long.valueOf(oldValue), Long.valueOf(newValue));
} Reports a bound property change. |
public void firePropertyChange(String propertyName,
float oldValue,
float newValue) {
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, Float.valueOf(oldValue), Float.valueOf(newValue));
} Reports a bound property change. |
public void firePropertyChange(String propertyName,
double oldValue,
double newValue) {
if (changeSupport == null || oldValue == newValue) {
return;
}
firePropertyChange(propertyName, Double.valueOf(oldValue), Double.valueOf(newValue));
} Reports a bound property change. |
final AccessControlContext getAccessControlContext() {
if (acc == null) {
throw new SecurityException("Component is missing AccessControlContext");
}
return acc;
} |
public AccessibleContext getAccessibleContext() {
return accessibleContext;
} 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. |
int getAccessibleIndexInParent() {
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;
}
} Gets the index of this object in its accessible parent.
If this object does not have an accessible parent, returns
-1. |
AccessibleStateSet getAccessibleStateSet() {
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 (Component.isInstanceOf(this, "javax.swing.JComponent")) {
if (((javax.swing.JComponent) this).isOpaque()) {
states.add(AccessibleState.OPAQUE);
}
}
return states;
}
} Gets the current state set of this object. |
public float getAlignmentX() {
return CENTER_ALIGNMENT;
} 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. |
public float getAlignmentY() {
return CENTER_ALIGNMENT;
} 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. |
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 Color getBackground() {
Color background = this.background;
if (background != null) {
return background;
}
Container parent = this.parent;
return (parent != null) ? parent.getBackground() : null;
} Gets the background color of this component. |
public int getBaseline(int width,
int height) {
if (width < 0 || height < 0) {
throw new IllegalArgumentException(
"Width and height must be >= 0");
}
return -1;
} Returns the baseline. The baseline is measured from the top of
the component. This method is primarily meant for
LayoutManagers to align components along their
baseline. A return value less than 0 indicates this component
does not have a reasonable baseline and that
LayoutManagers should not align this component on
its baseline.
The default implementation returns -1. Subclasses that support
baseline should override appropriately. If a value >= 0 is
returned, then the component has a valid baseline for any
size >= the minimum size and getBaselineResizeBehavior
can be used to determine how the baseline changes with size. |
public BaselineResizeBehavior getBaselineResizeBehavior() {
return BaselineResizeBehavior.OTHER;
} Returns an enum indicating how the baseline of the component
changes as the size changes. This method is primarily meant for
layout managers and GUI builders.
The default implementation returns
BaselineResizeBehavior.OTHER. Subclasses that have a
baseline should override appropriately. Subclasses should
never return null; if the baseline can not be
calculated return BaselineResizeBehavior.OTHER. Callers
should first ask for the baseline using
getBaseline and if a value >= 0 is returned use
this method. It is acceptable for this method to return a
value other than BaselineResizeBehavior.OTHER even if
getBaseline returns a value less than 0. |
public Rectangle getBounds() {
return bounds();
} 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. |
public Rectangle getBounds(Rectangle rv) {
if (rv == null) {
return new Rectangle(getX(), getY(), getWidth(), getHeight());
}
else {
rv.setBounds(getX(), getY(), getWidth(), getHeight());
return 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. |
int getBoundsOp() {
assert Thread.holdsLock(getTreeLock());
return boundsOp;
} Should only be used in subclass getBounds to check that part of bounds
is actualy changing |
BufferStrategy getBufferStrategy() {
return bufferStrategy;
} |
public ColorModel getColorModel() {
ComponentPeer peer = this.peer;
if ((peer != null) && ! (peer instanceof LightweightPeer)) {
return peer.getColorModel();
} else if (GraphicsEnvironment.isHeadless()) {
return ColorModel.getRGBdefault();
} // else
return getToolkit().getColorModel();
} Gets the instance of ColorModel used to display
the component on the output device. |
public Component getComponentAt(Point p) {
return getComponentAt(p.x, p.y);
} Returns the component or subcomponent that contains the
specified point. |
public Component getComponentAt(int x,
int y) {
return locate(x, 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. |
public synchronized ComponentListener[] getComponentListeners() {
return (ComponentListener[]) (getListeners(ComponentListener.class));
} Returns an array of all the component listeners
registered on this component. |
public ComponentOrientation getComponentOrientation() {
return componentOrientation;
} 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. |
Container getContainer() {
return getParent();
} |
Window getContainingWindow() {
return SunToolkit.getContainingWindow(this);
} Returns the Window ancestor of the component. |
public Cursor getCursor() {
return getCursor_NoClientCode();
} 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. |
final Cursor getCursor_NoClientCode() {
Cursor cursor = this.cursor;
if (cursor != null) {
return cursor;
}
Container parent = this.parent;
if (parent != null) {
return parent.getCursor_NoClientCode();
} else {
return Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR);
}
} |
public synchronized DropTarget getDropTarget() {
return dropTarget;
} Gets the DropTarget associated with this
Component. |
public Container getFocusCycleRootAncestor() {
Container rootAncestor = this.parent;
while (rootAncestor != null && !rootAncestor.isFocusCycleRoot()) {
rootAncestor = rootAncestor.parent;
}
return rootAncestor;
} 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. |
public synchronized FocusListener[] getFocusListeners() {
return (FocusListener[]) (getListeners(FocusListener.class));
} Returns an array of all the focus listeners
registered on this component. |
public Set<AWTKeyStroke> getFocusTraversalKeys(int id) {
if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH - 1) {
throw new IllegalArgumentException("invalid focus traversal key identifier");
}
return getFocusTraversalKeys_NoIDCheck(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. |
public boolean getFocusTraversalKeysEnabled() {
return focusTraversalKeysEnabled;
} 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. |
final 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 Font getFont() {
return getFont_NoClientCode();
} Gets the font of this component. |
public FontMetrics getFontMetrics(Font font) {
// This is an unsupported hack, but left in for a customer.
// Do not remove.
FontManager fm = FontManagerFactory.getInstance();
if (fm instanceof SunFontManager
&& ((SunFontManager) fm).usePlatformFontMetrics()) {
if (peer != null &&
!(peer instanceof LightweightPeer)) {
return peer.getFontMetrics(font);
}
}
return sun.font.FontDesignMetrics.getMetrics(font);
} Gets the font metrics for the specified font.
Warning: Since Font metrics are affected by the
FontRenderContext and
this method does not provide one, it can return only metrics for
the default render context which may not match that used when
rendering on the Component if Graphics2D functionality is being
used. Instead metrics can be obtained at rendering time by calling
Graphics#getFontMetrics() or text measurement APIs on the
Font class. |
final Font getFont_NoClientCode() {
Font font = this.font;
if (font != null) {
return font;
}
Container parent = this.parent;
return (parent != null) ? parent.getFont_NoClientCode() : null;
} |
public Color getForeground() {
Color foreground = this.foreground;
if (foreground != null) {
return foreground;
}
Container parent = this.parent;
return (parent != null) ? parent.getForeground() : null;
} Gets the foreground color of this component. |
public Graphics getGraphics() {
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;
}
} Creates a graphics context for this component. This method will
return null if this component is currently not
displayable. |
public GraphicsConfiguration getGraphicsConfiguration() {
synchronized(getTreeLock()) {
return getGraphicsConfiguration_NoClientCode();
}
} 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. |
final GraphicsConfiguration getGraphicsConfiguration_NoClientCode() {
return graphicsConfig;
} |
final Graphics getGraphics_NoClientCode() {
ComponentPeer peer = this.peer;
if (peer instanceof LightweightPeer) {
// This is for a lightweight component, need to
// translate coordinate spaces and clip relative
// to the parent.
Container parent = this.parent;
if (parent == null) return null;
Graphics g = parent.getGraphics_NoClientCode();
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_NoClientCode());
return g;
} else {
return (peer != null) ? peer.getGraphics() : null;
}
} |
final ComponentPeer getHWPeerAboveMe() {
checkTreeLock();
Container cont = getContainer();
int indexAbove = getSiblingIndexAbove();
while (cont != null) {
for (int i = indexAbove; i > -1; i--) {
Component comp = cont.getComponent(i);
if (comp != null && comp.isDisplayable() && !comp.isLightweight()) {
return comp.getPeer();
}
}
// traversing the hierarchy up to the closest HW container;
// further traversing may return a component that is not actually
// a native sibling of this component and this kind of z-order
// request may not be allowed by the underlying system (6852051).
if (!cont.isLightweight()) {
break;
}
indexAbove = cont.getSiblingIndexAbove();
cont = cont.getContainer();
}
return null;
} |
public int getHeight() {
return height;
} Returns the current height of this component.
This method is preferable to writing
component.getBounds().height,
or component.getSize().height because it
doesn't cause any heap allocations. |
public synchronized HierarchyBoundsListener[] getHierarchyBoundsListeners() {
return (HierarchyBoundsListener[])
(getListeners(HierarchyBoundsListener.class));
} Returns an array of all the hierarchy bounds listeners
registered on this component. |
public synchronized HierarchyListener[] getHierarchyListeners() {
return (HierarchyListener[])(getListeners(HierarchyListener.class));
} Returns an array of all the hierarchy listeners
registered on this component. |
public boolean getIgnoreRepaint() {
return ignoreRepaint;
} |
public InputContext getInputContext() {
Container parent = this.parent;
if (parent == null) {
return null;
} else {
return parent.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. |
public synchronized InputMethodListener[] getInputMethodListeners() {
return (InputMethodListener[]) (getListeners(InputMethodListener.class));
} Returns an array of all the input method listeners
registered on this component. |
public InputMethodRequests getInputMethodRequests() {
return null;
} 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. |
public synchronized KeyListener[] getKeyListeners() {
return (KeyListener[]) (getListeners(KeyListener.class));
} Returns an array of all the key listeners
registered on this component. |
public T[] getListeners(Class<T> listenerType) {
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);
} 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. |
public Locale getLocale() {
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();
}
} Gets the locale of this component. |
public Point getLocation() {
return location();
} 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.
|
public Point getLocation(Point rv) {
if (rv == null) {
return new Point(getX(), getY());
}
else {
rv.setLocation(getX(), getY());
return 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. |
public Point getLocationOnScreen() {
synchronized (getTreeLock()) {
return getLocationOnScreen_NoTreeLock();
}
} 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. |
final 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");
}
} |
Point getLocationOnWindow() {
checkTreeLock();
Point curLocation = getLocation();
for (Container parent = getContainer();
parent != null && !(parent instanceof Window);
parent = parent.getContainer())
{
curLocation.x += parent.getX();
curLocation.y += parent.getY();
}
return curLocation;
} |
public Dimension getMaximumSize() {
if (isMaximumSizeSet()) {
return new Dimension(maxSize);
}
return new Dimension(Short.MAX_VALUE, Short.MAX_VALUE);
} Gets the maximum size of this component. |
public Dimension getMinimumSize() {
return minimumSize();
} Gets the mininimum size of this component. |
public synchronized MouseListener[] getMouseListeners() {
return (MouseListener[]) (getListeners(MouseListener.class));
} Returns an array of all the mouse listeners
registered on this component. |
public synchronized MouseMotionListener[] getMouseMotionListeners() {
return (MouseMotionListener[]) (getListeners(MouseMotionListener.class));
} Returns an array of all the mouse motion listeners
registered on this component. |
public Point getMousePosition() throws HeadlessException {
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());
}
} 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 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. |
public synchronized MouseWheelListener[] getMouseWheelListeners() {
return (MouseWheelListener[]) (getListeners(MouseWheelListener.class));
} Returns an array of all the mouse wheel listeners
registered on this component. |
public String getName() {
if (name == null && !nameExplicitlySet) {
synchronized(getObjectLock()) {
if (name == null && !nameExplicitlySet)
name = constructComponentName();
}
}
return name;
} Gets the name of the component. |
Container getNativeContainer() {
Container p = parent;
while (p != null && p.peer instanceof LightweightPeer) {
p = p.getParent_NoClientCode();
}
return p;
} |
final Component getNextFocusCandidate() {
Container rootAncestor = getTraversalRoot();
Component comp = this;
while (rootAncestor != null &&
!(rootAncestor.isShowing() && rootAncestor.canBeFocusOwner()))
{
comp = rootAncestor;
rootAncestor = comp.getFocusCycleRootAncestor();
}
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("comp = " + comp + ", root = " + rootAncestor);
}
Component candidate = null;
if (rootAncestor != null) {
FocusTraversalPolicy policy = rootAncestor.getFocusTraversalPolicy();
Component toFocus = policy.getComponentAfter(rootAncestor, comp);
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("component after is " + toFocus);
}
if (toFocus == null) {
toFocus = policy.getDefaultComponent(rootAncestor);
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("default component is " + toFocus);
}
}
if (toFocus == null) {
Applet applet = EmbeddedFrame.getAppletIfAncestorOf(this);
if (applet != null) {
toFocus = applet;
}
}
candidate = toFocus;
}
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("Focus transfer candidate: " + candidate);
}
return candidate;
} |
final Region getNormalShape() {
checkTreeLock();
//XXX: we may take into account a user-specified shape for this component
Point compAbsolute = getLocationOnWindow();
return
Region.getInstanceXYWH(
compAbsolute.x,
compAbsolute.y,
getWidth(),
getHeight()
);
} Returns the full shape of the component located in window coordinates |
Object getObjectLock() {
return objectLock;
} |
Region getOpaqueShape() {
checkTreeLock();
if (mixingCutoutRegion != null) {
return mixingCutoutRegion;
} else {
return getNormalShape();
}
} Returns the "opaque shape" of the component.
The opaque shape of a lightweight components is the actual shape that
needs to be cut off of the heavyweight components in order to mix this
lightweight component correctly with them.
The method is overriden in the java.awt.Container to handle non-opaque
containers containing opaque children.
See 6637655 for details. |
public Container getParent() {
return getParent_NoClientCode();
} Gets the parent of this component. |
final Container getParent_NoClientCode() {
return parent;
} |
public ComponentPeer getPeer() {
return peer;
} Deprecated! As - of JDK version 1.1,
programs should not directly manipulate peers;
replaced by boolean isDisplayable().
|
public Dimension getPreferredSize() {
return preferredSize();
} Gets the preferred size of this component. |
public PropertyChangeListener[] getPropertyChangeListeners() {
synchronized (getObjectLock()) {
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners();
}
} Returns an array of all the property change listeners
registered on this component. |
public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
synchronized (getObjectLock()) {
if (changeSupport == null) {
return new PropertyChangeListener[0];
}
return changeSupport.getPropertyChangeListeners(propertyName);
}
} Returns an array of all the listeners which have been associated
with the named property. |
final int getSiblingIndexAbove() {
checkTreeLock();
Container parent = getContainer();
if (parent == null) {
return -1;
}
int nextAbove = parent.getComponentZOrder(this) - 1;
return nextAbove < 0 ? -1 : nextAbove;
} |
final int getSiblingIndexBelow() {
checkTreeLock();
Container parent = getContainer();
if (parent == null) {
return -1;
}
int nextBelow = parent.getComponentZOrder(this) + 1;
return nextBelow >= parent.getComponentCount() ? -1 : nextBelow;
} |
public Dimension getSize() {
return size();
} 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. |
public Dimension getSize(Dimension rv) {
if (rv == null) {
return new Dimension(getWidth(), getHeight());
}
else {
rv.setSize(getWidth(), getHeight());
return 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. |
public Toolkit getToolkit() {
return getToolkitImpl();
} 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. |
final 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();
} |
Container getTraversalRoot() {
return getFocusCycleRootAncestor();
} |
public final Object getTreeLock() {
return LOCK;
} Gets this component's locking object (the object that owns the thread
synchronization monitor) for AWT component-tree and layout
operations. |
public int getWidth() {
return width;
} 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. |
public int getX() {
return x;
} 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. |
public int getY() {
return y;
} 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. |
public boolean gotFocus(Event evt,
Object what) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processFocusEvent(FocusEvent).
|
public boolean handleEvent(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;
} Deprecated! As - of JDK version 1.1
replaced by processEvent(AWTEvent).
|
public boolean hasFocus() {
return (KeyboardFocusManager.getCurrentKeyboardFocusManager().
getFocusOwner() == this);
} Returns true if this Component is the
focus owner. This method is obsolete, and has been replaced by
isFocusOwner(). |
public void hide() {
isPacked = false;
if (visible) {
clearCurrentFocusCycleRootOnHide();
clearMostRecentFocusOwnerOnHide();
synchronized (getTreeLock()) {
visible = false;
mixOnHiding(isLightweight());
if (containsFocus() && KeyboardFocusManager.isAutoFocusTransferEnabled()) {
transferFocus(true);
}
ComponentPeer peer = this.peer;
if (peer != null) {
peer.setVisible(false);
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();
}
}
} Deprecated! As - of JDK version 1.1,
replaced by setVisible(boolean).
|
public boolean imageUpdate(Image img,
int infoflags,
int x,
int y,
int w,
int h) {
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;
} 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. |
void initializeFocusTraversalKeys() {
focusTraversalKeys = new Set[3];
} |
public boolean inside(int x,
int y) {
return (x >= 0) && (x < width) && (y >= 0) && (y < height);
} Deprecated! As - of JDK version 1.1,
replaced by contains(int, int).
|
public void invalidate() {
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;
}
invalidateParent();
}
} Invalidates this component and its ancestors.
By default, all the ancestors of the component up to the top-most
container of the hierarchy are marked invalid. If the {@code
java.awt.smartInvalidate} system property is set to {@code true},
invalidation stops on the nearest validate root of this component.
Marking a container invalid indicates that the container needs to
be laid out.
This method is called automatically when any layout-related information
changes (e.g. setting the bounds of the component, or adding the
component to a container).
This method might be called often, so it should work fast. |
final void invalidateIfValid() {
if (isValid()) {
invalidate();
}
} Invalidates the component unless it is already invalid. |
void invalidateParent() {
if (parent != null) {
parent.invalidateIfValid();
}
} Invalidates the parent of this component if any.
This method MUST BE invoked under the TreeLock. |
boolean isAutoFocusTransferOnDisposal() {
return autoFocusTransferOnDisposal;
} |
public boolean isBackgroundSet() {
return (background != null);
} 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. |
final boolean isCoalescingEnabled() {
return coalescingEnabled;
} Indicates whether coalesceEvents may do something. |
public boolean isCursorSet() {
return (cursor != null);
} 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. |
public boolean isDisplayable() {
return getPeer() != null;
} 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. |
public boolean isDoubleBuffered() {
return false;
} 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. |
public boolean isEnabled() {
return isEnabledImpl();
} 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. |
final boolean isEnabledImpl() {
return enabled;
} |
public boolean isFocusCycleRoot(Container container) {
Container rootAncestor = getFocusCycleRootAncestor();
return (rootAncestor == 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. |
public boolean isFocusOwner() {
return hasFocus();
} Returns true if this Component is the
focus owner. |
public boolean isFocusTraversable() {
if (isFocusTraversableOverridden == FOCUS_TRAVERSABLE_UNKNOWN) {
isFocusTraversableOverridden = FOCUS_TRAVERSABLE_DEFAULT;
}
return focusable;
} Deprecated! As - of 1.4, replaced by isFocusable().
Returns whether this Component can become the focus
owner. |
final boolean isFocusTraversableOverridden() {
return (isFocusTraversableOverridden != FOCUS_TRAVERSABLE_DEFAULT);
} |
public boolean isFocusable() {
return isFocusTraversable();
} Returns whether this Component can be focused. |
public boolean isFontSet() {
return (font != null);
} 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. |
public boolean isForegroundSet() {
return (foreground != null);
} 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. |
static boolean isInstanceOf(Object obj,
String className) {
if (obj == null) return false;
if (className == null) return false;
Class cls = obj.getClass();
while (cls != null) {
if (cls.getName().equals(className)) {
return true;
}
cls = cls.getSuperclass();
}
return false;
} Checks that the given object is instance of the given class. |
public boolean isLightweight() {
return getPeer() instanceof LightweightPeer;
} 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. |
public boolean isMaximumSizeSet() {
return maxSizeSet;
} Returns true if the maximum size has been set to a non-null
value otherwise returns false. |
public boolean isMinimumSizeSet() {
return minSizeSet;
} Returns whether or not setMinimumSize has been
invoked with a non-null value. |
final boolean isMixingNeeded() {
if (SunToolkit.getSunAwtDisableMixing()) {
if (mixingLog.isLoggable(PlatformLogger.FINEST)) {
mixingLog.finest("this = " + this + "; Mixing disabled via sun.awt.disableMixing");
}
return false;
}
if (!areBoundsValid()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this + "; areBoundsValid = " + areBoundsValid());
}
return false;
}
Window window = getContainingWindow();
if (window != null) {
if (!window.hasHeavyweightDescendants() || !window.hasLightweightDescendants()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("containing window = " + window +
"; has h/w descendants = " + window.hasHeavyweightDescendants() +
"; has l/w descendants = " + window.hasLightweightDescendants());
}
return false;
}
} else {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this + "; containing window is null");
}
return false;
}
return true;
} |
final boolean isNonOpaqueForMixing() {
return mixingCutoutRegion != null &&
mixingCutoutRegion.isEmpty();
} |
public boolean isOpaque() {
if (getPeer() == null) {
return false;
}
else {
return !isLightweight();
}
} 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.
Subclasses that guarantee to always completely paint their
contents should override this method and return true. |
public boolean isPreferredSizeSet() {
return prefSizeSet;
} Returns true if the preferred size has been set to a
non-null value otherwise returns false. |
boolean isRecursivelyVisible() {
return visible && (parent == null || parent.isRecursivelyVisible());
} Determines whether this component will be displayed on the screen. |
boolean isSameOrAncestorOf(Component comp,
boolean allowChildren) {
return comp == this;
} Overridden in Container. Must be called under TreeLock. |
public boolean isShowing() {
if (visible && (peer != null)) {
Container parent = this.parent;
return (parent == null) || parent.isShowing();
}
return false;
} Determines whether this component is showing on screen. This means
that the component must be visible, and it must be in a container
that is visible and showing.
Note: sometimes there is no way to detect whether the
{@code Component} is actually visible to the user. This can happen when:
- the component has been added to a visible {@code ScrollPane} but
the {@code Component} is not currently in the scroll pane's view port.
- the {@code Component} is obscured by another {@code Component} or
{@code Container}.
|
public boolean isValid() {
return (peer != null) && valid;
} 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. |
public boolean isVisible() {
return isVisible_NoClientCode();
} 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. |
final boolean isVisible_NoClientCode() {
return visible;
} |
public boolean keyDown(Event evt,
int key) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processKeyEvent(KeyEvent).
|
public boolean keyUp(Event evt,
int key) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processKeyEvent(KeyEvent).
|
public void layout() {
} Deprecated! As - of JDK version 1.1,
replaced by doLayout().
|
void lightweightPaint(Graphics g) {
paint(g);
} Simulates the peer callbacks into java.awt for painting of
lightweight Components. |
void lightweightPrint(Graphics g) {
print(g);
} Simulates the peer callbacks into java.awt for printing of
lightweight Components. |
public void list() {
list(System.out, 0);
} Prints a listing of this component to the standard system output
stream System.out. |
public void list(PrintStream out) {
list(out, 0);
} Prints a listing of this component to the specified output
stream. |
public void list(PrintWriter out) {
list(out, 0);
} Prints a listing to the specified print writer. |
public void list(PrintStream out,
int indent) {
for (int i = 0 ; i < indent ; i++) {
out.print(" ");
}
out.println(this);
} Prints out a list, starting at the specified indentation, to the
specified print stream. |
public void list(PrintWriter out,
int indent) {
for (int i = 0 ; i < indent ; i++) {
out.print(" ");
}
out.println(this);
} Prints out a list, starting at the specified indentation, to
the specified print writer. |
public Component locate(int x,
int y) {
return contains(x, y) ? this : null;
} Deprecated! As - of JDK version 1.1,
replaced by getComponentAt(int, int).
|
public Point location() {
return location_NoClientCode();
} Deprecated! As - of JDK version 1.1,
replaced by getLocation().
|
public boolean lostFocus(Event evt,
Object what) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processFocusEvent(FocusEvent).
|
public 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.getMinimumSize() :
size();
dim = minSize;
}
}
return new Dimension(dim);
} Deprecated! As - of JDK version 1.1,
replaced by getMinimumSize().
|
void mixOnHiding(boolean isLightweight) {
// We cannot be sure that the peer exists at this point, so we need the argument
// to find out whether the hiding component is (well, actually was) a LW or a HW.
synchronized (getTreeLock()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this + "; isLightweight = " + isLightweight);
}
if (!isMixingNeeded()) {
return;
}
if (isLightweight) {
applyCurrentShapeBelowMe();
}
}
} |
void mixOnReshaping() {
synchronized (getTreeLock()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this);
}
if (!isMixingNeeded()) {
return;
}
if (isLightweight()) {
applyCurrentShapeBelowMe();
} else {
applyCurrentShape();
}
}
} |
void mixOnShowing() {
synchronized (getTreeLock()) {
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this);
}
if (!isMixingNeeded()) {
return;
}
if (isLightweight()) {
subtractAndApplyShapeBelowMe();
} else {
applyCurrentShape();
}
}
} |
void mixOnValidating() {
// This method gets overriden in the Container. Obviously, a plain
// non-container components don't need to handle validation.
} |
void mixOnZOrderChanging(int oldZorder,
int newZorder) {
synchronized (getTreeLock()) {
boolean becameHigher = newZorder < oldZorder;
Container parent = getContainer();
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this +
"; oldZorder=" + oldZorder + "; newZorder=" + newZorder + "; parent=" + parent);
}
if (!isMixingNeeded()) {
return;
}
if (isLightweight()) {
if (becameHigher) {
if (parent != null && isShowing()) {
parent.recursiveSubtractAndApplyShape(getOpaqueShape(), getSiblingIndexBelow(), oldZorder);
}
} else {
if (parent != null) {
parent.recursiveApplyCurrentShape(oldZorder, newZorder);
}
}
} else {
if (becameHigher) {
applyCurrentShape();
} else {
if (parent != null) {
Region shape = getAppliedShape();
for (int index = oldZorder; index < newZorder; index++) {
Component c = parent.getComponent(index);
if (c.isLightweight() && c.isShowing()) {
shape = shape.getDifference(c.getOpaqueShape());
}
}
applyCompoundShape(shape);
}
}
}
}
} |
public boolean mouseDown(Event evt,
int x,
int y) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processMouseEvent(MouseEvent).
|
public boolean mouseDrag(Event evt,
int x,
int y) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processMouseMotionEvent(MouseEvent).
|
public boolean mouseEnter(Event evt,
int x,
int y) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processMouseEvent(MouseEvent).
|
public boolean mouseExit(Event evt,
int x,
int y) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processMouseEvent(MouseEvent).
|
public boolean mouseMove(Event evt,
int x,
int y) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processMouseMotionEvent(MouseEvent).
|
public boolean mouseUp(Event evt,
int x,
int y) {
return false;
} Deprecated! As - of JDK version 1.1,
replaced by processMouseEvent(MouseEvent).
|
public void move(int x,
int y) {
synchronized(getTreeLock()) {
setBoundsOp(ComponentPeer.SET_LOCATION);
setBounds(x, y, width, height);
}
} Deprecated! As - of JDK version 1.1,
replaced by setLocation(int, int).
|
public void nextFocus() {
transferFocus(false);
} Deprecated! As - of JDK version 1.1,
replaced by transferFocus().
|
int numListening(long mask) {
// One mask or the other, but not neither or both.
if (eventLog.isLoggable(PlatformLogger.FINE)) {
if ((mask != AWTEvent.HIERARCHY_EVENT_MASK) &&
(mask != AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK))
{
eventLog.fine("Assertion failed");
}
}
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(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(Graphics g) {
if (isShowing()) {
GraphicsCallback.PeerPaintCallback.getInstance().
runOneComponent(this, new Rectangle(0, 0, width, height),
g, g.getClip(),
GraphicsCallback.LIGHTWEIGHTS |
GraphicsCallback.HEAVYWEIGHTS);
}
} 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. |
void paintHeavyweightComponents(Graphics g) {
} Paints all the heavyweight subcomponents. |
protected String paramString() {
String thisName = getName();
String str = (thisName != null? thisName : "") + "," + x + "," + y + "," + width + "x" + height;
if (!isValid()) {
str += ",invalid";
}
if (!visible) {
str += ",hidden";
}
if (!enabled) {
str += ",disabled";
}
return str;
} 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. |
Point pointRelativeToComponent(Point absolute) {
Point compCoords = getLocationOnScreen();
return new Point(absolute.x - compCoords.x,
absolute.y - compCoords.y);
} Translates absolute coordinates into coordinates in the coordinate
space of this component. |
public boolean postEvent(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;
} Deprecated! As - of JDK version 1.1,
replaced by dispatchEvent(AWTEvent).
|
boolean postsOldMouseEvents() {
return false;
} |
public 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.getPreferredSize() :
getMinimumSize();
dim = prefSize;
}
}
return new Dimension(dim);
} Deprecated! As - of JDK version 1.1,
replaced by getPreferredSize().
|
public boolean prepareImage(Image image,
ImageObserver observer) {
return prepareImage(image, -1, -1, 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. |
public boolean prepareImage(Image image,
int width,
int height,
ImageObserver observer) {
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);
}
} 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. |
public void print(Graphics g) {
paint(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. |
public void printAll(Graphics g) {
if (isShowing()) {
GraphicsCallback.PeerPrintCallback.getInstance().
runOneComponent(this, new Rectangle(0, 0, width, height),
g, g.getClip(),
GraphicsCallback.LIGHTWEIGHTS |
GraphicsCallback.HEAVYWEIGHTS);
}
} 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. |
void printHeavyweightComponents(Graphics g) {
} Prints all the heavyweight subcomponents. |
protected void processComponentEvent(ComponentEvent e) {
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;
}
}
} 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. |
protected void processEvent(AWTEvent e) {
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;
}
}
} 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. |
protected void processFocusEvent(FocusEvent e) {
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;
}
}
} 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. |
protected void processHierarchyBoundsEvent(HierarchyEvent e) {
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;
}
}
} 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. |
protected void processHierarchyEvent(HierarchyEvent e) {
HierarchyListener listener = hierarchyListener;
if (listener != null) {
int id = e.getID();
switch (id) {
case HierarchyEvent.HIERARCHY_CHANGED:
listener.hierarchyChanged(e);
break;
}
}
} 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. |
protected void processInputMethodEvent(InputMethodEvent e) {
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;
}
}
} 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. |
protected void processKeyEvent(KeyEvent e) {
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;
}
}
} 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. |
protected void processMouseEvent(MouseEvent e) {
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;
}
}
} 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. |
protected void processMouseMotionEvent(MouseEvent e) {
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;
}
}
} 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. |
protected void processMouseWheelEvent(MouseWheelEvent e) {
MouseWheelListener listener = mouseWheelListener;
if (listener != null) {
int id = e.getID();
switch(id) {
case MouseEvent.MOUSE_WHEEL:
listener.mouseWheelMoved(e);
break;
}
}
} 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 MouseWheelEvent .
Note that if the event parameter is null
the behavior is unspecified and may result in an
exception. |
final void relocateComponent() {
synchronized (getTreeLock()) {
if (peer == null) {
return;
}
int nativeX = x;
int nativeY = y;
for (Component cont = getContainer();
cont != null && cont.isLightweight();
cont = cont.getContainer())
{
nativeX += cont.x;
nativeY += cont.y;
}
peer.setBounds(nativeX, nativeY, width, height,
ComponentPeer.SET_LOCATION);
}
} Fix the location of the HW component in a LW container hierarchy. |
public void remove(MenuComponent popup) {
synchronized (getTreeLock()) {
if (popups == null) {
return;
}
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;
}
}
}
} Removes the specified popup menu from the component. |
public synchronized void removeComponentListener(ComponentListener l) {
if (l == null) {
return;
}
componentListener = AWTEventMulticaster.remove(componentListener, l);
} |
public synchronized void removeFocusListener(FocusListener l) {
if (l == null) {
return;
}
focusListener = AWTEventMulticaster.remove(focusListener, l);
} |
public void removeHierarchyBoundsListener(HierarchyBoundsListener l) {
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(HierarchyListener l) {
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(InputMethodListener l) {
if (l == null) {
return;
}
inputMethodListener = AWTEventMulticaster.remove(inputMethodListener, l);
} |
public synchronized void removeKeyListener(KeyListener l) {
if (l == null) {
return;
}
keyListener = AWTEventMulticaster.remove(keyListener, l);
} |
public synchronized void removeMouseListener(MouseListener l) {
if (l == null) {
return;
}
mouseListener = AWTEventMulticaster.remove(mouseListener, l);
} |
public synchronized void removeMouseMotionListener(MouseMotionListener l) {
if (l == null) {
return;
}
mouseMotionListener = AWTEventMulticaster.remove(mouseMotionListener, l);
} |
public synchronized void removeMouseWheelListener(MouseWheelListener l) {
if (l == null) {
return;
}
mouseWheelListener = AWTEventMulticaster.remove(mouseWheelListener, l);
} |
public void removeNotify() {
KeyboardFocusManager.clearMostRecentFocusOwner(this);
if (KeyboardFocusManager.getCurrentKeyboardFocusManager().
getPermanentFocusOwner() == this)
{
KeyboardFocusManager.getCurrentKeyboardFocusManager().
setGlobalPermanentFocusOwner(null);
}
synchronized (getTreeLock()) {
if (isFocusOwner() && KeyboardFocusManager.isAutoFocusTransferEnabledFor(this)) {
transferFocus(true);
}
if (getContainer() != null && isAddNotifyComplete) {
getContainer().decreaseComponentCount(this);
}
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) {
boolean isLightweight = isLightweight();
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.setVisible(false);
}
peer = null; // Stop peer updates.
peerFont = null;
Toolkit.getEventQueue().removeSourceEvents(this, false);
KeyboardFocusManager.getCurrentKeyboardFocusManager().
discardKeyEvents(this);
p.dispose();
mixOnHiding(isLightweight);
isAddNotifyComplete = false;
// Nullifying compoundShape means that the component has normal shape
// (or has no shape at all).
this.compoundShape = null;
}
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);
}
}
} 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. |
public void removePropertyChangeListener(PropertyChangeListener listener) {
synchronized (getObjectLock()) {
if (listener == null || changeSupport == null) {
return;
}
changeSupport.removePropertyChangeListener(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. |
public void removePropertyChangeListener(String propertyName,
PropertyChangeListener listener) {
synchronized (getObjectLock()) {
if (listener == null || changeSupport == null) {
return;
}
changeSupport.removePropertyChangeListener(propertyName, 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. |
public void repaint() {
repaint(0, 0, 0, width, height);
} 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. |
public void repaint(long tm) {
repaint(tm, 0, 0, width, height);
} 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. |
public void repaint(int x,
int y,
int width,
int height) {
repaint(0, x, y, width, 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. |
public void repaint(long tm,
int x,
int y,
int width,
int height) {
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) {
if (x < 0) {
width += x;
x = 0;
}
if (y < 0) {
height += y;
y = 0;
}
int pwidth = (width > this.width) ? this.width : width;
int pheight = (height > this.height) ? this.height : height;
if (pwidth < = 0 || pheight < = 0) {
return;
}
int px = this.x + x;
int py = this.y + y;
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);
}
}
} 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. |
public void requestFocus() {
requestFocusHelper(false, true);
} 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, focusable, visible and all of
its ancestors (with the exception of the top-level Window) must
be visible 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.
Note: Not all focus transfers result from invoking this method. As
such, a component may receive focus without this or any of the other
{@code requestFocus} methods of {@code Component} being invoked. |
boolean requestFocus(Cause cause) {
return requestFocusHelper(false, true, cause);
} |
protected boolean requestFocus(boolean temporary) {
return requestFocusHelper(temporary, true);
} 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, focusable, visible and all of its ancestors (with
the exception of the top-level Window) must be visible 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.
Note: Not all focus transfers result from invoking this method. As
such, a component may receive focus without this or any of the other
{@code requestFocus} methods of {@code Component} being invoked. |
boolean requestFocus(boolean temporary,
Cause cause) {
return requestFocusHelper(temporary, true, cause);
} |
final boolean requestFocusHelper(boolean temporary,
boolean focusedWindowChangeAllowed) {
return requestFocusHelper(temporary, focusedWindowChangeAllowed, CausedFocusEvent.Cause.UNKNOWN);
} |
final boolean requestFocusHelper(boolean temporary,
boolean focusedWindowChangeAllowed,
Cause cause) {
if (!isRequestFocusAccepted(temporary, focusedWindowChangeAllowed, cause)) {
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("requestFocus is not accepted");
}
return false;
}
// Update most-recent map
KeyboardFocusManager.setMostRecentFocusOwner(this);
Component window = this;
while ( (window != null) && !(window instanceof Window)) {
if (!window.isVisible()) {
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("component is recurively invisible");
}
return false;
}
window = window.parent;
}
ComponentPeer peer = this.peer;
Component heavyweight = (peer instanceof LightweightPeer)
? getNativeContainer() : this;
if (heavyweight == null || !heavyweight.isVisible()) {
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("Component is not a part of visible hierarchy");
}
return false;
}
peer = heavyweight.peer;
if (peer == null) {
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("Peer is null");
}
return false;
}
// Focus this Component
long time = EventQueue.getMostRecentEventTime();
boolean success = peer.requestFocus
(this, temporary, focusedWindowChangeAllowed, time, cause);
if (!success) {
KeyboardFocusManager.getCurrentKeyboardFocusManager
(appContext).dequeueKeyEvents(time, this);
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("Peer request failed");
}
} else {
if (focusLog.isLoggable(PlatformLogger.FINEST)) {
focusLog.finest("Pass for " + this);
}
}
return success;
} |
public boolean requestFocusInWindow() {
return requestFocusHelper(false, false);
} 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, focusable, visible
and all of its ancestors (with the exception of the top-level
Window) must be visible 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.
Note: Not all focus transfers result from invoking this method. As
such, a component may receive focus without this or any of the other
{@code requestFocus} methods of {@code Component} being invoked. |
boolean requestFocusInWindow(Cause cause) {
return requestFocusHelper(false, false, cause);
} |
protected boolean requestFocusInWindow(boolean temporary) {
return requestFocusHelper(temporary, false);
} 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, focusable, visible and all of its ancestors (with
the exception of the top-level Window) must be visible 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.
Note: Not all focus transfers result from invoking this method. As
such, a component may receive focus without this or any of the other
{@code requestFocus} methods of {@code Component} being invoked. |
boolean requestFocusInWindow(boolean temporary,
Cause cause) {
return requestFocusHelper(temporary, false, cause);
} |
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;
}
boolean needNotify = true;
mixOnReshaping();
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);
// fix for 5025858: do not send ComponentEvents for toplevel
// windows here as it is done from peer or native code when
// the window is really resized or moved, otherwise some
// events may be sent twice
if (this instanceof Window) {
needNotify = false;
}
}
if (resized) {
invalidate();
}
if (parent != null) {
parent.invalidateIfValid();
}
}
if (needNotify) {
notifyNewBounds(resized, moved);
}
repaintParentIfNeeded(oldX, oldY, oldWidth, oldHeight);
} finally {
setBoundsOp(ComponentPeer.RESET_OPERATION);
}
}
} Deprecated! As - of JDK version 1.1,
replaced by setBounds(int, int, int, int).
|
public void resize(Dimension d) {
setSize(d.width, d.height);
} Deprecated! As - of JDK version 1.1,
replaced by setSize(Dimension).
|
public void resize(int width,
int height) {
synchronized(getTreeLock()) {
setBoundsOp(ComponentPeer.SET_SIZE);
setBounds(x, y, width, height);
}
} Deprecated! As - of JDK version 1.1,
replaced by setSize(int, int).
|
public void revalidate() {
synchronized (getTreeLock()) {
invalidate();
Container root = getContainer();
if (root == null) {
// There's no parents. Just validate itself.
validate();
} else {
while (!root.isValidateRoot()) {
if (root.getContainer() == null) {
// If there's no validate roots, we'll validate the
// topmost container
break;
}
root = root.getContainer();
}
root.validate();
}
}
} Revalidates the component hierarchy up to the nearest validate root.
This method first invalidates the component hierarchy starting from this
component up to the nearest validate root. Afterwards, the component
hierarchy is validated starting from the nearest validate root.
This is a convenience method supposed to help application developers
avoid looking for validate roots manually. Basically, it's equivalent to
first calling the #invalidate() method on this component, and
then calling the #validate() method on the nearest validate
root. |
void setAutoFocusTransferOnDisposal(boolean value) {
autoFocusTransferOnDisposal = value;
} |
public void setBackground(Color c) {
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);
} 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. |
public void setBounds(Rectangle r) {
setBounds(r.x, r.y, r.width, r.height);
} 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
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setBounds(int x,
int y,
int width,
int height) {
reshape(x, y, width, 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.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
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(ComponentOrientation o) {
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.
invalidateIfValid();
} Sets the language-sensitive orientation that is to be used to order
the elements or text within this component. Language-sensitive
LayoutManager and Component
subclasses will use this property to
determine how to lay out and draw components.
At construction time, a component's orientation is set to
ComponentOrientation.UNKNOWN,
indicating that it has not been specified
explicitly. The UNKNOWN orientation behaves the same as
ComponentOrientation.LEFT_TO_RIGHT.
To set the orientation of a single component, use this method.
To set the orientation of an entire component
hierarchy, use
applyComponentOrientation .
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setCursor(Cursor cursor) {
this.cursor = cursor;
updateCursorImmediately();
} 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.
The method may have no visual effect if the Java platform
implementation and/or the native system do not support
changing the mouse cursor shape. |
public synchronized void setDropTarget(DropTarget dt) {
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!
}
}
}
}
} Associate a DropTarget with this component.
The Component will receive drops only if it
is enabled. |
public void setEnabled(boolean b) {
enable(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.
Note: Disabling a heavyweight container prevents all components
in this container from receiving any input events. But disabling a
lightweight container affects only this container. |
public void setFocusTraversalKeys(int id,
Set<AWTKeyStroke> keystrokes) {
if (id < 0 || id >= KeyboardFocusManager.TRAVERSAL_KEY_LENGTH - 1) {
throw new IllegalArgumentException("invalid focus traversal key identifier");
}
setFocusTraversalKeys_NoIDCheck(id, 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. |
public void setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled) {
boolean oldFocusTraversalKeysEnabled;
synchronized (this) {
oldFocusTraversalKeysEnabled = this.focusTraversalKeysEnabled;
this.focusTraversalKeysEnabled = focusTraversalKeysEnabled;
}
firePropertyChange("focusTraversalKeysEnabled",
oldFocusTraversalKeysEnabled,
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. |
final void setFocusTraversalKeys_NoIDCheck(int id,
Set<AWTKeyStroke> 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");
}
// Fix for 6195828:
//According to javadoc this method should throw IAE instead of ClassCastException
if (!(obj instanceof AWTKeyStroke)) {
throw new IllegalArgumentException("object is expected to be AWTKeyStroke");
}
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) {
boolean oldFocusable;
synchronized (this) {
oldFocusable = this.focusable;
this.focusable = focusable;
}
isFocusTraversableOverridden = FOCUS_TRAVERSABLE_SET;
firePropertyChange("focusable", oldFocusable, focusable);
if (oldFocusable && !focusable) {
if (isFocusOwner() && KeyboardFocusManager.isAutoFocusTransferEnabled()) {
transferFocus(true);
}
KeyboardFocusManager.clearMostRecentFocusOwner(this);
}
} Sets the focusable state of this Component to the specified value. This
value overrides the Component's default focusability. |
public void setFont(Font f) {
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.
// Fix for 6213660. Should compare old and new fonts and do not
// call invalidate() if they are equal.
if (f != oldFont && (oldFont == null ||
!oldFont.equals(f))) {
invalidateIfValid();
}
} Sets the font of this component.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setForeground(Color c) {
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);
} Sets the foreground color of this component. |
void setGraphicsConfiguration(GraphicsConfiguration gc) {
synchronized(getTreeLock()) {
if (updateGraphicsData(gc)) {
removeNotify();
addNotify();
}
}
} |
public void setIgnoreRepaint(boolean ignoreRepaint) {
this.ignoreRepaint = 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. |
public void setLocale(Locale l) {
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.
invalidateIfValid();
} Sets the locale of this component. This is a bound property.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setLocation(Point p) {
setLocation(p.x, p.y);
} 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.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setLocation(int x,
int y) {
move(x, 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.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setMaximumSize(Dimension maximumSize) {
// 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);
} 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. |
public void setMinimumSize(Dimension minimumSize) {
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);
} 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. |
public void setName(String name) {
String oldName;
synchronized(getObjectLock()) {
oldName = this.name;
this.name = name;
nameExplicitlySet = true;
}
firePropertyChange("name", oldName, name);
} Sets the name of the component to the specified string. |
public void setPreferredSize(Dimension preferredSize) {
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);
} 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. |
static synchronized void setRequestFocusController(RequestFocusController requestController) {
if (requestController == null) {
requestFocusController = new DummyRequestFocusController();
} else {
requestFocusController = requestController;
}
} |
public void setSize(Dimension d) {
resize(d);
} Resizes this component so that it has width d.width
and height d.height.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setSize(int width,
int height) {
resize(width, height);
} Resizes this component so that it has width width
and height height.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void setVisible(boolean b) {
show(b);
} Shows or hides this component depending on the value of parameter
b.
This method changes layout-related information, and therefore,
invalidates the component hierarchy. |
public void show() {
if (!visible) {
synchronized (getTreeLock()) {
visible = true;
mixOnShowing();
ComponentPeer peer = this.peer;
if (peer != null) {
peer.setVisible(true);
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();
}
}
} Deprecated! As - of JDK version 1.1,
replaced by setVisible(boolean).
|
public void show(boolean b) {
if (b) {
show();
} else {
hide();
}
} Deprecated! As - of JDK version 1.1,
replaced by setVisible(boolean).
|
public Dimension size() {
return new Dimension(width, height);
} Deprecated! As - of JDK version 1.1,
replaced by getSize().
|
final void subtractAndApplyShape(Region s) {
checkTreeLock();
if (mixingLog.isLoggable(PlatformLogger.FINE)) {
mixingLog.fine("this = " + this + "; s=" + s);
}
applyCompoundShape(getAppliedShape().getDifference(s));
} |
final void subtractAndApplyShapeBelowMe() {
checkTreeLock();
Container parent = getContainer();
if (parent != null && isShowing()) {
Region opaqueShape = getOpaqueShape();
// First, cut my siblings
parent.recursiveSubtractAndApplyShape(opaqueShape, getSiblingIndexBelow());
// Second, if my container is non-opaque, cut siblings of my container
Container parent2 = parent.getContainer();
while (!parent.isOpaque() && parent2 != null) {
parent2.recursiveSubtractAndApplyShape(opaqueShape, parent.getSiblingIndexBelow());
parent = parent2;
parent2 = parent.getContainer();
}
}
} |
public String toString() {
return getClass().getName() + "[" + paramString() + "]";
} Returns a string representation of this component and its values. |
public void transferFocus() {
nextFocus();
} Transfers the focus to the next component, as though this Component were
the focus owner. |
boolean transferFocus(boolean clearOnFailure) {
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("clearOnFailure = " + clearOnFailure);
}
Component toFocus = getNextFocusCandidate();
boolean res = false;
if (toFocus != null && !toFocus.isFocusOwner() && toFocus != this) {
res = toFocus.requestFocusInWindow(CausedFocusEvent.Cause.TRAVERSAL_FORWARD);
}
if (clearOnFailure && !res) {
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("clear global focus owner");
}
KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
}
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("returning result: " + res);
}
return res;
} |
public void transferFocusBackward() {
transferFocusBackward(false);
} Transfers the focus to the previous component, as though this Component
were the focus owner. |
boolean transferFocusBackward(boolean clearOnFailure) {
Container rootAncestor = getTraversalRoot();
Component comp = this;
while (rootAncestor != null &&
!(rootAncestor.isShowing() && rootAncestor.canBeFocusOwner()))
{
comp = rootAncestor;
rootAncestor = comp.getFocusCycleRootAncestor();
}
boolean res = false;
if (rootAncestor != null) {
FocusTraversalPolicy policy = rootAncestor.getFocusTraversalPolicy();
Component toFocus = policy.getComponentBefore(rootAncestor, comp);
if (toFocus == null) {
toFocus = policy.getDefaultComponent(rootAncestor);
}
if (toFocus != null) {
res = toFocus.requestFocusInWindow(CausedFocusEvent.Cause.TRAVERSAL_BACKWARD);
}
}
if (!res) {
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("clear global focus owner");
}
KeyboardFocusManager.getCurrentKeyboardFocusManager().clearGlobalFocusOwner();
}
if (focusLog.isLoggable(PlatformLogger.FINER)) {
focusLog.finer("returning result: " + res);
}
return res;
} |
public void transferFocusUpCycle() {
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(CausedFocusEvent.Cause.TRAVERSAL_UP);
} else {
Window window = getContainingWindow();
if (window != null) {
Component toFocus = window.getFocusTraversalPolicy().
getDefaultComponent(window);
if (toFocus != null) {
KeyboardFocusManager.getCurrentKeyboardFocusManager().
setGlobalCurrentFocusCycleRoot(window);
toFocus.requestFocus(CausedFocusEvent.Cause.TRAVERSAL_UP);
}
}
}
} 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. |
public void update(Graphics g) {
paint(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. |
final void updateCursorImmediately() {
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();
}
} Updates the cursor. May not be invoked from the native
message pump. |
boolean updateGraphicsData(GraphicsConfiguration gc) {
checkTreeLock();
graphicsConfig = gc;
ComponentPeer peer = getPeer();
if (peer != null) {
return peer.updateGraphicsData(gc);
}
return false;
} |
void updateZOrder() {
peer.setZOrder(getHWPeerAboveMe());
} |
public void validate() {
synchronized (getTreeLock()) {
ComponentPeer peer = this.peer;
boolean wasValid = isValid();
if (!wasValid && 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;
if (!wasValid) {
mixOnValidating();
}
}
} Validates this component.
The meaning of the term validating is defined by the ancestors of
this class. See Container#validate for more details. |
java.awt.Component