home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / dtx9302 / tvision / tvpas / tvxedit.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1992-11-10  |  22.5 KB  |  878 lines
  1. (* ------------------------------------------------------ *)
  2. (*                     TVXEDIT.PAS                        *)
  3. (*                                                        *)
  4. (*        Editor mit erweitertem Menü + druckfähig        *)
  5. (*         (C) 1992 by Christian Ohr & DMV-Verlag         *)
  6. (*            (C) 1990 Borland international              *)
  7. (* ------------------------------------------------------ *)
  8.  
  9. {$R-,S-,I-,B-,D-,L-,V-,A+,F+,O+,X+}
  10. {$M 4096,8192,655360}
  11.  
  12.  
  13. PROGRAM TVXEdit;
  14.  
  15.  
  16. USES Crt, Dos, Objects, Drivers, Memory, Views, Menus,
  17.      Dialogs, StdDlgG, MsgBoxG, App, Buffers, Editors,
  18.      XViews, XMenus, XObjects, XDrivers, XDialogs,
  19.      XGadgets, XMacro;
  20.  
  21.  
  22. CONST
  23.   HeapSize = 32 * (1024 DIV 16);       (* 32 kB Rest-Heap *)
  24.  
  25.   cmOpen         = 100;
  26.   cmNew          = 101;
  27.   cmChangeDir    = 102;
  28.   cmDosShell     = 103;
  29.   cmShowClip     = 104;
  30.   cmVideoMode    = 105;
  31.   cmPrint        = 106;
  32.   cmStoreDesktop = 107;
  33.   cmLoadDesktop  = 108;
  34.   cmAbout        = 109;
  35.   cmIndent       = 110;
  36.   cmOvWrt        = 111;
  37.  
  38.  
  39. TYPE
  40.   pXEditWindow = ^tXEditWindow;
  41.   tXEditWindow = OBJECT(tXWindow)
  42.     Editor: pFileEditor;
  43.     CONSTRUCTOR Init (VAR Bounds: tRect; FileName: FNameStr;
  44.                       ANumber: INTEGER);
  45.     CONSTRUCTOR Load(VAR S: tStream);
  46.     PROCEDURE Close; VIRTUAL;
  47.     FUNCTION GetTitle (MaxSize: INTEGER): tTitleStr;
  48.                       VIRTUAL;
  49.     PROCEDURE HandleEvent (VAR Event: tEvent); VIRTUAL;
  50.     PROCEDURE InitMenuBar; VIRTUAL;
  51.     PROCEDURE InitStatusLine; VIRTUAL;
  52.     FUNCTION IsClipWindow: BOOLEAN;
  53.     PROCEDURE Store (VAR S: tStream); VIRTUAL;
  54.   END;
  55.  
  56.  
  57.   pEditorApp = ^tEditorApp;
  58.   tEditorApp = OBJECT(tMacroApplication)
  59.     Buzzer: pBuzzer;
  60.     CONSTRUCTOR Init;
  61.     DESTRUCTOR Done; VIRTUAL;
  62.     PROCEDURE HandleEvent(VAR Event: tEvent); VIRTUAL;
  63.     PROCEDURE Idle; VIRTUAL;
  64.     PROCEDURE InitMenuBar; VIRTUAL;
  65.     PROCEDURE InitStatusLine; VIRTUAL;
  66.     PROCEDURE LoadDesktop;
  67.     PROCEDURE OutOfMemory; VIRTUAL;
  68.     PROCEDURE StoreDesktop;
  69.   END;
  70.  
  71.  
  72. CONST
  73.   rXEditWindow: tStreamRec = (
  74.     ObjType: 1600;
  75.     VmtLink: Ofs(TypeOf(tXEditWindow)^);
  76.     Load: @tXEditWindow.Load;
  77.     Store: @tXEditWindow.Store
  78.   );
  79.  
  80.   Check: STRING[2] = ' √';
  81.  
  82.  
  83. VAR
  84.   EditorApp: tEditorApp;
  85.   ClipWindow: pXEditWindow;
  86.   PrnS: pPrintStream;
  87.  
  88.  
  89. FUNCTION CreateFindDialog: pDialog;
  90. VAR
  91.   D: pDialog;
  92.   Control: pView;
  93.   R: tRect;
  94. BEGIN
  95.   R.Assign(0, 0, 38, 12);
  96.   D := New(pDialog, Init(R, 'Finden'));
  97.   WITH D^ DO BEGIN
  98.     Options := Options OR ofCentered;
  99.  
  100.     R.Assign(3, 3, 32, 4);
  101.     Control := New(pInputLine, Init(R, 80));
  102.     Insert(Control);
  103.     R.Assign(2, 2, 15, 3);
  104.     Insert(New(pLabel, Init(R, '~S~uchen nach', Control)));
  105.     R.Assign(32, 3, 35, 4);
  106.     Insert(New(pHistory, Init(R, pInputLine(Control), 10)));
  107.  
  108.     R.Assign(3, 5, 35, 7);
  109.     Insert(New(pCheckBoxes, Init(R,
  110.       NewSItem('~G~roß-/Kleinschreibung',
  111.       NewSItem('~A~ls ~W~ort', NIL)))));
  112.  
  113.     R.Assign(13, 9, 23, 11);
  114.     Insert(New(pButton, Init(R, 'O~K~', cmOk, bfDefault)));
  115.     Inc(R.A.X, 12); Inc(R.B.X, 13);
  116.     Insert(New(pButton, Init(R, 'Abbruch', cmCancel,
  117.                              bfNormal)));
  118.  
  119.     SelectNext(FALSE);
  120.   END;
  121.   CreateFindDialog := D;
  122. END;
  123.  
  124.  
  125. FUNCTION CreateReplaceDialog: pDialog;
  126. VAR
  127.   D: pDialog;
  128.   Control: pView;
  129.   R: tRect;
  130. BEGIN
  131.   R.Assign(0, 0, 40, 16);
  132.   D := New(pDialog, Init(R, 'Ersetzen'));
  133.   WITH D^ DO BEGIN
  134.     Options := Options OR ofCentered;
  135.  
  136.     R.Assign(3, 3, 34, 4);
  137.     Control := New(pInputLine, Init(R, 80));
  138.     Insert(Control);
  139.     R.Assign(2, 2, 15, 3);
  140.     Insert(New(pLabel, Init(R, '~S~uchen nach', Control)));
  141.     R.Assign(34, 3, 37, 4);
  142.     Insert(New(pHistory, Init(R, pInputLine(Control), 10)));
  143.  
  144.     R.Assign(3, 6, 34, 7);
  145.     Control := New(pInputLine, Init(R, 80));
  146.     Insert(Control);
  147.     R.Assign(2, 5, 12, 6);
  148.     Insert(New(pLabel, Init(R,'~E~rsetzen durch',Control)));
  149.     R.Assign(34, 6, 37, 7);
  150.     Insert(New(pHistory, Init(R, pInputLine(Control), 11)));
  151.  
  152.     R.Assign(3, 8, 37, 12);
  153.     Insert(New(pCheckBoxes, Init(R,
  154.       NewSItem('~G~roß-/Kleinschreibung',
  155.       NewSItem('~A~ls Wort',
  156.       NewSItem('~B~estätigen',
  157.       NewSItem('A~l~les ersetzen', NIL)))))));
  158.  
  159.     R.Assign(15, 13, 25, 15);
  160.     Insert(New(pButton, Init(R, 'O~K~', cmOk, bfDefault)));
  161.     Inc(R.A.X, 12); Inc(R.B.X, 13);
  162.     Insert(New(pButton, Init(R, 'Abbruch', cmCancel,
  163.                              bfNormal)));
  164.  
  165.     SelectNext(FALSE);
  166.   END;
  167.   CreateReplaceDialog := D;
  168. END;
  169.  
  170.  
  171. FUNCTION DoDialog(Dialog: INTEGER; Info: POINTER):WORD; FAR;
  172. VAR
  173.   R: tRect;
  174.   T: tPoint;
  175. BEGIN
  176.   CASE Dialog OF
  177.     edOutOfMemory:
  178.       DoDialog := MessageBox(
  179.         'Nicht genügend Speicher vorhanden.',
  180.         NIL, mfError + mfOkButton);
  181.     edReadError:
  182.       DoDialog := MessageBox('Datei %s nicht lesbar.',
  183.         @Info, mfError + mfOkButton);
  184.     edWriteError:
  185.       DoDialog := MessageBox('Datei %s nicht schreibbar.',
  186.         @Info, mfError + mfOkButton);
  187.     edCreateError:
  188.       DoDialog := MessageBox('Datei %s nicht erstellt.',
  189.         @Info, mfError + mfOkButton);
  190.     edSaveModify:
  191.       DoDialog := MessageBox(
  192.         '%s wurde modifiziert. Sichern?',
  193.         @Info, mfInformation + mfYesNoCancel);
  194.     edSaveUntitled:
  195.       DoDialog := MessageBox('Unbenannte Datei sichern?',
  196.         NIL, mfInformation + mfYesNoCancel);
  197.     edSaveAs:
  198.       DoDialog := ExecDialog(New(PFileDialog,Init('*.*',
  199.         'Sichern unter', '~N~ame', fdOkButton, 101)), Info);
  200.     edFind:
  201.       DoDialog := ExecDialog(CreateFindDialog, Info);
  202.     edSearchFailed:
  203.       DoDialog := MessageBox('Suchbegriff nicht gefunden.',
  204.         NIL, mfError + mfOkButton);
  205.     edReplace:
  206.       DoDialog := ExecDialog(CreateReplaceDialog, Info);
  207.     edReplacePrompt:
  208.      BEGIN
  209.         R.Assign(0, 1, 40, 8);
  210.         R.Move((Desktop^.Size.X - R.B.X) DIV 2, 0);
  211.         Desktop^.MakeGlobal(R.B, T);
  212.         Inc(T.Y);
  213.         IF tPoint(Info).Y <= T.Y THEN
  214.           R.Move(0, Desktop^.Size.Y - R.B.Y - 2);
  215.         DoDialog := MessageBoxRect(R,
  216.           'Begriff ersetzen?',
  217.           NIL, mfYesNoCancel + mfInformation);
  218.       END;
  219.   END;
  220. END;
  221.  
  222.  
  223. FUNCTION OpenEditor(FileName: FNameStr; Visible: BOOLEAN;
  224.                     ANumber: INTEGER): pXEditWindow;
  225. VAR
  226.   P: pView;
  227.   R: tRect;
  228. BEGIN
  229.   DeskTop^.GetExtent(R);
  230.   P := Application^.ValidView(New(pXEditWindow,
  231.     Init(R, FileName, ANumber)));
  232.   IF NOT Visible THEN P^.Hide;
  233.   DeskTop^.Insert(P);
  234.   OpenEditor := pXEditWindow(P);
  235. END;
  236.  
  237.  
  238. PROCEDURE Print;
  239. BEGIN
  240.   PrnS := New(pPrintStream, Init(LPT1));
  241.   IF TypeOf(Desktop^.Current^) = TypeOf(tXEditWindow) THEN
  242.     WITH pXEditWindow(Desktop^.Current)^.Editor^ DO
  243.       IF SelStart = SelEnd THEN BEGIN
  244.         Message(Desktop^.Current, evCommand, cmTextEnd,NIL);
  245.         PrnS^.Write(Buffer^[0], BufLen);
  246.       END ELSE
  247.         PrnS^.Write(Buffer^[SelStart], SelEnd - SelStart);
  248.   IF PrnS^.Status <> 0 THEN
  249.     MessageBox(PrnCodeStr[PrnS^.ErrorInfo], NIL,
  250.                mfError + mfOkButton);
  251.   Dispose(PrnS, Done);
  252. END;
  253.  
  254.  
  255.  
  256. (* ------------------------------------------------------ *)
  257. (*                  tXEditWindow                          *)
  258. (* ------------------------------------------------------ *)
  259.  
  260.  
  261. CONSTRUCTOR tXEditWindow.Init(VAR Bounds: tRect;
  262.   FileName: FNameStr; ANumber: INTEGER);
  263. VAR
  264.   Indicator: pIndicator;
  265.   HScrollBar, VScrollBar: pScrollBar;
  266.   R: tRect;
  267. BEGIN
  268.   tXWindow.Init(Bounds, '', ANumber, StdSysMenu);
  269.   Options := Options OR ofTileable;
  270.   R.Assign(18, Size.Y - 1, Size.X - 2, Size.Y);
  271.   HScrollBar := New(pScrollBar, Init(R));
  272.   HScrollBar^.Hide;
  273.   Insert(HScrollBar);
  274.   R.Assign(Size.X - 1, 1, Size.X, Size.Y - 1);
  275.   VScrollBar := New(pScrollBar, Init(R));
  276.   VScrollBar^.Hide;
  277.   Insert(VScrollBar);
  278.   R.Assign(2, Pred(Size.Y), 16, Size.Y);
  279.   Indicator := New(pIndicator, Init(R));
  280.   Indicator^.Hide;
  281.   Insert(Indicator);
  282.   GetExtent(R);
  283.   R.Grow(-1, -2);
  284.   Editor := New(pFileEditor, Init(
  285.     R, HScrollBar, VScrollBar, Indicator, FileName));
  286.   Insert(Editor);
  287.   FindItem(WinMenuBar^.Menu, cmOvWrt, TRUE)^.Param^ :=
  288.     Check[Succ(Ord(Editor^.Overwrite))];
  289.   FindItem(WinMenuBar^.Menu, cmIndent, TRUE)^.Param^ :=
  290.     Check[Succ(Ord(Editor^.AutoIndent))];
  291.  
  292. END;
  293.  
  294.  
  295. CONSTRUCTOR tXEditWindow.Load(VAR S: tStream);
  296. BEGIN
  297.   tXWindow.Load(S);
  298.   GetSubViewPtr(S, Editor);
  299. END;
  300.  
  301.  
  302. PROCEDURE tXEditWindow.Close;
  303. BEGIN
  304.   IF IsClipWindow THEN Hide ELSE tXWindow.Close;
  305. END;
  306.  
  307.  
  308. FUNCTION tXEditWindow.GetTitle(MaxSize: INTEGER): tTitleStr;
  309. VAR
  310.   Temp: tTitleStr;
  311.   I   : INTEGER;
  312. BEGIN
  313.   IF IsClipWindow THEN
  314.     GetTitle := 'Zwischenablage' ELSE
  315.     IF Editor^.FileName = '' THEN
  316.       GetTitle := 'Unbenannt' ELSE BEGIN
  317.         Temp := Editor^.FileName;
  318.         I := Pos('\', Temp);
  319.         WHILE (Length(Temp) > MaxSize) AND (I > 0) DO BEGIN
  320.           System.Delete(Temp, 1, I);
  321.           Temp := '...' + Temp;
  322.           I := Pos('\', Temp);
  323.         END;
  324.         IF Length(Temp) > MaxSize THEN
  325.           System.Delete(Temp, 1, Length(Temp) - MaxSize);
  326.         GetTitle := Temp;
  327.       END;
  328. END;
  329.  
  330.  
  331. PROCEDURE tXEditWindow.HandleEvent(VAR Event: tEvent);
  332. VAR
  333.   ThisMenu: pMenuItem;
  334. BEGIN
  335.   IF Event.What = evkeyDown THEN
  336.     CASE Event.KeyCode OF
  337.       kbIns:
  338.         BEGIN
  339.           Event.What := evCommand;
  340.           Event.Command := cmOvWrt;
  341.         END;
  342.       $180F:
  343.         BEGIN
  344.           Event.What := evCommand;
  345.           Event.Command := cmIndent;
  346.         END;
  347.     END;
  348.  
  349.   tXWindow.HandleEvent(Event);
  350.  
  351.   CASE Event.What OF
  352.     evBroadcast:
  353.       IF Event.Command = cmUpdateTitle THEN BEGIN
  354.         Frame^.DrawView;
  355.         ClearEvent(Event);
  356.       END;
  357.     evCommand:
  358.       CASE Event.Command OF
  359.         cmIndent:
  360.           BEGIN
  361.             ThisMenu := FindItem(WinMenuBar^.Menu,
  362.                                  cmIndent, TRUE);
  363.             ThisMenu^.Param^ := Check[2 - Ord(
  364.               Editor^.AutoIndent)];
  365.             Event.Command := cmIndentMode;
  366.             PutEvent(Event);
  367.           END;
  368.         cmOvWrt:
  369.           BEGIN
  370.             ThisMenu := FindItem(WinMenuBar^.Menu,
  371.                                  cmOvWrt, TRUE);
  372.             ThisMenu^.Param^ := Check[2 - Ord(
  373.               Editor^.Overwrite)];
  374.             Event.Command := cmInsMode;
  375.             PutEvent(Event);
  376.           END;
  377.       END;
  378.   END;
  379. END;
  380.  
  381.  
  382. PROCEDURE tXEditWindow.InitMenuBar;
  383. VAR
  384.   R: tRect;
  385. BEGIN
  386.   GetExtent(R);
  387.   R.Grow(-1, 0);
  388.   R.Move(0, 1);
  389.   R.B.Y := Succ(R.A.Y);
  390.  
  391.   WinMenuBar := New(PWinRipMenuBar, Init(R, NewMenu(NIL)));
  392.   StartMenuAt(WinMenuBar^.Menu);
  393.  
  394.   AddSub('~A~usgabe', 0);
  395.     AddItem('~S~ichern', 'F2', kbF2, cmSave, 0);
  396.     AddItem('Sichern ~u~nter...', '', kbNoKey, cmSaveAs, 0);
  397.     AddLine;
  398.     AddItem('~D~rucken', '', kbNoKey, cmPrint, 0);
  399.   CloseSub('~A~usgabe');
  400.  
  401.   AddSub('~B~earbeiten', 0);
  402.     AddItem('~R~ückgängig', '', kbNoKey, cmUndo, 0);
  403.     AddLine;
  404.     AddItem('~A~usschneiden', 'Shift-Del', kbShiftDel,
  405.              cmCut, 0);
  406.     AddItem('~K~opieren', 'Ctrl-Ins', kbCtrlIns, cmCopy, 0);
  407.     AddItem('~E~infügen', 'Shift-Ins', kbShiftIns,
  408.             cmPaste, 0);
  409.     AddItem('~Z~wischenablage', '', kbNoKey, cmShowClip, 0);
  410.     AddLine;
  411.     AddItem('~L~öschen', 'Ctrl-Del', kbCtrlDel, cmClear, 0);
  412.   CloseSub('~B~earbeiten');
  413.  
  414.   AddSub('~S~uchen', 0);
  415.     AddItem('~F~inden...', '', kbNoKey, cmFind, 0);
  416.     AddItem('~E~rsetzen...', '', kbNoKey, cmReplace, 0);
  417.     AddItem('~W~iederholen', '', kbNoKey, cmSearchAgain,0);
  418.   CloseSub('~S~uchen');
  419.  
  420.   AddSub('~E~ditor', 0);
  421.     AddItem('~E~inrücken', ' ', kbNoKey, cmIndent, 0);
  422.     AddItem('Ü~b~erschreiben', ' ', kbNoKey, cmOvWrt, 0);
  423.   CloseSub('~E~ditor');
  424. END;
  425.  
  426.  
  427. PROCEDURE tXEditWindow.InitStatusLine;
  428. VAR
  429.   R: tRect;
  430. BEGIN
  431.   GetExtent(R);
  432.   R.Grow(-1, 0);
  433.   R.Move(0, -1);
  434.   R.A.Y := Pred(R.B.Y);
  435.   WinStatusLine := New(PWinStatusLine, Init(R,
  436.     NewStatusDef(0, $FFFF,
  437.       NewStatusKey('~F2~ Sichern', kbF2, cmSave,
  438.       NewStatusKey('~F7~ Symbol', kbF7, cmShrink,
  439.       NewStatusKey('~Ctrl-F10~ Menü', kbCtrlF10, cmWinMenu,
  440.       NewStatusKey('', kbCtrlF3, cmSysMenu,
  441.       NewStatusKey('', kbCtrlF5, cmResize,
  442.       NIL))))),
  443.     NIL)));
  444. END;
  445.  
  446.  
  447. FUNCTION tXEditWindow.IsClipWindow: BOOLEAN;
  448. BEGIN
  449.   IsClipWindow := (ClipWindow = @Self);
  450. END;
  451.  
  452.  
  453. PROCEDURE tXEditWindow.Store(VAR S: tStream);
  454. BEGIN
  455.   tXWindow.Store(S);
  456.   PutSubViewPtr(S, Editor);
  457. END;
  458.  
  459.  
  460.  
  461. (* ------------------------------------------------------ *)
  462. (*                     tEditorApp                         *)
  463. (* ------------------------------------------------------ *)
  464.  
  465.  
  466. CONSTRUCTOR tEditorApp.Init;
  467. VAR
  468.   Pat: CHAR;
  469.   H: WORD;
  470.   R: tRect;
  471.   I: INTEGER;
  472. BEGIN
  473.   H := PtrRec(HeapEnd).Seg - PtrRec(HeapPtr).Seg;
  474.   IF H > HeapSize THEN
  475.     BufHeapSize := H - HeapSize ELSE
  476.     BufHeapSize := 0;
  477.   InitBuffers;
  478.  
  479.   tMacroApplication.Init;
  480.  
  481.   DisableCommands([cmSave, cmSaveAs, cmCut, cmCopy, cmPaste,
  482.                    cmClear, cmUndo, cmFind, cmReplace,
  483.                    cmSearchAgain]);
  484.  
  485.   SetSystemMsg(TRUE);  (* Systemmeldungen als MessageBox  *)
  486.   InitStdSysMenu;      (* Standard-Systemmenü für Fenster *)
  487.   
  488.   EditorDialog := DoDialog;
  489.  
  490.   ClipWindow := OpenEditor('', FALSE, wnNoNumber);
  491.   IF ClipWindow <> NIL THEN
  492.   BEGIN
  493.     Clipboard := ClipWindow^.Editor;
  494.     Clipboard^.CanUndo := FALSE;
  495.     ClipWindow^.Flags := ClipWindow^.Flags AND NOT wfShrink;
  496.   END;
  497.  
  498.   GetExtent(R);
  499.   Dec(R.B.X);
  500.   R.A.X := R.B.X - 9; R.B.Y := Succ(R.A.Y);
  501.   Buzzer := New(pBuzzer, Init(R));
  502.   Insert(Buzzer);
  503.  
  504.   MacroObj := New(pMacro, Init);
  505.  
  506.   RegisterObjects;
  507.   RegisterViews;
  508.   RegisterMenus;
  509.   RegisterDialogs;
  510.   RegisterApp;
  511.   RegisterXDialogs;
  512.   RegisterXMenus;
  513.   RegisterXViews;
  514.   RegisterXMacro;
  515.   RegisterEditors;
  516.   RegisterType(rXEditWindow);
  517.   LoadKeyStream;       (* Keycode-Konstanten-Stream lesen *)
  518.  
  519.   PinUp(50, 8,
  520.         #13#3'TVXEdit -- Extended Editor' +
  521.         #13#3 +
  522.         #13#3'(C) 1992 Christian Ohr & DMV-Verlag' +
  523.         #13#3'(C) 1983,90 Borland Int.', NIL);
  524.   Delay(1500);
  525.   PinDown;
  526.  
  527.   IF ParamCount > 0 THEN
  528.     FOR I := 1 TO ParamCount DO
  529.       OpenEditor(ParamStr(I), TRUE, wnAutoNumber);
  530. END;
  531.  
  532.  
  533. DESTRUCTOR tEditorApp.Done;
  534. BEGIN
  535.   tMacroApplication.Done;
  536.   DoneBuffers;
  537. END;
  538.  
  539.  
  540. PROCEDURE tEditorApp.HandleEvent(VAR Event: tEvent);
  541.  
  542.   PROCEDURE AboutBox;
  543.   VAR
  544.     BufHeap : LONGINT;
  545.   BEGIN
  546.     BufHeap := LONGINT(BufHeapSize) SHR 6;
  547.     MessageBox(
  548.          #3'TVXEDIT  -  Extended Editor' +
  549.       #13#3 +
  550.       #13#3'Gesamtbuffer: %d kB', @BufHeap,
  551.       mfInformation + mfOkButton);
  552.   END;
  553.  
  554.   PROCEDURE FileOpen;
  555.   VAR
  556.     FileName: FNameStr;
  557.   BEGIN
  558.     FileName := '*.*';
  559.     IF ExecDialog(New(PFileDialog, Init('*.*',
  560.        'Datei öffnen', '~N~ame', fdOpenButton, 100)),
  561.        @FileName) <> cmCancel THEN
  562.       OpenEditor(FileName, TRUE, wnAutoNumber);
  563.   END;
  564.  
  565.   PROCEDURE FileNew;
  566.   BEGIN
  567.     OpenEditor('', TRUE, wnAutoNumber);
  568.   END;
  569.  
  570.   PROCEDURE ChangeDir;
  571.   BEGIN
  572.     ExecDialog(New(PChDirDialog, Init(cdNormal, 0)), NIL);
  573.   END;
  574.  
  575.   PROCEDURE DosShell;
  576.   BEGIN
  577.     DoneSysError;
  578.     DoneEvents;
  579.     DoneVideo;
  580.     DoneMemory;
  581.     SetMemTop(Ptr(BufHeapPtr, 0));
  582.     PrintStr('EXIT, um zu TVXEDIT zurückzukehren...');
  583.     SwapVectors;
  584.     Exec(GetEnv('COMSPEC'), '');
  585.     SwapVectors;
  586.     SetMemTop(Ptr(BufHeapEnd, 0));
  587.     InitMemory;
  588.     InitVideo;
  589.     InitEvents;
  590.     InitSysError;
  591.     Redraw;
  592.   END;
  593.  
  594.   PROCEDURE ShowClip;
  595.   BEGIN
  596.     ClipWindow^.Select;
  597.     ClipWindow^.Show;
  598.   END;
  599.  
  600.   PROCEDURE Tile;
  601.   VAR
  602.     R: tRect;
  603.   BEGIN
  604.     Desktop^.GetExtent(R);
  605.     Desktop^.Tile(R);
  606.   END;
  607.  
  608.   PROCEDURE Cascade;
  609.   VAR
  610.     R: tRect;
  611.   BEGIN
  612.     Desktop^.GetExtent(R);
  613.     Desktop^.Cascade(R);
  614.   END;
  615.  
  616.   PROCEDURE VideoMode;
  617.   VAR
  618.     NewMode: WORD;
  619.     R: tRect;
  620.   BEGIN
  621.     IF HiResScreen THEN BEGIN
  622.       NewMode := ScreenMode XOR smFont8x8;
  623.       IF NewMode AND smFont8x8 <> 0 THEN
  624.         ShadowSize.X := 1 ELSE
  625.         ShadowSize.X := 2;
  626.       SetScreenMode(NewMode);
  627.     END;
  628.   END;
  629.  
  630.   PROCEDURE SaveMacros;
  631.   VAR
  632.     FileName: FNameStr;
  633.     S: pBufStream;
  634.   BEGIN
  635.     FileName := '*.MAC';
  636.     IF ExecDialog(New(PFileDialog, Init('*.MAC',
  637.        'Makrodatei sichern', '~N~ame', fdOkButton, 100)),
  638.        @FileName) <> cmCancel THEN BEGIN
  639.       FileName := FExpand(FileName);
  640.       S := New(pBufStream, Init(FileName, stCreate, 1024));
  641.       IF LowMemory THEN OutOfMemory ELSE
  642.         IF S^.Status <> stOk THEN
  643.           MessageBox('Datei nicht geöffnet', NIL,
  644.                      mfError + mfOkButton) ELSE BEGIN
  645.           S^.Put(MacroObj);
  646.           IF S^.Status <> stOk THEN
  647.             MessageBox('Datei nicht schreibbar', NIL,
  648.                      mfError + mfOkButton);
  649.        END;
  650.      Dispose(S, Done);
  651.    END;
  652.   END;
  653.  
  654.   PROCEDURE LoadMacros;
  655.   VAR
  656.     FileName: FNameStr;
  657.     S: pBufStream;
  658.   BEGIN
  659.     FileName := '*.MAC';
  660.     IF ExecDialog(New(PFileDialog, Init('*.MAC',
  661.        'Makrodatei öffnen', '~N~ame', fdOpenButton, 100)),
  662.        @FileName) <> cmCancel THEN BEGIN
  663.       FileName := FExpand(FileName);
  664.       S := New(pBufStream, Init(FileName, stOpenRead,1024));
  665.       IF LowMemory THEN OutOfMemory ELSE
  666.         IF S^.Status <> stOk THEN
  667.           MessageBox('Datei nicht geöffnet', NIL,
  668.                      mfError + mfOkButton) ELSE BEGIN
  669.           IF MacroObj <> NIL THEN
  670.             Dispose(MacroObj, Done);
  671.           MacroObj := pMacro(S^. Get);
  672.           IF S^.Status <> stOk THEN
  673.             MessageBox('Datei nicht lesbar', NIL,
  674.                        mfError + mfOkButton);
  675.         END;
  676.       Dispose(S, Done);
  677.     END;
  678.   END;
  679.  
  680.  
  681. BEGIN
  682.   SetStatusHelpCtx;
  683.  
  684.   tMacroApplication.HandleEvent(Event);
  685.   CASE Event.What OF
  686.     evCommand:
  687.       CASE Event.Command OF
  688.         cmAbout: AboutBox;
  689.         cmOpen: FileOpen;
  690.         cmNew: FileNew;
  691.         cmChangeDir: ChangeDir;
  692.         cmDosShell: DosShell;
  693.         cmShowClip: ShowClip;
  694.         cmTile: Tile;
  695.         cmCascade: Cascade;
  696.         cmPrint: Print;
  697.         cmWindowList: WindowListDialog;
  698.         cmVideoMode: VideoMode;
  699.         cmStoreDesktop: StoreDesktop;
  700.         cmLoadDesktop: LoadDesktop;
  701.         cmRecordMacro:
  702.           IF MacroObj <> NIL THEN MacroObj^.RecordMacro;
  703.         cmMacros:
  704.           IF MacroObj <> NIL THEN MacroObj^.MacroDialog;
  705.         cmSaveMacros: SaveMacros;
  706.         cmLoadMacros: LoadMacros;
  707.       ELSE
  708.         Exit;
  709.       END;
  710.   ELSE
  711.     Exit;
  712.   END;
  713.   ClearEvent(Event);
  714. END;
  715.  
  716.  
  717. PROCEDURE tEditorApp.Idle;
  718. BEGIN
  719.   tMacroApplication.Idle;
  720.   Buzzer^.Update;
  721. END;
  722.  
  723.  
  724. PROCEDURE tEditorApp.InitMenuBar;
  725. VAR
  726.   R: tRect;
  727. BEGIN
  728.   GetExtent(R);
  729.   R.B.Y := Succ(R.A.Y);
  730.   MenuBar := New(pRipMenuBar, Init(R, NewMenu(NIL)));
  731.   StartMenuAt(MenuBar^.Menu);
  732.  
  733.   AddSub('~≡~', 0);
  734.     AddItem('~I~nfo...', '', kbNoKey, cmAbout, 0);
  735.   CloseSub('~≡~');
  736.  
  737.   AddSub('~D~atei', 0);
  738.     AddItem('Ö~f~fnen...', 'F3', kbF3, cmOpen, 0);
  739.     AddItem('~N~eu', '', kbNoKey, cmNew, 0);
  740.     AddLine;
  741.     AddItem('~V~erzeichnis...', '', kbNoKey, cmChangeDir,0);
  742.     AddItem('~D~OS shell', '', kbNoKey, cmDosShell, 0);
  743.     AddItem('~B~eenden', 'Alt-X', kbAltX, cmQuit, 0);
  744.   CloseSub('~D~atei');
  745.  
  746.   AddSub('~O~ptionen', 0);
  747.     AddItem('43/50 ~Z~eilen', '', kbNoKey, cmVideoMode, 0);
  748.     AddLine;
  749.     AddItem('Desktop ~s~ichern', '',kbNoKey,
  750.             cmStoreDesktop, 0);
  751.     AddItem('Desktop ~l~aden', '', kbNoKey,
  752.             cmLoadDesktop,0);
  753.   CloseSub('~O~ptionen');
  754.  
  755.   AddSub('~M~akros', 0);
  756.     AddItem('~A~ufnahme...', '', kbNoKey, cmRecordMacro, 0);
  757.     AddItem('~B~earbeiten/Ausführen...', 'Alt-F7', kbAltF7,
  758.             cmMacros, 0);
  759.     AddLine;
  760.     AddItem('Makros ~s~ichern...', '', kbNokey,
  761.             cmSaveMacros, 0);
  762.     AddItem('Makros ~l~aden...', '', kbNoKey,
  763.             cmLoadMacros, 0);
  764.   CloseSub('~M~akros');
  765.  
  766.  
  767.   AddSub('~F~enster', 0);
  768.     AddItem('~N~ebeneinander', '', kbNoKey, cmTile, 0);
  769.     AddItem('Über~l~append', '', kbNoKey, cmCascade, 0);
  770.     AddItem('~W~eiter', 'F6', kbF6, cmNext, 0);
  771.     AddItem('~Z~urück', 'Shift-F6', kbShiftF6, cmPrev, 0);
  772.     AddLine;
  773.     AddItem('~F~enster...', 'Alt-0', kbAlt0,cmWindowList,0);
  774.   CloseSub('~F~enster');
  775. END;
  776.  
  777.  
  778. PROCEDURE tEditorApp.InitStatusLine;
  779. VAR
  780.   R: tRect;
  781. BEGIN
  782.   GetExtent(R);
  783.   R.A.Y := R.B.Y - 1;
  784.   StatusLine := New(pStatusLine, Init(R,
  785.     NewStatusDef(0, hcCtrl,
  786.       NewStatusKey('~F3~ Öffnen', kbF3, cmOpen,
  787.       NewStatusKey('~F6~ Weiter', kbF6, cmNext,
  788.       NewStatusKey('~F10~ Menü', kbF10, cmMenu,
  789.       NIL))),
  790.     NewStatusDef(hcAlt, hcAlt,
  791.       NewStatusKey('~Alt-X~ Beenden', kbAltX, cmQuit,
  792.       NewStatusKey('~Alt-F3~ Schließen', kbAltF3, cmClose,
  793.       NewStatusKey('~Alt-F7~ Makro', kbAltF7, cmMacros,
  794.       NIL))),
  795.     NIL))));
  796. END;
  797.  
  798.  
  799. PROCEDURE tEditorApp.LoadDesktop;
  800. VAR
  801.   P: pView;
  802.   S: pStream;
  803.  
  804.   PROCEDURE CloseView(P: pView); FAR;
  805.   BEGIN
  806.     Message(P, evCommand, cmClose, NIL);
  807.   END;
  808.  
  809. BEGIN
  810.   S := New(PBufStream, Init('TVXEDIT.DSK',stOpenRead,1024));
  811.   IF LowMemory THEN OutOfMemory ELSE
  812.     IF S^.Status <> stOk THEN
  813.       MessageBox('Datei nicht geöffnet',
  814.                   NIL, mfOkButton + mfError) ELSE BEGIN
  815.       IF Desktop^.Valid(cmClose) THEN BEGIN
  816.         Desktop^.ForEach(@CloseView);
  817.         REPEAT
  818.           P := pView(S^.Get);
  819.           Desktop^.InsertBefore(ValidView(P),Desktop^.Last);
  820.         UNTIL P = NIL;
  821.       END;
  822.       IF S^.Status <> stOk THEN
  823.         MessageBox('Datei nicht lesbar', NIL,
  824.                     mfOkButton + mfError);
  825.     END;
  826.   Dispose(S, Done);
  827. END;
  828.  
  829.  
  830. PROCEDURE tEditorApp.OutOfMemory;
  831. BEGIN
  832.   MessageBox('Nicht genügend Speicher vorhanden.',
  833.     NIL, mfError + mfOkButton);
  834. END;
  835.  
  836.  
  837. PROCEDURE tEditorApp.StoreDesktop;
  838. VAR
  839.   S: pStream;
  840.   F: FILE;
  841.  
  842.   PROCEDURE WriteView(P: pView); FAR;
  843.   BEGIN
  844.     IF (P <> Desktop^.Last) AND
  845.        (TypeOf(P^) <> TypeOf(tPinMenuBox)) AND NOT
  846.        pXEditWindow(P)^.IsClipWindow THEN S^.Put(P);
  847.   END;
  848.  
  849. BEGIN
  850.   S := New(PBufStream, Init('TVXEDIT.DSK', stCreate, 1024));
  851.   IF NOT LowMemory AND (S^.Status = stOk) THEN
  852.   BEGIN
  853.     Desktop^.ForEach(@WriteView);
  854.     S^.Put(NIL);
  855.     IF S^.Status <> stOk THEN
  856.     BEGIN
  857.       MessageBox('Datei TVXEDIT.DSK nicht erstellt.',
  858.                   NIL, mfOkButton + mfError);
  859.       Dispose(S, Done);
  860.       Assign(F, 'TVXEDIT.DSK');
  861.       Erase(F);
  862.       Exit;
  863.     END;
  864.   END;
  865.   Dispose(S, Done);
  866. END;
  867.  
  868.  
  869. BEGIN
  870.   EditorApp.Init;
  871.   EditorApp.Run;
  872.   EditorApp.Done;
  873. END.
  874.  
  875.  
  876. (* ------------------------------------------------------ *)
  877. (*                Ende von TVXEDIT.PAS                    *)
  878.