588 lines
22 KiB
588 lines
22 KiB
/*
|
|
* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.awt;
|
|
|
|
import java.awt.event.InputEvent;
|
|
import java.awt.event.KeyEvent;
|
|
import java.awt.image.BufferedImage;
|
|
import java.awt.image.DataBufferInt;
|
|
import java.awt.image.DirectColorModel;
|
|
import java.awt.image.Raster;
|
|
import java.awt.image.WritableRaster;
|
|
import java.awt.peer.RobotPeer;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import sun.awt.ComponentFactory;
|
|
import sun.awt.SunToolkit;
|
|
import sun.awt.image.SunWritableRaster;
|
|
import sun.security.util.SecurityConstants;
|
|
|
|
/**
|
|
* This class is used to generate native system input events
|
|
* for the purposes of test automation, self-running demos, and
|
|
* other applications where control of the mouse and keyboard
|
|
* is needed. The primary purpose of Robot is to facilitate
|
|
* automated testing of Java platform implementations.
|
|
* <p>
|
|
* Using the class to generate input events differs from posting
|
|
* events to the AWT event queue or AWT components in that the
|
|
* events are generated in the platform's native input
|
|
* queue. For example, <code>Robot.mouseMove</code> will actually move
|
|
* the mouse cursor instead of just generating mouse move events.
|
|
* <p>
|
|
* Note that some platforms require special privileges or extensions
|
|
* to access low-level input control. If the current platform configuration
|
|
* does not allow input control, an <code>AWTException</code> will be thrown
|
|
* when trying to construct Robot objects. For example, X-Window systems
|
|
* will throw the exception if the XTEST 2.2 standard extension is not supported
|
|
* (or not enabled) by the X server.
|
|
* <p>
|
|
* Applications that use Robot for purposes other than self-testing should
|
|
* handle these error conditions gracefully.
|
|
*
|
|
* @author Robi Khan
|
|
* @since 1.3
|
|
*/
|
|
public class Robot {
|
|
private static final int MAX_DELAY = 60000;
|
|
private RobotPeer peer;
|
|
private boolean isAutoWaitForIdle = false;
|
|
private int autoDelay = 0;
|
|
private static int LEGAL_BUTTON_MASK = 0;
|
|
|
|
private DirectColorModel screenCapCM = null;
|
|
|
|
/**
|
|
* Constructs a Robot object in the coordinate system of the primary screen.
|
|
* <p>
|
|
*
|
|
* @throws AWTException if the platform configuration does not allow
|
|
* low-level input control. This exception is always thrown when
|
|
* GraphicsEnvironment.isHeadless() returns true
|
|
* @throws SecurityException if <code>createRobot</code> permission is not granted
|
|
* @see java.awt.GraphicsEnvironment#isHeadless
|
|
* @see SecurityManager#checkPermission
|
|
* @see AWTPermission
|
|
*/
|
|
public Robot() throws AWTException {
|
|
if (GraphicsEnvironment.isHeadless()) {
|
|
throw new AWTException("headless environment");
|
|
}
|
|
init(GraphicsEnvironment.getLocalGraphicsEnvironment()
|
|
.getDefaultScreenDevice());
|
|
}
|
|
|
|
/**
|
|
* Creates a Robot for the given screen device. Coordinates passed
|
|
* to Robot method calls like mouseMove and createScreenCapture will
|
|
* be interpreted as being in the same coordinate system as the
|
|
* specified screen. Note that depending on the platform configuration,
|
|
* multiple screens may either:
|
|
* <ul>
|
|
* <li>share the same coordinate system to form a combined virtual screen</li>
|
|
* <li>use different coordinate systems to act as independent screens</li>
|
|
* </ul>
|
|
* This constructor is meant for the latter case.
|
|
* <p>
|
|
* If screen devices are reconfigured such that the coordinate system is
|
|
* affected, the behavior of existing Robot objects is undefined.
|
|
*
|
|
* @param screen A screen GraphicsDevice indicating the coordinate
|
|
* system the Robot will operate in.
|
|
* @throws AWTException if the platform configuration does not allow
|
|
* low-level input control. This exception is always thrown when
|
|
* GraphicsEnvironment.isHeadless() returns true.
|
|
* @throws IllegalArgumentException if <code>screen</code> is not a screen
|
|
* GraphicsDevice.
|
|
* @throws SecurityException if <code>createRobot</code> permission is not granted
|
|
* @see java.awt.GraphicsEnvironment#isHeadless
|
|
* @see GraphicsDevice
|
|
* @see SecurityManager#checkPermission
|
|
* @see AWTPermission
|
|
*/
|
|
public Robot(GraphicsDevice screen) throws AWTException {
|
|
checkIsScreenDevice(screen);
|
|
init(screen);
|
|
}
|
|
|
|
private void init(GraphicsDevice screen) throws AWTException {
|
|
checkRobotAllowed();
|
|
Toolkit toolkit = Toolkit.getDefaultToolkit();
|
|
if (toolkit instanceof ComponentFactory) {
|
|
peer = ((ComponentFactory)toolkit).createRobot(this, screen);
|
|
disposer = new RobotDisposer(peer);
|
|
sun.java2d.Disposer.addRecord(anchor, disposer);
|
|
}
|
|
initLegalButtonMask();
|
|
}
|
|
|
|
private static synchronized void initLegalButtonMask() {
|
|
if (LEGAL_BUTTON_MASK != 0) return;
|
|
|
|
int tmpMask = 0;
|
|
if (Toolkit.getDefaultToolkit().areExtraMouseButtonsEnabled()){
|
|
if (Toolkit.getDefaultToolkit() instanceof SunToolkit) {
|
|
final int buttonsNumber = ((SunToolkit)(Toolkit.getDefaultToolkit())).getNumberOfButtons();
|
|
for (int i = 0; i < buttonsNumber; i++){
|
|
tmpMask |= InputEvent.getMaskForButton(i+1);
|
|
}
|
|
}
|
|
}
|
|
tmpMask |= InputEvent.BUTTON1_MASK|
|
|
InputEvent.BUTTON2_MASK|
|
|
InputEvent.BUTTON3_MASK|
|
|
InputEvent.BUTTON1_DOWN_MASK|
|
|
InputEvent.BUTTON2_DOWN_MASK|
|
|
InputEvent.BUTTON3_DOWN_MASK;
|
|
LEGAL_BUTTON_MASK = tmpMask;
|
|
}
|
|
|
|
/* determine if the security policy allows Robot's to be created */
|
|
private void checkRobotAllowed() {
|
|
SecurityManager security = System.getSecurityManager();
|
|
if (security != null) {
|
|
security.checkPermission(SecurityConstants.AWT.CREATE_ROBOT_PERMISSION);
|
|
}
|
|
}
|
|
|
|
/* check if the given device is a screen device */
|
|
private void checkIsScreenDevice(GraphicsDevice device) {
|
|
if (device == null || device.getType() != GraphicsDevice.TYPE_RASTER_SCREEN) {
|
|
throw new IllegalArgumentException("not a valid screen device");
|
|
}
|
|
}
|
|
|
|
private transient Object anchor = new Object();
|
|
|
|
static class RobotDisposer implements sun.java2d.DisposerRecord {
|
|
private final RobotPeer peer;
|
|
public RobotDisposer(RobotPeer peer) {
|
|
this.peer = peer;
|
|
}
|
|
public void dispose() {
|
|
if (peer != null) {
|
|
peer.dispose();
|
|
}
|
|
}
|
|
}
|
|
|
|
private transient RobotDisposer disposer;
|
|
|
|
/**
|
|
* Moves mouse pointer to given screen coordinates.
|
|
* @param x X position
|
|
* @param y Y position
|
|
*/
|
|
public synchronized void mouseMove(int x, int y) {
|
|
peer.mouseMove(x, y);
|
|
afterEvent();
|
|
}
|
|
|
|
/**
|
|
* Presses one or more mouse buttons. The mouse buttons should
|
|
* be released using the {@link #mouseRelease(int)} method.
|
|
*
|
|
* @param buttons the Button mask; a combination of one or more
|
|
* mouse button masks.
|
|
* <p>
|
|
* It is allowed to use only a combination of valid values as a {@code buttons} parameter.
|
|
* A valid combination consists of {@code InputEvent.BUTTON1_DOWN_MASK},
|
|
* {@code InputEvent.BUTTON2_DOWN_MASK}, {@code InputEvent.BUTTON3_DOWN_MASK}
|
|
* and values returned by the
|
|
* {@link InputEvent#getMaskForButton(int) InputEvent.getMaskForButton(button)} method.
|
|
*
|
|
* The valid combination also depends on a
|
|
* {@link Toolkit#areExtraMouseButtonsEnabled() Toolkit.areExtraMouseButtonsEnabled()} value as follows:
|
|
* <ul>
|
|
* <li> If support for extended mouse buttons is
|
|
* {@link Toolkit#areExtraMouseButtonsEnabled() disabled} by Java
|
|
* then it is allowed to use only the following standard button masks:
|
|
* {@code InputEvent.BUTTON1_DOWN_MASK}, {@code InputEvent.BUTTON2_DOWN_MASK},
|
|
* {@code InputEvent.BUTTON3_DOWN_MASK}.
|
|
* <li> If support for extended mouse buttons is
|
|
* {@link Toolkit#areExtraMouseButtonsEnabled() enabled} by Java
|
|
* then it is allowed to use the standard button masks
|
|
* and masks for existing extended mouse buttons, if the mouse has more then three buttons.
|
|
* In that way, it is allowed to use the button masks corresponding to the buttons
|
|
* in the range from 1 to {@link java.awt.MouseInfo#getNumberOfButtons() MouseInfo.getNumberOfButtons()}.
|
|
* <br>
|
|
* It is recommended to use the {@link InputEvent#getMaskForButton(int) InputEvent.getMaskForButton(button)}
|
|
* method to obtain the mask for any mouse button by its number.
|
|
* </ul>
|
|
* <p>
|
|
* The following standard button masks are also accepted:
|
|
* <ul>
|
|
* <li>{@code InputEvent.BUTTON1_MASK}
|
|
* <li>{@code InputEvent.BUTTON2_MASK}
|
|
* <li>{@code InputEvent.BUTTON3_MASK}
|
|
* </ul>
|
|
* However, it is recommended to use {@code InputEvent.BUTTON1_DOWN_MASK},
|
|
* {@code InputEvent.BUTTON2_DOWN_MASK}, {@code InputEvent.BUTTON3_DOWN_MASK} instead.
|
|
* Either extended {@code _DOWN_MASK} or old {@code _MASK} values
|
|
* should be used, but both those models should not be mixed.
|
|
* @throws IllegalArgumentException if the {@code buttons} mask contains the mask for extra mouse button
|
|
* and support for extended mouse buttons is {@link Toolkit#areExtraMouseButtonsEnabled() disabled} by Java
|
|
* @throws IllegalArgumentException if the {@code buttons} mask contains the mask for extra mouse button
|
|
* that does not exist on the mouse and support for extended mouse buttons is {@link Toolkit#areExtraMouseButtonsEnabled() enabled} by Java
|
|
* @see #mouseRelease(int)
|
|
* @see InputEvent#getMaskForButton(int)
|
|
* @see Toolkit#areExtraMouseButtonsEnabled()
|
|
* @see java.awt.MouseInfo#getNumberOfButtons()
|
|
* @see java.awt.event.MouseEvent
|
|
*/
|
|
public synchronized void mousePress(int buttons) {
|
|
checkButtonsArgument(buttons);
|
|
peer.mousePress(buttons);
|
|
afterEvent();
|
|
}
|
|
|
|
/**
|
|
* Releases one or more mouse buttons.
|
|
*
|
|
* @param buttons the Button mask; a combination of one or more
|
|
* mouse button masks.
|
|
* <p>
|
|
* It is allowed to use only a combination of valid values as a {@code buttons} parameter.
|
|
* A valid combination consists of {@code InputEvent.BUTTON1_DOWN_MASK},
|
|
* {@code InputEvent.BUTTON2_DOWN_MASK}, {@code InputEvent.BUTTON3_DOWN_MASK}
|
|
* and values returned by the
|
|
* {@link InputEvent#getMaskForButton(int) InputEvent.getMaskForButton(button)} method.
|
|
*
|
|
* The valid combination also depends on a
|
|
* {@link Toolkit#areExtraMouseButtonsEnabled() Toolkit.areExtraMouseButtonsEnabled()} value as follows:
|
|
* <ul>
|
|
* <li> If the support for extended mouse buttons is
|
|
* {@link Toolkit#areExtraMouseButtonsEnabled() disabled} by Java
|
|
* then it is allowed to use only the following standard button masks:
|
|
* {@code InputEvent.BUTTON1_DOWN_MASK}, {@code InputEvent.BUTTON2_DOWN_MASK},
|
|
* {@code InputEvent.BUTTON3_DOWN_MASK}.
|
|
* <li> If the support for extended mouse buttons is
|
|
* {@link Toolkit#areExtraMouseButtonsEnabled() enabled} by Java
|
|
* then it is allowed to use the standard button masks
|
|
* and masks for existing extended mouse buttons, if the mouse has more then three buttons.
|
|
* In that way, it is allowed to use the button masks corresponding to the buttons
|
|
* in the range from 1 to {@link java.awt.MouseInfo#getNumberOfButtons() MouseInfo.getNumberOfButtons()}.
|
|
* <br>
|
|
* It is recommended to use the {@link InputEvent#getMaskForButton(int) InputEvent.getMaskForButton(button)}
|
|
* method to obtain the mask for any mouse button by its number.
|
|
* </ul>
|
|
* <p>
|
|
* The following standard button masks are also accepted:
|
|
* <ul>
|
|
* <li>{@code InputEvent.BUTTON1_MASK}
|
|
* <li>{@code InputEvent.BUTTON2_MASK}
|
|
* <li>{@code InputEvent.BUTTON3_MASK}
|
|
* </ul>
|
|
* However, it is recommended to use {@code InputEvent.BUTTON1_DOWN_MASK},
|
|
* {@code InputEvent.BUTTON2_DOWN_MASK}, {@code InputEvent.BUTTON3_DOWN_MASK} instead.
|
|
* Either extended {@code _DOWN_MASK} or old {@code _MASK} values
|
|
* should be used, but both those models should not be mixed.
|
|
* @throws IllegalArgumentException if the {@code buttons} mask contains the mask for extra mouse button
|
|
* and support for extended mouse buttons is {@link Toolkit#areExtraMouseButtonsEnabled() disabled} by Java
|
|
* @throws IllegalArgumentException if the {@code buttons} mask contains the mask for extra mouse button
|
|
* that does not exist on the mouse and support for extended mouse buttons is {@link Toolkit#areExtraMouseButtonsEnabled() enabled} by Java
|
|
* @see #mousePress(int)
|
|
* @see InputEvent#getMaskForButton(int)
|
|
* @see Toolkit#areExtraMouseButtonsEnabled()
|
|
* @see java.awt.MouseInfo#getNumberOfButtons()
|
|
* @see java.awt.event.MouseEvent
|
|
*/
|
|
public synchronized void mouseRelease(int buttons) {
|
|
checkButtonsArgument(buttons);
|
|
peer.mouseRelease(buttons);
|
|
afterEvent();
|
|
}
|
|
|
|
private void checkButtonsArgument(int buttons) {
|
|
if ( (buttons|LEGAL_BUTTON_MASK) != LEGAL_BUTTON_MASK ) {
|
|
throw new IllegalArgumentException("Invalid combination of button flags");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rotates the scroll wheel on wheel-equipped mice.
|
|
*
|
|
* @param wheelAmt number of "notches" to move the mouse wheel
|
|
* Negative values indicate movement up/away from the user,
|
|
* positive values indicate movement down/towards the user.
|
|
*
|
|
* @since 1.4
|
|
*/
|
|
public synchronized void mouseWheel(int wheelAmt) {
|
|
peer.mouseWheel(wheelAmt);
|
|
afterEvent();
|
|
}
|
|
|
|
/**
|
|
* Presses a given key. The key should be released using the
|
|
* <code>keyRelease</code> method.
|
|
* <p>
|
|
* Key codes that have more than one physical key associated with them
|
|
* (e.g. <code>KeyEvent.VK_SHIFT</code> could mean either the
|
|
* left or right shift key) will map to the left key.
|
|
*
|
|
* @param keycode Key to press (e.g. <code>KeyEvent.VK_A</code>)
|
|
* @throws IllegalArgumentException if <code>keycode</code> is not
|
|
* a valid key
|
|
* @see #keyRelease(int)
|
|
* @see java.awt.event.KeyEvent
|
|
*/
|
|
public synchronized void keyPress(int keycode) {
|
|
checkKeycodeArgument(keycode);
|
|
peer.keyPress(keycode);
|
|
afterEvent();
|
|
}
|
|
|
|
/**
|
|
* Releases a given key.
|
|
* <p>
|
|
* Key codes that have more than one physical key associated with them
|
|
* (e.g. <code>KeyEvent.VK_SHIFT</code> could mean either the
|
|
* left or right shift key) will map to the left key.
|
|
*
|
|
* @param keycode Key to release (e.g. <code>KeyEvent.VK_A</code>)
|
|
* @throws IllegalArgumentException if <code>keycode</code> is not a
|
|
* valid key
|
|
* @see #keyPress(int)
|
|
* @see java.awt.event.KeyEvent
|
|
*/
|
|
public synchronized void keyRelease(int keycode) {
|
|
checkKeycodeArgument(keycode);
|
|
peer.keyRelease(keycode);
|
|
afterEvent();
|
|
}
|
|
|
|
private void checkKeycodeArgument(int keycode) {
|
|
// rather than build a big table or switch statement here, we'll
|
|
// just check that the key isn't VK_UNDEFINED and assume that the
|
|
// peer implementations will throw an exception for other bogus
|
|
// values e.g. -1, 999999
|
|
if (keycode == KeyEvent.VK_UNDEFINED) {
|
|
throw new IllegalArgumentException("Invalid key code");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the color of a pixel at the given screen coordinates.
|
|
* @param x X position of pixel
|
|
* @param y Y position of pixel
|
|
* @return Color of the pixel
|
|
*/
|
|
public synchronized Color getPixelColor(int x, int y) {
|
|
checkScreenCaptureAllowed();
|
|
Color color = new Color(peer.getRGBPixel(x, y));
|
|
return color;
|
|
}
|
|
|
|
/**
|
|
* Creates an image containing pixels read from the screen. This image does
|
|
* not include the mouse cursor.
|
|
* @param screenRect Rect to capture in screen coordinates
|
|
* @return The captured image
|
|
* @throws IllegalArgumentException if <code>screenRect</code> width and height are not greater than zero
|
|
* @throws SecurityException if <code>readDisplayPixels</code> permission is not granted
|
|
* @see SecurityManager#checkPermission
|
|
* @see AWTPermission
|
|
*/
|
|
public synchronized BufferedImage createScreenCapture(Rectangle screenRect) {
|
|
checkScreenCaptureAllowed();
|
|
|
|
checkValidRect(screenRect);
|
|
|
|
BufferedImage image;
|
|
DataBufferInt buffer;
|
|
WritableRaster raster;
|
|
|
|
if (screenCapCM == null) {
|
|
/*
|
|
* Fix for 4285201
|
|
* Create a DirectColorModel equivalent to the default RGB ColorModel,
|
|
* except with no Alpha component.
|
|
*/
|
|
|
|
screenCapCM = new DirectColorModel(24,
|
|
/* red mask */ 0x00FF0000,
|
|
/* green mask */ 0x0000FF00,
|
|
/* blue mask */ 0x000000FF);
|
|
}
|
|
|
|
// need to sync the toolkit prior to grabbing the pixels since in some
|
|
// cases rendering to the screen may be delayed
|
|
Toolkit.getDefaultToolkit().sync();
|
|
|
|
int pixels[];
|
|
int[] bandmasks = new int[3];
|
|
|
|
pixels = peer.getRGBPixels(screenRect);
|
|
buffer = new DataBufferInt(pixels, pixels.length);
|
|
|
|
bandmasks[0] = screenCapCM.getRedMask();
|
|
bandmasks[1] = screenCapCM.getGreenMask();
|
|
bandmasks[2] = screenCapCM.getBlueMask();
|
|
|
|
raster = Raster.createPackedRaster(buffer, screenRect.width, screenRect.height, screenRect.width, bandmasks, null);
|
|
SunWritableRaster.makeTrackable(buffer);
|
|
|
|
image = new BufferedImage(screenCapCM, raster, false, null);
|
|
|
|
return image;
|
|
}
|
|
|
|
private static void checkValidRect(Rectangle rect) {
|
|
if (rect.width <= 0 || rect.height <= 0) {
|
|
throw new IllegalArgumentException("Rectangle width and height must be > 0");
|
|
}
|
|
}
|
|
|
|
private static void checkScreenCaptureAllowed() {
|
|
SecurityManager security = System.getSecurityManager();
|
|
if (security != null) {
|
|
security.checkPermission(
|
|
SecurityConstants.AWT.READ_DISPLAY_PIXELS_PERMISSION);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Called after an event is generated
|
|
*/
|
|
private void afterEvent() {
|
|
autoWaitForIdle();
|
|
autoDelay();
|
|
}
|
|
|
|
/**
|
|
* Returns whether this Robot automatically invokes <code>waitForIdle</code>
|
|
* after generating an event.
|
|
* @return Whether <code>waitForIdle</code> is automatically called
|
|
*/
|
|
public synchronized boolean isAutoWaitForIdle() {
|
|
return isAutoWaitForIdle;
|
|
}
|
|
|
|
/**
|
|
* Sets whether this Robot automatically invokes <code>waitForIdle</code>
|
|
* after generating an event.
|
|
* @param isOn Whether <code>waitForIdle</code> is automatically invoked
|
|
*/
|
|
public synchronized void setAutoWaitForIdle(boolean isOn) {
|
|
isAutoWaitForIdle = isOn;
|
|
}
|
|
|
|
/*
|
|
* Calls waitForIdle after every event if so desired.
|
|
*/
|
|
private void autoWaitForIdle() {
|
|
if (isAutoWaitForIdle) {
|
|
waitForIdle();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the number of milliseconds this Robot sleeps after generating an event.
|
|
*/
|
|
public synchronized int getAutoDelay() {
|
|
return autoDelay;
|
|
}
|
|
|
|
/**
|
|
* Sets the number of milliseconds this Robot sleeps after generating an event.
|
|
* @throws IllegalArgumentException If <code>ms</code> is not between 0 and 60,000 milliseconds inclusive
|
|
*/
|
|
public synchronized void setAutoDelay(int ms) {
|
|
checkDelayArgument(ms);
|
|
autoDelay = ms;
|
|
}
|
|
|
|
/*
|
|
* Automatically sleeps for the specified interval after event generated.
|
|
*/
|
|
private void autoDelay() {
|
|
delay(autoDelay);
|
|
}
|
|
|
|
/**
|
|
* Sleeps for the specified time.
|
|
* To catch any <code>InterruptedException</code>s that occur,
|
|
* <code>Thread.sleep()</code> may be used instead.
|
|
* @param ms time to sleep in milliseconds
|
|
* @throws IllegalArgumentException if <code>ms</code> is not between 0 and 60,000 milliseconds inclusive
|
|
* @see java.lang.Thread#sleep
|
|
*/
|
|
public synchronized void delay(int ms) {
|
|
checkDelayArgument(ms);
|
|
try {
|
|
Thread.sleep(ms);
|
|
} catch(InterruptedException ite) {
|
|
ite.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private void checkDelayArgument(int ms) {
|
|
if (ms < 0 || ms > MAX_DELAY) {
|
|
throw new IllegalArgumentException("Delay must be to 0 to 60,000ms");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Waits until all events currently on the event queue have been processed.
|
|
* @throws IllegalThreadStateException if called on the AWT event dispatching thread
|
|
*/
|
|
public synchronized void waitForIdle() {
|
|
checkNotDispatchThread();
|
|
// post a dummy event to the queue so we know when
|
|
// all the events before it have been processed
|
|
try {
|
|
SunToolkit.flushPendingEvents();
|
|
EventQueue.invokeAndWait( new Runnable() {
|
|
public void run() {
|
|
// dummy implementation
|
|
}
|
|
} );
|
|
} catch(InterruptedException ite) {
|
|
System.err.println("Robot.waitForIdle, non-fatal exception caught:");
|
|
ite.printStackTrace();
|
|
} catch(InvocationTargetException ine) {
|
|
System.err.println("Robot.waitForIdle, non-fatal exception caught:");
|
|
ine.printStackTrace();
|
|
}
|
|
}
|
|
|
|
private void checkNotDispatchThread() {
|
|
if (EventQueue.isDispatchThread()) {
|
|
throw new IllegalThreadStateException("Cannot call method from the event dispatcher thread");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of this Robot.
|
|
*
|
|
* @return the string representation.
|
|
*/
|
|
public synchronized String toString() {
|
|
String params = "autoDelay = "+getAutoDelay()+", "+"autoWaitForIdle = "+isAutoWaitForIdle();
|
|
return getClass().getName() + "[ " + params + " ]";
|
|
}
|
|
}
|