(***************************************************************************

     $RCSfile: FPEDlg.mod $
  Description: Displays and handles the main dialog for the FPE utility.

   Created by: fjc (Frank Copeland)
    $Revision: 1.9 $
      $Author: fjc $
        $Date: 1994/08/08 16:14:57 $

  Copyright © 1993-1994, Frank Copeland.
  This file is part of FPE.
  See FPE.doc for conditions of use and distribution.

  Log entries are at the end of the file.

***************************************************************************)

MODULE FPEDlg;

(*
** $C= CaseChk       $I= IndexChk  $L= LongAdr   $N- NilChk
** $P- PortableCode  $R= RangeChk  $S= StackChk  $T= TypeChk
** $V= OvflChk       $Z= ZeroVars
**
** Compiler NIL checking is replaced by ASSERTs at the appropriate places.
*)

IMPORT
  Errors, E := Exec, EU := ExecUtil, Dos, I := Intuition, ASL,
  IU := IntuiUtil, Ev := Events, ARPUtil, ASLUtil, ISup := IntuiSup,
  ISU := IntuiSupUtil, ISE := ISupEvents, Str := Strings, Data,
  Tpl := FPETpl, SD := StringDialog, TD := ToolDlg, SYS := SYSTEM;


(* ===== Dialog Window ===== *)

CONST

(* Gadget IDs *)

  ModuleID      = 0;

  FilesID       = ModuleID + 1;
  LastFilesID   = ModuleID + Data.NumFiles;

  ButtonsID     = LastFilesID + 1;
  LastButtonsID = LastFilesID + Data.NumTools;

(* Menu data indexes *)

  FPEIdx                   = 0;
    AboutItemIdx             = 1;
    QuitItemIdx              = 2;

  ProgramIdx               = 3;
    CreateDirIdx             = 4;
    OpenItemIdx              = 5;
    AddModuleItemIdx         = 6;
    RemoveModuleItemIdx      = 7;
    SaveItemIdx              = 8;

  SetupIdx                 = 9;
    LoadItemIdx              = 10;
      LoadDefaultIdx           = 11;
      LoadAltIdx               = 12;
      LoadSelectIdx            = 13;
    SaveSetupItemIdx         = 14;
      SaveDefaultIdx           = 15;
      SaveAltIdx               = 16;
      SaveSelectIdx            = 17;
    ButtonsItemIdx           = 18;
      FirstButtonsSubItemIdx   = ButtonsItemIdx + 1;
      LastButtonsSubItemIdx    = ButtonsItemIdx + Data.NumTools;
    FilesItemIdx             = LastButtonsSubItemIdx + 1;
      FirstFilesSubItemIdx     = FilesItemIdx + 1;
      LastFilesSubItemIdx      = FilesItemIdx + Data.NumFiles;

  NumMenus = LastFilesSubItemIdx + 1;

(* Menu IDs *)

  FPEID               = 0;
    AboutItemID         = 0;
    QuitItemID          = 1;

  ProgramID           = 1;
    CreateDirID         = 0;
    OpenItemID          = 1;
    AddModuleItemID     = 2;
    RemoveModuleItemID  = 3;
    SaveItemID          = 4;

  SetupID             = 2;
    LoadItemID          = 0;
      LoadDefaultID       = 0;
      LoadAltID           = 1;
      LoadSelectID        = 2;
    SaveSetupItemID     = 1;
      SaveDefaultID       = 0;
      SaveAltID           = 1;
      SaveSelectID        = 2;
    ButtonsItemID       = 2;
    FilesItemID         = 3;

VAR

  renderInfo         : ISup.RenderInfoPtr;
  newWindow          : I.NewWindow;
  window             : I.WindowPtr;
  programNameBuffer  : ARRAY Data.FileChars + 1 OF CHAR;
  template           : Tpl.Template;
  gadgetList         : ISup.GadgetList;
  menuData           : ARRAY NumMenus + 1 OF ISup.MenuData;
  menuList           : ISup.MenuList;


CONST
  WindowTitle = "FPE 1.6 (26 Jul 1994)";
  ScreenTitle = "Frank's Programming Environment";


(* ===== Dialog Handler ===== *)

TYPE

  Handler = POINTER TO HandlerRec;
  HandlerRec = RECORD (ISE.ISupPortRec) END;

CONST
  IDCMPFlags = Tpl.GadgetIDCMPFlags + {I.idcmpCloseWindow, I.idcmpMenuPick};

VAR
  setupDir  : Data.Path;
  setupFile : Data.FileName;
  handler   : Handler;

(* ===== Miscellaneous ===== *)

CONST

  OutOfMemory = "FPE : Out of memory";


(*------------------------------------------------------------------------*)
(* Local procedures *)


PROCEDURE* Cleanup ();

BEGIN (* Cleanup *)
  IF menuList # NIL   THEN ISup.base.FreeMenu (menuList) END;
  IF gadgetList # NIL THEN ISup.base.FreeGadgets (gadgetList) END;
  IF renderInfo # NIL THEN ISup.base.FreeRenderInfo (renderInfo) END;
  Tpl.Cleanup (template);
END Cleanup;


(*------------------------------------------------------------------------*)
(* ===== Dialog window procedures ===== *)


(*------------------------------------*)
PROCEDURE Init * ();

  PROCEDURE InitGadgets ();

    VAR index, result : INTEGER;

  BEGIN (* InitGadgets *)
    index := 0;
    WHILE index < Data.NumFiles DO
      template.GadgetData.g1 [index].text :=
        SYS.ADR (Data.extensions [index]);
      INC (index);
    END; (* WHILE *)

    index := 0;
    WHILE index < Data.NumTools DO
      template.GadgetData.g2 [index].text  :=
        SYS.ADR (Data.tools [index].title);
      INC (index)
    END; (* WHILE *)

    template.TextData[1].text := SYS.ADR(programNameBuffer);

    renderInfo :=
      ISup.base.GetRenderInfo (NIL, Tpl.RenderInfoFlags);
    Errors.Assert (renderInfo # NIL, "FPE : failed to get render info");

    gadgetList :=
      ISup.base.CreateGadgets
        (renderInfo, template.GadgetData.g0, 0, 0, NIL);
    Errors.Assert (gadgetList # NIL, "FPE : failed to create gadgets");
  END InitGadgets;

  PROCEDURE InitMenus ();

    CONST
      On = {}; Off = {ISup.mdDisabled};

    VAR index : INTEGER;

  BEGIN (* InitMenus *)
    menuData [FPEIdx].type := ISup.title;
    menuData [FPEIdx].flags := On;
    menuData [FPEIdx].name := SYS.ADR("FPE");

      menuData [AboutItemIdx].type := ISup.item;
      menuData [AboutItemIdx].flags := On;
      menuData [AboutItemIdx].name := SYS.ADR("About ...");

      menuData [QuitItemIdx].type := ISup.item;
      menuData [QuitItemIdx].flags := On;
      menuData [QuitItemIdx].name := SYS.ADR("Quit");
      menuData [QuitItemIdx].commandKey := SYS.ADR("Q");

    menuData [ProgramIdx].type := ISup.title;
    menuData [ProgramIdx].flags := On;
    menuData [ProgramIdx].name := SYS.ADR("Project");

      menuData [CreateDirIdx].type := ISup.item;
      menuData [CreateDirIdx].flags := On;
      menuData [CreateDirIdx].name := SYS.ADR("Create Directory ...");

      menuData [OpenItemIdx].type := ISup.item;
      menuData [OpenItemIdx].flags := On;
      menuData [OpenItemIdx].name := SYS.ADR("Select Project ...");

      menuData [AddModuleItemIdx].type := ISup.item;
      menuData [AddModuleItemIdx].flags := On;
      menuData [AddModuleItemIdx].name := SYS.ADR("Add Module ...");

      menuData [RemoveModuleItemIdx].type := ISup.item;
      menuData [RemoveModuleItemIdx].flags := On;
      menuData [RemoveModuleItemIdx].name := SYS.ADR("Remove Module ...");

      menuData [SaveItemIdx].type := ISup.item;
      menuData [SaveItemIdx].flags := On;
      menuData [SaveItemIdx].name := SYS.ADR("Save Module List");

    menuData [SetupIdx].type := ISup.title;
    menuData [SetupIdx].flags := On;
    menuData [SetupIdx].name := SYS.ADR("Setup");

      menuData [LoadItemIdx].type := ISup.item;
      menuData [LoadItemIdx].flags := On;
      menuData [LoadItemIdx].name := SYS.ADR("Load Setup");

        menuData [LoadDefaultIdx].type := ISup.subItem;
        menuData [LoadDefaultIdx].flags := On;
        menuData [LoadDefaultIdx].name := SYS.ADR ("Default Setup");

        menuData [LoadAltIdx].type := ISup.subItem;
        menuData [LoadAltIdx].flags := On;
        menuData [LoadAltIdx].name := SYS.ADR ("Alternate Setup");

        menuData [LoadSelectIdx].type := ISup.subItem;
        menuData [LoadSelectIdx].flags := On;
        menuData [LoadSelectIdx].name := SYS.ADR ("Select Setup ...");

      menuData [SaveSetupItemIdx].type := ISup.item;
      menuData [SaveSetupItemIdx].flags := On;
      menuData [SaveSetupItemIdx].name := SYS.ADR("Save Setup");

        menuData [SaveDefaultIdx].type := ISup.subItem;
        menuData [SaveDefaultIdx].flags := On;
        menuData [SaveDefaultIdx].name := SYS.ADR ("Default Setup");

        menuData [SaveAltIdx].type := ISup.subItem;
        menuData [SaveAltIdx].flags := On;
        menuData [SaveAltIdx].name := SYS.ADR ("Alternate Setup");

        menuData [SaveSelectIdx].type := ISup.subItem;
        menuData [SaveSelectIdx].flags := On;
        menuData [SaveSelectIdx].name := SYS.ADR ("Select Setup ...");

      menuData [ButtonsItemIdx].type := ISup.item;
      menuData [ButtonsItemIdx].flags := On;
      menuData [ButtonsItemIdx].name := SYS.ADR("Edit Tool Button");

        index := 0;
        WHILE index < Data.NumTools DO
          menuData [index + FirstButtonsSubItemIdx].type := ISup.subItem;
          menuData [index + FirstButtonsSubItemIdx].flags := On;
          menuData [index + FirstButtonsSubItemIdx].name := SYS.ADR (Data.tools [index].title);
          INC( index );
        END; (* WHILE *)

      menuData [FilesItemIdx].type := ISup.item;
      menuData [FilesItemIdx].flags := On;
      menuData [FilesItemIdx].name := SYS.ADR("Edit File Extension");

        index := 0;
        WHILE index < Data.NumFiles DO
          menuData [index + FirstFilesSubItemIdx].type := ISup.subItem;
          menuData [index + FirstFilesSubItemIdx].flags := On;
          menuData [index + FirstFilesSubItemIdx].name := SYS.ADR (Data.extensions [index]);
          INC( index );
        END; (* WHILE *)

    menuData [NumMenus].type := ISup.dataEnd;
  END InitMenus;

  PROCEDURE InitWindow ();

  BEGIN (* InitWindow *)
    window := NIL;
    newWindow.leftEdge   := Tpl.LeftEdge;
    newWindow.topEdge    := Tpl.TopEdge;
    newWindow.width      := Tpl.Width;
    newWindow.height     := Tpl.Height;
    newWindow.blockPen   := 1;
    newWindow.idcmpFlags := {};
    newWindow.flags      := Tpl.WindowFlags;
    newWindow.title      := SYS.ADR(WindowTitle);
    newWindow.type       := {I.wbenchScreen};
    newWindow.minWidth   := 80;   newWindow.minHeight := 30;
    newWindow.maxWidth   := 1024; newWindow.maxHeight := 1024;
  END InitWindow;

BEGIN (* Init *)
  Tpl.Init (template);
  SYS.SETCLEANUP (Cleanup);
  InitGadgets ();
  InitMenus();
  InitWindow();
END Init;


(*------------------------------------*)
PROCEDURE KillModuleList ();

  CONST
    Disable = {ISup.gdDisabled}; NoFlags = {};

  VAR ignore : LONGINT;

BEGIN (* KillModuleList *)
  ignore := ISup.base.SetGadgetAttributes
    (gadgetList, ModuleID, Disable, Disable, ISup.useCurrentValue, 0, NIL);
END KillModuleList;


(*------------------------------------*)
PROCEDURE RefreshModuleList ();

  CONST
    Disable = {ISup.gdDisabled}; NoFlags = {};

  VAR ignore : LONGINT;

BEGIN (* RefreshModuleList *)
  IF EU.ListLength (Data.moduleList) = 0 THEN
    ignore := ISup.base.SetGadgetAttributes
      ( gadgetList, ModuleID, Disable, Disable, ISup.useCurrentValue, 0,
        NIL);
  ELSE
    ignore := ISup.base.SetGadgetAttributes
      ( gadgetList, ModuleID, Disable, NoFlags, ISup.useCurrentValue,
        Data.currentModuleNo, SYS.ADR (Data.moduleList));
  END
END RefreshModuleList;


(*------------------------------------*)
PROCEDURE Display ();

  VAR index, left, top, width, height : INTEGER;

BEGIN (* Display *)
  left := window.borderLeft; top := window.borderTop;
  width := window.width - left - window.borderRight;
  height := window.height - top - window.borderBottom;
  ISup.base.ClearWindow (renderInfo, window, left, top, width, height, {});
  ISup.base.DisplayGadgets (window, gadgetList);
  ISup.base.DisplayTextsPtr
    (renderInfo, window, template.TextData, 0, 0, NIL);
  ISup.base.DisplayBordersPtr
    (renderInfo, window, template.BorderData, 0, 0);

  index := 0;
  WHILE index < Data.NumFiles DO
    ISU.SelectGadget
      (gadgetList, FilesID + index, index IN Data.currentFiles);
    INC (index)
  END; (* WHILE *)

  index := 0;
  WHILE index < Data.NumTools DO
    ISU.DisableGadget
      (gadgetList, ButtonsID + index, ~Data.tools [index].isActive);
    INC (index);
  END; (* WHILE *)
  RefreshModuleList ();
END Display;


(*------------------------------------*)
PROCEDURE * Close ();

  VAR ignore : I.WindowPtr;

BEGIN (* Close *)
  IF gadgetList # NIL THEN ignore := ISup.base.RemoveGadgets (gadgetList) END;
  IF menuList # NIL THEN ignore := ISup.base.RemoveMenu (menuList) END;
  IF window # NIL THEN ISup.base.CloseWindow (window, E.LFALSE); window := NIL END
END Close;


(*------------------------------------*)
PROCEDURE Open * ();

BEGIN (* Open *)
  window :=
    ISup.base.OpenWindow (renderInfo, newWindow, Tpl.OpenWindowFlags);
  Errors.Assert (window # NIL, "FPE - IOpenWindow() failed");
  SYS.SETCLEANUP (Close);

  I.base.SetWindowTitles
    (window, SYS.ADR (WindowTitle), SYS.ADR (ScreenTitle));

  menuList :=
    ISup.base.CreateMenuA (renderInfo, window, menuData, NIL, NIL);
  Errors.Assert (menuList # NIL, "FPE - ICreateMenu() failed");
  ISup.base.AttachMenu (window, menuList);

  Display ();
END Open;


(*------------------------------------*)
(* $D- disable copying of open arrays *)
PROCEDURE ShowMessage ( message : ARRAY OF CHAR );

BEGIN (* ShowMessage *)
  ISU.DoNotice (window, SYS.ADR("*** FPE Message ***"), message)
END ShowMessage;


(*------------------------------------*)
PROCEDURE RefreshProgramName ();

BEGIN (* RefreshProgramName *)
  programNameBuffer := "                              ";
  Str.OverWrite (programNameBuffer, Data.programName, 0);
  ISup.base.DisplayTextsPtr
    (renderInfo, window, template.TextData, 0, 0, NIL);
END RefreshProgramName;


(*------------------------------------*)
PROCEDURE RefreshWindow ();

  CONST Flags = {ISup.cwNormalColor};

BEGIN (* RefreshWindow *)
  ISup.base.RefreshGadgets (gadgetList);
  ISup.base.DisplayTextsPtr
    (renderInfo, window, template.TextData, 0, 0, NIL);
  ISup.base.DisplayBordersPtr
    (renderInfo, window, template.BorderData, 0, 0);
END RefreshWindow;


(*------------------------------------*)
PROCEDURE ResetGadgets ();

  VAR  window : I.WindowPtr;

BEGIN (* ResetGadgets *)
  window := ISup.base.RemoveGadgets (gadgetList);
  ISup.base.FreeGadgets (gadgetList);

  gadgetList :=
    ISup.base.CreateGadgets
      (renderInfo, template.GadgetData.g0, 0, 0, NIL);
  Errors.Assert (gadgetList # NIL, "FPE : failed to reset gadgets");

  Display ();
END ResetGadgets;


(*------------------------------------------------------------------------*)
(* ===== Dialog handler procedures ===== *)


(*------------------------------------*)
(* $D- disable copying of open arrays *)
PROCEDURE DoLoadProgram (program : ARRAY OF CHAR);

  VAR message : ARRAY 60 OF CHAR;

BEGIN (* DoLoadProgram *)
  ISup.base.ChangeMousePointerPtr (window, NIL, E.LFALSE);
  KillModuleList ();
  IF ~Data.LoadProgram (program) THEN
    message := "Could not find ";
    Str.Append (message, program);
    Str.Append (message, ".prg");
    ShowMessage (message);
    IF program [0] = 0X THEN
      IF ~Data.ScanModules () THEN
        ShowMessage ("Error scanning for modules");
      END; (* IF *)
    ELSE
      Data.MakeModule (program);
    END; (* IF *)
  END; (* IF *)
  RefreshProgramName ();
  RefreshModuleList ();
  ISup.base.RestoreMousePointer (window);
END DoLoadProgram;


(*------------------------------------*)
PROCEDURE (handler : Handler) HandleISup
  ( msg : I.IntuiMessagePtr)
  : INTEGER;

  VAR gadget : LONGINT; value  : LONGINT;

BEGIN (* HandleISup *)
  gadget := msg.code; value := SYS.VAL (LONGINT, msg.iAddress);
  ISup.base.ReplyMsg (msg);

  CASE gadget OF
    ModuleID :
      Data.currentModule :=
        SYS.VAL (Data.ModuleNodePtr, EU.NodeAt (Data.moduleList, value));
      Data.currentModuleNo := value
    |
    FilesID .. LastFilesID :
      IF value # 0 THEN
        INCL (Data.currentFiles, gadget - FilesID);
      ELSE
        EXCL (Data.currentFiles, gadget - FilesID);
      END
    |
    ButtonsID .. LastButtonsID :
      Data.DoTool (SHORT (gadget) - ButtonsID)
    |
  ELSE
  END; (* CASE gadget *)

  RETURN Ev.Continue;
END HandleISup;


(*------------------------------------*)
PROCEDURE* HandleClosewindow
  ( ip : Ev.IdcmpPort;
    msg : I.IntuiMessagePtr )
  : INTEGER;

BEGIN (* HandleClosewindow *)
  E.base.ReplyMsg (msg);
  RETURN Ev.StopAll;
END HandleClosewindow;


(*------------------------------------*)
PROCEDURE* HandleMenuPick
  ( ip : Ev.IdcmpPort;
    msg : I.IntuiMessagePtr )
  : INTEGER;

  VAR
    menuNumber, result : INTEGER; window : I.WindowPtr;
    menuChoice : IU.Choice;

  (*------------------------------------*)
  PROCEDURE RequestFile
    ( hail : ARRAY OF CHAR;
      VAR file, dir : ARRAY OF CHAR )
    : BOOLEAN;

  (* $D- *)
  BEGIN (* RequestFile *)
    IF ASL.base # NIL THEN
      RETURN ASLUtil.RequestFile (window, hail, file, dir)
    ELSE
      RETURN ARPUtil.RequestFile (window, hail, file, dir)
    END
  END RequestFile;

  (*------------------------------------*)
  PROCEDURE DoAbout ();

    VAR ignore : BOOLEAN;

    BEGIN (* DoAbout *)
      ignore :=
        ISup.base.AutoRequest
          ( window, SYS.ADR("About FPE"),
            "FPE 1.6 (26 Jul 1994)\\n"
            "Frank's Programming Environment\\n"
            "--oOo--\\n"
            "Copyright © 1993-1994 Frank Copeland\\n"
            "Written using Oberon-A\\n"
            "and intuisup.library\\n\\n"
            "see FPE.doc for conditions of use",
            NIL, SYS.ADR("Continue"), {}, {},
            { ISup.arBackFill, ISup.arMovePointerNeg,
              ISup.arDrawRaster, ISup.arTextCenter },
            NIL)
    END DoAbout;

  (*------------------------------------*)
  PROCEDURE DoCreateDir ();

    VAR
      strDlg : SD.StrDlg; dirName : ARRAY 32 OF CHAR;
      newDir : Dos.FileLockPtr; msg : ARRAY 60 OF CHAR;

    BEGIN (* DoCreateDir *)
      NEW (strDlg);
      IF strDlg # NIL THEN
        SD.InitStrDlg
          ( strDlg, renderInfo, "Create Directory", "Enter directory name",
            31, 31);
        dirName := "";
        IF SD.Activate (strDlg, window, dirName) THEN
          newDir := Dos.base.CreateDir (dirName);
          IF newDir # NIL THEN
            Dos.base.UnLock (newDir)
          ELSE
            msg := "Could not create directory : ";
            Str.Append (msg, dirName);
            ShowMessage (msg);
          END
        END;
        SYS.DISPOSE (strDlg)
      ELSE ShowMessage (OutOfMemory)
      END
    END DoCreateDir;

  (*------------------------------------*)
  PROCEDURE DoOpen;

    VAR tempFile : Data.FileName; tempDir : Data.Path;

    BEGIN (* DoOpen *)
      tempFile := ""; tempDir := Data.currentPath;
      IF RequestFile ("Select a project", tempFile, tempDir)
      THEN
        Data.ChangeDirectory (tempDir);
        DoLoadProgram (tempFile)
      END;
    END DoOpen;

  (*------------------------------------*)
  PROCEDURE DoSave ();

    VAR msg : ARRAY 60 OF CHAR;

    BEGIN (* DoSave *)
      ISup.base.ChangeMousePointerPtr (window, NIL, E.LFALSE);
      IF ~Data.SaveProgram() THEN
        msg := "Could not save ";
        Str.Append (msg, Data.programName);
        Str.Append (msg, ".prg");
        ShowMessage (msg);
      END; (* IF *)
      ISup.base.RestoreMousePointer (window);
    END DoSave;

  (*------------------------------------*)
  PROCEDURE DoAddModule ();

    VAR strDlg : SD.StrDlg; module : Data.FileName;

    BEGIN (* DoAddModule *)
      NEW (strDlg);
      IF strDlg # NIL THEN
        SD.InitStrDlg
          ( strDlg, renderInfo, "Add Module",
            "Enter a module name", Data.FileChars, Data.FileChars);
        module := "";
        IF SD.Activate (strDlg, window, module) THEN
          Data.MakeModule (module);
          RefreshModuleList ()
        END;
        SYS.DISPOSE (strDlg)
      ELSE
        ShowMessage (OutOfMemory)
      END
    END DoAddModule;

  (*------------------------------------*)
  PROCEDURE DoRemoveModule ();

    BEGIN (* DoRemoveModule *)
      IF
        ISU.DoRequest
          ( window, SYS.ADR("Remove the current module?"),
            "  Are you sure about this?  ")
      THEN
        Data.RemoveModule();
        RefreshModuleList ()
      END; (* IF *)
    END DoRemoveModule;

  (*------------------------------------*)
  PROCEDURE DoSetupFiles ( file : INTEGER );

    VAR strDlg : SD.StrDlg; extension : Data.Extension;

    BEGIN (* DoSetupFiles *)
      NEW (strDlg);
      IF strDlg # NIL THEN
        SD.InitStrDlg
          ( strDlg, renderInfo, "Setup Files", "Enter extension",
            Data.ExtensionChars, Data.ExtensionChars);
        extension := Data.extensions [file];
        IF SD.Activate (strDlg, window, extension) THEN
          Data.extensions [file] := extension; ResetGadgets ()
        END;
        SYS.DISPOSE (strDlg)
      ELSE
        ShowMessage (OutOfMemory)
      END
    END DoSetupFiles;

  (*------------------------------------*)
  PROCEDURE DoSetupButtons (toolNo : INTEGER);

    CONST DisableFlag = {ISup.gdDisabled}; NoFlag = {};

    VAR ignore : LONGINT; toolDialog : TD.Dialog;

  BEGIN (* DoSetupButtons *)
    TD.MakeDialog (toolDialog);
    TD.Activate (toolDialog, Data.tools [toolNo], window);
    IF toolDialog.accepted THEN
      ISU.DisableGadget
        ( gadgetList, ButtonsID + toolNo,
          ~Data.tools [toolNo].isActive )
    END;
    TD.FreeDialog (toolDialog);
  END DoSetupButtons;


  (*------------------------------------*)
  PROCEDURE DoSaveSetup ();

    VAR tempFile : Data.FileName; tempDir : Data.Path;

  BEGIN (* DoSaveSetup *)
    tempFile := setupFile; tempDir := setupDir;
    IF
      RequestFile ("Save setup to ...", tempFile, tempDir)
    THEN
      setupFile := tempFile; setupDir := tempDir;
      Data.SaveSetup (tempDir, tempFile)
    END; (* IF *)
  END DoSaveSetup;


  (*------------------------------------*)
  PROCEDURE DoLoadSetup ();

    VAR tempFile : Data.FileName; tempDir : Data.Path;

  BEGIN (* DoLoadSetup *)
    tempFile := setupFile; tempDir := setupDir;
    IF
      RequestFile ("Load setup from ...", tempFile, tempDir)
    THEN
      setupFile := tempFile; setupDir := tempDir;
      Data.LoadSetup (tempDir, tempFile); ResetGadgets ()
    END;
  END DoLoadSetup;

BEGIN (* HandleMenuPick *)
  result := Ev.Continue;

  menuNumber := msg.code;
  window := msg.idcmpWindow;
  E.base.ReplyMsg (msg);

  WHILE menuNumber # I.menuNull DO
    IU.GetMenuChoice (menuNumber, window.menuStrip^, menuChoice);

    CASE menuChoice.menuChosen OF
      FPEID :
        CASE menuChoice.itemChosen OF
          AboutItemID : DoAbout();
          |
          QuitItemID  : result := Ev.StopAll;
          |
        END; (* CASE menuChoice.itemChosen *)
      |
      ProgramID :
        CASE menuChoice.itemChosen OF
          CreateDirID        : DoCreateDir()
          |
          OpenItemID         : DoOpen();
          |
          AddModuleItemID    : DoAddModule();
          |
          RemoveModuleItemID : DoRemoveModule();
          |
          SaveItemID         : DoSave();
          |
        END; (* CASE menuChoice.itemChosen *)
      |
      SetupID :
        CASE menuChoice.itemChosen OF
          SaveSetupItemID :
            CASE menuChoice.subItemChosen OF
              SaveDefaultID : Data.SaveDefSetup (TRUE);
              |
              SaveAltID : Data.SaveDefSetup (FALSE);
              |
              SaveSelectID : DoSaveSetup ();
              |
            END; (* CASE menuChoice.subItemChosen *)
          |
          LoadItemID      :
            CASE menuChoice.subItemChosen OF
              LoadDefaultID :
                Data.LoadDefSetup (TRUE); ResetGadgets ()
              |
              LoadAltID :
                Data.LoadDefSetup (FALSE); ResetGadgets ()
              |
              LoadSelectID : DoLoadSetup ();
              |
            END; (* CASE menuChoice.subItemChosen *)
          |
          ButtonsItemID   :
            DoSetupButtons (menuChoice.subItemChosen)
          |
          FilesItemID     :
            DoSetupFiles (menuChoice.subItemChosen)
          |
        END; (* CASE menuChoice.itemChosen *)
      |
    END; (* CASE menuChoice.menuChosen *)

    menuNumber := menuChoice.pointer.nextSelect;
  END; (* WHILE *)

  RETURN result;
END HandleMenuPick;


(*------------------------------------*)
PROCEDURE Start * ();

BEGIN (* Start *)
  NEW (handler); ASSERT (handler # NIL, 137);
  handler.Init();
  handler.Handle [I.idcmpCloseWindow] := HandleClosewindow;
  handler.Handle [I.idcmpMenuPick] := HandleMenuPick;
  setupDir := "FPE:S";
  setupFile := "Default.fpe";

  I.base.OldModifyIDCMP (window, IDCMPFlags);
  Ev.AttachPort (handler, window.userPort);
  DoLoadProgram (Data.programName);
  Ev.SimpleLoop (handler);
  Ev.DetachPort (handler)
END Start;

END FPEDlg.

(***************************************************************************

  $Log: FPEDlg.mod $
  Revision 1.9  1994/08/08  16:14:57  fjc
  Release 1.4

  Revision 1.8  1994/06/21  22:09:15  fjc
  - Added code to conditionally call asl.library instead of
    arp.library.

  Revision 1.7  1994/06/17  17:26:27  fjc
  - Updated for release

  Revision 1.6  1994/06/09  13:36:47  fjc
  - Incorporated changes in Amiga interface.
  - Bumped version strings.

  Revision 1.5  1994/06/04  23:49:52  fjc
  - Changed to use new Amiga interface

  Revision 1.4  1994/05/19  23:45:35  fjc
  - Added "Program-Create Directory" menu item

  Revision 1.3  1994/05/12  21:26:09  fjc
  - Prepared for release

  Revision 1.2  1994/01/24  14:33:33  fjc
  Changed to conform with changes in Module Handlers:
    Handler procedures now reply to any messages they handle
  Modified About requester

  Revision 1.1  1994/01/15  17:32:38  fjc
  Start of revision control

***************************************************************************)