package abbot.editor.recorder;

 import java.awt.*;

 import java.awt.event.*;

 import java.text.*;

 import java.util.*;

 import javax.swing.*;

 import javax.swing.text.JTextComponent;

 import abbot.BugReport;

 import abbot.Log;

 import abbot.Platform;

 import abbot.finder.*;

 import abbot.finder.matchers.WindowMatcher;

 import abbot.i18n.Strings;

 import abbot.script.*;

 import abbot.script.Action;

 import abbot.script.Resolver;

 import abbot.tester.*;

 import abbot.tester.Robot;

 import abbot.util.AWT;

 /**

  * Record basic semantic events you might find on any component.  This class

  * handles the following actions:<p>

  * <ul>

  * <li>window actions

  * <li>popup menus

  * <li>click 

  * <li>typed keys

  * <li>basic drag and drop

  * <li>InputMethod events (extended character input)

  * </ul>

  * Clicks, popup menus, and drag/drop actions may be based on coordinates or

  * component substructure (cell, row, tab, etc) locations.

  *

  * <h3>Window Actions</h3>

  * While these nominally might be handled in a WindowRecorder, they are so

  * common that it's easier to handle here instead.  Currently supports

  * tracking show/hide/activate.  TODO: move/resize/iconfify/deiconify.

  * <h3>Popup Menus</h3>

  * Currently only the click/select/click sequence is supported.  The

  * press/drag/release version shouldn't be hard to implement, though.

  * <h3>Click</h3>

  * Simple press/release on a component, storing the exact coordinate of the

  * click.  Most things with selectability will want to override this.  Culling

  * accidental intervening drags would be nice but probably not worth the

  * effort or complexity (better just to be less sloppy with your mouse).

  * <h3>Key Type</h3>

  * Capture only events that result in actual output.  No plain modifiers,

  * shortcuts, or mnemonics.

  * <h3>Drag/Drop</h3>

  * Basic drag from one component and drop on another, storing exact

  * coordinates of the press/release actions.  Should definitely override this

  * to represent your component's internal objects (e.g. cells in a table).

  * Note that these are two distinct actions, even though they always appear

  * together.  The source is responsible for identifying the drag, and the

  * target is responsible for identifying the drop.

  * <h3>InputMethod</h3>

  * Catch extended character input.

  */

 // NOTE: Mac OSX robot will actually generate key modifiers prior

 // to  button2/3 

 // NOTE: Mac OSX CTRL/ALT+MB1 invokes MB2

 // CTRL+MB1->CTRL+MB2

 // ALT+MB1->MB2

     // TODO: test recorders by sending an event stream; test platform stream

     // by generating robot events and verifying stream seen; this splits the

     // tests into separate concerns.

     private static final String[] TYPES = {

         "any", "window", "menu", "click", "key",

         "drag", "drop", "text", "input method"

     };

     /** Mappings for special keys. */

     private static java.util.HashMap specialMap;

     static {

         // Make explicit some special key mappings which we DON'T want to save

         // as the resulting characters (b/c they may not actually be

         // characters, or they're not particularly good to save as

         // characters. 

             { '\t', KeyEvent.VK_TAB },

             { '', KeyEvent.VK_ESCAPE }, // No escape sequence exists

             { '\b', KeyEvent.VK_BACK_SPACE },

             { '', KeyEvent.VK_DELETE }, // No escape sequence exists

             { '\n', KeyEvent.VK_ENTER },

             { '\r', KeyEvent.VK_ENTER },

         };

                            AWT.getKeyCode(mappings[i][1]));

         }

     }

     // For windows

     private Window window = null;

     private boolean isClose = false;

     // For key events

     private char keychar = KeyEvent.CHAR_UNDEFINED;

     private int modifiers;

     // For clicks

     private Component target;

     private Component forwardedTarget;

     private int x, y;

     private boolean released;

     private int clickCount;

     // For menu events

     private Component invoker;

     private int menux, menuy;

     private MenuItem awtMenuTarget;

     private Component menuTarget;

     private boolean isPopup;

     private boolean hasAWTPopup;

     private MenuListener menuListener;

     private boolean menuCanceled;

     // For drag events

     // This class is responsible for handling drag/drop once the action has

     // been recognized by a derived class

     private Component dragSource;

     private int dragx, dragy;

     // For drop events

     private Component dropTarget;

     private int dropx, dropy;

     private boolean nativeDrag;

     // InputMethod

     private ArrayList imKeyCodes = new ArrayList();

     private StringBuffer imText = new StringBuffer();

     /** Keep a short-term memory of windows we've seen open/close already. */

     private static WeakHashMap closeEventWindows = new WeakHashMap();

     private static WeakHashMap openEventWindows = new WeakHashMap();

     /** Create a ComponentRecorder for use in capturing the semantics of a GUI

      * action.

      */ 

     }

     /** Does the given event indicate a window was shown? */

         // 1.3 VMs may generate a WINDOW_OPEN without a COMPONENT_SHOWN

         // (see EventRecorderTest.testClickWithDialog)

         // NOTE: COMPONENT_SHOWN precedes WINDOW_OPENED, but we don't really

         // care in this case, since we're just recording the event, not

         // watching for the component's validity.

               && !openEventWindows.containsKey(event.getSource()))

              || id == ComponentEvent.COMPONENT_SHOWN)) {

         }

     }

     /** Does the given event indicate a window was closed? */

         // Window.dispose doesn't generate a HIDDEN event, but it does

         // generate a WINDOW_CLOSED event (1.3/1.4)

               && !closeEventWindows.containsKey(event.getSource()))

              || id == ComponentEvent.COMPONENT_HIDDEN)) {

         }

     }

     /** Returns whether this ComponentRecorder wishes to accept the given

      * event.  If the event is accepted, the recorder must invoke init() with

      * the appropriate semantic event type.

      */

         }

         }

         }

         }

         }

         }

         else {

         }

     }

     /** Test whether the given event is a trigger for a window event. 

      * Allow derived classes to change definition of a click.

      */

         // Ignore activate and deactivate.  They are unreliable.

         // We only want open/close events on non-tooltip and non-popup windows

             && !AWT.isHeavyweightPopup((Window)event.getSource())

             && !isToolTip(event.getSource())

             && (isClose(event) || isOpen(event));

     }

     /**

      * Return true if the given event source is a tooltip.

      * Such events look like window events, but we check for them before other

      * kinds of window events so as to be able to filter them out.

      * <P>

      * TODO: emit steps to confirm value of tooltip?

      * <P>

      * @param source the object to examine

      * @return true if this event source is a tooltip

      */

         // Tooltips appear to be a direct subclass of JWindow and

         // have a single component of class JToolTip

             }

         }

     }

             && event.getSource() instanceof java.awt.MenuItem) {

         }

                 || ((me.getModifiers() & AWTConstants.POPUP_MASK) != 0)

                 || me.getSource() instanceof JMenu;

         }

     }

     }

     /** Test whether the given event is a trigger for a mouse button click.

      * Allow derived classes to change definition of a click.

      */ 

         }

     }

     /** Test whether the given event precurses a drop. */

     }

     /** Default to recording a drag if it looks like one. */

     // FIXME may be some better detection, like checking for DND interfaces. */

     }

     /** Default to waiting for multiple clicks. */

     }

     /** Is this the start of an input method event? */

         // NOTE: HALF_WIDTH signals start of kanji input

         // NOTE: Mac uses input method for some dual-keystroke chars (option-e)

                 && ((KeyEvent)event).getKeyCode() == KeyEvent.VK_HALF_WIDTH)

             || event.getID() == InputMethodEvent.INPUT_METHOD_TEXT_CHANGED;

     }

     /** Provide standard parsing of mouse button events. */

                 // Add the component immediately, just in case it gets removed

                 // from the hierarchy as a result of the click.

             }

             else {

                 }

                     // It's possible to get two consecutive MOUSE_PRESSED

                     // events for different targets (e.g. double click on a

                     // table cell to get the default editor) (OSX 1.3.1, XP

                     // 1.4.1_01). Ignore the second click, since it is

                     // artificial, and wait for the original click to finish.

                     // i.e. w32 1.3.1

                     // MOUSE_PRESSED  JTable

                     // MOUSE_PRESSED  JTextField

                     // FOCUS_LOST     JTable

                     // FOCUS_GAINED   JTextField

                     // MOUSE_EXITED   JTable

                     // MOUSE_ENTERED  JTextField

                     // MOUSE_RELEASED JTable

                     // MOUSE_RELEASED JTextField

                 }

             }

         }

             // Optionally disallow multiple clicks

         }

             // optionally wait for multiple clicks

         }

             }

                 // May not see any DRAGGED events if it's a native drag;

                 // 1.3 posts MOUSE_EXITED after MOUSE_PRESSED, no drag events

                                            (MouseEvent)event);

                 }

             }

         }

                 // nothing

             }

             }

         }

                 || Math.abs(me.getY() - y) >= AWTConstants.DRAG_THRESHOLD) {

                 // Was actually a drag; pass off to drag handler

             }

             else {

             }

         }

         // These events will not prevent a multi-click from being registered.

                    && id <= ComponentEvent.COMPONENT_LAST)

                  || (event instanceof ContainerEvent)

                  || (event instanceof FocusEvent)  

                  || (id == HierarchyEvent.HIERARCHY_CHANGED 

                      && (((HierarchyEvent)event).getChangeFlags()

                          & HierarchyEvent.SHOWING_CHANGED) == 0)) {

             // Ignore most hierarchy change and component events between

             // clicks. 

             // The focus event is sporadic on w32 1.4.1_02

         }

         else {

             // All other events should cause the click to finish,

             // but don't register a click unless we've received the release

             // event. 

             }

         }

     }

         // Keep track of window open/close state so we don't parse the same

         // semantic event twice (e.g. COMPONENT_SHOWN + WINDOW_OPENED or

         // multiple WINDOW_CLOSED events).

         }

         else {

         }

     }

                           + keychar + "'");

             }

             else {

                 // Ignore KEY_TYPED input for control and alt modifiers, since

                 // the generated characters are not accepted as text input.

                 // Add others if you encounter them, but err on the side of

                 // accepting input that can later be removed.

                     || (modifiers & InputEvent.ALT_MASK) == InputEvent.ALT_MASK) {

                 }

             }

         }

             // Ignore and wait for FOCUS_GAINED

         }

             // Looks like a focus accelerator focus change.  Ignore the

             // KEY_TYPED event.

             }

             }

             else {

             }

         }

         else {

         }

     }

     /** Base implementation handles context (popup) menus. */

         // press, release, show, [move, show,] press, release

         // press, [drag, show,] release (FIXME not done)

         // ACTION_PERFORMED and ITEM_STATE_CHANGED are only 

         // produced by AWT components (wxp/1.4.2)

             || id == ItemEvent.ITEM_STATE_CHANGED) {

             // If there is no invoker, the selection came from the MenuBar

             }

                       + Robot.toString(invoker));

             }

             else {

                 // ItemEvent doesn't report modifiers, so ask use internal

                 // tracking to see if any modifiers are active.

             }

         }

             // On the first press, we haven't yet set the invoker, which

             // is either a JMenu or the component holding the popup.

                 // Must add the listener now, b/c on w32 release/click events

                 // are not generated until *after* the awt popup selection.

                 }

                 // It's possible for a popup menu to be triggered by some

                 // other event (e.g. a button click).  Assume that action is

                 // already recorded and simply make note of the appropriate

                 // menu selection.

                     && !(invoker instanceof JMenu)) {

                 }

             }

                 // ignore

             }

                 // Click to select the menu item; this will be the second

                 // press event received

             }

             else {

                 // Mouse press in something other than the menu, assume it was

                 // canceled. 

                 // Popup was canceled.  Discard subsequent release/click.

             }

         }

             // The menu target won't be set until the second mouse press

             }

                 // This is the first mouse release

                 }

             }

             else {

             }

         }

             // If it was a popup trigger, make sure there was a popup,

             // otherwise record it as a click.

             // Note that we won't likely get any events with an AWT popup, so

             // just assume it was invoked if there is one.

                 && AWT.findActivePopupMenu() == null) {

             }

         }

         else {

         }

     }

     // TODO: set up test to generate several different drag types, then sample

     // the event streams on different platforms:

     // drag from one component to another

     // drag within a component

         // Use enter/exit events to determine what the final destination

         // is, since drag events always use the drag source for the component. 

             // If we don't have a target yet, default to the drag source

             }

             // origin is always the drag source

                 || Math.abs(p.y - me.getY()) > AWTConstants.DRAG_THRESHOLD) {

             }

         }

             // This seems to be the canonical exit from a drag/drop

             // Observed on: w32 1.4.2 JTree, JTable, JLabel drops

             // I'd much rather see a MOUSE_RELEASED when the drag completes. 

         }

         }

             // If a true drag is in effect (as of 1.4+), we will see no java

             // event queue events until this one (on w32, anyway).

             // If it's 1.3, we won't get any events, even after the drag

             // completes. 

                 && Platform.JAVA_VERSION >= Platform.JAVA_1_4) {

             }

         }

             // FIXME verify that the component is always the original press

             // source 

         }

         else {

         }

     }

                 // This indicates the input method start (for kanji, anyway)

                 // This indicates the input method end (for kanji, anyway)

                 // Consume other key release events, assuming there was no

                 // corresponding key press event.

             }

         }

                          ch = iter.next()) {

                     }

                 }

             }

         }

         else {

         }

     }

     /** Handle an event.  Return whether the event was consumed. */

                       + " as " + TYPES[getRecordingType()]);

         // Default handling is event consumed, and assume not finished

             // error

         }

             }

             catch(Throwable thr) {

             }

         }

     }

     /** Provide a hint about the type of the drag. */

     }

     /** Returns whether the first drag motion event should be consumed.

      * Derived classes may override this to provide custom drag behavior.

      * Default behavior saves the drag initiation event by itself.

      */

                                   int x, int y,

                                   int modifiers,

                                   MouseEvent dragEvent) {

     }

     /** Returns the script step generated from the events recorded so far. */

                      ? TYPES[getRecordingType()] : String.valueOf(type)));

                            && !(mc instanceof Component)) {

                     }

                                         + " has no Component ancestor");

                     }

                 }

             }

                                                 menuTarget);

             }

             }

             }

             else {

             }

         }

         }

         }

             else {

             }

         }

     }

     /** Create a wait for the window show/hide.  Use an appropriate identifier

         string, which might be the name, title, or component reference.

     */

                                  ComponentTester.class.getName(),

                                  method, 

                                  new String[] { ref.getID() },

                                  "true", isClose);

     }

                                null, "actionSelectMenuItem",

                                new String[] { cr.getID() });

     }

                                           boolean isPopup) {

         // Get a unique path for the MenuItem

         // Do a quick search on the invoker for other popups.  If there are

         // duplicates, include the menu item name

                                null, method,

                                new String[] { ref.getID(), path });

     }

                                             Component menuItem) {

                               null, "actionSelectPopupMenuItem",

                               new String[] { inv.getID(), where,

                                              mi.getText()

                               }, invoker.getClass());

         }

         else {

                               null, "actionSelectMenuItem",

                               new String[] { ref.getID() });

         }

     }

         // NOTE: Any keys which might have effects as key press/release should

         // be encoded as a keystroke, rather than a keystring.

         // NOTE: We encode strings rather than integer values, since the

         // names are more useful.

                 ? new String[] { cr.getID(), code,

                                  AWT.getKeyModifiers(mods) }

                 : new String[] { cr.getID(), code };

         }            

                           "actionKeyString",

                           new String[] { cr.getID(),

                                          String.valueOf(keychar) });

     }

                               null, "actionDrop", new String[] { 

                                   cr.getID(), where

                               }, comp.getClass());

         }

     }

                                null, "actionDrag", new String[] {

                                    ref.getID(), where,

                                }, comp.getClass());

     }

     /** Create a click event with the given event information. */

                                int mods, int count) {

             || count > 1) {

             // NOTE: this currently saves POPUP or TERTIARY, rather than

             // an explicit button 2 or 3.  I figure that makes more sense

             // than a hard coded button number.

             }

         }

                           (String[])args.toArray(new String[args.size()]),

                           target.getClass());

     }

                           "actionKeyString", 

                           new String[] { text });

     }

     }

     /** Invoke when end of the semantic event has been seen. */

         }

     }

         }

     }

         private ArrayList items = new ArrayList();

             }

         }

                 }

             }

         }

         }

             }

         }

     }

     /** Obtain the String representation of the Component-specific location. */

     }

     /** Obtain a more precise location than the given coordinate, if

      * possible.

      */

     }

 }