6021 lines
178 KiB
Java
6021 lines
178 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package java.awt;
|
|
|
|
//import java.awt.dnd.DropTarget;
|
|
import java.awt.event.ComponentEvent;
|
|
import java.awt.event.ComponentListener;
|
|
import java.awt.event.FocusEvent;
|
|
import java.awt.event.FocusListener;
|
|
import java.awt.event.HierarchyBoundsListener;
|
|
import java.awt.event.HierarchyEvent;
|
|
import java.awt.event.HierarchyListener;
|
|
import java.awt.event.InputMethodEvent;
|
|
import java.awt.event.InputMethodListener;
|
|
import java.awt.event.InvocationEvent;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.event.KeyListener;
|
|
import java.awt.event.MouseEvent;
|
|
import java.awt.event.MouseListener;
|
|
import java.awt.event.MouseMotionListener;
|
|
import java.awt.event.MouseWheelEvent;
|
|
import java.awt.event.MouseWheelListener;
|
|
import java.awt.event.PaintEvent;
|
|
import java.awt.event.WindowEvent;
|
|
import java.awt.im.InputContext;
|
|
import java.awt.im.InputMethodRequests;
|
|
import java.awt.image.BufferStrategy;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.ColorModel;
|
|
import java.awt.image.ImageObserver;
|
|
import java.awt.image.ImageProducer;
|
|
import java.awt.image.VolatileImage;
|
|
import java.awt.image.WritableRaster;
|
|
import java.awt.peer.ComponentPeer;
|
|
import java.beans.PropertyChangeListener;
|
|
import java.beans.PropertyChangeSupport;
|
|
import java.io.IOException;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.PrintStream;
|
|
import java.io.PrintWriter;
|
|
import java.io.Serializable;
|
|
import java.lang.reflect.Array;
|
|
import java.lang.reflect.Method;
|
|
import java.security.AccessController;
|
|
import java.security.PrivilegedAction;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.EventListener;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Hashtable;
|
|
import java.util.Iterator;
|
|
import java.util.LinkedList;
|
|
import java.util.Locale;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
//???AWT
|
|
//import javax.accessibility.Accessible;
|
|
//import javax.accessibility.AccessibleComponent;
|
|
//import javax.accessibility.AccessibleContext;
|
|
//import javax.accessibility.AccessibleRole;
|
|
//import javax.accessibility.AccessibleState;
|
|
//import javax.accessibility.AccessibleStateSet;
|
|
|
|
import org.apache.harmony.awt.ClipRegion; //import org.apache.harmony.awt.FieldsAccessor;
|
|
import org.apache.harmony.awt.gl.MultiRectArea;
|
|
import org.apache.harmony.awt.internal.nls.Messages;
|
|
import org.apache.harmony.awt.state.State; //import org.apache.harmony.awt.text.TextFieldKit;
|
|
//import org.apache.harmony.awt.text.TextKit;
|
|
import org.apache.harmony.awt.wtk.NativeWindow;
|
|
import org.apache.harmony.luni.util.NotImplementedException;
|
|
|
|
/**
|
|
* The abstract Component class specifies an object with a graphical
|
|
* representation that can be displayed on the screen and that can interact with
|
|
* the user (for example: scrollbars, buttons, checkboxes).
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
public abstract class Component implements ImageObserver, MenuContainer, Serializable {
|
|
|
|
/**
|
|
* The Constant serialVersionUID.
|
|
*/
|
|
private static final long serialVersionUID = -7644114512714619750L;
|
|
|
|
/**
|
|
* The Constant TOP_ALIGNMENT indicates the top alignment of the component.
|
|
*/
|
|
public static final float TOP_ALIGNMENT = 0.0f;
|
|
|
|
/**
|
|
* The Constant CENTER_ALIGNMENT indicates the center alignment of the
|
|
* component.
|
|
*/
|
|
public static final float CENTER_ALIGNMENT = 0.5f;
|
|
|
|
/**
|
|
* The Constant BOTTOM_ALIGNMENT indicates the bottom alignment of the
|
|
* component.
|
|
*/
|
|
public static final float BOTTOM_ALIGNMENT = 1.0f;
|
|
|
|
/**
|
|
* The Constant LEFT_ALIGNMENT indicates the left alignment of the
|
|
* component.
|
|
*/
|
|
public static final float LEFT_ALIGNMENT = 0.0f;
|
|
|
|
/**
|
|
* The Constant RIGHT_ALIGNMENT indicates the right alignment of the
|
|
* component.
|
|
*/
|
|
public static final float RIGHT_ALIGNMENT = 1.0f;
|
|
|
|
/**
|
|
* The Constant childClassesFlags.
|
|
*/
|
|
private static final Hashtable<Class<?>, Boolean> childClassesFlags = new Hashtable<Class<?>, Boolean>();
|
|
|
|
/**
|
|
* The Constant peer.
|
|
*/
|
|
private static final ComponentPeer peer = new ComponentPeer() {
|
|
};
|
|
|
|
/**
|
|
* The Constant incrementalImageUpdate.
|
|
*/
|
|
private static final boolean incrementalImageUpdate;
|
|
|
|
/**
|
|
* The toolkit.
|
|
*/
|
|
final transient Toolkit toolkit = Toolkit.getDefaultToolkit();
|
|
|
|
// ???AWT
|
|
/*
|
|
* protected abstract class AccessibleAWTComponent extends AccessibleContext
|
|
* implements Serializable, AccessibleComponent { private static final long
|
|
* serialVersionUID = 642321655757800191L; protected class
|
|
* AccessibleAWTComponentHandler implements ComponentListener { protected
|
|
* AccessibleAWTComponentHandler() { } public void
|
|
* componentHidden(ComponentEvent e) { if (behaviour.isLightweight()) {
|
|
* return; } firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
|
|
* AccessibleState.VISIBLE, null); } public void
|
|
* componentMoved(ComponentEvent e) { } public void
|
|
* componentResized(ComponentEvent e) { } public void
|
|
* componentShown(ComponentEvent e) { if (behaviour.isLightweight()) {
|
|
* return; } firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
|
|
* null, AccessibleState.VISIBLE); } } protected class
|
|
* AccessibleAWTFocusHandler implements FocusListener { public void
|
|
* focusGained(FocusEvent e) { if (behaviour.isLightweight()) { return; }
|
|
* firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY, null,
|
|
* AccessibleState.FOCUSED); } public void focusLost(FocusEvent e) { if
|
|
* (behaviour.isLightweight()) { return; }
|
|
* firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
|
|
* AccessibleState.FOCUSED, null); } } protected ComponentListener
|
|
* accessibleAWTComponentHandler; protected FocusListener
|
|
* accessibleAWTFocusHandler;
|
|
*/
|
|
/*
|
|
* Number of registered property change listeners.
|
|
*/
|
|
/*
|
|
* int listenersCount; public void addFocusListener(FocusListener l) {
|
|
* Component.this.addFocusListener(l); }
|
|
* @Override public void addPropertyChangeListener(PropertyChangeListener
|
|
* listener) { toolkit.lockAWT(); try {
|
|
* super.addPropertyChangeListener(listener); listenersCount++; if
|
|
* (accessibleAWTComponentHandler == null) { accessibleAWTComponentHandler =
|
|
* new AccessibleAWTComponentHandler();
|
|
* Component.this.addComponentListener(accessibleAWTComponentHandler); } if
|
|
* (accessibleAWTFocusHandler == null) { accessibleAWTFocusHandler = new
|
|
* AccessibleAWTFocusHandler();
|
|
* Component.this.addFocusListener(accessibleAWTFocusHandler); } } finally {
|
|
* toolkit.unlockAWT(); } } public boolean contains(Point p) {
|
|
* toolkit.lockAWT(); try { return Component.this.contains(p); } finally {
|
|
* toolkit.unlockAWT(); } } public Accessible getAccessibleAt(Point arg0) {
|
|
* toolkit.lockAWT(); try { return null; } finally { toolkit.unlockAWT(); }
|
|
* } public Color getBackground() { toolkit.lockAWT(); try { return
|
|
* Component.this.getBackground(); } finally { toolkit.unlockAWT(); } }
|
|
* public Rectangle getBounds() { toolkit.lockAWT(); try { return
|
|
* Component.this.getBounds(); } finally { toolkit.unlockAWT(); } } public
|
|
* Cursor getCursor() { toolkit.lockAWT(); try { return
|
|
* Component.this.getCursor(); } finally { toolkit.unlockAWT(); } } public
|
|
* Font getFont() { toolkit.lockAWT(); try { return
|
|
* Component.this.getFont(); } finally { toolkit.unlockAWT(); } } public
|
|
* FontMetrics getFontMetrics(Font f) { toolkit.lockAWT(); try { return
|
|
* Component.this.getFontMetrics(f); } finally { toolkit.unlockAWT(); } }
|
|
* public Color getForeground() { toolkit.lockAWT(); try { return
|
|
* Component.this.getForeground(); } finally { toolkit.unlockAWT(); } }
|
|
* public Point getLocation() { toolkit.lockAWT(); try { return
|
|
* Component.this.getLocation(); } finally { toolkit.unlockAWT(); } } public
|
|
* Point getLocationOnScreen() { toolkit.lockAWT(); try { return
|
|
* Component.this.getLocationOnScreen(); } finally { toolkit.unlockAWT(); }
|
|
* } public Dimension getSize() { toolkit.lockAWT(); try { return
|
|
* Component.this.getSize(); } finally { toolkit.unlockAWT(); } } public
|
|
* boolean isEnabled() { toolkit.lockAWT(); try { return
|
|
* Component.this.isEnabled(); } finally { toolkit.unlockAWT(); } } public
|
|
* boolean isFocusTraversable() { toolkit.lockAWT(); try { return
|
|
* Component.this.isFocusTraversable(); } finally { toolkit.unlockAWT(); } }
|
|
* public boolean isShowing() { toolkit.lockAWT(); try { return
|
|
* Component.this.isShowing(); } finally { toolkit.unlockAWT(); } } public
|
|
* boolean isVisible() { toolkit.lockAWT(); try { return
|
|
* Component.this.isVisible(); } finally { toolkit.unlockAWT(); } } public
|
|
* void removeFocusListener(FocusListener l) {
|
|
* Component.this.removeFocusListener(l); }
|
|
* @Override public void removePropertyChangeListener(PropertyChangeListener
|
|
* listener) { toolkit.lockAWT(); try {
|
|
* super.removePropertyChangeListener(listener); listenersCount--; if
|
|
* (listenersCount > 0) { return; } // if there are no more listeners,
|
|
* remove handlers:
|
|
* Component.this.removeFocusListener(accessibleAWTFocusHandler);
|
|
* Component.this.removeComponentListener(accessibleAWTComponentHandler);
|
|
* accessibleAWTComponentHandler = null; accessibleAWTFocusHandler = null; }
|
|
* finally { toolkit.unlockAWT(); } } public void requestFocus() {
|
|
* toolkit.lockAWT(); try { Component.this.requestFocus(); } finally {
|
|
* toolkit.unlockAWT(); } } public void setBackground(Color color) {
|
|
* toolkit.lockAWT(); try { Component.this.setBackground(color); } finally {
|
|
* toolkit.unlockAWT(); } } public void setBounds(Rectangle r) {
|
|
* toolkit.lockAWT(); try { Component.this.setBounds(r); } finally {
|
|
* toolkit.unlockAWT(); } } public void setCursor(Cursor cursor) {
|
|
* toolkit.lockAWT(); try { Component.this.setCursor(cursor); } finally {
|
|
* toolkit.unlockAWT(); } } public void setEnabled(boolean enabled) {
|
|
* toolkit.lockAWT(); try { Component.this.setEnabled(enabled); } finally {
|
|
* toolkit.unlockAWT(); } } public void setFont(Font f) { toolkit.lockAWT();
|
|
* try { Component.this.setFont(f); } finally { toolkit.unlockAWT(); } }
|
|
* public void setForeground(Color color) { toolkit.lockAWT(); try {
|
|
* Component.this.setForeground(color); } finally { toolkit.unlockAWT(); } }
|
|
* public void setLocation(Point p) { toolkit.lockAWT(); try {
|
|
* Component.this.setLocation(p); } finally { toolkit.unlockAWT(); } }
|
|
* public void setSize(Dimension size) { toolkit.lockAWT(); try {
|
|
* Component.this.setSize(size); } finally { toolkit.unlockAWT(); } } public
|
|
* void setVisible(boolean visible) { toolkit.lockAWT(); try {
|
|
* Component.this.setVisible(visible); } finally { toolkit.unlockAWT(); } }
|
|
* @Override public Accessible getAccessibleParent() { toolkit.lockAWT();
|
|
* try { Accessible aParent = super.getAccessibleParent(); if (aParent !=
|
|
* null) { return aParent; } Container parent = getParent(); return (parent
|
|
* instanceof Accessible ? (Accessible) parent : null); } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
* @Override public Accessible getAccessibleChild(int i) {
|
|
* toolkit.lockAWT(); try { return null; } finally { toolkit.unlockAWT(); }
|
|
* }
|
|
* @Override public int getAccessibleChildrenCount() { toolkit.lockAWT();
|
|
* try { return 0; } finally { toolkit.unlockAWT(); } }
|
|
* @Override public AccessibleComponent getAccessibleComponent() { return
|
|
* this; }
|
|
* @Override public String getAccessibleDescription() { return
|
|
* super.getAccessibleDescription(); // why override? }
|
|
* @Override public int getAccessibleIndexInParent() { toolkit.lockAWT();
|
|
* try { if (getAccessibleParent() == null) { return -1; } int count = 0;
|
|
* Container parent = getParent(); for (int i = 0; i <
|
|
* parent.getComponentCount(); i++) { Component aComp =
|
|
* parent.getComponent(i); if (aComp instanceof Accessible) { if (aComp ==
|
|
* Component.this) { return count; } ++count; } } return -1; } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
* @Override public AccessibleRole getAccessibleRole() { toolkit.lockAWT();
|
|
* try { return AccessibleRole.AWT_COMPONENT; } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
* @Override public AccessibleStateSet getAccessibleStateSet() {
|
|
* toolkit.lockAWT(); try { AccessibleStateSet set = new
|
|
* AccessibleStateSet(); if (isEnabled()) {
|
|
* set.add(AccessibleState.ENABLED); } if (isFocusable()) {
|
|
* set.add(AccessibleState.FOCUSABLE); } if (hasFocus()) {
|
|
* set.add(AccessibleState.FOCUSED); } if (isOpaque()) {
|
|
* set.add(AccessibleState.OPAQUE); } if (isShowing()) {
|
|
* set.add(AccessibleState.SHOWING); } if (isVisible()) {
|
|
* set.add(AccessibleState.VISIBLE); } return set; } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
* @Override public Locale getLocale() throws IllegalComponentStateException
|
|
* { toolkit.lockAWT(); try { return Component.this.getLocale(); } finally {
|
|
* toolkit.unlockAWT(); } } }
|
|
*/
|
|
/**
|
|
* The BltBufferStrategy class provides opportunity of blitting offscreen
|
|
* surfaces to a component. For more information on blitting, see <a
|
|
* href="http://en.wikipedia.org/wiki/Bit_blit">Bit blit</a>.
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
protected class BltBufferStrategy extends BufferStrategy {
|
|
|
|
/**
|
|
* The back buffers.
|
|
*/
|
|
protected VolatileImage[] backBuffers;
|
|
|
|
/**
|
|
* The caps.
|
|
*/
|
|
protected BufferCapabilities caps;
|
|
|
|
/**
|
|
* The width.
|
|
*/
|
|
protected int width;
|
|
|
|
/**
|
|
* The height.
|
|
*/
|
|
protected int height;
|
|
|
|
/**
|
|
* The validated contents.
|
|
*/
|
|
protected boolean validatedContents;
|
|
|
|
/**
|
|
* Instantiates a new BltBufferStrategy buffer strategy.
|
|
*
|
|
* @param numBuffers
|
|
* the number of buffers.
|
|
* @param caps
|
|
* the BufferCapabilities.
|
|
* @throws NotImplementedException
|
|
* the not implemented exception.
|
|
*/
|
|
protected BltBufferStrategy(int numBuffers, BufferCapabilities caps)
|
|
throws org.apache.harmony.luni.util.NotImplementedException {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the drawing buffer has been lost since the last call
|
|
* to getDrawGraphics.
|
|
*
|
|
* @return true if the drawing buffer has been lost since the last call
|
|
* to getDrawGraphics, false otherwise.
|
|
* @see java.awt.image.BufferStrategy#contentsLost()
|
|
*/
|
|
@Override
|
|
public boolean contentsLost() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the drawing buffer has been restored from a lost
|
|
* state and reinitialized to the default background color.
|
|
*
|
|
* @return true if the drawing buffer has been restored from a lost
|
|
* state and reinitialized to the default background color,
|
|
* false otherwise.
|
|
* @see java.awt.image.BufferStrategy#contentsRestored()
|
|
*/
|
|
@Override
|
|
public boolean contentsRestored() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Creates the back buffers.
|
|
*
|
|
* @param numBuffers
|
|
* the number of buffers.
|
|
*/
|
|
protected void createBackBuffers(int numBuffers) {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the BufferCapabilities of the buffer strategy.
|
|
*
|
|
* @return the BufferCapabilities.
|
|
* @see java.awt.image.BufferStrategy#getCapabilities()
|
|
*/
|
|
@Override
|
|
public BufferCapabilities getCapabilities() {
|
|
return (BufferCapabilities)caps.clone();
|
|
}
|
|
|
|
/**
|
|
* Gets Graphics of current buffer strategy.
|
|
*
|
|
* @return the Graphics of current buffer strategy.
|
|
* @see java.awt.image.BufferStrategy#getDrawGraphics()
|
|
*/
|
|
@Override
|
|
public Graphics getDrawGraphics() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Revalidates the lost drawing buffer.
|
|
*/
|
|
protected void revalidate() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the next available buffer.
|
|
*
|
|
* @see java.awt.image.BufferStrategy#show()
|
|
*/
|
|
@Override
|
|
public void show() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The FlipBufferStrategy class is for flipping buffers on a component.
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
protected class FlipBufferStrategy extends BufferStrategy {
|
|
|
|
/**
|
|
* The Buffer Capabilities.
|
|
*/
|
|
protected BufferCapabilities caps;
|
|
|
|
/**
|
|
* The drawing buffer.
|
|
*/
|
|
protected Image drawBuffer;
|
|
|
|
/**
|
|
* The drawing VolatileImage buffer.
|
|
*/
|
|
protected VolatileImage drawVBuffer;
|
|
|
|
/**
|
|
* The number of buffers.
|
|
*/
|
|
protected int numBuffers;
|
|
|
|
/**
|
|
* The validated contents indicates if the drawing buffer is restored
|
|
* from lost state.
|
|
*/
|
|
protected boolean validatedContents;
|
|
|
|
/**
|
|
* Instantiates a new flip buffer strategy.
|
|
*
|
|
* @param numBuffers
|
|
* the number of buffers.
|
|
* @param caps
|
|
* the BufferCapabilities.
|
|
* @throws AWTException
|
|
* if the capabilities supplied could not be supported or
|
|
* met.
|
|
*/
|
|
protected FlipBufferStrategy(int numBuffers, BufferCapabilities caps) throws AWTException {
|
|
// ???AWT
|
|
/*
|
|
* if (!(Component.this instanceof Window) && !(Component.this
|
|
* instanceof Canvas)) { // awt.14B=Only Canvas or Window is allowed
|
|
* throw new ClassCastException(Messages.getString("awt.14B"));
|
|
* //$NON-NLS-1$ }
|
|
*/
|
|
// TODO: throw new AWTException("Capabilities are not supported");
|
|
this.numBuffers = numBuffers;
|
|
this.caps = (BufferCapabilities)caps.clone();
|
|
}
|
|
|
|
/**
|
|
* Returns true if the drawing buffer has been lost since the last call
|
|
* to getDrawGraphics.
|
|
*
|
|
* @return true if the drawing buffer has been lost since the last call
|
|
* to getDrawGraphics, false otherwise.
|
|
* @see java.awt.image.BufferStrategy#contentsLost()
|
|
*/
|
|
@Override
|
|
public boolean contentsLost() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the drawing buffer has been restored from a lost
|
|
* state and reinitialized to the default background color.
|
|
*
|
|
* @return true if the drawing buffer has been restored from a lost
|
|
* state and reinitialized to the default background color,
|
|
* false otherwise.
|
|
* @see java.awt.image.BufferStrategy#contentsRestored()
|
|
*/
|
|
@Override
|
|
public boolean contentsRestored() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Creates flipping buffers with the specified buffer capabilities.
|
|
*
|
|
* @param numBuffers
|
|
* the number of buffers.
|
|
* @param caps
|
|
* the BufferCapabilities.
|
|
* @throws AWTException
|
|
* if the capabilities could not be supported or met.
|
|
*/
|
|
protected void createBuffers(int numBuffers, BufferCapabilities caps) throws AWTException {
|
|
if (numBuffers < 2) {
|
|
// awt.14C=Number of buffers must be greater than one
|
|
throw new IllegalArgumentException(Messages.getString("awt.14C")); //$NON-NLS-1$
|
|
}
|
|
if (!caps.isPageFlipping()) {
|
|
// awt.14D=Buffer capabilities should support flipping
|
|
throw new IllegalArgumentException(Messages.getString("awt.14D")); //$NON-NLS-1$
|
|
}
|
|
if (!Component.this.behaviour.isDisplayable()) {
|
|
// awt.14E=Component should be displayable
|
|
throw new IllegalStateException(Messages.getString("awt.14E")); //$NON-NLS-1$
|
|
}
|
|
// TODO: throw new AWTException("Capabilities are not supported");
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Destroy buffers.
|
|
*/
|
|
protected void destroyBuffers() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Flips the contents of the back buffer to the front buffer.
|
|
*
|
|
* @param flipAction
|
|
* the flip action.
|
|
*/
|
|
protected void flip(BufferCapabilities.FlipContents flipAction) {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the back buffer as Image.
|
|
*
|
|
* @return the back buffer as Image.
|
|
*/
|
|
protected Image getBackBuffer() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Returns the BufferCapabilities of the buffer strategy.
|
|
*
|
|
* @return the BufferCapabilities.
|
|
* @see java.awt.image.BufferStrategy#getCapabilities()
|
|
*/
|
|
@Override
|
|
public BufferCapabilities getCapabilities() {
|
|
return (BufferCapabilities)caps.clone();
|
|
}
|
|
|
|
/**
|
|
* Gets Graphics of current buffer strategy.
|
|
*
|
|
* @return the Graphics of current buffer strategy.
|
|
* @see java.awt.image.BufferStrategy#getDrawGraphics()
|
|
*/
|
|
@Override
|
|
public Graphics getDrawGraphics() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Revalidates the lost drawing buffer.
|
|
*/
|
|
protected void revalidate() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Shows the next available buffer.
|
|
*
|
|
* @see java.awt.image.BufferStrategy#show()
|
|
*/
|
|
@Override
|
|
public void show() {
|
|
if (true) {
|
|
throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The internal component's state utilized by the visual theme.
|
|
*/
|
|
class ComponentState implements State {
|
|
|
|
/**
|
|
* The default minimum size.
|
|
*/
|
|
private Dimension defaultMinimumSize = new Dimension();
|
|
|
|
/**
|
|
* Checks if the component is enabled.
|
|
*
|
|
* @return true, if the component is enabled.
|
|
*/
|
|
public boolean isEnabled() {
|
|
return enabled;
|
|
}
|
|
|
|
/**
|
|
* Checks if the component is visible.
|
|
*
|
|
* @return true, if the component is visible.
|
|
*/
|
|
public boolean isVisible() {
|
|
return visible;
|
|
}
|
|
|
|
/**
|
|
* Checks if is focused.
|
|
*
|
|
* @return true, if is focused.
|
|
*/
|
|
public boolean isFocused() {
|
|
// ???AWT: return isFocusOwner();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Gets the font.
|
|
*
|
|
* @return the font.
|
|
*/
|
|
public Font getFont() {
|
|
return Component.this.getFont();
|
|
}
|
|
|
|
/**
|
|
* Checks if the font has been set.
|
|
*
|
|
* @return true, if the font has been set.
|
|
*/
|
|
public boolean isFontSet() {
|
|
return font != null;
|
|
}
|
|
|
|
/**
|
|
* Gets the background color.
|
|
*
|
|
* @return the background color.
|
|
*/
|
|
public Color getBackground() {
|
|
Color c = Component.this.getBackground();
|
|
return (c != null) ? c : getDefaultBackground();
|
|
}
|
|
|
|
/**
|
|
* Checks if the background is set.
|
|
*
|
|
* @return true, if the background is set.
|
|
*/
|
|
public boolean isBackgroundSet() {
|
|
return backColor != null;
|
|
}
|
|
|
|
/**
|
|
* Gets the text color.
|
|
*
|
|
* @return the text color.
|
|
*/
|
|
public Color getTextColor() {
|
|
Color c = getForeground();
|
|
return (c != null) ? c : getDefaultForeground();
|
|
}
|
|
|
|
/**
|
|
* Checks if the text color is set.
|
|
*
|
|
* @return true, if the text color is set.
|
|
*/
|
|
public boolean isTextColorSet() {
|
|
return foreColor != null;
|
|
}
|
|
|
|
/**
|
|
* Gets the font metrics.
|
|
*
|
|
* @return the font metrics.
|
|
*/
|
|
@SuppressWarnings("deprecation")
|
|
public FontMetrics getFontMetrics() {
|
|
return toolkit.getFontMetrics(Component.this.getFont());
|
|
}
|
|
|
|
/**
|
|
* Gets the bounding rectangle.
|
|
*
|
|
* @return the bounding rectangle.
|
|
*/
|
|
public Rectangle getBounds() {
|
|
return new Rectangle(x, y, w, h);
|
|
}
|
|
|
|
/**
|
|
* Gets the size of the bounding rectangle.
|
|
*
|
|
* @return the size of the bounding rectangle.
|
|
*/
|
|
public Dimension getSize() {
|
|
return new Dimension(w, h);
|
|
}
|
|
|
|
/**
|
|
* Gets the window id.
|
|
*
|
|
* @return the window id.
|
|
*/
|
|
public long getWindowId() {
|
|
NativeWindow win = getNativeWindow();
|
|
return (win != null) ? win.getId() : 0;
|
|
}
|
|
|
|
/**
|
|
* Gets the default minimum size.
|
|
*
|
|
* @return the default minimum size.
|
|
*/
|
|
public Dimension getDefaultMinimumSize() {
|
|
if (defaultMinimumSize == null) {
|
|
calculate();
|
|
}
|
|
return defaultMinimumSize;
|
|
}
|
|
|
|
/**
|
|
* Sets the default minimum size.
|
|
*
|
|
* @param size
|
|
* the new default minimum size.
|
|
*/
|
|
public void setDefaultMinimumSize(Dimension size) {
|
|
defaultMinimumSize = size;
|
|
}
|
|
|
|
/**
|
|
* Reset the default minimum size to null.
|
|
*/
|
|
public void reset() {
|
|
defaultMinimumSize = null;
|
|
}
|
|
|
|
/**
|
|
* Calculate the default minimum size: to be overridden.
|
|
*/
|
|
public void calculate() {
|
|
// to be overridden
|
|
}
|
|
}
|
|
|
|
// ???AWT: private transient AccessibleContext accessibleContext;
|
|
|
|
/**
|
|
* The behaviour.
|
|
*/
|
|
final transient ComponentBehavior behaviour;
|
|
|
|
// ???AWT: Container parent;
|
|
|
|
/**
|
|
* The name.
|
|
*/
|
|
private String name;
|
|
|
|
/**
|
|
* The auto name.
|
|
*/
|
|
private boolean autoName = true;
|
|
|
|
/**
|
|
* The font.
|
|
*/
|
|
private Font font;
|
|
|
|
/**
|
|
* The back color.
|
|
*/
|
|
private Color backColor;
|
|
|
|
/**
|
|
* The fore color.
|
|
*/
|
|
private Color foreColor;
|
|
|
|
/**
|
|
* The deprecated event handler.
|
|
*/
|
|
boolean deprecatedEventHandler = true;
|
|
|
|
/**
|
|
* The enabled events.
|
|
*/
|
|
private long enabledEvents;
|
|
|
|
/**
|
|
* The enabled AWT events.
|
|
*/
|
|
private long enabledAWTEvents;
|
|
|
|
/**
|
|
* The component listeners.
|
|
*/
|
|
private final AWTListenerList<ComponentListener> componentListeners = new AWTListenerList<ComponentListener>(
|
|
this);
|
|
|
|
/**
|
|
* The focus listeners.
|
|
*/
|
|
private final AWTListenerList<FocusListener> focusListeners = new AWTListenerList<FocusListener>(
|
|
this);
|
|
|
|
/**
|
|
* The hierarchy listeners.
|
|
*/
|
|
private final AWTListenerList<HierarchyListener> hierarchyListeners = new AWTListenerList<HierarchyListener>(
|
|
this);
|
|
|
|
/**
|
|
* The hierarchy bounds listeners.
|
|
*/
|
|
private final AWTListenerList<HierarchyBoundsListener> hierarchyBoundsListeners = new AWTListenerList<HierarchyBoundsListener>(
|
|
this);
|
|
|
|
/**
|
|
* The key listeners.
|
|
*/
|
|
private final AWTListenerList<KeyListener> keyListeners = new AWTListenerList<KeyListener>(this);
|
|
|
|
/**
|
|
* The mouse listeners.
|
|
*/
|
|
private final AWTListenerList<MouseListener> mouseListeners = new AWTListenerList<MouseListener>(
|
|
this);
|
|
|
|
/**
|
|
* The mouse motion listeners.
|
|
*/
|
|
private final AWTListenerList<MouseMotionListener> mouseMotionListeners = new AWTListenerList<MouseMotionListener>(
|
|
this);
|
|
|
|
/**
|
|
* The mouse wheel listeners.
|
|
*/
|
|
private final AWTListenerList<MouseWheelListener> mouseWheelListeners = new AWTListenerList<MouseWheelListener>(
|
|
this);
|
|
|
|
/**
|
|
* The input method listeners.
|
|
*/
|
|
private final AWTListenerList<InputMethodListener> inputMethodListeners = new AWTListenerList<InputMethodListener>(
|
|
this);
|
|
|
|
/**
|
|
* The x.
|
|
*/
|
|
int x;
|
|
|
|
/**
|
|
* The y.
|
|
*/
|
|
int y;
|
|
|
|
/**
|
|
* The w.
|
|
*/
|
|
int w;
|
|
|
|
/**
|
|
* The h.
|
|
*/
|
|
int h;
|
|
|
|
/**
|
|
* The maximum size.
|
|
*/
|
|
private Dimension maximumSize;
|
|
|
|
/**
|
|
* The minimum size.
|
|
*/
|
|
private Dimension minimumSize;
|
|
|
|
/**
|
|
* The preferred size.
|
|
*/
|
|
private Dimension preferredSize;
|
|
|
|
/**
|
|
* The bounds mask param.
|
|
*/
|
|
private int boundsMaskParam;
|
|
|
|
/**
|
|
* The ignore repaint.
|
|
*/
|
|
private boolean ignoreRepaint;
|
|
|
|
/**
|
|
* The enabled.
|
|
*/
|
|
private boolean enabled = true;
|
|
|
|
/**
|
|
* The input methods enabled.
|
|
*/
|
|
private boolean inputMethodsEnabled = true;
|
|
|
|
/**
|
|
* The dispatch to im.
|
|
*/
|
|
transient boolean dispatchToIM = true;
|
|
|
|
/**
|
|
* The focusable.
|
|
*/
|
|
private boolean focusable = true; // By default, all Components return
|
|
|
|
// true from isFocusable() method
|
|
/**
|
|
* The visible.
|
|
*/
|
|
boolean visible = true;
|
|
|
|
/**
|
|
* The called set focusable.
|
|
*/
|
|
private boolean calledSetFocusable;
|
|
|
|
/**
|
|
* The overridden is focusable.
|
|
*/
|
|
private boolean overridenIsFocusable = true;
|
|
|
|
/**
|
|
* The focus traversal keys enabled.
|
|
*/
|
|
private boolean focusTraversalKeysEnabled = true;
|
|
|
|
/**
|
|
* Possible keys are: FORWARD_TRAVERSAL_KEYS, BACKWARD_TRAVERSAL_KEYS,
|
|
* UP_CYCLE_TRAVERSAL_KEYS.
|
|
*/
|
|
private final Map<Integer, Set<? extends AWTKeyStroke>> traversalKeys = new HashMap<Integer, Set<? extends AWTKeyStroke>>();
|
|
|
|
/**
|
|
* The traversal i ds.
|
|
*/
|
|
int[] traversalIDs;
|
|
|
|
/**
|
|
* The locale.
|
|
*/
|
|
private Locale locale;
|
|
|
|
/**
|
|
* The orientation.
|
|
*/
|
|
private ComponentOrientation orientation;
|
|
|
|
/**
|
|
* The property change support.
|
|
*/
|
|
private PropertyChangeSupport propertyChangeSupport;
|
|
|
|
// ???AWT: private ArrayList<PopupMenu> popups;
|
|
|
|
/**
|
|
* The coalescer.
|
|
*/
|
|
private boolean coalescer;
|
|
|
|
/**
|
|
* The events table.
|
|
*/
|
|
private Hashtable<Integer, LinkedList<AWTEvent>> eventsTable;
|
|
|
|
/**
|
|
* Cashed reference used during EventQueue.postEvent()
|
|
*/
|
|
private LinkedList<AWTEvent> eventsList;
|
|
|
|
/**
|
|
* The hierarchy changing counter.
|
|
*/
|
|
private int hierarchyChangingCounter;
|
|
|
|
/**
|
|
* The was showing.
|
|
*/
|
|
private boolean wasShowing;
|
|
|
|
/**
|
|
* The was displayable.
|
|
*/
|
|
private boolean wasDisplayable;
|
|
|
|
/**
|
|
* The cursor.
|
|
*/
|
|
Cursor cursor;
|
|
|
|
// ???AWT: DropTarget dropTarget;
|
|
|
|
/**
|
|
* The mouse exited expected.
|
|
*/
|
|
private boolean mouseExitedExpected;
|
|
|
|
/**
|
|
* The repaint region.
|
|
*/
|
|
transient MultiRectArea repaintRegion;
|
|
|
|
// ???AWT: transient RedrawManager redrawManager;
|
|
/**
|
|
* The redraw manager.
|
|
*/
|
|
transient Object redrawManager;
|
|
|
|
/**
|
|
* The valid.
|
|
*/
|
|
private boolean valid;
|
|
|
|
/**
|
|
* The updated images.
|
|
*/
|
|
private HashMap<Image, ImageParameters> updatedImages;
|
|
|
|
/**
|
|
* The lock object for private component's data which don't affect the
|
|
* component hierarchy.
|
|
*/
|
|
private class ComponentLock {
|
|
}
|
|
|
|
/**
|
|
* The component lock.
|
|
*/
|
|
private final transient Object componentLock = new ComponentLock();
|
|
static {
|
|
PrivilegedAction<String[]> action = new PrivilegedAction<String[]>() {
|
|
public String[] run() {
|
|
String properties[] = new String[2];
|
|
properties[0] = System.getProperty("awt.image.redrawrate", "100"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
properties[1] = System.getProperty("awt.image.incrementaldraw", "true"); //$NON-NLS-1$ //$NON-NLS-2$
|
|
return properties;
|
|
}
|
|
};
|
|
String properties[] = AccessController.doPrivileged(action);
|
|
// FIXME: rate is never used, can this code and the get property above
|
|
// be removed?
|
|
// int rate;
|
|
//
|
|
// try {
|
|
// rate = Integer.decode(properties[0]).intValue();
|
|
// } catch (NumberFormatException e) {
|
|
// rate = 100;
|
|
// }
|
|
incrementalImageUpdate = properties[1].equals("true"); //$NON-NLS-1$
|
|
}
|
|
|
|
/**
|
|
* Instantiates a new component.
|
|
*/
|
|
protected Component() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
orientation = ComponentOrientation.UNKNOWN;
|
|
redrawManager = null;
|
|
// ???AWT
|
|
/*
|
|
* traversalIDs = this instanceof Container ?
|
|
* KeyboardFocusManager.contTraversalIDs :
|
|
* KeyboardFocusManager.compTraversalIDs; for (int element :
|
|
* traversalIDs) { traversalKeys.put(new Integer(element), null); }
|
|
* behaviour = createBehavior();
|
|
*/
|
|
behaviour = null;
|
|
|
|
deriveCoalescerFlag();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine that the class inherited from Component declares the method
|
|
* coalesceEvents(), and put the results to the childClassesFlags map.
|
|
*/
|
|
private void deriveCoalescerFlag() {
|
|
Class<?> thisClass = getClass();
|
|
boolean flag = true;
|
|
synchronized (childClassesFlags) {
|
|
Boolean flagWrapper = childClassesFlags.get(thisClass);
|
|
if (flagWrapper == null) {
|
|
Method coalesceMethod = null;
|
|
for (Class<?> c = thisClass; c != Component.class; c = c.getSuperclass()) {
|
|
try {
|
|
coalesceMethod = c.getDeclaredMethod("coalesceEvents", new Class[] { //$NON-NLS-1$
|
|
Class.forName("java.awt.AWTEvent"), //$NON-NLS-1$
|
|
Class.forName("java.awt.AWTEvent")}); //$NON-NLS-1$
|
|
} catch (Exception e) {
|
|
}
|
|
if (coalesceMethod != null) {
|
|
break;
|
|
}
|
|
}
|
|
flag = (coalesceMethod != null);
|
|
childClassesFlags.put(thisClass, Boolean.valueOf(flag));
|
|
} else {
|
|
flag = flagWrapper.booleanValue();
|
|
}
|
|
}
|
|
coalescer = flag;
|
|
if (flag) {
|
|
eventsTable = new Hashtable<Integer, LinkedList<AWTEvent>>();
|
|
} else {
|
|
eventsTable = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the name of the Component.
|
|
*
|
|
* @param name
|
|
* the new name of the Component.
|
|
*/
|
|
public void setName(String name) {
|
|
String oldName;
|
|
toolkit.lockAWT();
|
|
try {
|
|
autoName = false;
|
|
oldName = this.name;
|
|
this.name = name;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("name", oldName, name); //$NON-NLS-1$
|
|
}
|
|
|
|
/**
|
|
* Gets the name of this Component.
|
|
*
|
|
* @return the name of this Component.
|
|
*/
|
|
public String getName() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if ((name == null) && autoName) {
|
|
name = autoName();
|
|
}
|
|
return name;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Auto name.
|
|
*
|
|
* @return the string.
|
|
*/
|
|
String autoName() {
|
|
String name = getClass().getName();
|
|
if (name.indexOf("$") != -1) { //$NON-NLS-1$
|
|
return null;
|
|
}
|
|
// ???AWT
|
|
// int number = toolkit.autoNumber.nextComponent++;
|
|
int number = 0;
|
|
name = name.substring(name.lastIndexOf(".") + 1) + Integer.toString(number); //$NON-NLS-1$
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Returns the string representation of the Component.
|
|
*
|
|
* @return the string representation of the Component.
|
|
*/
|
|
@Override
|
|
public String toString() {
|
|
/*
|
|
* The format is based on 1.5 release behavior which can be revealed by
|
|
* the following code: Component c = new Component(){};
|
|
* c.setVisible(false); System.out.println(c);
|
|
*/
|
|
toolkit.lockAWT();
|
|
try {
|
|
return getClass().getName() + "[" + paramString() + "]"; //$NON-NLS-1$ //$NON-NLS-2$
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* public void add(PopupMenu popup) { toolkit.lockAWT(); try { if
|
|
* (popup.getParent() == this) { return; } if (popups == null) { popups =
|
|
* new ArrayList<PopupMenu>(); } popup.setParent(this); popups.add(popup); }
|
|
* finally { toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Returns true, if the component contains the specified Point.
|
|
*
|
|
* @param p
|
|
* the Point.
|
|
* @return true, if the component contains the specified Point, false
|
|
* otherwise.
|
|
*/
|
|
public boolean contains(Point p) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return contains(p.x, p.y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true, if the component contains the point with the specified
|
|
* coordinates.
|
|
*
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return true, if the component contains the point with the specified
|
|
* coordinates, false otherwise.
|
|
*/
|
|
public boolean contains(int x, int y) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return inside(x, y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by replaced by getSize() method.
|
|
*
|
|
* @return the dimension.
|
|
* @deprecated Replaced by getSize() method.
|
|
*/
|
|
@Deprecated
|
|
public Dimension size() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return new Dimension(w, h);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* public Container getParent() { toolkit.lockAWT(); try { return parent; }
|
|
* finally { toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* List.
|
|
*
|
|
* @param out
|
|
* the out.
|
|
* @param indent
|
|
* the indent
|
|
* @return the nearest heavyweight ancestor in hierarchy or
|
|
* <code>null</code> if not found.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* Component getHWAncestor() { return (parent != null ?
|
|
* parent.getHWSurface() : null); }
|
|
*/
|
|
|
|
/**
|
|
* @return heavyweight component that is equal to or is a nearest
|
|
* heavyweight container of the current component, or
|
|
* <code>null</code> if not found.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* Component getHWSurface() { Component parent; for (parent = this; (parent
|
|
* != null) && (parent.isLightweight()); parent = parent .getParent()) { ; }
|
|
* return parent; } Window getWindowAncestor() { Component par; for (par =
|
|
* this; par != null && !(par instanceof Window); par = par.getParent()) { ;
|
|
* } return (Window) par; }
|
|
*/
|
|
|
|
/**
|
|
* To be called by container
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* void setParent(Container parent) { this.parent = parent;
|
|
* setRedrawManager(); } void setRedrawManager() { redrawManager =
|
|
* getRedrawManager(); } public void remove(MenuComponent menu) {
|
|
* toolkit.lockAWT(); try { if (menu.getParent() == this) {
|
|
* menu.setParent(null); popups.remove(menu); } } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
*/
|
|
/**
|
|
* Prints a list of this component with the specified number of leading
|
|
* whitespace characters to the specified PrintStream.
|
|
*
|
|
* @param out
|
|
* the output PrintStream object.
|
|
* @param indent
|
|
* how many leading whitespace characters to prepend.
|
|
*/
|
|
public void list(PrintStream out, int indent) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
out.println(getIndentStr(indent) + this);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints a list of this component to the specified PrintWriter.
|
|
*
|
|
* @param out
|
|
* the output PrintWriter object.
|
|
*/
|
|
public void list(PrintWriter out) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
list(out, 1);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints a list of this component with the specified number of leading
|
|
* whitespace characters to the specified PrintWriter.
|
|
*
|
|
* @param out
|
|
* the output PrintWriter object.
|
|
* @param indent
|
|
* how many leading whitespace characters to prepend.
|
|
*/
|
|
public void list(PrintWriter out, int indent) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
out.println(getIndentStr(indent) + this);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets a string composed of the desired number of whitespace characters.
|
|
*
|
|
* @param indent
|
|
* the length of the String to return.
|
|
* @return the string composed of the desired number of whitespace
|
|
* characters.
|
|
*/
|
|
String getIndentStr(int indent) {
|
|
char[] ind = new char[indent];
|
|
for (int i = 0; i < indent; ind[i++] = ' ') {
|
|
;
|
|
}
|
|
return new String(ind);
|
|
}
|
|
|
|
/**
|
|
* Prints a list of this component to the specified PrintStream.
|
|
*
|
|
* @param out
|
|
* the output PrintStream object.
|
|
*/
|
|
public void list(PrintStream out) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// default indent = 1
|
|
list(out, 1);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints a list of this component to the standard system output stream.
|
|
*/
|
|
public void list() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
list(System.out);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints this component.
|
|
*
|
|
* @param g
|
|
* the Graphics to be used for painting.
|
|
*/
|
|
public void print(Graphics g) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
paint(g);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prints the component and all of its subcomponents.
|
|
*
|
|
* @param g
|
|
* the Graphics to be used for painting.
|
|
*/
|
|
public void printAll(Graphics g) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
paintAll(g);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the size of the Component specified by width and height parameters.
|
|
*
|
|
* @param width
|
|
* the width of the Component.
|
|
* @param height
|
|
* the height of the Component.
|
|
*/
|
|
public void setSize(int width, int height) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
resize(width, height);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the size of the Component specified by Dimension object.
|
|
*
|
|
* @param d
|
|
* the new size of the Component.
|
|
*/
|
|
public void setSize(Dimension d) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
resize(d);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by setSize(int, int) method.
|
|
*
|
|
* @param width
|
|
* the width.
|
|
* @param height
|
|
* the height.
|
|
* @deprecated Replaced by setSize(int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public void resize(int width, int height) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
boundsMaskParam = NativeWindow.BOUNDS_NOMOVE;
|
|
setBounds(x, y, width, height);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by setSize(int, int) method.
|
|
*
|
|
* @param size
|
|
* the size.
|
|
* @deprecated Replaced by setSize(int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public void resize(Dimension size) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setSize(size.width, size.height);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this component is completely opaque.
|
|
*
|
|
* @return true, if this component is completely opaque, false by default.
|
|
*/
|
|
public boolean isOpaque() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return behaviour.isOpaque();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Disables.
|
|
*
|
|
* @deprecated Replaced by setEnabled(boolean) method.
|
|
*/
|
|
@Deprecated
|
|
public void disable() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setEnabledImpl(false);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
// ???AWT: fireAccessibleStateChange(AccessibleState.ENABLED, false);
|
|
}
|
|
|
|
/**
|
|
* Enables this component.
|
|
*
|
|
* @deprecated Replaced by setEnabled(boolean) method.
|
|
*/
|
|
@Deprecated
|
|
public void enable() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setEnabledImpl(true);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
// ???AWT: fireAccessibleStateChange(AccessibleState.ENABLED, true);
|
|
}
|
|
|
|
/**
|
|
* Enables or disable this component.
|
|
*
|
|
* @param b
|
|
* the boolean parameter.
|
|
* @deprecated Replaced by setEnabled(boolean) method.
|
|
*/
|
|
@Deprecated
|
|
public void enable(boolean b) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (b) {
|
|
enable();
|
|
} else {
|
|
disable();
|
|
}
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stores the location of this component to the specified Point object;
|
|
* returns the point of the component's top-left corner.
|
|
*
|
|
* @param rv
|
|
* the Point object where the component's top-left corner
|
|
* position will be stored.
|
|
* @return the Point which specifies the component's top-left corner.
|
|
*/
|
|
public Point getLocation(Point rv) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (rv == null) {
|
|
rv = new Point();
|
|
}
|
|
rv.setLocation(getX(), getY());
|
|
return rv;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the location of this component on the form; returns the point of the
|
|
* component's top-left corner.
|
|
*
|
|
* @return the Point which specifies the component's top-left corner.
|
|
*/
|
|
public Point getLocation() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return location();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the size of this Component.
|
|
*
|
|
* @return the size of this Component.
|
|
*/
|
|
public Dimension getSize() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return size();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stores the size of this Component to the specified Dimension object.
|
|
*
|
|
* @param rv
|
|
* the Dimension object where the size of the Component will be
|
|
* stored.
|
|
* @return the Dimension of this Component.
|
|
*/
|
|
public Dimension getSize(Dimension rv) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (rv == null) {
|
|
rv = new Dimension();
|
|
}
|
|
rv.setSize(getWidth(), getHeight());
|
|
return rv;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this Component is valid. A component is valid if it
|
|
* is correctly sized and positioned within its parent container and all its
|
|
* children are also valid.
|
|
*
|
|
* @return true, if the Component is valid, false otherwise.
|
|
*/
|
|
public boolean isValid() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return valid && behaviour.isDisplayable();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by getComponentAt(int, int) method.
|
|
*
|
|
* @return the Point.
|
|
* @deprecated Replaced by getComponentAt(int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public Point location() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return new Point(x, y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Connects this Component to a native screen resource and makes it
|
|
* displayable. This method not be called directly by user applications.
|
|
*/
|
|
public void addNotify() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
prepare4HierarchyChange();
|
|
behaviour.addNotify();
|
|
// ???AWT
|
|
// finishHierarchyChange(this, parent, 0);
|
|
// if (dropTarget != null) {
|
|
// dropTarget.addNotify(peer);
|
|
// }
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Map to display.
|
|
*
|
|
* @param b
|
|
* the b.
|
|
*/
|
|
void mapToDisplay(boolean b) {
|
|
// ???AWT
|
|
/*
|
|
* if (b && !isDisplayable()) { if ((this instanceof Window) || ((parent
|
|
* != null) && parent.isDisplayable())) { addNotify(); } } else if (!b
|
|
* && isDisplayable()) { removeNotify(); }
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Gets the toolkit.
|
|
*
|
|
* @return accessible context specific for particular component.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* AccessibleContext createAccessibleContext() { return null; } public
|
|
* AccessibleContext getAccessibleContext() { toolkit.lockAWT(); try { if
|
|
* (accessibleContext == null) { accessibleContext =
|
|
* createAccessibleContext(); } return accessibleContext; } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Gets Toolkit for the current Component.
|
|
*
|
|
* @return the Toolkit of this Component.
|
|
*/
|
|
public Toolkit getToolkit() {
|
|
return toolkit;
|
|
}
|
|
|
|
/**
|
|
* Gets this component's locking object for AWT component tree and layout
|
|
* operations.
|
|
*
|
|
* @return the tree locking object.
|
|
*/
|
|
public final Object getTreeLock() {
|
|
return toolkit.awtTreeLock;
|
|
}
|
|
|
|
/**
|
|
* Handles the event. Use ActionListener instead of this.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param what
|
|
* the event's key.
|
|
* @return true, if successful.
|
|
* @deprecated Use ActionListener class for registering event listener.
|
|
*/
|
|
@Deprecated
|
|
public boolean action(Event evt, Object what) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Gets the property change support.
|
|
*
|
|
* @return the property change support.
|
|
*/
|
|
private PropertyChangeSupport getPropertyChangeSupport() {
|
|
synchronized (componentLock) {
|
|
if (propertyChangeSupport == null) {
|
|
propertyChangeSupport = new PropertyChangeSupport(this);
|
|
}
|
|
return propertyChangeSupport;
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* public void addPropertyChangeListener(PropertyChangeListener listener) {
|
|
* getPropertyChangeSupport().addPropertyChangeListener(listener); } public
|
|
* void addPropertyChangeListener(String propertyName,
|
|
* PropertyChangeListener listener) {
|
|
* getPropertyChangeSupport().addPropertyChangeListener(propertyName,
|
|
* listener); } public void applyComponentOrientation(ComponentOrientation
|
|
* orientation) { toolkit.lockAWT(); try {
|
|
* setComponentOrientation(orientation); } finally { toolkit.unlockAWT(); }
|
|
* }
|
|
*/
|
|
|
|
/**
|
|
* Returns true if the set of focus traversal keys for the given focus
|
|
* traversal operation has been explicitly defined for this Component.
|
|
*
|
|
* @param id
|
|
* the ID of traversal key.
|
|
* @return true, if the set of focus traversal keys for the given focus.
|
|
* traversal operation has been explicitly defined for this
|
|
* Component, false otherwise.
|
|
*/
|
|
public boolean areFocusTraversalKeysSet(int id) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
Integer Id = new Integer(id);
|
|
if (traversalKeys.containsKey(Id)) {
|
|
return traversalKeys.get(Id) != null;
|
|
}
|
|
// awt.14F=invalid focus traversal key identifier
|
|
throw new IllegalArgumentException(Messages.getString("awt.14F")); //$NON-NLS-1$
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the bounds of the Component.
|
|
*
|
|
* @return the rectangle bounds of the Component.
|
|
* @deprecated Use getBounds() methood.
|
|
*/
|
|
@Deprecated
|
|
public Rectangle bounds() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return new Rectangle(x, y, w, h);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the construction status of a specified image with the specified
|
|
* width and height that is being created.
|
|
*
|
|
* @param image
|
|
* the image to be checked.
|
|
* @param width
|
|
* the width of scaled image which status is being checked, or
|
|
* -1.
|
|
* @param height
|
|
* the height of scaled image which status is being checked, or
|
|
* -1.
|
|
* @param observer
|
|
* the ImageObserver object to be notified while the image is
|
|
* being prepared.
|
|
* @return the ImageObserver flags of the current state of the image data.
|
|
*/
|
|
public int checkImage(Image image, int width, int height, ImageObserver observer) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return toolkit.checkImage(image, width, height, observer);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the construction status of a specified image that is being
|
|
* created.
|
|
*
|
|
* @param image
|
|
* the image to be checked.
|
|
* @param observer
|
|
* the ImageObserver object to be notified while the image is
|
|
* being prepared.
|
|
* @return the ImageObserver flags of the current state of the image data.
|
|
*/
|
|
public int checkImage(Image image, ImageObserver observer) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return toolkit.checkImage(image, -1, -1, observer);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Coalesces the existed event with new event.
|
|
*
|
|
* @param existingEvent
|
|
* the existing event in the EventQueue.
|
|
* @param newEvent
|
|
* the new event to be posted to the EventQueue.
|
|
* @return the coalesced AWTEvent, or null if there is no coalescing done.
|
|
*/
|
|
protected AWTEvent coalesceEvents(AWTEvent existingEvent, AWTEvent newEvent) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// Nothing to do:
|
|
// 1. Mouse events coalesced at WTK level
|
|
// 2. Paint events handled by RedrawManager
|
|
// This method is for overriding only
|
|
return null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if this Component is a coalescer.
|
|
*
|
|
* @return true, if is coalescer.
|
|
*/
|
|
boolean isCoalescer() {
|
|
return coalescer;
|
|
}
|
|
|
|
/**
|
|
* Gets the relative event.
|
|
*
|
|
* @param id
|
|
* the id.
|
|
* @return the relative event.
|
|
*/
|
|
AWTEvent getRelativeEvent(int id) {
|
|
Integer idWrapper = new Integer(id);
|
|
eventsList = eventsTable.get(idWrapper);
|
|
if (eventsList == null) {
|
|
eventsList = new LinkedList<AWTEvent>();
|
|
eventsTable.put(idWrapper, eventsList);
|
|
return null;
|
|
}
|
|
if (eventsList.isEmpty()) {
|
|
return null;
|
|
}
|
|
return eventsList.getLast();
|
|
}
|
|
|
|
/**
|
|
* Adds the new event.
|
|
*
|
|
* @param event
|
|
* the event.
|
|
*/
|
|
void addNewEvent(AWTEvent event) {
|
|
eventsList.addLast(event);
|
|
}
|
|
|
|
/**
|
|
* Removes the relative event.
|
|
*/
|
|
void removeRelativeEvent() {
|
|
eventsList.removeLast();
|
|
}
|
|
|
|
/**
|
|
* Removes the next event.
|
|
*
|
|
* @param id
|
|
* the id.
|
|
*/
|
|
void removeNextEvent(int id) {
|
|
eventsTable.get(new Integer(id)).removeFirst();
|
|
}
|
|
|
|
/**
|
|
* Creates the image with the specified ImageProducer.
|
|
*
|
|
* @param producer
|
|
* the ImageProducer to be used for image creation.
|
|
* @return the image with the specified ImageProducer.
|
|
*/
|
|
public Image createImage(ImageProducer producer) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return toolkit.createImage(producer);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an off-screen drawable image to be used for double buffering.
|
|
*
|
|
* @param width
|
|
* the width of the image.
|
|
* @param height
|
|
* the height of the image.
|
|
* @return the off-screen drawable image or null if the component is not
|
|
* displayable or GraphicsEnvironment.isHeadless() method returns
|
|
* true.
|
|
*/
|
|
public Image createImage(int width, int height) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!isDisplayable()) {
|
|
return null;
|
|
}
|
|
GraphicsConfiguration gc = getGraphicsConfiguration();
|
|
if (gc == null) {
|
|
return null;
|
|
}
|
|
ColorModel cm = gc.getColorModel(Transparency.OPAQUE);
|
|
WritableRaster wr = cm.createCompatibleWritableRaster(width, height);
|
|
Image image = new BufferedImage(cm, wr, cm.isAlphaPremultiplied(), null);
|
|
fillImageBackground(image, width, height);
|
|
return image;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates an off-screen drawable image with the specified width, height and
|
|
* ImageCapabilities.
|
|
*
|
|
* @param width
|
|
* the width.
|
|
* @param height
|
|
* the height.
|
|
* @param caps
|
|
* the ImageCapabilities.
|
|
* @return the volatile image.
|
|
* @throws AWTException
|
|
* if an image with the specified capabilities cannot be
|
|
* created.
|
|
*/
|
|
public VolatileImage createVolatileImage(int width, int height, ImageCapabilities caps)
|
|
throws AWTException {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!isDisplayable()) {
|
|
return null;
|
|
}
|
|
GraphicsConfiguration gc = getGraphicsConfiguration();
|
|
if (gc == null) {
|
|
return null;
|
|
}
|
|
VolatileImage image = gc.createCompatibleVolatileImage(width, height, caps);
|
|
fillImageBackground(image, width, height);
|
|
return image;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a volatile off-screen drawable image which is used for double
|
|
* buffering.
|
|
*
|
|
* @param width
|
|
* the width of image.
|
|
* @param height
|
|
* the height of image.
|
|
* @return the volatile image a volatile off-screen drawable image which is
|
|
* used for double buffering or null if the component is not
|
|
* displayable, or GraphicsEnvironment.isHeadless() method returns
|
|
* true.
|
|
*/
|
|
public VolatileImage createVolatileImage(int width, int height) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!isDisplayable()) {
|
|
return null;
|
|
}
|
|
GraphicsConfiguration gc = getGraphicsConfiguration();
|
|
if (gc == null) {
|
|
return null;
|
|
}
|
|
VolatileImage image = gc.createCompatibleVolatileImage(width, height);
|
|
fillImageBackground(image, width, height);
|
|
return image;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fill the image being created by createImage() or createVolatileImage()
|
|
* with the component's background color to prepare it for double-buffered
|
|
* painting.
|
|
*
|
|
* @param image
|
|
* the image.
|
|
* @param width
|
|
* the width.
|
|
* @param height
|
|
* the height.
|
|
*/
|
|
private void fillImageBackground(Image image, int width, int height) {
|
|
Graphics gr = image.getGraphics();
|
|
gr.setColor(getBackground());
|
|
gr.fillRect(0, 0, width, height);
|
|
gr.dispose();
|
|
}
|
|
|
|
/**
|
|
* Delivers event.
|
|
*
|
|
* @param evt
|
|
* the event.
|
|
* @deprecated Replaced by dispatchEvent(AWTEvent e) method.
|
|
*/
|
|
@Deprecated
|
|
public void deliverEvent(Event evt) {
|
|
postEvent(evt);
|
|
}
|
|
|
|
/**
|
|
* Prompts the layout manager to lay out this component.
|
|
*/
|
|
public void doLayout() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
layout();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
// Implemented in Container
|
|
}
|
|
|
|
/**
|
|
* Fire property change impl.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old value.
|
|
* @param newValue
|
|
* the new value.
|
|
*/
|
|
private void firePropertyChangeImpl(String propertyName, Object oldValue, Object newValue) {
|
|
PropertyChangeSupport pcs;
|
|
synchronized (componentLock) {
|
|
if (propertyChangeSupport == null) {
|
|
return;
|
|
}
|
|
pcs = propertyChangeSupport;
|
|
}
|
|
pcs.firePropertyChange(propertyName, oldValue, newValue);
|
|
}
|
|
|
|
/**
|
|
* Reports a bound property changes for int properties.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old property's value.
|
|
* @param newValue
|
|
* the new property's value.
|
|
*/
|
|
protected void firePropertyChange(String propertyName, int oldValue, int newValue) {
|
|
firePropertyChangeImpl(propertyName, new Integer(oldValue), new Integer(newValue));
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a boolean-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the property's old value.
|
|
* @param newValue
|
|
* the property's new value.
|
|
*/
|
|
protected void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
|
|
firePropertyChangeImpl(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
|
|
}
|
|
|
|
/**
|
|
* Reports a bound property change for an Object-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the property's old value.
|
|
* @param newValue
|
|
* the property's new value.
|
|
*/
|
|
protected void firePropertyChange(final String propertyName, final Object oldValue,
|
|
final Object newValue) {
|
|
firePropertyChangeImpl(propertyName, oldValue, newValue);
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a byte-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the property's old value.
|
|
* @param newValue
|
|
* the property's new value.
|
|
*/
|
|
public void firePropertyChange(String propertyName, byte oldValue, byte newValue) {
|
|
firePropertyChangeImpl(propertyName, new Byte(oldValue), new Byte(newValue));
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a char-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old property's value.
|
|
* @param newValue
|
|
* the new property's value.
|
|
*/
|
|
public void firePropertyChange(String propertyName, char oldValue, char newValue) {
|
|
firePropertyChangeImpl(propertyName, new Character(oldValue), new Character(newValue));
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a short-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old property's value.
|
|
* @param newValue
|
|
* the new property's value.
|
|
*/
|
|
public void firePropertyChange(String propertyName, short oldValue, short newValue) {
|
|
firePropertyChangeImpl(propertyName, new Short(oldValue), new Short(newValue));
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a long-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old property's value.
|
|
* @param newValue
|
|
* the new property's value.
|
|
*/
|
|
public void firePropertyChange(String propertyName, long oldValue, long newValue) {
|
|
firePropertyChangeImpl(propertyName, new Long(oldValue), new Long(newValue));
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a float-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old property's value.
|
|
* @param newValue
|
|
* the new property's value.
|
|
*/
|
|
public void firePropertyChange(String propertyName, float oldValue, float newValue) {
|
|
firePropertyChangeImpl(propertyName, new Float(oldValue), new Float(newValue));
|
|
}
|
|
|
|
/**
|
|
* Report a bound property change for a double-valued property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param oldValue
|
|
* the old property's value.
|
|
* @param newValue
|
|
* the new property's value.
|
|
*/
|
|
public void firePropertyChange(String propertyName, double oldValue, double newValue) {
|
|
firePropertyChangeImpl(propertyName, new Double(oldValue), new Double(newValue));
|
|
}
|
|
|
|
/**
|
|
* Gets the alignment along the x axis.
|
|
*
|
|
* @return the alignment along the x axis.
|
|
*/
|
|
public float getAlignmentX() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return CENTER_ALIGNMENT;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the alignment along the y axis.
|
|
*
|
|
* @return the alignment along y axis.
|
|
*/
|
|
public float getAlignmentY() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return CENTER_ALIGNMENT;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the background color for this component.
|
|
*
|
|
* @return the background color for this component.
|
|
*/
|
|
public Color getBackground() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT
|
|
/*
|
|
* if ((backColor == null) && (parent != null)) { return
|
|
* parent.getBackground(); }
|
|
*/
|
|
return backColor;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the bounding rectangle of this component.
|
|
*
|
|
* @return the bounding rectangle of this component.
|
|
*/
|
|
public Rectangle getBounds() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return bounds();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Writes the data of the bounding rectangle to the specified Rectangle
|
|
* object.
|
|
*
|
|
* @param rv
|
|
* the Rectangle object where the bounding rectangle's data is
|
|
* stored.
|
|
* @return the bounding rectangle.
|
|
*/
|
|
public Rectangle getBounds(Rectangle rv) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (rv == null) {
|
|
rv = new Rectangle();
|
|
}
|
|
rv.setBounds(x, y, w, h);
|
|
return rv;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the color model of the Component.
|
|
*
|
|
* @return the color model of the Component.
|
|
*/
|
|
public ColorModel getColorModel() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return getToolkit().getColorModel();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the Component which contains the specified Point.
|
|
*
|
|
* @param p
|
|
* the Point.
|
|
* @return the Component which contains the specified Point.
|
|
*/
|
|
public Component getComponentAt(Point p) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return getComponentAt(p.x, p.y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the Component which contains the point with the specified
|
|
* coordinates.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the point.
|
|
* @param y
|
|
* the y coordinate of the point.
|
|
* @return the Component which contains the point with the specified
|
|
* coordinates.
|
|
*/
|
|
public Component getComponentAt(int x, int y) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return locate(x, y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the component's orientation.
|
|
*
|
|
* @return the component's orientation.
|
|
*/
|
|
public ComponentOrientation getComponentOrientation() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return orientation;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the cursor of the Component.
|
|
*
|
|
* @return the Cursor.
|
|
*/
|
|
public Cursor getCursor() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (cursor != null) {
|
|
return cursor;
|
|
// ???AWT
|
|
/*
|
|
* } else if (parent != null) { return parent.getCursor();
|
|
*/
|
|
}
|
|
return Cursor.getDefaultCursor();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* public DropTarget getDropTarget() { toolkit.lockAWT(); try { return
|
|
* dropTarget; } finally { toolkit.unlockAWT(); } } public Container
|
|
* getFocusCycleRootAncestor() { toolkit.lockAWT(); try { for (Container c =
|
|
* parent; c != null; c = c.getParent()) { if (c.isFocusCycleRoot()) {
|
|
* return c; } } return null; } finally { toolkit.unlockAWT(); } }
|
|
* @SuppressWarnings("unchecked") public Set<AWTKeyStroke>
|
|
* getFocusTraversalKeys(int id) { toolkit.lockAWT(); try { Integer kId =
|
|
* new Integer(id); KeyboardFocusManager.checkTraversalKeysID(traversalKeys,
|
|
* kId); Set<? extends AWTKeyStroke> keys = traversalKeys.get(kId); if (keys
|
|
* == null && parent != null) { keys = parent.getFocusTraversalKeys(id); }
|
|
* if (keys == null) { keys =
|
|
* KeyboardFocusManager.getCurrentKeyboardFocusManager()
|
|
* .getDefaultFocusTraversalKeys(id); } return (Set<AWTKeyStroke>) keys; }
|
|
* finally { toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Checks if the the focus traversal keys are enabled for this component.
|
|
*
|
|
* @return true, if the the focus traversal keys are enabled for this
|
|
* component, false otherwise.
|
|
*/
|
|
public boolean getFocusTraversalKeysEnabled() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return focusTraversalKeysEnabled;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the font metrics of the specified Font.
|
|
*
|
|
* @param f
|
|
* the Font.
|
|
* @return the FontMetrics of the specified Font.
|
|
*/
|
|
@SuppressWarnings("deprecation")
|
|
public FontMetrics getFontMetrics(Font f) {
|
|
return toolkit.getFontMetrics(f);
|
|
}
|
|
|
|
/**
|
|
* Gets the foreground color of the Component.
|
|
*
|
|
* @return the foreground color of the Component.
|
|
*/
|
|
public Color getForeground() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT
|
|
/*
|
|
* if (foreColor == null && parent != null) { return
|
|
* parent.getForeground(); }
|
|
*/
|
|
return foreColor;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the Graphics of the Component or null if this Component is not
|
|
* displayable.
|
|
*
|
|
* @return the Graphics of the Component or null if this Component is not
|
|
* displayable.
|
|
*/
|
|
public Graphics getGraphics() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!isDisplayable()) {
|
|
return null;
|
|
}
|
|
Graphics g = behaviour.getGraphics(0, 0, w, h);
|
|
g.setColor(foreColor);
|
|
g.setFont(font);
|
|
return g;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the GraphicsConfiguration associated with this Component.
|
|
*
|
|
* @return the GraphicsConfiguration associated with this Component.
|
|
*/
|
|
public GraphicsConfiguration getGraphicsConfiguration() {
|
|
// ???AWT
|
|
/*
|
|
* toolkit.lockAWT(); try { Window win = getWindowAncestor(); if (win ==
|
|
* null) { return null; } return win.getGraphicsConfiguration(); }
|
|
* finally { toolkit.unlockAWT(); }
|
|
*/
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the height of the Component.
|
|
*
|
|
* @return the height of the Component.
|
|
*/
|
|
public int getHeight() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return h;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if paint messages received from the operating system should
|
|
* be ignored.
|
|
*
|
|
* @return true if paint messages received from the operating system should
|
|
* be ignored, false otherwise.
|
|
*/
|
|
public boolean getIgnoreRepaint() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return ignoreRepaint;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the input context of this component for handling the communication
|
|
* with input methods when text is entered in this component.
|
|
*
|
|
* @return the InputContext used by this Component or null if no context is
|
|
* specifined.
|
|
*/
|
|
public InputContext getInputContext() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT
|
|
/*
|
|
* Container parent = getParent(); if (parent != null) { return
|
|
* parent.getInputContext(); }
|
|
*/
|
|
return null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the input method request handler which supports requests from input
|
|
* methods for this component, or null for default.
|
|
*
|
|
* @return the input method request handler which supports requests from
|
|
* input methods for this component, or null for default.
|
|
*/
|
|
public InputMethodRequests getInputMethodRequests() {
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the locale of this Component.
|
|
*
|
|
* @return the locale of this Component.
|
|
*/
|
|
public Locale getLocale() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT
|
|
/*
|
|
* if (locale == null) { if (parent == null) { if (this instanceof
|
|
* Window) { return Locale.getDefault(); } // awt.150=no parent
|
|
* throw new
|
|
* IllegalComponentStateException(Messages.getString("awt.150"));
|
|
* //$NON-NLS-1$ } return getParent().getLocale(); }
|
|
*/
|
|
return locale;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the location of this component in the form of a point specifying the
|
|
* component's top-left corner in the screen's coordinate space.
|
|
*
|
|
* @return the Point giving the component's location in the screen's
|
|
* coordinate space.
|
|
* @throws IllegalComponentStateException
|
|
* if the component is not shown on the screen.
|
|
*/
|
|
public Point getLocationOnScreen() throws IllegalComponentStateException {
|
|
toolkit.lockAWT();
|
|
try {
|
|
Point p = new Point();
|
|
if (isShowing()) {
|
|
// ???AWT
|
|
/*
|
|
* Component comp; for (comp = this; comp != null && !(comp
|
|
* instanceof Window); comp = comp .getParent()) {
|
|
* p.translate(comp.getX(), comp.getY()); } if (comp instanceof
|
|
* Window) { p.translate(comp.getX(), comp.getY()); }
|
|
*/
|
|
return p;
|
|
}
|
|
// awt.151=component must be showing on the screen to determine its
|
|
// location
|
|
throw new IllegalComponentStateException(Messages.getString("awt.151")); //$NON-NLS-1$
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the peer. This method should not be called directly by user
|
|
* applications.
|
|
*
|
|
* @return the ComponentPeer.
|
|
* @deprecated Replaced by isDisplayable().
|
|
*/
|
|
@Deprecated
|
|
public ComponentPeer getPeer() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (behaviour.isDisplayable()) {
|
|
return peer;
|
|
}
|
|
return null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the property change listeners registered to this
|
|
* Component.
|
|
*
|
|
* @return an array of the PropertyChangeListeners registered to this
|
|
* Component.
|
|
*/
|
|
public PropertyChangeListener[] getPropertyChangeListeners() {
|
|
return getPropertyChangeSupport().getPropertyChangeListeners();
|
|
}
|
|
|
|
/**
|
|
* Gets an array of PropertyChangeListener objects registered to this
|
|
* Component for the specified property.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @return an array of PropertyChangeListener objects registered to this
|
|
* Component for the specified property.
|
|
*/
|
|
public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
|
|
return getPropertyChangeSupport().getPropertyChangeListeners(propertyName);
|
|
}
|
|
|
|
/**
|
|
* Gets the width of the Component.
|
|
*
|
|
* @return the width of the Component.
|
|
*/
|
|
public int getWidth() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return w;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the x coordinate of the component's top-left corner.
|
|
*
|
|
* @return the x coordinate of the component's top-left corner.
|
|
*/
|
|
public int getX() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return x;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the y coordinate of the component's top-left corner.
|
|
*
|
|
* @return the y coordinate of the component's top-left corner.
|
|
*/
|
|
public int getY() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return y;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Got the focus.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param what
|
|
* the Object.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processFocusEvent(FocusEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean gotFocus(Event evt, Object what) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Handles event.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processEvent(AWTEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean handleEvent(Event evt) {
|
|
switch (evt.id) {
|
|
case Event.ACTION_EVENT:
|
|
return action(evt, evt.arg);
|
|
case Event.GOT_FOCUS:
|
|
return gotFocus(evt, null);
|
|
case Event.LOST_FOCUS:
|
|
return lostFocus(evt, null);
|
|
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_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_UP:
|
|
return mouseUp(evt, evt.x, evt.y);
|
|
case Event.KEY_ACTION:
|
|
case Event.KEY_PRESS:
|
|
return keyDown(evt, evt.key);
|
|
case Event.KEY_ACTION_RELEASE:
|
|
case Event.KEY_RELEASE:
|
|
return keyUp(evt, evt.key);
|
|
}
|
|
return false;// event not handled
|
|
}
|
|
|
|
/**
|
|
* Checks whether the Component is the focus owner or not.
|
|
*
|
|
* @return true, if the Component is the focus owner, false otherwise.
|
|
*/
|
|
public boolean hasFocus() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT: return isFocusOwner();
|
|
return false;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Hides the Component.
|
|
*
|
|
* @deprecated Replaced by setVisible(boolean) method.
|
|
*/
|
|
@Deprecated
|
|
public void hide() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!visible) {
|
|
return;
|
|
}
|
|
prepare4HierarchyChange();
|
|
visible = false;
|
|
moveFocusOnHide();
|
|
behaviour.setVisible(false);
|
|
postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_HIDDEN));
|
|
// ???AWT: finishHierarchyChange(this, parent, 0);
|
|
notifyInputMethod(null);
|
|
// ???AWT: invalidateRealParent();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not the point with the specified coordinates belongs to
|
|
* the Commponent.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the Point.
|
|
* @param y
|
|
* the y coordinate of the Point.
|
|
* @return true, if the point with the specified coordinates belongs to the
|
|
* Commponent, false otherwise.
|
|
* @deprecated Replaced by contains(int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean inside(int x, int y) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return x >= 0 && x < getWidth() && y >= 0 && y < getHeight();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invalidates the component, this component and all parents above it are
|
|
* marked as needing to be laid out.
|
|
*/
|
|
public void invalidate() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
valid = false;
|
|
resetDefaultSize();
|
|
// ???AWT: invalidateRealParent();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not the background color is set to this Component.
|
|
*
|
|
* @return true, if the background color is set to this Component, false
|
|
* otherwise.
|
|
*/
|
|
public boolean isBackgroundSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return backColor != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not a cursor is set for the Component.
|
|
*
|
|
* @return true, if a cursor is set for the Component, false otherwise.
|
|
*/
|
|
public boolean isCursorSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return cursor != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this Component is displayable.
|
|
*
|
|
* @return true, if this Component is displayable, false otherwise.
|
|
*/
|
|
public boolean isDisplayable() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return behaviour.isDisplayable();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this component is painted to an buffer which is
|
|
* copied to the screen later.
|
|
*
|
|
* @return true, if this component is painted to an buffer which is copied
|
|
* to the screen later, false otherwise.
|
|
*/
|
|
public boolean isDoubleBuffered() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// false by default
|
|
return false;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this Component is enabled.
|
|
*
|
|
* @return true, if this Component is enabled, false otherwise.
|
|
*/
|
|
public boolean isEnabled() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return enabled;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* "Recursive" isEnabled().
|
|
*
|
|
* @return true if not only component itself is enabled but its heavyweight
|
|
* parent is also "indirectly" enabled.
|
|
*/
|
|
boolean isIndirectlyEnabled() {
|
|
Component comp = this;
|
|
while (comp != null) {
|
|
if (!comp.isLightweight() && !comp.isEnabled()) {
|
|
return false;
|
|
}
|
|
// ???AWT: comp = comp.getRealParent();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Checks if the component is key enabled.
|
|
*
|
|
* @return true, if the component is enabled and indirectly enabled.
|
|
*/
|
|
boolean isKeyEnabled() {
|
|
if (!isEnabled()) {
|
|
return false;
|
|
}
|
|
return isIndirectlyEnabled();
|
|
}
|
|
|
|
/**
|
|
* Gets only parent of a child component, but not owner of a window.
|
|
*
|
|
* @return parent of child component, null if component is a top-level
|
|
* (Window instance).
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* Container getRealParent() { return (!(this instanceof Window) ?
|
|
* getParent() : null); } public boolean isFocusCycleRoot(Container
|
|
* container) { toolkit.lockAWT(); try { return getFocusCycleRootAncestor()
|
|
* == container; } finally { toolkit.unlockAWT(); } } public boolean
|
|
* isFocusOwner() { toolkit.lockAWT(); try { return
|
|
* KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() ==
|
|
* this; } finally { toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Checks whether or not this Component can be focusable.
|
|
*
|
|
* @return true, if this Component can be focusable, false otherwise.
|
|
* @deprecated Replaced by isFocusable().
|
|
*/
|
|
@Deprecated
|
|
public boolean isFocusTraversable() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
overridenIsFocusable = false;
|
|
return focusable; // a Component must either be both focusable and
|
|
// focus traversable, or neither
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if this Component can be focusable or not.
|
|
*
|
|
* @return true, if this Component can be focusable, false otherwise.
|
|
*/
|
|
public boolean isFocusable() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return isFocusTraversable();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if the Font is set for this Component or not.
|
|
*
|
|
* @return true, if the Font is set, false otherwise.
|
|
*/
|
|
public boolean isFontSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return font != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks if foreground color is set for the Component or not.
|
|
*
|
|
* @return true, if is foreground color is set for the Component, false
|
|
* otherwise.
|
|
*/
|
|
public boolean isForegroundSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return foreColor != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if this component has a lightweight peer.
|
|
*
|
|
* @return true, if this component has a lightweight peer, false if it has a
|
|
* native peer or no peer.
|
|
*/
|
|
public boolean isLightweight() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return behaviour.isLightweight();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this Component is shown.
|
|
*
|
|
* @return true, if this Component is shown, false otherwise.
|
|
*/
|
|
public boolean isShowing() {
|
|
// ???AWT
|
|
/*
|
|
* toolkit.lockAWT(); try { return (isVisible() && isDisplayable() &&
|
|
* (parent != null) && parent.isShowing()); } finally {
|
|
* toolkit.unlockAWT(); }
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not this Component is visible.
|
|
*
|
|
* @return true, if the Component is visible, false otherwise.
|
|
*/
|
|
public boolean isVisible() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return visible;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by processKeyEvent(KeyEvent) method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param key
|
|
* the key code.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by replaced by processKeyEvent(KeyEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean keyDown(Event evt, int key) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by processKeyEvent(KeyEvent) method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param key
|
|
* the key code.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processKeyEvent(KeyEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean keyUp(Event evt, int key) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deprecated: Replaced by doLayout() method.
|
|
*
|
|
* @deprecated Replaced by doLayout() method.
|
|
*/
|
|
@Deprecated
|
|
public void layout() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// Implemented in Container
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by getComponentAt(int, int) method.
|
|
*
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return The component.
|
|
* @deprecated Replaced by getComponentAt(int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public Component locate(int x, int y) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (contains(x, y)) {
|
|
return this;
|
|
}
|
|
return null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by processFocusEvent(FocusEvent).
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param what
|
|
* the Object.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processFocusEvent(FocusEvent).
|
|
*/
|
|
@Deprecated
|
|
public boolean lostFocus(Event evt, Object what) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by processMouseEvent(MouseEvent) method.
|
|
*
|
|
* @param evt
|
|
* the MouseEvent.
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processMouseEvent(MouseEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean mouseDown(Event evt, int x, int y) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by getMinimumSize() method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by getMinimumSize() method.
|
|
*/
|
|
@Deprecated
|
|
public boolean mouseDrag(Event evt, int x, int y) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Replaced by processMouseEvent(MouseEvent) method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return true, if successful.
|
|
* @deprecated replaced by processMouseEvent(MouseEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean mouseEnter(Event evt, int x, int y) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Replaced by processMouseEvent(MouseEvent) method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processMouseEvent(MouseEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean mouseExit(Event evt, int x, int y) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Replaced by processMouseEvent(MouseEvent) method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @deprecated Replaced by processMouseEvent(MouseEvent) method.
|
|
* @return true, if successful.
|
|
*/
|
|
@Deprecated
|
|
public boolean mouseMove(Event evt, int x, int y) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Replaced by processMouseEvent(MouseEvent) method.
|
|
*
|
|
* @param evt
|
|
* the Event.
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @return true, if successful.
|
|
* @deprecated Replaced by processMouseEvent(MouseEvent) method.
|
|
*/
|
|
@Deprecated
|
|
public boolean mouseUp(Event evt, int x, int y) {
|
|
// to be overridden: do nothing,
|
|
// just return false to propagate event up to the parent container
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by setLocation(int, int) method.
|
|
*
|
|
* @param x
|
|
* the x coordinates.
|
|
* @param y
|
|
* the y coordinates.
|
|
* @deprecated Replaced by setLocation(int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public void move(int x, int y) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
boundsMaskParam = NativeWindow.BOUNDS_NOSIZE;
|
|
setBounds(x, y, w, h);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* @Deprecated public void nextFocus() { toolkit.lockAWT(); try {
|
|
* transferFocus(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS); } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Returns a string representation of the component's state.
|
|
*
|
|
* @return the string representation of the component's state.
|
|
*/
|
|
protected String paramString() {
|
|
/*
|
|
* The format is based on 1.5 release behavior which can be revealed by
|
|
* the following code: Component c = new Component(){};
|
|
* c.setVisible(false); System.out.println(c);
|
|
*/
|
|
toolkit.lockAWT();
|
|
try {
|
|
return getName() + "," + getX() + "," + getY() + "," + getWidth() + "x" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
|
|
+ getHeight() + (!isVisible() ? ",hidden" : ""); //$NON-NLS-1$ //$NON-NLS-2$
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
@Deprecated
|
|
@SuppressWarnings("deprecation")
|
|
public boolean postEvent(Event evt) {
|
|
boolean handled = handleEvent(evt);
|
|
if (handled) {
|
|
return true;
|
|
}
|
|
// ???AWT
|
|
/*
|
|
* // propagate non-handled events up to parent Component par = parent;
|
|
* // try to call postEvent only on components which // override any of
|
|
* deprecated method handlers // while (par != null &&
|
|
* !par.deprecatedEventHandler) { // par = par.parent; // } // translate
|
|
* event coordinates before posting it to parent if (par != null) {
|
|
* evt.translate(x, y); par.postEvent(evt); }
|
|
*/
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Prepares an image for rendering on the Component.
|
|
*
|
|
* @param image
|
|
* the Image to be prepared.
|
|
* @param observer
|
|
* the ImageObserver object to be notified as soon as the image
|
|
* is prepared.
|
|
* @return true if the image has been fully prepared, false otherwise.
|
|
*/
|
|
public boolean prepareImage(Image image, ImageObserver observer) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return toolkit.prepareImage(image, -1, -1, observer);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepares an image for rendering on the Component with the specified
|
|
* width, height, and ImageObserver.
|
|
*
|
|
* @param image
|
|
* the Image to be prepared.
|
|
* @param width
|
|
* the width of scaled image.
|
|
* @param height
|
|
* the height of scaled height.
|
|
* @param observer
|
|
* the ImageObserver object to be notified as soon as the image
|
|
* is prepared.
|
|
* @return true if the image is been fully prepared, false otherwise.
|
|
*/
|
|
public boolean prepareImage(Image image, int width, int height, ImageObserver observer) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return toolkit.prepareImage(image, width, height, observer);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Makes this Component undisplayable.
|
|
*/
|
|
public void removeNotify() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT
|
|
/*
|
|
* if (dropTarget != null) { dropTarget.removeNotify(peer); }
|
|
*/
|
|
prepare4HierarchyChange();
|
|
// /???AWT: moveFocus();
|
|
behaviour.removeNotify();
|
|
// ???AWT: finishHierarchyChange(this, parent, 0);
|
|
removeNotifyInputContext();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Calls InputContext.removeNotify.
|
|
*/
|
|
private void removeNotifyInputContext() {
|
|
if (!inputMethodsEnabled) {
|
|
return;
|
|
}
|
|
InputContext ic = getInputContext();
|
|
if (ic != null) {
|
|
// ???AWT: ic.removeNotify(this);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method is called when some property of a component changes, making
|
|
* it unfocusable, e. g. hide(), removeNotify(), setEnabled(false),
|
|
* setFocusable(false) is called, and therefore automatic forward focus
|
|
* traversal is necessary
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* void moveFocus() { // don't use transferFocus(), but query focus
|
|
* traversal policy directly // and if it returns null, transfer focus up
|
|
* cycle // and find next focusable component there KeyboardFocusManager kfm
|
|
* = KeyboardFocusManager.getCurrentKeyboardFocusManager(); Container root =
|
|
* kfm.getCurrentFocusCycleRoot(); Component nextComp = this; boolean
|
|
* success = !isFocusOwner(); while (!success) { if (root !=
|
|
* nextComp.getFocusCycleRootAncestor()) { // component was probably removed
|
|
* from container // so focus will be lost in some time return; } nextComp =
|
|
* root.getFocusTraversalPolicy().getComponentAfter(root, nextComp); if
|
|
* (nextComp == this) { nextComp = null; // avoid looping } if (nextComp !=
|
|
* null) { success = nextComp.requestFocusInWindow(); } else { nextComp =
|
|
* root; root = root.getFocusCycleRootAncestor(); // if no acceptable
|
|
* component is found at all - clear global // focus owner if (root == null)
|
|
* { if (nextComp instanceof Window) { Window wnd = (Window) nextComp;
|
|
* wnd.setFocusOwner(null); wnd.setRequestedFocus(null); }
|
|
* kfm.clearGlobalFocusOwner(); return; } } } }
|
|
*/
|
|
|
|
/**
|
|
* For Container there's a difference between moving focus when being made
|
|
* invisible or made unfocusable in some other way, because when container
|
|
* is made invisible, component still remains visible, i. e. its hide() or
|
|
* setVisible() is not called.
|
|
*/
|
|
void moveFocusOnHide() {
|
|
// ???AWT: moveFocus();
|
|
}
|
|
|
|
/**
|
|
* Removes the property change listener registered for this component.
|
|
*
|
|
* @param listener
|
|
* the PropertyChangeListener.
|
|
*/
|
|
public void removePropertyChangeListener(PropertyChangeListener listener) {
|
|
getPropertyChangeSupport().removePropertyChangeListener(listener);
|
|
}
|
|
|
|
/**
|
|
* Removes the property change listener registered fot this component for
|
|
* the specified propertyy.
|
|
*
|
|
* @param propertyName
|
|
* the property name.
|
|
* @param listener
|
|
* the PropertyChangeListener.
|
|
*/
|
|
public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) {
|
|
getPropertyChangeSupport().removePropertyChangeListener(propertyName, listener);
|
|
}
|
|
|
|
/**
|
|
* Repaints the specified rectangle of this component within tm
|
|
* milliseconds.
|
|
*
|
|
* @param tm
|
|
* the time in milliseconds before updating.
|
|
* @param x
|
|
* the x coordinate of Rectangle.
|
|
* @param y
|
|
* the y coordinate of Rectangle.
|
|
* @param width
|
|
* the width of Rectangle.
|
|
* @param height
|
|
* the height of Rectangle.
|
|
*/
|
|
public void repaint(long tm, int x, int y, int width, int height) {
|
|
// ???AWT
|
|
/*
|
|
* toolkit.lockAWT(); try { if (width <= 0 || height <= 0 ||
|
|
* (redrawManager == null) || !isShowing()) { return; } if (behaviour
|
|
* instanceof LWBehavior) { if (parent == null || !parent.visible ||
|
|
* !parent.behaviour.isDisplayable()) { return; } if (repaintRegion ==
|
|
* null) { repaintRegion = new MultiRectArea(new Rectangle(x, y, width,
|
|
* height)); } repaintRegion.intersect(new Rectangle(0, 0, this.w,
|
|
* this.h)); repaintRegion.translate(this.x, this.y);
|
|
* parent.repaintRegion = repaintRegion; repaintRegion = null;
|
|
* parent.repaint(tm, x + this.x, y + this.y, width, height); } else {
|
|
* if (repaintRegion != null) { redrawManager.addUpdateRegion(this,
|
|
* repaintRegion); repaintRegion = null; } else {
|
|
* redrawManager.addUpdateRegion(this, new Rectangle(x, y, width,
|
|
* height)); }
|
|
* toolkit.getSystemEventQueueCore().notifyEventMonitor(toolkit); } }
|
|
* finally { toolkit.unlockAWT(); }
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Post event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
void postEvent(AWTEvent e) {
|
|
getToolkit().getSystemEventQueueImpl().postEvent(e);
|
|
}
|
|
|
|
/**
|
|
* Repaints the specified Rectangle of this Component.
|
|
*
|
|
* @param x
|
|
* the x coordinate of Rectangle.
|
|
* @param y
|
|
* the y coordinate of Rectangle.
|
|
* @param width
|
|
* the width of Rectangle.
|
|
* @param height
|
|
* the height of Rectangle.
|
|
*/
|
|
public void repaint(int x, int y, int width, int height) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
repaint(0, x, y, width, height);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Repaints this component.
|
|
*/
|
|
public void repaint() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (w > 0 && h > 0) {
|
|
repaint(0, 0, 0, w, h);
|
|
}
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Repaints the component within tm milliseconds.
|
|
*
|
|
* @param tm
|
|
* the time in milliseconds before updating.
|
|
*/
|
|
public void repaint(long tm) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
repaint(tm, 0, 0, w, h);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Requests that this Component get the input focus temporarily. This
|
|
* component must be displayable, visible, and focusable.
|
|
*
|
|
* @param temporary
|
|
* this parameter is true if the focus change is temporary, when
|
|
* the window loses the focus.
|
|
* @return true if the focus change request is succeeded, false otherwise.
|
|
*/
|
|
protected boolean requestFocus(boolean temporary) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT: return requestFocusImpl(temporary, true, false);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
// ???AWT
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Requests that this Component get the input focus. This component must be
|
|
* displayable, visible, and focusable.
|
|
*/
|
|
public void requestFocus() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
requestFocus(false);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* protected boolean requestFocusInWindow(boolean temporary) {
|
|
* toolkit.lockAWT(); try { Window wnd = getWindowAncestor(); if ((wnd ==
|
|
* null) || !wnd.isFocused()) { return false; } return
|
|
* requestFocusImpl(temporary, false, false); } finally {
|
|
* toolkit.unlockAWT(); } } boolean requestFocusImpl(boolean temporary,
|
|
* boolean crossWindow, boolean rejectionRecovery) { if (!rejectionRecovery
|
|
* && isFocusOwner()) { return true; } Window wnd = getWindowAncestor();
|
|
* Container par = getRealParent(); if ((par != null) && par.isRemoved) {
|
|
* return false; } if (!isShowing() || !isFocusable() ||
|
|
* !wnd.isFocusableWindow()) { return false; } return
|
|
* KeyboardFocusManager.getCurrentKeyboardFocusManager().requestFocus(this,
|
|
* temporary, crossWindow, true); } public boolean requestFocusInWindow() {
|
|
* toolkit.lockAWT(); try { return requestFocusInWindow(false); } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Deprecated: replaced by setBounds(int, int, int, int) method.
|
|
*
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
* @param w
|
|
* the width.
|
|
* @param h
|
|
* the height.
|
|
* @deprecated Replaced by setBounds(int, int, int, int) method.
|
|
*/
|
|
@Deprecated
|
|
public void reshape(int x, int y, int w, int h) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setBounds(x, y, w, h, boundsMaskParam, true);
|
|
boundsMaskParam = 0;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets rectangle for this Component to be the rectangle with the specified
|
|
* x,y coordinates of the top-left corner and the width and height.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the rectangle's top-left corner.
|
|
* @param y
|
|
* the y coordinate of the rectangle's top-left corner.
|
|
* @param w
|
|
* the width of rectangle.
|
|
* @param h
|
|
* the height of rectangle.
|
|
*/
|
|
public void setBounds(int x, int y, int w, int h) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
reshape(x, y, w, h);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets rectangle for this Component to be the rectangle with the specified
|
|
* x,y coordinates of the top-left corner and the width and height and posts
|
|
* the appropriate events.
|
|
*
|
|
* @param x
|
|
* the x coordinate of the rectangle's top-left corner.
|
|
* @param y
|
|
* the y coordinate of the rectangle's top-left corner.
|
|
* @param w
|
|
* the width of rectangle.
|
|
* @param h
|
|
* the height of rectangle.
|
|
* @param bMask
|
|
* the bitmask of bounds options.
|
|
* @param updateBehavior
|
|
* the whether to update the behavoir's bounds as well.
|
|
*/
|
|
void setBounds(int x, int y, int w, int h, int bMask, boolean updateBehavior) {
|
|
int oldX = this.x;
|
|
int oldY = this.y;
|
|
int oldW = this.w;
|
|
int oldH = this.h;
|
|
setBoundsFields(x, y, w, h, bMask);
|
|
// Moved
|
|
if ((oldX != this.x) || (oldY != this.y)) {
|
|
// ???AWT: invalidateRealParent();
|
|
postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_MOVED));
|
|
spreadHierarchyBoundsEvents(this, HierarchyEvent.ANCESTOR_MOVED);
|
|
}
|
|
// Resized
|
|
if ((oldW != this.w) || (oldH != this.h)) {
|
|
invalidate();
|
|
postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_RESIZED));
|
|
spreadHierarchyBoundsEvents(this, HierarchyEvent.ANCESTOR_RESIZED);
|
|
}
|
|
if (updateBehavior) {
|
|
behaviour.setBounds(this.x, this.y, this.w, this.h, bMask);
|
|
}
|
|
notifyInputMethod(new Rectangle(x, y, w, h));
|
|
}
|
|
|
|
/**
|
|
* Calls InputContextImpl.notifyClientWindowChanged.
|
|
*
|
|
* @param bounds
|
|
* the bounds.
|
|
*/
|
|
void notifyInputMethod(Rectangle bounds) {
|
|
// only Window actually notifies IM of bounds change
|
|
}
|
|
|
|
/**
|
|
* Sets the bounds fields.
|
|
*
|
|
* @param x
|
|
* the x.
|
|
* @param y
|
|
* the y.
|
|
* @param w
|
|
* the w.
|
|
* @param h
|
|
* the h.
|
|
* @param bMask
|
|
* the b mask.
|
|
*/
|
|
private void setBoundsFields(int x, int y, int w, int h, int bMask) {
|
|
if ((bMask & NativeWindow.BOUNDS_NOSIZE) == 0) {
|
|
this.w = w;
|
|
this.h = h;
|
|
}
|
|
if ((bMask & NativeWindow.BOUNDS_NOMOVE) == 0) {
|
|
this.x = x;
|
|
this.y = y;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the native insets.
|
|
*
|
|
* @return the native insets.
|
|
*/
|
|
Insets getNativeInsets() {
|
|
return new Insets(0, 0, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* Gets the insets.
|
|
*
|
|
* @return the insets.
|
|
*/
|
|
Insets getInsets() {
|
|
return new Insets(0, 0, 0, 0);
|
|
}
|
|
|
|
/**
|
|
* Checks if is mouse exited expected.
|
|
*
|
|
* @return true, if is mouse exited expected.
|
|
*/
|
|
boolean isMouseExitedExpected() {
|
|
return mouseExitedExpected;
|
|
}
|
|
|
|
/**
|
|
* Sets the mouse exited expected.
|
|
*
|
|
* @param expected
|
|
* the new mouse exited expected.
|
|
*/
|
|
void setMouseExitedExpected(boolean expected) {
|
|
mouseExitedExpected = expected;
|
|
}
|
|
|
|
/**
|
|
* Sets the new bounding rectangle for this Component.
|
|
*
|
|
* @param r
|
|
* the new bounding rectangle.
|
|
*/
|
|
public void setBounds(Rectangle r) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setBounds(r.x, r.y, r.width, r.height);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the component orientation which affects the component's elements and
|
|
* text within this component.
|
|
*
|
|
* @param o
|
|
* the ComponentOrientation object.
|
|
*/
|
|
public void setComponentOrientation(ComponentOrientation o) {
|
|
ComponentOrientation oldOrientation;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldOrientation = orientation;
|
|
orientation = o;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("componentOrientation", oldOrientation, orientation); //$NON-NLS-1$
|
|
invalidate();
|
|
}
|
|
|
|
/**
|
|
* Sets the specified cursor for this Component.
|
|
*
|
|
* @param cursor
|
|
* the new Cursor.
|
|
*/
|
|
public void setCursor(Cursor cursor) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
this.cursor = cursor;
|
|
setCursor();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set current cursor shape to Component's Cursor.
|
|
*/
|
|
void setCursor() {
|
|
if (isDisplayable() && isShowing()) {
|
|
Rectangle absRect = new Rectangle(getLocationOnScreen(), getSize());
|
|
Point absPointerPos = toolkit.dispatcher.mouseDispatcher.getPointerPos();
|
|
// ???AWT
|
|
/*
|
|
* if (absRect.contains(absPointerPos)) { // set Cursor only on
|
|
* top-level Windows(on X11) Window topLevelWnd =
|
|
* getWindowAncestor(); if (topLevelWnd != null) { Point pointerPos
|
|
* = MouseDispatcher.convertPoint(null, absPointerPos, topLevelWnd);
|
|
* Component compUnderCursor =
|
|
* topLevelWnd.findComponentAt(pointerPos); // if (compUnderCursor
|
|
* == this || // compUnderCursor.getCursorAncestor() == this) {
|
|
* NativeWindow wnd = topLevelWnd.getNativeWindow(); if
|
|
* (compUnderCursor != null && wnd != null) {
|
|
* compUnderCursor.getRealCursor().getNativeCursor()
|
|
* .setCursor(wnd.getId()); } // } } }
|
|
*/
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the ancestor Cursor if Component is disabled (directly or via an
|
|
* ancestor) even if Cursor is explicitly set.
|
|
*
|
|
* @param value
|
|
* the value.
|
|
* @return the actual Cursor to be displayed.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* Cursor getRealCursor() { Component cursorAncestor = getCursorAncestor();
|
|
* return cursorAncestor != null ? cursorAncestor.getCursor() :
|
|
* Cursor.getDefaultCursor(); }
|
|
*/
|
|
|
|
/**
|
|
* Gets the ancestor(or component itself) whose cursor is set when pointer
|
|
* is inside component
|
|
*
|
|
* @return the actual Cursor to be displayed.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* Component getCursorAncestor() { Component comp; for (comp = this; comp !=
|
|
* null; comp = comp.getParent()) { if (comp instanceof Window ||
|
|
* comp.isCursorSet() && comp.isKeyEnabled()) { return comp; } } return
|
|
* null; } public void setDropTarget(DropTarget dt) { toolkit.lockAWT(); try
|
|
* { if (dropTarget == dt) { return; } DropTarget oldDropTarget =
|
|
* dropTarget; dropTarget = dt; if (oldDropTarget != null) { if
|
|
* (behaviour.isDisplayable()) { oldDropTarget.removeNotify(peer); }
|
|
* oldDropTarget.setComponent(null); } if (dt != null) {
|
|
* dt.setComponent(this); if (behaviour.isDisplayable()) {
|
|
* dt.addNotify(peer); } } } finally { toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Sets this component to the "enabled" or "disabled" state depending on the
|
|
* specified boolean parameter.
|
|
*
|
|
* @param value
|
|
* true if this component should be enabled; false if this
|
|
* component should be disabled.
|
|
*/
|
|
public void setEnabled(boolean value) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
enable(value);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the enabled impl.
|
|
*
|
|
* @param value
|
|
* the new enabled impl.
|
|
*/
|
|
void setEnabledImpl(boolean value) {
|
|
if (enabled != value) {
|
|
enabled = value;
|
|
setCursor();
|
|
if (!enabled) {
|
|
moveFocusOnHide();
|
|
}
|
|
behaviour.setEnabled(value);
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* private void fireAccessibleStateChange(AccessibleState state, boolean
|
|
* value) { if (behaviour.isLightweight()) { return; } AccessibleContext ac
|
|
* = getAccessibleContext(); if (ac != null) { AccessibleState oldValue =
|
|
* null; AccessibleState newValue = null; if (value) { newValue = state; }
|
|
* else { oldValue = state; }
|
|
* ac.firePropertyChange(AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
|
|
* oldValue, newValue); } }
|
|
*/
|
|
|
|
// ???AWT
|
|
/*
|
|
* public void setFocusTraversalKeys(int id, Set<? extends AWTKeyStroke>
|
|
* keystrokes) { Set<? extends AWTKeyStroke> oldTraversalKeys; String
|
|
* propName = "FocusTraversalKeys"; //$NON-NLS-1$ toolkit.lockAWT(); try {
|
|
* Integer kId = new Integer(id);
|
|
* KeyboardFocusManager.checkTraversalKeysID(traversalKeys, kId);
|
|
* Map<Integer, Set<? extends AWTKeyStroke>> keys = new HashMap<Integer,
|
|
* Set<? extends AWTKeyStroke>>(); for (int kid : traversalIDs) { Integer
|
|
* key = new Integer(kid); keys.put(key, getFocusTraversalKeys(kid)); }
|
|
* KeyboardFocusManager.checkKeyStrokes(traversalIDs, keys, kId,
|
|
* keystrokes); oldTraversalKeys = traversalKeys.get(new Integer(id)); //
|
|
* put a copy of keystrokes object into map: Set<? extends AWTKeyStroke>
|
|
* newKeys = keystrokes; if (keystrokes != null) { newKeys = new
|
|
* HashSet<AWTKeyStroke>(keystrokes); } traversalKeys.put(kId, newKeys);
|
|
* String direction = ""; //$NON-NLS-1$ switch (id) { case
|
|
* KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS: direction = "forward";
|
|
* //$NON-NLS-1$ break; case KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS:
|
|
* direction = "backward"; //$NON-NLS-1$ break; case
|
|
* KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS: direction = "upCycle";
|
|
* //$NON-NLS-1$ break; case KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS:
|
|
* direction = "downCycle"; //$NON-NLS-1$ break; } propName = direction +
|
|
* propName; } finally { toolkit.unlockAWT(); } firePropertyChange(propName,
|
|
* oldTraversalKeys, keystrokes); }
|
|
*/
|
|
|
|
/**
|
|
* Sets the focus traversal keys state for this component.
|
|
*
|
|
* @param value
|
|
* true if the focus traversal keys state is enabled, false if
|
|
* the focus traversal keys state is disabled.
|
|
*/
|
|
public void setFocusTraversalKeysEnabled(boolean value) {
|
|
boolean oldFocusTraversalKeysEnabled;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldFocusTraversalKeysEnabled = focusTraversalKeysEnabled;
|
|
focusTraversalKeysEnabled = value;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("focusTraversalKeysEnabled", oldFocusTraversalKeysEnabled, //$NON-NLS-1$
|
|
focusTraversalKeysEnabled);
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* public void setFocusable(boolean focusable) { boolean oldFocusable;
|
|
* toolkit.lockAWT(); try { calledSetFocusable = true; oldFocusable =
|
|
* this.focusable; this.focusable = focusable; if (!focusable) {
|
|
* moveFocus(); } } finally { toolkit.unlockAWT(); }
|
|
* firePropertyChange("focusable", oldFocusable, focusable); //$NON-NLS-1$ }
|
|
* public Font getFont() { toolkit.lockAWT(); try { return (font == null) &&
|
|
* (parent != null) ? parent.getFont() : font; } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Sets the font for this Component.
|
|
*
|
|
* @param f
|
|
* the new font of the Component.
|
|
*/
|
|
public void setFont(Font f) {
|
|
Font oldFont;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldFont = font;
|
|
setFontImpl(f);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("font", oldFont, font); //$NON-NLS-1$
|
|
}
|
|
|
|
/**
|
|
* Sets the font impl.
|
|
*
|
|
* @param f
|
|
* the new font impl.
|
|
*/
|
|
void setFontImpl(Font f) {
|
|
font = f;
|
|
invalidate();
|
|
if (isShowing()) {
|
|
repaint();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invalidate the component if it inherits the font from the parent. This
|
|
* method is overridden in Container.
|
|
*
|
|
* @return true if the component was invalidated, false otherwise.
|
|
*/
|
|
boolean propagateFont() {
|
|
if (font == null) {
|
|
invalidate();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Sets the foreground color for this Component.
|
|
*
|
|
* @param c
|
|
* the new foreground color.
|
|
*/
|
|
public void setForeground(Color c) {
|
|
Color oldFgColor;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldFgColor = foreColor;
|
|
foreColor = c;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("foreground", oldFgColor, foreColor); //$NON-NLS-1$
|
|
repaint();
|
|
}
|
|
|
|
/**
|
|
* Sets the background color for the Component.
|
|
*
|
|
* @param c
|
|
* the new background color for this component.
|
|
*/
|
|
public void setBackground(Color c) {
|
|
Color oldBkColor;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldBkColor = backColor;
|
|
backColor = c;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("background", oldBkColor, backColor); //$NON-NLS-1$
|
|
repaint();
|
|
}
|
|
|
|
/**
|
|
* Sets the flag for whether paint messages received from the operating
|
|
* system should be ignored or not.
|
|
*
|
|
* @param value
|
|
* true if paint messages received from the operating system
|
|
* should be ignored, false otherwise.
|
|
*/
|
|
public void setIgnoreRepaint(boolean value) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
ignoreRepaint = value;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the locale of the component.
|
|
*
|
|
* @param locale
|
|
* the new Locale.
|
|
*/
|
|
public void setLocale(Locale locale) {
|
|
Locale oldLocale;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldLocale = this.locale;
|
|
this.locale = locale;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("locale", oldLocale, locale); //$NON-NLS-1$
|
|
}
|
|
|
|
/**
|
|
* Sets the location of the Component to the specified point.
|
|
*
|
|
* @param p
|
|
* the new location of the Component.
|
|
*/
|
|
public void setLocation(Point p) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setLocation(p.x, p.y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the location of the Component to the specified x, y coordinates.
|
|
*
|
|
* @param x
|
|
* the x coordinate.
|
|
* @param y
|
|
* the y coordinate.
|
|
*/
|
|
public void setLocation(int x, int y) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
move(x, y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the visibility state of the component.
|
|
*
|
|
* @param b
|
|
* true if the component is visible, false if the component is
|
|
* not shown.
|
|
*/
|
|
public void setVisible(boolean b) {
|
|
// show() & hide() are not deprecated for Window,
|
|
// so have to call them from setVisible()
|
|
show(b);
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by setVisible(boolean) method.
|
|
*
|
|
* @deprecated Replaced by setVisible(boolean) method.
|
|
*/
|
|
@Deprecated
|
|
public void show() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (visible) {
|
|
return;
|
|
}
|
|
prepare4HierarchyChange();
|
|
mapToDisplay(true);
|
|
validate();
|
|
visible = true;
|
|
behaviour.setVisible(true);
|
|
postEvent(new ComponentEvent(this, ComponentEvent.COMPONENT_SHOWN));
|
|
// ???AWT: finishHierarchyChange(this, parent, 0);
|
|
notifyInputMethod(new Rectangle(x, y, w, h));
|
|
// ???AWT: invalidateRealParent();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by setVisible(boolean) method.
|
|
*
|
|
* @param b
|
|
* the visibility's state.
|
|
* @deprecated Replaced by setVisible(boolean) method.
|
|
*/
|
|
@Deprecated
|
|
public void show(boolean b) {
|
|
if (b) {
|
|
show();
|
|
} else {
|
|
hide();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* void transferFocus(int dir) { Container root = null; if (this instanceof
|
|
* Container) { Container cont = (Container) this; if
|
|
* (cont.isFocusCycleRoot()) { root = cont.getFocusTraversalRoot(); } } if
|
|
* (root == null) { root = getFocusCycleRootAncestor(); } // transfer focus
|
|
* up cycle if root is unreachable Component comp = this; while ((root !=
|
|
* null) && !(root.isFocusCycleRoot() && root.isShowing() &&
|
|
* root.isEnabled() && root .isFocusable())) { comp = root; root =
|
|
* root.getFocusCycleRootAncestor(); } if (root == null) { return; }
|
|
* FocusTraversalPolicy policy = root.getFocusTraversalPolicy(); Component
|
|
* nextComp = null; switch (dir) { case
|
|
* KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS: nextComp =
|
|
* policy.getComponentAfter(root, comp); break; case
|
|
* KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS: nextComp =
|
|
* policy.getComponentBefore(root, comp); break; } if (nextComp != null) {
|
|
* nextComp.requestFocus(false); } } public void transferFocus() {
|
|
* toolkit.lockAWT(); try { nextFocus(); } finally { toolkit.unlockAWT(); }
|
|
* } public void transferFocusBackward() { toolkit.lockAWT(); try {
|
|
* transferFocus(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS); } finally {
|
|
* toolkit.unlockAWT(); } } public void transferFocusUpCycle() {
|
|
* toolkit.lockAWT(); try { KeyboardFocusManager kfm =
|
|
* KeyboardFocusManager.getCurrentKeyboardFocusManager(); Container root =
|
|
* kfm.getCurrentFocusCycleRoot(); if(root == null) { return; } boolean
|
|
* success = false; Component nextComp = null; Container newRoot = root; do
|
|
* { nextComp = newRoot instanceof Window ?
|
|
* newRoot.getFocusTraversalPolicy() .getDefaultComponent(newRoot) :
|
|
* newRoot; newRoot = newRoot.getFocusCycleRootAncestor(); if (nextComp ==
|
|
* null) { break; } success = nextComp.requestFocusInWindow(); if (newRoot
|
|
* == null) { break; } kfm.setGlobalCurrentFocusCycleRoot(newRoot); } while
|
|
* (!success); if (!success && root != newRoot) {
|
|
* kfm.setGlobalCurrentFocusCycleRoot(root); } } finally {
|
|
* toolkit.unlockAWT(); } }
|
|
*/
|
|
|
|
/**
|
|
* Validates that this component has a valid layout.
|
|
*/
|
|
public void validate() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!behaviour.isDisplayable()) {
|
|
return;
|
|
}
|
|
validateImpl();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate impl.
|
|
*/
|
|
void validateImpl() {
|
|
valid = true;
|
|
}
|
|
|
|
/**
|
|
* Gets the native window.
|
|
*
|
|
* @return the native window.
|
|
*/
|
|
NativeWindow getNativeWindow() {
|
|
return behaviour.getNativeWindow();
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not a maximum size is set for the Component.
|
|
*
|
|
* @return true, if the maximum size is set for the Component, false
|
|
* otherwise.
|
|
*/
|
|
public boolean isMaximumSizeSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return maximumSize != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not the minimum size is set for the component.
|
|
*
|
|
* @return true, if the minimum size is set for the component, false
|
|
* otherwise.
|
|
*/
|
|
public boolean isMinimumSizeSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return minimumSize != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Checks whether or not the preferred size is set for the Component.
|
|
*
|
|
* @return true, if the preferred size is set for the Component, false
|
|
* otherwise.
|
|
*/
|
|
public boolean isPreferredSizeSet() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return preferredSize != null;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the maximum size of the Component.
|
|
*
|
|
* @return the maximum size of the Component.
|
|
*/
|
|
public Dimension getMaximumSize() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return isMaximumSizeSet() ? new Dimension(maximumSize) : new Dimension(Short.MAX_VALUE,
|
|
Short.MAX_VALUE);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the minimum size of the Component.
|
|
*
|
|
* @return the minimum size of the Component.
|
|
*/
|
|
public Dimension getMinimumSize() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return minimumSize();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by getMinimumSize() method.
|
|
*
|
|
* @return the Dimension.
|
|
* @deprecated Replaced by getMinimumSize() method.
|
|
*/
|
|
@Deprecated
|
|
public Dimension minimumSize() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (isMinimumSizeSet()) {
|
|
return (Dimension)minimumSize.clone();
|
|
}
|
|
Dimension defSize = getDefaultMinimumSize();
|
|
if (defSize != null) {
|
|
return (Dimension)defSize.clone();
|
|
}
|
|
return isDisplayable() ? new Dimension(1, 1) : new Dimension(w, h);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the preferred size of the Component.
|
|
*
|
|
* @return the preferred size of the Component.
|
|
*/
|
|
public Dimension getPreferredSize() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
return preferredSize();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Deprecated: replaced by getPreferredSize() method.
|
|
*
|
|
* @return the Dimension.
|
|
* @deprecated Replaced by getPreferredSize() method.
|
|
*/
|
|
@Deprecated
|
|
public Dimension preferredSize() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (isPreferredSizeSet()) {
|
|
return new Dimension(preferredSize);
|
|
}
|
|
Dimension defSize = getDefaultPreferredSize();
|
|
if (defSize != null) {
|
|
return new Dimension(defSize);
|
|
}
|
|
return new Dimension(getMinimumSize());
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the maximum size of the Component.
|
|
*
|
|
* @param maximumSize
|
|
* the new maximum size of the Component.
|
|
*/
|
|
public void setMaximumSize(Dimension maximumSize) {
|
|
Dimension oldMaximumSize;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldMaximumSize = this.maximumSize;
|
|
if (oldMaximumSize != null) {
|
|
oldMaximumSize = oldMaximumSize.getSize();
|
|
}
|
|
if (this.maximumSize == null) {
|
|
if (maximumSize != null) {
|
|
this.maximumSize = new Dimension(maximumSize);
|
|
}
|
|
} else {
|
|
if (maximumSize != null) {
|
|
this.maximumSize.setSize(maximumSize);
|
|
} else {
|
|
this.maximumSize = null;
|
|
}
|
|
}
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("maximumSize", oldMaximumSize, this.maximumSize); //$NON-NLS-1$
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT: invalidateRealParent();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the minimum size of the Component.
|
|
*
|
|
* @param minimumSize
|
|
* the new minimum size of the Component.
|
|
*/
|
|
public void setMinimumSize(Dimension minimumSize) {
|
|
Dimension oldMinimumSize;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldMinimumSize = this.minimumSize;
|
|
if (oldMinimumSize != null) {
|
|
oldMinimumSize = oldMinimumSize.getSize();
|
|
}
|
|
if (this.minimumSize == null) {
|
|
if (minimumSize != null) {
|
|
this.minimumSize = new Dimension(minimumSize);
|
|
}
|
|
} else {
|
|
if (minimumSize != null) {
|
|
this.minimumSize.setSize(minimumSize);
|
|
} else {
|
|
this.minimumSize = null;
|
|
}
|
|
}
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("minimumSize", oldMinimumSize, this.minimumSize); //$NON-NLS-1$
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT: invalidateRealParent();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the preferred size of the Component.
|
|
*
|
|
* @param preferredSize
|
|
* the new preferred size of the Component.
|
|
*/
|
|
public void setPreferredSize(Dimension preferredSize) {
|
|
Dimension oldPreferredSize;
|
|
toolkit.lockAWT();
|
|
try {
|
|
oldPreferredSize = this.preferredSize;
|
|
if (oldPreferredSize != null) {
|
|
oldPreferredSize = oldPreferredSize.getSize();
|
|
}
|
|
if (this.preferredSize == null) {
|
|
if (preferredSize != null) {
|
|
this.preferredSize = new Dimension(preferredSize);
|
|
}
|
|
} else {
|
|
if (preferredSize != null) {
|
|
this.preferredSize.setSize(preferredSize);
|
|
} else {
|
|
this.preferredSize = null;
|
|
}
|
|
}
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
firePropertyChange("preferredSize", oldPreferredSize, this.preferredSize); //$NON-NLS-1$
|
|
toolkit.lockAWT();
|
|
try {
|
|
// ???AWT: invalidateRealParent();
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* RedrawManager getRedrawManager() { if (parent == null) { return null; }
|
|
* return parent.getRedrawManager(); }
|
|
*/
|
|
|
|
/**
|
|
* Checks if is focusability explicitly set.
|
|
*
|
|
* @return true if component has a focusable peer.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* boolean isPeerFocusable() { // The recommendations for Windows and Unix
|
|
* are that // Canvases, Labels, Panels, Scrollbars, ScrollPanes, Windows,
|
|
* // and lightweight Components have non-focusable peers, // and all other
|
|
* Components have focusable peers. if (this instanceof Canvas || this
|
|
* instanceof Label || this instanceof Panel || this instanceof Scrollbar ||
|
|
* this instanceof ScrollPane || this instanceof Window || isLightweight())
|
|
* { return false; } return true; }
|
|
*/
|
|
|
|
/**
|
|
* @return true if focusability was explicitly set via a call to
|
|
* setFocusable() or via overriding isFocusable() or
|
|
* isFocusTraversable().
|
|
*/
|
|
boolean isFocusabilityExplicitlySet() {
|
|
return calledSetFocusable || overridenIsFocusable;
|
|
}
|
|
|
|
/**
|
|
* Paints the component and all of its subcomponents.
|
|
*
|
|
* @param g
|
|
* the Graphics to be used for painting.
|
|
*/
|
|
public void paintAll(Graphics g) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
paint(g);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Updates this Component.
|
|
*
|
|
* @param g
|
|
* the Graphics to be used for updating.
|
|
*/
|
|
public void update(Graphics g) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!isLightweight() && !isPrepainter()) {
|
|
g.setColor(getBackground());
|
|
g.fillRect(0, 0, w, h);
|
|
g.setColor(getForeground());
|
|
}
|
|
paint(g);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Paints this component.
|
|
*
|
|
* @param g
|
|
* the Graphics to be used for painting.
|
|
*/
|
|
public void paint(Graphics g) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// Just to nothing
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepares the component to be painted.
|
|
*
|
|
* @param g
|
|
* the Graphics to be used for painting.
|
|
*/
|
|
void prepaint(Graphics g) {
|
|
// Just to nothing. For overriding.
|
|
}
|
|
|
|
/**
|
|
* Checks if is prepainter.
|
|
*
|
|
* @return true, if is prepainter.
|
|
*/
|
|
boolean isPrepainter() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Prepare4 hierarchy change.
|
|
*/
|
|
void prepare4HierarchyChange() {
|
|
if (hierarchyChangingCounter++ == 0) {
|
|
wasShowing = isShowing();
|
|
wasDisplayable = isDisplayable();
|
|
prepareChildren4HierarchyChange();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prepare children4 hierarchy change.
|
|
*/
|
|
void prepareChildren4HierarchyChange() {
|
|
// To be inherited by Container
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* void finishHierarchyChange(Component changed, Container changedParent,
|
|
* int ancestorFlags) { if (--hierarchyChangingCounter == 0) { int
|
|
* changeFlags = ancestorFlags; if (wasShowing != isShowing()) { changeFlags
|
|
* |= HierarchyEvent.SHOWING_CHANGED; } if (wasDisplayable !=
|
|
* isDisplayable()) { changeFlags |= HierarchyEvent.DISPLAYABILITY_CHANGED;
|
|
* } if (changeFlags > 0) { postEvent(new HierarchyEvent(this,
|
|
* HierarchyEvent.HIERARCHY_CHANGED, changed, changedParent, changeFlags));
|
|
* } finishChildrenHierarchyChange(changed, changedParent, ancestorFlags); }
|
|
* } void finishChildrenHierarchyChange(Component changed, Container
|
|
* changedParent, int ancestorFlags) { // To be inherited by Container }
|
|
* void postHierarchyBoundsEvents(Component changed, int id) { postEvent(new
|
|
* HierarchyEvent(this, id, changed, null, 0)); }
|
|
*/
|
|
|
|
/**
|
|
* Spread hierarchy bounds events.
|
|
*
|
|
* @param changed
|
|
* the changed.
|
|
* @param id
|
|
* the id.
|
|
*/
|
|
void spreadHierarchyBoundsEvents(Component changed, int id) {
|
|
// To be inherited by Container
|
|
}
|
|
|
|
/**
|
|
* Dispatches an event to this component.
|
|
*
|
|
* @param e
|
|
* the Event.
|
|
*/
|
|
public final void dispatchEvent(AWTEvent e) {
|
|
// ???AWT
|
|
/*
|
|
* if (e.isConsumed()) { return; } if (e instanceof PaintEvent) {
|
|
* toolkit.dispatchAWTEvent(e); processPaintEvent((PaintEvent) e);
|
|
* return; } KeyboardFocusManager kfm =
|
|
* KeyboardFocusManager.getCurrentKeyboardFocusManager(); if
|
|
* (!e.dispatchedByKFM && kfm.dispatchEvent(e)) { return; } if (e
|
|
* instanceof KeyEvent) { KeyEvent ke = (KeyEvent) e; // consumes
|
|
* KeyEvent which represents a focus traversal key if
|
|
* (getFocusTraversalKeysEnabled()) { kfm.processKeyEvent(this, ke); if
|
|
* (ke.isConsumed()) { return; } } } if (inputMethodsEnabled &&
|
|
* dispatchToIM && e.isPosted && dispatchEventToIM(e)) { return; } if
|
|
* (e.getID() == WindowEvent.WINDOW_ICONIFIED) {
|
|
* notifyInputMethod(null); } AWTEvent.EventDescriptor descriptor =
|
|
* toolkit.eventTypeLookup.getEventDescriptor(e);
|
|
* toolkit.dispatchAWTEvent(e); if (descriptor != null) { if
|
|
* (isEventEnabled(descriptor.eventMask) ||
|
|
* (getListeners(descriptor.listenerType).length > 0)) {
|
|
* processEvent(e); } // input events can be consumed by user listeners:
|
|
* if (!e.isConsumed() && ((enabledAWTEvents & descriptor.eventMask) !=
|
|
* 0)) { postprocessEvent(e, descriptor.eventMask); } }
|
|
* postDeprecatedEvent(e);
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Post deprecated event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
private void postDeprecatedEvent(AWTEvent e) {
|
|
if (deprecatedEventHandler) {
|
|
Event evt = e.getEvent();
|
|
if (evt != null) {
|
|
postEvent(evt);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Postprocess event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param eventMask
|
|
* the event mask.
|
|
*/
|
|
void postprocessEvent(AWTEvent e, long eventMask) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
// call system listeners under AWT lock
|
|
if (eventMask == AWTEvent.FOCUS_EVENT_MASK) {
|
|
preprocessFocusEvent((FocusEvent)e);
|
|
} else if (eventMask == AWTEvent.KEY_EVENT_MASK) {
|
|
preprocessKeyEvent((KeyEvent)e);
|
|
} else if (eventMask == AWTEvent.MOUSE_EVENT_MASK) {
|
|
preprocessMouseEvent((MouseEvent)e);
|
|
} else if (eventMask == AWTEvent.MOUSE_MOTION_EVENT_MASK) {
|
|
preprocessMouseMotionEvent((MouseEvent)e);
|
|
} else if (eventMask == AWTEvent.COMPONENT_EVENT_MASK) {
|
|
preprocessComponentEvent((ComponentEvent)e);
|
|
} else if (eventMask == AWTEvent.MOUSE_WHEEL_EVENT_MASK) {
|
|
preprocessMouseWheelEvent((MouseWheelEvent)e);
|
|
} else if (eventMask == AWTEvent.INPUT_METHOD_EVENT_MASK) {
|
|
preprocessInputMethodEvent((InputMethodEvent)e);
|
|
}
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Preprocess input method event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
private void preprocessInputMethodEvent(InputMethodEvent e) {
|
|
processInputMethodEventImpl(e, inputMethodListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Preprocess mouse wheel event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
private void preprocessMouseWheelEvent(MouseWheelEvent e) {
|
|
processMouseWheelEventImpl(e, mouseWheelListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Process mouse wheel event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processMouseWheelEventImpl(MouseWheelEvent e, Collection<MouseWheelListener> c) {
|
|
for (MouseWheelListener listener : c) {
|
|
switch (e.getID()) {
|
|
case MouseEvent.MOUSE_WHEEL:
|
|
listener.mouseWheelMoved(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Preprocess component event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
private void preprocessComponentEvent(ComponentEvent e) {
|
|
processComponentEventImpl(e, componentListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Preprocess mouse motion event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
void preprocessMouseMotionEvent(MouseEvent e) {
|
|
processMouseMotionEventImpl(e, mouseMotionListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Preprocess mouse event.
|
|
*
|
|
* @param e
|
|
* the e
|
|
*/
|
|
void preprocessMouseEvent(MouseEvent e) {
|
|
processMouseEventImpl(e, mouseListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Preprocess key event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
void preprocessKeyEvent(KeyEvent e) {
|
|
processKeyEventImpl(e, keyListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Preprocess focus event.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
void preprocessFocusEvent(FocusEvent e) {
|
|
processFocusEventImpl(e, focusListeners.getSystemListeners());
|
|
}
|
|
|
|
/**
|
|
* Processes AWTEvent occurred on this component.
|
|
*
|
|
* @param e
|
|
* the AWTEvent.
|
|
*/
|
|
protected void processEvent(AWTEvent e) {
|
|
long eventMask = toolkit.eventTypeLookup.getEventMask(e);
|
|
if (eventMask == AWTEvent.COMPONENT_EVENT_MASK) {
|
|
processComponentEvent((ComponentEvent)e);
|
|
} else if (eventMask == AWTEvent.FOCUS_EVENT_MASK) {
|
|
processFocusEvent((FocusEvent)e);
|
|
} else if (eventMask == AWTEvent.KEY_EVENT_MASK) {
|
|
processKeyEvent((KeyEvent)e);
|
|
} else if (eventMask == AWTEvent.MOUSE_EVENT_MASK) {
|
|
processMouseEvent((MouseEvent)e);
|
|
} else if (eventMask == AWTEvent.MOUSE_WHEEL_EVENT_MASK) {
|
|
processMouseWheelEvent((MouseWheelEvent)e);
|
|
} else if (eventMask == AWTEvent.MOUSE_MOTION_EVENT_MASK) {
|
|
processMouseMotionEvent((MouseEvent)e);
|
|
} else if (eventMask == AWTEvent.HIERARCHY_EVENT_MASK) {
|
|
processHierarchyEvent((HierarchyEvent)e);
|
|
} else if (eventMask == AWTEvent.HIERARCHY_BOUNDS_EVENT_MASK) {
|
|
processHierarchyBoundsEvent((HierarchyEvent)e);
|
|
} else if (eventMask == AWTEvent.INPUT_METHOD_EVENT_MASK) {
|
|
processInputMethodEvent((InputMethodEvent)e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of all listener's objects based on the specified listener
|
|
* type and registered to this Component.
|
|
*
|
|
* @param listenerType
|
|
* the listener type.
|
|
* @return an array of all listener's objects based on the specified
|
|
* listener type and registered to this Component.
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public <T extends EventListener> T[] getListeners(Class<T> listenerType) {
|
|
if (ComponentListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getComponentListeners();
|
|
} else if (FocusListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getFocusListeners();
|
|
} else if (HierarchyBoundsListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getHierarchyBoundsListeners();
|
|
} else if (HierarchyListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getHierarchyListeners();
|
|
} else if (InputMethodListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getInputMethodListeners();
|
|
} else if (KeyListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getKeyListeners();
|
|
} else if (MouseWheelListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getMouseWheelListeners();
|
|
} else if (MouseMotionListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getMouseMotionListeners();
|
|
} else if (MouseListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getMouseListeners();
|
|
} else if (PropertyChangeListener.class.isAssignableFrom(listenerType)) {
|
|
return (T[])getPropertyChangeListeners();
|
|
}
|
|
return (T[])Array.newInstance(listenerType, 0);
|
|
}
|
|
|
|
/**
|
|
* Process paint event.
|
|
*
|
|
* @param event
|
|
* the event.
|
|
*/
|
|
private void processPaintEvent(PaintEvent event) {
|
|
if (redrawManager == null) {
|
|
return;
|
|
}
|
|
Rectangle clipRect = event.getUpdateRect();
|
|
if ((clipRect.width <= 0) || (clipRect.height <= 0)) {
|
|
return;
|
|
}
|
|
Graphics g = getGraphics();
|
|
if (g == null) {
|
|
return;
|
|
}
|
|
initGraphics(g, event);
|
|
if (!getIgnoreRepaint()) {
|
|
if (event.getID() == PaintEvent.PAINT) {
|
|
paint(g);
|
|
} else {
|
|
update(g);
|
|
}
|
|
}
|
|
g.dispose();
|
|
}
|
|
|
|
/**
|
|
* Inits the graphics.
|
|
*
|
|
* @param g
|
|
* the g.
|
|
* @param e
|
|
* the e.
|
|
*/
|
|
void initGraphics(Graphics g, PaintEvent e) {
|
|
Rectangle clip = e.getUpdateRect();
|
|
if (clip instanceof ClipRegion) {
|
|
g.setClip(((ClipRegion)clip).getClip());
|
|
} else {
|
|
g.setClip(clip);
|
|
}
|
|
if (isPrepainter()) {
|
|
prepaint(g);
|
|
} else if (!isLightweight() && (e.getID() == PaintEvent.PAINT)) {
|
|
g.setColor(getBackground());
|
|
g.fillRect(0, 0, w, h);
|
|
}
|
|
g.setFont(getFont());
|
|
g.setColor(getForeground());
|
|
}
|
|
|
|
/**
|
|
* Enables the events with the specified event mask to be delivered to this
|
|
* component.
|
|
*
|
|
* @param eventsToEnable
|
|
* the events mask which specifies the types of events to enable.
|
|
*/
|
|
protected final void enableEvents(long eventsToEnable) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
enabledEvents |= eventsToEnable;
|
|
deprecatedEventHandler = false;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Enable awt events.
|
|
*
|
|
* @param eventsToEnable
|
|
* the events to enable.
|
|
*/
|
|
private void enableAWTEvents(long eventsToEnable) {
|
|
enabledAWTEvents |= eventsToEnable;
|
|
}
|
|
|
|
/**
|
|
* Disables the events with types specified by the specified event mask from
|
|
* being delivered to this component.
|
|
*
|
|
* @param eventsToDisable
|
|
* the event mask specifying the event types.
|
|
*/
|
|
protected final void disableEvents(long eventsToDisable) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
enabledEvents &= ~eventsToDisable;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/*
|
|
* For use in MouseDispatcher only. Really it checks not only mouse events.
|
|
*/
|
|
/**
|
|
* Checks if is mouse event enabled.
|
|
*
|
|
* @param eventMask
|
|
* the event mask.
|
|
* @return true, if is mouse event enabled.
|
|
*/
|
|
boolean isMouseEventEnabled(long eventMask) {
|
|
return (isEventEnabled(eventMask) || (enabledAWTEvents & eventMask) != 0);
|
|
}
|
|
|
|
/**
|
|
* Checks if is event enabled.
|
|
*
|
|
* @param eventMask
|
|
* the event mask.
|
|
* @return true, if is event enabled.
|
|
*/
|
|
boolean isEventEnabled(long eventMask) {
|
|
return ((enabledEvents & eventMask) != 0);
|
|
}
|
|
|
|
/**
|
|
* Enables or disables input method support for this component.
|
|
*
|
|
* @param enable
|
|
* true to enable input method support, false to disable it.
|
|
*/
|
|
public void enableInputMethods(boolean enable) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
if (!enable) {
|
|
removeNotifyInputContext();
|
|
}
|
|
inputMethodsEnabled = enable;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of all component's listeners registered for this component.
|
|
*
|
|
* @return an array of all component's listeners registered for this
|
|
* component.
|
|
*/
|
|
public ComponentListener[] getComponentListeners() {
|
|
return componentListeners.getUserListeners(new ComponentListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified component listener to the Component for receiving
|
|
* component's event.
|
|
*
|
|
* @param l
|
|
* the ComponentListener.
|
|
*/
|
|
public void addComponentListener(ComponentListener l) {
|
|
componentListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the component listener registered for this Component.
|
|
*
|
|
* @param l
|
|
* the ComponentListener.
|
|
*/
|
|
public void removeComponentListener(ComponentListener l) {
|
|
componentListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a component event that has occurred on this component by
|
|
* dispatching them to any registered ComponentListener objects.
|
|
*
|
|
* @param e
|
|
* the ComponentEvent.
|
|
*/
|
|
protected void processComponentEvent(ComponentEvent e) {
|
|
processComponentEventImpl(e, componentListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Process component event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processComponentEventImpl(ComponentEvent e, Collection<ComponentListener> c) {
|
|
for (ComponentListener listener : c) {
|
|
switch (e.getID()) {
|
|
case ComponentEvent.COMPONENT_HIDDEN:
|
|
listener.componentHidden(e);
|
|
break;
|
|
case ComponentEvent.COMPONENT_MOVED:
|
|
listener.componentMoved(e);
|
|
break;
|
|
case ComponentEvent.COMPONENT_RESIZED:
|
|
listener.componentResized(e);
|
|
break;
|
|
case ComponentEvent.COMPONENT_SHOWN:
|
|
listener.componentShown(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of focus listeners registered for this Component.
|
|
*
|
|
* @return the array of focus listeners registered for this Component.
|
|
*/
|
|
public FocusListener[] getFocusListeners() {
|
|
return focusListeners.getUserListeners(new FocusListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified focus listener to the Component for receiving focus
|
|
* events.
|
|
*
|
|
* @param l
|
|
* the FocusListener.
|
|
*/
|
|
public void addFocusListener(FocusListener l) {
|
|
focusListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt focus listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTFocusListener(FocusListener l) {
|
|
enableAWTEvents(AWTEvent.FOCUS_EVENT_MASK);
|
|
focusListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the focus listener registered for this Component.
|
|
*
|
|
* @param l
|
|
* the FocusListener.
|
|
*/
|
|
public void removeFocusListener(FocusListener l) {
|
|
focusListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a FocusEvent that has occurred on this component by dispatching
|
|
* it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the FocusEvent.
|
|
*/
|
|
protected void processFocusEvent(FocusEvent e) {
|
|
processFocusEventImpl(e, focusListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Process focus event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processFocusEventImpl(FocusEvent e, Collection<FocusListener> c) {
|
|
for (FocusListener listener : c) {
|
|
switch (e.getID()) {
|
|
case FocusEvent.FOCUS_GAINED:
|
|
listener.focusGained(e);
|
|
break;
|
|
case FocusEvent.FOCUS_LOST:
|
|
listener.focusLost(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of registered HierarchyListeners for this Component.
|
|
*
|
|
* @return an array of registered HierarchyListeners for this Component.
|
|
*/
|
|
public HierarchyListener[] getHierarchyListeners() {
|
|
return hierarchyListeners.getUserListeners(new HierarchyListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified hierarchy listener.
|
|
*
|
|
* @param l
|
|
* the HierarchyListener.
|
|
*/
|
|
public void addHierarchyListener(HierarchyListener l) {
|
|
hierarchyListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the hierarchy listener registered for this component.
|
|
*
|
|
* @param l
|
|
* the HierarchyListener.
|
|
*/
|
|
public void removeHierarchyListener(HierarchyListener l) {
|
|
hierarchyListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a hierarchy event that has occurred on this component by
|
|
* dispatching it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the HierarchyEvent.
|
|
*/
|
|
protected void processHierarchyEvent(HierarchyEvent e) {
|
|
for (HierarchyListener listener : hierarchyListeners.getUserListeners()) {
|
|
switch (e.getID()) {
|
|
case HierarchyEvent.HIERARCHY_CHANGED:
|
|
listener.hierarchyChanged(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of HierarchyBoundsListener objects registered to this
|
|
* Component.
|
|
*
|
|
* @return an array of HierarchyBoundsListener objects.
|
|
*/
|
|
public HierarchyBoundsListener[] getHierarchyBoundsListeners() {
|
|
return hierarchyBoundsListeners.getUserListeners(new HierarchyBoundsListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified hierarchy bounds listener.
|
|
*
|
|
* @param l
|
|
* the HierarchyBoundsListener.
|
|
*/
|
|
public void addHierarchyBoundsListener(HierarchyBoundsListener l) {
|
|
hierarchyBoundsListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the hierarchy bounds listener registered for this Component.
|
|
*
|
|
* @param l
|
|
* the HierarchyBoundsListener.
|
|
*/
|
|
public void removeHierarchyBoundsListener(HierarchyBoundsListener l) {
|
|
hierarchyBoundsListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a hierarchy bounds event that has occurred on this component by
|
|
* dispatching it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the HierarchyBoundsEvent.
|
|
*/
|
|
protected void processHierarchyBoundsEvent(HierarchyEvent e) {
|
|
for (HierarchyBoundsListener listener : hierarchyBoundsListeners.getUserListeners()) {
|
|
switch (e.getID()) {
|
|
case HierarchyEvent.ANCESTOR_MOVED:
|
|
listener.ancestorMoved(e);
|
|
break;
|
|
case HierarchyEvent.ANCESTOR_RESIZED:
|
|
listener.ancestorResized(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the key listeners registered to the Component.
|
|
*
|
|
* @return an array of the key listeners registered to the Component.
|
|
*/
|
|
public KeyListener[] getKeyListeners() {
|
|
return keyListeners.getUserListeners(new KeyListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified key listener.
|
|
*
|
|
* @param l
|
|
* the KeyListener.
|
|
*/
|
|
public void addKeyListener(KeyListener l) {
|
|
keyListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt key listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTKeyListener(KeyListener l) {
|
|
enableAWTEvents(AWTEvent.KEY_EVENT_MASK);
|
|
keyListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the key listener registered for this Component.
|
|
*
|
|
* @param l
|
|
* the KeyListener.
|
|
*/
|
|
public void removeKeyListener(KeyListener l) {
|
|
keyListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a key event that has occurred on this component by dispatching
|
|
* it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the KeyEvent.
|
|
*/
|
|
protected void processKeyEvent(KeyEvent e) {
|
|
processKeyEventImpl(e, keyListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Process key event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processKeyEventImpl(KeyEvent e, Collection<KeyListener> c) {
|
|
for (KeyListener listener : c) {
|
|
switch (e.getID()) {
|
|
case KeyEvent.KEY_PRESSED:
|
|
listener.keyPressed(e);
|
|
break;
|
|
case KeyEvent.KEY_RELEASED:
|
|
listener.keyReleased(e);
|
|
break;
|
|
case KeyEvent.KEY_TYPED:
|
|
listener.keyTyped(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the mouse listeners registered to the Component.
|
|
*
|
|
* @return an array of the mouse listeners registered to the Component.
|
|
*/
|
|
public MouseListener[] getMouseListeners() {
|
|
return mouseListeners.getUserListeners(new MouseListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified mouse listener.
|
|
*
|
|
* @param l
|
|
* the MouseListener.
|
|
*/
|
|
public void addMouseListener(MouseListener l) {
|
|
mouseListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt mouse listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTMouseListener(MouseListener l) {
|
|
enableAWTEvents(AWTEvent.MOUSE_EVENT_MASK);
|
|
mouseListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt mouse motion listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTMouseMotionListener(MouseMotionListener l) {
|
|
enableAWTEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK);
|
|
mouseMotionListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt component listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTComponentListener(ComponentListener l) {
|
|
enableAWTEvents(AWTEvent.COMPONENT_EVENT_MASK);
|
|
componentListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt input method listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTInputMethodListener(InputMethodListener l) {
|
|
enableAWTEvents(AWTEvent.INPUT_METHOD_EVENT_MASK);
|
|
inputMethodListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Adds the awt mouse wheel listener.
|
|
*
|
|
* @param l
|
|
* the l.
|
|
*/
|
|
void addAWTMouseWheelListener(MouseWheelListener l) {
|
|
enableAWTEvents(AWTEvent.MOUSE_WHEEL_EVENT_MASK);
|
|
mouseWheelListeners.addSystemListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the mouse listener registered for this Component.
|
|
*
|
|
* @param l
|
|
* the MouseListener.
|
|
*/
|
|
public void removeMouseListener(MouseListener l) {
|
|
mouseListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a mouse event that has occurred on this component by
|
|
* dispatching it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the MouseEvent.
|
|
*/
|
|
protected void processMouseEvent(MouseEvent e) {
|
|
processMouseEventImpl(e, mouseListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Process mouse event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processMouseEventImpl(MouseEvent e, Collection<MouseListener> c) {
|
|
for (MouseListener listener : c) {
|
|
switch (e.getID()) {
|
|
case MouseEvent.MOUSE_CLICKED:
|
|
listener.mouseClicked(e);
|
|
break;
|
|
case MouseEvent.MOUSE_ENTERED:
|
|
listener.mouseEntered(e);
|
|
break;
|
|
case MouseEvent.MOUSE_EXITED:
|
|
listener.mouseExited(e);
|
|
break;
|
|
case MouseEvent.MOUSE_PRESSED:
|
|
listener.mousePressed(e);
|
|
break;
|
|
case MouseEvent.MOUSE_RELEASED:
|
|
listener.mouseReleased(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process mouse motion event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processMouseMotionEventImpl(MouseEvent e, Collection<MouseMotionListener> c) {
|
|
for (MouseMotionListener listener : c) {
|
|
switch (e.getID()) {
|
|
case MouseEvent.MOUSE_DRAGGED:
|
|
listener.mouseDragged(e);
|
|
break;
|
|
case MouseEvent.MOUSE_MOVED:
|
|
listener.mouseMoved(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the mouse motion listeners registered to the Component.
|
|
*
|
|
* @return an array of the MouseMotionListeners registered to the Component.
|
|
*/
|
|
public MouseMotionListener[] getMouseMotionListeners() {
|
|
return mouseMotionListeners.getUserListeners(new MouseMotionListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified mouse motion listener.
|
|
*
|
|
* @param l
|
|
* the MouseMotionListener.
|
|
*/
|
|
public void addMouseMotionListener(MouseMotionListener l) {
|
|
mouseMotionListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the mouse motion listener registered for this component.
|
|
*
|
|
* @param l
|
|
* the MouseMotionListener.
|
|
*/
|
|
public void removeMouseMotionListener(MouseMotionListener l) {
|
|
mouseMotionListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a mouse motion event that has occurred on this component by
|
|
* dispatching it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the MouseEvent.
|
|
*/
|
|
protected void processMouseMotionEvent(MouseEvent e) {
|
|
processMouseMotionEventImpl(e, mouseMotionListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the mouse wheel listeners registered to the Component.
|
|
*
|
|
* @return an array of the MouseWheelListeners registered to the Component.
|
|
*/
|
|
public MouseWheelListener[] getMouseWheelListeners() {
|
|
return mouseWheelListeners.getUserListeners(new MouseWheelListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified mouse wheel listener.
|
|
*
|
|
* @param l
|
|
* the MouseWheelListener.
|
|
*/
|
|
public void addMouseWheelListener(MouseWheelListener l) {
|
|
mouseWheelListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the mouse wheel listener registered for this component.
|
|
*
|
|
* @param l
|
|
* the MouseWheelListener.
|
|
*/
|
|
public void removeMouseWheelListener(MouseWheelListener l) {
|
|
mouseWheelListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes a mouse wheel event that has occurred on this component by
|
|
* dispatching it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the MouseWheelEvent.
|
|
*/
|
|
protected void processMouseWheelEvent(MouseWheelEvent e) {
|
|
processMouseWheelEventImpl(e, mouseWheelListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Gets an array of the InputMethodListener listeners registered to the
|
|
* Component.
|
|
*
|
|
* @return an array of the InputMethodListener listeners registered to the
|
|
* Component.
|
|
*/
|
|
public InputMethodListener[] getInputMethodListeners() {
|
|
return inputMethodListeners.getUserListeners(new InputMethodListener[0]);
|
|
}
|
|
|
|
/**
|
|
* Adds the specified input method listener.
|
|
*
|
|
* @param l
|
|
* the InputMethodListener.
|
|
*/
|
|
public void addInputMethodListener(InputMethodListener l) {
|
|
inputMethodListeners.addUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Removes the input method listener registered for this component.
|
|
*
|
|
* @param l
|
|
* the InputMethodListener.
|
|
*/
|
|
public void removeInputMethodListener(InputMethodListener l) {
|
|
inputMethodListeners.removeUserListener(l);
|
|
}
|
|
|
|
/**
|
|
* Processes an input method event that has occurred on this component by
|
|
* dispatching it to the registered listeners.
|
|
*
|
|
* @param e
|
|
* the InputMethodEvent.
|
|
*/
|
|
protected void processInputMethodEvent(InputMethodEvent e) {
|
|
processInputMethodEventImpl(e, inputMethodListeners.getUserListeners());
|
|
}
|
|
|
|
/**
|
|
* Process input method event impl.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @param c
|
|
* the c.
|
|
*/
|
|
private void processInputMethodEventImpl(InputMethodEvent e, Collection<InputMethodListener> c) {
|
|
for (InputMethodListener listener : c) {
|
|
switch (e.getID()) {
|
|
case InputMethodEvent.CARET_POSITION_CHANGED:
|
|
listener.caretPositionChanged(e);
|
|
break;
|
|
case InputMethodEvent.INPUT_METHOD_TEXT_CHANGED:
|
|
listener.inputMethodTextChanged(e);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* public Point getMousePosition() throws HeadlessException { Point
|
|
* absPointerPos = MouseInfo.getPointerInfo().getLocation(); Window
|
|
* winUnderPtr =
|
|
* toolkit.dispatcher.mouseDispatcher.findWindowAt(absPointerPos); Point
|
|
* pointerPos = MouseDispatcher.convertPoint(null, absPointerPos,
|
|
* winUnderPtr); boolean isUnderPointer = false; if (winUnderPtr == null) {
|
|
* return null; } isUnderPointer = winUnderPtr.isComponentAt(this,
|
|
* pointerPos); if (isUnderPointer) { return
|
|
* MouseDispatcher.convertPoint(null, absPointerPos, this); } return null; }
|
|
*/
|
|
|
|
/**
|
|
* Set native caret at the given position <br>
|
|
* Note: this method takes AWT lock inside because it walks through the
|
|
* component hierarchy.
|
|
*
|
|
* @param x
|
|
* the x.
|
|
* @param y
|
|
* the y.
|
|
*/
|
|
void setCaretPos(final int x, final int y) {
|
|
Runnable r = new Runnable() {
|
|
public void run() {
|
|
toolkit.lockAWT();
|
|
try {
|
|
setCaretPosImpl(x, y);
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
};
|
|
if (Thread.currentThread() instanceof EventDispatchThread) {
|
|
r.run();
|
|
} else {
|
|
toolkit.getSystemEventQueueImpl().postEvent(new InvocationEvent(this, r));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method should be called only at event dispatch thread.
|
|
*
|
|
* @param x
|
|
* the x.
|
|
* @param y
|
|
* the y.
|
|
*/
|
|
void setCaretPosImpl(int x, int y) {
|
|
Component c = this;
|
|
while ((c != null) && c.behaviour.isLightweight()) {
|
|
x += c.x;
|
|
y += c.y;
|
|
// ???AWT: c = c.getParent();
|
|
}
|
|
if (c == null) {
|
|
return;
|
|
}
|
|
// ???AWT
|
|
/*
|
|
* if (c instanceof Window) { Insets insets = c.getNativeInsets(); x -=
|
|
* insets.left; y -= insets.top; }
|
|
* toolkit.getWindowFactory().setCaretPosition(x, y);
|
|
*/
|
|
}
|
|
|
|
// to be overridden in standard components such as Button and List
|
|
/**
|
|
* Gets the default minimum size.
|
|
*
|
|
* @return the default minimum size.
|
|
*/
|
|
Dimension getDefaultMinimumSize() {
|
|
return null;
|
|
}
|
|
|
|
// to be overridden in standard components such as Button and List
|
|
/**
|
|
* Gets the default preferred size.
|
|
*
|
|
* @return the default preferred size.
|
|
*/
|
|
Dimension getDefaultPreferredSize() {
|
|
return null;
|
|
}
|
|
|
|
// to be overridden in standard components such as Button and List
|
|
/**
|
|
* Reset default size.
|
|
*/
|
|
void resetDefaultSize() {
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* ComponentBehavior createBehavior() { return new LWBehavior(this); }
|
|
*/
|
|
|
|
/**
|
|
* Gets the default background.
|
|
*
|
|
* @return the default background.
|
|
*/
|
|
Color getDefaultBackground() {
|
|
// ???AWT: return getWindowAncestor().getDefaultBackground();
|
|
return getBackground();
|
|
}
|
|
|
|
/**
|
|
* Gets the default foreground.
|
|
*
|
|
* @return the default foreground.
|
|
*/
|
|
Color getDefaultForeground() {
|
|
// ???AWT return getWindowAncestor().getDefaultForeground();
|
|
return getForeground();
|
|
}
|
|
|
|
/**
|
|
* Called when native resource for this component is created (for
|
|
* heavyweights only).
|
|
*
|
|
* @param win
|
|
* the win.
|
|
*/
|
|
void nativeWindowCreated(NativeWindow win) {
|
|
// to be overridden
|
|
}
|
|
|
|
/**
|
|
* Determine the component's area hidden behind the windows that have higher
|
|
* Z-order, including windows of other applications.
|
|
*
|
|
* @param image
|
|
* the image.
|
|
* @param destLocation
|
|
* the dest location.
|
|
* @param destSize
|
|
* the dest size.
|
|
* @param source
|
|
* the source.
|
|
* @return the calculated region, or null if it cannot be determined.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* MultiRectArea getObscuredRegion(Rectangle part) { if (!visible || parent
|
|
* == null || !parent.visible) { return null; } Rectangle r = new
|
|
* Rectangle(0, 0, w, h); if (part != null) { r = r.intersection(part); } if
|
|
* (r.isEmpty()) { return null; } r.translate(x, y); MultiRectArea ret =
|
|
* parent.getObscuredRegion(r); if (ret != null) {
|
|
* parent.addObscuredRegions(ret, this); ret.translate(-x, -y);
|
|
* ret.intersect(new Rectangle(0, 0, w, h)); } return ret; }
|
|
*/
|
|
|
|
// ???AWT
|
|
/*
|
|
* private void readObject(ObjectInputStream stream) throws IOException,
|
|
* ClassNotFoundException { stream.defaultReadObject(); FieldsAccessor
|
|
* accessor = new FieldsAccessor(Component.class, this);
|
|
* accessor.set("toolkit", Toolkit.getDefaultToolkit()); //$NON-NLS-1$
|
|
* accessor.set("behaviour", createBehavior()); //$NON-NLS-1$
|
|
* accessor.set("componentLock", new Object()); // $NON-LOCK-1$
|
|
* //$NON-NLS-1$ }
|
|
*/
|
|
|
|
final void onDrawImage(Image image, Point destLocation, Dimension destSize, Rectangle source) {
|
|
ImageParameters imageParams;
|
|
if (updatedImages == null) {
|
|
updatedImages = new HashMap<Image, ImageParameters>();
|
|
}
|
|
imageParams = updatedImages.get(image);
|
|
if (imageParams == null) {
|
|
imageParams = new ImageParameters();
|
|
updatedImages.put(image, imageParams);
|
|
}
|
|
imageParams.addDrawing(destLocation, destSize, source);
|
|
}
|
|
|
|
public boolean imageUpdate(Image img, int infoflags, int x, int y, int w, int h) {
|
|
toolkit.lockAWT();
|
|
try {
|
|
boolean done = false;
|
|
if ((infoflags & (ALLBITS | FRAMEBITS)) != 0) {
|
|
done = true;
|
|
} else if ((infoflags & SOMEBITS) != 0 && incrementalImageUpdate) {
|
|
done = true;
|
|
}
|
|
if (done) {
|
|
repaint();
|
|
}
|
|
return (infoflags & (ABORT | ALLBITS)) == 0;
|
|
} finally {
|
|
toolkit.unlockAWT();
|
|
}
|
|
}
|
|
|
|
// ???AWT
|
|
/*
|
|
* private void invalidateRealParent() { Container realParent =
|
|
* getRealParent(); if ((realParent != null) && realParent.isValid()) {
|
|
* realParent.invalidate(); } }
|
|
*/
|
|
|
|
/**
|
|
* The Class ImageParameters.
|
|
*/
|
|
private class ImageParameters {
|
|
|
|
/**
|
|
* The drawing params.
|
|
*/
|
|
private final LinkedList<DrawingParameters> drawingParams = new LinkedList<DrawingParameters>();
|
|
|
|
/**
|
|
* The size.
|
|
*/
|
|
Dimension size = new Dimension(Component.this.w, Component.this.h);
|
|
|
|
/**
|
|
* Adds the drawing.
|
|
*
|
|
* @param destLocation
|
|
* the dest location.
|
|
* @param destSize
|
|
* the dest size.
|
|
* @param source
|
|
* the source.
|
|
*/
|
|
void addDrawing(Point destLocation, Dimension destSize, Rectangle source) {
|
|
drawingParams.add(new DrawingParameters(destLocation, destSize, source));
|
|
}
|
|
|
|
/**
|
|
* Drawing parameters iterator.
|
|
*
|
|
* @return the iterator< drawing parameters>.
|
|
*/
|
|
Iterator<DrawingParameters> drawingParametersIterator() {
|
|
return drawingParams.iterator();
|
|
}
|
|
|
|
/**
|
|
* The Class DrawingParameters.
|
|
*/
|
|
class DrawingParameters {
|
|
|
|
/**
|
|
* The dest location.
|
|
*/
|
|
Point destLocation;
|
|
|
|
/**
|
|
* The dest size.
|
|
*/
|
|
Dimension destSize;
|
|
|
|
/**
|
|
* The source.
|
|
*/
|
|
Rectangle source;
|
|
|
|
/**
|
|
* Instantiates a new drawing parameters.
|
|
*
|
|
* @param destLocation
|
|
* the dest location.
|
|
* @param destSize
|
|
* the dest size.
|
|
* @param source
|
|
* the source.
|
|
*/
|
|
DrawingParameters(Point destLocation, Dimension destSize, Rectangle source) {
|
|
this.destLocation = new Point(destLocation);
|
|
if (destSize != null) {
|
|
this.destSize = new Dimension(destSize);
|
|
} else {
|
|
this.destSize = null;
|
|
}
|
|
if (source != null) {
|
|
this.source = new Rectangle(source);
|
|
} else {
|
|
this.source = null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* TextComponent support.
|
|
*
|
|
* @param e
|
|
* the e.
|
|
* @return true, if dispatch event to im.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* private TextKit textKit = null; TextKit getTextKit() { return textKit; }
|
|
* void setTextKit(TextKit kit) { textKit = kit; }
|
|
*/
|
|
|
|
/**
|
|
* TextField support.
|
|
*/
|
|
// ???AWT
|
|
/*
|
|
* private TextFieldKit textFieldKit = null; TextFieldKit getTextFieldKit()
|
|
* { return textFieldKit; } void setTextFieldKit(TextFieldKit kit) {
|
|
* textFieldKit = kit; }
|
|
*/
|
|
|
|
/**
|
|
* Dispatches input & focus events to input method context.
|
|
*
|
|
* @param e
|
|
* event to pass to InputContext.dispatchEvent().
|
|
* @return true if event was consumed by IM, false otherwise.
|
|
*/
|
|
private boolean dispatchEventToIM(AWTEvent e) {
|
|
InputContext ic = getInputContext();
|
|
if (ic == null) {
|
|
return false;
|
|
}
|
|
int id = e.getID();
|
|
boolean isInputEvent = ((id >= KeyEvent.KEY_FIRST) && (id <= KeyEvent.KEY_LAST))
|
|
|| ((id >= MouseEvent.MOUSE_FIRST) && (id <= MouseEvent.MOUSE_LAST));
|
|
if (((id >= FocusEvent.FOCUS_FIRST) && (id <= FocusEvent.FOCUS_LAST)) || isInputEvent) {
|
|
ic.dispatchEvent(e);
|
|
}
|
|
return e.isConsumed();
|
|
}
|
|
}
|