public Robot() throws AWTException 
{
                                                                        
        if (GraphicsEnvironment.isHeadless()) {
            throw new AWTException("headless environment");
        }
        init(GraphicsEnvironment.getLocalGraphicsEnvironment()
            .getDefaultScreenDevice());
}

Constructs a Robot object in the coordinate system of the primary screen.

Throws:

AWTException - if the platform configuration does not allow low-level input control. This exception is always thrown when GraphicsEnvironment.isHeadless() returns true

SecurityException - if createRobot permission is not granted

Also see:

java.awt.GraphicsEnvironment#isHeadless
SecurityManager#checkPermission
AWTPermission

 public Robot(GraphicsDevice screen) throws AWTException 
{
        checkIsScreenDevice(screen);
        init(screen);
}

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:
• share the same coordinate system to form a combined virtual screen
• use different coordinate systems to act as independent screens
This constructor is meant for the latter case.

If screen devices are reconfigured such that the coordinate system is affected, the behavior of existing Robot objects is undefined.

Parameters:

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.

IllegalArgumentException - if screen is not a screen GraphicsDevice.

SecurityException - if createRobot permission is not granted

Also see:

java.awt.GraphicsEnvironment#isHeadless
GraphicsDevice
SecurityManager#checkPermission
AWTPermission

 public synchronized BufferedImage createScreenCapture(Rectangle screenRect) 
{
        checkScreenCaptureAllowed();
        // according to the spec, screenRect is relative to robot's GD
        Rectangle translatedRect = new Rectangle(screenRect);
        translatedRect.translate(gdLoc.x, gdLoc.y);
        checkValidRect(translatedRect);
        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);
        }
        int pixels[];
        int[] bandmasks = new int[3];
        pixels = peer.getRGBPixels(translatedRect);
        buffer = new DataBufferInt(pixels, pixels.length);
        bandmasks[0] = screenCapCM.getRedMask();
        bandmasks[1] = screenCapCM.getGreenMask();
        bandmasks[2] = screenCapCM.getBlueMask();
        raster = Raster.createPackedRaster(buffer, translatedRect.width, translatedRect.height, translatedRect.width, bandmasks, null);
        image = new BufferedImage(screenCapCM, raster, false, null);
        return image;
}

Creates an image containing pixels read from the screen. This image does not include the mouse cursor.

 public synchronized  void delay(int ms) 
{
        checkDelayArgument(ms);
        try {
            Thread.sleep(ms);
        } catch(InterruptedException ite) {
            ite.printStackTrace();
        }
}

Sleeps for the specified time. To catch any InterruptedExceptions that occur, Thread.sleep() may be used instead.

 public synchronized int getAutoDelay() 
{
        return autoDelay;
}

Returns the number of milliseconds this Robot sleeps after generating an event.

 public synchronized Color getPixelColor(int x,
    int y) 
{
        Color color = new Color(peer.getRGBPixel(gdLoc.x + x, gdLoc.y + y));
        return color;
}

Returns the color of a pixel at the given screen coordinates.

 public synchronized boolean isAutoWaitForIdle() 
{
        return isAutoWaitForIdle;
}

Returns whether this Robot automatically invokes waitForIdle after generating an event.

 public synchronized  void keyPress(int keycode) 
{
        checkKeycodeArgument(keycode);
        peer.keyPress(keycode);
        afterEvent();
}

Presses a given key. The key should be released using the keyRelease method.

Key codes that have more than one physical key associated with them (e.g. KeyEvent.VK_SHIFT could mean either the left or right shift key) will map to the left key.

 public synchronized  void keyRelease(int keycode) 
{
        checkKeycodeArgument(keycode);
        peer.keyRelease(keycode);
        afterEvent();
}

Releases a given key.

Key codes that have more than one physical key associated with them (e.g. KeyEvent.VK_SHIFT could mean either the left or right shift key) will map to the left key.

 public synchronized  void mouseMove(int x,
    int y) 
{
        peer.mouseMove(gdLoc.x + x, gdLoc.y + y);
        afterEvent();
}

Moves mouse pointer to given screen coordinates.

 public synchronized  void mousePress(int buttons) 
{
        checkButtonsArgument(buttons);
        peer.mousePress(buttons);
        afterEvent();
}

Presses one or more mouse buttons. The mouse buttons should be released using the mouseRelease method.

 public synchronized  void mouseRelease(int buttons) 
{
        checkButtonsArgument(buttons);
        peer.mouseRelease(buttons);
        afterEvent();
}

Releases one or more mouse buttons.

 public synchronized  void mouseWheel(int wheelAmt) 
{
        peer.mouseWheel(wheelAmt);
        afterEvent();
}

Rotates the scroll wheel on wheel-equipped mice.

 public synchronized  void setAutoDelay(int ms) 
{
        checkDelayArgument(ms);
        autoDelay = ms;
}

Sets the number of milliseconds this Robot sleeps after generating an event.

 public synchronized  void setAutoWaitForIdle(boolean isOn) 
{
        isAutoWaitForIdle = isOn;
}

Sets whether this Robot automatically invokes waitForIdle after generating an event.

 public synchronized String toString() 
{
        String params = "autoDelay = "+getAutoDelay()+", "+"autoWaitForIdle = "+isAutoWaitForIdle();
        return getClass().getName() + "[ " + params + " ]";
}

Returns a string representation of this Robot.

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

Waits until all events currently on the event queue have been processed.