package abbot.editor;

 import java.awt.*;

 import java.awt.event.*;

 import java.io.*;

 import java.lang.reflect.*;

 import java.net.URL;

 import java.util.*;

 import java.util.List;

 import javax.swing.*;

 import javax.swing.filechooser.FileFilter;

 import javax.swing.event.*;

 import junit.extensions.abbot.*;

 import junit.runner.TestCollector;

 import abbot.BugReport;

 import abbot.Log;

 import abbot.ExitException;

 import abbot.NoExitSecurityManager;

 import abbot.AssertionFailedError;

 import abbot.Platform;

 import abbot.editor.actions.*;

 import abbot.editor.editors.*;

 import abbot.editor.recorder.*;

 import abbot.editor.widgets.*;

 import abbot.editor.widgets.TextField;

 import abbot.finder.*;

 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.*;

 import abbot.util.Properties;

 import abbot.util.ThreadTerminatingSecurityManager.ThreadTerminatedException;

 import com.apple.mrj.*;

 /**

  * This is the 'model' behind the script editor UI.<p>

  *

  * Acts as a resolver, using the currently in-context script as the component

  * resolver. <p>

  */

 /* To add new actions, add the action to the list in initActions(),

  * and optionally add it to the menu layout in initMenus.  Define a name for

  * it in EditorConstants, and an inner Action class for it which uses that

  * name. 

  */

 // Apologies for the extreme cruftiness and lack of proper factoring.  This

 // was written at the same time as the underlying framework, and refactored

 // (sort of) into model/view at the same time, so it's hardly a shining

 // example of clean design.  Don't know if it would have been any better

 // written TDD, though.

     implements ActionListener, Resolver, EditorConstants {

     private static int selectKey;

     private static int captureKey;

     private static int captureImageKey;

     static {

         }

         catch(Exception e) {

             // Ignore for now

         }

     }

     // if set, log all events, even those going to filtered components

     private static final boolean LOG_ALL_EVENTS =

         Boolean.getBoolean("abbot.editor.log_all_events");

     private static final long FIXTURE_EVENT_MASK =

         Long.getLong("abbot.fixture.event_mask", 

                     EventRecorder.RECORDING_EVENT_MASK).longValue();

     /** Key to use to invert an assertion/wait. */

     public static final int KC_INVERT = KeyEvent.VK_SHIFT;

     /** Key to use to insert a wait instead of an assertion.   Use option key

         on mac, control key anywhere else. */

     public static final int KC_WAIT =

     /** Flag for informational status. */

     private static final int INFO = 0;

     /** Flag to indicate a warning. */

     private static final int WARN = 1;

     /** Flag to indicate an error. */

     private static final int ERROR = 2;

     /** Flag to indicate a script failure. */

     private static final int FAILURE = 3;

     /** Prefixes for different types of status messages. */

     private static final String[] statusFormat =

         { "Normal", "Warning", "Error", "Failure" };

     private static final Color[] statusColor = {

         Color.black,

         Color.orange.darker(),

         Color.red,

         Color.red,

     };

     private ArrayList insertActions = new ArrayList();

     private ArrayList assertActions = new ArrayList();

     private ArrayList waitActions = new ArrayList();

     private ArrayList captureActions = new ArrayList();

     /** Adapter for representing the script itself, providing access to

      * individual script steps.

      */

     private ScriptModel scriptModel;

     private ScriptTable scriptTable;

     private EditorSecurityManager securityManager;

     private SecurityManager oldSecurityManager;

     private int nonce;

     /** Keep all application under test threads in the same group to make them

      * easier to track. */

     private ThreadGroup appGroup;

     private TestHierarchy hierarchy;

     private Hierarchy oldHierarchy;

     private Recorder[] recorders;

     private java.util.List savedStateWhileRecording;

     /** Allow exits from anywhere until the editor is fully initialized. */

     private boolean rootIsExiting = true;

     private boolean exiting;

     private boolean hiding;

     private boolean ignoreStepEvents;

     /** Whether to ignore incoming AWT events. */

     private boolean ignoreEvents;

     /** Is there a script or launch step currently running? */

     private boolean isScriptRunning;

     /** When was some portion of the app exercised? */

     private long lastLaunchTime;

     /** Are we trying to capture an image? */

     private boolean capturingImage;

     /** What component is currently "selected" for capture? */

     private Component captureComponent;

     private Component innermostCaptureComponent;

     private Highlighter highlighter;

     /** Is this the first editor launched, or one under test? */

     private boolean isRootEditor = true;

     /** AWT input state. */

     private static InputState state = Robot.getState();

     /** Generic filter to select a test script. */

     private ScriptFilter filter = new ScriptFilter();

     /** Current test case class (should derive from AWTTestCase). */

     private Class testClass;

     /** Current test suite.  */

     private ScriptTestSuite testSuite;

     /** Current test script. */

     private Script testScript;

     /** Is the current script a temporary placeholder? */

     private File tempFile;

     /** Runner used to execute the script. */

     private StepRunner runner;

     /** Current set of scripts, based on the test suite (if any). */

     private List testScriptList;

     /** Currently selected component.  Note that this may be a dummy

      * component.

      */

     private Component selectedComponent;

     /** Currently selected reference, if any. */

     private ComponentReference selectedReference;

     /** Are we currently recording events? */

     private boolean recording;

     /** The current recorder to pass events for capture. */

     private Recorder recorder;

     /** Since recorder starts with a key release, and stops with a key press,

         make sure we don't start immediately after stopping.

     */

     private boolean justStoppedRecording;

     /** Need to be able to set the combo box selection w/o reacting to the

      * resulting posted action.

      */

     private boolean ignoreComboBox;

     /** Where to stop. */

     private Step stopStep;

     // GUI components

     private JFileChooser chooser;

     private ScriptEditorFrame view;

     private ComboBoxModel model;

     private boolean invertAssertions;

     private boolean waitAssertions;

     private ActionMap actionMap;

     private String name;

     /**

      * Constructs a ScriptEditor which handles script editing logic.

      * ScriptEditorFrame provides the view/controller.

      * @see ScriptEditorFrame

      */

         }

         else {

         }

         // TODO: clean this up

         // Clear the status only if there were no errors

         }

     }

     /** Provides a convenient menu setup definition.

         Use a defined action name to indicate that action's place within the

         menu.  Null values indicate menu separators.

      */

             MENU_FILE,

             ACTION_SCRIPT_NEW,

             ACTION_SCRIPT_DUPLICATE,

             ACTION_SCRIPT_OPEN,

             null,

             ACTION_SCRIPT_SAVE,

             ACTION_SCRIPT_SAVE_AS,

             ACTION_SCRIPT_RENAME,

             ACTION_SCRIPT_CLOSE,

             null,

             ACTION_SCRIPT_DELETE,

         }));

         }

             ACTION_EDITOR_USERGUIDE,

             ACTION_EDITOR_WEBSITE,

             ACTION_EDITOR_EMAIL,

             ACTION_EDITOR_BUGREPORT,

         }));

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

             {

                 MENU_EDIT,

                 ACTION_STEP_CUT,

                 null,

                 ACTION_STEP_MOVE_UP,

                 ACTION_STEP_MOVE_DOWN,

                 ACTION_STEP_GROUP,

                 null,

                 ACTION_SELECT_COMPONENT,

                 null,

                 ACTION_SCRIPT_CLEAR,

             },

             {

                 MENU_TEST,

                 ACTION_RUN,

                 ACTION_RUN_TO,

                 ACTION_RUN_SELECTED,

                 null,

                 ACTION_EXPORT_HIERARCHY,

                 null,

                 ACTION_RUN_LAUNCH,

                 ACTION_RUN_TERMINATE,

                 null,

                 ACTION_TOGGLE_STOP_ON_FAILURE,

                 ACTION_TOGGLE_STOP_ON_ERROR,

                 ACTION_TOGGLE_FORKED,

                 ACTION_GET_VMARGS,

                 ACTION_TOGGLE_SLOW_PLAYBACK,

                 ACTION_TOGGLE_AWT_MODE,

             },

             {

                 MENU_INSERT,

                 ACTION_INSERT_ANNOTATION,

                 ACTION_INSERT_APPLET,

                 ACTION_INSERT_CALL,

                 ACTION_INSERT_COMMENT,

                 ACTION_INSERT_EXPRESSION,

                 ACTION_INSERT_LAUNCH,

                 ACTION_INSERT_FIXTURE,

                 ACTION_INSERT_SAMPLE,

                 ACTION_INSERT_SCRIPT,

                 ACTION_INSERT_SEQUENCE,

                 ACTION_INSERT_TERMINATE,

             },

             {

                 MENU_CAPTURE,

             },

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

         };

     }

     // All editor actions should be defined here

             new EditorAboutAction(),

             new EditorEmailAction(),

             new EditorBugReportAction(),

             new EditorWebsiteAction(),

             new EditorUserGuideAction(),

             new EditorQuitAction(),

             new ScriptOpenAction(),

             new ScriptNewAction(),

             new ScriptDuplicateAction(),

             new ScriptSaveAction(),

             new ScriptSaveAsAction(),

             new ScriptRenameAction(),

             new ScriptCloseAction(),

             new ScriptDeleteAction(),

             new ScriptClearAction(),

             new StepCutAction(),

             new StepMoveUpAction(),

             new StepMoveDownAction(),

             new StepGroupAction(),

             new RunAction(),

             new RunToAction(),

             new RunSelectedAction(),

             new RunLaunchAction(),

             new RunTerminateAction(),

             new GetVMArgsAction(),

             new SelectTestSuiteAction(),

             new ExportHierarchyAction(),

             new ToggleForkedAction(),

             new InsertLaunchAction(),

             new InsertFixtureAction(),

             new InsertAppletAction(),

             new InsertTerminateAction(),

             new InsertCallAction(),

             new InsertSampleAction(),

             new InsertSequenceAction(),

             new InsertScriptAction(),

             new InsertCommentAction(),

             new InsertExpressionAction(),

             new InsertAnnotationAction(),

             new ToggleStopOnFailureAction(),

             new ToggleStopOnErrorAction(),

             new ToggleSlowPlaybackAction(),

             new ToggleAWTModeAction(),

             new CaptureImageAction(),

             new CaptureComponentAction(),

             new SelectComponentAction(),

         };

         }

     }

     /**

      *  Add event handlers to their respective components

      */

             addListSelectionListener(new ScriptTableSelectionHandler());

                 }

             }

         });

                 }                                                              

             }                                                                  

         };

             }

         });

             // Mac has it's own dedicated Quit/About menu items

                 }

             });

                 }

             });

         }

     }