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

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

   Created by: fjc (Frank Copeland)
    $Revision: 1.4 $
      $Author: fjc $
        $Date: 1994/05/19 23:45:35 $

  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;

(* $P- allow non-portable code *)

IMPORT
  Errors, T := Types, E := Exec, EU := ExecUtil, Dos, I := Intuition,
  IU := IntuiUtil, Ev := Events, ARPUtil, 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         : T.APTR;
  menuData           : ARRAY NumMenus + 1 OF ISup.MenuData;
  menuList           : T.APTR;


CONST
  WindowTitle = "FPE 1.1 (17 May 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";

VAR

  OldCleanup1, OldCleanup2 : PROCEDURE (rc : LONGINT);


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


PROCEDURE* Cleanup (rc : LONGINT);

BEGIN (* Cleanup *)
  IF menuList # NIL   THEN ISup.Base.IFreeMenu (menuList) END;
  IF gadgetList # NIL THEN ISup.Base.IFreeGadgets (gadgetList) END;
  IF renderInfo # NIL THEN ISup.Base.IFreeRenderInfo (renderInfo) END;
  Tpl.Cleanup (template);
  IF OldCleanup1 # NIL THEN OldCleanup1 (rc) END;
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].gdText :=
        SYS.ADR (Data.extensions [index]);
      INC (index);
    END; (* WHILE *)

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

    template.TextData.t1.tdText := SYS.ADR(programNameBuffer);

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

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

  PROCEDURE InitMenus ();

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

    VAR index : INTEGER;

  BEGIN (* InitMenus *)
    menuData [FPEIdx].mdType := ISup.mdtTitle;
    menuData [FPEIdx].mdFlags := On;
    menuData [FPEIdx].mdName := SYS.ADR("FPE");

      menuData [AboutItemIdx].mdType := ISup.mdtItem;
      menuData [AboutItemIdx].mdFlags := On;
      menuData [AboutItemIdx].mdName := SYS.ADR("About ...");

      menuData [QuitItemIdx].mdType := ISup.mdtItem;
      menuData [QuitItemIdx].mdFlags := On;
      menuData [QuitItemIdx].mdName := SYS.ADR("Quit");
      menuData [QuitItemIdx].mdCommandKey := SYS.ADR("Q\0");

    menuData [ProgramIdx].mdType := ISup.mdtTitle;
    menuData [ProgramIdx].mdFlags := On;
    menuData [ProgramIdx].mdName := SYS.ADR("Program");

      menuData [CreateDirIdx].mdType := ISup.mdtItem;
      menuData [CreateDirIdx].mdFlags := On;
      menuData [CreateDirIdx].mdName := SYS.ADR("Create Directory ...");

      menuData [OpenItemIdx].mdType := ISup.mdtItem;
      menuData [OpenItemIdx].mdFlags := On;
      menuData [OpenItemIdx].mdName := SYS.ADR("Select Program ...");

      menuData [AddModuleItemIdx].mdType := ISup.mdtItem;
      menuData [AddModuleItemIdx].mdFlags := On;
      menuData [AddModuleItemIdx].mdName := SYS.ADR("Add Module ...");

      menuData [RemoveModuleItemIdx].mdType := ISup.mdtItem;
      menuData [RemoveModuleItemIdx].mdFlags := On;
      menuData [RemoveModuleItemIdx].mdName := SYS.ADR("Remove Module ...");

      menuData [SaveItemIdx].mdType := ISup.mdtItem;
      menuData [SaveItemIdx].mdFlags := On;
      menuData [SaveItemIdx].mdName := SYS.ADR("Save Module List");

    menuData [SetupIdx].mdType := ISup.mdtTitle;
    menuData [SetupIdx].mdFlags := On;
    menuData [SetupIdx].mdName := SYS.ADR("Setup");

      menuData [LoadItemIdx].mdType := ISup.mdtItem;
      menuData [LoadItemIdx].mdFlags := On;
      menuData [LoadItemIdx].mdName := SYS.ADR("Load Setup");

        menuData [LoadDefaultIdx].mdType := ISup.mdtSubItem;
        menuData [LoadDefaultIdx].mdFlags := On;
        menuData [LoadDefaultIdx].mdName := SYS.ADR ("Default Setup");

        menuData [LoadAltIdx].mdType := ISup.mdtSubItem;
        menuData [LoadAltIdx].mdFlags := On;
        menuData [LoadAltIdx].mdName := SYS.ADR ("Alternate Setup");

        menuData [LoadSelectIdx].mdType := ISup.mdtSubItem;
        menuData [LoadSelectIdx].mdFlags := On;
        menuData [LoadSelectIdx].mdName := SYS.ADR ("Select Setup ...");

      menuData [SaveSetupItemIdx].mdType := ISup.mdtItem;
      menuData [SaveSetupItemIdx].mdFlags := On;
      menuData [SaveSetupItemIdx].mdName := SYS.ADR("Save Setup");

        menuData [SaveDefaultIdx].mdType := ISup.mdtSubItem;
        menuData [SaveDefaultIdx].mdFlags := On;
        menuData [SaveDefaultIdx].mdName := SYS.ADR ("Default Setup");

        menuData [SaveAltIdx].mdType := ISup.mdtSubItem;
        menuData [SaveAltIdx].mdFlags := On;
        menuData [SaveAltIdx].mdName := SYS.ADR ("Alternate Setup");

        menuData [SaveSelectIdx].mdType := ISup.mdtSubItem;
        menuData [SaveSelectIdx].mdFlags := On;
        menuData [SaveSelectIdx].mdName := SYS.ADR ("Select Setup ...");

      menuData [ButtonsItemIdx].mdType := ISup.mdtItem;
      menuData [ButtonsItemIdx].mdFlags := On;
      menuData [ButtonsItemIdx].mdName := SYS.ADR("Edit Tool Button");

        index := 0;
        WHILE index < Data.NumTools DO
          menuData [index + FirstButtonsSubItemIdx].mdType := ISup.mdtSubItem;
          menuData [index + FirstButtonsSubItemIdx].mdFlags := On;
          menuData [index + FirstButtonsSubItemIdx].mdName := SYS.ADR (Data.tools [index].title);
          INC( index );
        END; (* WHILE *)

      menuData [FilesItemIdx].mdType := ISup.mdtItem;
      menuData [FilesItemIdx].mdFlags := On;
      menuData [FilesItemIdx].mdName := SYS.ADR("Edit File Extension");

        index := 0;
        WHILE index < Data.NumFiles DO
          menuData [index + FirstFilesSubItemIdx].mdType := ISup.mdtSubItem;
          menuData [index + FirstFilesSubItemIdx].mdFlags := On;
          menuData [index + FirstFilesSubItemIdx].mdName := SYS.ADR (Data.extensions [index]);
          INC( index );
        END; (* WHILE *)

    menuData [NumMenus].mdType := 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 *)
  Errors.Assert
    (Tpl.Init (template), "FPE : failed to init window template");
  SYS.SETCLEANUP (Cleanup, OldCleanup1);
  InitGadgets ();
  InitMenus();
  InitWindow();
END Init;


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

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

  VAR ignore : LONGINT;

BEGIN (* RefreshModuleList *)
  IF EU.ListLength (Data.moduleList) = 0 THEN
    ignore := ISup.Base.ISetGadgetAttributes
      ( gadgetList, ModuleID, Disable, Disable, ISup.useCurrentValue, 0,
        NIL);
  ELSE
    ignore := ISup.Base.ISetGadgetAttributes
      ( 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.IClearWindow (renderInfo, window, left, top, width, height, {});
  ISup.Base.IDisplayGadgets (window, gadgetList);
  ISup.Base.IDisplayTexts
    (renderInfo, window, template.TextData.t0, 0, 0, NIL);
  ISup.Base.IDisplayBorders
    (renderInfo, window, template.BorderData.b0, 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 (rc : LONGINT);

  VAR ignore : I.WindowPtr;

BEGIN (* Close *)
  IF gadgetList # NIL THEN ignore := ISup.Base.IRemoveGadgets (gadgetList) END;
  IF menuList # NIL THEN ignore := ISup.Base.IRemoveMenu (menuList) END;
  IF window # NIL THEN ISup.Base.ICloseWindow (window, T.LFALSE); window := NIL END;
  IF OldCleanup2 # NIL THEN OldCleanup2 (rc) END;
END Close;


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

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

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

  menuList :=
    ISup.Base.ICreateMenu (renderInfo, window, menuData [0], NIL, NIL);
  Errors.Assert (menuList # NIL, "FPE - ICreateMenu() failed");
  ISup.Base.IAttachMenu (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.IDisplayTexts
    (renderInfo, window, template.TextData.t0, 0, 0, NIL);
END RefreshProgramName;


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

  CONST Flags = {ISup.cwfNormalColor};

BEGIN (* RefreshWindow *)
  ISup.Base.IRefreshGadgets (gadgetList);
  ISup.Base.IDisplayTexts
    (renderInfo, window, template.TextData.t0, 0, 0, NIL);
  ISup.Base.IDisplayBorders
    (renderInfo, window, template.BorderData.b0, 0, 0);
END RefreshWindow;


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

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

  VAR ignore : LONGINT;

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


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

  VAR  window : I.WindowPtr;

BEGIN (* ResetGadgets *)
  window := ISup.Base.IRemoveGadgets (gadgetList);
  ISup.Base.IFreeGadgets (gadgetList);

  gadgetList :=
    ISup.Base.ICreateGadgets
      (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.IChangeMousePointer (window, NIL, T.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.IRestoreMousePointer (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.IReplyMsg (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 DoAbout ();

    VAR ignore : BOOLEAN;

    BEGIN (* DoAbout *)
      ignore :=
        ISup.Base.IAutoRequest
          ( window, SYS.ADR("About FPE"),
            "FPE 1.1 (17 May 1994)\\nFrank's Programming Environment\\n--oOo--\\nCopyright © 1993-1994 Frank Copeland\\nWritten using Oberon-A\\nand intuisup.library\\n\\nsee FPE.doc for conditions of use",
            NIL, SYS.ADR("Continue"), {}, {},
            { ISup.arfBackFill, ISup.arfMovePointerNeg, ISup.arfDrawRaster,
              ISup.arfTextCenter }, 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 ARPUtil.RequestFile (NIL, "Select a program", tempFile, tempDir)
      THEN
        Data.ChangeDirectory (tempDir);
        DoLoadProgram (tempFile)
      END;
    END DoOpen;

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

    VAR msg : ARRAY 60 OF CHAR;

    BEGIN (* DoSave *)
      ISup.Base.IChangeMousePointer (window, NIL, T.LFALSE);
      IF ~Data.SaveProgram() THEN
        msg := "Could not save ";
        Str.Append (msg, Data.programName);
        Str.Append (msg, ".prg");
        ShowMessage (msg);
      END; (* IF *)
      ISup.Base.IRestoreMousePointer (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.gdfDisabled};
          NoFlag = {};

    VAR ignore : LONGINT; toolDialog : TD.Dialog;

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


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

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

  BEGIN (* DoSaveSetup *)
    tempFile := setupFile; tempDir := setupDir;
    IF
      ARPUtil.RequestFile (NIL, "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
      ARPUtil.RequestFile (NIL, "Load setup from ...", tempFile, tempDir)
    THEN
      setupFile := tempFile; setupDir := tempDir;
      Data.LoadSetup (tempDir, tempFile); ResetGadgets ()
    END; (* IF *)
  END DoLoadSetup;

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

  menuNumber := msg.Code;
  window := msg.IDCMPWindow;
  E.Base.ReplyMsg (msg^);

  WHILE menuNumber # (*I.MenuNull*) -1 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); 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.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

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