home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 22 / windows / actdwin.pas next >
Encoding:
Pascal/Delphi Source File  |  1991-01-04  |  23.5 KB  |  698 lines
  1. (* ----------------------------------------------------- *)
  2. (*                    ACTDWIN.PAS                        *)
  3. (*                ('ACTiveDataWINdow')                   *)
  4. (*                                                       *)
  5. (* ■ ActiveDataWindow: Reagiert, wie ActiveStandWin, auf *)
  6. (*   Ereignisse; erweitert um die Abfrage der Scroll-    *)
  7. (*   balken und der neu hinzugekommenen Symbole. Denn    *)
  8. (*   ActiveDataWindow unterscheidet nicht nur zwischen   *)
  9. (*   zwei Zuständen (aktiv und passiv), sondern auch     *)
  10. (*   zwischen drei weiteren: Iconized, Normal, Maximized,*)
  11. (*   die Grösse angeben und unterschiedliche Symbole be- *)
  12. (*   sitzen wie zum vergrössern, verkleinern ... - Dafür *)
  13. (*   ist ActiveDataWindow eigensinnig: Bestimmte Werte   *)
  14. (*   wie Zooming und Moving gleich TRUE werden verlangt, *)
  15. (*   etwas anderes nicht zugelassen.                     *)
  16. (*                                                       *)
  17. (*            (c) 1991 by R.Reichert & toolbox           *)
  18. (* ----------------------------------------------------- *)
  19. UNIT ActDWin;
  20.  
  21. INTERFACE
  22.  
  23. USES Stuff,    UMouse,  MouKey,  DiskBuf,
  24.      WinVSM,   SB,
  25.      FrameWin, ActStWi, DataWin;
  26.  
  27. CONST
  28.   ADWIconSetPassive = 40;  { IconSymbol => Passiv gesetzt }
  29.   ADWScrolledBuf    = 41;  { gescrollt                    }
  30.   ADWSwitchedNormal = 42;  { in Normalzustand "geschaltet"}
  31.   ADWSwitchedIcon   = 43;  { in Icongrösse                }
  32.   ADWSwitchedMax    = 44;  { in Maximale Grösse gegangen  }
  33.   ADWSetCursor      = 45;  { Cursor neu gesetzt           }
  34.  
  35. TYPE
  36.   WindowStates = (Maximized, Normal, Iconized);
  37.  
  38.   ActiveDataWindowPtr = ^ActiveDataWindow;
  39.   ActiveDataWindow =
  40.     OBJECT (DataWindow)
  41.  
  42.       CtrlCodes,         { ControlCodes berücksichtigen ? }
  43.       SaveByIcon : BOOLEAN;        { Auslagern bei Icon ? }
  44.       IconTL : STRING [18];             { String für Icon }
  45.       Number : BYTE;                    { Fensternummer   }
  46.       State  : WindowStates;            { "Zustand"       }
  47.       StMaxX1, StMaxY1, StMaxX2, StMaxY2, { Koordinaten   }
  48.       StNorX1, StNorY1, StNorX2, StNorY2, { der "Zustände"}
  49.       StIcoX1, StIcoY1, StIcoX2, StIcoY2 : BYTE;
  50.  
  51.       CONSTRUCTOR Init (MaxColumns,MaxLines,FreeHeap: WORD;
  52.                         NewVSM : WExtVSMPtr);
  53.       CONSTRUCTOR Copy (Win : ActiveDataWindow);
  54.       PROCEDURE Open;                              VIRTUAL;
  55.       PROCEDURE SetSaveBack (Save : BOOLEAN);      VIRTUAL;
  56.       PROCEDURE SetClearWin (Clear : BOOLEAN);     VIRTUAL;
  57.       PROCEDURE SetMoving (Moving : BOOLEAN);      VIRTUAL;
  58.       PROCEDURE SetZooming (Zooming : BOOLEAN);    VIRTUAL;
  59.       PROCEDURE Close;                             VIRTUAL;
  60.       PROCEDURE CheckMouEvent (Ev : EventObj);     VIRTUAL;
  61.       {--------------- *** INTERN: *** -------------------}
  62.       PROCEDURE CheckMouSBVertic (Ev : EventObj);  VIRTUAL;
  63.       PROCEDURE CheckMouSBHoriz (Ev : EventObj);   VIRTUAL;
  64.       PROCEDURE CheckMouStates (Ev : EventObj);    VIRTUAL;
  65.       PROCEDURE CheckMouDoubleC (Ev : EventObj);   VIRTUAL;
  66.       PROCEDURE CheckMouZooming (Ev : EventObj);   VIRTUAL;
  67.       {---------------------------------------------------}
  68.       PROCEDURE CheckKeyEvent (Ev : EventObj);     VIRTUAL;
  69.       PROCEDURE SwitchState (NewSt:WindowStates);  VIRTUAL;
  70.       PROCEDURE DrawTitles;                        VIRTUAL;
  71.       PROCEDURE DrawFrame;                         VIRTUAL;
  72.       PROCEDURE SetNumber (N : BYTE);              VIRTUAL;
  73.       PROCEDURE SetIconTitle (IT : STRING);        VIRTUAL;
  74.       PROCEDURE SetIconXY (ix1,iy1 : BYTE);        VIRTUAL;
  75.       PROCEDURE SetMaxXY (mx1,my1,mx2,my2 :BYTE);  VIRTUAL;
  76.       PROCEDURE SetSaveByIcon (Save : BOOLEAN);    VIRTUAL;
  77.       PROCEDURE CheckControlCodes (CC : BOOLEAN);  VIRTUAL;
  78.  
  79.       FUNCTION CtrlCodesChecked : BOOLEAN;         VIRTUAL;
  80.       FUNCTION GetSaveByIcon : BOOLEAN;            VIRTUAL;
  81.       FUNCTION GetState : WindowStates;            VIRTUAL;
  82.       FUNCTION GetNumber : BYTE;                   VIRTUAL;
  83.       FUNCTION GetIconTitle : STRING;              VIRTUAL;
  84.     END;
  85.  
  86. IMPLEMENTATION
  87.  
  88. (* ----------------------------------------------------- *)
  89. (* Der neue Konstruktor ruft zuerst seinen Vorgänger auf,*)
  90. (* belegt dann die eigenen Variablen mit Standardwerten. *)
  91. (* ----------------------------------------------------- *)
  92. CONSTRUCTOR ActiveDataWindow.Init
  93.               (MaxColumns, MaxLines, FreeHeap : WORD;
  94.                NewVSM : WExtVSMPtr);
  95. BEGIN
  96.   IF DataWindow.Init (MaxColumns, MaxLines,
  97.                       FreeHeap, NewVSM) THEN BEGIN
  98.     State   := Normal;  IconTL  := '';  Number := 0;
  99.     StMaxX1 := 1;       StMaxY1 := 2;
  100.     SaveByIcon := TRUE; CtrlCodes := TRUE;
  101.     StMaxX2 := VSM^.GetXLength-2;
  102.     StMaxY2 := VSM^.GetYLength-2;
  103.     StIcoX1 := VSM^.GetXLength-25;
  104.     StIcoY1 := VSM^.GetYLength-4;
  105.     StIcoX2 := VSM^.GetXLength-6;
  106.     StIcoY2 := VSM^.GetYLength-2;
  107.     SetZooming (On);
  108.     SetKeys (CtrlF5, AltF3);
  109.   END ELSE
  110.     Fail;
  111. END;
  112.  
  113. CONSTRUCTOR ActiveDataWindow.Copy (Win : ActiveDataWindow);
  114. BEGIN
  115.   IF DataWindow.Copy (Win) THEN
  116.     Self := Win
  117.   ELSE
  118.     Fail
  119. END;
  120.  
  121. (* ----------------------------------------------------- *)
  122. (* Öffnen des Fensters. Befindet es sich im "Icon"-Zu-   *)
  123. (* stand, so muss das Öffnen eigenhändig erfolgen, wegen *)
  124. (* Schatten etc.                                         *)
  125. (* ----------------------------------------------------- *)
  126. PROCEDURE ActiveDataWindow.Open;
  127.   VAR MouVis : BOOLEAN;
  128. BEGIN
  129.   IF State=Iconized THEN BEGIN
  130.     MouVis := Mouse^.GetVisible;
  131.     Mouse^.Hide;
  132.     VSM^.GetPart (x1, y1, x2, y2, BackGround);
  133.     BackSaved := TRUE;   Opened := TRUE;
  134.     DrawFrame;
  135.     DrawTitles;
  136.     IF MouVis THEN Mouse^.Show;
  137.     VSM^.GotoXY (Succ (x1), Succ (y1));
  138.   END ELSE
  139.     DataWindow.Open;
  140. END;
  141.  
  142. (* ----------------------------------------------------- *)
  143. (* ActiveDataWindow pocht auf die folgenden Werte, daher *)
  144. (* wird nicht anderes zugelassen.                        *)
  145. (* ----------------------------------------------------- *)
  146. PROCEDURE ActiveDataWindow.SetSaveBack (Save : BOOLEAN);
  147. BEGIN
  148.   SaveBack := TRUE;               { wird NICHT akzeptiert }
  149. END;
  150.  
  151. PROCEDURE ActiveDataWindow.SetClearWin (Clear : BOOLEAN);
  152. BEGIN
  153.   ClearWin := FALSE;                               { item }
  154. END;
  155.  
  156. PROCEDURE ActiveDataWindow.SetMoving (Moving : BOOLEAN);
  157. BEGIN
  158.   MoveAllowed := TRUE;
  159. END;
  160.  
  161. PROCEDURE ActiveDataWindow.SetZooming (Zooming : BOOLEAN);
  162. BEGIN
  163.   ZoomAllowed := TRUE;
  164. END;
  165.  
  166. (* ----------------------------------------------------- *)
  167. (* Schliessen des Fensters. Auch hier wird bei "Iconized"*)
  168. (* eine Ausnahme gemacht.                                *)
  169. (* ----------------------------------------------------- *)
  170. PROCEDURE ActiveDataWindow.Close;
  171.   VAR MouVis : BOOLEAN;
  172. BEGIN
  173.   IF State=Iconized THEN BEGIN
  174.     MouVis := Mouse^.GetVisible;
  175.     Mouse^.Hide;
  176.     VSM^.PutPart (x1, y1, x2, y2, TRUE, BackGround);
  177.     BackGround := NIL; BackSaved := FALSE; Opened := FALSE;
  178.     IF MouVis THEN
  179.       Mouse^.Show;
  180.   END ELSE
  181.     DataWindow.Close;
  182. END;
  183.  
  184. PROCEDURE ActiveDataWindow.CheckMouEvent (Ev : EventObj);
  185. BEGIN
  186.   IF NOT Opened OR NOT Active OR
  187.      NOT Mouse^.GetVisible THEN BEGIN
  188.     SetReturnCode (CantWork);
  189.     Exit;
  190.   END;
  191.   SetReturnCode (EvNotExpr);
  192.   CheckMouSBVertic (Ev);        { kann auch ohne Speicher }
  193.   IF ReturnCode=EvNotExpr THEN
  194.     CheckMouSBHoriz (Ev);              { gescrollt werden }
  195.   IF (EnoughMemory) AND
  196.      (ReturnCode=EvNotExpr) THEN BEGIN
  197.  
  198.     { da hier aber eventuell gezoomt wird, besteht
  199.       CheckMouEv auf der Speichermenge                    }
  200.  
  201.     IF (Ev.Y=y1) AND (Ev.X>=x1) AND (Ev.X<=x2) THEN BEGIN
  202.       CheckMouStates (Ev);           { Zustand ändern ? }
  203.       IF ReturnCode=EvNotExpr THEN
  204.         CheckMouDoubleC (Ev);   { Doppelklick erfolgt ? }
  205.     END;
  206.     IF ReturnCode=EvNotExpr THEN
  207.       CheckMouSBVertic (Ev);      { vertikaler Balken ? }
  208.     IF ReturnCode=EvNotExpr THEN
  209.       CheckMouSBHoriz (Ev);            { horizontaler ? }
  210.     IF ReturnCode=EvNotExpr THEN
  211.       CheckMouZooming (Ev);                  { zoomen ? }
  212.  
  213.     { wenn immer noch nicht ausgewertet, dann soll sich
  214.       der Vorgänger an dem Event versuchen.             }
  215.  
  216.     IF ReturnCode=EvNotExpr THEN
  217.       DataWindow.CheckMouEvent (Ev);
  218.   END;
  219. END;
  220.  
  221. (* ----------------------------------------------------- *)
  222. (* Prüft, ob ein Mausereignis den vertikalen Scrollbalken*)
  223. (* betrifft; stellt keine Vorbedingungen.                *)
  224. (* ----------------------------------------------------- *)
  225. PROCEDURE ActiveDataWindow.CheckMouSBVertic (Ev:EventObj);
  226.   VAR ScrY  : INTEGER;
  227.       Answer: BYTE;
  228.  
  229.   PROCEDURE ScrollBufMouse (Dx, Dy : INTEGER);
  230.     VAR MVCur : BOOLEAN;
  231.   BEGIN
  232.     MVCur := GetMoveCur;
  233.     SetMoveCur (FALSE);
  234.     ScrollBuf (Dx, Dy);
  235.     SetMoveCur (MVCur);
  236.   END;
  237.  
  238. BEGIN
  239.   IF EvHand^.MouPressed (Ev) THEN BEGIN
  240.     ScrY := 0;
  241.     SBVertic^.CheckMouEv (Ev);
  242.     Answer := SBVertic^.GetReturnCode;
  243.     CASE Answer OF                           { scrollen ? }
  244.       SBScrollUp  : ScrY := -1;
  245.       SBScrollDown: ScrY :=  1;
  246.       SBScrollPgUp: ScrY := -Pred (WinBufYLength);
  247.       SBScrollPgDn: ScrY := Pred (WinBufYLength);
  248.     END;
  249.     IF ScrY<>0 THEN BEGIN
  250.       REPEAT
  251.         EvHand^.PeekEvent (Ev);
  252.         IF Ev.Time=MaxLongInt THEN BEGIN
  253.           IF Abs (ScrY)>1 THEN
  254.             VSM^.Delay (MouseDelay*3)
  255.           ELSE
  256.             VSM^.Delay (MouseDelay);
  257.           ScrollBufMouse (0, ScrY);
  258.         END;
  259.       UNTIL (EvHand^.MouReleased (Ev)) OR
  260.             (Ev.EventType=EvMouMove);
  261.       LastEv := Ev;
  262.       SetReturnCode (ADWScrolledBuf);
  263.     END;
  264.                                    { nein, Positionierung }
  265.     IF (Answer=SBGotoPos) THEN BEGIN
  266.       ScrollBufMouse
  267.         (0,INTEGER (SBVertic^.GetPos-
  268.                     (BufY2-BufY1) DIV 2-BufY1));
  269.       LastEv := Ev;
  270.       SetReturnCode (ADWScrolledBuf);
  271.     END;
  272.   END;
  273. END;
  274.  
  275. (* ----------------------------------------------------- *)
  276. (* Analog zu CheckMouSBVertic, hier für den horizontalen *)
  277. (* Scrollbalken.                                         *)
  278. (* ----------------------------------------------------- *)
  279. PROCEDURE ActiveDataWindow.CheckMouSBHoriz (Ev:EventObj);
  280.   VAR ScrX  : INTEGER;
  281.       Answer: BYTE;
  282.  
  283.   PROCEDURE ScrollBufMouse (Dx, Dy : INTEGER);
  284.     VAR MVCur : BOOLEAN;
  285.   BEGIN
  286.     MVCur := GetMoveCur;
  287.     SetMoveCur (FALSE);
  288.     ScrollBuf (Dx, Dy);
  289.     SetMoveCur (MVCur);
  290.   END;
  291.  
  292. BEGIN
  293.   IF EvHand^.MouPressed (Ev) THEN BEGIN
  294.     ScrX := 0;
  295.     SBHoriz^.CheckMouEv (Ev);
  296.     Answer := SBHoriz^.GetReturnCode;
  297.     CASE Answer OF                           { scrollen ? }
  298.       SBScrollUp  : ScrX := -1;
  299.       SBScrollDown: ScrX :=  1;
  300.       SBScrollPgUp: ScrX := -Pred (WinBufXLength);
  301.       SBScrollPgDn: ScrX := Pred (WinBufXLength);
  302.     END;
  303.     IF ScrX<>0 THEN BEGIN
  304.       REPEAT
  305.         EvHand^.PeekEvent (Ev);
  306.         IF Ev.Time=MaxLongInt THEN BEGIN
  307.           IF Abs (ScrX)>1 THEN
  308.             VSM^.Delay (MouseDelay*3)
  309.           ELSE
  310.             VSM^.Delay (MouseDelay);
  311.           ScrollBufMouse (ScrX, 0);
  312.         END
  313.       UNTIL (EvHand^.MouReleased (Ev)) OR
  314.             (Ev.EventType=EvMouMove);
  315.       LastEv := Ev;
  316.       SetReturnCode (ADWScrolledBuf);
  317.     END;
  318.                                    { Direktpositionierung }
  319.     IF (Answer=SBGotoPos) THEN BEGIN
  320.       ScrollBufMouse
  321.         (INTEGER (SBHoriz^.GetPos-
  322.                  (BufX2-BufX1) DIV 2-BufX1), 0);
  323.       LastEv := Ev;
  324.       SetReturnCode (ADWScrolledBuf);
  325.     END;
  326.   END;
  327. END;
  328.  
  329. (* ----------------------------------------------------- *)
  330. (* Geht davon aus, dass Ev.X>=x1, Ev.X<=x2, Ev.Y=y1 ist  *)
  331. (* (Maus sich also in Titelzeile befindet), dass Ev ein  *)
  332. (* Mausevent ist. Prüft, ob eines der "StatesChanging"-  *)
  333. (* Symbole angeklickt wurde.                             *)
  334. (* ----------------------------------------------------- *)
  335. PROCEDURE ActiveDataWindow.CheckMouStates (Ev : EventObj);
  336.   VAR Switch : BOOLEAN;
  337. BEGIN
  338.   {------------ "Maximized" oder "Iconized" ? ------------}
  339.   { Dann ist das Symbol zum Umschalten nach "Normal" von
  340.     beiden am gleichen Ort, beide schalten in den gleichen
  341.     Zustand um, also gemeinsame Abfrage möglich.          }
  342.  
  343.   IF (State<>Normal) AND
  344.      (Ev.X>=x2-4) AND (Ev.X<=x2-2) THEN BEGIN
  345.     Switch := FALSE;
  346.     IF EvHand^.MouReleased (Ev) THEN
  347.       Switch := TRUE
  348.     ELSE BEGIN
  349.       REPEAT
  350.         EvHand^.WaitForEvent (EvMouAll, Ev);
  351.       UNTIL EvHand^.MouReleased (Ev);
  352.       IF (Ev.X>=x2-4) AND (Ev.X<=x2-2) THEN
  353.         Switch := TRUE;
  354.     END;
  355.     IF Switch THEN BEGIN
  356.       LastEv := Ev;
  357.       SwitchState (Normal);
  358.     END;
  359.   END ELSE
  360.   {---------- "Minimieren" oder "iconisieren" ? ---------}
  361.   { Hier muss zwischen zwei Symbolen unterschieden werden}
  362.     IF (State=Normal) AND
  363.        (Ev.X>=x2-7) AND (Ev.X<=x2-2) THEN BEGIN
  364.       Switch := FALSE;
  365.       IF Evhand^.MouReleased (Ev) THEN Switch := TRUE
  366.       ELSE BEGIN
  367.         REPEAT
  368.           EvHand^.WaitForEvent (EvMouAll, Ev)
  369.         UNTIL Evhand^.MouReleased (Ev);
  370.         IF (Ev.X>=x2-7) AND (Ev.X<=x2-2) THEN
  371.           Switch := TRUE;
  372.       END;
  373.       IF Switch THEN
  374.         IF (Ev.X>=x2-4) AND
  375.            (Ev.X<=x2-2) THEN BEGIN     { zu "Icon" machen }
  376.           SwitchState (Iconized);
  377.           IF ReturnCode<>DWCantSaveBuf THEN
  378.              SetReturnCode (ADWSwitchedIcon);
  379.         END ELSE BEGIN                { oder volle Grösse }
  380.           SwitchState (Maximized);
  381.           SetReturnCode (ADWSwitchedMax);
  382.         END;
  383.       LastEv := Ev;
  384.     END;
  385. END;
  386.  
  387. (* ----------------------------------------------------- *)
  388. (* Prüft, ob ein Doppelklick in Titelzeile erfolgte.     *)
  389. (* Bedingungen: Siehe CheckMouStates.                    *)
  390. (* ----------------------------------------------------- *)
  391. PROCEDURE ActiveDataWindow.CheckMouDoubleC (Ev : EventObj);
  392. BEGIN
  393.   IF EvHand^.MouPressed (Ev) THEN
  394.     IF EvHand^.MouReleased (LastEv) AND
  395.      (LastEv.Y=Ev.Y) AND (LastEv.X=Ev.X) AND
  396.      (LastEv.Time+DoubleClickTime>=Ev.Time) THEN BEGIN
  397.     REPEAT
  398.       EvHand^.WaitForEvent (EvMouAll, Ev)
  399.     UNTIL (Ev.EventType=EvMouMove) OR
  400.           (EvHand^.MouReleased (Ev));
  401.     LastEv := Ev;
  402.     IF Ev.EventType<>EvMouMove THEN
  403.       IF State=Maximized THEN BEGIN
  404.         SwitchState (Normal);
  405.         SetReturnCode (ADWSwitchedNormal);
  406.       END ELSE BEGIN
  407.         SwitchState (Maximized);
  408.         SetReturnCode (ADWSwitchedMax);
  409.       END;
  410.   END;
  411. END;
  412.  
  413. (* ----------------------------------------------------- *)
  414. (* CheckMouZooming prüft, ob das Zooming-Symbol ange-    *)
  415. (* klickt wurde.                                         *)
  416. (* ----------------------------------------------------- *)
  417. PROCEDURE ActiveDataWindow.CheckMouZooming (Ev : EventObj);
  418.   VAR DifX : BYTE;
  419. BEGIN
  420.   IF EvHand^.MouPressed (Ev) AND
  421.      (Ev.X>=Pred (x2)) AND
  422.      (Ev.X<=x2) AND (Ev.Y=y2) THEN BEGIN
  423.     DifX := x2-Ev.X;
  424.     StartChange;
  425.     REPEAT
  426.       EvHand^.WaitForEvent (EvMouAll, Ev);
  427.       IF Ev.EventType=EvMouMove THEN
  428.         ZoomAbs (Ev.X-DifX, Ev.Y)
  429.     UNTIL EvHand^.MouReleased (Ev);
  430.     EndChange;
  431.     LastEv := Ev;
  432.     SetReturnCode (ZoomedWin);
  433.   END;
  434. END;
  435.  
  436. PROCEDURE ActiveDataWindow.CheckKeyEvent (Ev : EventObj);
  437.   VAR NewX, NewY : INTEGER;
  438.       Key        : WORD;
  439.       KeyExpr    : BOOLEAN;
  440. BEGIN
  441.   SetReturnCode (EvNotExpr);
  442.   IF Ev.EventType=EvKeyPressed THEN BEGIN
  443.     {---------------- für alle Zustände ------------------}
  444.     CASE Ev.Key OF
  445.       362 : BEGIN                    { Alt-F3, schliessen }
  446.               Close;
  447.               SetReturnCode (ClosedWin);
  448.             END;
  449.       319 : BEGIN                    { F5, Zustand ändern }
  450.               IF State=Normal THEN BEGIN
  451.                 SwitchState (Maximized);
  452.                 SetReturnCode (ADWSwitchedMax);
  453.               END ELSE BEGIN
  454.                 SwitchState (Normal);
  455.                 SetReturnCode (ADWSwitchedNormal);
  456.               END;
  457.             END;
  458.     END;
  459.     {----------- nur für "Maximized" und "Normal" --------}
  460.     IF (State<>Iconized) AND
  461.        (ReturnCode=EvNotExpr) THEN BEGIN
  462.       Key := Ev.Key;   KeyExpr := TRUE;
  463.       IF CtrlCodes THEN
  464.         CASE Key OF            { umwandeln der Ctrl-Codes }
  465.           CtrlS : Key := CurLeft;
  466.           CtrlD : Key := CurRight;
  467.           CtrlE : Key := CurUp;
  468.           CtrlX : Key := CurDown;
  469.           CtrlR : Key := CurPgUp;
  470.           CtrlC : Key := CurPgDn;
  471.         END;
  472.       NewX := Buf^.GetX;  NewY := Buf^.GetY;
  473.       CASE Key OF
  474.         CurUp   : IF NewY>1 THEN Dec (NewY);
  475.         CurDown : IF NewY<Buf^.GetLines THEN Inc (NewY);
  476.         CurPgUp : IF NewY>Pred (WinBufYLength) THEN
  477.                     Dec (NewY, Pred (WinBufYLength))
  478.                   ELSE
  479.                     NewY := 1;
  480.         CurPgDn : BEGIN
  481.                     Inc (NewY, Pred (WinBufYLength));
  482.                     IF NewY>Buf^.GetLines THEN
  483.                       NewY := Buf^.GetLines;
  484.                   END;
  485.         CtrlHome: BEGIN  NewX := 1;  NewY := 1  END;
  486.         CtrlEnd : BEGIN
  487.                     NewX := 1; NewY := Buf^.GetLines;
  488.                   END;
  489.         CurLeft : Dec (NewX);
  490.         CurRight: Inc (NewX);
  491.         CurHome : NewX := 1;
  492.         CurEnd  : NewX := Buf^.GetColumns
  493.       ELSE
  494.         KeyExpr := FALSE;
  495.       END;
  496.       IF (NewX<>Buf^.GetX) OR
  497.          (NewY<>Buf^.GetY) OR
  498.          (KeyExpr) THEN BEGIN
  499.         GotoXY (NewX, NewY);
  500.         SetReturnCode (ADWSetCursor);
  501.       END;
  502.     END;
  503.   END;
  504.   {----- falls bis hierhin nicht ausgewertet, kann das
  505.          der Vorgänger eventuell übernehmen --------------}
  506.   IF (ReturnCode=EvNotExpr) THEN
  507.     IF State=Iconized THEN BEGIN
  508.       ZoomAllowed := FALSE;  SaveWinContent := TRUE;
  509.       DataWindow.CheckKeyEvent (Ev);
  510.       ZoomAllowed := TRUE;   SaveWinContent := FALSE;
  511.     END ELSE
  512.       DataWindow.CheckKeyEvent (Ev);
  513. END;
  514.  
  515. (* ----------------------------------------------------- *)
  516. (* Zustand wechseln. Dazu wird zunächst das Fenster ge-  *)
  517. (* schlossen, falls von Normal ausgehend die aktuellen   *)
  518. (* Koordinaten in StNor.. gesichert, dann die neuen Daten*)
  519. (* gesetzt und das Fenster neu geöffnet. Besonderheit ist*)
  520. (* dabei das Wechseln nach "Iconized": Das Fenster wird  *)
  521. (* gleichzeitig "passiv" gesetzt, der ReturnCode lautet  *)
  522. (* "ADWIconSetPassive".                                  *)
  523. (* ----------------------------------------------------- *)
  524. PROCEDURE ActiveDataWindow.SwitchState(NewSt:WindowStates);
  525.   VAR i1, i2 : WORD;
  526. BEGIN
  527.   IF (Opened) AND (NewSt<>State) THEN BEGIN
  528.     IF State=Normal THEN BEGIN
  529.       StNorX1 := x1;  StNorY1 := y1;
  530.       StNorX2 := x2;  StNorY2 := y2;
  531.     END;
  532.     Close;
  533.     IF NewSt=Maximized THEN BEGIN
  534.       x1 := StMaxX1;  y1 := StMaxY1;
  535.       x2 := StMaxX2;  y2 := StMaxY2
  536.     END ELSE IF NewSt=Iconized THEN BEGIN
  537.       x1 := StIcoX1;  y1 := StIcoY1;
  538.       x2 := StIcoX2;  y2 := StIcoY2;
  539.       IF SaveByIcon THEN SaveBuffer;
  540.       IF ReturnCode=DWCantSaveBuf THEN
  541.         NewSt := State
  542.       ELSE BEGIN
  543.         SetReturnCode (ADWIconSetPassive);
  544.         SetPassive;
  545.       END;
  546.     END;
  547.     IF NewSt=Normal THEN BEGIN
  548.       x1 := StNorX1;  y1 := StNorY1;
  549.       x2 := StNorX2;  y2 := StNorY2
  550.     END;
  551.     IF (NewSt<>Iconized) AND        { von Icon ausgehend, }
  552.        (State=Iconized) AND  { ganzer Puffer ausgelagert ?}
  553.        (SaveByIcon) THEN BEGIN
  554.       i1 := Succ (Buf^.GetMaxColumns)*2;
  555.         { ^^^ Speicherbedarf einer Zeile }
  556.       IF MemAvail>Buf^.GetFreeHeap THEN
  557.         i2 := ((MemAvail-Buf^.GetFreeHeap) DIV i1) DIV 2;
  558.           { soviele Zeilen können geladen werden, geteilt
  559.             durch 2 }
  560.       i1 := i2;
  561.       IF BufY2+i2>Buf^.Lines THEN BEGIN
  562.         i2 := Buf^.GetLines-BufY2;  Inc (i1, i2);
  563.            { einschränken, über GetLines hinaus kann nicht
  564.              geladen werden }
  565.       END;
  566.       IF INTEGER (BufY1-i1)<0 THEN BEGIN
  567.         Inc (i2, i1-BufY1);  i1 := Pred (BufY1);
  568.            { einschränken, unter 1 kann nicht geladen
  569.              werden }
  570.       END;
  571.       DiskBufferPtr (Buf)^.LoadPart (BufY1-i1, BufY2+i2);
  572.         { diese ganzen Berechnungen sind dazu da, dass
  573.           maximal viel auf einmal wieder in den Speicher
  574.           geladen wird }
  575.     END;
  576.     State := NewSt;
  577.     Open;
  578.   END;
  579. END;
  580.  
  581. (* ----------------------------------------------------- *)
  582. (* "Kopfzeile" schreiben: Symbole, Nummer und Titel.     *)
  583. (* Je nach Zustand anders.                               *)
  584. (* ----------------------------------------------------- *)
  585. PROCEDURE ActiveDataWindow.DrawTitles;
  586.   VAR s : STRING;
  587. BEGIN
  588.   System.Str (Number, s);
  589.   IF State=Iconized THEN BEGIN
  590.     VSM^.FillPart (Succ (x1), Succ (y1),
  591.                    Pred (x2), Succ (y1), 7, ' ');
  592.     VSM^.WriteStr (x1+(x2-x1) DIV 2, y1, FrCol, s);
  593.     VSM^.WriteStr (Succ (x1), Succ (y1), FrCol, IconTL);
  594.     IF Active THEN BEGIN
  595.       VSM^.WriteStr (x1+2, y1, FrCol, '[■]');
  596.       VSM^.WriteStr (x2-4, y1, FrCol, '['+Chr (24)+']');
  597.     END;
  598.   END ELSE BEGIN
  599.     IF Length (TL)<(x2-x1-16) THEN
  600.       VSM^.WriteStr ((x1+x2+4+Length (TL)) DIV 2, y1,
  601.                      TLCol, TL);
  602.     VSM^.WriteStr (x1+2, y1, FrCol, '[■]');
  603.     IF State=Maximized THEN
  604.       VSM^.WriteStr (x2-4-Succ(Length(s)), y1, FrCol,
  605.                      s+Frames [Frame, 5]+'['+Chr (18)+']')
  606.     ELSE
  607.       VSM^.WriteStr (x2-7-Succ(Length(s)), y1, FrCol,
  608.                      s+Frames[Frame,5]+
  609.                      '['+Chr(24)+']['+Chr(25)+']');
  610.   END;
  611. END;
  612.  
  613. (* ----------------------------------------------------- *)
  614. (* Den Rahmen zeichnen, falls nicht "Iconized" wird das  *)
  615. (* "ZoomingSymbol" hinzugefügt.                          *)
  616. (* ----------------------------------------------------- *)
  617. PROCEDURE ActiveDataWindow.DrawFrame;
  618.   VAR MouVis : BOOLEAN;
  619. BEGIN
  620.   MouVis := Mouse^.GetVisible;
  621.   Mouse^.Hide;
  622.   DataWindow.DrawFrame;
  623.   IF (State<>Iconized) AND Active THEN
  624.     VSM^.WriteStr (Pred (x2), y2, 15, '─┘');
  625.   IF MouVis THEN
  626.     Mouse^.Show;
  627. END;
  628.  
  629. PROCEDURE ActiveDataWindow.SetNumber (N : BYTE);
  630. BEGIN
  631.   IF NOT Opened THEN Number := N;
  632. END;
  633.  
  634. PROCEDURE ActiveDataWindow.SetIconTitle (IT : STRING);
  635. BEGIN
  636.   IF (State<>Iconized) OR NOT Opened THEN BEGIN
  637.     IF Length (IT)>18 THEN
  638.       IT [0] := Chr (18);
  639.     IconTL := IT;
  640.   END;
  641. END;
  642.  
  643. PROCEDURE ActiveDataWindow.SetIconXY (ix1, iy1 : BYTE);
  644. BEGIN
  645.   IF NOT Opened OR (State<>Iconized) THEN BEGIN
  646.     StIcoX1 := ix1;         StIcoY1 := iy1;
  647.     StIcoX2 := StIcoX1+19;  StIcoY2 := StIcoY1+2;
  648.   END;
  649. END;
  650.  
  651. PROCEDURE ActiveDataWindow.SetMaxXY (mx1,my1,mx2,my2:BYTE);
  652. BEGIN
  653.   IF NOT Opened OR (State<>Maximized) THEN BEGIN
  654.     StMaxX1 := mx1;  StMaxY1 := my1;
  655.     StMaxX2 := mx2;  StMaxY2 := my2;
  656.   END;
  657. END;
  658.  
  659. PROCEDURE ActiveDataWindow.SetSaveByIcon (Save : BOOLEAN);
  660. BEGIN
  661.   SaveByIcon := Save;
  662. END;
  663.  
  664. PROCEDURE ActiveDataWindow.CheckControlCodes (CC : BOOLEAN);
  665. BEGIN
  666.   CtrlCodes := CC;
  667. END;
  668.  
  669. FUNCTION ActiveDataWindow.CtrlCodesChecked : BOOLEAN;
  670. BEGIN
  671.   CtrlCodesChecked := CtrlCodes;
  672. END;
  673.  
  674. FUNCTION ActiveDataWindow.GetSaveByIcon : BOOLEAN;
  675. BEGIN
  676.   GetSaveByIcon := SaveByIcon;
  677. END;
  678.  
  679. FUNCTION ActiveDataWindow.GetState : WindowStates;
  680. BEGIN
  681.   GetState := State;
  682. END;
  683.  
  684. FUNCTION ActiveDataWindow.GetNumber : BYTE;
  685. BEGIN
  686.   GetNumber := Number;
  687. END;
  688.  
  689. FUNCTION ActiveDataWindow.GetIconTitle : STRING;
  690. BEGIN
  691.   GetIconTitle := IconTL;
  692. END;
  693.  
  694. END.
  695. (* ----------------------------------------------------- *)
  696. (*                  Ende von ACTDWIN.PAS                 *)
  697. (* ----------------------------------------------------- *)
  698.