package abbot.editor.recorder;

 import java.awt.*;

 import java.awt.dnd.*;

 import java.awt.event.*;

 import java.lang.reflect.*;

 import java.text.MessageFormat;

 import java.util.*;

 import javax.swing.*;

 import abbot.*;

 import abbot.i18n.Strings;

 import abbot.script.*;

 import abbot.script.Action;

 import abbot.script.Event;

 import abbot.script.Resolver;

 import abbot.tester.Robot;

 import abbot.util.AWT;

 /** 

  * Provides recording of raw AWT events and high-level semantic events.

  * This is the main controller for any SemanticRecorder objects.

  */

 // TODO: Are there other instances (cf JInternalFrame) where we'd like this

 // recorder to be the listener to other events?

 // TODO: add internal frame listener, re-post events when heard

 // TODO: discard events on LAF pieces of internal frames

 // TODO: extract filters as plugins

 // TODO: run all semantic recorder tests through this class, using canned

 // event streams instead of robot-generated events; keep the robot-generated

 // event streams, though, to test whether the stream has changed

     extends Recorder implements SemanticEvents {

     private static final String ANY_KEY = null;

     private static final int EITHER = 0;

     private static final int PRESS = 1;

     private static final int RELEASE = 2;

     private boolean captureMotion;

     private long lastStepTime;

     ArrayList steps = new ArrayList();

     /** Put all built-in recorder classes here.  Don't worry though, 'cause if

      * it doesn't get added here it'll get found dynamically.

      */

     private static final Class[] recorderClasses = {

         AbstractButton.class,

         Component.class,

         Container.class,

         Dialog.class,

         Frame.class,

         JComboBox.class,

         JComponent.class,

         JInternalFrame.class,

         JList.class,

         JMenuItem.class,

         JTabbedPane.class,

         JTable.class,

         JTree.class,

         Window.class,

     };

     /** Create a Recorder for use in capturing raw AWTEvents.  Indicate

      * whether mouse motion should be captured, and what semantic event type

      * to capture.

      */

         // Install existing semantic recorders

         }

     }

     /** Return the name of the type of GUI action to be recorded. */

             ? Strings.get("actions.capture-all")

             : Strings.get("actions.capture");

     }

     }

                 && (type == EITHER

                     || (type == PRESS

                         && "KEY_PRESSED".equals(se.getKind()))

                     || (type == RELEASE

                         && "KEY_RELEASED".equals(se.getKind())))

                 && (code == ANY_KEY

                     || code.equals(se.getAttribute(XMLConstants.TAG_KEYCODE)));

         }

     }

             && ((Action)step).getMethodName().equals("actionKeyString");

     }

                         || (args.length > 1 && args[1].equals(keycode))

                         || (keycode.startsWith("VK_NUMPAD") 

                             && args[1].equals("VK_" + keycode.substring(9))));

             }

         }

     }

         // Remove the terminal SHIFT keypress

             }

         }

     }

     /** Eliminate redundant modifier keys surrounding keystrokes or

      * keystrings.

      */

                             }

                         }

                                  || isKeyString(next)) {

                         }

                         }

                     }

                 }

                 }

             }

         }

     }

     /** Combine multiple keystroke actions into keystring actions. */

                             args1[0], args1[1] + args2[1]

                         });

                                   + "' and '" + args2[1] + "'");

                     }

                     else {

                     }

                 }

             }

         }

     }

     /** Eliminate redundant key press/release events surrounding a keytyped

      * event.  

      */

                 // In the case of modifiers, remove only if the presence of

                 // the key down/up is redundant.

                 // OSX option modifier should be ignored, since it is used to

                 // generate input method events.

                     Platform.isOSX() && code == KeyEvent.VK_ALT;

                 // In the case of non-modifier keys, walk the steps until we

                 // find the key release, then optionally replace the key press

                 // with a keystroke, or remove it if the keystroke was already

                 // recorded.  This sorts out jumbled key press/release events.

                     // If we find the release, remove it and this

                         // Add a keystroke only if we didn't find any key

                         // input between press and release (except on OSX,

                         // where the option key generates input method events

                         // which aren't recorded). 

                                 se.getAttribute(XMLConstants.TAG_MODIFIERS);

                                  ? new String[] { target, cs }

                                  : new String[] { target, cs, mods});

                                 new Action(getResolver(), 

                                            null, "actionKeyStroke", args);

                         }

                         else {

                                       + cs + ")");

                         }

                     }

                              || isKeyString(next)) {

                         // If it's a numpad keycode, use the numpad

                         // keycode instead of the resulting numeric character

                         // keystroke. 

                         }

                     }

                 }

                 // We don't like standalone key presses

                 }

             }

         }

     }

     // Required for OS X, remove modifier keys when they're only used to

     // invoke MB2/3

     private boolean pruneButtonModifier = false;

     private int lastButton = 0;

     /** Used only on Mac OS, to remove key modifiers that are used to simulate

      * mouse buttons 2 and 3.  Returns whether the event should be ignored.

      */

                 & (MouseEvent.BUTTON2_MASK|MouseEvent.BUTTON3_MASK);

         }

                  && pruneButtonModifier) {

                  && (lastButton & MouseEvent.BUTTON2_MASK) != 0)

                 || (code == KeyEvent.VK_META 

                     && (lastButton & MouseEvent.BUTTON3_MASK) != 0)) {

                          && isKey(step, "VK_CONTROL", PRESS)

                         || (code == KeyEvent.VK_ALT

                             && isKey(step, "VK_ALT", PRESS)))

                         || (code == KeyEvent.VK_META

                             && isKey(step, "VK_META", PRESS))) {

                         // might be another one

                     }

                 }

             }

         }

     }

     /** Ignore any key presses at the end of the recording. */

                && isKey((Step)steps.get(steps.size()-1), ANY_KEY, PRESS)) {

         }

     }

     /** Remove keypress events preceding and following ActionMap actions. */

                             equals(((Action)step).getMethodName())) {

                         }

                     }

                         }

                     }

                 }

             }

         }

     }

     /** Insert an arbitrary script step into the currently recorded stream. */