Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!tut.cis.ohio-state.edu!ucbvax!agate!bionet!ames!amdcad!sun!pitstop!sundc!seismo!uunet!mcvax!hp4nl!eutrc3!wsinpp
From: wsinpp@eutrc3.UUCP (Peter Peters)
Newsgroups: comp.lang.pascal
Subject: Re: wanting a TP keyboard macro program hints?
Keywords: TSR, keyboard macro
Message-ID: <457@eutrc3.UUCP>
Date: 2 Feb 89 13:35:31 GMT
References: <8310@orstcs.CS.ORST.EDU> <368@lafcol.UUCP> <8549@orstcs.CS.ORST.EDU>
Organization: Tech. Univ. Eindhoven, Neth.
Lines: 166

How about the same program in Turbo Pascal, would
that be better ??
Comments are left out (mainly) because it's all the
same as the assembly "menumouse" you received.
Code follows behind the dotted line.

 -----------------------------------------------------

Program MenuMouse;
{ A-,B-,D-,E-,F-,I-,L-,N-,O-,R-,S-,V-}  (* speed up things *)
{$M 1024,0,0}                           (* minimum of space *)

{ Mouse Movement is mapped to up,down,left,right arrow keys
  Left Button  ==> <Esc>
  Right Button ==> <Enter>
}

Uses
  Dos;

Const
  fn_home        = $4700;
  fn_end         = $4f00;
  lt_arr         = $4b00;
  rt_arr         = $4d00;
  up_arr         = $4800;
  dn_arr         = $5000;
  carr_rtn       = $1c0d;
  esc_key        = $011b;

  mouse_int      = $33;
  get_butt_press = 5;
  read_mouse_mot = 11;
  set_subr_mask  = 12;
  set_sens       = 15;

  lt_button      = 0;
  rt_button      = 1;
  vert_sens      = 4;
  horiz_sens     = 10;

  buffer_segm    = $40;
  buffer_length  = $20;
  buffer_rd_ptr  = $1a;
  buffer_wrt_ptr = buffer_rd_ptr+2;
  buffer_start   = buffer_wrt_ptr+2;
  buffer_end     = buffer_start+buffer_length;
  horiz_pos      : Integer = 0;
  vert_pos       : Integer = 0;

Var
  Regs           : Registers;

Procedure Sti;
{Enable interrupts
 }
  Inline ($fb);

Procedure Retf_from_interrupt;
{Exit for the mousedriver call needed while the interrupt
 procedure ends with RETI and the driver expects RET FAR

 mov sp,bp; pop es; pop ds; pop di; pop si; pop dx;
 pop cx; pop bx; pop ax; ret far
 }
 Inline ($89/$ec/$5d/$07/$1f/$5f/$5e/$5a/$59/$5b/$58/$cb);

Procedure Enter (keystroke : word);
{Fake key entry in keyboard type ahead buffer
 }
Var
  next,curr : Word;
Begin
  curr := Memw[buffer_segm:buffer_wrt_ptr];
  next := curr+2;
  If next = buffer_end Then
    next := buffer_start;
  If next <> Memw[buffer_segm:buffer_rd_ptr] Then
    Begin
      Memw[buffer_segm:buffer_wrt_ptr] := next;
      Memw[buffer_segm:curr]  := keystroke;
  End;
End;

{$F+}
Procedure UserInputMask; Interrupt;
{Routine called every time a mouse movement or button
 is detected. The Interrupt directive is misused here
 to generate the required pushes to save all registers.
 To take care of a correct return to the caller, the
 procedure Retf_from_interrupt is used which pops the
 pushed registers and performs a retf instead of a reti.
 }
Begin
  Sti;

  Regs.AX := get_butt_press;
  Regs.BX := lt_button;
  Intr (mouse_int,Regs);
  If Regs.BX <> 0 Then
    Enter (esc_key)
  Else
    Begin
      Regs.AX := get_butt_press;
      Regs.BX := rt_button;
      Intr (mouse_int,Regs);
      If Regs.BX <> 0 Then
        Enter (carr_rtn)
      Else
        Begin
          Regs.AX := read_mouse_mot;
          Intr (mouse_int,Regs);

          horiz_pos := horiz_pos + Integer(Regs.CX);
          If Abs(horiz_pos) >= horiz_sens Then
            Begin
              If horiz_pos < 0 Then
                Enter (lt_arr)
              Else
                Enter (rt_arr);
              horiz_pos := 0;
            End;

            vert_pos := vert_pos + Integer(Regs.DX);
            If Abs(vert_pos) >= vert_sens Then
              Begin
                If vert_pos < 0 Then
                  Enter (up_arr)
                Else
                  Enter (dn_arr);
                vert_pos := 0;
              End;
        End;
    End;
  Retf_from_interrupt;
End;
{$F-}

Begin {Main}
  Regs.DX   := Ofs(UserInputMask);
  Regs.ES   := Seg(UserInputMask);
  Regs.AX   := set_subr_mask;
  Regs.CX   := $0b;
  Intr (mouse_int,Regs);

  Regs.AX   := set_sens;
  Regs.CX   := horiz_sens;
  Regs.DX   := vert_sens;
  Intr (mouse_int,Regs);

  (* restore the interrupt vectors to their state they
     were in before TP changed them, don't know if it's
     really necessary.
  *)
  Swapvectors;
  (* Terminate and stay resident *)
  Keep (0);
End.

--------------------------------------------------------

Hope it's of any use :-)

			Peter Peters.
			Eindhoven University of Technology
			Standard disclaimer blah blah....