Turbo Toolbox/Turbo_Toolbox.iso/dtx9302/tvision/tvpas/xmacro.pas

Pascal/Delphi Source File | 1992-11-10 | 24.4 KB | 995 lines

(* ------------------------------------------------------ *)
(*                     XMACRO.PAS                         *)
(*                                                        *)
(*  Makros, Makro-Listbox, -Statuszeile und -Applikation  *)
(*        (C) 1992 by Christian Ohr & DMV-Verlag          *)
(* ------------------------------------------------------ *)
{$R-,S-,I-,B-,D-,L-,V-,A+,F+,O+,X+}


UNIT XMacro;


INTERFACE


USES Objects, Drivers, Views, Dialogs, Menus, App,
     XDialogs;

CONST
  cmRecordMacro = 150;
  cmMacros      = 151;
  cmSaveMacros  = 152;
  cmLoadMacros  = 153;

  StreamName = 'KBCONST.STM';


TYPE
  pKeyRec = ^tKeyRec;
  tKeyRec = RECORD
    Key: pString;
    Value: WORD;
  END;


  (* in tKeyCol werden alle Tastennamen u. deren Scancode *)
  (* abgespeichert. Diese Daten werden zu Beginn aus      *)
  (* einem Stream (KBCONST.STM) geladen.                  *)

  pKeyCol = ^tKeyCol;
  tKeyCol = OBJECT(tStringCollection)
    PROCEDURE FreeItem (Item: POINTER); VIRTUAL;
    FUNCTION GetItem (VAR S: TStream): POINTER; VIRTUAL;
    PROCEDURE InsertKey (AKey: STRING; AValue: WORD);
    FUNCTION KeyOf (Item: POINTER): POINTER; VIRTUAL;
    PROCEDURE PutItem (VAR S: TStream; Item: POINTER);
                          VIRTUAL;
  END;



  (* tEvCol stellt eine Kollektion dar, in der Ereignis-  *)
  (* abfolgen mit einem Namen und Aufruf-Tastencode ver-  *)
  (* sehen abgespeichert werden                           *)

  pEvCol = ^tEvCol;
  tEvCol = OBJECT(tCollection)
    Title    : pString;
    ScanIndex: INTEGER;
    Delayed  : WORD;
    PlayIndex: INTEGER;
    EventMask: WORD;
    CONSTRUCTOR Init (ATitle: TTitleStr; AScanIndex:
                      INTEGER; ADelay, AEvMaskCode: WORD);
    DESTRUCTOR Done; VIRTUAL;
    CONSTRUCTOR Load (VAR S: tStream);
    PROCEDURE FreeItem(Item: POINTER); VIRTUAL;
    FUNCTION  GetItem(VAR S: TStream): POINTER; VIRTUAL;
    FUNCTION  GetNextEvent (VAR Event: tEvent): BOOLEAN;
    PROCEDURE InsertEvent(Event: tEvent);
    PROCEDURE PutItem(VAR S: TStream; Item: POINTER);
                          VIRTUAL;
    PROCEDURE Store (VAR S: tStream); VIRTUAL;
  END;


  (* tMacCol nimmt alle Event-Collections auf u. sortiert *)
  (* sie nach deren Macro-Namen.                          *)

  pMacCol = ^tMacCol;
  tMacCol = OBJECT(tSortedCollection)
    FUNCTION Compare(Key1, Key2: POINTER): INTEGER; VIRTUAL;
  END;


  (* tKeyColInputLine spezialisiert tColInputLine auf die *)
  (* Verarbeitung von tKeyCol-Objekten                    *)

  pKeyColInputLine = ^tKeyColInputLine;
  tKeyColInputLine = OBJECT(tColInputLine)
    FUNCTION At (AValue: INTEGER): pString; VIRTUAL;
    FUNCTION DataSize: WORD; VIRTUAL;
    PROCEDURE GetData (VAR Rec); VIRTUAL;
    FUNCTION IndexOf (P: pString): INTEGER; VIRTUAL;
    PROCEDURE SetData (VAR Rec); VIRTUAL;
  END;


  (* tMacro erledigt die gesamte Macroverwaltung. tMacro  *)
  (* bekommt Ereignisse von tMacroApplication.GetEvent    *)
  (* zugestellt und/oder gibt vorher aufgezeichnete       *)
  (* Ereignisse an die gleiche Methode ab.                *)

  pMacro = ^tMacro;
  tMacro = OBJECT(tObject)
    RecMacro   : pEvCol;
    PlayCol    : pCollection;
    MacroCol   : pMacCol;
    Break      : tEvent;
    CONSTRUCTOR Init;
    DESTRUCTOR Done; VIRTUAL;
    CONSTRUCTOR Load (VAR S: tStream);
    FUNCTION  BreakEvent (VAR Event: tEvent): BOOLEAN;
    FUNCTION  CurrentPlayer: pEvCol;
    FUNCTION  InitMacroDialog: pDialog; VIRTUAL;
    PROCEDURE MacroDialog;
    PROCEDURE Recorder (VAR Event: tEvent); VIRTUAL;
    PROCEDURE RecordMacro;
    FUNCTION  Replay  (VAR Event: tEvent): INTEGER; VIRTUAL;
    FUNCTION  ReplayHotKey(KeyCode: WORD): BOOLEAN; VIRTUAL;
    PROCEDURE Store (VAR S: tStream); VIRTUAL;
  END;


  (* tMacroListBox stellt Kollektionen vom Typ tMacCol    *)
  (* in einer ListBox dar.                                *)

  pMacroListBox = ^tMacroListBox;
  tMacroListBox = OBJECT(tListBox)
    CONSTRUCTOR Init (VAR Bounds: tRect;
                    AScrollBar: pScrollBar; AList: pMacCol);
    PROCEDURE GetData (VAR Rec); VIRTUAL;
    FUNCTION GetText (Item, MaxLen: INTEGER): STRING; VIRTUAL;
    PROCEDURE HandleEvent (VAR Event: tEvent); VIRTUAL;
    PROCEDURE SetData (VAR Rec); VIRTUAL;
  END;


  (* tMacroDialog ist die Schnittstelle zur Makro-        *)
  (* bearbeitung                                          *)

  pMacroDialog = ^tMacroDialog;
  tMacroDialog = OBJECT(tDialog)
    MacroListBox: pMacroListBox;
    CONSTRUCTOR Init (AList: pMacCol);
    CONSTRUCTOR Load (VAR S: tStream);
    PROCEDURE HandleEvent (VAR Event: tEvent); VIRTUAL;
    PROCEDURE Store (VAR S: tStream); VIRTUAL;
  END;


  (* Für Makroverarbeitung muß d. Applikation anstatt von *)
  (* tApplication von diesem Objekt abgeleitet werden.    *)

  pMacroApplication = ^tMacroApplication;
  tMacroApplication = OBJECT(tApplication)
    MacroObj : pMacro;
    Pending : tEvent;
    CONSTRUCTOR Init;
    FUNCTION EventAvail: BOOLEAN;
    PROCEDURE GetEvent(VAR Event: tEvent); VIRTUAL;
    PROCEDURE HandleEvent (VAR Event: tEvent); VIRTUAL;
    PROCEDURE Idle; VIRTUAL;
    PROCEDURE PutEvent(VAR Event: tEvent); VIRTUAL;
  END;


PROCEDURE LoadKeyStream;
PROCEDURE RegisterXMacro;


VAR
  KeyCol: pKeyCol;


CONST
  rKeyCol: tStreamRec = (
    ObjType: 1500;
    VmtLink: Ofs(TypeOf(tKeyCol)^);
    Load: @tKeyCol.Load;
    Store: @tKeyCol.Store
  );
  rEvCol: tStreamRec = (
    ObjType: 1501;
    VmtLink: Ofs(TypeOf(tEvCol)^);
    Load: @tEvCol.Load;
    Store: @tEvCol.Store
  );
  rMacCol: tStreamRec = (
    ObjType: 1502;
    VmtLink: Ofs(TypeOf(tMacCol)^);
    Load: @tMacCol.Load;
    Store: @tMacCol.Store
  );
  rKeyColInputLine: tStreamRec = (
    ObjType: 1503;
    VmtLink: Ofs(TypeOf(tKeyColInputLine)^);
    Load: @tKeyColInputLine.Load;
    Store: @tKeyColInputLine.Store
  );
  rMacroListBox: tStreamRec = (
    ObjType: 1504;
    VmtLink: Ofs(TypeOf(tMacroListBox)^);
    Load: @tMacroListBox.Load;
    Store: @tMacroListBox.Store
  );
  rMacro: tStreamRec = (
    ObjType: 1505;
    VmtLink: Ofs(TypeOf(tMacro)^);
    Load: @tMacro.Load;
    Store: @tMacro.Store
  );
  rMacroDialog: tStreamRec = (
    ObjType: 1506;
    VmtLink: Ofs(TypeOf(tMacroDialog)^);
    Load: @tMacroDialog.Load;
    Store: @tMacroDialog.Store
  );



IMPLEMENTATION

USES CRT, Fields, Memory, MsgBoxG;


CONST
  cmReplayMacro     = 10;
  cmEditMacro       = 12;
  cmNewMacro        = 13;
  cmDeleteMacro     = 154;
  cmDeleteAllMacros = 155;

TYPE
  tRecordMacro = RECORD
                   Title     : tTitleStr;
                   ScanIndex : INTEGER;
                   Delayed   : LONGINT;
                   EventMask : WORD;
                 END;

VAR
  RecMacDescr : tRecordMacro;
  EventAhead  : BOOLEAN;


FUNCTION CreateRecordDialog: pDialog;
VAR
  D: pDialog;
  C: pView;
  R: tRect;
BEGIN
  R.Assign(0, 0, 40, 16);
  D := New(pDialog, Init(R, 'Makro aufzeichnen'));
  WITH D^ DO BEGIN
    Options := Options OR ofCentered;

    R.Assign(3, 3, 32, 4);
    C := New(pKeyInputLine, Init(R, 80));
    Insert(C);
    R.Assign(2, 2, 15, 3);
    Insert(New(pXLabel, Init(R, 'Makro-~N~ame', C)));

    R.Assign(3, 7, 18, 8);
    C := New(pScrollBar, Init(R));
    Insert(C);
    R.Assign(3, 6, 18, 7);
    C := New(pKeyColInputLine, Init(R, 10,
                   pScrollBar(C), KeyCol));
    Insert(C);
    R.Assign(2, 5, 20, 6);
    Insert(New(pXLabel, Init(R, '~T~astenkombination', C)));

    R.Assign(3, 10, 15, 11);
    C := New(pNumInputLine, Init(R, 8, 0, 65535));
    Insert(C);
    R.Assign(2, 9, 19, 10);
    Insert(New(pXLabel, Init(R, '~V~erzögerung (ms)', C)));

    R.Assign(21, 9, 37, 11);
    Insert(New(pCheckBoxes, Init(R,
      NewSItem('~T~astatur',
      NewSItem('~M~ausklicks', NIL)))));

    R.Assign(14, 13, 24, 15);
    Insert(New(pButton, Init(R, 'O~K~', cmOk, bfDefault)));
    R.Move(12, 0); Inc(R.B.X);
    Insert(New(pButton, Init(R, 'Abbruch', cmCancel,
                             bfNormal)));
    SelectNext(FALSE);
  END;
  CreateRecordDialog := D;
END;



FUNCTION CreateEditDialog: pDialog;
VAR
  D: pDialog;
  C: pView;
  R: tRect;
BEGIN
  R.Assign(0, 0, 38, 16);
  D := New(pDialog, Init(R, 'Makro bearbeiten'));
  WITH D^ DO BEGIN
    Options := Options OR ofCentered;

    R.Assign(3, 3, 32, 4);
    C := New(pKeyInputLine, Init(R, 80));
    Insert(C);
    R.Assign(2, 2, 15, 3);
    Insert(New(pXLabel, Init(R, 'Makro-~N~ame', C)));

    R.Assign(3, 7, 18, 8);
    C := New(pScrollBar, Init(R));
    Insert(C);
    R.Assign(3, 6, 18, 7);
    C := New(pKeyColInputLine, Init(R, 10, pScrollBar(C),
                                    KeyCol));
    Insert(C);
    R.Assign(2, 5, 20, 6);
    Insert(New(pXLabel, Init(R, '~T~astenkombination', C)));

    R.Assign(3, 10, 15, 11);
    C := New(pNumInputLine, Init(R, 8, 0, 65535));
    Insert(C);
    R.Assign(2, 9, 19, 10);
    Insert(New(pXLabel, Init(R, '~V~erzögerung (ms)', C)));

    R.Assign(13, 13, 23, 15);
    Insert(New(pButton, Init(R, 'O~K~', cmOk, bfDefault)));
    R.Move(12, 0); Inc(R.B.X);
    Insert(New(pButton, Init(R, 'Abbruch', cmCancel,
                             bfNormal)));
    SelectNext(FALSE);
  END;
  CreateEditDialog := D;
END;



(* ------------------------------------------------------ *)
(*                       tKeyCol                          *)
(* ------------------------------------------------------ *)


PROCEDURE tKeyCol.FreeItem(Item: POINTER);
BEGIN
  DisposeStr(pKeyRec(Item)^.Key);
  FreeMem(Item, SizeOf(tKeyRec));
END;


FUNCTION tKeyCol.GetItem(VAR S: TStream): POINTER;
VAR
  P: pKeyRec;
BEGIN
  GetMem(P, SizeOf(tKeyRec));
  S.Read(P^.Value, SizeOf(WORD));
  P^.Key := S.ReadStr;
  GetItem := P;
END;


PROCEDURE tKeyCol.InsertKey(AKey: STRING; AValue: WORD);
VAR
  P: pKeyRec;
BEGIN
  P := New(pKeyRec);
  P^.Value := aValue;
  P^.Key := NewStr(AKey);
  Insert(P);
END;


FUNCTION tKeyCol.KeyOf(Item: POINTER): POINTER;
BEGIN
  KeyOf := pKeyRec(Item)^.Key;
END;


PROCEDURE tKeyCol.PutItem(VAR S: TStream; Item: POINTER);
BEGIN
  S.Write(pKeyRec(Item)^.Value, SizeOf(WORD));
  S.WriteStr(pKeyRec(Item)^.Key);
END;



(* ------------------------------------------------------ *)
(*                        tEvCol                          *)
(* ------------------------------------------------------ *)


CONSTRUCTOR tEvCol.Init (ATitle: tTitleStr;
                         AScanIndex: INTEGER;
                         ADelay, AEvMaskCode: WORD );
BEGIN
  TCollection.Init(20, 10);
  Title := NewStr(ATitle);
  ScanIndex := AScanIndex;
  Delayed := ADelay;
  EventMask := evNothing;
  IF AEvMaskCode AND 1 = 1 THEN
    EventMask := EventMask OR evKeyDown;
  IF AEvMaskCode AND 2 = 2 THEN
    EventMask := EventMask OR (evMouseDown + evMouseUp);
  PlayIndex := -1;
END;


DESTRUCTOR tEvCol.Done;
BEGIN
  DisposeStr(Title);
  TCollection.Done;
END;


CONSTRUCTOR tEvCol.Load (VAR S: tStream);
BEGIN
  tCollection.Load(S);
  Title := S.ReadStr;
  S.Read(ScanIndex, SizeOf(INTEGER));
  S.Read(Delayed, SizeOf(WORD));
  S.Read(EventMask, SizeOf(WORD));
  PlayIndex := -1;
END;


PROCEDURE tEvCol.FreeItem(Item: POINTER);
BEGIN
  Dispose(pEvent(Item));
END;


FUNCTION tEvCol.GetItem(VAR S: tStream): POINTER;
VAR
  P: pEvent;
BEGIN
  P := New(pEvent);
  S.Read(P^, SizeOf(tEvent));
  GetItem := P;
END;


FUNCTION tEvCol.GetNextEvent (VAR Event: tEvent): BOOLEAN;
BEGIN
  IF PlayIndex < Pred(Count) THEN BEGIN
    Inc(PlayIndex);
    Event := pEvent(At(PlayIndex))^;
    GetNextEvent := TRUE;
  END ELSE BEGIN
    PlayIndex := -1;
    Event.What := evNothing;
    GetNextEvent := FALSE;
  END;
END;


PROCEDURE tEvCol.InsertEvent(Event: tEvent);
VAR
  P: pEvent;
BEGIN
  P := New(PEvent);
  P^ := Event;
  Insert(P);
END;


PROCEDURE tEvCol.PutItem(VAR S: tStream; Item: POINTER);
BEGIN
  S.Write(pEvent(Item)^, SizeOf(tEvent));
END;


PROCEDURE tEvCol.Store (VAR S: tStream);
BEGIN
  tCollection.Store(S);
  S.WriteStr(Title);
  S.Write(ScanIndex, SizeOf(INTEGER));
  S.Write(Delayed, SizeOf(WORD));
  S.Write(EventMask, SizeOf(WORD));
END;



(* ------------------------------------------------------ *)
(*                      tMacCol                           *)
(* ------------------------------------------------------ *)


FUNCTION tMacCol.Compare(Key1, Key2: POINTER): INTEGER;
BEGIN
  IF pEvCol(Key1)^.Title^ < pEvCol(Key2)^.Title^ THEN
    Compare := -1 ELSE
    IF pEvCol(Key1)^.Title^ = pEvCol(Key2)^.Title^ THEN
      Compare := 0 ELSE
      Compare := 1;
END;



(* ------------------------------------------------------ *)
(*                  tKeyColInputLine                      *)
(* ------------------------------------------------------ *)


FUNCTION tKeyColInputLine.At (AValue: INTEGER): pString;
BEGIN
  IF (AValue >= Limit.X) AND (AValue <= Limit.Y) THEN
    At := pKeyRec(Col^.At(AValue))^.Key;
END;


FUNCTION tKeyColInputLine.DataSize: WORD;
BEGIN
  DataSize := SizeOf(INTEGER);
END;


PROCEDURE tKeyColInputLine.GetData (VAR Rec);
BEGIN
  INTEGER(Rec) := Value;
END;


FUNCTION tKeyColInputLine.IndexOf(P: pString): INTEGER;
VAR
  T: tKeyRec;
  Index: INTEGER;
BEGIN
  T.Key := P;
  Index := Col^.IndexOf(@T);
  IF Index = -1 THEN
    IndexOf := OutOfRange ELSE
    IndexOf := Index;
END;


PROCEDURE tKeyColInputLine.SetData (VAR Rec);
BEGIN
  Value := INTEGER(Rec);
  Data^ := pKeyRec(Col^.At(Value))^.Key^;
END;



(* ------------------------------------------------------ *)
(*                       tMacro                           *)
(* ------------------------------------------------------ *)


CONSTRUCTOR tMacro.Init;
BEGIN
  tObject.Init;
  MacroCol := New(pMacCol, Init(10, 5));
  PlayCol := New(pCollection, Init(5, 1));
  RecMacro := NIL;
  Break.What := evKeyDown;
  Break.KeyCode := kbGrayMinus;
  IF LowMemory THEN BEGIN
    Application^.OutOfMemory;
    Application^.DisableCommands([cmRecordMacro..
                                  cmLoadMacros]);
    Fail;
  END;
END;


DESTRUCTOR tMacro.Done;
BEGIN
  tObject.Done;
  IF MacroCol <> NIL THEN Dispose(MacroCol, Done);
  IF PlayCol <> NIL THEN Dispose(PlayCol, Done);
  IF RecMacro <> NIL THEN Dispose(RecMacro, Done);
END;


CONSTRUCTOR tMacro.Load (VAR S: tStream);
BEGIN
  MacroCol := pMacCol(S.Get);
  PlayCol := New(pCollection, Init(5, 1));
  RecMacro := NIL;
END;


FUNCTION tMacro.BreakEvent (VAR Event: tEvent): BOOLEAN;
BEGIN
  BreakEvent := FALSE;
  IF (Event.What = Break.What) AND
     (Event.KeyCode = Break.KeyCode) THEN BEGIN
    Sound(800);
    Delay(40);
    NoSound;
    Event.What := evNothing;
    BreakEvent := TRUE
  END;
END;


FUNCTION tMacro.CurrentPlayer: pEvCol;
BEGIN
  IF PlayCol^.Count > 0 THEN
    CurrentPlayer:= pEvCol(PlayCol^.At(
                      Pred(PlayCol^.Count))) ELSE
    CurrentPlayer:= NIL;
END;


FUNCTION tMacro.InitMacroDialog: pDialog;
BEGIN
  InitMacroDialog := New(pMacroDialog, Init(MacroCol));
END;


PROCEDURE tMacro.MacroDialog;
VAR
  Result  : WORD;
  Index   : INTEGER;
  EvColPtr: pEvCol;

  PROCEDURE EditMacro;
  BEGIN
    WITH RecMacDescr DO BEGIN
      Title := EvColPtr^.Title^;
      ScanIndex := EvColPtr^.ScanIndex;
      Delayed := EvColPtr^.Delayed;
      IF ExecDialog(CreateEditDialog, @RecMacDescr)
         <> cmCancel THEN BEGIN
        DisposeStr(EvColPtr^.Title);
        EvColPtr^.Title := NewStr(Title);
        EvColPtr^.ScanIndex := ScanIndex;
        EvColPtr^.Delayed := Delayed;
      END;
    END;
  END;

BEGIN
  Index := 0;
  Result := ExecDialog(InitMacroDialog, @EvColPtr);
  IF Result <> cmCancel THEN
    IF EvColPtr <> NIL THEN
      CASE Result OF
        cmReplayMacro: PlayCol^.Insert(EvColPtr);
        cmEditMacro  : EditMacro;
        cmNewMacro   : RecordMacro;
      END;
END;


PROCEDURE tMacro.Recorder (VAR Event: TEvent);
VAR
  Index: INTEGER;
BEGIN
  IF RecMacro <> NIL THEN
    IF NOT BreakEvent(Event) THEN BEGIN
      IF (Event.What AND RecMacro^.EventMask <> 0) AND
         (PlayCol^.Count = 0) THEN BEGIN
        RecMacro^.InsertEvent(Event);
        IF LowMemory THEN BEGIN
          Application^.OutOfMemory;
          Application^.PutEvent(Break);
        END;
      END
    END ELSE BEGIN
      MacroCol^.Insert(RecMacro);
      RecMacro := NIL;
    END;
END;


PROCEDURE tMacro.RecordMacro;
VAR
  Ok: BOOLEAN;
  Index: INTEGER;
BEGIN
  FillChar(RecMacDescr, SizeOf(tRecordMacro), 0);
  REPEAT
    Ok := TRUE;
    IF ExecDialog(CreateRecordDialog, @RecMacDescr)
       <> cmCancel THEN
      WITH RecMacDescr DO
        IF EventMask <> 0 THEN BEGIN
          RecMacro := New(pEvCol, Init(Title, ScanIndex,
                          Delayed, EventMask));
          IF LowMemory THEN
            Application^.OutOfMemory ELSE BEGIN
              Ok := NOT MacroCol^.Search(RecMacro, Index);
              IF NOT Ok THEN BEGIN
                MessageBox(#13#3'Makro-Name schon belegt!',
                           NIL, mfError + mfOkButton);
                Dispose(RecMacro, Done);
                RecMacro := NIL;
              END;
            END;
        END;
  UNTIL Ok;
END;


FUNCTION tMacro.Replay (VAR Event: TEvent): INTEGER;
BEGIN
  Replay := PlayCol^.Count;
  IF PlayCol^.Count > 0 THEN
    IF CurrentPlayer^.GetNextEvent(Event) THEN
      Delay(CurrentPlayer^.Delayed) ELSE
      PlayCol^.Delete(CurrentPlayer)
  ELSE Event.What := evNothing;
END;


FUNCTION tMacro.ReplayHotKey (KeyCode: WORD): BOOLEAN;
VAR
  EvColPtr: pEvCol;

  FUNCTION GetIndex (P: pEvCol): BOOLEAN; FAR;
  BEGIN
    GetIndex := pKeyRec(KeyCol^.At(P^.ScanIndex))^.Value
              = KeyCode;
  END;

BEGIN
  ReplayHotKey := TRUE;
  EvColPtr := MacroCol^.FirstThat(@GetIndex);
  IF EvColPtr <> NIL THEN
    PlayCol^.Insert(EvColPtr) ELSE
    ReplayHotKey := FALSE;
END;


PROCEDURE tMacro.Store (VAR S: tStream);
BEGIN
  S.Put(MacroCol);
END;



(* ------------------------------------------------------ *)
(*                    tMacroListBox                       *)
(* ------------------------------------------------------ *)


CONSTRUCTOR tMacroListBox.Init (VAR Bounds: tRect;
                    AScrollBar: pScrollBar; AList: pMacCol);
VAR
  R: tRect;
  C: pScrollBar;
BEGIN
  IF AList = NIL THEN Fail;
  tListBox.Init(Bounds, 1, AScrollBar);
  NewList(AList);
END;


PROCEDURE tMacroListBox.GetData (VAR Rec);
BEGIN
  IF List^.Count > 0 THEN
    pEvCol(Rec) := pEvCol(List^.At(Focused)) ELSE
    pEvCol(Rec) := NIL;
END;


FUNCTION tMacroListBox.GetText (Item, MaxLen: INTEGER)
                               : STRING;
VAR
  Result: STRING;
  Params: ARRAY[0..1] OF POINTER;
BEGIN
  Params[0] := pEvCol(List^.At(Item))^.Title;
  Params[1] := pKeyRec(KeyCol^.At(pEvCol(
                List^.At(Item))^.ScanIndex))^.Key;
  FormatStr(Result, '%-18s %-12s', Params);
  GetText := Copy(Result, 1, MaxLen);
END;


PROCEDURE TMacroListBox.HandleEvent(VAR Event: TEvent);
BEGIN
  IF (Event.What = evMouseDown) AND (Event.DOUBLE) THEN
  BEGIN
    Event.What := evCommand;
    Event.Command := cmOK;
    PutEvent(Event);
    ClearEvent(Event);
  END ELSE TListBox.HandleEvent(Event);
END;


PROCEDURE tMacroListBox.SetData (VAR Rec);
BEGIN
END;



(* ------------------------------------------------------ *)
(*                     tMacroDialog                       *)
(* ------------------------------------------------------ *)


CONSTRUCTOR tMacroDialog.Init (AList: pMacCol);
VAR
  R: tRect;
  C: pView;
BEGIN
  R.Assign(0, 0, 57, 17);
  tDialog.Init(R, 'Makros');

  Options := Options OR ofCentered;

  R.Assign( 36, 3, 37, 14);
  C := New(pScrollBar, Init(R));
  Insert(C);

  R.Assign( 3, 3, 36, 14);
  MacroListBox := New(pMacroListBox, Init(R, pScrollBar(C),
                                          AList));
  Insert(MacroListBox);
  R.Assign( 2, 2, 12, 3);
  Insert(New(pXLabel, Init(R, '~M~akros', C)));

  R.Assign(38, 3, 55, 5);
  Insert(New(pButton, Init(R, ' ~A~usführen', cmReplayMacro,
                           bfDefault + bfLeftJust)));
  R.Move(0, 2);
  Insert(New(pButton, Init(R, ' ~B~earbeiten', cmEditMacro,
                           bfNormal + bfLeftJust)));
  R.Move(0, 2);
  Insert(New(pButton, Init(R, ' ~N~eu', cmNewMacro,
                           bfNormal + bfLeftJust)));
  R.Move(0, 2);
  Insert(New(pButton, Init(R, ' ~L~öschen', cmDeleteMacro,
                           bfNormal + bfLeftJust)));
  R.Move(0, 2);
  Insert(New(pButton, Init(R, ' A~l~le löschen',
        cmDeleteAllMacros, bfNormal + bfLeftJust)));
  R.Move(0, 2);
  Insert(New(pButton, Init(R, ' Abbruch', cmCancel,
                           bfNormal + bfLeftJust)));
  SelectNext(FALSE);
END;


CONSTRUCTOR tMacroDialog.Load (VAR S: tStream);
BEGIN
  tDialog.Load(S);
  GetSubViewPtr(S, MacroListBox);
END;


PROCEDURE tMacroDialog.HandleEvent (VAR Event: tEvent);
VAR
  EvColPtr: pEvCol;
BEGIN
  tDialog.HandleEvent(Event);
  IF (Event.What = evCommand) THEN
    WITH MacroListBox^ DO BEGIN
      CASE Event.Command OF
        cmDeleteAllMacros:
          List^.FreeAll;
        cmDeleteMacro:
          BEGIN
            GetData(EvColPtr);
            IF EvColPtr <> NIL THEN List^.Free(EvColPtr);
          END;
        ELSE
          Exit;
      END;
      SetRange(List^.Count);     (* wird meist vergessen! *)
      DrawView;
      ClearEvent(Event);
    END;
END;


PROCEDURE tMacroDialog.Store (VAR S: tStream);
BEGIN
  tDialog.Store(S);
  PutSubViewPtr(S, MacroListBox);
END;



(* ------------------------------------------------------ *)
(*                  tMacroApplication                     *)
(* ------------------------------------------------------ *)


CONSTRUCTOR tMacroApplication.Init;
BEGIN
  tApplication.Init;
  MacroObj := NIL;
  Pending.What := evNothing;
END;


FUNCTION tMacroApplication.EventAvail : BOOLEAN;
BEGIN
  IF MacroObj <> NIL THEN
    EventAvail := tApplication.EventAvail AND
                  (MacroObj^.CurrentPlayer <> NIL) ELSE
    EventAvail := tApplication.EventAvail;
END;


PROCEDURE tMacroApplication.GetEvent (VAR Event: tEvent);

  FUNCTION ContainsMouse (P: pView): BOOLEAN; FAR;
  BEGIN
    ContainsMouse := (P^.State AND sfVisible <> 0) AND
                      P^.MouseInView(Event.Where);
  END;

BEGIN
  IF MacroObj <> NIL THEN BEGIN
    IF Pending.What <> evNothing THEN BEGIN
      Event := Pending;
      Pending.What := evNothing;
    END ELSE IF MacroObj^.Replay(Event) = 0 THEN BEGIN
      GetMouseEvent(Event);
      IF Event.What = evNothing THEN BEGIN
        GetKeyEvent(Event);
        IF Event.What = evNothing THEN Idle;
      END;
      MacroObj^.Recorder(Event);
    END;
    IF StatusLine <> NIL THEN
      IF (Event.What AND evKeyDown <> 0) OR
         (Event.What AND evMouseDown <> 0) AND
         (FirstThat(@ContainsMouse) = pView(StatusLine))
        THEN StatusLine^.HandleEvent(Event);
  END ELSE tApplication.GetEvent(Event);
END;


PROCEDURE tMacroApplication.HandleEvent (VAR Event: tEvent);
BEGIN
  IF (MacroObj <> NIL) AND (Event.What = evKeyDown) THEN
    IF MacroObj^.ReplayHotKey(Event.KeyCode) THEN
      ClearEvent(Event);
  tApplication.HandleEvent(Event);
END;


PROCEDURE tMacroApplication.Idle;
BEGIN
  tApplication.Idle;
  IF MacroObj <> NIL THEN
    IF MacroObj^.RecMacro <> NIL THEN
      DisableCommands([cmRecordMacro, cmSaveMacros,
                       cmLoadMacros]) ELSE
      EnableCommands([cmRecordMacro, cmSaveMacros,
                    cmLoadMacros]);
END;


PROCEDURE tMacroApplication.PutEvent (VAR Event: TEvent);
BEGIN
  Pending := Event;
END;




PROCEDURE LoadKeyStream;
VAR
  KeyStream: tDosStream;
BEGIN
  KeyStream.Init(StreamName, stOpenRead);
  KeyCol := pKeyCol(KeyStream.Get);
  IF KeyStream.Status <> stOk THEN BEGIN
    PrintStr('KBCONST.STM nicht gefunden.');
    Halt(1);
  END;
  KeyStream.Done;
END;


PROCEDURE RegisterXMacro;
BEGIN
  RegisterType(rKeyCol);
  RegisterType(rEvCol);
  RegisterType(rMacCol);
  RegisterType(rKeyColInputLine);
  RegisterType(rMacroListBox);
  RegisterType(rMacro);
  RegisterType(rMacroDialog);
END;


END.


(* ------------------------------------------------------ *)
(*                 Ende von XMACRO.PAS                    *)