Turbo Toolbox/Turbo_Toolbox.iso/spezial/22/windows/framewin.pas

Pascal/Delphi Source File | 1991-01-04 | 10.0 KB | 319 lines

(* ----------------------------------------------------- *)
(*                     FRAMEWIN.PAS                      *)
(*                                                       *)
(* ■ FrameWindow: Beinhaltet nur die Fähigkeit, einen    *)
(*   Fensterrahmen in verschiedenen Arten und mit oder   *)
(*   ohne Schatten zu zeichnen. Der Konstruktor Copy er- *)
(*   laubt die Übernahme (ohne Prüfung) aller Daten aus  *)
(*   einem anderen Objekt des gleichen Typs; Show        *)
(*   zeichnet den Rahmen mit Hilfe von internen Methoden,*)
(*   die keine Prüfung der Variablen vornehmen, also     *)
(*   wirklich nur intern gebraucht werden sollten.       *)
(*                                                       *)
(*         (c) 1991 by R.Reichert & toolbox              *)
(* ----------------------------------------------------- *)
UNIT FrameWin;

INTERFACE

USES UBase, WinVSM;

CONST
  On       = TRUE;
  Off      = FALSE;
  FrameNo  = 5;          { Anzahl Rahmenarten, Arten:     }
  FSingle  = 1;          { einfach                        }
  FDouble  = 2;          { doppelt                        }
  FHorizD  = 3;          { horizontal doppelt             }
  FVerticD = 4;          { vertikal doppelt               }
  FMixed   = 5;          { rechts und unten doppelt       }
  Frames   : ARRAY [1..FrameNo] OF STRING [8] =
               ('┌┐└┘──││',  '╔╗╚╝══║║',
                '╒╕╘╛══││',  '╓╖╙╜──║║',
                '┌╖╘╝─═│║');
  Invers   = $70;
  StdFrCol = Invers;
  StdTLCol = 15+Invers;
  StdBLCol = Invers;
  StdShaCol= Invers;

TYPE
  FrameWindowPtr = ^FrameWindow;
  FrameWindow =
    OBJECT (Base)

      x1, y1, x2, y2,                  { Ecken            }
      Frame,                           { Rahmenart        }
      ShaCol,                          { Schattenfarbe    }
      FrCol,                           { Rahmenfarbe      }
      TLCol,                           { Kopfzeilenfarbe  }
      BLCol : BYTE;                    { Fusszeilenfarbe  }
      TL,                              { Kopfzeile        }
      BL    : STRING;                  { Fusszeile        }
      VarOk,                           { Variablen gültig?}
      Shadow,                          { Schatten ?       }
      Opened: BOOLEAN;                 { geöffnet ?       }
      VSM   : WExtVSMPtr;

      CONSTRUCTOR Init (NewVSM : WExtVSMPtr);
      CONSTRUCTOR Copy (NewFW  : FrameWindow);
      PROCEDURE Show;                              VIRTUAL;
      PROCEDURE Hide;                              VIRTUAL;
      PROCEDURE DrawFrame;           { INTERN }    VIRTUAL;
      PROCEDURE DrawTitles;          { INTERN }    VIRTUAL;
      PROCEDURE DrawShadow;          { INTERN }    VIRTUAL;
      PROCEDURE CheckVars;           { INTERN }    VIRTUAL;
      { Die folgenden Set... Methoden übernehmen Daten nur,
        wenn Opened FALSE ist.                            }
      PROCEDURE SetColors
        (FrameCol, TLineCol,
         BLineCol, ShadowCol : BYTE);              VIRTUAL;
      PROCEDURE SetTitles
        (TopLine, BottomLine : STRING);            VIRTUAL;
      PROCEDURE SetShadow (Sha : BOOLEAN);         VIRTUAL;
      PROCEDURE SetFrame (NewFrame : BYTE);        VIRTUAL;
      PROCEDURE SetXY (NewX1, NewY1,
                       NewX2, NewY2 : BYTE);       VIRTUAL;

      FUNCTION IsOpened : BOOLEAN;                 VIRTUAL;
      FUNCTION ShadowOn : BOOLEAN;                 VIRTUAL;
      FUNCTION GetFrameCol : BYTE;                 VIRTUAL;
      FUNCTION GetTLineCol : BYTE;                 VIRTUAL;
      FUNCTION GetBLineCol : BYTE;                 VIRTUAL;
      FUNCTION GetShadowCol: BYTE;                 VIRTUAL;
      FUNCTION GetTopLine : STRING;                VIRTUAL;
      FUNCTION GetBottomLine : STRING;             VIRTUAL;
      FUNCTION GetVarOK : BOOLEAN;                 VIRTUAL;
      FUNCTION GetFrame : BYTE;                    VIRTUAL;
      FUNCTION GetX1 : BYTE;                       VIRTUAL;
      FUNCTION GetY1 : BYTE;                       VIRTUAL;
      FUNCTION GetX2 : BYTE;                       VIRTUAL;
      FUNCTION GetY2 : BYTE;                       VIRTUAL;
    END;

IMPLEMENTATION

CONSTRUCTOR FrameWindow.Init (NewVSM : WExtVSMPtr);
BEGIN
  IF NewVSM<>NIL THEN BEGIN
    Opened := FALSE;
    VSM    := NewVSM;
    SetFrame (FSingle);                { einfacher Rahmen }
    SetColors (StdFrCol, StdTLCol,          { Grundfarben }
               StdBLCol, StdShaCol);
    SetShadow (Off);                  { und kein Schatten }
    SetXY (1, 1, VSM^.GetXLength, VSM^.GetYLength);
                                           { volle Grösse }
    SetTitles ('', '');                      { ohne Titel }
    VarOk := TRUE;         { alles noch in bester Ordnung }
  END;
END;

CONSTRUCTOR FrameWindow.Copy (NewFW : FrameWindow);
BEGIN
  IF NewFW.VSM=NIL THEN Fail
                   ELSE Self := NewFW;
END;

(* ----------------------------------------------------- *)
(* Show "zeichnet" das Fenster in den Bildschirm -       *)
(* ACHTUNG: Welcher "Bildschirm" das ist, bestimmt das   *)
(* Anwenderobjekt vom Typ ExtVSManager(Ptr), auf das VSM *)
(* zeigt !                                               *)
(* ----------------------------------------------------- *)
PROCEDURE FrameWindow.Show;
BEGIN
  CheckVars;
  IF VarOk THEN BEGIN
    DrawFrame;                               { den Rahmen }
    DrawTitles;                   { und die "Titel" sowie }
    DrawShadow;                         { ev den Schatten }
    Opened := TRUE;                          { "zeichnen" }
  END;
END;

PROCEDURE FrameWindow.Hide;
BEGIN
  Opened := FALSE;    { kann sich noch nicht "verstecken" }
END;

PROCEDURE FrameWindow.DrawFrame;
BEGIN
  WITH VSM^ DO BEGIN
    FillPart (Succ (x1), y1, Pred (x2), y1,
              FrCol, Frames [Frame, 5]);
    FillPart (Succ (x1), y2, Pred (x2), y2,
              FrCol, Frames [Frame, 6]);
    FillPart (x1, Succ (y1), x1, Pred (y2),
              FrCol, Frames [Frame, 7]);
    FillPart (x2, Succ (y1), x2, Pred (y2),
              FrCol, Frames [Frame, 8]);
    WriteChr (x1, y1, FrCol, Frames [Frame, 1]);
    WriteChr (x2, y1, FrCol, Frames [Frame, 2]);
    WriteChr (x1, y2, FrCol, Frames [Frame, 3]);
    WriteChr (x2, y2, FrCol, Frames [Frame, 4]);
  END;
END;

PROCEDURE FrameWindow.DrawTitles;
BEGIN
  WITH VSM^ DO BEGIN
    IF Length (TL) < Pred (x2-x1) THEN
      WriteStr (x1+(x2-x1) DIV 2-Length (TL) DIV 2,
                y1, TLCol, TL);
    IF Length (BL) < Pred (x2-x1) THEN
      WriteStr (Pred (x2) - Length (BL), y2, BLCol, BL);
  END;
END;

PROCEDURE FrameWindow.DrawShadow;
BEGIN
  IF Shadow THEN
    WITH VSM^ DO BEGIN
      FillPartAttr (Succ (x2), Succ (y1+1),
                    Succ (x2+1),Succ (y2), ShaCol);
      FillPartAttr (Succ (x1+1), Succ (y2),
                    Succ (x2+1), Succ (y2), ShaCol);
    END;
END;

(* ----------------------------------------------------- *)
(* CheckVars setzt via SetXY die Koordinaten noch einmal,*)
(* damit sichergestellt ist, dass der Schatten schon ON/ *)
(* OFF gesetzt ist. So wird sichergestellt, dass der ev  *)
(* vorhandene Schatten Platz hat (SetShadow kann auch    *)
(* nach SetXY aufgerufen werden, dann ist keine Kontrolle*)
(* mehr möglich).                                        *)
(* ----------------------------------------------------- *)
PROCEDURE FrameWindow.CheckVars;
BEGIN
  SetXY (x1, y1, x2, y2);
END;

PROCEDURE FrameWindow.SetColors
            (FrameCol, TLineCol,
             BLineCol, ShadowCol : BYTE);
BEGIN
  IF NOT Opened THEN BEGIN
    FrCol := FrameCol;  ShaCol := ShadowCol;
    TLCol := TLineCol;  BLCol  := BLineCol;
  END;
END;

PROCEDURE FrameWindow.SetTitles
            (TopLine, BottomLine : STRING);
BEGIN
  IF NOT Opened THEN BEGIN
    TL := TopLine;  BL := BottomLine;
  END;
END;

PROCEDURE FrameWindow.SetShadow (Sha : BOOLEAN);
BEGIN
  IF NOT Opened THEN Shadow := Sha;
END;

PROCEDURE FrameWindow.SetFrame (NewFrame : BYTE);
BEGIN
  IF (NOT Opened) AND
     (NewFrame>=1) AND
     (NewFrame<=FrameNo) THEN
    Frame := NewFrame;
END;

PROCEDURE FrameWindow.SetXY
            (NewX1, NewY1, NewX2, NewY2 : BYTE);
  VAR XL, YL : BYTE;
BEGIN
  IF NOT Opened THEN BEGIN
    XL := VSM^.GetXLength;  YL := VSM^.GetYLength;
    IF Shadow THEN BEGIN        { wenn Schatten, dann ist }
      Dec (XL, 2);  Dec (YL, 1);   { Bildschirm "kleiner" }
    END;
    IF (NewX2>=1) AND (NewX2<=XL) AND
       (NewX1>=1) AND (NewX1<NewX2) AND
       (NewY2>=1) AND (NewY2<=YL) AND
       (NewY1>=1) AND (NewY1<NewY2) THEN BEGIN
      x1 := NewX1;  x2 := NewX2;
      y1 := NewY1;  y2 := NewY2;
      VarOk := TRUE;
    END ELSE
      VarOk := FALSE;
  END;
END;

FUNCTION FrameWindow.IsOpened : BOOLEAN;
BEGIN
  IsOpened := Opened;
END;

FUNCTION FrameWindow.ShadowOn : BOOLEAN;
BEGIN
  ShadowOn := Shadow;
END;

FUNCTION FrameWindow.GetFrameCol : BYTE;
BEGIN
  GetFrameCol := FrCol;
END;

FUNCTION FrameWindow.GetTLineCol : BYTE;
BEGIN
  GetTLineCol := TLCol;
END;

FUNCTION FrameWindow.GetBLineCol : BYTE;
BEGIN
  GetBLineCol := BLCol;
END;

FUNCTION FrameWindow.GetShadowCol: BYTE;
BEGIN
  GetShadowCol := ShaCol;
END;

FUNCTION FrameWindow.GetTopLine  : STRING;
BEGIN
  GetTopLine := TL;
END;

FUNCTION FrameWindow.GetBottomLine : STRING;
BEGIN
  GetBottomLine := BL;
END;

FUNCTION FrameWindow.GetVarOk : BOOLEAN;
BEGIN
  GetVarOk := VarOk;
END;

FUNCTION FrameWindow.GetFrame : BYTE;
BEGIN
  GetFrame := Frame;
END;

FUNCTION FrameWindow.GetX1 : BYTE;
BEGIN
  GetX1 := x1;
END;

FUNCTION FrameWindow.GetY1 : BYTE;
BEGIN
  GetY1 := y1;
END;

FUNCTION FrameWindow.GetX2 : BYTE;
BEGIN
  GetX2 := x2;
END;

FUNCTION FrameWindow.GetY2 : BYTE;
BEGIN
  GetY2 := y2;
END;

END.
(* ----------------------------------------------------- *)
(*               Ende von FRAMEWIN.PAS                   *)
(* ----------------------------------------------------- *)