home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 22 / windows / actstwi.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1991-01-04  |  15.5 KB  |  450 lines
  1. (* ----------------------------------------------------- *)
  2. (*                    ACTSTWI.PAS                        *)
  3. (*           ('ACTive' STandard Window)                  *)
  4. (*                                                       *)
  5. (* ■ ActiveStandWin: Erweitert "StandardWindow" um die   *)
  6. (*   Fähigkeit, Events, die das Fenster betreffen, selbst*)
  7. (*   auszuwerten. Dafür muss CheckEvent mit dem zu prü-  *)
  8. (*   fenden Event als Parameter aufgerufen werden. -     *)
  9. (*   Kennt zwei Zustände: Aktiv und Passiv; nur im       *)
  10. (*   aktiven Zustand kann auf Events reagiert werden; vom*)
  11. (*   Zustand hängt die Darstellung ab, die Daten dafür   *)
  12. (*   werden in SetActive/PassiveData gesetzt.            *)
  13. (*                                                       *)
  14. (*         (c) 1991 by R.Reichert & toolbox              *)
  15. (* ----------------------------------------------------- *)
  16. UNIT ActStWi;
  17.  
  18. INTERFACE
  19.  
  20. USES VSObj, WinVSM, Stuff, MouKey, StandWin;
  21.  
  22. CONST
  23.   On            = TRUE;
  24.   Off           = FALSE;       { ReturnCodes ("Antwort"): }
  25.   EvNotExpr     = 21;          { Event nicht ausgewertet  }
  26.   ZoomedWin     = 22;          { Fenster wurde "gezoomt"  }
  27.   MovedWin      = 23;          { Fenster wurde bewegt     }
  28.   ClosedWin     = 24;          { Fenster geschlossen      }
  29.   EvNotMouEv    = 25;          { kein MausEv (CheckMouEv) }
  30.   EvNotKeyEv    = 26;          { kein TastEv (CheckKeyEv) }
  31.   CantWork      = 27;          { Bedingungen nicht erfüllt,
  32.                                  BEDINGUNGEN:
  33.                                  ■ Active       TRUE,
  34.                                  ■ MoveAllowed  TRUE,
  35.                                  ■ Opened       TRUE,
  36.                                  ■ SaveBack     TRUE,
  37.                                  ■ BackSaved    TRUE,
  38.                                  ■ genügend Speicher für
  39.                                   Fensterinhalt (der tempo-
  40.                                   rär gespeichert wird,
  41.                                   falls SaveWinContent TRUE
  42.                                   ist),
  43.                                  ■ für CheckMouEv: Maus
  44.                                    sichtbar               }
  45.  
  46. TYPE
  47.   ActiveStandWinPtr = ^ActiveStandWin;
  48.   ActiveStandWin    = OBJECT (StandardWindow)
  49.  
  50.     FraCol,
  51.     Fra    : BYTE;                { zum temp. speichern }
  52.     LastEv : EventObj;       { letztes Event festhalten }
  53.                                      { Tastencode für...}
  54.     SwitchKey,                       { Moduswechsel,    }
  55.                                      { Mv..Key werden   }
  56.                                      { auch fürs Zoomen }
  57.                                      { gebraucht        }
  58.     CloseKey   : WORD;               { zum Schliessen   }
  59.     SaveWinContent, { speichern des Fensterinhalts bei
  60.                       bewegen / vergrössern ?           }
  61.     Active,   { Ist Fenster aktiv, kann es auf Events
  62.                 reagieren, ist es passiv, reagiert es
  63.                 nicht. Davon hängt auch die Darstellung
  64.                 des Fensters ab, hier standardmässig:
  65.                   ACTIVE : Doppelter Rahmen, Titel etc
  66.                   PASSIV : Einfacher Rahmen, ohne Titel }
  67.                                      { INTERNE Flags:   }
  68.     Changing,                            { Wechselmodus }
  69.     BeginChange,   { Anfang oder Ende des Wechselmodus, }
  70.     FinishChange: BOOLEAN; { für Open und Close wichtig }
  71.     TempWinMem : ScreenMemPtr;       { INTERN,          }
  72.      { hier wird der Fensterinhalt temporär gespeichert }
  73.  
  74.     CONSTRUCTOR Init (NewVSM : WExtVSMPtr);
  75.     CONSTRUCTOR Copy (Win : ActiveStandWin);
  76.     PROCEDURE Open;                              VIRTUAL;
  77.     PROCEDURE DrawTitles;                        VIRTUAL;
  78.     PROCEDURE Close;                             VIRTUAL;
  79.     PROCEDURE CheckEvent (Ev : EventObj);        VIRTUAL;
  80.     PROCEDURE CheckMouEvent (Ev : EventObj);     VIRTUAL;
  81.     PROCEDURE CheckKeyEvent (Ev : EventObj);     VIRTUAL;
  82.     PROCEDURE StartChange;                       VIRTUAL;
  83.     PROCEDURE EndChange;                         VIRTUAL;
  84.     PROCEDURE SetActive;                         VIRTUAL;
  85.     PROCEDURE SetActiveData; { *** INTERN *** }  VIRTUAL;
  86.     PROCEDURE SetPassive;                        VIRTUAL;
  87.     PROCEDURE SetPassiveData; { *** INTERN *** } VIRTUAL;
  88.     PROCEDURE SetKeys (SwKey, CK : WORD);        VIRTUAL;
  89.     PROCEDURE SetMinLength (MXL, MYL : BYTE);    VIRTUAL;
  90.     PROCEDURE SetSaveWinContent (Save:BOOLEAN);  VIRTUAL;
  91.  
  92.     FUNCTION ShiftPressed : BOOLEAN;             VIRTUAL;
  93.     FUNCTION EnoughMemory : BOOLEAN;             VIRTUAL;
  94.     FUNCTION GetSaveWinContent : BOOLEAN;        VIRTUAL;
  95.     FUNCTION GetSwitchKey : WORD;                VIRTUAL;
  96.     FUNCTION GetClosingKey : WORD;               VIRTUAL;
  97.   END;
  98.  
  99. IMPLEMENTATION
  100.  
  101. CONSTRUCTOR ActiveStandWin.Init (NewVSM : WExtVSMPtr);
  102. BEGIN
  103.   IF StandardWindow.Init (NewVSM) THEN BEGIN
  104.     SetKeys (CtrlF5, ESC);
  105.     SetMoving (On);
  106.     SetSaveWinContent (On);
  107.     SetActive;
  108.     Changing     := FALSE;
  109.     BeginChange  := FALSE;
  110.     FinishChange := FALSE;
  111.   END ELSE
  112.     Fail;
  113. END;
  114.  
  115. CONSTRUCTOR ActiveStandWin.Copy (Win: ActiveStandWin);
  116. BEGIN
  117.   IF Win.VSM=NIL THEN Fail
  118.                  ELSE Self := Win
  119. END;
  120.  
  121. (* ----------------------------------------------------- *)
  122. (* Neues Open, sofern Changing FALSE ist, wird nach      *)
  123. (* Active unterschieden (SetActive/PassiveData). Ist der *)
  124. (* Wechselmodus aktiv, so wird der von Close gerettete   *)
  125. (* Fensterinhalt wird ins Fenster kopiert.               *)
  126. (* ----------------------------------------------------- *)
  127. PROCEDURE ActiveStandWin.Open;
  128.   VAR Sha : BOOLEAN;  MouVis : BOOLEAN;
  129. BEGIN
  130.   MouVis := Mouse^.GetVisible;
  131.   Mouse^.Hide;
  132.   IF NOT Changing THEN BEGIN     { Wechselmodus inaktiv ? }
  133.     IF Active THEN SetActiveData                 { ja ... }
  134.               ELSE SetPassiveData;         { Daten setzen }
  135.     StandardWindow.Open;
  136.     IF (FinishChange) AND (SaveWinContent) THEN
  137.       VSM^.PutPart (Succ (x1), Succ (y1),
  138.                     Pred (x2), Pred (y2),
  139.                     TRUE, TempWinMem);
  140.  
  141.   END ELSE BEGIN                     { Wechselmodus aktiv }
  142.     VSM^.GetPart (x1, y1, x2, y2, Background);
  143.     BackSaved := TRUE;
  144.       {^^^ keine Prüfung notwendig, wenn es vorher genügend
  145.         Speicher hatte, ist der jetzt auch noch da        }
  146.     IF SaveWinContent AND (TempWinMem<>NIL) THEN
  147.       VSM^.PutPart (Succ (x1), Succ (y1),
  148.                     Pred (x2), Pred (y2),
  149.                     TRUE, TempWinMem);
  150.     StandardWindow.DrawFrame;
  151.     Opened := TRUE;
  152.   END;    { kein ReturnCode, das ist alles familienintern }
  153.   IF MouVis THEN
  154.     Mouse^.Show;
  155. END;
  156.  
  157. (* ----------------------------------------------------- *)
  158. (* Dieses Close leitet, falls Changing FALSE ist, wie    *)
  159. (* Open den Aufruf weiter, ansonsten wird der Fenster-   *)
  160. (* INHALT (!) gesichert (falls gewünscht via             *)
  161. (* SaveWinContentund der Hintergrund wieder restauriert. *)
  162. (* ----------------------------------------------------- *)
  163. PROCEDURE ActiveStandWin.Close;
  164.   VAR MouVis : BOOLEAN;
  165. BEGIN
  166.   MouVis := Mouse^.GetVisible;
  167.   Mouse^.Hide;
  168.   IF NOT Changing THEN
  169.     StandardWindow.Close
  170.   ELSE BEGIN
  171.     IF SaveWinContent THEN
  172.       VSM^.GetPart (Succ (x1), Succ (y1),
  173.                     Pred (x2), Pred (y2), TempWinMem);
  174.     { Keine Abfrage auf Erfolg, da CheckKeyEv / CheckMouEv
  175.       die Prüfung, ob genügend Speicher da ist, übernehmen}
  176.     IF BeginChange AND Shadow THEN      { geht's los ?    }
  177.       VSM^.PutPart (x1, y1, x2+2, y2+1, TRUE, Background)
  178.     ELSE
  179.       VSM^.PutPart (x1, y1, x2, y2, TRUE, Background);
  180.     Background := NIL;
  181.     BackSaved  := FALSE;  Opened := FALSE;
  182.   END;
  183.   IF MouVis THEN
  184.     Mouse^.Show;
  185. END;
  186.  
  187. (* ----------------------------------------------------- *)
  188. (* Neues DrawTitles: "Closing-Symbol" ('[■]') ist neu.   *)
  189. (* ----------------------------------------------------- *)
  190. PROCEDURE ActiveStandWin.DrawTitles;
  191. BEGIN
  192.   WITH VSM^ DO BEGIN
  193.     IF Length (TL)+6 < Pred (x2-x1) THEN
  194.       WriteStr ((x1+x2+4-Length (TL)) DIV 2, y1,
  195.                 TLCol, TL);
  196.     IF Length (BL) < Pred (x2-x1) THEN
  197.       WriteStr (Pred (x2) - Length (BL), y2, BLCol, BL);
  198.   END;
  199.   IF Active THEN
  200.     VSM^.WriteStr (x1+2, y1, FrCol, '[■]');
  201. END;
  202.  
  203. PROCEDURE ActiveStandWin.CheckEvent (Ev : EventObj);
  204. BEGIN
  205.   IF (Ev.EventType AND EvKeyAll) > 0 THEN
  206.     CheckKeyEvent (Ev)
  207.   ELSE
  208.     CheckMouEvent (Ev);
  209.   IF (ReturnCode=EvNotMouEv) OR
  210.      (ReturnCode=EvNotKeyEv) THEN
  211.     SetReturnCode (EvNotExpr)
  212. END;
  213.  
  214. (* ----------------------------------------------------- *)
  215. (* Prüft, ob das Mausevent das Fenster in irgendeiner    *)
  216. (* Art und Weise beeinflusst, wie bewegen, schliessen.   *)
  217. (* ----------------------------------------------------- *)
  218. PROCEDURE ActiveStandWin.CheckMouEvent (Ev: EventObj);
  219.   VAR DifX      : BYTE;
  220. BEGIN
  221.   SetReturnCode (EvNotExpr);
  222.   {----------------- Bedingungen erfüllt ? ---------------}
  223.   IF Opened    AND SaveBack AND
  224.      BackSaved AND MoveAllowed AND
  225.      Active    AND EnoughMemory AND
  226.      Mouse^.GetVisible THEN BEGIN
  227.  
  228.      IF (EvHand^.MouPressed (Ev)) AND
  229.        (Ev.Y=y1) AND (Ev.X>=x1) AND (Ev.X<=x2) THEN BEGIN
  230.       {------------- CloseSymbol angeklickt ? ------------}
  231.       IF (Ev.X>Succ (x1)) AND (Ev.X<x1+5) THEN BEGIN
  232.         REPEAT                 { warten bis losgelassen }
  233.           Evhand^.WaitForEvent (EvMouAll, Ev);
  234.         UNTIL (Evhand^.MouReleased (Ev)) OR
  235.               ((Ev.EventType=EvMouMove) AND NOT
  236.                ((Ev.X>Succ (x1)) AND (Ev.X<x1+5) AND
  237.                 (Ev.Y=y1)));
  238.         IF (Ev.X>Succ (x1)) AND (Ev.X<x1+5) AND
  239.            (Ev.Y=y1) THEN BEGIN
  240.           Close;
  241.           SetReturnCode (ClosedWin);
  242.         END;
  243.       END ELSE BEGIN
  244.       {--------------- Nein => Bewegung ------------------}
  245.         DifX := (Ev.X-x1);   { Abstand des Mauscursor zum
  246.                                linken Ecken des Fensters  }
  247.         StartChange;
  248.         REPEAT
  249.           EvHand^.WaitForEvent (EvMouAll, Ev);
  250.           {----------------- Maus bewegt ? ---------------}
  251.           IF Ev.EventType=EvMouMove THEN
  252.             IF Ev.X>DifX THEN
  253.               MoveAbs (Ev.X-DifX, Ev.Y)        { mitgehen }
  254.             ELSE
  255.               MoveAbs (0, Ev.Y);
  256.           SetReturnCode (MovedWin);
  257.         UNTIL EvHand^.MouReleased (Ev); { bis losgelassen }
  258.         EndChange;
  259.       END;
  260.       LastEv := Ev;
  261.     END;
  262.   END ELSE
  263.     SetReturnCode (CantWork); { Bedingungen nicht erfüllt }
  264. END;
  265.  
  266. (* ----------------------------------------------------- *)
  267. (* Wie CheckMouEv; prüft, ob ein Tastaturevent das       *)
  268. (* Fenster berührt.                                      *)
  269. (* ----------------------------------------------------- *)
  270. PROCEDURE ActiveStandWin.CheckKeyEvent (Ev: EventObj);
  271.   VAR Quit      : BOOLEAN;
  272.       DifX, DifY: INTEGER;
  273. BEGIN
  274.   IF Opened    AND SaveBack AND
  275.      BackSaved AND MoveAllowed AND
  276.      Active    AND EnoughMemory THEN BEGIN
  277.  
  278.     SetReturnCode (0);
  279.     Changing := FALSE;  Quit := FALSE;
  280.     REPEAT
  281.       IF Ev.EventType=EvKeyPressed THEN BEGIN
  282.         {------- ESC oder Enter, Changing Aktiv ----------}
  283.         IF ((Ev.Key=ESC) OR            { ESC oder Enter ? }
  284.             (Ev.Key=Enter)) AND          { und Wm aktiv ? }
  285.            (Changing) THEN BEGIN
  286.           EndChange;  Quit := TRUE;
  287.         END;
  288.         {--------- CloseKey, Changing nicht aktiv, -------}
  289.         IF (Ev.Key=CloseKey) AND
  290.            (NOT Changing) AND
  291.            (NOT Quit) THEN BEGIN
  292.           { ^ sonst wird nach Durchlauf von obigem
  293.             das hier auch noch durchlaufen                }
  294.           Close;
  295.           SetReturnCode (ClosedWin);
  296.           Quit := TRUE;
  297.         END;
  298.         {---- Pfeiltaste mit oder ohne Shift gedrückt ?---}
  299.         IF Changing THEN BEGIN
  300.           DifX := 0;  DifY := 0;
  301.           CASE Ev.Key OF
  302.             CurLeft : DifX := -1;
  303.             CurRight: DifX :=  1;
  304.             CurUp   : DifY := -1;
  305.             CurDown : DifY :=  1;
  306.           END;
  307.           IF ((DifX<>0) OR (DifY<>0)) THEN
  308.             IF ShiftPressed THEN BEGIN
  309.               Zoom (DifX, DifY);
  310.               SetReturnCode (ZoomedWin);
  311.             END ELSE BEGIN
  312.               Move (DifX, DifY);
  313.               SetReturnCode (MovedWin);
  314.             END;
  315.         END ELSE
  316.           {------- "Moduswechseltaste" gedrückt ? --------}
  317.           IF Ev.Key=SwitchKey THEN
  318.             StartChange;
  319.       END;
  320.       IF (NOT Changing) AND           { nichts passiert ? }
  321.          (ReturnCode<>ClosedWin) AND
  322.          (ReturnCode<>MovedWin) THEN BEGIN
  323.         Quit := TRUE;               { ja, also fertig, Ev }
  324.         SetReturnCode (EvNotExpr);      { nicht brauchbar }
  325.       END;
  326.       IF NOT Quit THEN           { => Changing TRUE, also }
  327.         EvHand^.WaitForEvent (EvAll, Ev);        { weiter }
  328.     UNTIL Quit;                      { bis endlich fertig }
  329.     LastEv := Ev;
  330.   END ELSE
  331.     SetReturnCode (CantWork); { Bedingungen nicht erfüllt }
  332. END;
  333.  
  334. PROCEDURE ActiveStandWin.StartChange;
  335. BEGIN
  336.   IF NOT Changing THEN BEGIN
  337.     Changing := TRUE;  Fra := Frame;
  338.     FraCol := FrCol;   BeginChange := TRUE;
  339.     Close;
  340.     BeginChange := FALSE;
  341.     SetFrame (1);
  342.     SetColors (15, TLCol, BLCol, ShaCol);
  343.     Open;
  344.     HideCursor;
  345.   END;
  346. END;
  347.  
  348. PROCEDURE ActiveStandWin.EndChange;
  349. BEGIN
  350.   IF Changing THEN BEGIN
  351.     Close;
  352.     SetFrame(Fra);
  353.     SetColors (FraCol, TLCol, BLCol, ShaCol);
  354.     Changing := FALSE;  FinishChange := TRUE;
  355.     Open;
  356.     FinishChange := FALSE;
  357.     ShowCursor;
  358.   END;
  359. END;
  360.  
  361. PROCEDURE ActiveStandWin.SetActive;
  362. BEGIN
  363.   Active := TRUE;
  364.   SetActiveData;
  365.   IF Opened THEN BEGIN
  366.     DrawFrame;
  367.     DrawTitles;
  368.   END;
  369. END;
  370.  
  371. PROCEDURE ActiveStandWin.SetActiveData;
  372. BEGIN
  373.   Frame := 2;   FrCol := 15;
  374.   TLCol := 15;  BLCol := 15;
  375.   Shadow:= TRUE;
  376. END;
  377.  
  378. PROCEDURE ActiveStandWin.SetPassive;
  379. BEGIN
  380.   Active := FALSE;
  381.   SetPassiveData;
  382.   IF Opened THEN BEGIN
  383.     DrawFrame;
  384.     DrawTitles;
  385.   END;
  386. END;
  387.  
  388. PROCEDURE ActiveStandWin.SetPassiveData;
  389. BEGIN
  390.   Frame := 1;  FrCol := 7;
  391.   TLCol := 7;  BLCol := 7;
  392.   Shadow:= FALSE;
  393. END;
  394.  
  395. PROCEDURE ActiveStandWin.SetKeys (SwKey, CK : WORD);
  396. BEGIN
  397.   SwitchKey := CtrlF5;  CloseKey  := CK;
  398. END;
  399.  
  400. PROCEDURE ActiveStandWin.SetMinLength (MXL, MYL : BYTE);
  401. BEGIN
  402.   IF MXL>10 THEN MinXL := MXL
  403.             ELSE MinXL := 10;
  404.   IF MYL>1  THEN MinYL := MYL
  405.             ELSE MinYL := 1;
  406. END;
  407.  
  408. PROCEDURE ActiveStandWin.SetSaveWinContent (Save:BOOLEAN);
  409. BEGIN
  410.   SaveWinContent := Save;
  411. END;
  412.  
  413. FUNCTION ActiveStandWin.ShiftPressed : BOOLEAN;
  414. BEGIN
  415.   ShiftPressed := ((EvHand^.KeyState AND RightShift)>0) OR
  416.                   ((EvHand^.KeyState AND LeftShift)>0);
  417. END;
  418.  
  419. FUNCTION ActiveStandWin.EnoughMemory : BOOLEAN;
  420.   VAR NeededMem : LONGINT;
  421. BEGIN
  422.   IF SaveWinContent THEN
  423.     NeededMem:= 4*VSM^.GetXLength*VSM^.GetYLength-
  424.                 Succ (x2-x1)*Succ (y2-y1)*2
  425.   ELSE
  426.     NeededMem := 2*VSM^.GetXLength*VSM^.GetYLength-
  427.                  Succ (x2-x1)*Succ (y2-y1)*2;
  428.   EnoughMemory := MemAvail>NeededMem;
  429. END;
  430.  
  431. FUNCTION ActiveStandWin.GetSaveWinContent : BOOLEAN;
  432. BEGIN
  433.   GetSaveWinContent := SaveWinContent;
  434. END;
  435.  
  436. FUNCTION ActiveStandWin.GetSwitchKey : WORD;
  437. BEGIN
  438.   GetSwitchKey := SwitchKey;
  439. END;
  440.  
  441. FUNCTION ActiveStandWin.GetClosingKey : WORD;
  442. BEGIN
  443.   GetClosingKey := CloseKey;
  444. END;
  445.  
  446. END.
  447. (* ----------------------------------------------------- *)
  448. (*                  Ende von ACTSTWI.PAS                 *)
  449. (* ----------------------------------------------------- *)
  450.