home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1988 / 02 / hyperkey / hyperkey.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1987-11-22  |  7.4 KB  |  129 lines
  1. (*---------------------------------------------------------------------------*)
  2. (*                             HYPERKEY.PAS  (v2.1)                          *)
  3. (*          Resident-Utility zur interaktiven Tastaturredefinition           *)
  4. (*          fuer MS-DOS-Systeme, Pascal-Compiler: Turbo Pascal 3.x           *)
  5. (*          (c) 1987   Karsten Gieselmann  &  PASCAL International           *)
  6. (*     Compilieren mit mIn=mAx free dynamic memory = $500 Paragraphen !      *)
  7. (*---------------------------------------------------------------------------*)
  8. {$C-,I-,K-,R-,U-,V-}                (* alle Compiler-Schalter desaktivieren! *)
  9. {$I REGS8088.INC}                         (* CPU-Registertyp aus PASCAL 8/87 *)
  10. {$I MAKEINT.INC}                       (* Interrupt-Handling aus PASCAL 8/87 *)
  11. {$I TSRWIND.INC}                          (* Window-Handling aus PASCAL 8/87 *)
  12. CONST Version   = 'HYPERKEY v2.1';
  13.       XWin = 15;  YWin = 1;        (* linke obere Ecke des HYPERKEY-Fensters *)
  14.       TSR_Char  = $54;          (* HYPERKEY-Aktivierungscode:  hier Shift-F1 *)
  15.       Old_Kbd   = $61;                        (* der alte Tastatur-Interrupt *)
  16.       TSR_Int   = $62;                           (* der neue Makro-Interrupt *)
  17.       TSRDseg   :INTEGER    =   0;                       (* TSR Data Segment *)
  18.       TSRSseg   :INTEGER    =   0;                      (* TSR Stack Segment *)
  19.       DosSseg   :INTEGER    =   0;                      (* DOS Stack Segment *)
  20.       TSR_InUse :BOOLEAN    = FALSE;                  (* Flag fuer Rekursion *)
  21.       TSR_IntIP :INTEGER    =   0;                 (* urspruenglicher IP Int *)
  22.       TSR_IntCs :INTEGER    =   0;                 (* urspruenglicher CS Int *)
  23.       StackSize :INTEGER    =   0;
  24.       Regs      :Regs8088_  = (AX:0; BX:0; CX:0; DX:0;       (* CPU-Register *)
  25.                                BP:0; SI:0; DI:0;
  26.                                DS:0; ES:0; Flags:0);
  27. VAR   SaveRegs      :Regs8088_;
  28.       HalfRegs      :Regs8088_ ABSOLUTE Regs;
  29.       TSR_terminate :BOOLEAN;
  30.       Segm,Offs     :INTEGER;
  31. (* ------------------------------------------------------------------------- *)
  32. (*     Der HYPERKEY-Tastaturtreiber mit allen zugehoerigen Deklarationen     *)
  33. CONST MaxMacroLen = 100;            (* Maximale Laenge eines Tastatur-Makros *)
  34. TYPE  Range       = 0..MaxMacroLen;
  35.       MacroType   = ARRAY [Range] OF INTEGER;
  36.       ListPtrType = ^EntryType;
  37.       EntryType   = RECORD                            (* Typ der Makro-Liste *)
  38.                        EntryNr, Scancode :INTEGER;
  39.                        Active            :BOOLEAN;
  40.                        Replacement       :MacroType;
  41.                        Last, Next        :ListPtrType
  42.                     END;
  43. VAR   Macro       :MacroType;                                (* Macro-Puffer *)
  44.       MacroLen    :INTEGER ABSOLUTE Macro;    (* Laenge des aktuellen Makros *)
  45.       MacroPtr    :INTEGER;                      (* Zeiger fuer Makro-Puffer *)
  46.       MacroRegs   :Regs8088_;                   (* Variable fuer Intr-Aufruf *)
  47.       ListHead,                        (* globale Variablen fuer Makro-Liste *)
  48.       ListEnd,
  49.       ListPtr,
  50.       SearchPtr   :ListPtrType;                    (* Zeiger fuer "MacroInt" *)
  51.  
  52. (*     diese Routine wird vor den aktuellen Tastatur-Interrupt gehaengt:     *)
  53. PROCEDURE MacroInt;
  54. VAR ShiftState :BYTE ABSOLUTE $0040:$0017;        (* Sondertasten-Statusbyte *)
  55. {$I BEGININT.INC}
  56.   WITH PgmRegs DO
  57.     CASE PgmAH OF                              (* welche Interrupt-Funktion? *)
  58.       0: IF MacroPtr <= MacroLen THEN BEGIN  (* liegen n. Makro-Zeichen vor? *)
  59.             PgmAX := Macro[MacroPtr];  MacroPtr := Succ(MacroPtr)
  60.          END
  61.          ELSE BEGIN        (* keine Makro-Zeichen, ueberpruefen auf Ersetzen *)
  62.             MacroRegs.AH := $00;
  63.             Intr (Old_Kbd, MacroRegs);        (* Zeichen von altem Interrupt *)
  64.             SearchPtr := ListHead;
  65.             WITH MacroRegs DO
  66.                WHILE (SearchPtr <> NIL) AND (AX <> SearchPtr^.Scancode) DO
  67.                   SearchPtr := SearchPtr^.Next;
  68.             IF (SearchPtr <> NIL) AND SearchPtr^.Active THEN BEGIN
  69.                Macro := SearchPtr^.Replacement;
  70.                PgmAX := Macro[1];                  (* ersten Code uebergeben *)
  71.                MacroPtr := 2
  72.             END
  73.             ELSE PgmAX := MacroRegs.AX
  74.          END;
  75.       1: IF MacroPtr <= MacroLen THEN BEGIN  (* liegen n. Makro-Zeichen vor? *)
  76.             PgmAL    := $00;
  77.             PgmFlags := PgmFlags AND $BF               (* Zero-Flag loeschen *)
  78.          END
  79.          ELSE BEGIN
  80.             MacroRegs.AH := $01;          Intr (Old_Kbd, MacroRegs);
  81.             PgmFlags := MacroRegs.Flags;  PgmAX := MacroRegs.AX
  82.          END;
  83.       2: PgmAL := ShiftState
  84.     END;
  85. {$I ENDINT.INC}
  86. (* ------------------------------------------------------------------------- *)
  87. (*       HYPERKEY:  Unterprogramm zur Manipulation von Tastaturmakros        *)
  88. PROCEDURE TSRPgm;
  89.    {$I HYPERKEY.DEC}                                    (* Deklarationen     *)
  90.    {$I HYPERKEY.UTL}                                    (* Utility-Routinen  *)
  91.    {$I HYPERKEY.HLP}                                    (* Hilfsbildschirme  *)
  92.    {$I HYPERKEY.LST}                                    (* Listenoperationen *)
  93.    {$I HYPERKEY.EDT}                                    (* der Makro-Editor  *)
  94.    {$I HYPERKEY.PGM}                                    (* das Hauptprogramm *)
  95. (* ------------------------------------------------------------------------- *)
  96. (*                    der Installationsteil von HYPERKEY                     *)
  97. {$I INTERRPT.301}                       (* Interrupt-Handler aus PASCAL 8/87 *)
  98. BEGIN
  99.    TSR_InUse := FALSE;  TSR_terminate := FALSE;
  100.    TSRDseg := DSeg;                   (* Data Segment Adresse des Interrupts *)
  101.    TSRSseg := SSeg;                  (* Stack Segment Adresse des Interrupts *)
  102.    LowVideo;  WriteLn;  WriteLn;
  103.    WriteLn (Version, '    (c) 1987  Karsten Gieselmann & PASCAL INT.');
  104.    IntGet (Old_Kbd, Segm, Offs);                   (* Interrupt-Vektor holen *)
  105.    IF Segm <> 0 THEN BEGIN                         (* und ueberpruefen       *)
  106.       WriteLn ('  Interrupt-Vektor Nr.', Old_Kbd,
  107.                ' schon benutzt - ',Version,' nicht resident!');
  108.       Halt;                                         (* Ende, Schluss, Aus !! *)
  109.    END;
  110.    IntGet (TSR_Int, Segm, Offs);                 (* den auch ueberpruefen !! *)
  111.    IF Segm <> 0 THEN BEGIN                         (* und ueberpruefen       *)
  112.       WriteLn ('  Interrupt-Vektor Nr.', TSR_Int,
  113.                ' schon benutzt - ',Version,' nicht resident!');
  114.       Halt;                                         (* Ende, Schluss, Aus !! *)
  115.    END;
  116.    IntGet (IntKeyBoard, Segm, Offs);           (* alten Tastaturvektor holen *)
  117.    IntSet (Old_Kbd, Segm, Offs);
  118.    IntSet (TSR_Int, Cseg, Ofs(MacroInt));      (* Makro-Treiber installieren *)
  119.    TSR_IntIP := MemW [0:TSR_Int*4];  TSR_IntCs := MemW [0:TSR_Int*4+2];
  120.    IntSet (IntKeyBoard, Cseg, Ofs(Interrpt));       (* HYPERKEY installieren *)
  121.    ListHead := NIL;            (* dynamische Listenverwaltung initialisieren *)
  122.    ListEnd  := NIL;   ListPtr  := NIL;
  123.    InitWindow;                             (* Window-Handling initialisieren *)
  124.    MacroPtr := MaxMacroLen;                 (* Makro-Handling initialisieren *)
  125.    MacroLen := 0;
  126.    WriteLn ('  ',Version,' installiert. Aktivieren mit Shift-<F1>...');
  127.    MakeResident;
  128. END.
  129.