home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / EFFO / forum8.lzh / PROGRAMME / MODULA / WINDOW / area.mod < prev    next >
Text File  |  1989-01-19  |  39KB  |  1,168 lines
  1. (*
  2. -------------------------------------------------------------------------------
  3. @@@@@@@@@@@@@@@@@@@*)  IMPLEMENTATION  MODULE  Area;  (*@@@@@@@@@@@@@@@@@@@@@@@
  4. -------------------------------------------------------------------------------
  5. -------------------------------------------------------------------------------
  6. | Kurzbeschreibung   | minimales Fenstersystem fuer Textbildschirme           |
  7. |                    |                                                        |
  8. ---------------------+---------------------------------------------------------
  9. | Programm - Version |  2.2   |   Text - Version        |   V#093             |
  10. ---------------------+--------+-------------------------+----------------------
  11. | Modulholder        |  WS    |   Urversion     |  WS   |   August 88         |
  12. ---------------------+---------------------------------------------------------
  13. | System - Version   | OS-9, Miele-Modula-2 3.5                               |
  14. ---------------------+---------------------------------------------------------
  15. | Copyright          | Freigegeben fuer nichtkommerzielle Nutzung             |
  16. |                    |  durch Teilnehmer am EFFO                              |
  17. ---------------------+---------------------------------------------------------
  18. | Hardware           | GEPARD 68010, 1 MByte RAM, 80Zeichen-Textkarte         |
  19. ---------------------+---------------------------------------------------------
  20. | besondere Importe  |                                                        |
  21. ---------------------+---------------------------------------------------------
  22. | Autoren            |  WS    | Werner Stehling, Seilerwis 3,                 |
  23. |                    |        | CH-8606 Greifensee, Tel. 01/256 42 21         |
  24. ---------------------+---------------------------------------------------------
  25. |   U P D A T E S    |                                                        |
  26. ----------------------                                                        |
  27. |   Datum   Version  Autor  Bemerkungen                                       |
  28. | --------  -------  -----  -----------                                       |
  29. | 10. 8.88    1.1      WS   dynamische Fensterverwaltung unter GDOS           |
  30. | 17. 8.88    1.1      WS   Prozeduren zur Zahlenausgabe                      |
  31. | 12.12.88    2.0      WS   Umstellung auf OS-9 / Miele-Modula 2              |
  32. | 15.12.88    2.0      WS   Aufteilung in area und areaIO                     |
  33. | 20.12.88    2.1      WS   Area-Record mit dynamischer Laenge                |
  34. | 27. 1.89    2.1      WS   GetAreaPar mit VAR bereich                        |
  35. |  3. 2.89    2.1      WS   Write (CR) geflickt                               |
  36. |  7. 2.89    2.2      WS   SetTemp und EndTemp neu                           |
  37. |  9. 2.89    2.2      WS   ResetAktiv definiert zum Beschleunigen            |
  38. |                                                                             |
  39. -------------------------------------------------------------------------------
  40. | Modul-Beschreibung |   siehe Definition Modul                               |
  41. ----------------------                                                        |
  42. -------------------------------------------------------------------------------
  43. *)
  44.  
  45. FROM  Screen    IMPORT  Send, Gotoxy, Controls;
  46. FROM  SYSTEM    IMPORT  WORD, ADDRESS, SIZE, ADR;
  47. FROM  Storage   IMPORT  ALLOCATE, DEALLOCATE;
  48. FROM  BasicIO   IMPORT  TerminalMode, SetTerminal, In;
  49. FROM  FileIO    IMPORT  StdIn, StdOut, FReadCh, FWriteCh;
  50. FROM  Strings   IMPORT  Length;
  51.  
  52. CONST   kreuz   = \160;         (* Character zum Rahmen zeichnen        *)
  53.         tlinks  = \166;
  54.         eckelo  = \170;
  55.         eckero  = \171;
  56.         eckelu  = \172;
  57.         eckeru  = \173;
  58.         trecht  = \175;
  59.         waagre  = \184;
  60.         senkre  = \185;
  61.         tunten  = \186;
  62.         toben   = \187;          
  63.  
  64. TYPE    RahmTyp = [kreuz..toben];
  65.         Dump   = POINTER TO dump;
  66.         dump   = RECORD
  67.                    nextdump     : Dump;         (* verketttete Liste    *)
  68.                    dumplen      : CARDINAL;     (* Groesse von indump   *)
  69.                    xmin, ymin   : CARDINAL;     (* linke obere Ecke     *)
  70.                    breite, hoehe: CARDINAL;
  71.                    aktiv        : Area    ;     (* gerade aktive Area   *)
  72.                    indump       : Screen        (* Fensterinhalt        *)
  73.                  END;
  74.        
  75. VAR     schirm          : ARRAY [0..maxx],[0..maxy] OF CHAR;
  76.         fenster1, fenstere, workarea            : Area;
  77.         ersatz  : ARRAY RahmTyp,RahmTyp,BOOLEAN OF RahmTyp;
  78.         ax0, ay0, adx, ady, axc, ayc, fxc, fyc  : CARDINAL;
  79.         firstdump                               : Dump;
  80.         
  81. (*--------------------------------------------------------------------------*)
  82.         PROCEDURE  SaveScreen (x0, y0, dx, dy : CARDINAL);
  83. (*--------------------------------------------------------------------------*)
  84. (* Rettet den absoluten Bildschirm von (x0,y0) bis (x0+dx,y0+dy) auf den    *)
  85. (* Stack.                                                                   *)
  86.  
  87. VAR     work    : Dump;
  88.         i, k, l : CARDINAL;
  89.  
  90. BEGIN
  91.   work := NIL;
  92.   l := 18 + dx * dy;            (* Platzbedarf in Byte          *)
  93.   ALLOCATE (work, l);
  94.   IF  work <> NIL  THEN
  95.     WITH  work^  DO
  96.       nextdump := firstdump;
  97.       firstdump := work;
  98.       dumplen := l;
  99.       xmin   := x0;
  100.       ymin   := y0;
  101.       breite := dx;
  102.       hoehe  := dy;
  103.       aktiv  := workarea;
  104.       l := 0;
  105.       FOR  k := y0  TO  y0+dy-1  DO
  106.         FOR  i := x0  TO  x0+dx-1  DO
  107.           indump [l] := schirm[i, k];
  108.           INC (l)
  109.         END
  110.       END
  111.     END
  112.   END
  113. END  SaveScreen;
  114.  
  115. (*--------------------------------------------------------------------------*)
  116.         PROCEDURE  SetTemp (bereich : Area);
  117. (*--------------------------------------------------------------------------*)
  118. (* Rettet den absoluten Bildschirmbereich auf den Stack, bevor der neue     *)
  119. (* Bereich angezeigt wird. Restaurieren durch EndTemp.                      *)
  120.  
  121. BEGIN
  122.   IF  bereich = NIL  THEN
  123.     SaveScreen (0, 0, maxx, maxy)
  124.   ELSE
  125.     WITH  bereich^  DO
  126.       SaveScreen (xmin-1, ymin-1, breite+2, hoehe+2)
  127.     END
  128.   END;
  129.   SetAktiv (bereich)
  130. END  SetTemp;
  131.  
  132. (*--------------------------------------------------------------------------*)
  133.         PROCEDURE  EndTemp;
  134. (*--------------------------------------------------------------------------*)
  135. (* Holt den zuletzt geretteten Bildschirm vom Stack                         *)
  136.  
  137. VAR     work    : Dump;
  138.         i, k, l : CARDINAL;
  139.  
  140. BEGIN
  141.   IF  workarea <> NIL  THEN
  142.     WITH  workarea^  DO      (* save cursor  *)
  143.       xcurs := axc;
  144.       ycurs := ayc
  145.     END
  146.   ELSE
  147.     fxc := axc;
  148.     fyc := ayc
  149.   END;
  150.   IF  firstdump <> NIL  THEN
  151.     work := firstdump;
  152.     WITH  work^  DO
  153.       l := 0;
  154.       FOR  k := ymin  TO  ymin+hoehe-1  DO
  155.         Gotoxy (xmin, k);
  156.         FOR  i := xmin  TO  xmin+breite-1  DO
  157.           FWriteCh (StdOut, indump [l]);
  158.           schirm[i, k] := indump[l];
  159.           INC (l)
  160.         END
  161.       END;
  162.       workarea := aktiv
  163.     END;
  164.     IF  workarea <> NIL  THEN
  165.       WITH  workarea^  DO
  166.         ax0 := xmin;
  167.         ay0 := ymin;
  168.         adx := breite;
  169.         ady := hoehe;
  170.         GotoXY (xcurs, ycurs)
  171.       END
  172.     ELSE
  173.       ax0 := 0;
  174.       ay0 := 0;
  175.       adx := maxx+1;
  176.       ady := maxy+1;
  177.       GotoXY (fxc, fyc)
  178.     END;
  179.     firstdump := work^.nextdump;
  180.     DEALLOCATE (work, work^.dumplen)
  181.   END
  182. END  EndTemp;
  183.  
  184. (*--------------------------------------------------------------------------*)
  185.         PROCEDURE  FindArea (bereich : Area) : BOOLEAN;
  186. (*--------------------------------------------------------------------------*)
  187. (* Return TRUE, wenn bereich definiert ist                                  *)
  188.  
  189. VAR     work    : Area;
  190.  
  191. BEGIN
  192.   IF  bereich <> NIL  THEN
  193.     work := fenster1;
  194.     WHILE  (work <> NIL) AND (work <> bereich)  DO
  195.       work := work^.nextarea
  196.     END;
  197.     RETURN  work = bereich
  198.   ELSE
  199.     RETURN  FALSE
  200.   END
  201. END FindArea;
  202.  
  203. (*--------------------------------------------------------------------------*)
  204.         PROCEDURE  Adjust (bereich : Area);
  205. (*--------------------------------------------------------------------------*)
  206. (* Fenster immer voll auf dem Schirm                                        *)
  207.  
  208. BEGIN
  209.   IF  FindArea (bereich)  THEN
  210.     WITH  bereich^  DO
  211.       IF  breite < 1  THEN
  212.         breite := 1
  213.       END;
  214.       IF  hoehe < 1  THEN
  215.         hoehe := 1
  216.       END;
  217.       IF  breite > maxx-1  THEN
  218.         breite := maxx - 1
  219.       END;
  220.       IF  hoehe  > maxy-1  THEN
  221.         hoehe  := maxy - 1
  222.       END;
  223.       IF  xmin < 1  THEN
  224.         xmin := 1
  225.       END;
  226.       IF  ymin < 1  THEN
  227.         ymin := 1
  228.       END;
  229.       IF  xmin+breite > maxx  THEN
  230.         xmin := maxx - breite
  231.       END;
  232.       IF  ymin+hoehe  > maxy  THEN
  233.         ymin := maxy - hoehe
  234.       END;
  235.     END
  236.   END
  237. END  Adjust;
  238.  
  239. (*--------------------------------------------------------------------------*)
  240.         PROCEDURE  MakeArea (x0, y0, dx, dy : CARDINAL) : Area;
  241. (*--------------------------------------------------------------------------*)
  242. (* neuen Bereich auf dem Schirm einrichten                                  *)
  243. (* x0 und y0 sind die Position des ersten Characters oben links             *)
  244. (* dx und dy sind die wahre Breite und Hoehe; der Rahmen zaehlt zusaetzlich *)
  245.  
  246. VAR     i       : Area;
  247.         l       : CARDINAL;
  248.  
  249. BEGIN
  250.   i := NIL;
  251.   l := 18 + dx * dy;            (* Platzbedarf in Byte          *)
  252.   ALLOCATE (i, l);
  253.   IF  i <> NIL  THEN
  254.     IF  fenster1 = NIL  THEN
  255.       fenster1 := i               (* frische Liste                *)
  256.     END;
  257.     IF  fenstere <> NIL  THEN
  258.       fenstere^.nextarea := i
  259.     END;
  260.     fenstere := i;                (* neues Ende der Liste         *)
  261.     WITH  i^  DO
  262.       arealen := l;
  263.       xmin   := x0;
  264.       ymin   := y0;
  265.       breite := dx;
  266.       hoehe  := dy;
  267.       xcurs  := 0;
  268.       ycurs  := 0;
  269.       nextarea := NIL;
  270.       FOR  l := 0  TO dx*dy-1 DO
  271.         inarea [l] := ' '
  272.       END;
  273.     END;
  274.     Adjust (i);
  275.   END;
  276.   RETURN  i
  277. END MakeArea;
  278.  
  279. (*--------------------------------------------------------------------------*)
  280.     PROCEDURE  GetAreaPar (bereich : Area; VAR x0, y0, dx, dy : CARDINAL);
  281. (*--------------------------------------------------------------------------*)
  282.  
  283. BEGIN
  284.   IF  bereich = NIL  THEN
  285.     x0 := ax0;
  286.     y0 := ay0;
  287.     dx := adx;
  288.     dy := ady
  289.   ELSE
  290.     WITH  bereich^  DO
  291.       x0 := xmin;
  292.       y0 := ymin;
  293.       dx := breite;
  294.       dy := hoehe
  295.     END
  296.   END
  297. END GetAreaPar;
  298.  
  299. (*--------------------------------------------------------------------------*)
  300.         PROCEDURE  PositArea (VAR bereich : Area; x0, y0 : CARDINAL);
  301. (*--------------------------------------------------------------------------*)
  302. (* Fenster  nach x0, y0 verschieben                                         *)
  303.  
  304. BEGIN
  305.   IF  FindArea (bereich)  THEN
  306.     WITH  bereich^  DO
  307.       xmin := x0;
  308.       ymin := y0
  309.     END;
  310.     Adjust (bereich);
  311.     IF  bereich = workarea  THEN
  312.       SetAktiv (bereich)                (* neu zeichnen         *)
  313.     END;
  314.   END;
  315. END PositArea;
  316.  
  317. (*--------------------------------------------------------------------------*)
  318.         PROCEDURE  DimArea (VAR bereich : Area; dx, dy : CARDINAL);
  319. (*--------------------------------------------------------------------------*)
  320. (* Fenstergroesse neu festlegen                                             *)
  321.  
  322. VAR     i, k, l : CARDINAL;
  323.         neu     : Area;
  324.  
  325. BEGIN
  326.   IF  FindArea (bereich)  THEN
  327.     neu := MakeArea (bereich^.xmin, bereich^.ymin, dx, dy);
  328.     IF  neu <> NIL  THEN
  329.       WITH  bereich^  DO
  330.         k := breite * hoehe;
  331.         l := xcurs + ycurs * breite
  332.       END;
  333.       WITH  neu^  DO
  334.         xcurs := l MOD breite;
  335.         ycurs := l DIV breite;
  336.         IF  ycurs > hoehe  THEN
  337.           xcurs := breite;
  338.           ycurs := hoehe
  339.         END;
  340.         i := breite * hoehe;
  341.         IF  i < k  THEN  k := i  END;
  342.         FOR  l := 0  TO  k - 1  DO
  343.           inarea[l] := bereich^.inarea[l]
  344.         END;
  345.         IF  bereich = workarea  THEN
  346.           axc := xcurs;
  347.           ayc := ycurs;
  348.           SetAktiv (neu)                    (* neu zeichnen         *)
  349.         END;
  350.       END;
  351.     ReturnArea (bereich);                   (* alte area loeschen   *)
  352.     bereich := neu;                         (* neuer pointer        *)
  353.     END;
  354.   END;
  355. END DimArea;
  356.  
  357. (*--------------------------------------------------------------------------*)
  358.         PROCEDURE  ReturnArea (bereich : Area);
  359. (*--------------------------------------------------------------------------*)
  360. (* Area zurueckgeben                                                        *)
  361.  
  362. VAR     hilf, vorher    : Area;
  363.  
  364. BEGIN
  365.   hilf := fenster1;
  366.   vorher := NIL;
  367.   WHILE  (hilf <> NIL) AND (hilf <> bereich)  DO
  368.     vorher := hilf;
  369.     hilf := hilf^.nextarea
  370.   END;
  371.   IF  hilf = bereich  THEN
  372.     IF  hilf = fenster1  THEN
  373.       fenster1 := hilf^.nextarea        (* neues erstes Fenster         *)
  374.     END;
  375.     IF  vorher <> NIL  THEN
  376.       vorher^.nextarea := hilf^.nextarea (* raus aus der Liste          *)
  377.     END;
  378.     IF  hilf = fenstere  THEN
  379.       fenstere := vorher                (* neues letztes Fenster        *)
  380.     END;
  381.     IF  hilf = workarea  THEN
  382.       workarea := NIL                   (* kein Fenster mehr offen      *)
  383.     END;
  384.     DEALLOCATE (bereich, bereich^.arealen)
  385.   END;
  386. END ReturnArea;
  387.  
  388. (*--------------------------------------------------------------------------*)
  389.         PROCEDURE  ReturnAll;
  390. (*--------------------------------------------------------------------------*)
  391. (* Alle Areas zurueckgeben                                                  *)
  392.  
  393. BEGIN
  394.   WHILE  fenster1 <> NIL  DO
  395.     ReturnArea (fenster1)
  396.   END  
  397. END  ReturnAll;
  398.  
  399. (*----------------------------------------------------------------------------*)
  400.     PROCEDURE  InitModule;
  401. (*----------------------------------------------------------------------------*)
  402. VAR     i, k    : CARDINAL;
  403.  
  404. BEGIN
  405.   (* Wenn dieses ARRAY auch grausam aussieht: im Betrieb ist diese Methode ein
  406.      ganzes Stueck schneller, als eine Serie IF- oder CASE-Anweisungen. Der
  407.      erste Parameter ist der neu zu schreibende Character, der Zweite ist der
  408.      bereits an dieser Stelle stehende Rahmen-Character und der BOOLEAN-
  409.      Parameter gibt an, ob es sich um eine linke oder obere (FALSE) oder eine
  410.      rechte oder untere (TRUE) Rahmenseite handelt.
  411.   *)
  412.   ersatz[kreuz ,kreuz ,FALSE]:=kreuz  ; ersatz[kreuz ,tlinks,FALSE]:=kreuz  ;
  413.   ersatz[kreuz ,eckelo,FALSE]:=kreuz  ; ersatz[kreuz ,eckero,FALSE]:=kreuz  ;
  414.   ersatz[kreuz ,eckelu,FALSE]:=kreuz  ; ersatz[kreuz ,eckeru,FALSE]:=kreuz  ;
  415.   ersatz[kreuz ,trecht,FALSE]:=kreuz  ; ersatz[kreuz ,waagre,FALSE]:=kreuz  ;
  416.   ersatz[kreuz ,senkre,FALSE]:=kreuz  ; ersatz[kreuz ,tunten,FALSE]:=kreuz  ;
  417.   ersatz[kreuz ,toben ,FALSE]:=kreuz  ;
  418.   
  419.   ersatz[kreuz ,kreuz , TRUE]:=kreuz  ; ersatz[kreuz ,tlinks, TRUE]:=kreuz  ;
  420.   ersatz[kreuz ,eckelo, TRUE]:=kreuz  ; ersatz[kreuz ,eckero, TRUE]:=kreuz  ;
  421.   ersatz[kreuz ,eckelu, TRUE]:=kreuz  ; ersatz[kreuz ,eckeru, TRUE]:=kreuz  ;
  422.   ersatz[kreuz ,trecht, TRUE]:=kreuz  ; ersatz[kreuz ,waagre, TRUE]:=kreuz  ;
  423.   ersatz[kreuz ,senkre, TRUE]:=kreuz  ; ersatz[kreuz ,tunten, TRUE]:=kreuz  ;
  424.   ersatz[kreuz ,toben , TRUE]:=kreuz  ;
  425.   
  426.   ersatz[tlinks,kreuz ,FALSE]:=tlinks ; ersatz[tlinks,tlinks,FALSE]:=tlinks ;
  427.   ersatz[tlinks,eckelo,FALSE]:=tlinks ; ersatz[tlinks,eckero,FALSE]:=tlinks ;
  428.   ersatz[tlinks,eckelu,FALSE]:=tlinks ; ersatz[tlinks,eckeru,FALSE]:=tlinks ;
  429.   ersatz[tlinks,trecht,FALSE]:=tlinks ; ersatz[tlinks,waagre,FALSE]:=tlinks ;
  430.   ersatz[tlinks,senkre,FALSE]:=tlinks ; ersatz[tlinks,tunten,FALSE]:=tlinks ;
  431.   ersatz[tlinks,toben ,FALSE]:=tlinks ;
  432.   
  433.   ersatz[tlinks,kreuz , TRUE]:=kreuz  ; ersatz[tlinks,tlinks, TRUE]:=tlinks ;
  434.   ersatz[tlinks,eckelo, TRUE]:=kreuz  ; ersatz[tlinks,eckero, TRUE]:=tlinks ;
  435.   ersatz[tlinks,eckelu, TRUE]:=kreuz  ; ersatz[tlinks,eckeru, TRUE]:=tlinks ;
  436.   ersatz[tlinks,trecht, TRUE]:=kreuz  ; ersatz[tlinks,waagre, TRUE]:=kreuz  ;
  437.   ersatz[tlinks,senkre, TRUE]:=tlinks ; ersatz[tlinks,tunten, TRUE]:=kreuz  ;
  438.   ersatz[tlinks,toben , TRUE]:=kreuz  ;
  439.   
  440.   ersatz[eckelo,kreuz ,FALSE]:=kreuz  ; ersatz[eckelo,tlinks,FALSE]:=kreuz  ;
  441.   ersatz[eckelo,eckelo,FALSE]:=eckelo ; ersatz[eckelo,eckero,FALSE]:=tunten ;
  442.   ersatz[eckelo,eckelu,FALSE]:=trecht ; ersatz[eckelo,eckeru,FALSE]:=kreuz  ;
  443.   ersatz[eckelo,trecht,FALSE]:=trecht ; ersatz[eckelo,waagre,FALSE]:=tunten ;
  444.   ersatz[eckelo,senkre,FALSE]:=trecht ; ersatz[eckelo,tunten,FALSE]:=tunten ;
  445.   ersatz[eckelo,toben ,FALSE]:=kreuz  ;
  446.   
  447.   ersatz[eckelo,kreuz , TRUE]:=kreuz  ; ersatz[eckelo,tlinks, TRUE]:=kreuz  ;
  448.   ersatz[eckelo,eckelo, TRUE]:=eckelo ; ersatz[eckelo,eckero, TRUE]:=tunten ;
  449.   ersatz[eckelo,eckelu, TRUE]:=trecht ; ersatz[eckelo,eckeru, TRUE]:=kreuz  ;
  450.   ersatz[eckelo,trecht, TRUE]:=trecht ; ersatz[eckelo,waagre, TRUE]:=tunten ;
  451.   ersatz[eckelo,senkre, TRUE]:=trecht ; ersatz[eckelo,tunten, TRUE]:=tunten ;
  452.   ersatz[eckelo,toben , TRUE]:=kreuz  ;
  453.   
  454.   ersatz[eckero,kreuz ,FALSE]:=kreuz  ; ersatz[eckero,tlinks,FALSE]:=tlinks ;
  455.   ersatz[eckero,eckelo,FALSE]:=tunten ; ersatz[eckero,eckero,FALSE]:=eckero ;
  456.   ersatz[eckero,eckelu,FALSE]:=kreuz  ; ersatz[eckero,eckeru,FALSE]:=tlinks ;
  457.   ersatz[eckero,trecht,FALSE]:=kreuz  ; ersatz[eckero,waagre,FALSE]:=tunten ;
  458.   ersatz[eckero,senkre,FALSE]:=tlinks ; ersatz[eckero,tunten,FALSE]:=tunten ;
  459.   ersatz[eckero,toben ,FALSE]:=kreuz  ;
  460.   
  461.   ersatz[eckero,kreuz , TRUE]:=kreuz  ; ersatz[eckero,tlinks, TRUE]:=tlinks ;
  462.   ersatz[eckero,eckelo, TRUE]:=tunten ; ersatz[eckero,eckero, TRUE]:=eckero ;
  463.   ersatz[eckero,eckelu, TRUE]:=kreuz  ; ersatz[eckero,eckeru, TRUE]:=tlinks ;
  464.   ersatz[eckero,trecht, TRUE]:=kreuz  ; ersatz[eckero,waagre, TRUE]:=tunten ;
  465.   ersatz[eckero,senkre, TRUE]:=tlinks ; ersatz[eckero,tunten, TRUE]:=tunten ;
  466.   ersatz[eckero,toben , TRUE]:=kreuz  ;
  467.   
  468.   ersatz[eckelu,kreuz ,FALSE]:=kreuz  ; ersatz[eckelu,tlinks,FALSE]:=kreuz  ;
  469.   ersatz[eckelu,eckelo,FALSE]:=trecht ; ersatz[eckelu,eckero,FALSE]:=kreuz  ;
  470.   ersatz[eckelu,eckelu,FALSE]:=eckelu ; ersatz[eckelu,eckeru,FALSE]:=toben  ;
  471.   ersatz[eckelu,trecht,FALSE]:=trecht ; ersatz[eckelu,waagre,FALSE]:=toben  ;
  472.   ersatz[eckelu,senkre,FALSE]:=trecht ; ersatz[eckelu,tunten,FALSE]:=kreuz  ;
  473.   ersatz[eckelu,toben ,FALSE]:=toben  ;
  474.   
  475.   ersatz[eckelu,kreuz , TRUE]:=kreuz  ; ersatz[eckelu,tlinks, TRUE]:=kreuz  ;
  476.   ersatz[eckelu,eckelo, TRUE]:=trecht ; ersatz[eckelu,eckero, TRUE]:=kreuz  ;
  477.   ersatz[eckelu,eckelu, TRUE]:=eckelu ; ersatz[eckelu,eckeru, TRUE]:=toben  ;
  478.   ersatz[eckelu,trecht, TRUE]:=trecht ; ersatz[eckelu,waagre, TRUE]:=toben  ;
  479.   ersatz[eckelu,senkre, TRUE]:=trecht ; ersatz[eckelu,tunten, TRUE]:=kreuz  ;
  480.   ersatz[eckelu,toben , TRUE]:=toben  ;
  481.   
  482.   ersatz[eckeru,kreuz ,FALSE]:=kreuz  ; ersatz[eckeru,tlinks,FALSE]:=tlinks ;
  483.   ersatz[eckeru,eckelo,FALSE]:=kreuz  ; ersatz[eckeru,eckero,FALSE]:=tlinks ;
  484.   ersatz[eckeru,eckelu,FALSE]:=toben  ; ersatz[eckeru,eckeru,FALSE]:=eckeru ;
  485.   ersatz[eckeru,trecht,FALSE]:=kreuz  ; ersatz[eckeru,waagre,FALSE]:=toben  ;
  486.   ersatz[eckeru,senkre,FALSE]:=tlinks ; ersatz[eckeru,tunten,FALSE]:=kreuz  ;
  487.   ersatz[eckeru,toben ,FALSE]:=toben  ;
  488.   
  489.   ersatz[eckeru,kreuz , TRUE]:=kreuz  ; ersatz[eckeru,tlinks, TRUE]:=tlinks ;
  490.   ersatz[eckeru,eckelo, TRUE]:=kreuz  ; ersatz[eckeru,eckero, TRUE]:=tlinks ;
  491.   ersatz[eckeru,eckelu, TRUE]:=toben  ; ersatz[eckeru,eckeru, TRUE]:=eckeru ;
  492.   ersatz[eckeru,trecht, TRUE]:=kreuz  ; ersatz[eckeru,waagre, TRUE]:=toben  ;
  493.   ersatz[eckeru,senkre, TRUE]:=tlinks ; ersatz[eckeru,tunten, TRUE]:=kreuz  ;
  494.   ersatz[eckeru,toben , TRUE]:=toben  ;
  495.   
  496.   ersatz[trecht,kreuz ,FALSE]:=kreuz  ; ersatz[trecht,tlinks,FALSE]:=kreuz  ;
  497.   ersatz[trecht,eckelo,FALSE]:=trecht ; ersatz[trecht,eckero,FALSE]:=kreuz  ;
  498.   ersatz[trecht,eckelu,FALSE]:=trecht ; ersatz[trecht,eckeru,FALSE]:=kreuz  ;
  499.   ersatz[trecht,trecht,FALSE]:=trecht ; ersatz[trecht,waagre,FALSE]:=kreuz  ;
  500.   ersatz[trecht,senkre,FALSE]:=trecht ; ersatz[trecht,tunten,FALSE]:=kreuz  ;
  501.   ersatz[trecht,toben ,FALSE]:=kreuz  ;
  502.   
  503.   ersatz[trecht,kreuz , TRUE]:=trecht ; ersatz[trecht,tlinks, TRUE]:=trecht ;
  504.   ersatz[trecht,eckelo, TRUE]:=trecht ; ersatz[trecht,eckero, TRUE]:=trecht ;
  505.   ersatz[trecht,eckelu, TRUE]:=trecht ; ersatz[trecht,eckeru, TRUE]:=trecht ;
  506.   ersatz[trecht,trecht, TRUE]:=trecht ; ersatz[trecht,waagre, TRUE]:=trecht ;
  507.   ersatz[trecht,senkre, TRUE]:=trecht ; ersatz[trecht,tunten, TRUE]:=trecht ;
  508.   ersatz[trecht,toben , TRUE]:=trecht ;
  509.   
  510.   ersatz[waagre,kreuz ,FALSE]:=toben  ; ersatz[waagre,tlinks,FALSE]:=toben  ;
  511.   ersatz[waagre,eckelo,FALSE]:=waagre ; ersatz[waagre,eckero,FALSE]:=waagre ;
  512.   ersatz[waagre,eckelu,FALSE]:=toben  ; ersatz[waagre,eckeru,FALSE]:=toben  ;
  513.   ersatz[waagre,trecht,FALSE]:=toben  ; ersatz[waagre,waagre,FALSE]:=waagre ;
  514.   ersatz[waagre,senkre,FALSE]:=toben  ; ersatz[waagre,tunten,FALSE]:=waagre ;
  515.   ersatz[waagre,toben ,FALSE]:=toben  ;
  516.   
  517.   ersatz[waagre,kreuz , TRUE]:=tunten ; ersatz[waagre,tlinks, TRUE]:=tunten ;
  518.   ersatz[waagre,eckelo, TRUE]:=tunten ; ersatz[waagre,eckero, TRUE]:=tunten ;
  519.   ersatz[waagre,eckelu, TRUE]:=waagre ; ersatz[waagre,eckeru, TRUE]:=waagre ;
  520.   ersatz[waagre,trecht, TRUE]:=tunten ; ersatz[waagre,waagre, TRUE]:=waagre ;
  521.   ersatz[waagre,senkre, TRUE]:=tunten ; ersatz[waagre,tunten, TRUE]:=tunten ;
  522.   ersatz[waagre,toben , TRUE]:=waagre ;
  523.   
  524.   ersatz[senkre,kreuz ,FALSE]:=tlinks ; ersatz[senkre,tlinks,FALSE]:=tlinks ;
  525.   ersatz[senkre,eckelo,FALSE]:=senkre ; ersatz[senkre,eckero,FALSE]:=tlinks ;
  526.   ersatz[senkre,eckelu,FALSE]:=senkre ; ersatz[senkre,eckeru,FALSE]:=tlinks ;
  527.   ersatz[senkre,trecht,FALSE]:=senkre ; ersatz[senkre,waagre,FALSE]:=tlinks ;
  528.   ersatz[senkre,senkre,FALSE]:=senkre ; ersatz[senkre,tunten,FALSE]:=tlinks ;
  529.   ersatz[senkre,toben ,FALSE]:=tlinks ;
  530.   
  531.   ersatz[senkre,kreuz , TRUE]:=trecht ; ersatz[senkre,tlinks, TRUE]:=senkre ;
  532.   ersatz[senkre,eckelo, TRUE]:=trecht ; ersatz[senkre,eckero, TRUE]:=senkre ;
  533.   ersatz[senkre,eckelu, TRUE]:=trecht ; ersatz[senkre,eckeru, TRUE]:=senkre ;
  534.   ersatz[senkre,trecht, TRUE]:=trecht ; ersatz[senkre,waagre, TRUE]:=trecht ;
  535.   ersatz[senkre,senkre, TRUE]:=senkre ; ersatz[senkre,tunten, TRUE]:=trecht ;
  536.   ersatz[senkre,toben , TRUE]:=trecht ;
  537.   
  538.   ersatz[tunten,kreuz ,FALSE]:=kreuz  ; ersatz[tunten,tlinks,FALSE]:=kreuz  ;
  539.   ersatz[tunten,eckelo,FALSE]:=tunten ; ersatz[tunten,eckero,FALSE]:=tunten ;
  540.   ersatz[tunten,eckelu,FALSE]:=kreuz  ; ersatz[tunten,eckeru,FALSE]:=kreuz  ;
  541.   ersatz[tunten,trecht,FALSE]:=kreuz  ; ersatz[tunten,waagre,FALSE]:=tunten ;
  542.   ersatz[tunten,senkre,FALSE]:=kreuz  ; ersatz[tunten,tunten,FALSE]:=tunten ;
  543.   ersatz[tunten,toben ,FALSE]:=kreuz  ;
  544.   
  545.   ersatz[tunten,kreuz , TRUE]:=tunten ; ersatz[tunten,tlinks, TRUE]:=tunten ;
  546.   ersatz[tunten,eckelo, TRUE]:=tunten ; ersatz[tunten,eckero, TRUE]:=tunten ;
  547.   ersatz[tunten,eckelu, TRUE]:=tunten ; ersatz[tunten,eckeru, TRUE]:=tunten ;
  548.   ersatz[tunten,trecht, TRUE]:=tunten ; ersatz[tunten,waagre, TRUE]:=tunten ;
  549.   ersatz[tunten,senkre, TRUE]:=tunten ; ersatz[tunten,tunten, TRUE]:=tunten ;
  550.   ersatz[tunten,toben , TRUE]:=tunten ;
  551.   
  552.   ersatz[toben ,kreuz ,FALSE]:=toben  ; ersatz[toben ,tlinks,FALSE]:=toben  ;
  553.   ersatz[toben ,eckelo,FALSE]:=toben  ; ersatz[toben ,eckero,FALSE]:=toben  ;
  554.   ersatz[toben ,eckelu,FALSE]:=toben  ; ersatz[toben ,eckeru,FALSE]:=toben  ;
  555.   ersatz[toben ,trecht,FALSE]:=toben  ; ersatz[toben ,waagre,FALSE]:=toben  ;
  556.   ersatz[toben ,senkre,FALSE]:=toben  ; ersatz[toben ,tunten,FALSE]:=toben  ;
  557.   ersatz[toben ,toben ,FALSE]:=toben  ;
  558.   
  559.   ersatz[toben ,kreuz , TRUE]:=kreuz  ; ersatz[toben ,tlinks, TRUE]:=kreuz  ;
  560.   ersatz[toben ,eckelo, TRUE]:=kreuz  ; ersatz[toben ,eckero, TRUE]:=kreuz  ;
  561.   ersatz[toben ,eckelu, TRUE]:=toben  ; ersatz[toben ,eckeru, TRUE]:=toben  ;
  562.   ersatz[toben ,trecht, TRUE]:=kreuz  ; ersatz[toben ,waagre, TRUE]:=toben  ;
  563.   ersatz[toben ,senkre, TRUE]:=kreuz  ; ersatz[toben ,tunten, TRUE]:=kreuz  ;
  564.   ersatz[toben ,toben , TRUE]:=toben  ;
  565.   
  566.  
  567.   workarea := NIL;
  568.   fenster1 := NIL;
  569.   fenstere := NIL;
  570.   firstdump:= NIL;
  571.   FOR  k := 0 TO maxy  DO
  572.     FOR  i := 0 TO maxx  DO
  573.       schirm[i,k] := ' '
  574.     END;
  575.   END;
  576.   Send (ClrScreen);
  577.   fxc := 0;                             (* full screen cursor           *)
  578.   fyc := 0;
  579.   ax0 := 0;
  580.   ay0 := 0;
  581.   adx := maxx+1;
  582.   ady := maxy+1;
  583.   GotoXY (fxc, fyc)
  584. END  InitModule;
  585.  
  586. (*--------------------------------------------------------------------------*)
  587.         PROCEDURE  GotoXY (x0, y0 : CARDINAL);
  588. (*--------------------------------------------------------------------------*)
  589.  
  590. BEGIN
  591.   axc := x0 MOD adx;
  592.   ayc := y0 MOD ady;
  593.   Gotoxy (ax0+axc, ay0+ayc)
  594. END GotoXY;
  595.  
  596. (*--------------------------------------------------------------------------*)
  597.         PROCEDURE  GetXY (VAR x0, y0 : CARDINAL);
  598. (*--------------------------------------------------------------------------*)
  599.  
  600. BEGIN
  601.   x0 := axc;
  602.   y0 := ayc
  603. END GetXY;
  604.  
  605. (*--------------------------------------------------------------------------*)
  606.     PROCEDURE  Rahmen;
  607. (*--------------------------------------------------------------------------*)
  608.  
  609. VAR     ch, ck          : CHAR;
  610.         i, y            : CARDINAL;
  611.         m               : ADDRESS;
  612.         k               : BOOLEAN;
  613.         x               : ARRAY [FALSE..TRUE] OF CARDINAL;
  614.         
  615.     (*----------------------------------------------------------------------*)
  616.         PROCEDURE  Rahmenchar (ch : CHAR) : BOOLEAN;
  617.     (*----------------------------------------------------------------------*)
  618.     (*  SET funktioniert nicht  *)
  619.     
  620.     BEGIN
  621.       CASE  ch  OF
  622.         kreuz,
  623.         tlinks,
  624.         eckelo,
  625.         eckero,
  626.         eckelu,
  627.         eckeru,
  628.         trecht,
  629.         waagre,
  630.         senkre,
  631.         tunten, 
  632.         toben:      RETURN  TRUE
  633.       ELSE
  634.                     RETURN  FALSE
  635.       END
  636.     END  Rahmenchar;
  637.  
  638.     (*----------------------------------------------------------------------*)
  639.  
  640. BEGIN
  641.   IF  workarea <> NIL  THEN
  642.     Gotoxy (ax0-1, ay0-1);
  643.     ck := schirm[ax0-1,ay0-1];
  644.     ch := eckelo;
  645.     IF  Rahmenchar (ck)  THEN                    (* Ecke links oben      *)
  646.       ch := ersatz [ch, ck, FALSE];
  647.     END;
  648.     schirm[ax0-1,ay0-1] := ch;
  649.     FWriteCh (StdOut, ch);
  650.     
  651.     y := ay0-1;
  652.     FOR  i := ax0  TO  ax0 + adx - 1  DO          (* Oberkante            *)
  653.       ck := schirm[i,y];
  654.       ch := waagre;
  655.       IF  Rahmenchar (ck)  THEN
  656.         ch := ersatz [ch, ck, FALSE];
  657.       END;
  658.       schirm[i,y] := ch;
  659.       FWriteCh (StdOut, ch)
  660.     END;
  661.     
  662.     ck := schirm[ax0+adx,ay0-1];
  663.     ch := eckero;
  664.     IF  Rahmenchar (ck)  THEN                    (* Ecke rechts oben     *)
  665.       ch := ersatz [ch, ck,  TRUE];
  666.     END;
  667.     schirm[ax0+adx,ay0-1] := ch;
  668.     FWriteCh (StdOut, ch);
  669.     
  670.     x[FALSE] := ax0 - 1;
  671.     x[TRUE ] := ax0 + adx ;
  672.     FOR  i := ay0  TO  ay0+ady - 1  DO          (* linke und rechte Kante *)
  673.       FOR  k := FALSE  TO  TRUE  DO
  674.         Gotoxy (x[k], i);
  675.         ck := schirm[x[k],i];
  676.         ch := senkre;
  677.         IF  Rahmenchar (ck)  THEN
  678.           ch := ersatz [ch, ck, k];
  679.         END;
  680.         schirm[x[k],i] := ch;
  681.         FWriteCh (StdOut, ch)
  682.       END;
  683.     END;
  684.     
  685.     Gotoxy (ax0-1, ay0+ady);
  686.     ck := schirm[ax0-1,ay0+ady];
  687.     ch := eckelu;
  688.     IF  Rahmenchar (ck)  THEN                    (* Ecke links unten     *)
  689.       ch := ersatz [ch, ck, FALSE];
  690.     END;
  691.     schirm[ax0-1,ay0+ady] := ch;
  692.     FWriteCh (StdOut, ch);
  693.     
  694.     y := ay0+ady;
  695.     FOR  i := ax0  TO  ax0 + adx - 1  DO          (* Unterkante           *)
  696.       ck := schirm[i,y];
  697.       ch := waagre;
  698.       IF  Rahmenchar (ck)  THEN
  699.         ch := ersatz [ch, ck,  TRUE];
  700.       END;
  701.       schirm[i,y] := ch;
  702.       FWriteCh (StdOut, ch)
  703.     END;
  704.   
  705.     ck := schirm[ax0+adx,ay0+ady];
  706.     ch := eckeru;
  707.     IF  Rahmenchar (ck)  THEN                    (* Ecke rechts unten    *)
  708.       ch := ersatz [ch, ck,  TRUE];
  709.     END;
  710.     schirm[ax0+adx,ay0+ady] := ch;
  711.     FWriteCh (StdOut, ch)
  712.     
  713.   END
  714. END Rahmen;
  715.   
  716. (*--------------------------------------------------------------------------*)
  717.         PROCEDURE  ScrollUp;
  718. (*--------------------------------------------------------------------------*)
  719.  
  720. VAR     i, k, l, p  : CARDINAL;
  721.  
  722. BEGIN
  723.   WITH  workarea^  DO
  724.     p := ax0+adx-1;
  725.     l := 0;
  726.     FOR  k := ay0  TO  ay0+ady-2  DO
  727.       Gotoxy (ax0, k);
  728.       FOR  i := ax0  TO  p  DO
  729.         inarea [l] := inarea [l+adx];
  730.         schirm [i,k] := inarea [l];
  731.         FWriteCh (StdOut, inarea[l]);
  732.         INC (l)
  733.       END;
  734.     END;
  735.     p := ay0+ady-1;
  736.     Gotoxy (ax0, p);
  737.     FOR  i := ax0  TO ax0+adx-1  DO
  738.       inarea [l] := ' ';
  739.       schirm [i,p] := inarea [l];
  740.       FWriteCh (StdOut, inarea[l]);
  741.       INC (l)
  742.     END
  743.   END
  744. END  ScrollUp;
  745.  
  746. (*--------------------------------------------------------------------------*)
  747.         PROCEDURE  WriteLn;
  748. (*--------------------------------------------------------------------------*)
  749.  
  750. VAR     ch      : CHAR;
  751.         i, k    : CARDINAL;
  752.  
  753. BEGIN
  754.   IF  workarea = NIL  THEN
  755.     ch := CRKey;
  756.     FWriteCh (StdOut, ch);
  757.     axc := 0;
  758.     IF  ayc < ady-1  THEN
  759.       INC (ayc)
  760.     ELSE
  761.       FOR  i := 0  TO  adx-1  DO
  762.         FOR  k := 0  TO  ady-2  DO
  763.           schirm[i,k] := schirm[i,k+1]
  764.         END;
  765.         schirm[i,ady-1] := ' '
  766.       END
  767.     END  
  768.   ELSE
  769.     WITH  workarea^  DO
  770.       IF  ayc = ady - 1  THEN
  771.         ScrollUp
  772.       ELSE
  773.         INC (ayc)
  774.       END;
  775.       axc := 0;
  776.       Gotoxy (ax0, ay0+ayc)
  777.     END
  778.   END;
  779. END WriteLn;
  780.  
  781. (*--------------------------------------------------------------------------*)
  782.         PROCEDURE  Write (ch : CHAR);
  783. (*--------------------------------------------------------------------------*)
  784.  
  785. BEGIN
  786.   IF  ch = CRKey  THEN
  787.     WriteLn
  788.   ELSIF  ch <> 0c  THEN
  789.     IF  axc >= adx  THEN
  790.       WriteLn
  791.     END;
  792.     FWriteCh (StdOut, ch);
  793.     schirm [ax0+axc, ay0+ayc] := ch;
  794.     IF  workarea <> NIL  THEN
  795.       workarea^.inarea[axc+ayc*adx] := ch;
  796.     END;
  797.     INC (axc)
  798.   END
  799. END Write;
  800.  
  801. (*--------------------------------------------------------------------------*)
  802.         PROCEDURE  ShowArea;
  803. (*--------------------------------------------------------------------------*)
  804.  
  805. VAR     i, k    : CARDINAL;
  806.  
  807. BEGIN
  808.   IF  workarea = NIL  THEN
  809.     FOR  k := 0  TO  maxy  DO
  810.       Gotoxy (0, k);
  811.       FOR  i := 0  TO  maxx  DO
  812.         FWriteCh (StdOut, schirm[i,k])
  813.       END;
  814.     END;
  815.     GotoXY (fxc, fyc)
  816.   ELSE
  817.     WITH  workarea^  DO
  818.       GotoXY (0, 0);
  819.       FOR  i := 0  TO  adx*ady-1  DO
  820.         Write (inarea[i])
  821.       END;
  822.       axc := xcurs;
  823.       ayc := ycurs;
  824.       Gotoxy (ax0+axc, ay0+ayc)
  825.     END;
  826.   END;
  827. END ShowArea;
  828.  
  829. (*--------------------------------------------------------------------------*)
  830.         PROCEDURE  ResetAktiv (bereich : Area);
  831. (*--------------------------------------------------------------------------*)
  832. (* der weitere Output geht wieder in Area bereich                           *)
  833.  
  834. BEGIN
  835.   IF  workarea <> NIL  THEN
  836.     WITH  workarea^  DO      (* save cursor  *)
  837.       xcurs := axc;
  838.       ycurs := ayc
  839.     END;
  840.   ELSE
  841.     fxc := axc;
  842.     fyc := ayc
  843.   END;
  844.   workarea := fenster1;
  845.   WHILE  (workarea <> NIL) AND (workarea <> bereich)  DO
  846.     workarea := workarea^.nextarea
  847.   END;
  848.   IF  workarea <> NIL  THEN
  849.     WITH  workarea^  DO
  850.       ax0 := xmin;
  851.       ay0 := ymin;
  852.       adx := breite;
  853.       ady := hoehe;
  854.       axc := xcurs;
  855.       ayc := ycurs;
  856.       Gotoxy (ax0+axc, ay0+ayc)
  857.     END;
  858.   ELSE
  859.     ax0 := 0;
  860.     ay0 := 0;
  861.     adx := maxx+1;
  862.     ady := maxy+1;
  863.     GotoXY (fxc, fyc)
  864.   END
  865. END ResetAktiv;
  866.  
  867. (*--------------------------------------------------------------------------*)
  868.         PROCEDURE  SetAktiv (bereich : Area);
  869. (*--------------------------------------------------------------------------*)
  870. (* der weitere Output geht in Area bereich                                  *)
  871.  
  872. BEGIN
  873.   IF  workarea <> NIL  THEN
  874.     WITH  workarea^  DO      (* save cursor  *)
  875.       xcurs := axc;
  876.       ycurs := ayc
  877.     END;
  878.   ELSE
  879.     fxc := axc;
  880.     fyc := ayc
  881.   END;
  882.   workarea := fenster1;
  883.   WHILE  (workarea <> NIL) AND (workarea <> bereich)  DO
  884.     workarea := workarea^.nextarea
  885.   END;
  886.   IF  workarea <> NIL  THEN
  887.     WITH  workarea^  DO
  888.       ax0 := xmin;
  889.       ay0 := ymin;
  890.       adx := breite;
  891.       ady := hoehe;
  892.       Rahmen;
  893.     END;
  894.   ELSE
  895.     ax0 := 0;
  896.     ay0 := 0;
  897.     adx := maxx+1;
  898.     ady := maxy+1
  899.   END;
  900.   ShowArea;
  901. END SetAktiv;
  902.  
  903. (*--------------------------------------------------------------------------*)
  904.         PROCEDURE  GetAktiv (VAR bereich : Area);
  905. (*--------------------------------------------------------------------------*)
  906.  
  907. BEGIN
  908.   bereich := workarea
  909. END GetAktiv;
  910.  
  911. (*--------------------------------------------------------------------------*)
  912.         PROCEDURE  ClearScreen;
  913. (*--------------------------------------------------------------------------*)
  914.  
  915. BEGIN
  916.   Send (ClrScreen);
  917. END  ClearScreen;
  918.  
  919. (*--------------------------------------------------------------------------*)
  920.         PROCEDURE  ClearArea;
  921. (*--------------------------------------------------------------------------*)
  922.  
  923. VAR     i, k    : CARDINAL;
  924.  
  925. BEGIN
  926.   IF  workarea = NIL  THEN
  927.     FOR  k := 0  TO  maxy  DO
  928.       FOR  i := 0  TO  maxx  DO
  929.         schirm[i,k] := ' '
  930.       END;
  931.     END;
  932.     Send (ClrScreen);
  933.     fxc := 0;
  934.     fyc := 0;
  935.   ELSE
  936.     GotoXY (0, 0);
  937.     WITH  workarea^  DO
  938.       FOR  i := 0 TO adx*ady-1  DO
  939.         Write (' ')
  940.       END;
  941.       xcurs  := 0;
  942.       ycurs  := 0;
  943.     END;
  944.   END;
  945.   GotoXY (0, 0)
  946. END ClearArea;
  947.  
  948. (*--------------------------------------------------------------------------*)
  949.         PROCEDURE  ClearToEOL;
  950. (*--------------------------------------------------------------------------*)
  951.  
  952. VAR     sav, i  : CARDINAL;
  953.  
  954. BEGIN
  955.   sav := axc;
  956.   FOR  i := axc  TO  adx-1  DO
  957.     Write (' ')
  958.   END;
  959.   GotoXY (sav, ayc)
  960. END ClearToEOL;
  961.  
  962. (*--------------------------------------------------------------------------*)
  963.         PROCEDURE  ClearLine;
  964. (*--------------------------------------------------------------------------*)
  965.  
  966. BEGIN
  967.   GotoXY (0, ayc);
  968.   ClearToEOL
  969. END ClearLine;
  970.  
  971. (*--------------------------------------------------------------------------*)
  972.         PROCEDURE  WriteString (VAR s : ARRAY OF CHAR);
  973. (*--------------------------------------------------------------------------*)
  974.  
  975. VAR     i       : CARDINAL;
  976.  
  977. BEGIN
  978.   IF  s[0] <> 0c  THEN
  979.     FOR  i := 0  TO  Length (s)-1  DO
  980.       Write (s[i])
  981.     END
  982.   END
  983. END WriteString;
  984.  
  985. (*--------------------------------------------------------------------------*)
  986.         PROCEDURE  CursorDown;
  987. (*--------------------------------------------------------------------------*)
  988.  
  989. BEGIN
  990.   IF  workarea <> NIL  THEN
  991.     WITH  workarea^  DO
  992.       IF  ayc = ady-1  THEN
  993.         ScrollUp
  994.       ELSE
  995.         INC (ayc);
  996.       END;
  997.     END
  998.   ELSIF  ayc < ady-1  THEN
  999.     INC (ayc)
  1000.   END;
  1001.   GotoXY (axc, ayc)
  1002. END CursorDown;
  1003.  
  1004. (*--------------------------------------------------------------------------*)
  1005.         PROCEDURE  CursorUp;
  1006. (*--------------------------------------------------------------------------*)
  1007.  
  1008. BEGIN
  1009.   IF  ayc > 0  THEN
  1010.     DEC (ayc)
  1011.   END;
  1012.   GotoXY (axc, ayc)
  1013. END CursorUp;
  1014.  
  1015. (*--------------------------------------------------------------------------*)
  1016.         PROCEDURE  CursorLeft;
  1017. (*--------------------------------------------------------------------------*)
  1018.  
  1019. BEGIN
  1020.   IF  axc > 0  THEN
  1021.     DEC (axc);
  1022.     GotoXY (axc, ayc)
  1023.   ELSE
  1024.     axc := adx - 1;
  1025.     CursorUp
  1026.   END
  1027. END CursorLeft;
  1028.  
  1029. (*--------------------------------------------------------------------------*)
  1030.         PROCEDURE  CursorRight;
  1031. (*--------------------------------------------------------------------------*)
  1032.  
  1033. BEGIN
  1034.   IF  axc < adx-1  THEN
  1035.     INC (axc);
  1036.     GotoXY (axc, ayc)
  1037.   ELSE
  1038.     axc := 0;
  1039.     CursorDown
  1040.   END
  1041. END CursorRight;
  1042.  
  1043. (*--------------------------------------------------------------------------*)
  1044.         PROCEDURE  DeleteOne;
  1045. (*--------------------------------------------------------------------------*)
  1046.  
  1047. VAR     i, k, l    : CARDINAL;
  1048.  
  1049. BEGIN
  1050.   IF  workarea <> NIL  THEN
  1051.     WITH  workarea^  DO
  1052.       xcurs := axc;
  1053.       ycurs := ayc;
  1054.       k := axc+ayc*adx;
  1055.       l := (ayc+1)*adx-1;
  1056.       i := k;
  1057.       WHILE  i < l  DO
  1058.         inarea [i] := inarea [i+1];
  1059.         Write (inarea[i]);
  1060.         INC (i)
  1061.       END;
  1062.       inarea [l] := ' ';
  1063.       Write (inarea[l]);
  1064.       GotoXY (xcurs, ycurs)
  1065.     END
  1066.   ELSE
  1067.     i := axc;
  1068.     l := ayc;
  1069.     WHILE  axc < adx-1  DO
  1070.       Write (schirm[axc+1, ayc])
  1071.     END;
  1072.     Write (' ');
  1073.     GotoXY (i, l)
  1074.   END
  1075. END DeleteOne;
  1076.  
  1077. (*--------------------------------------------------------------------------*)
  1078.         PROCEDURE  InsertChar (num : CARDINAL);
  1079. (*--------------------------------------------------------------------------*)
  1080.  
  1081. VAR     i, k, l, xcu, ycu  : CARDINAL;
  1082.  
  1083. BEGIN
  1084.   IF  workarea <> NIL  THEN
  1085.     WITH  workarea^  DO
  1086.       xcurs := axc;
  1087.       ycurs := ayc;
  1088.       k := axc+ayc*adx+num;
  1089.       l := (ayc+1)*adx-1;
  1090.       i := l;
  1091.       WHILE  i >= k  DO
  1092.         inarea [i] := inarea [i-num];
  1093.         DEC (i)
  1094.       END;
  1095.       i := k-num;
  1096.       WHILE  i < k  DO
  1097.         inarea [i] := ' ';
  1098.         INC (i)
  1099.       END;
  1100.       i := k-num;
  1101.       WHILE  i <= l  DO
  1102.         Write (inarea[i]);
  1103.         INC (i)
  1104.       END;
  1105.       GotoXY (xcurs, ycurs)
  1106.     END
  1107.   ELSE
  1108.     xcu := axc;
  1109.     ycu := ayc;
  1110.     k := axc+num;
  1111.     l := adx-1;
  1112.     i := l;
  1113.     WHILE  i >= k  DO
  1114.       schirm [i, ycu] := schirm [i-num, ycu];
  1115.       DEC (i)
  1116.     END;
  1117.     i := k-num;
  1118.     WHILE  i < k  DO
  1119.       schirm [i, ycu] := ' ';
  1120.       INC (i)
  1121.     END;
  1122.     i := k-num;
  1123.     WHILE  i <= l  DO
  1124.       Write (schirm[i, ycu]);
  1125.       INC (i)
  1126.     END;
  1127.     GotoXY (xcu, ycu)
  1128.   END
  1129. END InsertChar;
  1130.  
  1131. (*--------------------------------------------------------------------------*)
  1132.         PROCEDURE  BusyRead (VAR ch : CHAR);
  1133. (*--------------------------------------------------------------------------*)
  1134.  
  1135. BEGIN
  1136.   FReadCh  (StdIn, ch)
  1137. END BusyRead;
  1138.  
  1139. (*--------------------------------------------------------------------------*)
  1140.         PROCEDURE  Read (VAR ch : CHAR);
  1141. (*--------------------------------------------------------------------------*)
  1142.  
  1143. BEGIN
  1144.   FReadCh  (StdIn, ch);
  1145.   CASE  ch  OF
  1146.     CRKey     : InsertChar (adx-axc); WriteLn  |
  1147.     DelKey    : DeleteOne                      |
  1148.     BSKey     : IF (axc > 0) OR (ayc > 0)  THEN
  1149.                   CursorLeft;  DeleteOne  END  |
  1150.     HTab      : GotoXY (axc + 4, ayc)          |
  1151.     INSKey    : InsertChar (1)                 |
  1152.     LeftKey   : CursorLeft                     |
  1153.     RightKey  : CursorRight                    |
  1154.     DownKey   : CursorDown                     |
  1155.     UpKey     : CursorUp                       |
  1156.     HomeKey   : ClearArea
  1157.   ELSE
  1158.     Write (ch)
  1159.   END
  1160. END Read;
  1161.  
  1162. (*--------------------------------------------------------------------------*)
  1163.  
  1164. BEGIN
  1165.   SetTerminal (In, CharBlank);      (* einzelner Characterinput ohne Echo ! *)
  1166.   InitModule;
  1167. END  Area.
  1168.