Power-Programmierung/CD1.mdf/pascal/das_buch/tvision/ide/ide.pas

Pascal/Delphi Source File | 1993-05-03 | 21.3 KB | 729 lines

(* ------------------------------------------------------ *)
(*                       IDE.PAS                          *)
(*    Integrierte Benutzeroberfläche für TASM oder BASM   *)
(*     (c) 1993 Wolfhard Rinke & te-wi Verlag, München    *)
(* ------------------------------------------------------ *)
PROGRAM IDE;

{$A+,B-,D+,E+,F-,G-,I+,L+,N-,O-,P-,Q+,R+,S+,T-,V+,X+,Y+}
{$M 16384,0,655360}

USES Dos, Objects, Drivers, Memory, Views, Menus, App,
     Dialogs, MsgBox, StdDlg, Calc, ASCIITab, IDE_Dlg,
     TxDos, TxEdit, IDE_Konst, HexCalc, Spooler, Browser,
     RedirOut;

(* ------------------------------------------------------ *)

TYPE
  pTitleText = ^tTitleText;
  tTitleText = OBJECT (tStaticText)
    FUNCTION GetPalette : pPalette;  VIRTUAL;
  END;

  FUNCTION tTitleText.GetPalette : pPalette;
  CONST
    P : STRING [Length(cStatusLine)] = cStatusLine;
  BEGIN
    GetPalette := @P;
  END;

(* ------------------------------------------------------ *)

TYPE
  tIDE_App = OBJECT (tApplication)
    ClipboardWindow : pEditWindow;
    WindNo          : INTEGER;
    WorkFile        : FNameStr;
    ErrFile         : FNameStr;

    CONSTRUCTOR Init;
    PROCEDURE   InitStatusLine; VIRTUAL;
    PROCEDURE   InitMenuBar;    VIRTUAL;
    PROCEDURE   HandleEvent(VAR Event : tEvent); VIRTUAL;
    PROCEDURE   NewEditWin(FileName : FNameStr);
    PROCEDURE   OpenWindow;
    PROCEDURE   ShowClipBoard;
    PROCEDURE   SaveDesktop;
    PROCEDURE   LoadDesktop;
  PRIVATE
    Develop    : BOOLEAN;
    EraseBat   : BOOLEAN;
    EditBak    : BOOLEAN;
    DefaultExt : PathStr;
    UtilPath   : PathStr;
    LibPath    : PathStr;
    ObjPath    : PathStr;
    IncPath    : PathStr;
    AsmOpts    : STRING;
    LinkOpts   : STRING;

    PROCEDURE   DoHexCalc;
    PROCEDURE   DoDezCalc;
    PROCEDURE   DoAsciiTab;
    PROCEDURE   DoAboutBox;
    PROCEDURE   Directories;
    PROCEDURE   DoPrint;
    PROCEDURE   Browse(FileName : PathStr; Open : BOOLEAN);
    PROCEDURE   ChangeDir;
    PROCEDURE   DoAsmOpts;
    PROCEDURE   DoLinkOpts;
    PROCEDURE   ShutSystem(Video : BOOLEAN);
    PROCEDURE   ReInitSystem(Video : BOOLEAN);
    PROCEDURE   DoAssemble;
    PROCEDURE   DoLink;
  END;

  PROCEDURE tIDE_App.SaveDesktop;
  VAR
    DeskFile : tBufStream;
  BEGIN
    Desktop^.Delete(ClipBoardWindow);
    WITH DeskFile DO BEGIN
      Init(DesktopFileName, stCreate, 1024);
      Put(Desktop);
      Done;
    END;
    InsertWindow(ClipBoardWindow);
  END;

  PROCEDURE tIDE_App.LoadDesktop;
  VAR
    DeskFile  : tBufStream;
    TempDesk  : pDesktop;
    R         : tRect;
  BEGIN
    DeskFile.Init(DesktopFileName, stOpenRead, 1024);
    TempDesk := pDeskTop(DeskFile.Get);
    DeskFile.Done;
    IF ValidView(TempDesk) <> NIL THEN BEGIN
      Desktop^.Delete(ClipboardWindow);
      Delete(Desktop);
      Dispose(Desktop, Done);
      Desktop := TempDesk;
      Insert(Desktop);
      GetExtent(R);
      R.Grow(0, -1);
      Desktop^.Locate(R);
      InsertWindow(ClipboardWindow);
    END;
  END;

  PROCEDURE tIDE_App.ShowClipBoard;
  BEGIN
    WITH ClipBoardWindow^ DO BEGIN
      Select;
      Show;
    END;
  END;

  PROCEDURE tIDE_App.OpenWindow;
  VAR
    R : tRect;
    F : pFileDialog;
    N : FNameStr;
  BEGIN
    N := DefaultExt;
    New(F, Init(N, 'Open File', '~F~ile name',
      fdOkButton OR fdOpenButton, 1));
    IF ExecuteDialog(F, @N) <> cmCancel THEN BEGIN
      GetExtent(R);
      Dec(R.B.Y, 2);
      InsertWindow(New(pEditWindow, Init(R, N, WindNo)));
      Inc(WindNo);
      WorkFile := N;
    END;
  END;

  CONSTRUCTOR tIDE_App.Init;
  VAR
    R : tRect;
  BEGIN
    MaxHeapSize  := 8192;
    EditorDialog := StdEditorDialog;
    StreamError  := @EditStreamError;
    RegisterObjects;
    RegisterViews;
    RegisterApp;
    RegisterEditors;
    RegisterCalc;
    RegisterPetzCalc;
    RegisterAsciiTab;
    RegisterBrowser;
    inherited Init;

(* ------------------- *)

    Desktop^.GetExtent(R);
    ClipBoardWindow := New(pEditWindow, Init(R, '', wnNoNumber));
    IF ValidView(ClipBoardWindow) <> NIL THEN BEGIN
      ClipBoardWindow^.Hide;
      InsertWindow(ClipboardWindow);
      ClipBoard := ClipBoardWindow^.Editor;
      ClipBoard^.CanUndo := FALSE;
    END;

      (* Prepare Desktop ID for pMenuBar *)
    R.A.X := R.B.X - Length(DesktopID) - 1;
    R.B.Y := R.A.Y + 1;
    Insert(New(pTitleText, Init(R, DesktopID)));

    WindNo := 1;

      (* Command Line Parameter *)
    IF ParamCount = 1 THEN BEGIN
      WorkFile := ParamStr(1);
      IF Pos('.', WorkFile) = 0 THEN
        WorkFile := SetDefaultExt(WorkFile, '.ASM');
      IF Exists(WorkFile) THEN
        NewEditWin(WorkFile)
      ELSE
        WorkFile := '';
    END;
    IF (WorkFile = '') OR NOT Exists(WorkFile) THEN BEGIN
      DoAboutBox;
      NewEditWin('');
    END ELSE
      NewEditWin(WorkFile);

    IF WorkFile <> '' THEN BEGIN
      ErrFile := SetDefaultExt(WorkFile, '.ERR');
      EnableCommands([cmAssemble]);
      IF Exists(ErrFile) THEN EnableCommands([cmLastError]);
    END ELSE
      ErrFile := '';

    (* Defaults *)
    UtilPath   := 'C:\BP\BIN\';
    LibPath    := 'C:\BP\ASM\LIB\';
    ObjPath    := 'C:\BP\ASM\OBJ\';
    IncPath    := 'C:\BP\ASM\SRC\';
    Develop    := TRUE;
    EraseBat   := FALSE;
    EditBak    := TRUE;
    DefaultExt := '*.ASM';
  END;

  PROCEDURE tIDE_App.NewEditWin(FileName : FNameStr);
  VAR
    R : tRect;
    E : pEditWindow;
  BEGIN
    GetExtent(R);
    Dec(R.B.Y, 2);
    E := New(pEditWindow, Init(R, FileName, WindNo));
    InsertWindow(E);
    Inc(WindNo);
  END;

  PROCEDURE tIDE_App.Browse(FileName : PathStr; Open : BOOLEAN);
  VAR
    D : pFileDialog;
    N : PathStr;
    W : pWindow;
    R : tRect;
  BEGIN
    N := FileName;
    IF (FileName = '') OR NOT Open THEN BEGIN
      (* kein Dateiname angegeben *)
      D := pFileDialog(ValidView(New(pFileDialog,
                       Init(FileName, 'Browse a file',
                       '~N~ame', fdOpenButton, 100))));

      IF ExecuteDialog(D, @N) <> cmCancel THEN BEGIN
        R.Assign(0, 0, 80, 10);
        W := pWindow(ValidView(New(pFileWindow, Init(R, N))));
        IF W <> NIL THEN Desktop^.Insert(W);
      END;
    END ELSE BEGIN
      R.Assign(0, 0, 80, 10);
      W := pWindow(ValidView(New(pFileWindow, Init(R, N))));
      IF W <> NIL THEN Desktop^.Insert(W);
    END;
  END;

  PROCEDURE tIDE_App.ShutSystem(Video : BOOLEAN);
  BEGIN
    DoneSysError;
    DoneEvents;
    IF Video THEN DoneVideo;
    DoneDosMem;
    SwapVectors;
  END;

  PROCEDURE tIDE_App.ReInitSystem(Video : BOOLEAN);
  BEGIN
    SwapVectors;
    InitDosMem;
    IF Video THEN InitVideo;
    InitEvents;
    InitSysError;
    Redraw;
  END;

(* ------------------------------------------------------ *)

  FUNCTION GetPointerToViewer : pView;

    FUNCTION IsMyView(P : pView) : BOOLEAN; FAR;
    BEGIN
      IsMyView := (TypeOf(P^) = TypeOf(tEditWindow));
    END;

  BEGIN
    GetPointerToViewer := Desktop^.FirstThat(@IsMyView);
  END;

(* ------------------------------------------------------ *)

  PROCEDURE tIDE_App.DoAsmOpts;
  VAR
    Data : AsmOptRec;
    S    : STRING;  (* Instanz im Hauptobjekt wg Resource/Stream *)
                    (* ... aber den Record mit den Data zu speichern,
                      wäre natürlich erheblich besser ! *)
  BEGIN
    S := ' /t';
    (* /t = always supress messages when no warnigs *)
    WITH Data DO BEGIN
      (* Defaults: *)
      SegOrder  := $0000; (* 1 *)
      DebugInfo := $0000; (* 2 *)
      CrossRef  := $0000; (* 3 *)
      Warnings  := $0000; (* 4 *)
      Floating  := $0000; (* 5 *)
      Listing   := $0000; (* 6 *)
      ListErr   := $0000; (* 7 *)
      Code      := $0000; (* 8 *)
      Special   := $0000; (* 9 *)
    END;
    ExecuteDialog(AsmOptDlg, @Data);
    WITH Data DO BEGIN
      IF SegOrder = 0 THEN S := S + ' /a' ELSE S := S + ' /s';
      CASE DebugInfo OF
        0 : S := S + ' /zi';
        1 : S := S + ' /zd';
        2 : S := S + ' /zn';
      END;
      IF CrossRef = 1 THEN S := S + ' /c';
      CASE Warnings OF
        0 : S := S + ' /w0';
        1 : S := S + ' /w1';
        2 : S := S + ' /w2';
      END;
      IF Floating = 0 THEN S := S + ' /e' ELSE S := S + ' /r';
      IF Listing  = 0 THEN S := S + ' /l' ELSE S := S + ' /la';
      IF (ListErr AND 1) = 1 THEN S := S + ' /n';
      IF (ListErr AND 2) = 2 THEN S := S + ' /z';
      IF (ListErr AND 4) = 4 THEN S := S + ' /x';
      CASE Code OF
        0 : S := S + ' /os';
        1 : S := S + ' /o';
        2 : S := S + ' /op';
        3 : S := S + ' /oi';
      END;
      IF (Special AND 1) = 1 THEN S := S + ' /p';
      IF (Special AND 2) = 2 THEN S := S + ' /q';
    END;
    AsmOpts := S;
  END;

  PROCEDURE tIDE_App.DoAssemble;
  VAR
    Err : STRING;
    N   : FNameStr;
    E   : pEditWindow;
  BEGIN
    E := pEditWindow(GetPointerToViewer);
    N := E^.GetTitle(64);

    MessageBox('WorkFile ' + N + ' to be assembled',
               NIL, mfInformation + mfOkButton);

   (*
     Syntax:  TASM [options] source [,object] [,listing] [,xref]
    /iPATH        Search PATH for include files  = IncPath;
   *)

    ShutSystem(FALSE);
    RedOut;                       (* redirect stdout to STDOUT.RED *)
    Exec(UtilPath + 'TASM.EXE', AsmOpts + ' /t' + WorkFile + ',,,;');
    Redback;                      (* redirect STDOUT.RED to stdout *)
    ReInitSystem(FALSE);
    IF DosError <> 0 THEN BEGIN
      Str(DosError, Err);
      MessageBox('Dos error #' + Err, NIL, mfError + mfOkButton);
    END ELSE BEGIN
      IF DosExitCode <> 0 THEN BEGIN
        Str(DosExitCode, Err);
        MessageBox('Child process exit code = ' + Err,
                   NIL, mfInformation + mfOkButton);

      (* wenn child process exit code = 0, alles klar. *)
      (*     1 = Fehler *)
        Browse('STDOUT.RED', TRUE);
      END ELSE
        MessageBox('Assembly successful.', NIL, mfInformation + mfOkButton);
    END;
  END;

(* ------------------------------------------------------ *)

  PROCEDURE tIDE_App.DoLinkOpts;
  VAR
    Data : LinkOptRec;
    S    : STRING;
  BEGIN
    S := '';
    WITH Data DO BEGIN
      DebugInfo := $0000;
      MemSwap   := $0000;
      Libraries := $0000;
      Target    := $0000;
    END;
    ExecuteDialog(LinkOptDlg, @Data);
    WITH Data DO BEGIN
      IF (DebugInfo AND  1) =  1 THEN S := S + ' /m';
      IF (DebugInfo AND  2) =  2 THEN S := S + ' /x';
      IF (DebugInfo AND  4) =  4 THEN S := S + ' /l';
      IF (DebugInfo AND  8) =  8 THEN S := S + ' /s';
      IF (DebugInfo AND 16) = 16 THEN S := S + ' /v';
      IF (DebugInfo AND 32) = 32 THEN S := S + ' /i';
      IF (DebugInfo AND 64) = 64 THEN S := S + ' /o';
      IF MemSwap = 0 THEN S := S + ' /ye' ELSE S := S + ' /yx';
      IF (Libraries AND  1) =  1 THEN S := S + ' /n';
      IF (Libraries AND  2) =  2 THEN S := S + ' /d';
      IF (Libraries AND  4) =  4 THEN S := S + ' /c';
      IF (Libraries AND  8) =  8 THEN S := S + ' /e';
      IF (Libraries AND 16) = 16 THEN S := S + ' /C';
      IF (Libraries AND 32) = 32 THEN S := S + ' /3';
      CASE Target OF
        0 : S := S + ' /Tdc';
        1 : S := S + ' /Tdx';
        2 : S := S + ' /Tdd';
        3 : S := S + ' /Twc';
        4 : S := S + ' /Twx';
        5 : S := S + ' /Twd';
      END;
    END;
  END;

  PROCEDURE tIDE_App.DoLink;
  VAR
    Err : STRING;
    N   : FNameStr;
    E   : pEditWindow;
  BEGIN
    E := pEditWindow(GetPointerToViewer);
    N := E^.GetTitle(64);

    MessageBox('WorkFile ' + N + ' to be linked',
               NIL, mfInformation + mfOkButton);

     (*
       Syntax: TLINK objfiles, exefile, mapfile, libfiles, deffile
               /L  Specify library search paths
     *)

    ShutSystem(FALSE);
    RedOut;          (* redirect stdout to STDOUT.RED *)
    Exec(UtilPath + 'TLINK.EXE', LinkOpts + ' ' + N + ',,,,,;');
    RedBack;
    ReInitSystem(FALSE);
    IF DosError <> 0 THEN BEGIN
      Str(DosError, Err);
      MessageBox('Dos error #' + Err, NIL, mfError + mfOkButton);
    END ELSE BEGIN
      IF DosExitCode <> 0 THEN BEGIN
        Str(DosExitCode, Err);
        MessageBox('Child process exit code = ' + Err,
                   NIL, mfInformation + mfOkButton);
        Browse('STDOUT.RED', TRUE)
      END ELSE
        MessageBox('Linkage successful.',
                   NIL, mfInformation + mfOkButton);
    END;
  END;

  PROCEDURE tIDE_App.DoPrint;
  VAR
    E : pEditWindow;
    N : FNameStr;
  BEGIN
    E := pEditWindow(GetPointerToViewer);
    N := E^.GetTitle(64);
    IF SpoolerState THEN
      SubmitFile(N)
    ELSE
      MessageBox(#3'PRINT.COM not installed',
                 NIL, mfError OR mfOkButton);

      (* alternativ: Datei Öffnen,
                     while not eof ...
                     Readln
                     writeln(lst)
                     end while
                     Datei schließen
      *)
  END;

  PROCEDURE tIDE_App.DoAboutBox;
  BEGIN
    MessageBox(#3 + DeskTopID + #13+
               #3'Integrierte Benutzeroberfläche'#13+
               #3'(c) 1993 Wolfhard Rinke & '#13+
               #3'te-wi Verlag, München'#13#13,
               NIL, mfInformation OR mfOkButton);
  END;

  PROCEDURE tIDE_App.DoHexCalc;
  VAR
    C : pPetzCalc;
  BEGIN
    C := New(pPetzCalc, Init);
    Desktop^.Insert(C);
  END;

  PROCEDURE tIDE_App.DoDezCalc;
  VAR
    C : pCalculator;
  BEGIN
    C := New(pCalculator, Init);
    Desktop^.Insert(C);
  END;

  PROCEDURE tIDE_App.DoAsciiTab;
  VAR
    C : pAsciiChart;
  BEGIN
    C := New(pAsciiChart, Init);
    Desktop^.Insert(C);
  END;

  PROCEDURE tIDE_App.ChangeDir;
  BEGIN
    ExecuteDialog(New(pChDirDialog, Init(cdNormal, 0)), NIL);
  END;

  PROCEDURE tIDE_App.Directories;
  VAR
    DirInfo : RECORD
                UtilPath : PathStr;
                LibPath  : PathStr;
                ObjPath  : PathStr;
                IncPath  : PathStr;
              END;
  BEGIN
    DirInfo.UtilPath := UtilPath;
    DirInfo.LibPath  := LibPath;
    DirInfo.ObjPath  := ObjPath;
    DirInfo.IncPath  := IncPath;

    ExecuteDialog(CreateDirDialog, @DirInfo);

    UtilPath := DirInfo.UtilPath;
    LibPath  := DirInfo.LibPath;
    ObjPath  := DirInfo.ObjPath;
    IncPath  := DirInfo.IncPath;
  END;

(* ------------------------------------------------------ *)

  PROCEDURE tIDE_App.HandleEvent(VAR Event : tEvent);

    PROCEDURE Toggle(Command : WORD);
    VAR
      P : pMenuItem;

      FUNCTION FindMenuItem(Command : WORD) : pMenuItem;
      VAR
        P : pMenuItem;
        M : pMenu;
      BEGIN
        IF MenuBar <> NIL THEN BEGIN
          M := MenuBar^.Menu;
          P := M^.Default;
          WHILE (P <> NIL) AND (P^.Command <> Command) DO BEGIN
            IF P^.Command = 0 THEN BEGIN
              M := P^.SubMenu;
              P := M^.Default;
            END ELSE
              P := NIL;
          END;
        END;
        FindMenuItem := P;
      END;

    BEGIN
      IF Command = cmDevelop THEN BEGIN
        P := FindMenuItem(cmDevelop);
        IF P <> NIL THEN BEGIN
          IF P^.Param^ = '√' THEN BEGIN
            DisposeStr(P^.Param);
            P^.Param := NewStr(' ');
            Develop  := FALSE;
          END ELSE BEGIN
            DisposeStr(P^.Param);
            P^.Param := NewStr('√');
            Develop  := TRUE;
          END;
        END;
      END ELSE IF Command = cmEditBak THEN BEGIN
        P := FindMenuItem(cmEditBak);
        IF P <> NIL THEN BEGIN
          IF P^.Param^ = '√' THEN BEGIN
            DisposeStr(P^.Param);
            P^.Param := NewStr(' ');
            EditBak  := FALSE;
          END ELSE BEGIN
            DisposeStr(P^.Param);
            P^.Param := NewStr('√');
            EditBak  := TRUE;
          END;
        END;
      END ELSE IF Command = cmDefaultExt THEN BEGIN
        P := FindMenuItem(cmDefaultExt);
        IF P <> NIL THEN BEGIN
          IF P^.Param^ = '.ASM' THEN BEGIN
            DisposeStr(P^.Param);
            P^.Param   := NewStr('    ');
            DefaultExt := '*.*';
          END ELSE BEGIN
            DisposeStr(P^.Param);
            P^.Param   := NewStr('.ASM');
            DefaultExt := '*.ASM';
          END;
        END;
      END;
    END;

  BEGIN
    inherited HandleEvent(Event);

    IF Event.What = evCommand THEN BEGIN
      CASE Event.Command OF
        cmAbout       : DoAboutBox;
        cmCalc        : DoDezCalc;
        cmAsciiTab    : DoAsciiTab;
        cmHexCalc     : DoHexCalc;
        cmNew         : NewEditWin('');
        cmOpen        : OpenWindow;
        cmClipShow    : ShowClipBoard;
        cmOptionsSave : SaveDesktop;
        cmOptionsLoad : LoadDesktop;
        cmDevelop     : Toggle(cmDevelop);
        cmEraseBat    : Toggle(cmEraseBat);
        cmEditBak     : Toggle(cmEditBak);
        cmDefaultExt  : Toggle(cmDefaultExt);
        cmDirectories : Directories;
        cmLastError   : Browse(ErrFile, TRUE);
        cmPrint       : DoPrint;
        cmChDir       : ChangeDir;
        cmAsmOpts     : DoAsmOpts;
        cmLinkOpts    : DoLinkOpts;
        cmAssemble    : DoAssemble;
        cmLink        : DoLink;
      ELSE
        Exit;
      END;
      ClearEvent(Event);
    END;
  END;

  PROCEDURE tIDE_App.InitMenuBar;
  VAR
    R : tRect;
  BEGIN
    GetExtent(R);
    R.B.Y := R.A.Y + 1;
    MenuBar := New(pMenuBar, Init(R, NewMenu(
      NewSubMenu('~≡~', hcNoContext, NewMenu(
        NewItem('~D~ez Calculator', '', kbNoKey, cmCalc, hcNoContext,
        NewItem('~H~ex Calculator', '', kbNoKey, cmHexCalc, hcNoContext,
        NewItem('~A~SCII Table',    '', kbNoKey, cmASCIITab, hcNoContext,
        NewLine(
        NewItem('A~b~out...', '', kbNoKey, cmAbout, hcNoContext,
      NIL)))))),
      NewSubMenu('~F~ile', hcNoContext, NewMenu(
        NewItem('~N~ew', '', kbNoKey, cmNew, hcNoContext,
        NewItem('~O~pen...', 'F3', kbF3, cmOpen, hcNoContext,
        NewItem('~S~ave', 'F2', kbF2, cmSave, hcNoContext,
        NewItem('Save ~a~s...', '', kbNoKey, cmSaveAs, hcNoContext,
        NewLine(
        NewItem('~P~rint', '', kbNoKey, cmPrint, hcNoContext,
        NewLine(
        NewItem('~C~hange directory...', '', kbNoKey, cmChDir, hcNoContext,
        NewItem('~D~OS Shell', '', kbNoKey, cmDosShell, hcNoContext,
        NewItem('E~x~it', 'Alt+X', kbAltX, cmQuit, hcNoContext,
      NIL))))))))))),
      NewSubMenu('~E~dit', hcNoContext, NewMenu(
        NewItem('~U~ndo', '', kbAltBack, cmUndo, hcUndo,
        NewLine(
        NewItem('Cu~t~', 'Shift-Del', kbShiftDel, cmCut, hcCut,
        NewItem('~C~opy', 'Ctrl-Ins', kbCtrlIns, cmCopy, hcCopy,
        NewItem('~P~aste', 'Shift-Ins', kbShiftIns, cmPaste, hcPaste,
        NewItem('C~l~ear', 'Ctrl-Del', kbCtrlDel, cmClear, hcClear,
        NewLine(
        NewItem('~S~how clipboard', '', kbNoKey, cmClipShow,
                hcNoContext,
      NIL))))))))),
      NewSubMenu('~S~earch', hcNoContext, NewMenu(
        NewItem('~F~ind...', '', kbNoKey, cmFind, hcNoContext,
        NewItem('~R~eplace...', '', kbNoKey, cmReplace, hcNoContext,
        NewItem('Search ~a~gain', '', kbNoKey, cmSearchAgain, hcNoContext,
        NewLine(
        NewItem('~G~oto...', '', kbNoKey, cmGoto, hcNoContext,
        NewItem('~L~ast Error...', '', kbNoKey, cmLastError, hcNoContext,
      NIL))))))),
      NewSubMenu('~M~ake', hcNoContext, NewMenu(
        NewItem('~A~ssemble', 'F9', kbF9, cmAssemble, hcNoContext,
        NewItem('~L~ink', 'Alt+F9', kbAltF9, cmLink, hcNoContext,
      NIL))),
      NewSubMenu('~O~ptions', hcNoContext, NewMenu(
        NewItem('~D~evelop', '√', kbNoKey, cmDevelop, hcNoContext,
        NewItem('~C~reate Backup', '√', kbNoKey, cmEditBak, hcNoContext,
        NewItem('~A~ssembler', '', kbNoKey, cmAsmOpts, hcNoContext,
        NewItem('Lin~k~er', '', kbNoKey, cmLinkOpts, hcNoContext,
        NewItem('Default E~x~tension', '.ASM', kbNoKey, cmDefaultExt, hcNoContext,
        NewLine(
        NewItem('~E~nvironment...', '', kbNoKey, cmDirectories, hcNoContext,
        NewLine(
        NewItem('~L~oad desktop', '', kbNoKey, cmOptionsLoad, hcNoContext,
        NewItem('~S~ave desktop', '', kbNoKey, cmOptionsSave, hcNoContext,
      NIL))))))))))),
      NewSubMenu('~W~indow', hcNoContext, NewMenu(
        StdWindowMenuItems(NIL)),
    NIL))))))))));
  END;

  PROCEDURE tIDE_App.InitStatusLine;
  VAR
    R : tRect;
  BEGIN
    GetExtent(R);
    R.A.Y := R.B.Y - 1;
    New(StatusLine, Init(R,
      NewStatusDef(0, $F000,
        NewStatusKey('~Alt+X~ Exit', kbAltX, cmQuit,
        NewStatusKey('~F2~ Save', kbF2, cmSave,
        NewStatusKey('~F3~ Open', kbF3, cmOpen,
        NewStatusKey('~F9~ Assemble', kbF9, cmAssemble,
        NewStatusKey('~Alt+F9~ Link', kbAltF9, cmLink,
        NewStatusKey('~F10~ Menu', kbF10, cmMenu,
        NIL)))))),
      NIL)));
  END;

(* ------------------------------------------------------ *)

VAR
  IDE_App : tIDE_App;

BEGIN
  IDE_App.Init;
  IDE_App.Run;
  IDE_App.Done;
END.
(* ------------------------------------------------------ *)
(*                    Ende von IDE.PAS                    *)