awt/java/awt/Component.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package java.awt;

//import java.awt.dnd.DropTarget;
import java.awt.event.ComponentEvent;
import java.awt.event.ComponentListener;
import java.awt.event.FocusEvent;
import java.awt.event.FocusListener;
import java.awt.event.HierarchyBoundsListener;
import java.awt.event.HierarchyEvent;
import java.awt.event.HierarchyListener;
import java.awt.event.InputMethodEvent;
import java.awt.event.InputMethodListener;
import java.awt.event.InvocationEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.event.PaintEvent;
import java.awt.event.WindowEvent;
import java.awt.im.InputContext;
import java.awt.im.InputMethodRequests;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.image.VolatileImage;
import java.awt.image.WritableRaster;
import java.awt.peer.ComponentPeer;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.lang.reflect.Array;
import java.lang.reflect.Method;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.EventListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Map;
import java.util.Set;

//???AWT
//import javax.accessibility.Accessible;
//import javax.accessibility.AccessibleComponent;
//import javax.accessibility.AccessibleContext;
//import javax.accessibility.AccessibleRole;
//import javax.accessibility.AccessibleState;
//import javax.accessibility.AccessibleStateSet;

import org.apache.harmony.awt.ClipRegion;
//import org.apache.harmony.awt.FieldsAccessor;
import org.apache.harmony.awt.gl.MultiRectArea;
import org.apache.harmony.awt.internal.nls.Messages;
import org.apache.harmony.awt.state.State;
//import org.apache.harmony.awt.text.TextFieldKit;
//import org.apache.harmony.awt.text.TextKit;
import org.apache.harmony.awt.wtk.NativeWindow;

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

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