jemmy/operators/ComponentOperator.java

/*
 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package org.netbeans.jemmy.operators;

import java.awt.AWTEvent;
import java.awt.Color;
import java.awt.Component;
import java.awt.ComponentOrientation;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.MenuComponent;
import java.awt.Point;
import java.awt.PopupMenu;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.dnd.DropTarget;
import java.awt.event.ComponentListener;
import java.awt.event.FocusListener;
import java.awt.event.InputMethodListener;
import java.awt.event.KeyListener;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.im.InputContext;
import java.awt.im.InputMethodRequests;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.beans.PropertyChangeListener;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.util.Hashtable;
import java.util.Locale;

import org.netbeans.jemmy.CharBindingMap;
import org.netbeans.jemmy.ComponentChooser;
import org.netbeans.jemmy.ComponentSearcher;
import org.netbeans.jemmy.EventDispatcher;
import org.netbeans.jemmy.JemmyException;
import org.netbeans.jemmy.JemmyProperties;
import org.netbeans.jemmy.Outputable;
import org.netbeans.jemmy.QueueTool;
import org.netbeans.jemmy.TestOut;
import org.netbeans.jemmy.TimeoutExpiredException;
import org.netbeans.jemmy.Timeoutable;
import org.netbeans.jemmy.Timeouts;
import org.netbeans.jemmy.Waitable;
import org.netbeans.jemmy.Waiter;
import org.netbeans.jemmy.drivers.DriverManager;
import org.netbeans.jemmy.drivers.FocusDriver;
import org.netbeans.jemmy.drivers.KeyDriver;
import org.netbeans.jemmy.drivers.MouseDriver;

/**
 * Root class for all component operators.
 *
 * Provides basic methods to operate with mouse and keyboard.<BR>
 * <BR>
 * Almost all input methods can throw JemmyInputException or its subclass.<BR>
 *
 * ComponentOperator and its subclasses has a lot of methods which name and
 * parameters just like consistent component has. In this case operator class
 * just invokes consistent component method through AWT Event Queue
 * (invokeAndWait method).
 *
 * <BR><BR>Timeouts used: <BR>
 * ComponentOperator.PushKeyTimeout - time between key pressing and releasing
 * <BR>
 * ComponentOperator.MouseClickTimeout - time between mouse pressing and
 * releasing <BR>
 * ComponentOperator.WaitComponentTimeout - time to wait component displayed
 * <BR>
 * ComponentOperator.WaitComponentEnabledTimeout - time to wait component
 * enabled <BR>
 * ComponentOperator.BeforeDragTimeout - time to sleep before grag'n'drop
 * operations <BR>
 * ComponentOperator.AfterDragTimeout - time to sleep after grag'n'drop
 * operations <BR>
 * ComponentOperator.WaitFocusTimeout - time to wait component focus <BR>
 * ComponentOperator.WaitStateTimeout- time to wait component to be in some
 * state. Typically used from methods like
 * {@code Operator.wait"something happened"(*)}<br>.
 *
 * @see org.netbeans.jemmy.Timeouts
 *
 * @author Alexandre Iline (alexandre.iline@oracle.com)
 */
public class ComponentOperator extends Operator
        implements Timeoutable, Outputable {

    /**
     * Identifier for a name property.
     *
     * @see #getDump
     */
    public static final String NAME_DPROP = "Name:";

    /**
     * Identifier for a visible property.
     *
     * @see #getDump
     */
    public static final String IS_VISIBLE_DPROP = "Visible";

    /**
     * Identifier for a showing property.
     *
     * @see #getDump
     */
    public static final String IS_SHOWING_DPROP = "Showing";

    /**
     * Identifier for a x coordinate property.
     *
     * @see #getDump
     */
    public static final String X_DPROP = "X";

    /**
     * Identifier for a y coordinate property.
     *
     * @see #getDump
     */
    public static final String Y_DPROP = "Y";

    /**
     * Identifier for a width property.
     *
     * @see #getDump
     */
    public static final String WIDTH_DPROP = "Width";

    /**
     * Identifier for a height property.
     *
     * @see #getDump
     */
    public static final String HEIGHT_DPROP = "Height";

    private static final long PUSH_KEY_TIMEOUT = 0;
    private static final long MOUSE_CLICK_TIMEOUT = 0;
    private static final long BEFORE_DRAG_TIMEOUT = 0;
    private static final long AFTER_DRAG_TIMEOUT = 0;
    private static final long WAIT_COMPONENT_TIMEOUT = 60000;
    private static final long WAIT_COMPONENT_ENABLED_TIMEOUT = 60000;
    private static final long WAIT_FOCUS_TIMEOUT = 60000;
    private static final long WAIT_STATE_TIMEOUT = 60000;

    private final Component source;
    private volatile Timeouts timeouts; // used in invokeSmoothly in clickMouse
    private volatile TestOut output; // used in QueueTool.Locker
    private volatile EventDispatcher dispatcher; // used in JInternalFrameByTitleFinder.checkComponent
    private KeyDriver kDriver;
    private MouseDriver mDriver;
    private FocusDriver fDriver;

    /**
     * Constructor.
     *
     * @param comp a component
     */
    public ComponentOperator(Component comp) {
        super();
        source = comp;
        kDriver = DriverManager.getKeyDriver(getClass());
        mDriver = DriverManager.getMouseDriver(getClass());
        fDriver = DriverManager.getFocusDriver(getClass());
        setEventDispatcher(new EventDispatcher(comp));
    }

    /**
     * Constructs a ComponentOperator object.
     *
     * @param cont container
     * @param chooser a component chooser specifying searching criteria.
     * @param index an index between appropriate ones.
     */
    public ComponentOperator(ContainerOperator<?> cont, ComponentChooser chooser, int index) {
        this(waitComponent((Container) cont.getSource(),
                chooser,
                index, cont.getTimeouts(), cont.getOutput()));
        copyEnvironment(cont);
    }

    /**
     * Constructs a ComponentOperator object.
     *
     * @param cont container
     * @param chooser a component chooser specifying searching criteria.
     */
    public ComponentOperator(ContainerOperator<?> cont, ComponentChooser chooser) {
        this(cont, chooser, 0);
    }

    /**
     * Constructor. Waits for a component in a container to show. The component
     * is iis the {@code index+1}'th {@code java.awt.Component} that
     * shows and that lies below the container in the display containment
     * hierarchy. Uses cont's timeout and output for waiting and to init
     * operator.
     *
     * @param cont Operator for a java.awt.Container.
     * @param index an index between appropriate ones.
     * @throws TimeoutExpiredException
     */
    public ComponentOperator(ContainerOperator<?> cont, int index) {
        this(cont, ComponentSearcher.getTrueChooser("Any component"), index);
    }

    /**
     * Constructor. Waits for a component in a container to show. The component
     * is is the first {@code java.awt.Component} that shows and that lies
     * below the container in the display containment hierarchy. Uses cont's
     * timeout and output for waiting and to init operator.
     *
     * @param cont Operator for a java.awt.Container.
     * @throws TimeoutExpiredException
     */
    public ComponentOperator(ContainerOperator<?> cont) {
        this(cont, 0);
    }

    /**
     * Searches Component in container.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @return Component instance or null if component was not found.
     */
    public static Component findComponent(Container cont, ComponentChooser chooser, int index) {
        return findComponent(cont, chooser, index, false);
    }

    /**
     * Searches Component in container.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @return Component instance or null if component was not found.
     */
    public static Component findComponent(Container cont, ComponentChooser chooser) {
        return findComponent(cont, chooser, 0);
    }

    /**
     * Waits Component in container.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @return Component instance or null if component was not found.
     * @throws TimeoutExpiredException
     */
    public static Component waitComponent(Container cont, ComponentChooser chooser, int index) {
        return (waitComponent(cont, chooser, index,
                JemmyProperties.getCurrentTimeouts(),
                JemmyProperties.getCurrentOutput()));
    }

    /**
     * Waits Component in container.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @return Component instance or null if component was not found.
     * @throws TimeoutExpiredException
     */
    public static Component waitComponent(Container cont, ComponentChooser chooser) {
        return waitComponent(cont, chooser, 0);
    }

    /**
     * A method to be used from subclasses. Uses {@code contOper}'s
     * timeouts and output during the waiting.
     *
     * @param contOper Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @return Component instance or null if component was not found.
     * @throws TimeoutExpiredException
     */
    protected static Component waitComponent(ContainerOperator<?> contOper,
            ComponentChooser chooser, int index) {
        return (waitComponent((Container) contOper.getSource(),
                chooser, index,
                contOper.getTimeouts(),
                contOper.getOutput()));
    }

    /**
     * A method to be used from subclasses. Uses timeouts and output passed as
     * parameters during the waiting.
     *
     * @param cont Container to search component in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @param index Ordinal component index.
     * @param timeouts timeouts to be used during the waiting.
     * @param output an output to be used during the waiting.
     * @return Component instance or null if component was not found.
     * @throws TimeoutExpiredException
     */
    protected static Component waitComponent(final Container cont,
            final ComponentChooser chooser,
            final int index,
            Timeouts timeouts, final TestOut output) {
        try {
            Waiter<Component, Void> waiter = new Waiter<>(new Waitable<Component, Void>() {
                @Override
                public Component actionProduced(Void obj) {
                    return findComponent(cont, new VisibleComponentFinder(chooser), index,
                            output.createErrorOutput());
                }

                @Override
                public String getDescription() {
                    return "Wait " + chooser.getDescription() + " loaded";
                }

                @Override
                public String toString() {
                    return "ComponentOperator.waitComponent.Waitable{description = " + getDescription() + '}';
                }
            });
            waiter.setTimeoutsToCloneOf(timeouts, "ComponentOperator.WaitComponentTimeout");
            waiter.setOutput(output);
            return waiter.waitAction(null);
        } catch (InterruptedException e) {
            return null;
        }
    }

    /**
     * Searches Components in container.
     *
     * @param cont Container to search components in.
     * @param chooser org.netbeans.jemmy.ComponentChooser implementation.
     * @return Component array or empty array if component was not found.
     */
    public static Component[] findComponents(Container cont, ComponentChooser chooser) {
        ComponentSearcher searcher = new ComponentSearcher(cont);
        return searcher.findComponents(new VisibleComponentFinder(chooser));
    }

    private static Component findComponent(Container cont, ComponentChooser chooser, int index, TestOut output) {
        ComponentSearcher searcher = new ComponentSearcher(cont);
        searcher.setOutput(output);
        return searcher.findComponent(new VisibleComponentFinder(chooser), index);
    }

    private static Component findComponent(Container cont, ComponentChooser chooser, int index, boolean supressOutout) {
        return findComponent(cont, chooser, index, JemmyProperties.getCurrentOutput().createErrorOutput());
    }

    static {
        Timeouts.initDefault("ComponentOperator.PushKeyTimeout", PUSH_KEY_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.MouseClickTimeout", MOUSE_CLICK_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.BeforeDragTimeout", BEFORE_DRAG_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.AfterDragTimeout", AFTER_DRAG_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.WaitComponentTimeout", WAIT_COMPONENT_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.WaitComponentEnabledTimeout", WAIT_COMPONENT_ENABLED_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.WaitStateTimeout", WAIT_STATE_TIMEOUT);
        Timeouts.initDefault("ComponentOperator.WaitFocusTimeout", WAIT_FOCUS_TIMEOUT);
    }

    /**
     * Returns component.
     */
    @Override
    public Component getSource() {
        return source;
    }

    /**
     * Returns org.netbeans.jemmy.EventDispatcher instance which is used to
     * dispatch events.
     *
     * @return the dispatcher.
     * @see org.netbeans.jemmy.EventDispatcher
     */
    public EventDispatcher getEventDispatcher() {
        return dispatcher;
    }

    ////////////////////////////////////////////////////////
    //Environment                                         //
    ////////////////////////////////////////////////////////
    @Override
    public void setOutput(TestOut out) {
        super.setOutput(out);
        this.output = out;
        if (dispatcher != null) {
            dispatcher.setOutput(output.createErrorOutput());
        }
    }

    @Override
    public TestOut getOutput() {
        return output;
    }

    @Override
    public void setTimeouts(Timeouts timeouts) {
        super.setTimeouts(timeouts);
        this.timeouts = timeouts;
        if (dispatcher != null) {
            dispatcher.setTimeouts(getTimeouts());
        }
    }

    @Override
    public Timeouts getTimeouts() {
        return timeouts;
    }

    @Override
    public void copyEnvironment(Operator anotherOperator) {
        super.copyEnvironment(anotherOperator);
        kDriver = (KeyDriver) DriverManager.
                getDriver(DriverManager.KEY_DRIVER_ID,
                        getClass(),
                        anotherOperator.getProperties());
        mDriver = (MouseDriver) DriverManager.
                getDriver(DriverManager.MOUSE_DRIVER_ID,
                        getClass(),
                        anotherOperator.getProperties());
        fDriver = (FocusDriver) DriverManager.
                getDriver(DriverManager.FOCUS_DRIVER_ID,
                        getClass(),
                        anotherOperator.getProperties());
    }

    ////////////////////////////////////////////////////////
    //Mouse operations
    ////////////////////////////////////////////////////////
    /**
     * Makes mouse click.
     *
     * @param x Horizontal click coordinate
     * @param y Vertical click coordinate
     * @param clickCount Click count
     * @param mouseButton Mouse button (InputEvent.BUTTON1/2/3_MASK value)
     * @param modifiers Modifiers (combination of InputEvent.*_MASK values)
     * @param forPopup signals that click is intended to call popup.
     */
    public void clickMouse(final int x, final int y, final int clickCount, final int mouseButton,
            final int modifiers, final boolean forPopup) {
        getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Void>("Path selecting") {
            @Override
            public Void launch() {
                mDriver.clickMouse(ComponentOperator.this, x, y, clickCount, mouseButton, modifiers,
                        timeouts.create("ComponentOperator.MouseClickTimeout"));
                return null;
            }
        });
    }

    /**
     * Makes mouse click.
     *
     * @param x Horizontal click coordinate
     * @param y Vertical click coordinate
     * @param clickCount Click count
     * @param mouseButton Mouse button (InputEvent.BUTTON1/2/3_MASK value)
     * @param modifiers Modifiers (combination of InputEvent.*_MASK values)
     * @see #clickMouse(int, int, int, int, int, boolean)
     */
    public void clickMouse(int x, int y, int clickCount, int mouseButton, int modifiers) {
        clickMouse(x, y, clickCount, mouseButton, modifiers, false);
    }

    /**
     * Makes mouse click with 0 modifiers.
     *
     * @param x Horizontal click coordinate
     * @param y Vertical click coordinate
     * @param clickCount Click count
     * @param mouseButton Mouse button (InputEvent.BUTTON1/2/3_MASK value)
     * @see #clickMouse(int, int, int, int, int)
     */
    public void clickMouse(int x, int y, int clickCount, int mouseButton) {
        clickMouse(x, y, clickCount, mouseButton, 0);
    }

    /**
     * Makes mouse click by default mouse button with 0 modifiers.
     *
     * @param x Horizontal click coordinate
     * @param y Vertical click coordinate
     * @param clickCount Click count
     * @see #clickMouse(int, int, int, int)
     * @see #getDefaultMouseButton()
     */
    public void clickMouse(int x, int y, int clickCount) {
        clickMouse(x, y, clickCount, getDefaultMouseButton());
    }

    /**
     * Press mouse.
     *
     * @param x Horizontal click coordinate
     * @param y Vertical click coordinate
     */
    public void pressMouse(int x, int y) {
        mDriver.pressMouse(this, x, y, getDefaultMouseButton(), 0);
    }

    /**
     * Releases mouse.
     *
     * @param x Horizontal click coordinate
     * @param y Vertical click coordinate
     */
    public void releaseMouse(int x, int y) {
        mDriver.releaseMouse(this, x, y, getDefaultMouseButton(), 0);
    }

    /**
     * Move mouse over the component.
     *
     * @param x Horisontal destination coordinate.
     * @param y Vertical destination coordinate.
     */
    public void moveMouse(int x, int y) {
        mDriver.moveMouse(this, x, y);
    }

    /**
     * Drag mouse over the component.
     *
     * @param x Horisontal destination coordinate.
     * @param y Vertical destination coordinate.
     * @param mouseButton Mouse button
     * @param modifiers Modifiers
     */
    public void dragMouse(int x, int y, int mouseButton, int modifiers) {
        mDriver.dragMouse(this, x, y, getDefaultMouseButton(), 0);
    }

    /**
     * Drag mouse over the component with 0 modifiers.
     *
     * @param x Horisontal destination coordinate.
     * @param y Vertical destination coordinate.
     * @param mouseButton Mouse button
     * @see #dragMouse(int, int, int, int)
     */
    public void dragMouse(int x, int y, int mouseButton) {
        dragMouse(x, y, mouseButton, 0);
    }

    /**
     * Drag mouse over the component with 0 modifiers and default mose button
     * pressed.
     *
     * @param x Horisontal destination coordinate.
     * @param y Vertical destination coordinate.
     * @see #dragMouse(int, int, int)
     * @see #getDefaultMouseButton()
     */
    public void dragMouse(int x, int y) {
        dragMouse(x, y, getDefaultMouseButton());
    }

    /**
     * Makes drag'n'drop operation.
     *
     * @param start_x Start horizontal coordinate
     * @param start_y Start vertical coordinate
     * @param end_x End horizontal coordinate
     * @param end_y End vertical coordinate
     * @param mouseButton Mouse button
     * @param modifiers Modifiers
     */
    public void dragNDrop(int start_x, int start_y, int end_x, int end_y, int mouseButton, int modifiers) {
        mDriver.dragNDrop(this, start_x, start_y, end_x, end_y, mouseButton, modifiers,
                timeouts.create("ComponentOperator.BeforeDragTimeout"),
                timeouts.create("ComponentOperator.AfterDragTimeout"));
    }

    /**
     * Makes drag'n'drop operation with 0 modifiers.
     *
     * @param start_x Start horizontal coordinate
     * @param start_y Start vertical coordinate
     * @param end_x End horizontal coordinate
     * @param end_y End vertical coordinate
     * @param mouseButton Mouse button
     * @see #dragNDrop(int, int, int, int, int, int)
     */
    public void dragNDrop(int start_x, int start_y, int end_x, int end_y, int mouseButton) {
        dragNDrop(start_x, start_y, end_x, end_y, mouseButton, 0);
    }

    /**
     * Makes drag'n'drop operation by default mouse buttons with 0 modifiers.
     *
     * @param start_x Start horizontal coordinate
     * @param start_y Start vertical coordinate
     * @param end_x End horizontal coordinate
     * @param end_y End vertical coordinate
     * @see #dragNDrop(int, int, int, int, int)
     * @see #getDefaultMouseButton()
     */
    public void dragNDrop(int start_x, int start_y, int end_x, int end_y) {
        dragNDrop(start_x, start_y, end_x, end_y, getDefaultMouseButton(), 0);
    }

    /**
     * Clicks for popup.
     *
     * @param x Horizontal click coordinate.
     * @param y Vertical click coordinate.
     * @param mouseButton Mouse button.
     * @see #clickMouse(int, int, int, int, int, boolean)
     */
    public void clickForPopup(int x, int y, int mouseButton) {
        makeComponentVisible();
        clickMouse(x, y, 1, mouseButton, 0, true);
    }

    /**
     * Clicks for popup by popup mouse button.
     *
     * @param x Horizontal click coordinate.
     * @param y Vertical click coordinate.
     * @see #clickForPopup(int, int, int)
     * @see #getPopupMouseButton()
     */
    public void clickForPopup(int x, int y) {
        clickForPopup(x, y, getPopupMouseButton());
    }

    /**
     * Makes mouse click on the component center with 0 modifiers.
     *
     * @param clickCount Click count
     * @param mouseButton Mouse button (InputEvent.BUTTON1/2/3_MASK value)
     * @see #clickMouse(int, int, int, int)
     */
    public void clickMouse(final int clickCount, final int mouseButton) {
        getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Void>("Clicking the mouse button") {
            @Override
            public Void launch() {
                clickMouse(getCenterXForClick(), getCenterYForClick(), clickCount, mouseButton);
                return null;
            }
        });
    }

    /**
     * Makes mouse click on the component center by default mouse button with 0
     * modifiers.
     *
     * @param clickCount Click count
     * @see #clickMouse(int, int)
     * @see #getDefaultMouseButton()
     */
    public void clickMouse(int clickCount) {
        clickMouse(clickCount, getDefaultMouseButton());
    }

    /**
     * Makes siple mouse click on the component center by default mouse button
     * with 0 modifiers.
     *
     * @see #clickMouse(int)
     * @see #getDefaultMouseButton()
     */
    public void clickMouse() {
        clickMouse(1);
    }

    /**
     * Move mouse inside the component.
     */
    public void enterMouse() {
        mDriver.enterMouse(this);
    }

    /**
     * Move mouse outside the component.
     */
    public void exitMouse() {
        mDriver.exitMouse(this);
    }

    /**
     * Press mouse.
     */
    public void pressMouse() {
        getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Void>("Pressing the mouse button") {
            @Override
            public Void launch() {
                pressMouse(getCenterXForClick(), getCenterYForClick());
                return null;
            }
        });
    }

    /**
     * Releases mouse.
     */
    public void releaseMouse() {
        getQueueTool().invokeSmoothly(new QueueTool.QueueAction<Void>("Releasing the mouse button") {
            @Override
            public Void launch() {
                releaseMouse(getCenterXForClick(), getCenterYForClick());
                return null;
            }
        });
    }

    /**
     * Clicks for popup at the component center.
     *
     * @param mouseButton Mouse button.
     * @see #clickForPopup(int, int)
     */
    public void clickForPopup(int mouseButton) {
        clickForPopup(getCenterXForClick(), getCenterYForClick(), mouseButton);
    }

    /**
     * Clicks for popup by popup mouse button at the component center.
     *
     * @see #clickForPopup(int)
     * @see #getPopupMouseButton()
     */
    public void clickForPopup() {
        clickForPopup(getPopupMouseButton());
    }

    ////////////////////////////////////////////////////////
    //Keyboard operations
    ////////////////////////////////////////////////////////
    /**
     * Press key.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     * @param modifiers Modifiers (combination of InputEvent.*_MASK fields)
     */
    public void pressKey(int keyCode, int modifiers) {
        kDriver.pressKey(this, keyCode, modifiers);
    }

    /**
     * Press key with no modifiers.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     */
    public void pressKey(int keyCode) {
        pressKey(keyCode, 0);
    }

    /**
     * Typed key.
     *
     * @param keyChar Char to be typed.
     * @param modifiers Modifiers (combination of InputEvent.*_MASK fields)
     */
    public void typedKey(char keyChar, int modifiers) {
        kDriver.typedKey(this, getCharBindingMap().getCharKey(keyChar), keyChar, modifiers);
    }

    /**
     * Releases key.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     * @param modifiers Modifiers (combination of InputEvent.*_MASK fields)
     */
    public void releaseKey(int keyCode, int modifiers) {
        kDriver.releaseKey(this, keyCode, modifiers);
    }

    /**
     * Releases key with no modifiers.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     */
    public void releaseKey(int keyCode) {
        releaseKey(keyCode, 0);
    }

    /**
     * Pushs key.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     * @param modifiers Modifiers (combination of InputEvent.*_MASK fields)
     */
    public void pushKey(int keyCode, int modifiers) {
        kDriver.pushKey(this, keyCode, modifiers, timeouts.create("ComponentOperator.PushKeyTimeout"));
    }

    /**
     * Pushs key.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     */
    public void pushKey(int keyCode) {
        pushKey(keyCode, 0);
    }

    /**
     * Types one char.
     *
     * @param keyCode Key code (KeyEvent.VK_* value)
     * @param keyChar Char to be typed.
     * @param modifiers Modifiers (combination of InputEvent.*_MASK fields)
     */
    public void typeKey(int keyCode, char keyChar, int modifiers) {
        kDriver.typeKey(this, keyCode, keyChar, modifiers, timeouts.create("ComponentOperator.PushKeyTimeout"));
    }

    /**
     * Types one char. Uses map defined by setCharBindingMap(CharBindingMap)
     * method to find a key should be pressed.
     *
     * @param keyChar Char to be typed.
     * @param modifiers Modifiers (combination of InputEvent.*_MASK fields)
     * @see org.netbeans.jemmy.CharBindingMap
     * @see #setCharBindingMap(CharBindingMap)
     * @see #typeKey(int, char, int)
     */
    public void typeKey(char keyChar, int modifiers) {
        typeKey(getCharKey(keyChar), keyChar, modifiers | getCharModifiers(keyChar));
    }

    /**
     * Types one char. Uses map defined by setCharBindingMap(CharBindingMap)
     * method to find a key and modifiers should be pressed.
     *
     * @param keyChar Char to be typed.
     * @see #setCharBindingMap(CharBindingMap)
     * @see #typeKey(char, int)
     */
    public void typeKey(char keyChar) {
        typeKey(keyChar, 0);
    }

    ////////////////////////////////////////////////////////
    //Util
    ////////////////////////////////////////////////////////
    /**
     * Activates component's window.
     *
     * @deprecated Use makeComponentVisible() instead.
     * @see #makeComponentVisible()
     */
    @Deprecated
    public void activateWindow() {
        getVisualizer().makeVisible(this);
    }

    /**
     * Prepares component for user input. Uses visualizer defined by
     * setVisualiser() method.
     */
    public void makeComponentVisible() {
        getVisualizer().makeVisible(this);
        /*
        final ComponentOperator compOper = (ComponentOperator)this;
        runMapping(new MapVoidAction("add") {
                public void map() {
                    getVisualizer().makeVisible(compOper);
                }
            });
         */
    }

    /**
     * Gives input focus to the component.
     */
    public void getFocus() {
        fDriver.giveFocus(this);
    }

    /**
     * Return the center x coordinate.
     *
     * @return the center x coordinate.
     */
    public int getCenterX() {
        return getWidth() / 2;
    }

    /**
     * Return the center y coordinate.
     *
     * @return the center y coordinate.
     */
    public int getCenterY() {
        return getHeight() / 2;
    }

    /**
     * Return the x coordinate which should be used for mouse operations by
     * default.
     *
     * @return the center x coordinate of the visible component part.
     */
    public int getCenterXForClick() {
        return getCenterX();
    }

    /**
     * Return the y coordinate which should be used for mouse operations by
     * default.
     *
     * @return the center y coordinate of the visible component part.
     */
    public int getCenterYForClick() {
        return getCenterY();
    }

    /**
     * Waits for the component to be enabled.
     *
     * @throws TimeoutExpiredException
     * @throws InterruptedException
     */
    public void waitComponentEnabled() throws InterruptedException {
        Waiter<Component, Component> waiter = new Waiter<>(new Waitable<Component, Component>() {
            @Override
            public Component actionProduced(Component obj) {
                if (obj.isEnabled()) {
                    return obj;
                } else {
                    return null;
                }
            }

            @Override
            public String getDescription() {
                return ("Component enabled: "
                        + getSource().getClass().toString());
            }

            @Override
            public String toString() {
                return "ComponentOperator.waitComponentEnabled.Waitable{description = " + getDescription() + '}';
            }
        });
        waiter.setOutput(output);
        waiter.setTimeoutsToCloneOf(timeouts, "ComponentOperator.WaitComponentEnabledTimeout");
        waiter.waitAction(getSource());
    }

    /**
     * Waits for the component to be enabled. per request: 37831
     *
     * @throws TimeoutExpiredException
     */
    public void wtComponentEnabled() {
        try {
            waitComponentEnabled();
        } catch (InterruptedException e) {
            throw (new JemmyException("Interrupted!", e));
        }
    }

    /**
     * Returns an array of containers for this component.
     *
     * @return an array of containers
     */
    public Container[] getContainers() {
        int counter = 0;
        Container cont = getSource().getParent();
        if (cont == null) {
            return new Container[0];
        }
        do {
            counter++;
        } while ((cont = cont.getParent()) != null);
        Container[] res = new Container[counter];
        cont = getSource().getParent();
        counter = 0;
        do {
            counter++;
            res[counter - 1] = cont;
        } while ((cont = cont.getParent()) != null);
        return res;
    }

    /**
     * Searches a container.
     *
     * @param chooser a chooser specifying the searching criteria.
     * @return a containers specified by searching criteria.
     */
    public Container getContainer(ComponentChooser chooser) {
        int counter = 0;
        Container cont = getSource().getParent();
        if (cont == null) {
            return null;
        }
        do {
            if (chooser.checkComponent(cont)) {
                return cont;
            }
            counter++;
        } while ((cont = cont.getParent()) != null);
        return null;
    }

    /**
     * Searches the window under component.
     *
     * @return the component window.
     */
    public Window getWindow() {
        if (getSource() instanceof Window) {
            return (Window) getSource();
        }
        Window window = (Window) getContainer(new ComponentChooser() {
            @Override
            public boolean checkComponent(Component comp) {
                return comp instanceof Window;
            }

            @Override
            public String getDescription() {
                return "";
            }

            @Override
            public String toString() {
                return "ComponentOperator.getWindow.ComponentChooser{description = " + getDescription() + '}';
            }
        });
        if (window == null && getSource() instanceof Window) {
            return (Window) getSource();
        } else {
            return window;
        }
    }

    /**
     * Waits for this Component has the keyboard focus.
     *
     * @throws TimeoutExpiredException
     */
    public void waitHasFocus() {
        Waiter<String, Void> focusWaiter = new Waiter<>(new Waitable<String, Void>() {
            @Override
            public String actionProduced(Void obj) {
                return hasFocus() ? "" : null;
            }

            @Override
            public String getDescription() {
                return "Wait component has focus";
            }

            @Override
            public String toString() {
                return "ComponentOperator.waitHasFocus.Waitable{description = " + getDescription() + '}';
            }
        });
        focusWaiter.setTimeoutsToCloneOf(timeouts, "ComponentOperator.WaitFocusTimeout");
        focusWaiter.setOutput(output.createErrorOutput());
        try {
            focusWaiter.waitAction(null);
        } catch (InterruptedException e) {
            output.printStackTrace(e);
        }
    }

    /**
     * Waits for the component to be visible or unvisible.
     *
     * @param visibility required visiblity.
     * @throws TimeoutExpiredException
     */
    public void waitComponentVisible(final boolean visibility) {
        waitState(new ComponentChooser() {
            @Override
            public boolean checkComponent(Component comp) {
                return isVisible() == visibility;
            }

            @Override
            public String getDescription() {
                return "Component is " + (visibility ? "" : " not ") + "visible";
            }

            @Override
            public String toString() {
                return "ComponentOperator.waitComponentVisible.ComponentChooser{description = " + getDescription() + '}';
            }
        });
    }

    public void waitComponentShowing(final boolean visibility) {
        waitState(new ComponentChooser() {
            @Override
            public boolean checkComponent(Component comp) {
                return isShowing() == visibility;
            }

            @Override
            public String getDescription() {
                return "Component is " + (visibility ? "" : " not ") + "showing";
            }

            @Override
            public String toString() {
                return "ComponentOperator.waitComponentShowing.ComponentChooser{description = " + getDescription() + '}';
            }
        });
    }

    /**
     * Returns information about component.
     */
    @Override
    public Hashtable<String, Object> getDump() {
        Hashtable<String, Object> result = super.getDump();
        if (getSource().getName() != null) {
            result.put(NAME_DPROP, getSource().getName());
        }
        result.put(IS_VISIBLE_DPROP, getSource().isVisible() ? "true" : "false");
        result.put(IS_SHOWING_DPROP, getSource().isShowing() ? "true" : "false");
        result.put(X_DPROP, Integer.toString(getSource().getX()));
        result.put(Y_DPROP, Integer.toString(getSource().getY()));
        result.put(WIDTH_DPROP, Integer.toString(getSource().getWidth()));
        result.put(HEIGHT_DPROP, Integer.toString(getSource().getHeight()));
        return result;
    }

    ////////////////////////////////////////////////////////
    //Mapping                                             //
    /**
     * Maps {@code Component.add(PopupMenu)} through queue
     */
    public void add(final PopupMenu popupMenu) {
        runMapping(new MapVoidAction("add") {
            @Override
            public void map() {
                getSource().add(popupMenu);
            }
        });
    }

    /**
     * Maps {@code Component.addComponentListener(ComponentListener)}
     * through queue
     */
    public void addComponentListener(final ComponentListener componentListener) {
        runMapping(new MapVoidAction("addComponentListener") {
            @Override
            public void map() {
                getSource().addComponentListener(componentListener);
            }
        });
    }

    /**
     * Maps {@code Component.addFocusListener(FocusListener)} through queue
     */
    public void addFocusListener(final FocusListener focusListener) {
        runMapping(new MapVoidAction("addFocusListener") {
            @Override
            public void map() {
                getSource().addFocusListener(focusListener);
            }
        });
    }

    /**
     * Maps {@code Component.addInputMethodListener(InputMethodListener)}
     * through queue
     */
    public void addInputMethodListener(final InputMethodListener inputMethodListener) {
        runMapping(new MapVoidAction("addInputMethodListener") {
            @Override
            public void map() {
                getSource().addInputMethodListener(inputMethodListener);
            }
        });
    }

    /**
     * Maps {@code Component.addKeyListener(KeyListener)} through queue
     */
    public void addKeyListener(final KeyListener keyListener) {
        runMapping(new MapVoidAction("addKeyListener") {
            @Override
            public void map() {
                getSource().addKeyListener(keyListener);
            }
        });
    }

    /**
     * Maps {@code Component.addMouseListener(MouseListener)} through queue
     */
    public void addMouseListener(final MouseListener mouseListener) {
        runMapping(new MapVoidAction("addMouseListener") {
            @Override
            public void map() {
                getSource().addMouseListener(mouseListener);
            }
        });
    }

    /**
     * Maps {@code Component.addMouseMotionListener(MouseMotionListener)}
     * through queue
     */
    public void addMouseMotionListener(final MouseMotionListener mouseMotionListener) {
        runMapping(new MapVoidAction("addMouseMotionListener") {
            @Override
            public void map() {
                getSource().addMouseMotionListener(mouseMotionListener);
            }
        });
    }

    /**
     * Maps {@code Component.addNotify()} through queue
     */
    public void addNotify() {
        runMapping(new MapVoidAction("addNotify") {
            @Override
            public void map() {
                getSource().addNotify();
            }
        });
    }

    /**
     * Maps
     * {@code Component.addPropertyChangeListener(PropertyChangeListener)}
     * through queue
     */
    public void addPropertyChangeListener(final PropertyChangeListener propertyChangeListener) {
        runMapping(new MapVoidAction("addPropertyChangeListener") {
            @Override
            public void map() {
                getSource().addPropertyChangeListener(propertyChangeListener);
            }
        });
    }

    /**
     * Maps
     * {@code Component.addPropertyChangeListener(String, PropertyChangeListener)}
     * through queue
     */
    public void addPropertyChangeListener(final String string, final PropertyChangeListener propertyChangeListener) {
        runMapping(new MapVoidAction("addPropertyChangeListener") {
            @Override
            public void map() {
                getSource().addPropertyChangeListener(string, propertyChangeListener);
            }
        });
    }

    /**
     * Maps {@code Component.checkImage(Image, int, int, ImageObserver)}
     * through queue
     */
    public int checkImage(final Image image, final int i, final int i1, final ImageObserver imageObserver) {
        return (runMapping(new MapIntegerAction("checkImage") {
            @Override
            public int map() {
                return getSource().checkImage(image, i, i1, imageObserver);
            }
        }));
    }

    /**
     * Maps {@code Component.checkImage(Image, ImageObserver)} through queue
     */
    public int checkImage(final Image image, final ImageObserver imageObserver) {
        return (runMapping(new MapIntegerAction("checkImage") {
            @Override
            public int map() {
                return getSource().checkImage(image, imageObserver);
            }
        }));
    }

    /**
     * Maps {@code Component.contains(int, int)} through queue
     */
    public boolean contains(final int i, final int i1) {
        return (runMapping(new MapBooleanAction("contains") {
            @Override
            public boolean map() {
                return getSource().contains(i, i1);
            }
        }));
    }

    /**
     * Maps {@code Component.contains(Point)} through queue
     */
    public boolean contains(final Point point) {
        return (runMapping(new MapBooleanAction("contains") {
            @Override
            public boolean map() {
                return getSource().contains(point);
            }
        }));
    }

    /**
     * Maps {@code Component.createImage(int, int)} through queue
     */
    public Image createImage(final int i, final int i1) {
        return (runMapping(new MapAction<Image>("createImage") {
            @Override
            public Image map() {
                return getSource().createImage(i, i1);
            }
        }));
    }

    /**
     * Maps {@code Component.createImage(ImageProducer)} through queue
     */
    public Image createImage(final ImageProducer imageProducer) {
        return (runMapping(new MapAction<Image>("createImage") {
            @Override
            public Image map() {
                return getSource().createImage(imageProducer);
            }
        }));
    }

    /**
     * Maps {@code Component.dispatchEvent(AWTEvent)} through queue
     */
    public void dispatchEvent(final AWTEvent aWTEvent) {
        runMapping(new MapVoidAction("dispatchEvent") {
            @Override
            public void map() {
                getSource().dispatchEvent(aWTEvent);
            }
        });
    }

    /**
     * Maps {@code Component.doLayout()} through queue
     */
    public void doLayout() {
        runMapping(new MapVoidAction("doLayout") {
            @Override
            public void map() {
                getSource().doLayout();
            }
        });
    }

    /**
     * Maps {@code Component.enableInputMethods(boolean)} through queue
     */
    public void enableInputMethods(final boolean b) {
        runMapping(new MapVoidAction("enableInputMethods") {
            @Override
            public void map() {
                getSource().enableInputMethods(b);
            }
        });
    }

    /**
     * Maps {@code Component.getAlignmentX()} through queue
     */
    public float getAlignmentX() {
        return (runMapping(new MapFloatAction("getAlignmentX") {
            @Override
            public float map() {
                return getSource().getAlignmentX();
            }
        }));
    }

    /**
     * Maps {@code Component.getAlignmentY()} through queue
     */
    public float getAlignmentY() {
        return (runMapping(new MapFloatAction("getAlignmentY") {
            @Override
            public float map() {
                return getSource().getAlignmentY();
            }
        }));
    }

    /**
     * Maps {@code Component.getBackground()} through queue
     */
    public Color getBackground() {
        return (runMapping(new MapAction<Color>("getBackground") {
            @Override
            public Color map() {
                return getSource().getBackground();
            }
        }));
    }

    /**
     * Maps {@code Component.getBounds()} through queue
     */
    public Rectangle getBounds() {
        return (runMapping(new MapAction<Rectangle>("getBounds") {
            @Override
            public Rectangle map() {
                return getSource().getBounds();
            }
        }));
    }

    /**
     * Maps {@code Component.getBounds(Rectangle)} through queue
     */
    public Rectangle getBounds(final Rectangle rectangle) {
        return (runMapping(new MapAction<Rectangle>("getBounds") {
            @Override
            public Rectangle map() {
                return getSource().getBounds(rectangle);
            }
        }));
    }

    /**
     * Maps {@code Component.getColorModel()} through queue
     */
    public ColorModel getColorModel() {
        return (runMapping(new MapAction<ColorModel>("getColorModel") {
            @Override
            public ColorModel map() {
                return getSource().getColorModel();
            }
        }));
    }

    /**
     * Maps {@code Component.getComponentAt(int, int)} through queue
     */
    public Component getComponentAt(final int i, final int i1) {
        return (runMapping(new MapAction<Component>("getComponentAt") {
            @Override
            public Component map() {
                return getSource().getComponentAt(i, i1);
            }
        }));
    }

    /**
     * Maps {@code Component.getComponentAt(Point)} through queue
     */
    public Component getComponentAt(final Point point) {
        return (runMapping(new MapAction<Component>("getComponentAt") {
            @Override
            public Component map() {
                return getSource().getComponentAt(point);
            }
        }));
    }

    /**
     * Maps {@code Component.getComponentOrientation()} through queue
     */
    public ComponentOrientation getComponentOrientation() {
        return (runMapping(new MapAction<ComponentOrientation>("getComponentOrientation") {
            @Override
            public ComponentOrientation map() {
                return getSource().getComponentOrientation();
            }
        }));
    }

    /**
     * Maps {@code Component.getCursor()} through queue
     */
    public Cursor getCursor() {
        return (runMapping(new MapAction<Cursor>("getCursor") {
            @Override
            public Cursor map() {
                return getSource().getCursor();
            }
        }));
    }

    /**
     * Maps {@code Component.getDropTarget()} through queue
     */
    public DropTarget getDropTarget() {
        return (runMapping(new MapAction<DropTarget>("getDropTarget") {
            @Override
            public DropTarget map() {
                return getSource().getDropTarget();
            }
        }));
    }

    /**
     * Maps {@code Component.getFont()} through queue
     */
    public Font getFont() {
        return (runMapping(new MapAction<Font>("getFont") {
            @Override
            public Font map() {
                return getSource().getFont();
            }
        }));
    }

    /**
     * Maps {@code Component.getFontMetrics(Font)} through queue
     */
    public FontMetrics getFontMetrics(final Font font) {
        return (runMapping(new MapAction<FontMetrics>("getFontMetrics") {
            @Override
            public FontMetrics map() {
                return getSource().getFontMetrics(font);
            }
        }));
    }

    /**
     * Maps {@code Component.getForeground()} through queue
     */
    public Color getForeground() {
        return (runMapping(new MapAction<Color>("getForeground") {
            @Override
            public Color map() {
                return getSource().getForeground();
            }
        }));
    }

    /**
     * Maps {@code Component.getGraphics()} through queue
     */
    public Graphics getGraphics() {
        return (runMapping(new MapAction<Graphics>("getGraphics") {
            @Override
            public Graphics map() {
                return getSource().getGraphics();
            }
        }));
    }

    /**
     * Maps {@code Component.getHeight()} through queue
     */
    public int getHeight() {
        return (runMapping(new MapIntegerAction("getHeight") {
            @Override
            public int map() {
                return getSource().getHeight();
            }
        }));
    }

    /**
     * Maps {@code Component.getInputContext()} through queue
     */
    public InputContext getInputContext() {
        return (runMapping(new MapAction<InputContext>("getInputContext") {
            @Override
            public InputContext map() {
                return getSource().getInputContext();
            }
        }));
    }

    /**
     * Maps {@code Component.getInputMethodRequests()} through queue
     */
    public InputMethodRequests getInputMethodRequests() {
        return (runMapping(new MapAction<InputMethodRequests>("getInputMethodRequests") {
            @Override
            public InputMethodRequests map() {
                return getSource().getInputMethodRequests();
            }
        }));
    }

    /**
     * Maps {@code Component.getLocale()} through queue
     */
    public Locale getLocale() {
        return (runMapping(new MapAction<Locale>("getLocale") {
            @Override
            public Locale map() {
                return getSource().getLocale();
            }
        }));
    }

    /**
     * Maps {@code Component.getLocation()} through queue
     */
    public Point getLocation() {
        return (runMapping(new MapAction<Point>("getLocation") {
            @Override
            public Point map() {
                return getSource().getLocation();
            }
        }));
    }

    /**
     * Maps {@code Component.getLocation(Point)} through queue
     */
    public Point getLocation(final Point point) {
        return (runMapping(new MapAction<Point>("getLocation") {
            @Override
            public Point map() {
                return getSource().getLocation(point);
            }
        }));
    }

    /**
     * Maps {@code Component.getLocationOnScreen()} through queue
     */
    public Point getLocationOnScreen() {
        return (runMapping(new MapAction<Point>("getLocationOnScreen") {
            @Override
            public Point map() {
                return getSource().getLocationOnScreen();
            }
        }));
    }

    /**
     * Maps {@code Component.getMaximumSize()} through queue
     */
    public Dimension getMaximumSize() {
        return (runMapping(new MapAction<Dimension>("getMaximumSize") {
            @Override
            public Dimension map() {
                return getSource().getMaximumSize();
            }
        }));
    }

    /**
     * Maps {@code Component.getMinimumSize()} through queue
     */
    public Dimension getMinimumSize() {
        return (runMapping(new MapAction<Dimension>("getMinimumSize") {
            @Override
            public Dimension map() {
                return getSource().getMinimumSize();
            }
        }));
    }

    /**
     * Maps {@code Component.getName()} through queue
     */
    public String getName() {
        return (runMapping(new MapAction<String>("getName") {
            @Override
            public String map() {
                return getSource().getName();
            }
        }));
    }

    /**
     * Maps {@code Component.getParent()} through queue
     */
    public Container getParent() {
        return (runMapping(new MapAction<Container>("getParent") {
            @Override
            public Container map() {
                return getSource().getParent();
            }
        }));
    }

    /**
     * Maps {@code Component.getPreferredSize()} through queue
     */
    public Dimension getPreferredSize() {
        return (runMapping(new MapAction<Dimension>("getPreferredSize") {
            @Override
            public Dimension map() {
                return getSource().getPreferredSize();
            }
        }));
    }

    /**
     * Maps {@code Component.getSize()} through queue
     */
    public Dimension getSize() {
        return (runMapping(new MapAction<Dimension>("getSize") {
            @Override
            public Dimension map() {
                return getSource().getSize();
            }
        }));
    }

    /**
     * Maps {@code Component.getSize(Dimension)} through queue
     */
    public Dimension getSize(final Dimension dimension) {
        return (runMapping(new MapAction<Dimension>("getSize") {
            @Override
            public Dimension map() {
                return getSource().getSize(dimension);
            }
        }));
    }

    /**
     * Maps {@code Component.getToolkit()} through queue
     */
    public Toolkit getToolkit() {
        return (runMapping(new MapAction<Toolkit>("getToolkit") {
            @Override
            public Toolkit map() {
                return getSource().getToolkit();
            }
        }));
    }

    /**
     * Maps {@code Component.getTreeLock()} through queue
     */
    public Object getTreeLock() {
        return (runMapping(new MapAction<Object>("getTreeLock") {
            @Override
            public Object map() {
                return getSource().getTreeLock();
            }
        }));
    }

    /**
     * Maps {@code Component.getWidth()} through queue
     */
    public int getWidth() {
        return (runMapping(new MapIntegerAction("getWidth") {
            @Override
            public int map() {
                return getSource().getWidth();
            }
        }));
    }

    /**
     * Maps {@code Component.getX()} through queue
     */
    public int getX() {
        return (runMapping(new MapIntegerAction("getX") {
            @Override
            public int map() {
                return getSource().getX();
            }
        }));
    }

    /**
     * Maps {@code Component.getY()} through queue
     */
    public int getY() {
        return (runMapping(new MapIntegerAction("getY") {
            @Override
            public int map() {
                return getSource().getY();
            }
        }));
    }

    /**
     * Maps {@code Component.hasFocus()} through queue
     */
    public boolean hasFocus() {
        return (runMapping(new MapBooleanAction("hasFocus") {
            @Override
            public boolean map() {
                return getSource().hasFocus();
            }
        }));
    }

    /**
     * Maps {@code Component.imageUpdate(Image, int, int, int, int, int)}
     * through queue
     */
    public boolean imageUpdate(final Image image, final int i, final int i1, final int i2, final int i3, final int i4) {
        return (runMapping(new MapBooleanAction("imageUpdate") {
            @Override
            public boolean map() {
                return getSource().imageUpdate(image, i, i1, i2, i3, i4);
            }
        }));
    }

    /**
     * Maps {@code Component.invalidate()} through queue
     */
    public void invalidate() {
        runMapping(new MapVoidAction("invalidate") {
            @Override
            public void map() {
                getSource().invalidate();
            }
        });
    }

    /**
     * Maps {@code Component.isDisplayable()} through queue
     */
    public boolean isDisplayable() {
        return (runMapping(new MapBooleanAction("isDisplayable") {
            @Override
            public boolean map() {
                return getSource().isDisplayable();
            }
        }));
    }

    /**
     * Maps {@code Component.isDoubleBuffered()} through queue
     */
    public boolean isDoubleBuffered() {
        return (runMapping(new MapBooleanAction("isDoubleBuffered") {
            @Override
            public boolean map() {
                return getSource().isDoubleBuffered();
            }
        }));
    }

    /**
     * Maps {@code Component.isEnabled()} through queue
     */
    public boolean isEnabled() {
        return (runMapping(new MapBooleanAction("isEnabled") {
            @Override
            public boolean map() {
                return getSource().isEnabled();
            }
        }));
    }

    /**
     * Maps {@code Component.isFocusTraversable()} through queue
     */
    @Deprecated
    public boolean isFocusTraversable() {
        return (runMapping(new MapBooleanAction("isFocusTraversable") {
            @Override
            public boolean map() {
                return getSource().isFocusTraversable();
            }
        }));
    }

    /**
     * Maps {@code Component.isLightweight()} through queue
     */
    public boolean isLightweight() {
        return (runMapping(new MapBooleanAction("isLightweight") {
            @Override
            public boolean map() {
                return getSource().isLightweight();
            }
        }));
    }

    /**
     * Maps {@code Component.isOpaque()} through queue
     */
    public boolean isOpaque() {
        return (runMapping(new MapBooleanAction("isOpaque") {
            @Override
            public boolean map() {
                return getSource().isOpaque();
            }
        }));
    }

    /**
     * Maps {@code Component.isShowing()} through queue
     */
    public boolean isShowing() {
        return (runMapping(new MapBooleanAction("isShowing") {
            @Override
            public boolean map() {
                return getSource().isShowing();
            }
        }));
    }

    /**
     * Maps {@code Component.isValid()} through queue
     */
    public boolean isValid() {
        return (runMapping(new MapBooleanAction("isValid") {
            @Override
            public boolean map() {
                return getSource().isValid();
            }
        }));
    }

    /**
     * Maps {@code Component.isVisible()} through queue
     */
    public boolean isVisible() {
        return (runMapping(new MapBooleanAction("isVisible") {
            @Override
            public boolean map() {
                return getSource().isVisible();
            }
        }));
    }

    /**
     * Maps {@code Component.list()} through queue
     */
    public void list() {
        runMapping(new MapVoidAction("list") {
            @Override
            public void map() {
                getSource().list();
            }
        });
    }

    /**
     * Maps {@code Component.list(PrintStream)} through queue
     */
    public void list(final PrintStream printStream) {
        runMapping(new MapVoidAction("list") {
            @Override
            public void map() {
                getSource().list(printStream);
            }
        });
    }

    /**
     * Maps {@code Component.list(PrintStream, int)} through queue
     */
    public void list(final PrintStream printStream, final int i) {
        runMapping(new MapVoidAction("list") {
            @Override
            public void map() {
                getSource().list(printStream, i);
            }
        });
    }

    /**
     * Maps {@code Component.list(PrintWriter)} through queue
     */
    public void list(final PrintWriter printWriter) {
        runMapping(new MapVoidAction("list") {
            @Override
            public void map() {
                getSource().list(printWriter);
            }
        });
    }

    /**
     * Maps {@code Component.list(PrintWriter, int)} through queue
     */
    public void list(final PrintWriter printWriter, final int i) {
        runMapping(new MapVoidAction("list") {
            @Override
            public void map() {
                getSource().list(printWriter, i);
            }
        });
    }

    /**
     * Maps {@code Component.paint(Graphics)} through queue
     */
    public void paint(final Graphics graphics) {
        runMapping(new MapVoidAction("paint") {
            @Override
            public void map() {
                getSource().paint(graphics);
            }
        });
    }

    /**
     * Maps {@code Component.paintAll(Graphics)} through queue
     */
    public void paintAll(final Graphics graphics) {
        runMapping(new MapVoidAction("paintAll") {
            @Override
            public void map() {
                getSource().paintAll(graphics);
            }
        });
    }

    /**
     * Maps {@code Component.prepareImage(Image, int, int, ImageObserver)}
     * through queue
     */
    public boolean prepareImage(final Image image, final int i, final int i1, final ImageObserver imageObserver) {
        return (runMapping(new MapBooleanAction("prepareImage") {
            @Override
            public boolean map() {
                return getSource().prepareImage(image, i, i1, imageObserver);
            }
        }));
    }

    /**
     * Maps {@code Component.prepareImage(Image, ImageObserver)} through queue
     */
    public boolean prepareImage(final Image image, final ImageObserver imageObserver) {
        return (runMapping(new MapBooleanAction("prepareImage") {
            @Override
            public boolean map() {
                return getSource().prepareImage(image, imageObserver);
            }
        }));
    }

    /**
     * Maps {@code Component.print(Graphics)} through queue
     */
    public void print(final Graphics graphics) {
        runMapping(new MapVoidAction("print") {
            @Override
            public void map() {
                getSource().print(graphics);
            }
        });
    }

    /**
     * Maps {@code Component.printAll(Graphics)} through queue
     */
    public void printAll(final Graphics graphics) {
        runMapping(new MapVoidAction("printAll") {
            @Override
            public void map() {
                getSource().printAll(graphics);
            }
        });
    }

    /**
     * Maps {@code Component.remove(MenuComponent)} through queue
     */
    public void remove(final MenuComponent menuComponent) {
        runMapping(new MapVoidAction("remove") {
            @Override
            public void map() {
                getSource().remove(menuComponent);
            }
        });
    }

    /**
     * Maps {@code Component.removeComponentListener(ComponentListener)}
     * through queue
     */
    public void removeComponentListener(final ComponentListener componentListener) {
        runMapping(new MapVoidAction("removeComponentListener") {
            @Override
            public void map() {
                getSource().removeComponentListener(componentListener);
            }
        });
    }

    /**
     * Maps {@code Component.removeFocusListener(FocusListener)} through queue
     */
    public void removeFocusListener(final FocusListener focusListener) {
        runMapping(new MapVoidAction("removeFocusListener") {
            @Override
            public void map() {
                getSource().removeFocusListener(focusListener);
            }
        });
    }

    /**
     * Maps
     * {@code Component.removeInputMethodListener(InputMethodListener)}
     * through queue
     */
    public void removeInputMethodListener(final InputMethodListener inputMethodListener) {
        runMapping(new MapVoidAction("removeInputMethodListener") {
            @Override
            public void map() {
                getSource().removeInputMethodListener(inputMethodListener);
            }
        });
    }

    /**
     * Maps {@code Component.removeKeyListener(KeyListener)} through queue
     */
    public void removeKeyListener(final KeyListener keyListener) {
        runMapping(new MapVoidAction("removeKeyListener") {
            @Override
            public void map() {
                getSource().removeKeyListener(keyListener);
            }
        });
    }

    /**
     * Maps {@code Component.removeMouseListener(MouseListener)} through queue
     */
    public void removeMouseListener(final MouseListener mouseListener) {
        runMapping(new MapVoidAction("removeMouseListener") {
            @Override
            public void map() {
                getSource().removeMouseListener(mouseListener);
            }
        });
    }

    /**
     * Maps
     * {@code Component.removeMouseMotionListener(MouseMotionListener)}
     * through queue
     */
    public void removeMouseMotionListener(final MouseMotionListener mouseMotionListener) {
        runMapping(new MapVoidAction("removeMouseMotionListener") {
            @Override
            public void map() {
                getSource().removeMouseMotionListener(mouseMotionListener);
            }
        });
    }

    /**
     * Maps {@code Component.removeNotify()} through queue
     */
    public void removeNotify() {
        runMapping(new MapVoidAction("removeNotify") {
            @Override
            public void map() {
                getSource().removeNotify();
            }
        });
    }

    /**
     * Maps
     * {@code Component.removePropertyChangeListener(PropertyChangeListener)}
     * through queue
     */
    public void removePropertyChangeListener(final PropertyChangeListener propertyChangeListener) {
        runMapping(new MapVoidAction("removePropertyChangeListener") {
            @Override
            public void map() {
                getSource().removePropertyChangeListener(propertyChangeListener);
            }
        });
    }

    /**
     * Maps
     * {@code Component.removePropertyChangeListener(String, PropertyChangeListener)}
     * through queue
     */
    public void removePropertyChangeListener(final String string, final PropertyChangeListener propertyChangeListener) {
        runMapping(new MapVoidAction("removePropertyChangeListener") {
            @Override
            public void map() {
                getSource().removePropertyChangeListener(string, propertyChangeListener);
            }
        });
    }

    /**
     * Maps {@code Component.repaint()} through queue
     */
    public void repaint() {
        runMapping(new MapVoidAction("repaint") {
            @Override
            public void map() {
                getSource().repaint();
            }
        });
    }

    /**
     * Maps {@code Component.repaint(int, int, int, int)} through queue
     */
    public void repaint(final int i, final int i1, final int i2, final int i3) {
        runMapping(new MapVoidAction("repaint") {
            @Override
            public void map() {
                getSource().repaint(i, i1, i2, i3);
            }
        });
    }

    /**
     * Maps {@code Component.repaint(long)} through queue
     */
    public void repaint(final long l) {
        runMapping(new MapVoidAction("repaint") {
            @Override
            public void map() {
                getSource().repaint(l);
            }
        });
    }

    /**
     * Maps {@code Component.repaint(long, int, int, int, int)} through queue
     */
    public void repaint(final long l, final int i, final int i1, final int i2, final int i3) {
        runMapping(new MapVoidAction("repaint") {
            @Override
            public void map() {
                getSource().repaint(l, i, i1, i2, i3);
            }
        });
    }

    /**
     * Maps {@code Component.requestFocus()} through queue
     */
    public void requestFocus() {
        runMapping(new MapVoidAction("requestFocus") {
            @Override
            public void map() {
                getSource().requestFocus();
            }
        });
    }

    /**
     * Maps {@code Component.setBackground(Color)} through queue
     */
    public void setBackground(final Color color) {
        runMapping(new MapVoidAction("setBackground") {
            @Override
            public void map() {
                getSource().setBackground(color);
            }
        });
    }

    /**
     * Maps {@code Component.setBounds(int, int, int, int)} through queue
     */
    public void setBounds(final int i, final int i1, final int i2, final int i3) {
        runMapping(new MapVoidAction("setBounds") {
            @Override
            public void map() {
                getSource().setBounds(i, i1, i2, i3);
            }
        });
    }

    /**
     * Maps {@code Component.setBounds(Rectangle)} through queue
     */
    public void setBounds(final Rectangle rectangle) {
        runMapping(new MapVoidAction("setBounds") {
            @Override
            public void map() {
                getSource().setBounds(rectangle);
            }
        });
    }

    /**
     * Maps {@code Component.setComponentOrientation(ComponentOrientation)}
     * through queue
     */
    public void setComponentOrientation(final ComponentOrientation componentOrientation) {
        runMapping(new MapVoidAction("setComponentOrientation") {
            @Override
            public void map() {
                getSource().setComponentOrientation(componentOrientation);
            }
        });
    }

    /**
     * Maps {@code Component.setCursor(Cursor)} through queue
     */
    public void setCursor(final Cursor cursor) {
        runMapping(new MapVoidAction("setCursor") {
            @Override
            public void map() {
                getSource().setCursor(cursor);
            }
        });
    }

    /**
     * Maps {@code Component.setDropTarget(DropTarget)} through queue
     */
    public void setDropTarget(final DropTarget dropTarget) {
        runMapping(new MapVoidAction("setDropTarget") {
            @Override
            public void map() {
                getSource().setDropTarget(dropTarget);
            }
        });
    }

    /**
     * Maps {@code Component.setEnabled(boolean)} through queue
     */
    public void setEnabled(final boolean b) {
        runMapping(new MapVoidAction("setEnabled") {
            @Override
            public void map() {
                getSource().setEnabled(b);
            }
        });
    }

    /**
     * Maps {@code Component.setFont(Font)} through queue
     */
    public void setFont(final Font font) {
        runMapping(new MapVoidAction("setFont") {
            @Override
            public void map() {
                getSource().setFont(font);
            }
        });
    }

    /**
     * Maps {@code Component.setForeground(Color)} through queue
     */
    public void setForeground(final Color color) {
        runMapping(new MapVoidAction("setForeground") {
            @Override
            public void map() {
                getSource().setForeground(color);
            }
        });
    }

    /**
     * Maps {@code Component.setLocale(Locale)} through queue
     */
    public void setLocale(final Locale locale) {
        runMapping(new MapVoidAction("setLocale") {
            @Override
            public void map() {
                getSource().setLocale(locale);
            }
        });
    }

    /**
     * Maps {@code Component.setLocation(int, int)} through queue
     */
    public void setLocation(final int i, final int i1) {
        runMapping(new MapVoidAction("setLocation") {
            @Override
            public void map() {
                getSource().setLocation(i, i1);
            }
        });
    }

    /**
     * Maps {@code Component.setLocation(Point)} through queue
     */
    public void setLocation(final Point point) {
        runMapping(new MapVoidAction("setLocation") {
            @Override
            public void map() {
                getSource().setLocation(point);
            }
        });
    }

    /**
     * Maps {@code Component.setName(String)} through queue
     */
    public void setName(final String string) {
        runMapping(new MapVoidAction("setName") {
            @Override
            public void map() {
                getSource().setName(string);
            }
        });
    }

    /**
     * Maps {@code Component.setSize(int, int)} through queue
     */
    public void setSize(final int i, final int i1) {
        runMapping(new MapVoidAction("setSize") {
            @Override
            public void map() {
                getSource().setSize(i, i1);
            }
        });
    }

    /**
     * Maps {@code Component.setSize(Dimension)} through queue
     */
    public void setSize(final Dimension dimension) {
        runMapping(new MapVoidAction("setSize") {
            @Override
            public void map() {
                getSource().setSize(dimension);
            }
        });
    }

    /**
     * Maps {@code Component.setVisible(boolean)} through queue
     */
    public void setVisible(final boolean b) {
        runMapping(new MapVoidAction("setVisible") {
            @Override
            public void map() {
                getSource().setVisible(b);
            }
        });
    }

    /**
     * Maps {@code Component.transferFocus()} through queue
     */
    public void transferFocus() {
        runMapping(new MapVoidAction("transferFocus") {
            @Override
            public void map() {
                getSource().transferFocus();
            }
        });
    }

    /**
     * Maps {@code Component.update(Graphics)} through queue
     */
    public void update(final Graphics graphics) {
        runMapping(new MapVoidAction("update") {
            @Override
            public void map() {
                getSource().update(graphics);
            }
        });
    }

    /**
     * Maps {@code Component.validate()} through queue
     */
    public void validate() {
        runMapping(new MapVoidAction("validate") {
            @Override
            public void map() {
                getSource().validate();
            }
        });
    }

    //End of mapping                                      //
    ////////////////////////////////////////////////////////
    private void setEventDispatcher(EventDispatcher dispatcher) {
        dispatcher.setOutput(getOutput().createErrorOutput());
        dispatcher.setTimeouts(getTimeouts());
        this.dispatcher = dispatcher;
    }

    static class VisibleComponentFinder implements ComponentChooser {

        ComponentChooser subFinder;

        public VisibleComponentFinder(ComponentChooser sf) {
            subFinder = sf;
        }

        @Override
        public boolean checkComponent(Component comp) {
            if (comp.isShowing()) {
                return subFinder.checkComponent(comp);
            }
            return false;
        }

        @Override
        public String getDescription() {
            return subFinder.getDescription();
        }

        @Override
        public String toString() {
            return "VisibleComponentFinder{" + "subFinder=" + subFinder + '}';
        }
    }

}