package abbot.tester;

 import java.applet.Applet;

 import java.awt.*;

 import java.awt.event.*;

 import java.awt.geom.Rectangle2D;

 import java.awt.image.BufferedImage;

 import java.lang.reflect.InvocationTargetException;

 import java.util.Collection;

 import java.util.Iterator;

 import javax.accessibility.AccessibleAction;

 import javax.swing.*;

 import abbot.*;

 import abbot.finder.*;

 import abbot.finder.ComponentFinder;

 import abbot.finder.matchers.*;

 import abbot.i18n.Strings;

 import abbot.script.*;

 import abbot.util.*;

 /** Provide a higher level of abstraction for user input (A Better Robot).

     The Robot's operation may be affected by the following properties:<br>

     <pre><code>abbot.robot.auto_delay</code></pre><br>

     Set this to a value representing the millisecond count in between

     generated events.  Usually just set to 100-200 if you want to slow down

     the playback to simulate actual user input.  The default is zero delay.<br>

     <pre><code>abbot.robot.mode</code></pre><br>

     Set this to either "robot" or "awt" to designate the desired mode of event

     generation.  "robot" uses java.awt.Robot to generate events, while "awt"

     stuffs events directly into the AWT event queue.<br>

     <pre><code>abbot.robot.event_post_delay</code></pre><br>

     This is the maximum number of ms it takes the system to post an AWT event

     in response to a Robot-generated event.

     <pre><code>abbot.robot.default_delay</code></pre><br>

     Base delay setting, acts as default value for the next two.

     <pre><code>abbot.robot.popup_delay</code></pre><br>

     Set this to the maximum time to wait for a menu to appear or be generated.

     <pre><code>abbot.robot.component_delay</code></pre><br>

     Set this to the maximum time to wait for a Component to become available.

     <p>

     NOTE: Only use event queue synchronization (e.g.

     {@link #invokeAndWait(Runnable)} or {@link #waitForIdle()} when a

     subsequent robot-level action is being applied to the results of a prior

     action (e.g. focus, deiconify, menu selection).  Otherwise, don't

     introduce a mandatory delay (e.g. use {@link #invokeLater(Runnable)}). 

     <p>

     NOTE: If a robot action isn't reproduced properly, you may need to

     introduce either additional events or extra delay.  Adding enforced delay

     for a given platform is usually preferable to generating additional events,

     so always try that first, but be sure to restrict it to the platform in 

     question.

     <p>

     NOTE: Robot actions should <b>never</b> be invoked on the event dispatch

     thread. 

  */

     /** Use java.awt.Robot to generate events. */

     public static int EM_ROBOT = 0;

     /** Post events to the AWT event queue. */

     public static int EM_AWT   = 1;

     private static final Toolkit toolkit = Toolkit.getDefaultToolkit();

     // Max robot delay, in ms

     private static final int MAX_DELAY = 60000;

     // TODO: verify this value for X11, etc.; ALT for w32, option for OSX

     public static final int MOUSELESS_MODIFIER_MASK = InputEvent.ALT_MASK;

     public static final String MOUSELESS_MODIFIER =

         AWT.getKeyModifiers(MOUSELESS_MODIFIER_MASK);

     /** OS X using screenMenuBar actually uses an AWT menu as the live

         component.  The JXXX components exist, but are not effectively

         active. 

     */

         // Ideally we'd install a menu and check where it ended up, since the

         // property is read once at startup and ignored thereafter.

             && (Boolean.getBoolean("com.apple.macos.useScreenMenuBar")

                 || Boolean.getBoolean("apple.laf.useScreenMenuBar"));

     }

     /** Base delay setting. */

     public static int defaultDelay =

         Properties.getProperty("abbot.robot.default_delay", 30000, 0, 60000);

     /** Delay before checking for idle.  This allows the system a little time

         to put a native event onto the AWT event queue. */

     private static int eventPostDelay =

         Properties.getProperty("abbot.robot.event_post_delay", 100, 0, 1000);

     protected static long IDLE_TIMEOUT =

         Integer.getInteger("abbot.robot.idle_timeout", 10000).intValue();

     /** Delay before failing to find a popup menu that should appear. */

     protected static int popupDelay =

         Properties.getProperty("abbot.robot.popup_delay",

                                defaultDelay, 0, 60000);

     /** Delay before failing to find a component that should be visible. */

     public static int componentDelay =

         Properties.getProperty("abbot.robot.component_delay",

                                defaultDelay, 0, 60000);

     /** With decreased robot auto delay, OSX popup menus don't activate

      * properly.  Indicate the minimum delay for proper operation (determined

      * experimentally). 

      */

     /** How events are generated. */

     private static int eventMode = EM_ROBOT;

     private static boolean verified = false;

     private static boolean serviceMode = false;

     // FIXME add one per graphics device?

     /** The robot used to generate events. */

     private static java.awt.Robot robot;

     private static WindowTracker tracker;

     /** Current input state.  This will either be that of the AWT event queue

      * or of the robot, depending on the dispatch mode. 

      * Note that the robot state may be different from that seen by the AWT

      * event queue, since robot events may be as yet unprocessed.

      */

     private static InputState state;

     /** Suitable inter-event delay for most cases; tests have been run safely

      * at this value.  Should definitely be less than the double-click

      * threshold.<p>  

     */

     private static final int DEFAULT_DELAY = getPreferredRobotAutoDelay();

     private static final int SLEEP_INTERVAL = 10;

     private static int autoDelay = DEFAULT_DELAY;

     /** Returns a functioning instance of java.awt.Robot. If this method

      * returns null, it should be assumed that java.awt.Robot is unavailable

      * or non-functional on the current system.  

      */

     }

     /** Return a singleton InputState object. */

     }

     static {

     }

                                            autoDelay, -1, 60000);

             // Even if the robot doesn't work, we can still use it for some

             // things. 

             }

             else {

             }

                     equals(System.getProperty("abbot.robot.verify"));

                     // robot doesn't work (w32 service mode)

                                        + "falling back to AWT mode");

                 }

             }

         }

         catch(AWTException e) {

             // no robot available, send AWT events

                                + e.getMessage());

         }

         }

     }

     /** Returns the current event-generation mode. */

     }

     /** Set the event-generation mode.

         @throws IllegalStateException if the requested mode is EM_ROBOT and

         java.awt.Robot is unavailable in the current environment.

      */

             }

         }

     }

     }

     /** Allow this to be adjusted, mostly for testing. */

     }

     /** 

      * Move the mouse to the given location, in screen coordinates.  

      * NOTE: in robot mode, you may need to invoke this with a little jitter.

      * There are some conditions where a single mouse move will not

      * generate the necessary enter event on a component (typically a

      * dialog with an OK button) before a mousePress.  See also click().

      * NOTE: does 1.4+ need jitter?

      */

         }

         else {

             // Can't stuff an AWT event for an arbitrary location

         }

     }

     /** Send a button press event. */

             // OSX 1.4.1 accidentally swaps mb2 and mb3; fix it here

         }

         else {

             }

         }

     }

     /** Send a button release event for button 1. */

     }

     /** Send a button release event. */

         }

         else {

                 ? state.getDragSource()

                    ? lastMousePress.getComponent()

                    : state.getMouseComponent());

             }

                 }

             }

         }

     }

     /** Move keyboard focus to the given component.  Note that the component

         may not yet have focus when this method returns.

     */

     }

     /** Use an explicit listener, since hasFocus is not always reliable. */

         public volatile boolean focused = false;

         }

         }

         }

     }

     /** Move keyboard focus to the given component. */

         }

         // for pointer focus

         // Make sure the correct window is in front

             ? AWT.getWindow(currentOwner) : null;

         }

         // NOTE: while it would be nice to have a robot method instead of

         // requesting focus, clicking to change focus may have 

         // side effects 

             }

         });

                             Strings.get("tester.Robot.focus_failed",

                                         new Object[] { toString(comp) });

                     }

                 }

             }

         }

         finally {

         }

     }

     /** Usually only needed when dealing with Applets. */

     }

     /** Post a runnable on the given component's event queue.  Useful when

         driving multiple Applets, but is also useful to ensure an operation

         happens on the event dispatch thread.

     */

     }

     /** Post a runnable on the given component's event queue and wait for it

         to finish.  */

     }

     /** @deprecated Method renamed to {@link #invokeLater(Runnable)}

      * @param action

      */

     }

     /** @deprecated Method renamed to {@link #invokeLater(Component, Runnable)}

      * @param c

      * @param action

      */

     }

     /** Run the given action on the event dispatch thread.  This should be

      * used for any non-read-only methods invoked directly on a GUI

      * component. 

      * NOTE: if you want to use the results of the action, use invokeAndWait

      * instead. 

      */

     }

     /** Run the given action on the event dispatch thread, but don't return

         until it's been run.

     */

     }

     }

     /** Send a key press event. */

         }

         else {

                          keycode, KeyEvent.CHAR_UNDEFINED);

             // Auto-generate KEY_TYPED events, as best we can

             }

                              KeyEvent.VK_UNDEFINED, keyChar);

             }

         }

     }

     /** Send a key release event. */

                 // OSX, empirical

                 }

             }

         }

         else {

                          keycode, KeyEvent.CHAR_UNDEFINED);

         }

     }

                                       System.currentTimeMillis(),

                                       modifiers, keycode, ch));

         }

         else {

         }

     }

     /** Sleep for a little bit, measured in UI time. */

     }

     /** Sleep the given duration of ms. */

             }

         }

         else {

         }

     }

     private static final Runnable EMPTY_RUNNABLE =

     /** Check for a blocked event queue (symptomatic of an active w32 AWT

      * popup menu). 

      * @return whether the event queue is blocked.  

      */

                                    toolkit, 200);

     }

     /** @return whether we timed out waiting for the invocation to run */

                                           long timeout) {

                                              lock, true));

                 // NOTE: on fast linux systems when showing a dialog, if we

                 // don't provide a timeout, we're never notified, and the

                 // test will wait forever (up through 1.5.0_05).

             }

             catch(InterruptedException e) {

             }

         }

     }

         // NOTE: as of Java 1.3.1, robot.waitForIdle only waits for the

         // last event on the queue at the time of this invocation to be

         // processed.  We need better than that.  Make sure the given event

         // queue is empty when this method returns

         // We always post at least one idle event to allow any current event

         // dispatch processing to finish.

                          + IDLE_TIMEOUT + "ms (after " + count + " events)",

                          Log.FULL_STACK);

             }

                          + count + " events");

             }

             // NOTE: this does not detect invocation events (i.e. what

             // gets posted with EventQueue.invokeLater), so if someone

             // is repeatedly posting one, we might get stuck.  Not too

             // worried, since if a Runnable keeps calling invokeLater

             // on itself, *nothing* else gets much chance to run, so it

             // seems to be a bad programming practice.

     }

     /**

      * Wait for an idle AWT event queue.  Note that this is different from

      * the implementation of <code>java.awt.Robot.waitForIdle()</code>, which

      * may have events on the queue when it returns.  Do <b>NOT</b> use this

      * method if there are animations or other continual refreshes happening,

      * since in that case it may never return.<p>

      */

         }

         }

         else {

             // FIXME this resurrects dead event queues

             }

         }

     }

     /** Sample the color at the given point on the screen. */

         // Service mode always returns black when sampled

     }

     /** Sample the color at the given point on the component. */

     }

     /** Capture the contents of the given rectangle. */

     /* NOTE: Text components (and maybe others with a custom cursor) will

      * capture the cursor.  May want to move the cursor out of the component

      * bounds, although this might cause issues where the component is

      * responding visually to mouse movement. 

      * Is this an OSX bug?

      */

     }

     /** Capture the contents of the given component, sans any border or

      * insets.  This should only be used on components that do not use a LAF

      * UI, or the results will not be consistent across platforms.

      */ 

     }

     /** Capture the contents of the given component, optionally including the

      * border and/or insets.  This should only be used on components that do

      * not use a LAF UI, or the results will not be consistent across

      * platforms. 

      */ 

         // Make sure we don't sample the decorating space

         }

     }

     // Bug workaround support

     }

     // Bug workaround support

     }

     /** Move the pointer to the center of the given component. */

     }

     /** Wait the given number of ms for the component to be showing and

         ready.  Returns false if the operation times out. */

                     // wiggle the mouse over the parent menu item to

                     // ensure the submenu shows

                                invoker.getHeight()/2);

                     }

                 }

                              + " (" + Integer.toHexString(c.hashCode()) + ")"

                              + " not ready after " + delay + "ms: "

                              + "showing=" + c.isShowing()

                              + " win ready="

                              + tracker.isWindowReady(AWT.getWindow(c)));

                 }

             }

         }

     }

     /** If a component does not have mouse events enabled, use the

         first ancestor which does.

     */

                && !AWT.eventTypeEnabled(comp, id)) {

                       + " not interested");

                                                 comp.getParent());

         }

     }

     /** Move the pointer to the given coordinates relative to the given

      * component.

      */ 

                 + toString(comp);

         }

                 }

             }

             catch(java.awt.IllegalComponentStateException e) {

             }

         }

         else {

             // When dragging, the event source is always the target of the

             // original mouse press.

             }

             else {

                     || x >= comp.getWidth() || y >= comp.getHeight();

             }

                         SwingUtilities.convertPoint(comp, x, y, current);

                 }

                                 new Point(x, y));

             }

                 // Drag coordinates are relative to drag source component

             }

             // Add an exit event if warranted

                                 new Point(x, y));

             }

         }

     }

     /** Move the mouse appropriately to get from the source to the

         destination.  Enter/exit events will be generated where appropriate.

     */

     }

     /** Begin a drag operation using button 1.<p>

         This method is tuned for native drag/drop operations, so if you get

         odd behavior, you might try using a simple

         {@link #mousePress(Component,int,int)} instead. 

     */

     }

     /** Begin a drag operation using the given button mask.<p>

         This method is tuned for native drag/drop operations, so if you get

         odd behavior, you might try using a simple

         {@link #mousePress(Component,int,int,int)} instead. 

     */

     // TODO: maybe auto-switch to robot mode if available?

             && eventMode != EM_ROBOT

             && !Boolean.getBoolean("abbot.ignore_drag_error")) {

                 // If we start a native drag in this mode, it'll pretty much

                 // lock up the system, apparently with the native AWT libs

                 // starting a thread invisible to the VM that chews up all CPU

                 // time. 

             }

         }

         // Some platforms require a pause between mouse down and mouse motion

             Properties.getProperty("abbot.robot.drag_delay",

                                    ? 100 : 0, 0,

                                    60000);

                 ? AWTConstants.DRAG_THRESHOLD : 0;

                 ? AWTConstants.DRAG_THRESHOLD : 0;

         }

         else {

         }

     }

     /** End a drag operation, releasing the mouse button over the given target

         location.<p>

         This method is tuned for native drag/drop operations, so if you get

         odd behavior, you might try using a simple

         {@link #mouseMove(Component,int,int)}, {@link #mouseRelease()}

         instead.  

     */

         // Delay between final move and drop to ensure drop ends.

             Properties.getProperty("abbot.robot.drop_delay",

         // All motion events are relative to the drag source

             }

         }

     }

     /** Generate a mouse enter/exit/move/drag for the destination component.

      * NOTE: The VM automatically usually generates exit events; need a test

      * to define the behavior, though.

      */

         // The VM auto-generates exit events as needed (1.3, 1.4)

         // Avoid multiple moves to the same location

             || !to.equals(state.getMouseLocation())) {

                                           state.getModifiers(), to.x, to.y,

                                           state.getClickCount(), false));

         }

     }

     /** Type the given keycode with no modifiers. */

     }

     /** Press or release the appropriate modifiers corresponding to the given

         mask.

     */

         }

         else {

             // For consistency, release in the reverse order of press

         }

     }

     /** Type the given keycode with the given modifiers.  Modifiers is a mask

      * from the available InputEvent masks.

      */

     }

                   + " mod=" + AWT.getKeyModifiers(modifiers));

         }

         }

     }

     /**

      * Type the given character.  Note that this sends the key to whatever

      * component currently has the focus.

      */

     // FIXME should this be renamed to "key"?

             // If no mapping is available, we omit press/release events and

             // only generate a KEY_TYPED event

                          Log.FULL_STACK);

             }

                                        System.currentTimeMillis(),

                                        0, KeyEvent.VK_UNDEFINED, ch);

             // Allow any pending robot events to complete; otherwise we

             // might stuff the typed event before previous robot-generated

             // events are posted.

         }

         else {

                       + keycode + " mod=" + mod);

         }

     }

     /** Type the given string. */

         }

     }

     }

     }

     }

     /** Mouse down in the given part of the component.  All other mousePress

         methods must eventually invoke this one.

     */

         }

         else {

         }

     }

     /** Post a mouse press event to the AWT event queue for the given

         component.

     */

             ? lastMousePress.getWhen() : 0;

             && comp == lastMousePress.getComponent()) {

             }

         }

                                        state.getKeyModifiers() | mask,

                                        where.x, where.y, count,

                                        AWTConstants.POPUP_ON_PRESS

                                        && (mask & AWTConstants.POPUP_MASK) != 0));

     }

     /** Post a mouse release event to the AWT event queue for the given

         component.

     */

                                     state.getKeyModifiers() | mask,

                                     where.x, where.y, count,

                                     !AWTConstants.POPUP_ON_PRESS

                                     && (mask & AWTConstants.POPUP_MASK) != 0));

     }

     /** Click in the center of the given component. */

     }

     /** Click in the center of the given component, specifying which button. */

     }

     /** Click in the component at the given location. */

     }

     /** Click in the component at the given location with the given button. */

     }

     /** Click in the given part of the component.  All other click methods

      * must eventually invoke this one.  This method sometimes needs to be

      * redefined (i.e. JComponent to scroll before clicking).

      */

         // Adjust the auto-delay to ensure we actually get a multiple click

         // In general clicks have to be less than 200ms apart, although the

         // actual setting is not readable by java that I'm aware of.

         }

         }

     }

     /** @deprecated Renamed to {@link #selectAWTMenuItem(Frame,String)}. */

     }

     /** Select the given menu item from the given Frame.  The given String may

         be either a label or path of labels, but must uniquely identify the

         menu item.  For example, "Copy" would be valid if there is only one

         instance of that menu label under the MenuBar, otherwise you would

         need to specify "Edit|Copy" to ensure the proper selection. 

         Note that this method doesn't require referencing the MenuComponent

         directly as a parameter. 

      */

                                      new Object[] { toString(frame) });

         }

                                      new Object[] { path, toString(frame) });

         }

         }

     }

     /** @deprecated Renamed to

         {@link #selectAWTPopupMenuItem(Component,String)}.