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