/*
* 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 + '}';
}
}
}