Unit bbs_Menus;

{$I M_OPS.PAS}

Interface

Uses
  m_Strings,
  bbs_Common,
  bbs_Doors;

Type
  TMenuSystem = Class
    LBMenuPos : Byte;
    CmdNum    : Byte;
    Menu      : MenuRec;
    MenuList  : Array[1..mysMaxMenuCmds] of MenuCmdRec;
    MenuOld   : String[mysMaxMenuNameLen];
    MenuName  : String[mysMaxMenuNameLen];
    MenuStack : Array[1..8] of String[mysMaxMenuNameLen];
    StackNum  : Byte;

    Constructor Create (Var Owner: Pointer);
    Destructor  Destroy; Override;

    Function    StripSecurity     (Str : String) : String;
    Function    ReplaceSecurity   (Str : String) : String;
    Procedure   ToggleAccessFlags (Data: String; Var Flags: AccessFlagType);
    Function    LoadMenu          (CheckSec: Boolean; RunCmd: Boolean; Global: Boolean) : Byte;
    Procedure   ExecuteMenu       (FallBack, Global, View: Boolean);
    Function    ExecuteCommand    (Cmd: String; Data: String) : Boolean; {True if menu is to be reloaded}
  End;

Implementation

Uses
  bbs_Core,
  bbs_MsgBase,
  bbs_FileBase,
  bbs_General,
  bbs_User,
  bbs_NodeChat,
  bbs_NodeInfo,
  bbs_ansi_Help,
  MPL_Execute,
  bbs_cfg_MenuEdit,
  bbs_cfg_FileBase,
  bbs_cfg_UserEdit,
  bbs_cfg_MsgBase,
  bbs_cfg_SecLevel,
  bbs_cfg_Groups,
  bbs_cfg_Events,
  bbs_cfg_Vote,
  bbs_Cfg_Main;

Constructor TMenuSystem.Create (Var Owner: Pointer);
Begin
  Inherited Create;

  StackNum := 0;
End;

Destructor TMenuSystem.Destroy;
Begin
  Inherited Destroy;
End;

Function TMenuSystem.StripSecurity (Str : String) : String;
Begin
  Delete (Str, Pos('@S', Str), 2);

  Result := Str;
End;

Function TMenuSystem.ReplaceSecurity (Str : String) : String;
Var
  A : Byte;
Begin
  A := Pos('@', Str);

  If A > 0 Then Begin
    Delete (Str, A, 2);
    Insert (strI2S(Session.User.ThisUser.Security), Str, A);
  End;

  Result := Str;
End;

Procedure TMenuSystem.ToggleAccessFlags (Data: String; Var Flags: AccessFlagType);
Var
  A : Byte;
Begin
  A := 1;

  While A <= Length(Data) Do Begin
    If (Data[A] in ['+','-','!']) and (Data[A+1] in ['A'..'Z']) Then Begin
      Case Data[A] of
        '+' : Flags := Flags + [Ord(Data[A+1]) - 64];
        '-' : Flags := Flags - [Ord(Data[A+1]) - 64];
        '!' : If Ord(Data[2]) - 64 in Flags Then
                Flags := Flags - [Ord(Data[A+1]) - 64]
              Else
                Flags := Flags + [Ord(Data[A+1]) - 64];

      End;
      Inc (A);
    End;
    Inc(A);
  End;

  {$IFNDEF UNIX}
     Update_Status_Line(StatusPTR, '');
  {$ENDIF}
End;

Function TMenuSystem.ExecuteCommand (Cmd: String; Data: String) : Boolean;
Var
  A : Integer;
  Help : TAnsiMenuHelp;
Begin
  Result := False;

  {$IFDEF LOGGING} Session.SystemLog('Exec MenuCmd: ' + Cmd + ' ' + Data); {$ENDIF}

  If Length(Cmd) <> 2 Then Exit;

  Case Cmd[1] of
    '-' : Case Cmd[2] of
            'D' : ToggleAccessFlags(Data, Session.User.ThisUser.AF2);
            'F' : ToggleAccessFlags(Data, Session.User.ThisUser.AF1);
            'N' : Session.User.AcsOkFlag := Session.io.GetYN(Data, False);
            'P' : Session.User.AcsOkFlag := Session.io.GetPW(Copy(Data, 1, Pos(';', Data) - 1), Session.GetPrompt(417),
                                                strUpper(Copy(Data, Pos(';', Data) + 1, Length(Data))));
            'S' : Session.SystemLog(Data);
            'Y' : Session.User.AcsOkFlag := Session.io.GetYN(Data, True);
          End;
    'A' : Case Cmd[2] of
            'E' : AutoSig_Edit;
            'T' : Session.User.ThisUser.SigUse := Session.io.GetYN(Session.GetPrompt(335), False);
            'V' : AutoSig_View;
          End;
    'D' : Case Cmd[2] of
            '-' : ExecuteDoor (0, Data);
            'C' : ExecuteDoor (3, Data);
            'D' : ExecuteDoor (1, Data);
            'G' : ExecuteDoor (2, Data);
            '3' : ExecuteDoor (4, Data);
          End;
    'F' : Case Cmd[2] of
            'A' : Session.FileBase.ChangeFileArea(Data);
            'D' : Begin
                    Session.io.OutFile ('download', True, 0);

                    If (Session.FileBase.BatchNum > 0) and (Session.io.GetYN(Session.GetPrompt(85), True)) Then
                      Session.FileBase.DownloadBatch
                    Else
                      Session.FileBase.DownloadFile;
                  End;
            'F' : Session.FileBase.DownloadFileList (strUpper(Data));
            'G' : Session.FileBase.FileGroupChange (Data, True, True);
            'L' : Session.FileBase.ListFiles (1, strUpper(Data));
            'N' : Session.FileBase.NewFileScan(UpCase(Data[1]));
            'P' : Session.FileBase.SetFileScanDate;
            'S' : Session.FileBase.FileSearch;
            'U' : Session.FileBase.UploadFile;
            'V' : Session.FileBase.ViewFile;
            'Z' : Session.FileBase.ToggleFileNewScan;
            '1' : Session.FileBase.MassUpload;
            '2' : Session.FileBase.DirectoryEditor(False, '');
            '3' : Session.FileBase.SendFile (Data);
          End;
    'B' : Case Cmd[2] of
            'A' : Add_BBS_List  (Data);
            'L' : View_BBS_List (True, Data);
            'S' : View_BBS_List (False, Data);
          End;
    'G' : Case Cmd[2] of
            '1' : View_History(strS2I(Data));
            'A' : View_Directory(Data, 0);
            'D' : Session.io.OutFile (Data, True, 0);
            'E' : Session.User.Edit_User_Settings(strS2I(Data));
            'H',
            'I' : Begin
                    If Cmd[2] = 'H' Then Begin
                      If Session.FileBase.BatchNum > 0 Then Begin
                        Session.io.PromptInfo[1] := strI2S(Session.FileBase.BatchNum);
                        If Session.io.GetYN(Session.GetPrompt(121), False) Then
                          Session.FileBase.DownloadBatch;
                      End;
                      Session.io.OutFile ('logoff', True, 0);
                    End;
                    Session.SystemLog ('User logged off');
                    Halt(0);
                  End;
            'L' : Last_Callers;
            'O' : Begin
                    MenuOld  := MenuName;
                    MenuName := Data;
                    Result   := True;
                  End;
            'N' : One_Liners (Data);
            'P' : {$IFNDEF UNIX} Page_For_Chat (Pos('/F', strUpper(Data)) > 0) {$ENDIF};
            'R' : Begin
                    If StackNum > 0 Then Begin
                      MenuOld  := MenuName;
                      MenuName := MenuStack[StackNum];
                      Result   := True;

                      Dec (StackNum);
                    End;
                  End;
            'S' : Begin
                    MenuOld := MenuName;

                    If StackNum = 8 Then Begin
                      For A := 1 to 7 Do
                        MenuStack[A + 1] := MenuStack[A];

                      Dec (StackNum);
                    End;

                    Inc (StackNum);

                    MenuStack[StackNum] := MenuName;
                    MenuName            := Data;
                    Result              := True;
                  End;
            'T' : Session.io.OutFull (Data);
            'U' : List_Users (strUpper(Data));
            'X' : Result := ExecuteMPL(NIL, Data) = 2;
            '?' : Begin
                    // online ANSI help system (BBSHTML) prototype
                    Help := TAnsiMenuHelp.Create;
                    Help.OpenHelp (1, 1, 79, 23, Session.Lang.TextPath + Data, 'INDEX');
                    Help.Free;
                  End;
          End;
    'M' : Case Cmd[2] of
            'A' : Session.Msgs.ChangeArea(Data);
            'C' : Session.Msgs.CheckEMail;
            'D' : Session.Msgs.SetMessagePointers;
            'G' : Session.Msgs.MessageGroupChange (Data, True, True);
            'M' : Session.Msgs.SendMassEmail;
            'N' : Session.Msgs.MessageNewScan (strUpper(Data));
            'P' : Session.Msgs.PostMessage (False, Data);
//            'Q' : Session.Msgs.Message_QuickScan(UpCase(Data[1]));
            'R' : Begin
                    If Data = '' Then Data := ' ';

                    Session.Msgs.ReadMessages(UpCase(Data[1]), '');
                  End;
            'S' : Session.Msgs.GlobalMessageSearch(UpCase(Data[1]));
            'V' : Session.Msgs.ViewSentEmail;
            'W' : Session.Msgs.PostMessage (True, Data);
            'X' : Session.Msgs.PostTextFile(Data, False);
            'Z' : Session.Msgs.ToggleNewScan(False);
          End;
    'N' : Case Cmd[2] of
            'A' : Set_Node_Action (Data);
            'C' : Node_Chat;
            'S' : Send_Node_Message (3, Data, 0);
            'W' : Show_Whos_Online;
          End;
    'O' : Case Cmd[2] of
            'S' : Session.Msgs.ToggleNewScan(True);
            'D' : Session.Msgs.DownloadQWK(Data);
            'U' : Session.Msgs.UploadREP;
          End;
    'Q' : Case Cmd[2] of
            'A' : Session.FileBase.BatchAdd;
            'C' : Session.FileBase.BatchClear;
            'D' : Session.FileBase.BatchDelete;
            'L' : Session.FileBase.BatchList;
          End;
    'T' : Case Cmd[2] of
            'D' : Add_TimeBank;
            'W' : Get_TimeBank;
          End;
    'V' : Case Cmd[2] of
            'A' : Add_Booth;
            'N' : Voting_Booth_New;
            'R' : Voting_Result (strS2I(Data));
            'V' : Voting_Booth (False, strS2I(Data));
          End;
    'X' : Case Cmd[2] of
            'A' : Begin
                    Session.io.OutFile('newuser', True, 0);
                    If Session.io.GetYN(Session.GetPrompt(269), True) Then Begin
                      Session.User.CreateNewUser('');
                      Session.User.User_Logon2;

                      MenuName := Config.MatrixMenu;
                      Result   := True;
                    End;
                  End;
            'C' : If Session.User.GetMatrixUser Then Begin
                    If Session.User.Access(Config.MatrixAcs) Then Begin
                      Session.io.PromptInfo[1] := Config.MatrixPW;
                      Session.io.OutFull (Session.GetPrompt(270));
                    End Else
                      Session.io.OutFull (Session.GetPrompt(271));
                  End;
            'L' : If Session.io.GetPW (Session.GetPrompt(272), Session.GetPrompt(423), Config.MatrixPW) Then Begin
                    Session.User.MatrixOK := True;
                    Result                := True;
                  End;
            'P' : {$IFNDEF UNIX} If Session.User.GetMatrixUser Then
                    Page_For_Chat (Pos('/F', strUpper(Data)) > 0) {$ENDIF};
          End;
    '*' : Begin
            If Not Session.io.GetPW ('|CR|09Sysop Password: ', Session.GetPrompt(417), Config.SysopPW) Then Exit; {++lang}

            Case Cmd[2] of
              '#' : Begin
                      Menu_Editor;
                      Result := True;
                    End;
              'A' : Configuration_ExecuteEditor('A');
              'E' : Event_Editor;
              'F' : File_Base_Editor;
              'G' : Group_Editor;
              'L' : Levels_Editor;
              'M' : Message_Base_Editor;
              'P' : Configuration_ExecuteEditor('P');
              'S' : Configuration_MainMenu;
              'U' : User_Editor(False, False);
              'V' : Vote_Editor;
            End;
          End;
  End;
End;

Function TMenuSystem.LoadMenu (CheckSec: Boolean; RunCmd: Boolean; Global: Boolean) : Byte;
{ 0 = Menu not found: Load fallback menu
  1 = Menu loaded.
  2 = Re-load menu: ie GO in FIRSTCMD }
Var
  MenuFile : Text;
  Buffer   : Array[1..2048] of Char;
  Temp     : String;
Begin
  Result := 0;

  {$IFDEF LOGGING} Session.SystemLog('Load menu: ' + MenuName); {$ENDIF}

  Assign (MenuFile, Session.Lang.MenuPath + MenuName + '.mnu');
  {$I-} Reset (MenuFile); {$I+}

  If IoResult <> 0 Then Begin
    If Not Global Then Session.io.OutFullLn ('|CR|14Menu not found, loading fallback.');
    Exit;
  End;

  SetTextBuf (MenuFile, Buffer, SizeOf(Buffer));

  If CheckSec Then Begin
    ReadLn (MenuFile, Temp);  {Header}
    ReadLn (MenuFile, Temp);  {Prompt}
    ReadLn (MenuFile, Temp);  {Display columns}
    ReadLn (MenuFile, Temp);  {ACS}

    If Not Session.User.Access(Temp) Then Begin
      Close (MenuFile);

      MenuName := MenuOld;
      Result   := 2;

      If Not Global Then
        Session.io.OutFullLn (Session.GetPrompt(149));

      Exit;
    End;

    ReadLn (MenuFile, Temp);

    If Temp <> '' Then
      If Not Session.io.GetPW(Session.GetPrompt(150), Session.GetPrompt(417), Temp) Then Begin
        Close (MenuFile);

        Result   := 2;
        MenuName := MenuOld;

        Exit;
      End;
  End;

  Reset  (MenuFile);

  ReadLn (MenuFile, Menu.Header);
  ReadLn (MenuFile, Menu.Prompt);
  ReadLn (MenuFile, Menu.DispCols);
  ReadLn (MenuFile, Menu.ACS);
  ReadLn (MenuFile, Menu.Password);
  ReadLn (MenuFile, Menu.TextFile);
  ReadLn (MenuFile, Menu.FallBack);
  ReadLn (MenuFile, Menu.MenuType);
  ReadLn (MenuFile, Menu.InputType);
  ReadLn (MenuFile, Menu.DoneX);
  ReadLn (MenuFile, Menu.DoneY);
  ReadLn (MenuFile, Menu.Global);

  If Not Global Then CmdNum := 0;

  While (CmdNum < mysMaxMenuCmds) And (Not Eof(MenuFile)) Do Begin
    Inc (CmdNum);

    ReadLn (MenuFile, MenuList[CmdNum].Text);
    ReadLn (MenuFile, MenuList[CmdNum].HotKey);
    ReadLn (MenuFile, MenuList[CmdNum].LongKey);
    ReadLn (MenuFile, MenuList[CmdNum].ACS);
    ReadLn (MenuFile, MenuList[CmdNum].Command);
    ReadLn (MenuFile, MenuList[CmdNum].Data);
    ReadLn (MenuFile, MenuList[CmdNum].X);
    ReadLn (MenuFile, MenuList[CmdNum].Y);
    ReadLn (MenuFile, MenuList[CmdNum].cUP);
    ReadLn (MenuFile, MenuList[CmdNum].cDOWN);
    ReadLn (MenuFile, MenuList[CmdNum].cLEFT);
    ReadLn (MenuFile, MenuList[CmdNum].cRIGHT);
    ReadLn (MenuFile, MenuList[CmdNum].LText);
    ReadLn (MenuFile, MenuList[CmdNum].LHText);

    If (RunCmd) and (MenuList[CmdNum].HotKey = 'FIRSTCMD') Then Begin
      If Session.User.Access(MenuList[CmdNum].ACS) Then
        If ExecuteCommand (MenuList[CmdNum].Command, MenuList[CmdNum].Data) Then Begin
          Result := 2;
          Close (MenuFile);
          Exit;
        End;
      Dec (CmdNum);
    End;
  End;
  Close (MenuFile);

  LBMenuPos := 0;
  Result    := 1;
End;

Procedure TMenuSystem.ExecuteMenu (FallBack, Global, View: Boolean);
{If fallback is false, Run_Menu will not try to load any fallback menus.
if the MenuName variable doesn't exist}
Var
  Keys    : String[mysMaxMenuCmds];
  ExtKeys : String[mysMaxMenuCmds];
  HotKeys : Boolean;
  Done    : Boolean;

  Function ExecuteAfterCommands : Boolean;
  Var
    A : Byte;
  Begin
    ExecuteAfterCommands := False;

    For A := 1 to CmdNum Do
      If (MenuList[A].HotKey = 'AFTER') And Session.User.Access(MenuList[A].ACS) Then
        If ExecuteCommand(MenuList[A].Command, MenuList[A].Data) Then Begin
          ExecuteAfterCommands := True;
          Done                 := True;
          Exit;
        End;
  End;

  Function ValidLightBar (Pos : Byte) : Boolean;
  Begin
    ValidLightBar := False;

    If Pos = 0 Then Exit;

    ValidLightBar := (MenuList[Pos].HotKey <> 'EVERY') and
                     (MenuList[Pos].HotKey <> 'AFTER') and
                     (MenuList[Pos].LText <> '') and
                     (MenuList[Pos].LHText <> '');
{ we need to add LINEFEED?! }
  End;

  Procedure Do_LightBar_Menu;
  Var
    A       : Byte;
    Ch      : Char;
    TempPos : Byte;
    TempStr : String;
  Begin
    If View Then Begin
      Done      := False;
      LBMenuPos := 0;
    End;

    Session.io.OutFile (ReplaceSecurity(Menu.TextFile), True, 0);

    If Session.io.NoFile and (Pos('@S', Menu.TextFile) > 0) Then
      Session.io.OutFile (StripSecurity(Menu.TextFile), True, 0);

    For A := 1 to CmdNum Do
      If ValidLightBar(A) Then Begin
        If LBMenuPos = 0 Then LBMenuPos := A;
        Session.io.AnsiGotoXY (MenuList[A].X, MenuList[A].Y);
        Session.io.OutFull (MenuList[A].LText);
      End;

    Session.io.AllowArrow := True;

    If ExecuteAfterCommands Then Exit;

    Session.io.PurgeInputBuffer;

    Repeat
      Session.io.AnsiGotoXY (MenuList[LBMenuPos].X, MenuList[LBMenuPos].Y);
      Session.io.OutFull (MenuList[LBMenuPos].LHText);

      Ch := Session.io.GetKey;

      Case Ch of
        #13 : Begin
                TempStr := MenuList[LBMenuPos].HotKey;

                For A := 1 To CmdNum Do
                  If MenuList[A].HotKey = TempStr Then
                    If Session.User.Access(MenuList[A].ACS) Then Begin
                      Session.io.AnsiGotoXY (Menu.DoneX, Menu.DoneY);
                      If View Then Exit;
                      If ExecuteCommand(MenuList[A].Command, MenuList[A].Data) Then
                        Done := True;
                    End;
                Exit;
              End;
        #72,
        #75 : Begin {Up, Left}
                Session.io.AnsiGotoXY (MenuList[LBMenuPos].X, MenuList[LBMenuPos].Y);
                Session.io.OutFull (MenuList[LBMenuPos].LText);

                If Menu.MenuType = 1 Then Begin
                  TempPos := LBMenuPos;
                  Repeat
                    Dec (TempPos);
                    If ValidLightBar(TempPos) Then Begin
                      LBMenuPos := TempPos;
                      Break;
                    End;
                  Until TempPos <= 1;
                End Else
                  Case Ch of
                    #72 : If ValidLightBar(MenuList[LBMenuPos].cUP) Then
                            LBMenuPos := MenuList[LBMenuPos].cUP;
                    #75 : If ValidLightBar(MenuList[LBMenuPos].cLEFT) Then
                            LBMenuPos := MenuList[LBMenuPos].cLEFT;
                  End;
              End;
        #80,
        #77 : Begin {Down, Right}
                Session.io.AnsiGotoXY (MenuList[LBMenuPos].X, MenuList[LBMenuPos].Y);
                Session.io.OutFull (MenuList[LBMenuPos].LText);

                If Menu.MenuType = 1 Then Begin
                  If LBMenuPos < CmdNum Then Begin
                    TempPos := LBMenuPos;
                    Repeat
                      Inc (TempPos);
                      If ValidLightBar(TempPos) Then Begin
                        LBMenuPos := TempPos;
                        Break;
                      End;
                    Until TempPos >= CmdNum;
                  End;
                End Else Begin
                  Case Ch of
                    #77 : If ValidLightBar(MenuList[LBMenuPos].cRIGHT) Then
                            LBMenuPos := MenuList[LBMenuPos].cRIGHT;
                    #80 : If ValidLightBar(MenuList[LBMenuPos].cDOWN) Then
                            LBMenuPos := MenuList[LBMenuPos].cDOWN;
                  End;
                End;
              End;
      Else
        If Pos(UpCase(Ch), Keys) > 0 Then begin
          For A := 1 to CmdNum Do Begin
            If ((Ch = #27) and (MenuList[A].HotKey = 'ESCAPE')) or
               ((Ch = #9)  and (MenuList[A].HotKey = 'TAB')) or
               (UpCase(Ch) = MenuList[A].HotKey) Then
              If Session.User.Access(MenuList[A].ACS) Then Begin
                Session.io.AnsiGotoXY (Menu.DoneX, Menu.DoneY);
                If View Then Exit;
                If ExecuteCommand(MenuList[A].Command, MenuList[A].Data) Then
                  Done := True;
              End;
          End;
          Exit;
        End;
      End;
    Until Done;
  End;

  Procedure Do_Internal_Menu;
  Var
    Format : Byte;
    A      : Byte;
    Listed : Byte;
    Temp   : String[8];
    Ch     : Char;
    Found  : Boolean;
  Begin
    Session.io.OutFile (ReplaceSecurity(Menu.TextFile), True, 0);

    If Session.io.NoFile and (Pos('@S', Menu.TextFile) > 0) Then
      Session.io.OutFile (StripSecurity(Menu.TextFile), True, 0);

    If Session.io.NoFile Then Begin
      Case Menu.DispCols of
        1 : Format := 79;
        2 : Format := 39;
        3 : Format := 26;
      End;

      Session.io.OutFullLn (Menu.Header);

      Listed := 0;

      For A := 1 to CmdNum Do Begin
        If MenuList[A].Text <> '' Then
          If (MenuList[A].HotKey <> 'EVERY') and (MenuList[A].HotKey <> 'AFTER') Then
            If Session.User.Access(MenuList[A].ACS) Then Begin
              If MenuList[A].HotKey = 'LINEFEED' Then Begin
                If Listed MOD Menu.DispCols <> 0 Then Session.io.OutRawLn('');
                Session.io.OutFull(MenuList[A].Text);
                While Listed Mod Menu.DispCols <> 0 Do Inc(Listed);
              End Else Begin
                Inc (Listed);
                If Format <> 79 Then
                  Session.io.OutFull (strPadR(MenuList[A].Text, Format + (Length(MenuList[A].Text) - strMCILen(MenuList[A].Text)), ' '))
                Else
                  Session.io.OutFull (MenuList[A].Text);
                While Screen.CursorX < Format Do Session.io.BufAddChar(' ');
                If Listed Mod Menu.DispCols = 0 Then Session.io.OutRawLn ('');
              End;
            End;
      End;

      If Listed Mod Menu.DispCols <> 0 Then Session.io.OutRawLn ('');
    End;

    If ExecuteAfterCommands Then Exit;

    If Menu.Prompt <> '' Then Session.io.OutFull (Menu.Prompt);

    Session.io.PurgeInputBuffer;

    Listed     := 0;
    Session.io.AllowArrow := True;

    If HotKeys Then Begin
      Repeat
        Temp := UpCase(Session.io.GetKey);

        If Session.io.IsArrow Then Begin
          If Pos(Temp, ExtKeys) > 0 Then Break;
        End Else
          If Pos(Temp, Keys) > 0 Then
            If Temp = '/' Then Begin
              Session.io.BufAddChar (Temp[1]);
              Repeat
                Ch := UpCase(Session.io.GetKey);
                Case Ch of
                  #08 : If Length(Temp) > 0 Then Begin
                          Dec (Temp[0]);
                          Session.io.OutBS(1, True);
                        End;
                  #13 : Begin
                          Session.io.OutRawLn(Ch);
                          Exit;
                        End;
                  #32..
                  #126: Begin
                          Found := False;
                          For A := 1 to CmdNum Do
                            If Pos (Temp + Ch, MenuList[A].HotKey) > 0 Then Begin
                              If Not Found Then Begin
                                Temp  := Temp + Ch;
                                Found := True;
                                Session.io.BufAddChar (Ch);
                              End;
                              If Temp = MenuList[A].HotKey Then
                                If Session.User.Access(MenuList[A].ACS) Then Begin
                                  If View Then Exit;
                                  If Listed = 0 Then Session.io.OutRawLn('');
                                  Listed := A;
                                  ExecuteCommand (MenuList[A].Command, MenuList[A].Data);
                                  Done := True;
                                End;
                            End;
                          If Done Then Exit;
                        End;
                End;
              Until Temp = '';
            End Else
              Break;
      Until False;

      If Ord(Temp[1]) > 32 Then Session.io.OutRawLn(Temp) Else Session.io.OutRawLn('');

{ needs to ignore LINEFEED? }

      For A := 1 to CmdNum Do
        If ((Temp = #27) and (MenuList[A].HotKey = 'ESCAPE')) or
           ((Temp = #13) and (MenuList[A].HotKey = 'ENTER')) or
           ((Temp = #9)  and (MenuList[A].HotKey = 'TAB')) or
           (Session.io.IsArrow and (Temp = #72) and (MenuList[A].HotKey = 'UP')) or
           (Session.io.IsArrow and (Temp = #75) and (MenuList[A].HotKey = 'LEFT')) or
           (Session.io.IsArrow and (Temp = #77) and (MenuList[A].HotKey = 'RIGHT')) or
           (Session.io.IsArrow and (Temp = #80) and (MenuList[A].HotKey = 'DOWN')) or
           (Not Session.io.IsArrow and (Temp = MenuList[A].HotKey)) Then

              If Session.User.Access(MenuList[A].ACS) Then
                If ExecuteCommand (MenuList[A].Command, MenuList[A].Data) Then Begin
                  Done := True;
                  Exit;
                End;
    End Else Begin { non hotkey input }
      Temp := Session.io.GetInput (8, 8, 2, '');

      If Temp = '' Then Temp := 'ENTER';
      { temporary support for ENTER in non hotkey mode }

      For A := 1 to CmdNum Do
        If Temp = MenuList[A].LongKey Then
          If Session.User.Access(MenuList[A].ACS) Then Begin
            If View Then Exit;
            If ExecuteCommand (MenuList[A].Command, MenuList[A].Data) Then Begin
              Done := True;
              Exit;
            End;
          End;
    End;
  End;

Var
  A  : Byte;
  MR : MenuRec;
Begin
  If View Then Begin
    Keys := #13;
    If (Menu.MenuType > 0) and (Session.io.Graphics = 1) Then Begin
      Do_LightBar_Menu;
      Session.io.AnsiGotoXY (Menu.DoneX, Menu.DoneY);
    End Else
      Do_Internal_Menu;
    Exit;
  End;

  Repeat
    Case LoadMenu(True, True, False) of
      0 : Begin
          { 1. Try Menu.FallBack   }
          { 2. Try Config.dFallMNU }
          { 3. Give error and halt }
            If Not FallBack Then Exit;

            If (MenuName = Config.MatrixMenu) or (MenuName = Config.DefFallMenu) Then Begin
              Session.io.OutFullLn ('|CRError Loading ' + MenuName + '.mnu');
              Session.SystemLog ('Error Loading Menu: ' + MenuName);
              Halt(1);
            End;

            If (Menu.FallBack <> '') and (MenuName <> Menu.FallBack) Then
              MenuName := Menu.Fallback
            Else
              MenuName := Config.DefFallMenu;
            Exit;
          End;
      1 : Break;
      2 : Exit;
    End;
  Until False;

  If Global and (Menu.Global = 1) Then Begin
    Keys     := MenuName;
    MR       := Menu;
    MenuName := 'global';

    LoadMenu(True, True, True);

    MenuName := Keys;
    Menu     := MR;
  End;

  If Menu.InputType = 0 Then
    HotKeys := Session.User.ThisUser.HotKeys
  Else
    HotKeys := Not Boolean(Menu.InputType - 1);

  Repeat
    Done := False;

    Set_Node_Action (Session.GetPrompt(346));

    Check_Node_Message;

    Keys    := #13;
    ExtKeys := '';

    For A := 1 to CmdNum Do
      If Session.User.Access(MenuList[A].ACS) Then
        If MenuList[A].HotKey = 'EVERY' Then Begin
          If ExecuteCommand (MenuList[A].Command, MenuList[A].Data) Then Exit;
        End Else
        If MenuList[A].HotKey = 'TAB' Then
          Keys := Keys + #9
        Else
        If MenuList[A].HotKey = 'ESCAPE' Then
          Keys := Keys + #27
        Else
        If MenuList[A].HotKey = 'UP' Then
          ExtKeys := ExtKeys + #72
        Else
        If MenuList[A].HotKey = 'LEFT' Then
          ExtKeys := ExtKeys + #75
        Else
        If MenuList[A].HotKey = 'RIGHT' Then
          ExtKeys := ExtKeys + #77
        Else
        If MenuList[A].HotKey = 'DOWN' Then
          ExtKeys := ExtKeys + #80
        Else
          Keys := Keys + MenuList[A].HotKey[1];

    If (Menu.MenuType > 0) and (Session.io.Graphics = 1) Then
      Do_LightBar_Menu
    Else
      Do_Internal_Menu;
  Until Done;
End;

End.