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 {

             }