home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 11 / grdlagen / datawin.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1990-10-05  |  20.3 KB  |  627 lines
  1. (* ------------------------------------------------------ *)
  2. (*                    DATAWIN.PAS                         *)
  3. (*  Zweck dieser Unit: Daten in einem Fenster bearbeiten. *)
  4. (*  Dazu werden ein paar Prozeduren vom Objekt            *)
  5. (*  "DataWinObj" implementiert.                           *)
  6. (*         (c) 1990 R.Reichert & TOOLBOX                  *)
  7. (* ------------------------------------------------------ *)
  8. UNIT DataWin;
  9.  
  10. INTERFACE
  11.  
  12. USES
  13.   StandWin,
  14.   Buffer5,
  15.   SB,
  16.   Crt;
  17.  
  18. CONST
  19.   ScrYLength : BYTE = 25;
  20.  
  21. TYPE
  22.   DataWinObjPtr = ^DataWinObj;
  23.   DataWinObj    = OBJECT
  24.     ScrollBarV,                  { Horiz. Scrollbalken     }
  25.     ScrollBarH,                  { Vertik. Scrollbalken    }
  26.     Access,                      { Zugriff erlaubt         }
  27.     MoveCur,                     { Cursor bewegen          }
  28.     OnlyBuf     : BOOLEAN;       { Nur im Puffer           }
  29.     CurX, CurY,                  { X-und Y-Positionen      }
  30.     px1, py1,                    { Begrenzungen            }
  31.     px2, py2,
  32.     Ls, Ts,
  33.     Rs, Bs      : INTEGER;
  34.     Buf         : BufferObjPtr;  { Puffer                  }
  35.  
  36.     Win         : StandardWindowPtr;
  37.  
  38.     SBVertikal,                  { Scrollbalken-Objekte    }
  39.     SBHoriz     : ScrollBarObj;
  40.  
  41.     CONSTRUCTOR Init;
  42.     CONSTRUCTOR WinInit;
  43.     CONSTRUCTOR BufInit;
  44.  
  45.     PROCEDURE WriteComment;                         VIRTUAL;
  46.     PROCEDURE ShowBars;                             VIRTUAL;
  47.     PROCEDURE ScrollBuf(x, y : INTEGER);            VIRTUAL;
  48.     PROCEDURE SaveASCII(Name : STRING;
  49.                         VAR Err : INTEGER);         VIRTUAL;
  50.     PROCEDURE LoadASCII(Name : STRING;
  51.                         VAR Err : INTEGER);         VIRTUAL;
  52.     PROCEDURE ShowBufPart(y1, y2 : INTEGER);        VIRTUAL;
  53.     PROCEDURE ShowBuf;                              VIRTUAL;
  54.     FUNCTION  GetWinXLength : BYTE;                 VIRTUAL;
  55.     FUNCTION  GetWinYLength : BYTE;                 VIRTUAL;
  56.     FUNCTION  GetCols : INTEGER;                    VIRTUAL;
  57.     FUNCTION  GetRows : INTEGER;                    VIRTUAL;
  58.     FUNCTION  InWindow(x, y : INTEGER) : BOOLEAN;   VIRTUAL;
  59.  
  60.     DESTRUCTOR Done;                                VIRTUAL;
  61.  
  62.     { ---- Neu implementierte Methoden aus BufferObj ----- }
  63.  
  64.     PROCEDURE WriteStrXY(x, y : INTEGER;
  65.                          Str  : STRING);            VIRTUAL;
  66.     PROCEDURE WriteStr(Str : STRING);               VIRTUAL;
  67.     PROCEDURE SetCursor(x, y : INTEGER);            VIRTUAL;
  68.     PROCEDURE InsLines(y, No : INTEGER);            VIRTUAL;
  69.     PROCEDURE DelLines(y, No : INTEGER);            VIRTUAL;
  70.     PROCEDURE SetWriteColors(Col, Back : BYTE);     VIRTUAL;
  71.     PROCEDURE ChangeColor(x1, y1, x2, y2 : INTEGER;
  72.                           Col, Back : BYTE);        VIRTUAL;
  73.     FUNCTION  ConvertLine(y : INTEGER) : STRING;    VIRTUAL;
  74.     FUNCTION  GetLineLength(y : INTEGER) : INTEGER; VIRTUAL;
  75.  
  76.     { ---- Neu implementierte Methoden aus StandardWindow -}
  77.  
  78.     PROCEDURE Open;                                 VIRTUAL;
  79.     PROCEDURE MoveWin(x, y : INTEGER);              VIRTUAL;
  80.     PROCEDURE ZoomWin(x, y : INTEGER);              VIRTUAL;
  81.     PROCEDURE ChangeFrame(NF : BYTE);               VIRTUAL;
  82.     PROCEDURE Show;                                 VIRTUAL;
  83.     PROCEDURE Hide;                                 VIRTUAL;
  84.     PROCEDURE ReOpen(WinData : StandardWindow);     VIRTUAL;
  85.     PROCEDURE Close;                                VIRTUAL
  86.   END;
  87.  
  88.  
  89. IMPLEMENTATION
  90.  
  91.   CONSTRUCTOR DataWinObj.Init;
  92.   (* ---------------------------------------------------- *)
  93.   (* Initialisiert das Objekt. Dabei werden auch die      *)
  94.   (* Init-Konstruktoren der beiden Instanzen "Buf" und    *)
  95.   (* "Win" aufgerufen. Die Reihenfolge sollte nicht       *)
  96.   (* geändert werden. Ein Nachkomme sollte die Initiali-  *)
  97.   (* sierung aufrufen, Access abfragen und wenn TRUE zu-  *)
  98.   (* rückkommt, die Variablen auf eigene Werte setzen.    *)
  99.   (* ---------------------------------------------------- *)
  100.   BEGIN
  101.     Access := TRUE;
  102.     WinInit;
  103.     IF Access THEN BEGIN
  104.       ScrollBarV := TRUE;           ScrollBarH := TRUE;
  105.       Ls         := 2;              Ts         := 1;
  106.       Rs         := 2;              Bs         := 2;
  107.       px1        := 1;              py1        := 1;
  108.       px2        := GetWinXLength;
  109.       py2        := GetWinYLength;
  110.       CurX       := 1;              CurY       := 1;
  111.       MoveCur    := TRUE;           OnlyBuf    := FALSE;
  112.       BufInit;
  113.       IF NOT Access THEN BEGIN
  114.         Done;  Fail;
  115.       END;
  116.     END ELSE Done;
  117.   END;
  118.  
  119.   CONSTRUCTOR DataWinObj.WinInit;
  120.   (* ---------------------------------------------------- *)
  121.   (* Dieser Konstruktor kümmert sich um die Window-       *)
  122.   (* initialisation und -daten.                           *)
  123.   (* ---------------------------------------------------- *)
  124.   BEGIN
  125.     { Durch die erweiterte Funktion von New ist es mög-
  126.       lich, Win auch auf einen Nachfolger zeigen zu
  127.       lassen, ohne den Typ von Win zu ändern. Als zweiter
  128.       Parameter bleibt der Konstruktor.                    }
  129.     Win := New(StandardWindowPtr, Init(StandWinData));
  130.  
  131.     IF Win = NIL THEN
  132.       Access := FALSE
  133.     ELSE
  134.       WITH Win^ DO BEGIN
  135.         FrameColor   := 7;
  136.         x1           := 1;     x2          := 78;
  137.         y1           := 1;     y2          := 20;
  138.         ShaVisible   := TRUE;
  139.         ShaColor     := 7;     ShaChr      := '░';
  140.         ShaXl        := 1;     ShaYl       := 1;
  141.         Framevisible := TRUE;  ShaTranspar := FALSE;
  142.         MoveAllowed  := TRUE;  ZoomAllowed := TRUE;
  143.         Visible      := FALSE;
  144.         BackColor    := 7;
  145.         TopLine      := 'Demonstration von DataWinObj';
  146.         BottomLine   := '(c) 1990 R.Reichert & TOOLBOX'
  147.       END;
  148.   END;
  149.  
  150.   CONSTRUCTOR DataWinObj.BufInit;
  151.   { Will man eine typisierte Konstante von "BufferObj"
  152.     z.B. zum temporären Speichern des Inhalts von "Buf",
  153.     so kann man - schließlich kommt es auf den Anfangswert
  154.     der einzelnen Variablen nicht an - das Weglassen auf
  155.     die Spitze treiben :                                   }
  156.   CONST
  157.     TempBufData : BufferObj = ();
  158.   BEGIN
  159.     TempBufData := BufData;             { Retten der Daten }
  160.     WITH BufData DO BEGIN
  161.       IF Columns < GetWinXLength THEN
  162.         Columns := GetWinXLength;
  163.       IF Columns > MaxColumns THEN Access := FALSE;
  164.       IF Lines   < ScrYLength THEN Lines  := ScrYLength;
  165.       IF Lines   > MaxLines   THEN Access := FALSE;
  166.       LineForm   := Left;
  167.       BufCol     := 15;    BufBackCol := 0;
  168.       MoveBufCur := TRUE;  LineFeed   := TRUE;
  169.       KillWrite  := TRUE;
  170.     END;
  171.     IF Access THEN
  172.       Buf := New(BufferObjPtr, Init(BufData));
  173.     IF (Buf = NIL) OR (Buf^.InitError) THEN Access := FALSE;
  174.     BufData := TempBufData;
  175.   END;
  176.  
  177.   PROCEDURE DataWinObj.WriteComment;
  178.   BEGIN
  179.     IF Access THEN BEGIN
  180.       IF ScrollBarV AND (Rs > 0) THEN
  181.         WITH SBVertikal DO BEGIN
  182.           x1 := Pred(Win^.x2);
  183.           y1 := Win^.y1 + Ts;
  184.           x2 := x1;
  185.           y2 := Win^.y2 - Bs;
  186.  
  187.           TBBCol := 7;           Horiz  := FALSE;
  188.           BTLChr := Chr(24);     BBRChr := Chr(25);
  189.           PosCol := 15;          PosChr := '▒';
  190.           BarCol := $70;         BarChr := '▒';
  191.           Max    := Buf^.Lines;  Pos    := CurY;
  192.  
  193.           ShowBar;
  194.         END;
  195.       IF ScrollBarH AND (Bs > 0) THEN
  196.         WITH SBHoriz DO BEGIN
  197.           x1 := Win^.x1 + Ls;
  198.           y1 := Pred(Win^.y2);
  199.           x2 := Win^.x2 - Rs;
  200.           y2 := y1;
  201.  
  202.           TBBCol := 7;             Horiz  := TRUE;
  203.           BTLChr := Chr(27);       BBRChr := Chr(26);
  204.           PosCol := 15;            PosChr := '▒';
  205.           BarCol := $70;           BarChr := '▒';
  206.           Max    := Buf^.Columns;  Pos    := CurX;
  207.  
  208.           ShowBar;
  209.         END;
  210.     END;
  211.   END;
  212.  
  213.   PROCEDURE DataWinObj.ShowBars;
  214.   BEGIN
  215.     IF Access THEN BEGIN
  216.       IF ScrollBarV THEN
  217.         SBVertikal.ShowNewPos(CurY, Buf^.Lines);
  218.       IF ScrollBarH THEN
  219.         SBHoriz.ShowNewPos(CurX, Buf^.Columns)
  220.     END;
  221.   END;
  222.  
  223.   PROCEDURE DataWinObj.ScrollBuf (x, y : INTEGER);
  224.   (* ---------------------------------------------------- *)
  225.   (* Scrollt den Pufferinhalt in dem Fenster nach         *)
  226.   (* unten/oben(y) und rechts/links(x). ACHTUNG: x und y  *)
  227.   (* sind RELATIV zu px1/px2 und py1/py2 !                *)
  228.   (* ---------------------------------------------------- *)
  229.   BEGIN
  230.     IF Access THEN BEGIN
  231.       IF (px1+x < 1)            THEN x := -Pred(px1);
  232.       IF (px2+x > Buf^.Columns) THEN x := Buf^.Columns-px2;
  233.       IF (py1+y < 1)            THEN y := -Pred (py1);
  234.       IF (py2+y > Buf^.Lines)   THEN y := Buf^.Lines - py2;
  235.       IF (x <> 0) OR (y <> 0) THEN BEGIN
  236.         Inc(px1, x);  Inc(px2, x);
  237.         Inc(py1, y);  Inc(py2, y);
  238.         IF Buf^.AllSaved THEN  Buf^.LoadPart(py1, py2);
  239.         ShowBuf;
  240.       END;
  241.     END;
  242.   END;
  243.  
  244.   PROCEDURE DataWinObj.SaveASCII(Name    : STRING;
  245.                                  VAR Err : INTEGER);
  246.   VAR
  247.     t : Text;  i : INTEGER;  s : STRING;
  248.   BEGIN
  249.     IF Access THEN BEGIN
  250.       Assign(t, Name);
  251.     {$I-}
  252.       Rewrite(t);
  253.     {$I+}
  254.       Err := IOResult;
  255.       IF Err = 0 THEN BEGIN
  256.         i   := 1;
  257.         err := 0;
  258.         WHILE (i <= Buf^.Lines) AND (Err = 0) DO BEGIN
  259.           s := ConvertLine(i);
  260.         {$I-}
  261.           WriteLn(t, s);
  262.         {$I+}
  263.           Inc(i);
  264.           Err := IOResult;
  265.           IF (Buf^.BufDosErr <> 0) AND (Err = 0) THEN
  266.           { Fehler in BufferObj aufgetreten? wenn ja
  267.             und kein eigener Fehler, dann übertragen,
  268.             sonst hat eigener Fehler Vorrang.              }
  269.             Err := Buf^.BufDosErr
  270.         END;
  271.       {$I-}
  272.         System.Close(t);
  273.       {$I+}
  274.         Err := IOResult;
  275.         { MUSS ABGEFRAGT WERDEN, sonst kommt es bei
  276.           (falls I/O-Checking On ist) der nächsten
  277.           I/O-Funktion zu einem Run-Time-Error 101,
  278.           auch bei Readln oder Writeln !                   }
  279.       END;
  280.     END;
  281.   END;
  282.  
  283.   PROCEDURE DataWinObj.LoadASCII(Name    : STRING;
  284.                                  VAR Err : INTEGER);
  285.   CONST
  286.     TempBufData : BufferObj = ();
  287.     TempOwn     : DataWinObj= ();
  288.   VAR
  289.     t : Text;  i : INTEGER;  s : STRING;
  290.   BEGIN
  291.     IF Access THEN BEGIN
  292.       Assign(t, Name);
  293.     {$I-}
  294.       Reset(t);
  295.     {$I+}
  296.       Err := IOResult;
  297.       IF Err=0 THEN BEGIN
  298.         SetCursor(1, 1);
  299.         DelLines(Succ(GetWinYLength),
  300.                 (Buf^.Lines - GetWinYLength));
  301.         WITH Buf^ DO        { Zeilen im Fenster neu machen }
  302.           FOR i := 1 TO GetWinYLength DO
  303.             GetNewLine(Attr, TextBuf^[i]^);
  304.         TempBufData := Buf^;
  305.         TempOwn     := Self;
  306.         WITH Buf^ DO BEGIN
  307.           KillWrite    := FALSE;
  308.           KillLineRest := FALSE;
  309.           LineFeed     := FALSE;
  310.           MoveBufCur   := FALSE
  311.         END;
  312.         OnlyBuf := TRUE;
  313.         MoveCur := FALSE;
  314.         i       := 1;
  315.         Err     := 0;
  316.         WHILE (i <= MaxLines) AND (Err = 0) AND
  317.               NOT EoF(t) DO BEGIN
  318.         {$I-}
  319.           ReadLn(t, s);
  320.         {$I+}
  321.           WriteStrXY(1, i, s);
  322.           Inc(i);
  323.           Err := IOResult;
  324.           IF (Buf^.BufDosErr <> 0) AND (Err = 0) THEN
  325.             Err := Buf^.BufDosErr;
  326.         END;
  327.         Buf^.SetMaxLines (1);
  328.           { manipulierte Daten wieder herstellen. Dabei
  329.             muß berücksichtigt werden, daß
  330.             Buf^ := TempBufData;
  331.             NICHT funktioniert, da Variablen von "Buf"
  332.             ihre Werte bei dem Ladevorgang verändert haben
  333.             können. Deshalb werden nur die vier veränderten
  334.             Variablen einzeln wieder gesetzt.              }
  335.         WITH Buf^ DO BEGIN
  336.           KillWrite    := TempBufData.KillWrite;
  337.           KillLineRest := TempBufData.KillLineRest;
  338.           LineFeed     := TempBufData.LineFeed;
  339.           MoveBufCur   := TempBufData.MoveBufCur
  340.         END;
  341.         Self := TempOwn;
  342.         ShowBuf;
  343.         SetCursor(1, 1);
  344.       {$I-}
  345.         System.Close(t);
  346.       {$I+}
  347.         Err := IOResult;
  348.       END;
  349.     END;
  350.   END;
  351.  
  352.   PROCEDURE DataWinObj.ShowBufPart(y1, y2 : INTEGER);
  353.   (*----------------------------------------------------- *)
  354.   (* Zeigt den Pufferbereich px1-px2, y1-y2 im Fenster an *)
  355.   (* Bedingung: y1 und y2 in py1-py2 !                    *)
  356.   (*----------------------------------------------------- *)
  357.   VAR
  358.     i : INTEGER;
  359.   BEGIN
  360.     IF Access AND Win^.Visible THEN BEGIN
  361.       IF InWindow(px1, y1) AND InWindow(px1, y2) AND
  362.          (y1 <= y2) THEN
  363.         FOR i := 1 TO Succ(y2-y1) DO
  364.           Move(Buf^.TextBuf^[Pred(y1+i)]^[px1],
  365.                Screen^[Win^.y1+(y1-py1)+i+Ts,
  366.                        Succ (Win^.x1+Ls)],
  367.                GetWinXLength*2);
  368.     END;
  369.   END;
  370.  
  371.   PROCEDURE DataWinObj.ShowBuf;
  372.   BEGIN
  373.     ShowBufPart(py1, py2);
  374.   END;
  375.  
  376.   FUNCTION DataWinObj.GetWinXLength : BYTE;
  377.   BEGIN
  378.     IF Access THEN WITH Win^ DO
  379.       GetWinXLength := Pred(x2-x1-Ls-Rs);
  380.   END;
  381.  
  382.   FUNCTION DataWinObj.GetWinYLength : BYTE;
  383.   BEGIN
  384.     IF Access THEN WITH Win^ DO
  385.       GetWinYLength := Pred(y2-y1-Ts-Bs);
  386.   END;
  387.  
  388.   FUNCTION DataWinObj.GetCols : INTEGER;
  389.   BEGIN
  390.     IF Access THEN
  391.       GetCols := Buf^.Columns
  392.     ELSE
  393.       GetCols := 0
  394.   END;
  395.  
  396.   FUNCTION DataWinObj.GetRows : INTEGER;
  397.   BEGIN
  398.     IF Access THEN
  399.       GetRows := Buf^.Lines
  400.     ELSE
  401.       GetRows := 0
  402.   END;
  403.  
  404.   FUNCTION DataWinObj.InWindow(x, y: INTEGER) : BOOLEAN;
  405.   BEGIN
  406.     InWindow := ((x >= px1) AND (x <= px2) AND
  407.                  (y >= py1) AND (y <= py2));
  408.   END;
  409.  
  410.   DESTRUCTOR DataWinObj.Done;
  411.   (* ---------------------------------------------------- *)
  412.   (* Gibt den belegten Speicher wieder frei, indem die    *)
  413.   (* Destruktoren von "Buf" und "Win" aufgerufen werden.  *)
  414.   (* anderer Speicher wurde von "DataWinObj" nicht belegt *)
  415.   (* ---------------------------------------------------- *)
  416.   BEGIN
  417.     IF Buf <> NIL THEN Dispose(Buf, Done);
  418.     IF Win <> NIL THEN Dispose(Win, Done)
  419.   END;
  420.  
  421.   PROCEDURE DataWinObj.WriteStrXY(x, y : INTEGER;
  422.                                   Str  : STRING);
  423.   BEGIN
  424.     IF Access AND (Win^.Visible OR OnlyBuf) THEN BEGIN
  425.       Buf^.WriteStrXY(x, y, Str);
  426.       IF (y >= py1) AND (y <= py2) AND NOT OnlyBuf THEN
  427.         IF (Py2-Py1 = 0) THEN
  428.           ShowBufPart(y, y)
  429.         ELSE
  430.           ShowBufPart(y, Succ(y));
  431.         { Cursor setzen. Wenn x,y ausserhalb des Fensters,
  432.           dann übernimmt es SetCursor, zu scrollen.        }
  433.       SetCursor (Buf^.BufCurX, Buf^.BufCurY)
  434.     END;
  435.   END;
  436.  
  437.   PROCEDURE DataWinObj.WriteStr(Str : STRING);
  438.   BEGIN
  439.     WriteStrXY(CurX, CurY, Str);
  440.   END;
  441.  
  442.   PROCEDURE DataWinObj.SetCursor(x, y : INTEGER);
  443.   (* ---------------------------------------------------- *)
  444.   (* Setzt den Cursor an Pufferkoordinaten (x,y). Sind    *)
  445.   (* sie ausserhalb des Fensters, so wird gescrollt,      *)
  446.   (* sofern OnlyBuf=FALSE und MoveCur=TRUE sind.          *)
  447.   (*----------------------------------------------------- *)
  448.   BEGIN
  449.     IF Access AND Win^.Visible THEN BEGIN
  450.       IF x < 1       THEN x := 1;
  451.       IF x > GetCols THEN x := GetCols;
  452.       IF y < 1       THEN y := 1;
  453.       IF y > GetRows THEN y := GetRows;
  454.       IF NOT OnlyBuf AND MoveCur THEN BEGIN
  455.         IF NOT InWindow(x, y) THEN
  456.           IF InWindow(x, py1) THEN BEGIN
  457.             IF CurY-y < 0 THEN
  458.               ScrollBuf(0, py2-CurY+y-py2)
  459.             ELSE
  460.               ScrollBuf(0, py1-CurY+y-py1)
  461.           END ELSE IF CurX-x < 0 THEN
  462.             ScrollBuf(px2-CurX+x-px2, 0)
  463.           ELSE
  464.             ScrollBuf(px1-CurX+x-px1, 0);
  465.         GotoXY(Succ(BYTE(Win^.x1+x - (px1-Ls))),
  466.                Succ(BYTE(Win^.y1+y - (py1-Ts))));
  467.       END;
  468.       IF MoveCur THEN BEGIN
  469.         Buf^.BufCurX := x;   Buf^.BufCurY := y;
  470.         CurX := x;           CurY := y
  471.       END;
  472.       IF MoveCur AND NOT OnlyBuf THEN ShowBars;
  473.     END;
  474.   END;
  475.  
  476.   PROCEDURE DataWinObj.InsLines(y, No : INTEGER);
  477.   BEGIN
  478.     IF Access AND (Win^.Visible OR OnlyBuf) THEN BEGIN
  479.       Buf^.InsLines(y, No);
  480.       IF (y >= py1) AND (y <= py2) THEN ShowBufPart(y, py2);
  481.     END;
  482.   END;
  483.  
  484.   PROCEDURE DataWinObj.DelLines(y, No : INTEGER);
  485.   BEGIN
  486.     IF Access AND (Win^.Visible OR OnlyBuf) THEN BEGIN
  487.       Buf^.DelLines(y, No);
  488.       IF (y >= py1) AND (y <= py2) THEN ShowBufPart(y, py2);
  489.     END;
  490.   END;
  491.  
  492.   PROCEDURE DataWinObj.SetWriteColors(Col, Back : BYTE);
  493.   BEGIN
  494.     IF Access THEN Buf^.SetWriteColor(Col, Back);
  495.   END;
  496.  
  497.   PROCEDURE DataWinObj.ChangeColor(x1, y1, x2, y2 : INTEGER;
  498.                                    Col, Back      : BYTE);
  499.   BEGIN
  500.     IF Access AND (Win^.Visible OR OnlyBuf) THEN BEGIN
  501.       IF x1 < 1       THEN x1 := 1;
  502.       IF y1 < 1       THEN y1 := 1;
  503.       IF x2 > GetCols THEN x2 := GetCols;
  504.       IF y2 > GetRows THEN y2 := GetRows;
  505.       Buf^.ChangeColor(x1, y1, x2, y2, Col, Back);
  506.       IF InWindow(px1, y1) THEN ShowBufPart(py1, y1);
  507.       IF InWindow(px1, y2) THEN ShowBufPart(y2, py2);
  508.     END;
  509.   END;
  510.  
  511.   FUNCTION DataWinObj.ConvertLine (y: INTEGER) : STRING;
  512.   (* ---------------------------------------------------- *)
  513.   (*  Wandelt Zeile y aus dem Puffer in String um.        *)
  514.   (* ---------------------------------------------------- *)
  515.   BEGIN
  516.     IF Access THEN ConvertLine := Buf^.Convert2Str(y)
  517.               ELSE ConvertLine := '';
  518.   END;
  519.  
  520.   FUNCTION DataWinObj.GetLineLength(y : INTEGER) : INTEGER;
  521.   BEGIN
  522.     IF Access THEN GetLineLength := Buf^.GetLineLength(y)
  523.               ELSE GetLineLength := -1;
  524.   END;
  525.  
  526.   PROCEDURE DataWinObj.Open;
  527.   VAR
  528.     x, y : INTEGER;
  529.   BEGIN
  530.     IF Access AND NOT Win^.Visible THEN BEGIN
  531.       Win^.Open;
  532.       IF NOT Win^.Visible AND NOT OnlyBuf THEN
  533.         Access := FALSE
  534.       ELSE IF Win^.Visible THEN BEGIN
  535.         Access := TRUE;
  536.         WriteComment;
  537.         ShowBuf;
  538.         SetCursor(CurX, CurY);
  539.       END;
  540.     END;
  541.   END;
  542.  
  543.   PROCEDURE DataWinObj.MoveWin(x, y : INTEGER);
  544.   (* ---------------------------------------------------- *)
  545.   (*  Bewegt das Fenster RELATIV um x/y.                  *)
  546.   (* ---------------------------------------------------- *)
  547.   BEGIN
  548.     IF Access AND Win^.Visible THEN BEGIN
  549.       Win^.MoveWinRel(x, y);
  550.       WriteComment;
  551.       ShowBuf;
  552.       SetCursor(CurX, CurY);
  553.     END;
  554.   END;
  555.  
  556.   PROCEDURE DataWinObj.ZoomWin(x, y : INTEGER);
  557.   (* ---------------------------------------------------- *)
  558.   (*  Zoomt das FENSTER RELATIV um x/y.                   *)
  559.   (* ---------------------------------------------------- *)
  560.   BEGIN
  561.     IF Access AND Win^.Visible THEN
  562.       WITH Win^ DO
  563.         IF (x2+x <= Buf^.Columns) AND        { WICHTIG !!! }
  564.            (y2+y <= Buf^.Lines) THEN BEGIN
  565.           ZoomWinRel(x, y);
  566.           WriteComment;
  567.           px2 := px2 + x;
  568.           py2 := py2 + y;
  569.           WITH Buf^ DO BEGIN
  570.             IF px2 > Columns THEN BEGIN
  571.               px2 := Columns;
  572.               px1 := px2 - GetWinXLength;
  573.             END;
  574.             IF py2 > Lines THEN BEGIN
  575.               py2 := Lines;
  576.               py1 := py2 - GetWinYLength;
  577.             END;
  578.           END;
  579.           IF CurX > Px2 THEN CurX := Px2;
  580.           IF CurY > Py2 THEN CurY := py2;
  581.           ShowBuf;
  582.           SetCursor(CurX, CurY);
  583.         END;
  584.   END;
  585.  
  586.   PROCEDURE DataWinObj.ChangeFrame(NF : BYTE);
  587.   BEGIN
  588.     IF Access AND Win^.Visible THEN Win^.ChangeFrame(nf);
  589.   END;
  590.  
  591.   PROCEDURE DataWinObj.Show;
  592.   BEGIN
  593.     Open;
  594.   END;
  595.  
  596.   PROCEDURE DataWinObj.Hide;
  597.   BEGIN
  598.     Close;
  599.   END;
  600.  
  601.   PROCEDURE DataWinObj.ReOpen(WinData : StandardWindow);
  602.   (* ---------------------------------------------------- *)
  603.   (*  Öffnet das Fenster mit neuen Daten.                 *)
  604.   (* ---------------------------------------------------- *)
  605.   BEGIN
  606.     IF Access AND Win^.Visible THEN BEGIN
  607.       Close;
  608.       Win^         := WinData;
  609.       Win^.Visible := FALSE;
  610.       px2          := Pred(px1 + GetWinXLength);
  611.       py2          := Pred(py1 + GetWinYLength);
  612.       IF CurX > Px2 THEN CurX := Px2;
  613.       IF CurY > Py2 THEN CurY := py2;
  614.       Open;
  615.     END;
  616.   END;
  617.  
  618.   PROCEDURE DataWinObj.Close;
  619.   BEGIN
  620.     IF Access AND Win^.Visible THEN Win^.Close;
  621.   END;
  622.  
  623. END.
  624. (* ------------------------------------------------------ *)
  625. (*                Ende von DATAWIN.PAS                    *)
  626.  
  627.