home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 13 / tsr / window.inc < prev    next >
Encoding:
Text File  |  1988-03-30  |  8.2 KB  |  236 lines
  1. (* ------------------------------------------------------ *)
  2. (*                    WINDOW.INC                          *)
  3. (*                                                        *)
  4. (*    erweitert die Fähigkeiten der Window-Toolbox aus    *)
  5. (*    PASCAL 8/87 um die Möglichkeiten, Fenster zu        *)
  6. (*    verschieben und Pop-Up-Menüs zu erstellen.          *)
  7. (*    <C> 1988 by R.Merker & PASCAL International         *)
  8. (* ------------------------------------------------------ *)
  9.  
  10. FUNCTION ScrollLock : BOOLEAN;
  11.                           (* TRUE, wenn Scroll Lock aktiv *)
  12. VAR Regs : Regs8088_;
  13.  
  14. BEGIN
  15.   WITH Regs DO BEGIN
  16.     AH := $02;  Intr($16, Regs);
  17.     ScrollLock := AL AND $10 <> 0;
  18.   END;
  19. END;
  20.  
  21. (* ------------------------------------------------------ *)
  22. PROCEDURE ReadChar(x, y : BYTE;
  23.                    VAR Zeichen, Attribut : BYTE);
  24.               (* liest Zeichen+Attribut an der Stelle x,y *)
  25.               (* aus dem Bildschirmspeicher               *)
  26. VAR Regs : Regs8088_;
  27.  
  28. BEGIN
  29.   WITH Regs DO BEGIN
  30.     AH := 2;  BH := Mem[$40:$62];
  31.     DH := Pred(y); DL := Pred(x);
  32.   END;
  33.   Intr($10, Regs);
  34.   WITH Regs DO BEGIN
  35.     AH := 8;  BH := Mem[$40:$62];
  36.   END;
  37.   Intr($10, Regs);
  38.   WITH Regs DO BEGIN
  39.     Zeichen := AL;  Attribut := AH;
  40.   END;
  41. END;
  42. (* ------------------------------------------------------ *)
  43. PROCEDURE WriteChar(x, y : BYTE; Zeichen, Attribut : BYTE);
  44.          (* schreibt Zeichen + Attribut an der Stelle x,y *)
  45.          (* in den Bildschirmspeicher                     *)
  46. VAR Regs : Regs8088_;
  47. BEGIN
  48.   WITH Regs DO BEGIN
  49.     AH := 2;  BH := Mem[$40:$62];
  50.     DH := Pred(y);  DL := Pred(x);
  51.   END;
  52.   Intr($10, Regs);
  53.   WITH Regs DO BEGIN
  54.     AH := 9;  AL := Zeichen;
  55.     BH := Mem[$40:$62]; BL := Attribut;  CX := 1;
  56.   END;
  57.   Intr($10, Regs);
  58. END;
  59. (* ------------------------------------------------------ *)
  60. PROCEDURE MvWindow (x_diff, y_diff : INTEGER);
  61.      (* bewegt aktuelles Fenster in X-Richtung um X_Diff, *)
  62.      (* in Y-Richtung um Y_Diff                           *)
  63. VAR Zeichen, Attribut : ARRAY [1..80,1..25] OF BYTE;
  64.     Regs : Regs8088_;
  65.     Old_x, Old_y : INTEGER;
  66.     i, j : BYTE;
  67.  
  68. BEGIN
  69.   Where_Cursor(Old_x, Old_y);
  70.   Window(1, 1, 80, 25);
  71.   WITH Win DO BEGIN
  72.                        (* Fensterinhalt und Rahmen retten *)
  73.                        (* (Zeichen und Attribute)         *)
  74.     FOR i := Pred(Dim.x1) TO Succ(Dim.x2) DO
  75.       FOR j := Pred(Dim.y1) TO Succ(Dim.y2) DO
  76.        ReadChar(i,j,Zeichen[i,j],Attribut[i,j]);
  77.                                (* alter Bildinhalt zurück *)
  78.     IF ScreenMode = 7 THEN
  79.       MonoBuffer  := Keller[Tiefe]^.Bild
  80.     ELSE
  81.       ColorBuffer := Keller[Tiefe]^.Bild;
  82.     FOR i:=Pred(Dim.x1) TO Succ(Dim.x2) DO
  83.                                    (* Fenster verschieben *)
  84.       FOR j:=Pred(Dim.y1) TO Succ(Dim.y2) DO
  85.         WriteChar(i+x_diff, j+y_diff, Zeichen[i,j],
  86.                   Attribut[i,j]);
  87.                               (* Koordinaten verschieben: *)
  88.     Dim.x1 := Dim.x1 + x_diff;
  89.     Dim.y1 := Dim.y1 + y_diff;
  90.     Dim.x2 := Dim.x2 + x_diff;
  91.     Dim.y2 := Dim.y2 + y_diff;
  92.     Window(Dim.x1, Dim.y1, Dim.x2, Dim.y2);
  93.     Regs.AH := 2;  Regs.BH := Mem[$40:$62];
  94.     Regs.DL := Pred(Old_x + x_diff);
  95.     Regs.DH := Pred(Old_y + y_diff);
  96.     Intr($10, Regs);
  97.   END ;
  98. END;
  99. (* ------------------------------------------------------ *)
  100. PROCEDURE MoveWindow;
  101.           (* bewegt aktuelles Fenster durch Cursortasten, *)
  102.           (* solange Scroll Lock aktiv                    *)
  103. VAR ch : CHAR;
  104.  
  105. BEGIN
  106.   WHILE ScrollLock DO
  107.     IF KeyPressed THEN BEGIN
  108.       Read(Kbd,ch);
  109.       IF (ch = #27) AND KeyPressed THEN BEGIN
  110.         Read(Kbd, ch);
  111.         WITH Win.Dim DO
  112.           CASE ch OF
  113.                      (* Links-Pfeil: *)
  114.             #75 : IF (x1 > 2) THEN MvWindow(-1,0)
  115.                   ELSE Write(#7);
  116.                      (* Rechts-Pfeil: *)
  117.             #77 : IF (x2 < 79) THEN MvWindow(1,0)
  118.                   ELSE Write(#7);
  119.                      (* Oben-Pfeil: *)
  120.             #72 : IF (y1 > 2) THEN MvWindow(0,-1)
  121.                   ELSE Write(#7);
  122.                      (* Unten-Pfeil: *)
  123.             #80 : IF (y2 < 24) THEN MvWindow(0,1)
  124.                   ELSE Write(#7);
  125.             ELSE Write(#7);
  126.           END { Case };
  127.         END { If }
  128.     ELSE Write(#7);
  129.     END { If };
  130. END;
  131. (* ------------------------------------------------------ *)
  132. FUNCTION FlipMenue (x, y: INTEGER; Str: t_Str255): INTEGER;
  133.        (* zeigt ein Menü an der Stelle x,y, die einzelnen *)
  134.        (* Position werden durch "_" getrennt.             *)
  135.        (* Breite des Menüs wird errechnet.                *)
  136.  
  137. VAR i, Breite,
  138.     Ausgewaehlt, Anzahl : INTEGER;
  139.     Auswahl             : ARRAY[1..24] OF STRING[70];
  140.     Kontrolle, Antwort  : CHAR;
  141.     LeerStr             : STRING[70];
  142.     Line                : t_Str80;
  143.     Old_x, Old_y        : BYTE;
  144.     Regs                : Regs8088_;
  145.  
  146. BEGIN
  147.   WITH Regs DO BEGIN             (* Cursorposition retten *)
  148.     AH := 3;  BH := Mem[$40:$62];
  149.   END;
  150.   Intr($10, Regs);
  151.   WITH Regs DO BEGIN
  152.     Old_x := DL;  Old_y := DH;
  153.   END;                             (* Hilfszeile anzeigen *)
  154.   Line := #24 + #25 + ' bewegen Balken          ' + #17 +
  155.           #217 + ' wählt aus         SCROLL LOCK+' +
  156.           #24#25#26#27 + ' bewegen Fenster';
  157.   FOR i:=1 TO 80 DO
  158.     WriteChar(i,25,Ord(Line[i]),15);
  159.   WITH Regs DO BEGIN     (* an alte Cursorposition zurück *)
  160.     AH := 2;  BH := Mem[$40:$62];
  161.     DL := Old_x;  DH := Old_y;
  162.   END;
  163.   Intr($10, Regs);      (* übergebenen String in einzelne *)
  164.                         (* Strings an den mit "_"         *)
  165.   Breite := 1;          (* markierten Stellen auftrennen  *)
  166.   Anzahl := 1;
  167.   WHILE Pos('_',Str) <> 0 DO BEGIN
  168.     Auswahl[Anzahl] := Copy(Str, 1, Pos('_',Str) - 1);
  169.     Delete(Str, 1, Pos('_',Str));
  170.     IF Length(Auswahl[Anzahl]) > Breite THEN
  171.       Breite := Length(Auswahl[Anzahl]);
  172.     Anzahl := Succ(Anzahl);
  173.   END;
  174.   Breite := Succ(Breite);
  175.                (* alle Strings sollen gleiche Länge haben *)
  176.   Anzahl := Pred(Anzahl);
  177.   FillChar(LeerStr, Succ(Breite),' ');
  178.   FillChar(LeerStr, 1, Chr(Breite));
  179.   FOR Ausgewaehlt := 1 TO Anzahl DO
  180.     IF Length(Auswahl[Ausgewaehlt]) < Breite THEN
  181.       Auswahl[Ausgewaehlt] := Auswahl[Ausgewaehlt] +
  182.                     Copy(LeerStr, 1, Breite -
  183.                     Length(Auswahl[Ausgewaehlt]) - 1);
  184.   MkWindow(x, y, x + Breite, y + Anzahl + 2, 2, White,
  185.            Black,Black);                (* Fenster öffnen *)
  186.   FOR Ausgewaehlt := 1 TO Anzahl DO BEGIN
  187.                                    (* Menüpunkte anzeigen *)
  188.     GotoXY(1, Ausgewaehlt);
  189.     Write(Auswahl[Ausgewaehlt]);
  190.   END;
  191.   Ausgewaehlt := 1;       (* ersten Menüpunkt invertieren *)
  192.   GotoXY(1,1);  TextColor(0);
  193.   TextBackground(15);  Write(Auswahl[1]);
  194.   GotoXY(1,1);
  195.   Antwort := #0;
  196.   REPEAT
  197.     IF ScrollLock THEN MoveWindow;
  198.     IF KeyPressed THEN BEGIN
  199.       Read(Kbd, Antwort);
  200.       IF Antwort = #27 THEN              (* Cursortaste ? *)
  201.         IF KeyPressed THEN BEGIN
  202.           Read(Kbd, Kontrolle);
  203.           GotoXY(1, Ausgewaehlt);
  204.                              (* Menüpunkt normal anzeigen *)
  205.           TextColor(15);  TextBackground(0);
  206.           Write(Auswahl[Ausgewaehlt]);
  207.           CASE Kontrolle OF
  208.  
  209.             #80 : IF Ausgewaehlt < Anzahl THEN
  210.                     Ausgewaehlt := Succ(Ausgewaehlt)
  211.                   ELSE
  212.                     Ausgewaehlt := 1;
  213.             #72 : IF Ausgewaehlt > 1 THEN
  214.                     Ausgewaehlt:=Pred(Ausgewaehlt)
  215.                   ELSE
  216.                     Ausgewaehlt:=Anzahl;
  217.             ELSE Write(#7);
  218.           END;
  219.           GotoXY(1, Ausgewaehlt);
  220.                         (* nächsten Menüpunkt invertieren *)
  221.           TextColor(0);  TextBackground(15);
  222.           Write(Auswahl[Ausgewaehlt]);
  223.           GotoXY(1, Ausgewaehlt); END
  224.         ELSE
  225.           Write(#7)
  226.       ELSE
  227.         IF Antwort <> #13 THEN Write(#7);
  228.       END;
  229.   UNTIL Antwort = #13;
  230.   RmWindow;
  231.   TextColor(15);  TextBackground(0);
  232.   FlipMenue := Ausgewaehlt;
  233. END;
  234. (* ------------------------------------------------------ *)
  235. (*                 Ende von WINDOW.INC                    *)
  236.