Turbo Toolbox/Turbo_Toolbox.iso/1991/09_10/oop/saasched.pas

Pascal/Delphi Source File | 1991-06-12 | 8.6 KB | 292 lines

(* -----------------------------------------------------  *)
(*                    SAASCHED.PAS                        *)
(*                                                        *)
(*  SAAScheduler: Verwaltet maximal MaxItems von SAAItem  *)
(*  oder dessen Nachkommen. Anwendung: Siehe Demo.        *)
(*                                                        *)
(*          (c) 1991 by R.Reichert & TOOLBOX              *)
(* ------------------------------------------------------ *)
UNIT SAASched;

INTERFACE

USES MouKey, SAAItems;

CONST                    { Returncodes:                    }
  SchOk     =   0;       { alles Ok                        }
  SchFinish =   1;       { Scheduler beenden               }
  MaxItems  =  20;       { maximale Anzahl Items/Scheduler }
  Tab       =   9;
  ShiftTab  = 271;

TYPE
  ItemsArray = ARRAY [1..MaxItems] OF SAAItemPtr;

  SAASchedulerPtr = ^SAAScheduler;
  SAAScheduler    = OBJECT
    Items                          : ItemsArray;
    Active, Displayed, HKDisplayed : BOOLEAN;
    ActItem, ItemNum, SaveActItem  : WORD;
    ReturnCode                     : BYTE;

    CONSTRUCTOR Init;
    PROCEDURE   AddItem(NewItem : SAAItemPtr);     VIRTUAL;
    PROCEDURE   Open;                              VIRTUAL;
    PROCEDURE   Run;                               VIRTUAL;
    PROCEDURE   RunBy(ItNr : BYTE);                VIRTUAL;
    PROCEDURE   Display;                           VIRTUAL;
    PROCEDURE   DisplayHotKeys;                    VIRTUAL;
    PROCEDURE   Close;                             VIRTUAL;
    PROCEDURE   CheckEvent(VAR Ev : EventObj);     VIRTUAL;
    PROCEDURE   SetActive;                         VIRTUAL;
    PROCEDURE   SetPassive;                        VIRTUAL;
    PROCEDURE   SetDisplayedOff;                   VIRTUAL;
    PROCEDURE   SetXYRel(dx, dy : INTEGER);        VIRTUAL;
    PROCEDURE   SaveConfiguration;                 VIRTUAL;
    PROCEDURE   RestoreConfiguration;              VIRTUAL;

    FUNCTION    GetReturnCode : BYTE;              VIRTUAL;
    FUNCTION    IsActive : BOOLEAN;                VIRTUAL;
    FUNCTION    GetActiveItem : BYTE;              VIRTUAL;
    FUNCTION    GetItemNum : BYTE;                 VIRTUAL;
    FUNCTION    IsDisplayed : BOOLEAN;             VIRTUAL;
    FUNCTION    IsHKDisplayed : BOOLEAN;           VIRTUAL;
    FUNCTION    GetSaveItem : BYTE;                VIRTUAL;
    FUNCTION    GetItem(Nr : BYTE) : SAAItemPtr;   VIRTUAL;
    DESTRUCTOR  Done;                              VIRTUAL;
  END;

IMPLEMENTATION

  CONSTRUCTOR SAAScheduler.Init;
  BEGIN
    ReturnCode := 0;      Active      := FALSE;
    ItemNum    := 0;      ActItem     := 0;
    Displayed  := FALSE;  HKDisplayed := FALSE;
  END;

  PROCEDURE SAAScheduler.AddItem(NewItem : SAAItemPtr);
  BEGIN
    IF (NewItem <> NIL) AND (ItemNum < MaxItems) THEN BEGIN
      INC(ItemNum);  Items[ItemNum] := NewItem;
    END;
  END;

  PROCEDURE SAAScheduler.Open;
  BEGIN
    IF NOT Displayed THEN SaveConfiguration;
    Display;
    { dieser "Grundscheduler" hat noch keine Fenster o.ä. }
  END;

  PROCEDURE SAAScheduler.Run;
  BEGIN
    RunBy(1);
  END;

  PROCEDURE SAAScheduler.RunBy(ItNr : BYTE);
  VAR
    Ev   : EventObj;
    Quit : BOOLEAN;
  BEGIN
    IF ItemNum = 0 THEN Exit;
    IF NOT Displayed THEN Open;
    SetPassive;                    { altes Item passiv ... }
    ActItem := ItNr;  Quit := FALSE;
    Items[ActItem]^.SetActive;     { ... und neues aktiv   }
    REPEAT
      EvHand^.WaitForEvent(EvAll, Ev);
      CheckEvent(Ev);
      Quit := (ReturnCode = SchFinish);
                   { bis irgendein EndButton gewählt wurde }
    UNTIL Quit;
    ReturnCode := EndButPtr(Items[ActItem])^.GetSpecRC;
                  { den Endbutton-spezifischen Returncode  }
                  { übernehmen, siehe Demo                 }
  END;

  PROCEDURE SAAScheduler.Display;
  VAR
    i : BYTE;
  BEGIN
    IF ItemNum > 0 THEN BEGIN
      Displayed := TRUE;
      FOR i := 1 TO ItemNum DO Items[i]^.Display;
    END;
  END;

  PROCEDURE SAAScheduler.DisplayHotKeys;
  VAR
    i : BYTE;
  BEGIN
    IF Displayed THEN BEGIN
      HKDisplayed := TRUE;
      FOR i := 1 TO ItemNum DO Items[i]^.DisplayHotKey;
    END;
  END;

  PROCEDURE SAAScheduler.CLOSE;
  BEGIN
    { Kein Fenster vorhanden ! }  SetDisplayedOff;
  END;

  PROCEDURE SAAScheduler.CheckEvent(VAR Ev : EventObj);
  VAR
    i, j       : BYTE;
    Answer, RC : BYTE;
  BEGIN
    IF ItemNum > 0 THEN BEGIN
      ReturnCode := SchOk;
      Items[ActItem]^.CheckEvent(Ev);
      Answer := Items[ActItem]^.GetReturnCode;
               { kann das aktive Item das Event auswerten? }
      IF Answer = ItEvNotMine THEN BEGIN
        j := 0;
        FOR i := 1 TO ItemNum DO BEGIN  { nein, alle Items }
          Items[i]^.CheckEvent(Ev);     { durchlaufen      }
          RC := Items[i]^.GetReturnCode;
          IF RC <> ItEvNotMine THEN BEGIN
            j := i;
            Items[ActItem]^.SetPassive;
            ActItem := j;
            Items[ActItem]^.SetActive;
            IF RC = ItFinish THEN     { Endbutton gewählt? }
              ReturnCode := SchFinish;
          END;
        END;
        IF j = 0 THEN      { immer noch nicht ausgewertet? }
          IF Ev.EventType = EvKeyPressed THEN
            CASE Ev.Key OF
              Tab : BEGIN
                      Items[ActItem]^.SetPassive;
                      INC(ActItem);
                      IF ActItem > ItemNum THEN
                        ActItem := 1;
                      Items[ActItem]^.SetActive;
                    END;
              ShiftTab : BEGIN
                           Items[ActItem]^.SetPassive;
                           DEC(ActItem);
                           IF ActItem = 0 THEN
                             ActItem := ItemNum;
                           Items[ActItem]^.SetActive;
                         END;
            END
          ELSE
            IF (Ev.EventType = EvKeyState) AND
               (Ev.StateKey = Alt) THEN DisplayHotKeys;
      END ELSE
        IF Answer = ItFinish THEN
          ReturnCode := SchFinish;
                 { aktiver Button = angewählter Endbutton? }
    END;
  END;

  PROCEDURE SAAScheduler.SetActive;
  BEGIN
    IF ActItem > 0 THEN BEGIN
      Active := TRUE;
      Items[ActItem]^.SetActive;
    END;
  END;

  PROCEDURE SAAScheduler.SetPassive;
  BEGIN
    IF ActItem > 0 THEN BEGIN
      Active := FALSE;
      Items[ActItem]^.SetPassive;
    END;
  END;

  PROCEDURE SAAScheduler.SetXYRel(dx, dy : INTEGER);
  VAR
    i : BYTE;
  BEGIN
    IF ItemNum > 0 THEN BEGIN
      FOR i := 1 TO ItemNum DO    { alle Items durchlaufen }
        Items[i]^.SetXYRel(dx, dy);      { und verschieben }
      Items[ActItem]^.SetActive;
              { aktiven Item "aktivieren" => Cursor setzen }
    END;
  END;

  PROCEDURE SAAScheduler.SetDisplayedOff;
  BEGIN
    Displayed := FALSE;  HKDisplayed := FALSE;
  END;

  PROCEDURE SAAScheduler.SaveConfiguration;
  VAR
    i : BYTE;
  BEGIN
    IF ItemNum > 0 THEN BEGIN
      SaveActItem := ActItem;
      FOR i := 1 TO ItemNum DO Items[i]^.SaveConfiguration;
    END;
  END;

  PROCEDURE SAAScheduler.RestoreConfiguration;
  VAR
    i : BYTE;
  BEGIN
    IF ItemNum > 0 THEN BEGIN
      ActItem := SaveActItem;
      FOR i := 1 TO ItemNum DO Items[i]^.RestoreConfiguration;
    END;
  END;

  FUNCTION SAAScheduler.GetReturnCode : BYTE;
  BEGIN
    GetReturnCode := ReturnCode;
    ReturnCode    := SchOk;
  END;

  FUNCTION SAAScheduler.IsActive : BOOLEAN;
  BEGIN
    IsActive := Active;
  END;

  FUNCTION SAAScheduler.GetActiveItem : BYTE;
  BEGIN
    GetActiveItem := ActItem;
  END;

  FUNCTION SAAScheduler.GetItemNum : BYTE;
  BEGIN
    GetItemNum := ItemNum;
  END;

  FUNCTION SAAScheduler.IsDisplayed : BOOLEAN;
  BEGIN
    IsDisplayed := Displayed;
  END;

  FUNCTION SAAScheduler.IsHKDisplayed : BOOLEAN;
  BEGIN
    IsHKDisplayed := HKDisplayed;
  END;

  FUNCTION SAAScheduler.GetSaveItem : BYTE;
  BEGIN
    GetSaveItem := SaveActItem;
  END;

  FUNCTION SAAScheduler.GetItem(Nr : BYTE) : SAAItemPtr;
  BEGIN
    IF (Nr > 0) AND(Nr <= ItemNum) THEN
      GetItem := Items[Nr];
  END;

  DESTRUCTOR SAAScheduler.Done;
  VAR
    i : BYTE;
  BEGIN
    IF ItemNum > 0 THEN
      FOR i := 1 TO ItemNum DO        { Speicher der Items }
        DISPOSE(Items[i], Done);      { freigeben          }
  END;

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