home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 22 / windows / standwin.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-01-04  |  9.3 KB  |  282 lines
  1. (* ----------------------------------------------------- *)
  2. (*                     STANDWIN.PAS                      *)
  3. (*                                                       *)
  4. (* ■ StandardWindow: Ein Standardfenster hat die noble   *)
  5. (*   Fähigkeit, sich verschieben und vergrössern bzw ver-*)
  6. (*   kleinern zu können; dafür können Minimalgrösse und  *)
  7. (*   Maximalgrösse (=maximale Grösse) vorgeschrieben wer-*)
  8. (*   den.                                                *)
  9. (*                                                       *)
  10. (*           (c) 1991 by R.Reichert & toolbox             *)
  11. (* ----------------------------------------------------- *)
  12. UNIT StandWin;
  13.  
  14. INTERFACE
  15.  
  16. USES FrameWin, Windows, WinVSM;
  17.  
  18. CONST
  19.   On            = TRUE;
  20.   Off           = FALSE;       { ReturnCodes ("Antwort"): }
  21.   MvNotAllowed  = 11;   { MoveAllowed ist FALSE (MoveAbs) }
  22.   ZoNotAllowed  = 12;   { ZoomAloowed ist FALSE (ZoomAbs) }
  23.   MinMaxInvalid = 13;
  24.                      { Ungültige MinMax-Werte (SetMinMax) }
  25.   MLInvalid     = 14;
  26.                  { Ungültige Minimalgrösse (SetMinLength) }
  27.   WinIsOpen     = 15;   { Fenster offen, Methode darf     }
  28.                         { nicht aufgerufen werden (Open,  }
  29.                         { SetMinLength, SetXY ...)        }
  30.   WinNotOpen    = 16;   { Fenster nicht offen (Move...)   }
  31.  
  32. TYPE
  33.   StandardWindowPtr = ^StandardWindow;
  34.   StandardWindow =
  35.     OBJECT (WindowObj)
  36.  
  37.       ZoomAllowed,                    { Zooming erlaubt ? }
  38.       MoveAllowed : BOOLEAN;          { Bewegen erlaubt ? }
  39.       MinX, MinY,                     { Bewegungsraum     }
  40.       MaxX, MaxY,                { minimale INNERE Grösse }
  41.       MinXL, MinYL: BYTE;             { des Fensters      }
  42.  
  43.       CONSTRUCTOR Init (VSMPtr : WExtVSMPtr);
  44.       CONSTRUCTOR Copy (Win : StandardWindow);
  45.       PROCEDURE Move (x, y : SHORTINT);            VIRTUAL;
  46.       PROCEDURE Zoom (x, y : SHORTINT);            VIRTUAL;
  47.       PROCEDURE MoveAbs (x, y : BYTE);             VIRTUAL;
  48.       PROCEDURE ZoomAbs (x, y : BYTE);             VIRTUAL;
  49.       PROCEDURE SetMinMax
  50.         (NewMinX,NewMinY,NewMaxX,NewMaxY : BYTE);  VIRTUAL;
  51.       PROCEDURE SetXY
  52.         (NewX1, NewY1, NewX2, NewY2 : BYTE);       VIRTUAL;
  53.       PROCEDURE SetMinLength (MXL, MYL : BYTE);    VIRTUAL;
  54.       PROCEDURE SetZooming (Zooming : BOOLEAN);    VIRTUAL;
  55.       PROCEDURE SetMoving (Moving : BOOLEAN);      VIRTUAL;
  56.       PROCEDURE CheckVars;                         VIRTUAL;
  57.  
  58.       FUNCTION GetMove : BOOLEAN;                  VIRTUAL;
  59.       FUNCTION GetZoom : BOOLEAN;                  VIRTUAL;
  60.       FUNCTION GetMinX : BYTE;                     VIRTUAL;
  61.       FUNCTION GetMinY : BYTE;                     VIRTUAL;
  62.       FUNCTION GetMaxX : BYTE;                     VIRTUAL;
  63.       FUNCTION GetMaxY : BYTE;                     VIRTUAL;
  64.       FUNCTION GetMinXL: BYTE;                     VIRTUAL;
  65.       FUNCTION GetMinYL: BYTE;                     VIRTUAL;
  66.     END;
  67.  
  68. IMPLEMENTATION
  69.  
  70. CONSTRUCTOR StandardWindow.Init (VSMPtr : WExtVSMPtr);
  71. BEGIN
  72.   IF WindowObj.Init (VSMPtr) THEN BEGIN       { Vorgänger }
  73.     SetXY (1, 1, x2-2, y2-1);
  74.     SetShadow (On);
  75.     SetZooming (Off);          { nix ist erlaubt, weder   }
  76.     SetMoving (On);            { Zooming noch Moving      }
  77.     SetMinLength (10, 1);      { Std-Mini/Maximalgrösse   }
  78.     SetMinMax (1, 1, VSM^.GetXLength, VSM^.GetYLength);
  79.   END ELSE
  80.     Fail;
  81. END;
  82.  
  83. CONSTRUCTOR StandardWindow.Copy (Win : StandardWindow);
  84. BEGIN
  85.   IF Win.VSM=NIL THEN Fail
  86.                  ELSE Self := Win;
  87. END;
  88.  
  89. (* ----------------------------------------------------- *)
  90. (* Bewegt Fenster RELATIV um x,y (auch negativ möglich). *)
  91. (* ----------------------------------------------------- *)
  92. PROCEDURE StandardWindow.Move (x, y : SHORTINT);
  93. BEGIN
  94.   MoveAbs (BYTE (x1+x), BYTE (y1+Y));
  95. END;
  96.  
  97. (* ----------------------------------------------------- *)
  98. (* Vergrössert bzw verkleinert Fenster **RELATIV** um x/y*)
  99. (* ----------------------------------------------------- *)
  100. PROCEDURE StandardWindow.Zoom (x, y : SHORTINT);
  101. BEGIN
  102.   ZoomAbs (BYTE (x2+x), BYTE (y2+y));
  103. END;
  104.  
  105. (* ----------------------------------------------------- *)
  106. (* Bewegt Fenster **ABSOLUT**, dh x1=x und y1=y, x2 und  *)
  107. (* y2 werden so ausgerechnet, dass die Grösse beibehalten*)
  108. (* wird.                                                 *)
  109. (* ----------------------------------------------------- *)
  110. PROCEDURE StandardWindow.MoveAbs (x, y : BYTE);
  111.   VAR XLength, YLength : BYTE;
  112. BEGIN
  113.   IF Opened AND MoveAllowed THEN BEGIN
  114.     XLength := x2-x1;  YLength := y2-y1;
  115.     IF Shadow THEN BEGIN
  116.       Inc (XLength, 2);  Inc (YLength);
  117.     END;
  118.     IF x<MinX THEN x := MinX;
  119.     IF y<MinY THEN y := MinY;
  120.     IF x+XLength>MaxX THEN x := MaxX-XLength;
  121.     IF y+YLength>MaxY THEN y := MaxY-YLength;
  122.     IF (x<>x1) OR (y<>y1) THEN BEGIN
  123.       Close;
  124.       x2 := x2+(x-x1); y2 := y2+(y-y1);     { x und y neu }
  125.       x1 := x;         y1 := y;               { berechnen }
  126.       Open;                           { und wieder öffnen }
  127.     END;
  128.   END ELSE
  129.     IF Opened THEN
  130.       SetReturnCode (MvNotAllowed)   { Bew. nicht erlaubt }
  131.     ELSE
  132.       SetReturnCode (WinNotOpen);
  133. END;
  134.  
  135. (* ----------------------------------------------------- *)
  136. (* Vergrössert oder verkleinert Fenster **ABSOLUT**, dh  *)
  137. (* x2=x, y2=y, x1 und y1 bleiben unverändert. Weder die  *)
  138. (* maximale noch die minimale Grösse darf über- bzw      *)
  139. (* "unter"-schritten werden.                             *)
  140. (* ----------------------------------------------------- *)
  141. PROCEDURE StandardWindow.ZoomAbs (x, y : BYTE);
  142.   VAR TempX2, TempY2 : BYTE;
  143. BEGIN
  144.   IF Opened AND ZoomAllowed THEN BEGIN
  145.     TempX2 := x;  TempY2 := y;
  146.     IF Shadow THEN BEGIN
  147.       Inc (TempX2, 2);  Inc (TempY2);
  148.     END;
  149.     IF x<=x1+MinXL THEN x := Succ (x1+MinXL);
  150.     IF y<=y1+MinYL THEN y := Succ (y1+MinYL);
  151.     IF TempX2>MaxX THEN x := MaxX-2;
  152.     IF TempY2>MaxY THEN y := Pred (MaxY);
  153.     IF (x<>x2) OR (y<>y2) THEN BEGIN
  154.       Close;                             { ja, schliessen }
  155.       x2 := x;  y2 := y;               { neue Koordinaten }
  156.       Open;                            { und Neueröffnung }
  157.     END;
  158.   END ELSE
  159.     IF Opened THEN
  160.       SetReturnCode (ZoNotAllowed)     { Zooming verboten }
  161.     ELSE
  162.       SetReturnCode (WinNotOpen);
  163. END;
  164.  
  165. PROCEDURE StandardWindow.SetMinMax
  166.             (NewMinX, NewMinY, NewMaxX, NewMaxY : BYTE);
  167. BEGIN
  168.   IF NOT Opened THEN BEGIN
  169.     IF (NewMinX>=1) AND (NewMinY>=1) AND
  170.        (NewMinX<NewMaxX) AND (NewMinY<NewMaxY) AND
  171.        (NewMaxX<=VSM^.GetXLength) AND
  172.        (NewMaxY<=VSM^.GetYLength) THEN BEGIN
  173.       MinX := NewMinX;  MinY := NewMinY;
  174.       MaxX := NewMaxX;  MaxY := NewMaxY;
  175.     END ELSE
  176.       SetReturnCode (MinMaxInvalid);
  177.   END ELSE
  178.     SetReturnCode (WinIsOpen);
  179. END;
  180.  
  181. (* ----------------------------------------------------- *)
  182. (* Koordinaten festlegen. Hier schon wird geprüft, ob sie*)
  183. (* im vorgeschriebenen Raum liegen und die Mindestgrösse *)
  184. (* besitzen. Also zuerst SetMinMax und SetMinLength      *)
  185. (* (falls Standardwerte nicht genehm) aufrufen.          *)
  186. (* ----------------------------------------------------- *)
  187. PROCEDURE StandardWindow.SetXY (NewX1, NewY1,
  188.                                 NewX2, NewY2 : BYTE);
  189. BEGIN
  190.   WindowObj.SetXY (NewX1, NewY1, NewX2, NewY2);
  191.   IF (VarOk) THEN
  192.     IF (NewX1<MinX) AND (NewX2>MaxX) AND
  193.        (NewY1<MinY) AND (NewY2>MaxY) AND
  194.        (Pred (NewX2-NewX1)<MinXL) AND
  195.        (Pred (NewY2-NewY1)<MinYL) THEN
  196.     VarOk := FALSE;
  197. END;
  198.  
  199. PROCEDURE StandardWindow.SetMinLength (MXL, MYL : BYTE);
  200. BEGIN
  201.   IF NOT Opened THEN BEGIN
  202.     IF (MXL>=1) AND
  203.        (MXL<=VSM^.GetXLength-4) AND
  204.        (MYL>=1) AND
  205.        (MYL<=VSM^.GetYLength-3) THEN BEGIN
  206.       MinXL := MXL;
  207.       MinYL := MYL;
  208.     END ELSE
  209.       SetReturnCode (MLInvalid);
  210.   END ELSE
  211.     SetReturnCode (WinIsOpen);
  212. END;
  213.  
  214. PROCEDURE StandardWindow.SetZooming (Zooming : BOOLEAN);
  215. BEGIN
  216.   ZoomAllowed := Zooming;
  217. END;
  218.  
  219. PROCEDURE StandardWindow.SetMoving (Moving : BOOLEAN);
  220. BEGIN
  221.   MoveAllowed := Moving;
  222. END;
  223.  
  224. (* ----------------------------------------------------- *)
  225. (* Prüft die Variablen auf ihre Korrektheit unter Berück-*)
  226. (* sichtigung der Mindestgrösse und des Bewegungsraums.  *)
  227. (* ----------------------------------------------------- *)
  228. PROCEDURE StandardWindow.CheckVars;
  229. BEGIN
  230.   WindowObj.CheckVars;
  231.   IF VarOk THEN BEGIN
  232.     SetMinLength (MinXL, MinYL);
  233.     SetMinMax (MinX, MinY, MaxX, MaxY);
  234.     SetXY (x1, y1, x2, y2);
  235.   END;
  236. END;
  237.  
  238. FUNCTION StandardWindow.GetMove : BOOLEAN;
  239. BEGIN
  240.   GetMove := MoveAllowed;
  241. END;
  242.  
  243. FUNCTION StandardWindow.GetZoom : BOOLEAN;
  244. BEGIN
  245.   GetZoom := ZoomAllowed;
  246. END;
  247.  
  248. FUNCTION StandardWindow.GetMinX : BYTE;
  249. BEGIN
  250.   GetMinX := MinX;
  251. END;
  252.  
  253. FUNCTION StandardWindow.GetMinY : BYTE;
  254. BEGIN
  255.   GetMinY := MinY;
  256. END;
  257.  
  258. FUNCTION StandardWindow.GetMaxX : BYTE;
  259. BEGIN
  260.   GetMaxX := MaxX;
  261. END;
  262.  
  263. FUNCTION StandardWindow.GetMaxY : BYTE;
  264. BEGIN
  265.   GetMaxY := MaxY;
  266. END;
  267.  
  268. FUNCTION StandardWindow.GetMinXL: BYTE;
  269. BEGIN
  270.   GetMinXL := MinXL;
  271. END;
  272.  
  273. FUNCTION StandardWindow.GetMinYL: BYTE;
  274. BEGIN
  275.   GetMinYL := MinYL;
  276. END;
  277.  
  278. END.
  279. (* ----------------------------------------------------- *)
  280. (*                  Ende von STANDWIN.PAS                *)
  281. (* ----------------------------------------------------- *)
  282.