home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1991 / 02 / oop / vsobj.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1990-11-08  |  6.9 KB  |  225 lines
  1. (* ------------------------------------------------------ *)
  2. (*                       VSOBJ.PAS                        *)
  3. (*   Diese Unit enthält das Objekt "VirtualScreen",       *)
  4. (*   ein Objekt zur Erzeugung und Bearbeitung eines       *)
  5. (*   virtuellen Bildschirms.                              *)
  6. (*                                                        *)
  7. (*          (c) '90 by R.Reichert & toolbox               *)
  8. (* ------------------------------------------------------ *)
  9. UNIT VSObj;
  10.  
  11. INTERFACE
  12.  
  13. CONST                        { ReturnCodes ("Antworten"):  }
  14.   VSOk        = 0;           { Kein Fehler (defaultmäßig)  }
  15.   VSXYInvalid = 1;           { x und/oder y ungültig       }
  16.  
  17. TYPE
  18.   ScreenMemPtr = ^ScreenMemory;
  19.   ScreenMemory = ARRAY [0..10000] OF WORD;
  20.  
  21.   { Keine Angst, es wird nur soviel Speicher belegt, wie
  22.     der einzelne virtuelle Bildschirm wirklich benötigt.
  23.     Ausgerechnet wird es nach seiner X- und Y-Länge.       }
  24.  
  25.   VirtualScreenPtr = ^VirtualScreen;
  26.   VirtualScreen    =
  27.     OBJECT
  28.       { ------------------- Variablen -------------------- }
  29.       XLength,                          { X-Länge des vB's }
  30.       YLength,                          { Y-Länge des vB's }
  31.       ReturnCode : BYTE;                { "Antwort" (s.o.) }
  32.       VSMem      : ScreenMemPtr;        { Speicher für vB  }
  33.       {-------------------- Methoden --------------------- }
  34.       CONSTRUCTOR Init(XL, YL : BYTE);
  35.       PROCEDURE Clear;                             VIRTUAL;
  36.       PROCEDURE ClearPart(x1, y1, x2, y2 : BYTE);  VIRTUAL;
  37.       PROCEDURE Fill(Chr : CHAR; Attr : BYTE);     VIRTUAL;
  38.       PROCEDURE FillPart
  39.        (x1, y1, x2, y2, Attr : BYTE; Chr : CHAR);  VIRTUAL;
  40.       PROCEDURE FillPartAttr
  41.        (x1, y1, x2, y2, Attr : BYTE);              VIRTUAL;
  42.       PROCEDURE WriteChr(x,y,Attr:BYTE;Chr:CHAR);  VIRTUAL;
  43.       PROCEDURE WriteStr(x,y,Attr:BYTE;Str:STRING);VIRTUAL;
  44.       PROCEDURE WriteAttr(x, y, Attr : BYTE);      VIRTUAL;
  45.       PROCEDURE SetReturnCode(Code : BYTE);        VIRTUAL;
  46.       FUNCTION GetPartPtr(x,y:BYTE):ScreenMemPtr;  VIRTUAL;
  47.       FUNCTION XYInVSMem(x, y : BYTE) : BOOLEAN;   VIRTUAL;
  48.       FUNCTION GetAddr(x, y : BYTE) : WORD;        VIRTUAL;
  49.       FUNCTION GetReturnCode : INTEGER;            VIRTUAL;
  50.       FUNCTION GetXLength : BYTE;                  VIRTUAL;
  51.       FUNCTION GetYLength : BYTE;                  VIRTUAL;
  52.       DESTRUCTOR Done;                             VIRTUAL;
  53.     END;
  54.  
  55.  
  56. IMPLEMENTATION
  57.  
  58.   CONSTRUCTOR VirtualScreen.Init(XL, YL : BYTE);
  59.   {   Belegt für einen xl*yl großen virtuellen Bild-       }
  60.   {   schirm Speicher. Im Fehlerfall wird mit Fail be-     }
  61.   {   endet, dh eine dynamische Instanz zeigt auf NIL      }
  62.   {   (siehe auch Demoprogramm).                           }
  63.   VAR
  64.     NeededMem : WORD;
  65.   BEGIN
  66.     XLength    := XL;
  67.     YLength    := YL;
  68.     ReturnCode := VSOk;
  69.     NeededMem  := XLength * YLength * 2;
  70.     IF XLength * YLength > 10000 THEN
  71.       Fail               { zu groß -> geht nicht -> fertig }
  72.     ELSE
  73.       IF MemAvail > NeededMem THEN
  74.         GetMem(VSMem, XLength * YLength * 2)
  75.       ELSE
  76.         Fail;
  77.   END;
  78.  
  79.   PROCEDURE VirtualScreen.Clear;
  80.   BEGIN
  81.     Fill(' ', 7);
  82.   END;
  83.  
  84.   PROCEDURE VirtualScreen.ClearPart(x1, y1, x2, y2 : BYTE);
  85.   BEGIN
  86.     FillPart(x1, y1, x2, y2, 7, ' ');
  87.   END;
  88.  
  89.   PROCEDURE VirtualScreen.Fill(Chr : CHAR; Attr : BYTE);
  90.   BEGIN
  91.     FillPart(1, 1, XLength, YLength, Attr, Chr);
  92.   END;
  93.  
  94.   PROCEDURE VirtualScreen.FillPart
  95.              (x1, y1, x2, y2, Attr : BYTE; Chr : CHAR);
  96.   VAR
  97.     i, j : BYTE;
  98.   BEGIN
  99.     IF XYInVSMem(x1, y1) AND XYInVSMem(x2, y2) THEN
  100.       FOR i := y1 TO y2 DO             { ja, also "füllen" }
  101.         FOR j := x1 TO x2 DO
  102.           VSMem^[GetAddr(j, i)] := Ord(Chr) + Attr SHL 8
  103.     ELSE
  104.       SetReturnCode(VSXYInvalid);
  105.   END;
  106.  
  107.   PROCEDURE VirtualScreen.FillPartAttr
  108.              (x1, y1, x2, y2, Attr : BYTE);
  109.   VAR
  110.     i, j : BYTE;
  111.   BEGIN
  112.     IF XYInVSMem(x1, y1) AND XYInVSMem(x2, y2) THEN
  113.       FOR i := y1 TO y2 DO
  114.         FOR j := x1 TO x2 DO
  115.           VSMem^[GetAddr(j, i)] :=
  116.             Lo(VSMem^[GetAddr(j, i)]) + Attr SHL 8
  117.     ELSE                      { ändert nur das Attribut ! }
  118.       SetReturnCode(VSXYInvalid);
  119.   END;
  120.  
  121.   PROCEDURE VirtualScreen.WriteChr
  122.              (x, y, Attr : BYTE; Chr : CHAR);
  123.   BEGIN
  124.     IF XYInVSMem(x, y) THEN
  125.       VSMem^[GetAddr(x, y)] := Ord(Chr) + Attr SHL 8
  126.     ELSE
  127.       SetReturnCode(VSXYInvalid);
  128.   END;
  129.  
  130.   PROCEDURE VirtualScreen.WriteStr
  131.              (x, y, Attr : BYTE; Str : STRING);
  132.   VAR
  133.     i : BYTE;
  134.   BEGIN
  135.     IF XYInVSMem(x, y) AND
  136.        XYInVSMem(Pred(x+Length(Str)), y) THEN
  137.       FOR i := 1 TO Length(Str) DO
  138.         VSMem^[GetAddr(Pred(x+i), y)] :=
  139.           Ord(Str [i]) + Attr SHL 8
  140.     ELSE
  141.       SetReturnCode(VSXYInvalid);
  142.   END;
  143.  
  144.   PROCEDURE VirtualScreen.WriteAttr(x, y, Attr : BYTE);
  145.   VAR
  146.     Addr : WORD;
  147.   BEGIN
  148.     IF XYInVSMem(x, y) THEN BEGIN
  149.       Addr := GetAddr(x, y);
  150.       VSMem^[Addr] := Lo(VSMem^[Addr]) + Attr SHL 8;
  151.     END ELSE
  152.       SetReturnCode(VSXYInvalid);
  153.   END;
  154.  
  155.   PROCEDURE VirtualScreen.SetReturnCode(Code : BYTE);
  156.   BEGIN
  157.     ReturnCode := Code;
  158.   END;
  159.  
  160.   FUNCTION VirtualScreen.GetPartPtr
  161.             (x, y : BYTE) : ScreenMemPtr;
  162.   BEGIN
  163.     IF XYInVSMem(x, y) THEN
  164.       GetPartPtr := Addr(VSMem^[GetAddr(x, y)])
  165.     ELSE
  166.       SetReturnCode(VSXYInvalid);
  167.   END;
  168.  
  169.   FUNCTION VirtualScreen.XYInVSMem(x,y:BYTE) : BOOLEAN;
  170.   {   Prüft, ob x/y im Bereich des virtuellen Bild-        }
  171.   {   schirms liegt (intern verwendet, auch von außen      }
  172.   {   möglich).                                            }
  173.   BEGIN
  174.     IF(x > 0) AND (x <= XLength) AND
  175.       (y > 0) AND (y <= YLength) THEN
  176.       XYInVSMem := TRUE
  177.     ELSE
  178.       XYInVSMem := FALSE;
  179.   END;
  180.  
  181.   FUNCTION VirtualScreen.GetAddr(x, y : BYTE) : WORD;
  182.   {   Liefert die Adresse des Bytes mit der Position       }
  183.   {   x/y(im virtuellen Bildschirm) RELATIV zur An-        }
  184.   {   fangsposition des Speichers des virtuellen Bild-     }
  185.   {   schirms. Bedingung: X/Y innerhalb des vBs, wird      }
  186.   {   nicht(!) geprüft.                                    }
  187.   BEGIN
  188.     GetAddr := Pred(y) * XLength +  Pred(x);
  189.   END;
  190.  
  191.   FUNCTION VirtualScreen.GetReturnCode : INTEGER;
  192.   BEGIN
  193.     GetReturnCode := ReturnCode;
  194.     SetReturnCode(VSOk);
  195.   END;
  196.  
  197.   FUNCTION VirtualScreen.GetXLength : BYTE;
  198.   BEGIN
  199.     GetXLength := XLength;
  200.   END;
  201.  
  202.   FUNCTION VirtualScreen.GetYLength : BYTE;
  203.   BEGIN
  204.     GetYLength := YLength;
  205.   END;
  206.  
  207.   DESTRUCTOR VirtualScreen.Done;
  208.   BEGIN
  209.     IF VSMem <> NIL THEN
  210.       FreeMem(VSMem, XLength * YLength * 2);
  211.   END;
  212.  
  213. {$F+}
  214.   FUNCTION HeapFunc(Size : WORD) : INTEGER;
  215.   BEGIN
  216.     HeapFunc := 1;
  217.   END;
  218. {$F-}
  219.  
  220. BEGIN
  221.   HeapError := @HeapFunc;
  222. END.
  223. (* ------------------------------------------------------ *)
  224. (*                  Ende von VSOBJ.PAS                    *)
  225.