home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 22 / vsms / vsobj.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-01-04  |  6.9 KB  |  224 lines
  1. (* ----------------------------------------------------- *)
  2. (*                       VSOBJ.PAS                       *)
  3. (*                                                       *)
  4. (* ■ VirtualScreen: Objekt, das einen virtuellen Bild-   *)
  5. (*   schirm implementiert.                               *)
  6. (*                                                       *)
  7. (*          (c) 1991 by R.Reichert & toolbox             *)
  8. (* ----------------------------------------------------- *)
  9. UNIT VSObj;
  10.  
  11. INTERFACE
  12.  
  13. USES UBase;
  14.  
  15. CONST                       { ReturnCodes:                }
  16.   VSOk        = 0;          { Kein Fehler (defaultmässig) }
  17.   VSXYInvalid = 1;          { x und/oder y ungültig       }
  18.  
  19. TYPE
  20.   ScreenMemPtr = ^ScreenMemory;
  21.   ScreenMemory = ARRAY [0..10000] OF WORD;
  22.  
  23.   VirtualScreenPtr = ^VirtualScreen;
  24.   VirtualScreen    = OBJECT (Base)
  25.  
  26.     XLength,                         { X-Länge des vB's }
  27.     YLength,                         { Y-Länge des vB's }
  28.     ReturnCode : BYTE;
  29.     VSMem      : ScreenMemPtr;       { Speicher für vB  }
  30.  
  31.     CONSTRUCTOR Init (XL, YL : BYTE);
  32.     PROCEDURE Clear;                               VIRTUAL;
  33.     PROCEDURE ClearPart (x1, y1, x2, y2 : BYTE);   VIRTUAL;
  34.     PROCEDURE Fill (Chr:CHAR; Attr:BYTE);          VIRTUAL;
  35.     PROCEDURE FillPart
  36.       (x1, y1, x2, y2, Attr : BYTE; Chr : CHAR);   VIRTUAL;
  37.     PROCEDURE FillPartAttr
  38.       (x1, y1, x2, y2, Attr : BYTE);               VIRTUAL;
  39.     PROCEDURE WriteChr (x,y,Attr:BYTE;Chr:CHAR);   VIRTUAL;
  40.     PROCEDURE WriteStr(x,y,Attr:BYTE;Str:STRING);  VIRTUAL;
  41.     PROCEDURE WriteAttr (x, y, Attr : BYTE);       VIRTUAL;
  42.     PROCEDURE SetReturnCode (Code : BYTE);         VIRTUAL;
  43.     FUNCTION GetPartPtr (x,y:BYTE):ScreenMemPtr;   VIRTUAL;
  44.     FUNCTION XYInVSMem (x, y : BYTE) : BOOLEAN;    VIRTUAL;
  45.     FUNCTION GetAddr (x, y : BYTE) : WORD;         VIRTUAL;
  46.     FUNCTION GetReturnCode : INTEGER;              VIRTUAL;
  47.     FUNCTION GetXLength : BYTE;                    VIRTUAL;
  48.     FUNCTION GetYLength : BYTE;                    VIRTUAL;
  49.     DESTRUCTOR Done;                               VIRTUAL;
  50.   END;
  51.  
  52. IMPLEMENTATION
  53.  
  54. (* ----------------------------------------------------- *)
  55. (* Belegt für einen xl*yl grossen virtuellen Bildschirm  *)
  56. (* Speicher.                                             *)
  57. (* ----------------------------------------------------- *)
  58. CONSTRUCTOR VirtualScreen.Init (XL, YL : BYTE);
  59.   VAR NeededMem : WORD;
  60. BEGIN
  61.   XLength := XL;
  62.   YLength := YL;
  63.   ReturnCode := VSOk;
  64.   NeededMem := XLength*YLength*2;
  65.   IF XLength*YLength>10000 THEN
  66.     Fail
  67.   ELSE
  68.     IF MemAvail>NeededMem THEN
  69.       GetMem (VSMem, XLength*YLength*2)
  70.     ELSE           { wenn es nicht genügend Speicher für  }
  71.       Fail;        { den virt. Bildschirm hat, kann nicht }
  72.                    { gearbeitet werden.                   }
  73. END;
  74.  
  75. (* ----------------------------------------------------- *)
  76. (* Die folgenden Methoden sind zur Bearbeitung des virtu-*)
  77. (* ellen Bildschirms gedacht.                            *)
  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 i, j : BYTE;
  97. BEGIN
  98.   IF XYInVSMem (x1, y1) AND  { x und y gültig ? }
  99.      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)] :=
  103.           WORD (Ord(Chr)+Attr SHL 8)
  104.   ELSE
  105.     SetReturnCode (VSXYInvalid);
  106. END;
  107.  
  108. PROCEDURE VirtualScreen.FillPartAttr
  109.             (x1, y1, x2, y2, Attr : BYTE);
  110.   VAR i, j : BYTE;
  111. BEGIN
  112.   IF XYInVSMem (x1, y1) AND
  113.      XYInVSMem (x2, y2) THEN
  114.     FOR i := y1 TO y2 DO
  115.       FOR j := x1 TO x2 DO
  116.         VSMem^[GetAddr (j, i)] :=
  117.           WORD (Lo (VSMem^[GetAddr (j, i)]) + Attr SHL 8)
  118.   ELSE
  119.     SetReturnCode (VSXYInvalid);
  120. END;
  121.  
  122. PROCEDURE VirtualScreen.WriteChr
  123.             (x, y, Attr : BYTE; Chr : CHAR);
  124. BEGIN
  125.   IF XYInVSMem (x, y) THEN
  126.     VSMem^[GetAddr (x, y)] := WORD (Ord (Chr)+Attr SHL 8)
  127.   ELSE
  128.     SetReturnCode (VSXYInvalid);
  129. END;
  130.  
  131. PROCEDURE VirtualScreen.WriteStr
  132.             (x, y, Attr : BYTE; Str : STRING);
  133.   VAR 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.         WORD (Ord (Str [i]) + Attr SHL 8)
  140.   ELSE
  141.     SetReturnCode (VSXYInvalid);
  142. END;
  143.  
  144. PROCEDURE VirtualScreen.WriteAttr (x, y, Attr : BYTE);
  145.   VAR Addr : WORD;
  146. BEGIN
  147.   IF XYInVSMem (x, y) THEN BEGIN
  148.     Addr := GetAddr (x, y);
  149.     VSMem^[Addr] := WORD (Lo (VSMem^[Addr]) + Attr SHL 8);
  150.   END ELSE
  151.     SetReturnCode (VSXYInvalid);
  152. END;
  153.  
  154.  
  155. PROCEDURE VirtualScreen.SetReturnCode (Code : BYTE);
  156. BEGIN
  157.   ReturnCode := Code;
  158. END;
  159.  
  160. (* ----------------------------------------------------- *)
  161. (* Liefert einen Zeiger auf den mit x/y beginnenden Be-  *)
  162. (* reich des virtuellen Bildschirms.                     *)
  163. (* ----------------------------------------------------- *)
  164. FUNCTION VirtualScreen.GetPartPtr
  165.            (x, y : BYTE) : ScreenMemPtr;
  166. BEGIN
  167.   IF XYInVSMem (x, y) THEN
  168.     GetPartPtr := Addr (VSMem^[GetAddr (x, y)])
  169.   ELSE
  170.     SetReturnCode (VSXYInvalid);
  171. END;
  172.  
  173. (* ----------------------------------------------------- *)
  174. (* Prüft, ob x/y im Bereich des virtuellen Bildschirms.  *)
  175. (* ----------------------------------------------------- *)
  176. FUNCTION VirtualScreen.XYInVSMem (x,y:BYTE) : BOOLEAN;
  177. BEGIN
  178.   IF (x>0) AND (x<=XLength) AND
  179.      (y>0) AND (y<=YLength) THEN
  180.     XYInVSMem := TRUE
  181.   ELSE
  182.     XYInVSMem := FALSE
  183. END;
  184.  
  185. (* ----------------------------------------------------- *)
  186. (* Liefert die Adresse des Bytes mit der Position x/y    *)
  187. (* im virtuellen Bildschirm RELATIV zur Anfangsposition  *)
  188. (* virtuellen Bidlschirmspeicher.                        *)
  189. (* ----------------------------------------------------- *)
  190. FUNCTION VirtualScreen.GetAddr (x, y : BYTE) : WORD;
  191. BEGIN
  192.   IF XYInVSMem (x, y) THEN
  193.     GetAddr := Pred (y) * XLength +  Pred (x)
  194.   ELSE
  195.     GetAddr := 0;
  196. END;
  197.  
  198. FUNCTION VirtualScreen.GetReturnCode : INTEGER;
  199. BEGIN
  200.   GetReturnCode := ReturnCode;
  201.   SetReturnCode (VSOk);
  202. END;
  203.  
  204. FUNCTION VirtualScreen.GetXLength : BYTE;
  205. BEGIN
  206.   GetXLength := XLength;
  207. END;
  208.  
  209. FUNCTION VirtualScreen.GetYLength : BYTE;
  210. BEGIN
  211.   GetYLength := YLength;
  212. END;
  213.  
  214. DESTRUCTOR VirtualScreen.Done;
  215. BEGIN
  216.   IF VSMem<>NIL THEN
  217.     FreeMem (VSMem, XLength*YLength*2);
  218. END;
  219.  
  220. END.
  221. (* ----------------------------------------------------- *)
  222. (*                    Ende von VSOBJ.PAS                 *)
  223. (* ----------------------------------------------------- *)
  224.