| /* |
| * 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(); |
| } |
| } |