home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 22 / windows / datawin.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-01-04  |  25.1 KB  |  794 lines
  1. (* ----------------------------------------------------- *)
  2. (*                    DATAWIN.PAS                        *)
  3. (*                                                       *)
  4. (* ■ DataWindow: Verbindet Fenster mit Puffer; zum kon-  *)
  5. (*   fortablen Arbeiten stehen Scrollbalken und Spalten- *)
  6. (*   und Zeilenanzeige zur Verfügung. So viele Methoden, *)
  7. (*   da viele nach "Buffer" weitergeleitet werden; für   *)
  8. (*   die, die hier keine Weiterleitung haben, ist        *)
  9. (*   GetBufPtr gedacht: Es liefert den Zeiger auf das Buf*)
  10. (*   ferobjekt, so das mit einem Aufruf wie              *)
  11. (*     DataWindow^.GetBufPtr^.SetSaveExtern (FALSE);     *)
  12. (*   gearbeitet werden kann.                             *)
  13. (*                                                       *)
  14. (*         (c) 1991 by R.Reichert & toolbox              *)
  15. (* ----------------------------------------------------- *)
  16. UNIT DataWin;
  17.  
  18. INTERFACE
  19.  
  20. USES Dos,     Stuff,    VSObj,   WinVSM,
  21.      MouKey,  UBuffer,  DiskBuf,
  22.      SB,      FrameWin, ActStWi;
  23.  
  24. CONST
  25.   On            = TRUE;
  26.   Off           = FALSE;               { Fehlermeldungen: }
  27.   DWFileDoesntExist = 30; { File existiert nicht (Load)   }
  28.   DWCouldntLoad     = 31; { Fehler beim Laden aufgetreten }
  29.   DWCantCreateFile  = 32; { F kann nicht angelegt werden  }
  30.   DWCouldntSave     = 33; { Fehler beim Speichern         }
  31.   DWCantSaveBuf     = 34; { Fehler in SaveBuffer          }
  32.  
  33. TYPE
  34.   DataWindowPtr = ^DataWindow;
  35.   DataWindow    =  OBJECT (ActiveStandWin)
  36.  
  37.     Buf          : BufferPtr;             { Buffer-Objekt }
  38.     SBVertic,                              { ScrollBalken }
  39.     SBHoriz      : ScrollBarPtr;
  40.     BufX1, BufY1,               { Koordinaten des sicht-  }
  41.     BufX2, BufY2 : WORD;        { baren Bufferauschnittes }
  42.     LS, RS,                     { Ränder im Fenster       }
  43.     TS, BS,
  44.     OldCurX,                    { alte Cursorposition     }
  45.     OldCurY      : BYTE;
  46.     SBH, SBV,                   { Scrollbalken gewünscht ?}
  47.     CurPosShow,                 { Zeilen/Spaltenanzeige ? }
  48.     Loading,                    { beim Laden ?            }
  49.     MoveCur,                    { Cursor analog bewegen ? }
  50.     CurVisible   : BOOLEAN;     { Cursor sichtbar ?       }
  51.     ErrorCode    : INTEGER; { Fehler beim Laden/Speichern }
  52.  
  53.     {---- neu implementierte Methoden von Vorgängern: ----}
  54.     CONSTRUCTOR Init (MaxColumns,MaxLines,FreeHeap: WORD;
  55.                       NewVSM : WExtVSMPtr);
  56.     CONSTRUCTOR Copy (Win : DataWindow);
  57.     PROCEDURE Open;                                VIRTUAL;
  58.     PROCEDURE SetMinLength (MXL, MYL : BYTE);      VIRTUAL;
  59.     PROCEDURE SetTitles
  60.       (TopLine, BottomLine : STRING);              VIRTUAL;
  61.     PROCEDURE Close;                               VIRTUAL;
  62.  
  63.     {--------------- neue, eigene Methoden: --------------}
  64.     PROCEDURE DoLineFeed;                          VIRTUAL;
  65.     PROCEDURE GotoXY (x, y : WORD);                VIRTUAL;
  66.     PROCEDURE ScrollBuf (x, y : INTEGER);          VIRTUAL;
  67.     PROCEDURE SetMoveCur (MC : BOOLEAN);           VIRTUAL;
  68.     PROCEDURE SetSBVertic (SB : BOOLEAN);          VIRTUAL;
  69.     PROCEDURE SetSBHoriz (SB : BOOLEAN);           VIRTUAL;
  70.     PROCEDURE SetShowCurPos (CP : BOOLEAN);        VIRTUAL;
  71.     PROCEDURE SetSpaces (NLS,NRS,NTS,NBS:BYTE);    VIRTUAL;
  72.     {----------- für interne Zwecke gedacht: -------------}
  73.     PROCEDURE SaveBuffer;                          VIRTUAL;
  74.     PROCEDURE ShowBars;                            VIRTUAL;
  75.     PROCEDURE ShowBuffer;                          VIRTUAL;
  76.     PROCEDURE ShowBufPart (sy1, sy2 : WORD);       VIRTUAL;
  77.     FUNCTION GetLoadY1 : WORD; { INTERN }          VIRTUAL;
  78.     FUNCTION GetLoadY2 : WORD; { INTERN }          VIRTUAL;
  79.     FUNCTION InWindow (x, y : WORD) : BOOLEAN;     VIRTUAL;
  80.     FUNCTION WinBufXLength : WORD;                 VIRTUAL;
  81.     FUNCTION WinBufYLength : WORD;                 VIRTUAL;
  82.     {------- zum Abfragen der Variablen von aussen: ------}
  83.     FUNCTION GetBufX1 : WORD;                      VIRTUAL;
  84.     FUNCTION GetBufX2 : WORD;                      VIRTUAL;
  85.     FUNCTION GetBufY1 : WORD;                      VIRTUAL;
  86.     FUNCTION GetBufY2 : WORD;                      VIRTUAL;
  87.     FUNCTION HorizScrollBar : BOOLEAN;             VIRTUAL;
  88.     FUNCTION VerticScrollBar: BOOLEAN;             VIRTUAL;
  89.     FUNCTION ShowCurPos     : BOOLEAN;             VIRTUAL;
  90.     FUNCTION GetLeftSpace  : BYTE;                 VIRTUAL;
  91.     FUNCTION GetRightSpace : BYTE;                 VIRTUAL;
  92.     FUNCTION GetTopSpace   : BYTE;                 VIRTUAL;
  93.     FUNCTION GetBottomSpace: BYTE;                 VIRTUAL;
  94.     FUNCTION CursorVisible : BOOLEAN;              VIRTUAL;
  95.     FUNCTION GetErrorCode  : INTEGER;              VIRTUAL;
  96.     FUNCTION GetMoveCur    : BOOLEAN;              VIRTUAL;
  97.  
  98.     {--------- Methoden für die Bufferbearbeitung: -------}
  99.     PROCEDURE LoadASCII (Name : STRING;
  100.                          CutTooLong : BOOLEAN);    VIRTUAL;
  101.     PROCEDURE SaveASCII (Name : STRING);           VIRTUAL;
  102.     PROCEDURE WriteStrXY (x, y : WORD;
  103.                           str : STRING);           VIRTUAL;
  104.     PROCEDURE WriteStr (Str : STRING);             VIRTUAL;
  105.     PROCEDURE InsLines (y, No : WORD);             VIRTUAL;
  106.     PROCEDURE CopyLine (Source, Dest : WORD);      VIRTUAL;
  107.     PROCEDURE DelLines (y, No : WORD);             VIRTUAL;
  108.     PROCEDURE ChangeColor
  109.       (cx1, cy1, cx2, cy2 : WORD;
  110.        NewCol, NewBack : BYTE);                    VIRTUAL;
  111.     PROCEDURE SetBufAttr (Attr : BYTE);            VIRTUAL;
  112.     PROCEDURE SetMaxLines (NewML : INTEGER);       VIRTUAL;
  113.     PROCEDURE SetColumns (Cols : WORD);            VIRTUAL;
  114.  
  115.     FUNCTION ConvertLine (y : WORD) : STRING;      VIRTUAL;
  116.     FUNCTION LineLength (y : WORD) : WORD;         VIRTUAL;
  117.     FUNCTION GetCurX : WORD;                       VIRTUAL;
  118.     FUNCTION GetCurY : WORD;                       VIRTUAL;
  119.     FUNCTION GetLines : WORD;                      VIRTUAL;
  120.     FUNCTION GetColumns : WORD;                    VIRTUAL;
  121.     FUNCTION GetMaxLines : WORD;                   VIRTUAL;
  122.     FUNCTION GetMaxColumns : WORD;                 VIRTUAL;
  123.     FUNCTION GetBufAttr : BYTE;                    VIRTUAL;
  124.     FUNCTION GetBufPtr : DiskBufferPtr;            VIRTUAL;
  125.     DESTRUCTOR Done;                               VIRTUAL;
  126.   END;
  127.  
  128. IMPLEMENTATION
  129.  
  130. (* ----------------------------------------------------- *)
  131. (* Initialisiert Objekt, dafür braucht es Speicher für   *)
  132. (* ScrollBalken und BufferObj. Im Fehlerfalle wird Fail  *)
  133. (* aufgerufen. MaxColumns und MaxLines sind für das Buf- *)
  134. (* ferObjekt verbindlich, dh diese Werte gelten bei der  *)
  135. (* weiteren Arbeit mit DataWindow (MaxLines im Zweifels- *)
  136. (* fall lieber sehr gross, MaxColumns nicht allzu gross  *)
  137. (* wählen). FreeHeap gibt den Speicher an, der freige-   *)
  138. (* lassen werden soll.                                   *)
  139. (* ----------------------------------------------------- *)
  140. CONSTRUCTOR DataWindow.Init
  141.               (MaxColumns, MaxLines, FreeHeap : WORD;
  142.                NewVSM : WExtVSMPtr);
  143. BEGIN
  144.   IF ActiveStandWin.Init (NewVSM) THEN BEGIN
  145.     CurVisible := TRUE;  SBH := TRUE;  SBV := TRUE;
  146.     CurPosShow := TRUE;
  147.     LS := 0;  RS := 0;  TS := 0;  BS := 0;
  148.     IF MaxColumns<VSM^.GetXLength THEN
  149.       MaxColumns := VSM^.GetXLength-2;
  150.     IF MaxLines<VSM^.GetYLength THEN
  151.       MaxLines := VSM^.GetYLength;
  152.     Buf := New (DiskBufferPtr,
  153.                 Init (MaxColumns, MaxLines,
  154.                       VSM^.GetYLength, FreeHeap));
  155.     SBVertic := New (VertScrollBarPtr, Init (VSM));
  156.     SBHoriz  := New (HorizScrollBarPtr, Init (VSM));
  157.     IF (SBVertic<>NIL) AND
  158.        (SBHoriz<>NIL) AND
  159.        (Buf<>NIL) THEN BEGIN
  160.       SetMoveCur (TRUE);
  161.       SetSaveWinContent (FALSE);
  162.       BufX1 := 1;  BufX2 := WinBufXLength;
  163.       BufY1 := 1;  BufY2 := WinBufYLength;
  164.       ErrorCode := 0;  Loading := FALSE;
  165.     END ELSE
  166.       Fail;
  167.   END ELSE
  168.     Fail;
  169. END;
  170.  
  171. CONSTRUCTOR DataWindow.Copy (Win : DataWindow);
  172. BEGIN
  173.   IF (Win.VSM<>NIL) AND
  174.      (Win.SBVertic<>NIL) AND
  175.      (Win.SBHoriz<>NIL) AND
  176.      (Win.Buf<>NIL) THEN
  177.     Self := Win
  178.   ELSE
  179.     Fail
  180. END;
  181.  
  182. (* ----------------------------------------------------- *)
  183. (* Öffnet das Fenster, zeigt den Buffer sowie die Posi-  *)
  184. (* tion des Buffercursors auf dem Scrollbalken an, falls *)
  185. (* Active TRUE ist.                                      *)
  186. (* ----------------------------------------------------- *)
  187. PROCEDURE DataWindow.Open;
  188.   VAR MouVis : BOOLEAN;
  189. BEGIN
  190.   IF NOT Opened THEN BEGIN
  191.     ActiveStandWin.Open;
  192.     IF Opened THEN BEGIN
  193.       BufX2 := Pred (BufX1 + WinBufXLength);
  194.       BufY2 := Pred (BufY1 + WinBufYLength);
  195.       IF BufX2>Buf^.GetColumns THEN BEGIN
  196.         BufX2 := Buf^.GetColumns;
  197.         BufX1 := Succ (BufX2 - WinBufXLength);
  198.       END;
  199.       IF BufY2>Buf^.GetLines THEN BEGIN
  200.         BufY2 := Buf^.GetLines;
  201.         BufY1 := Succ (BufY2 - WinBufYLength);
  202.       END;
  203.       WITH VSM^ DO BEGIN  { Ränder mit Leerzeichen füllen:}
  204.         MouVis := Mouse^.GetVisible;
  205.         Mouse^.Hide;
  206.         IF LS>0 THEN FillPart (Succ (x1), Succ (y1),
  207.                                x1+LS, Pred (y2), 7, ' ');
  208.         IF RS>0 THEN FillPart (x2-RS, Succ (y1),
  209.                                Pred (x2), Pred (y2),
  210.                                7, ' ');
  211.         IF TS>0 THEN FillPart (Succ (x1), Succ (y1),
  212.                                Pred (x2), y1+TS, 7, ' ');
  213.         IF BS>0 THEN FillPart (Succ (x1), Pred (y2),
  214.                                Pred (x2), y2-BS,
  215.                                7, ' ');
  216.         IF MouVis THEN
  217.           Mouse^.Show;
  218.       END;
  219.       OldCurX := VSM^.WhereX;
  220.       OldCurY := VSM^.WhereY;
  221.       DiskBufferPtr (Buf)^.LoadPart (GetLoadY1, GetLoadY2);
  222.       ShowBuffer;
  223.       IF Active AND NOT Changing THEN BEGIN
  224.         SBVertic^.SetXY (x2, Succ (y1), x2, Pred (y2));
  225.         SBVertic^.SetMaxPos (Buf^.GetLines, Buf^.GetY);
  226.         IF SBV THEN SBVertic^.Show;
  227.         IF CurPosShow THEN
  228.           SBHoriz^.SetXY (x1+15, y2, x2-2, y2)
  229.         ELSE
  230.           SBHoriz^.SetXY (x1+2, y2, x2-2, y2);
  231.         SBHoriz^.SetMaxPos (Buf^.GetColumns, Buf^.GetX);
  232.         IF SBH THEN SBHoriz^.Show;
  233.         ShowBars;
  234.         IF InWindow (Buf^.GetX, Buf^.GetY) THEN BEGIN
  235.           GotoXY (Buf^.GetX, Buf^.GetY);
  236.         END ELSE
  237.           HideCursor;
  238.       END;
  239.     END;
  240.   END;
  241. END;
  242.  
  243. PROCEDURE DataWindow.SetMinLength (MXL, MYL : BYTE);
  244. BEGIN
  245.   IF MXL<25 THEN MXL := 25;      { wegen Scrollbalken und }
  246.   IF MYL<4 THEN  MYL := 4;               { Curpos-Anzeige }
  247.   ActiveStandWin.SetMinLength (MXL, MYL);
  248. END;
  249.  
  250. PROCEDURE DataWindow.SetTitles
  251.             (TopLine, BottomLine : STRING);
  252. BEGIN
  253.   ActiveStandWin.SetTitles (TopLine, '');
  254.     { Fusszeile darf wegen des Scrollbalken keine
  255.       mehr existieren }
  256. END;
  257.  
  258. PROCEDURE DataWindow.Close;
  259. BEGIN
  260.   ActiveStandWin.Close;
  261.   IF ReturnCode=0 THEN BEGIN
  262.     VSM^.GotoXY (OldCurX, OldCurY);
  263.     IF NOT Changing THEN
  264.       ShowCursor;
  265.   END;
  266. END;
  267.  
  268. (* ----------------------------------------------------- *)
  269. (* Macht einen Zeilenvorschub, entspricht "Writeln;" von *)
  270. (* Turbo Pascal oder einem "WriteStr ('');" von DataWin- *)
  271. (* dow.                                                  *)
  272. (* ----------------------------------------------------- *)
  273. PROCEDURE DataWindow.DoLineFeed;
  274.   VAR LF : BOOLEAN;
  275. BEGIN
  276.   LF := Buf^.GetLineFeed;
  277.   Buf^.SetLineFeed (FALSE);
  278.   WriteStr ('');
  279.   Buf^.SetLineFeed (LF);
  280. END;
  281.  
  282. (* ----------------------------------------------------- *)
  283. (* Setzt den Buffercursor an x/y. Wenn nötig, wird ge-   *)
  284. (* scrollt (siehe unten).                                *)
  285. (* ----------------------------------------------------- *)
  286. PROCEDURE DataWindow.GotoXY (x, y : WORD);
  287.   VAR ScrX, ScrY : INTEGER;
  288. BEGIN
  289.   IF Opened AND Active THEN BEGIN
  290.     {--------------- eventuell x/y korrigieren -----------}
  291.     IF (x > Buf^.GetColumns) AND
  292.        (y<Buf^.GetLines) THEN BEGIN
  293.       x := 1;  Inc (y);
  294.     END;
  295.     IF (x<1) AND (y>1) THEN BEGIN
  296.       x := Buf^.GetColumns;  Dec (y);
  297.     END;
  298.     {------------------ ausserhalb Fensters ? ------------}
  299.     IF NOT InWindow (x, y) THEN BEGIN
  300.       ScrX := 0;   ScrY := 0;
  301.       IF x > BufX2 THEN ScrX := x - BufX2;
  302.       IF x < BufX1 THEN ScrX := INTEGER (x - BufX1);
  303.       IF y > BufY2 THEN ScrY := y - BufY2;
  304.       IF y < BufY1 THEN ScrY := INTEGER (y - BufY1);
  305.       IF GetMoveCur THEN BEGIN       { analoge Bewegung ? }
  306.         Buf^.SetBufCursor (x, y);
  307.         ScrollBuf (ScrX, ScrY);            { ja, scrollen }
  308.           { ScrollBuf ruft seinerseits GotoXY auf, aber
  309.             dieser Teil wird nicht mehr durchlaufen,
  310.             sondern der untere, da dann der Cursor inner-
  311.             halb des Ausschnittes ist. Daher wird hier der
  312.             Cursor nicht gesetzt.                         }
  313.       END ELSE
  314.         HideCursor;           { nein, Cursor "verstecken" }
  315.     END ELSE BEGIN
  316.     {---------------- Cursor innerhalb Fenster -----------}
  317.       ShowCursor;
  318.       Buf^.SetBufCursor (x, y);
  319.       VSM^.GotoXY (Succ ( BYTE(x1+LS+x-BufX1)),
  320.                    Succ ( BYTE(y1+TS+y-BufY1)));
  321.     END;
  322.     ShowBars;
  323.   END;
  324. END;
  325.  
  326. (* ----------------------------------------------------- *)
  327. (* Scrollt den sichtbaren Bufferausschnitt um x/y und    *)
  328. (* setzt den Cursor neu.                                 *)
  329. (* ----------------------------------------------------- *)
  330. PROCEDURE DataWindow.ScrollBuf (x, y : INTEGER);
  331. BEGIN
  332.   IF Opened AND Active THEN BEGIN
  333.     IF BufX1+x < 1 THEN x := -Pred (BufX1);
  334.     IF BufX2+x > Buf^.GetColumns THEN
  335.       x := Buf^.GetColumns-BufX2;
  336.     IF BufY1+y < 1 THEN y := -Pred (BufY1);
  337.     IF BufY2+y > Buf^.GetLines THEN
  338.       y := Buf^.GetLines-BufY2;
  339.     IF (x=0) AND (y=0) THEN
  340.       x := 0;
  341.     IF (x<>0) OR (y<>0) THEN BEGIN
  342.       Inc (BufX1, x);  Inc (BufX2, x);
  343.       Inc (BufY1, y);  Inc (BufY2, y);
  344.       IF DiskBufferPtr (Buf)^.GetAllSaved THEN
  345.         DiskBufferPtr (Buf)^.LoadPart (GetLoadY1,
  346.                                        GetLoadY2);
  347.       ShowBuffer;
  348.       GotoXY (Buf^.GetX, Buf^.GetY);
  349.     END;
  350.   END;
  351. END;
  352.  
  353. PROCEDURE DataWindow.SetMoveCur (MC : BOOLEAN);
  354. BEGIN
  355.   MoveCur := MC;
  356.   Buf^.SetMoveCursor (MoveCur);
  357. END;
  358.  
  359. PROCEDURE DataWindow.SetSBVertic (SB : BOOLEAN);
  360. BEGIN
  361.   IF NOT Opened THEN SBV := SB;
  362. END;
  363.  
  364. PROCEDURE DataWindow.SetSBHoriz (SB : BOOLEAN);
  365. BEGIN
  366.   IF NOT Opened THEN SBH := SB;
  367. END;
  368.  
  369. PROCEDURE DataWindow.SetShowCurPos (CP : BOOLEAN);
  370. BEGIN
  371.   IF NOT Opened THEN CurPosShow := CP;
  372. END;
  373.  
  374. PROCEDURE DataWindow.SetSpaces (NLS,NRS,NTS,NBS:BYTE);
  375. BEGIN
  376.   IF NOT Opened THEN BEGIN
  377.     LS := NLS;  RS := NRS;  TS := NTS;  BS := NBS;
  378.     IF LS>5 THEN LS := 5;
  379.     IF RS>5 THEN RS := 5;
  380.     IF TS>2 THEN TS := 1;
  381.     IF BS>1 THEN BS := 1;
  382.   END;
  383. END;
  384.  
  385. (* ----------------------------------------------------- *)
  386. (* Speichert den gesamten (!) Buffer auf Diskette und    *)
  387. (* löscht ihn aus dem Speicher.                          *)
  388. (* ----------------------------------------------------- *)
  389. PROCEDURE DataWindow.SaveBuffer;
  390. BEGIN
  391.   DiskBufferPtr (Buf)^.CleanMem;
  392.   IF Buf^.GetErrorL1<>0 THEN
  393.     SetReturnCode (DWCantSaveBuf);
  394. END;
  395.  
  396. (* ----------------------------------------------------- *)
  397. (* Gibt die Cursorposition auf dem Scrollbalken sowie im *)
  398. (* unteren Fensterrand aus.                              *)
  399. (* ----------------------------------------------------- *)
  400. PROCEDURE DataWindow.ShowBars;
  401.   VAR s1, s2 : STRING;  MouVis : BOOLEAN;
  402. BEGIN
  403.   IF Opened AND Active THEN BEGIN
  404.     IF NOT Loading THEN BEGIN
  405.       IF ShowCurPos THEN BEGIN
  406.         MouVis := Mouse^.GetVisible;
  407.         Mouse^.Hide;
  408.         VSM^.FillPart (x1+3, y2, x1+13, y2,
  409.                        FrCol, Frames [Frame, 5]);
  410.         System.Str (Buf^.GetX, s1);
  411.         System.Str (Buf^.GetY, s2);
  412.         VSM^.WriteStr (x1+8-Length (s1), y2,
  413.                        FrCol, s1+':'+s2);
  414.         IF MouVis THEN
  415.           Mouse^.Show;
  416.       END;
  417.       IF SBV THEN
  418.         SBVertic^.ChangePos (Buf^.GetLines, BufY1);
  419.       IF SBH THEN
  420.         SBHoriz^.ChangePos (Buf^.GetColumns, BufX1);
  421.     END;
  422.   END;
  423. END;
  424.  
  425. PROCEDURE DataWindow.ShowBuffer;
  426. BEGIN
  427.   ShowBufPart (BufY1, BufY2);    { ganzen Puffer anzeigen }
  428. END;
  429.  
  430. (* ----------------------------------------------------- *)
  431. (* Pufferbereich sy1-sy2 anzeigen. Bedingungen:          *)
  432. (*   sy1>=BufY1, sy2<=BufY2, sy1<=sy2.                   *)
  433. (* ----------------------------------------------------- *)
  434. PROCEDURE DataWindow.ShowBufPart (sy1, sy2 : WORD);
  435.   VAR i : WORD; MouVis : BOOLEAN;
  436. BEGIN
  437.   IF Opened AND Active THEN BEGIN
  438.     MouVis := Mouse^.GetVisible;
  439.     Mouse^.Hide;
  440.     FOR i := sy1 TO sy2 DO
  441.       System.Move (Buf^.GetLinePtr (i)^[BufX1],
  442.                    VSM^.GetPartPtr (Succ (x1+LS),
  443.                                     Succ (y1+TS)+i-BufY1)^,
  444.                    WinBufXLength*2);
  445.     IF MouVis THEN
  446.       Mouse^.Show;
  447.   END;
  448. END;
  449.  
  450. FUNCTION DataWindow.GetLoadY1 : WORD;
  451.   VAR ly1 : WORD;
  452. BEGIN      { für Berechnung, von wo bis wo Puffer geladen }
  453.   Ly1 := BufY1-(VSM^.GetYLength-(BufY2-BufY1)) DIV 2;
  454.   IF Ly1>BufY1 THEN Ly1 := BufY1;
  455.   GetLoadY1 := Ly1;                         { werden soll }
  456. END;
  457.  
  458. FUNCTION DataWindow.GetLoadY2 : WORD;
  459.   VAR Ly2 : WORD;
  460. BEGIN
  461.   Ly2 := BufY2+(VSM^.GetYLength-(BufY2-BufY1)) DIV 2;
  462.   IF Ly2<BufY2 THEN Ly2 := BufY2;
  463.   GetLoadY2 := Ly2;
  464. END;
  465.  
  466. FUNCTION DataWindow.InWindow (x, y : WORD) : BOOLEAN;
  467. BEGIN
  468.   IF (x>=BufX1) AND (x<=BufX2) AND
  469.      (y>=BufY1) AND (y<=BufY2) THEN
  470.     InWindow := TRUE { x und y im Fensterpufferausschnitt }
  471.   ELSE
  472.     InWindow := FALSE;
  473. END;
  474.  
  475. FUNCTION DataWindow.WinBufXLength : WORD;
  476. BEGIN                   { Anzahl Pufferspalten im Fenster }
  477.   WinBufXLength := Pred (x2-x1-RS-LS);
  478. END;
  479.  
  480. FUNCTION DataWindow.WinBufYLength : WORD;
  481. BEGIN                    { Anzahl Pufferzeilen im Fenster }
  482.   WinBufYLength := Pred (y2-y1-TS-BS);
  483. END;
  484.  
  485. FUNCTION DataWindow.GetBufX1 : WORD;
  486. BEGIN
  487.   GetBufX1 := BufX1;
  488. END;
  489.  
  490. FUNCTION DataWindow.GetBufX2 : WORD;
  491. BEGIN
  492.   GetBufX2 := BufX2;
  493. END;
  494.  
  495. FUNCTION DataWindow.GetBufY1 : WORD;
  496. BEGIN
  497.   GetBufY1 := BufY1;
  498. END;
  499.  
  500. FUNCTION DataWindow.GetBufY2 : WORD;
  501. BEGIN
  502.   GetBufY2 := BufY2;
  503. END;
  504.  
  505. FUNCTION DataWindow.HorizScrollBar : BOOLEAN;
  506. BEGIN
  507.   HorizScrollBar := SBH;
  508. END;
  509.  
  510. FUNCTION DataWindow.VerticScrollBar : BOOLEAN;
  511. BEGIN
  512.   VerticScrollBar := SBV;
  513. END;
  514.  
  515. FUNCTION DataWindow.ShowCurPos : BOOLEAN;
  516. BEGIN
  517.   ShowCurPos := CurPosShow;
  518. END;
  519.  
  520. FUNCTION DataWindow.GetLeftSpace : BYTE;
  521. BEGIN
  522.   GetLeftSpace := LS;
  523. END;
  524.  
  525. FUNCTION DataWindow.GetRightSpace : BYTE;
  526. BEGIN
  527.   GetRightSpace := RS;
  528. END;
  529.  
  530. FUNCTION DataWindow.GetTopSpace : BYTE;
  531. BEGIN
  532.   GetTopSpace := TS;
  533. END;
  534.  
  535. FUNCTION DataWindow.GetBottomSpace : BYTE;
  536. BEGIN
  537.   GetBottomSpace := BS;
  538. END;
  539.  
  540. FUNCTION DataWindow.CursorVisible : BOOLEAN;
  541. BEGIN
  542.   CursorVisible := CurVisible;
  543. END;
  544.  
  545. FUNCTION DataWindow.GetErrorCode : INTEGER;
  546. BEGIN
  547.   GetErrorCode := ErrorCode;  ErrorCode := 0;
  548. END;
  549.  
  550. FUNCTION DataWindow.GetMoveCur : BOOLEAN;
  551. BEGIN
  552.   IF Buf^.GetMoveCursor <> MoveCur THEN
  553.     MoveCur := Buf^.GetMoveCursor;
  554.   GetMoveCur := MoveCur;
  555. END;
  556.  
  557. (* ----------------------------------------------------- *)
  558. (* Laden einer ASCII-Datei. Tritt dabei ein Fehler auf,  *)
  559. (* so wird der ReturnCode entsprechend gesetzt. Was für  *)
  560. (* Fehler vorlag, kann mit GetErrorCode abgefragt werden.*)
  561. (* ----------------------------------------------------- *)
  562. PROCEDURE DataWindow.LoadASCII (Name : STRING;
  563.                                 CutTooLong : BOOLEAN);
  564.   CONST
  565.     TempBuf : DiskBuffer = ();
  566.   VAR
  567.     t : TEXT;
  568.     i : WORD;
  569.     s : STRING;
  570. BEGIN
  571. {$I-}
  572.   System.Assign (t, Name);
  573.   System.Reset (t);
  574. {$I+}
  575.   ErrorCode := System.IoResult;
  576.   IF ErrorCode=0 THEN BEGIN
  577.     GotoXY (1, 1);
  578.     DelLines (Succ (VSM^.GetYLength),
  579.               Buf^.GetLines-VSM^.GetYLength);
  580.     FOR i := 1 TO VSM^.GetYLength DO
  581.       Buf^.GetNewLine (Buf^.GetAttr, Buf^.GetLinePtr (i)^);
  582.     TempBuf := DiskBufferPtr (Buf)^;
  583.     i := 1;  ErrorCode := 0;
  584.     Buf^.SetKillWriting (FALSE);
  585.     Buf^.SetKillRest (FALSE);
  586.     Buf^.SetLineFeed (FALSE);
  587.     SetMoveCur (FALSE);
  588.     Loading := TRUE;
  589.     WHILE (i<=Buf^.GetMaxLines) AND
  590.           (ErrorCode=0) AND NOT System.EoF (t) DO BEGIN
  591.     {$I-}
  592.       System.ReadLn (t, s);
  593.     {$I+}
  594.       ErrorCode := System.IoResult;
  595.       IF (Length (s)>Buf^.GetColumns) AND (CutTooLong) THEN
  596.         s[0] := Chr (Buf^.GetColumns);
  597.       WriteStrXY (1, i, s);
  598.       Inc (i);
  599.       IF (DiskBufferPtr (Buf)^.GetDosErr<>0) AND
  600.          (ErrorCode=0) THEN
  601.         ErrorCode := DiskBufferPtr (Buf)^.GetDosErr;
  602.     END;
  603.     Buf^.SetKillWriting (TempBuf.KillWrite);
  604.     Buf^.SetKillRest (TempBuf.KillLineRest);
  605.     Buf^.SetLineFeed (TempBuf.LineFeed);
  606.     SetMoveCur (TempBuf.MoveBufCur);
  607.     Loading := FALSE;
  608.     ShowBuffer;
  609.   {$I-}
  610.     System.Close (t);
  611.   {$I+}
  612.     ErrorCode := System.IoResult;
  613.     IF (ErrorCode<>0) THEN
  614.       SetReturnCode (DWCouldntLoad);
  615.   END ELSE
  616.     SetReturnCode (DWFileDoesntExist);
  617. END;
  618.  
  619. (* ----------------------------------------------------- *)
  620. (* Speichern des Bufferinhalts in eine ASCII-Datei. Sind *)
  621. (* die Bufferzeilen länger als 255 Zeichen, so gehen die *)
  622. (* nach dem 255. verloren. Falls Fehler, analog zu Load. *)
  623. (* ----------------------------------------------------- *)
  624. PROCEDURE DataWindow.SaveASCII (Name : STRING);
  625.   VAR
  626.     t : TEXT;
  627.     i : WORD;
  628.     s : STRING;
  629. BEGIN
  630. {$I-}
  631.   System.Assign (t, Name);
  632.   System.ReWrite (t);
  633. {$I+}
  634.   ErrorCode := System.IoResult;
  635.   IF ErrorCode=0 THEN BEGIN
  636.     i := 1;
  637.     WHILE (i<=Buf^.GetLines) AND (ErrorCode=0) DO BEGIN
  638.       s := Buf^.Convert2Str (i);
  639.     {$I-}
  640.       System.WriteLn (t, s);
  641.     {$I+}
  642.       ErrorCode := System.IoResult;  Inc (i);
  643.       IF (DiskBufferPtr (Buf)^.GetDosErr<>0) AND
  644.          (ErrorCode=0) THEN
  645.         ErrorCode := DiskBufferPtr (Buf)^.GetDosErr;
  646.     END;
  647.   {$I-}
  648.     System.Close (t);
  649.   {$I+}
  650.     ErrorCode := IoResult;
  651.     IF ErrorCode<>0 THEN
  652.       SetReturnCode (DWCouldntSave);
  653.   END ELSE
  654.     SetReturnCode (DWCantCreateFile);
  655. END;
  656.  
  657. PROCEDURE DataWindow.WriteStrXY (x,y : WORD; str : STRING);
  658. BEGIN
  659.   Buf^.WriteStrXY (x, y, Str);
  660.   IF InWindow (BufX1, y) AND
  661.      InWindow (BufX1, Buf^.GetY) AND
  662.      NOT Loading THEN
  663.     ShowBufPart (y, Buf^.GetY);
  664.   IF NOT Loading THEN
  665.     GotoXY (Buf^.GetX, Buf^.GetY);
  666. END;
  667.  
  668. PROCEDURE DataWindow.WriteStr (Str : STRING);
  669. BEGIN
  670.   WriteStrXY (Buf^.GetX, Buf^.GetY, Str);
  671. END;
  672.  
  673. PROCEDURE DataWindow.InsLines (y, No : WORD);
  674. BEGIN
  675.   Buf^.InsLines (y, No);
  676.   IF InWindow (BufX1, y) THEN
  677.     ShowBufPart (y, BufY2);
  678. END;
  679.  
  680. PROCEDURE DataWindow.CopyLine (Source, Dest : WORD);
  681. BEGIN
  682.   Buf^.CopyLine (Source, Dest);
  683.   IF ((Dest>=BufY1) AND (Dest<=BufY2)) THEN
  684.     ShowBufPart (Dest, Dest);
  685. END;
  686.  
  687. PROCEDURE DataWindow.DelLines (y, No : WORD);
  688. BEGIN
  689.   Buf^.DelLines (y, No);
  690.   IF BufY2>Buf^.GetLines THEN BEGIN
  691.     ScrollBuf (0, Buf^.GetLines-BufY2)
  692.   END ELSE
  693.     IF InWindow (BufX1, y) THEN
  694.       ShowBufPart (y, BufY2);
  695. END;
  696.  
  697. PROCEDURE DataWindow.ChangeColor (cx1, cy1, cx2, cy2: WORD;
  698.                                   NewCol, NewBack : BYTE);
  699. BEGIN
  700.   Buf^.ChangeColor (cx1, cy1, cx2, cy2,
  701.                     NewCol, NewBack);
  702.   IF InWindow (BufX1, cy1) AND
  703.      InWindow (BufX1, cy2) THEN
  704.     ShowBufPart (cy1, cy2)
  705.   ELSE
  706.     IF InWindow (BufX1, cy1) THEN
  707.       ShowBufPart (cy1, BufY2)
  708.     ELSE
  709.       IF InWindow (BufX1, cy2) THEN
  710.         ShowBufPart (BufY1, cy2);
  711. END;
  712.  
  713. PROCEDURE DataWindow.SetBufAttr (Attr : BYTE);
  714. BEGIN
  715.   Buf^.SetAttr (Attr);
  716. END;
  717.  
  718. PROCEDURE DataWindow.SetMaxLines (NewML : INTEGER);
  719. BEGIN
  720.   Buf^.SetMaxLines (NewML);
  721. END;
  722.  
  723. (* ----------------------------------------------------- *)
  724. (* Setzt die aktuelle Zeilenlänge. ACHTUNG: Dabei können *)
  725. (* auch schon vorhandene Zeilen "gekürzt" werden !       *)
  726. (* ----------------------------------------------------- *)
  727. PROCEDURE DataWindow.SetColumns (Cols : WORD);
  728. BEGIN
  729.   Buf^.SetColumns (Cols);
  730. END;
  731.  
  732. FUNCTION DataWindow.ConvertLine (y : WORD) : STRING;
  733. BEGIN
  734.   ConvertLine := Buf^.Convert2Str (y);
  735. END;
  736.  
  737. FUNCTION DataWindow.LineLength (y : WORD) : WORD;
  738. BEGIN
  739.   LineLength := Buf^.GetLineLength (y);
  740. END;
  741.  
  742. FUNCTION DataWindow.GetCurX : WORD;
  743. BEGIN
  744.   GetCurX := Buf^.GetX;
  745. END;
  746.  
  747. FUNCTION DataWindow.GetCurY : WORD;
  748. BEGIN
  749.   GetCurY := Buf^.GetY;
  750. END;
  751.  
  752. FUNCTION DataWindow.GetLines : WORD;
  753. BEGIN
  754.   GetLines := Buf^.GetLines;
  755. END;
  756.  
  757. FUNCTION DataWindow.GetColumns : WORD;
  758. BEGIN
  759.   GetColumns:= Buf^.GetColumns;
  760. END;
  761.  
  762. FUNCTION DataWindow.GetMaxLines : WORD;
  763. BEGIN
  764.   GetMaxLines := Buf^.GetMaxLines;
  765. END;
  766.  
  767. FUNCTION DataWindow.GetMaxColumns : WORD;
  768. BEGIN
  769.   GetMaxColumns := Buf^.GetMaxColumns;
  770. END;
  771.  
  772. FUNCTION DataWindow.GetBufAttr : BYTE;
  773. BEGIN
  774.   GetBufAttr := Buf^.GetAttr;
  775. END;
  776.  
  777. FUNCTION DataWindow.GetBufPtr : DiskBufferPtr;
  778. BEGIN
  779.   GetBufPtr := DiskBufferPtr (Buf);
  780. END;
  781.  
  782. DESTRUCTOR DataWindow.Done;
  783. BEGIN
  784.   ActiveStandWin.Done;
  785.   Dispose (SBHoriz, Done);
  786.   Dispose (SBVertic, Done);
  787.   Dispose (Buf, Done);
  788. END;
  789.  
  790. END.
  791. (* ----------------------------------------------------- *)
  792. (*                  Ende von DATAWIN.PAS                 *)
  793. (* ----------------------------------------------------- *)
  794.