home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / CLIPPER / NFSRC.ZIP / PUTKEY.ASM < prev    next >
Encoding:
Assembly Source File  |  1991-08-16  |  10.3 KB  |  233 lines
  1. ; File......: PUTKEY.ASM
  2. ; Author....: Ted Means
  3. ; Date......: $Date:   15 Aug 1991 23:07:10  $
  4. ; Revision..: $Revision:   1.2  $
  5. ; Log file..: $Logfile:   E:/nanfor/src/putkey.asv  $
  6. ; 
  7. ; This is an original work by Ted Means and is placed in the
  8. ; public domain.
  9. ;
  10. ; Modification history:
  11. ; ---------------------
  12. ;
  13. ; $Log:   E:/nanfor/src/putkey.asv  $
  14. ;  
  15. ;     Rev 1.2   15 Aug 1991 23:07:10   GLENN
  16. ;  Forest Belt proofread/edited/cleaned up doc
  17. ;  
  18. ;     Rev 1.1   14 Jun 1991 19:54:56   GLENN
  19. ;  Minor edit to file header
  20. ;  
  21. ;     Rev 1.0   01 Apr 1991 01:03:48   GLENN
  22. ;  Nanforum Toolkit
  23. ;  
  24.  
  25. ; $DOC$
  26. ; $FUNCNAME$
  27. ;     FT_PUTKEY()
  28. ; $CATEGORY$
  29. ;     Keyboard/Mouse
  30. ; $ONELINER$
  31. ;     Stuff a keystroke into the keyboard buffer
  32. ; $SYNTAX$
  33. ;     FT_PUTKEY( <nKeyValue> ) -> lResult
  34. ; $ARGUMENTS$
  35. ;     <nKeyValue> is the INKEY() value of the keystroke to be stuffed.
  36. ; $RETURNS$
  37. ;    .T. if the keystroke was put into the keyboard buffer.
  38. ;    .F. if nKeyValue was invalid or the buffer was full.
  39. ; $DESCRIPTION$
  40. ;    This function is similar to the KEYBOARD command, with a few
  41. ;    exceptions. First, this function does not clear the keyboard buffer
  42. ;    before inserting the keystroke.  In addition, since it uses the
  43. ;    Inkey() value, you can stuff any key, including function keys, into
  44. ;    the keyboard buffer. However, this also means that unlike the KEYBOARD
  45. ;    command, you can only stuff one keystroke at a time.
  46. ;
  47. ;    You can easily create a User-Defined Command that makes this function
  48. ;    even more like the KEYBOARD command.  For example,
  49. ;
  50. ;        #command KEYSTROKE <key> => FT_PUTKEY( <key> )
  51. ;
  52. ;    will create a command called KEYSTROKE that could be used as a
  53. ;    companion command to KEYBOARD.  The only difference is that it would
  54. ;    insert a single keystroke instead of a string.
  55. ;
  56. ;    Be aware that early releases of Clipper 5.0 have a bug in their
  57. ;    keyboard handling.  Among other things, Set Typeahead does not work
  58. ;    correctly, so this function may at times return .T. even though the
  59. ;    keyboard buffer is full.  The best solution is not to attempt stuffing
  60. ;    more than 15 keys at a time into the keyboard buffer.
  61. ;
  62. ;    This function is written to adhere to Turbo Assembler's IDEAL mode.
  63. ;    To use another assembler, rearrange the SEGMENT and PROC directives
  64. ;    and make any other necessary changes to the source code.
  65. ; $EXAMPLES$
  66. ;      FT_PUTKEY( -9 )   //  Stuff the F10 key
  67. ;      FT_PUTKEY( 276 )  //  Stuff the Alt T key
  68. ;      KEYSTROKE 28      //  Stuff the F1 key using a User-Defined Command
  69. ; $END$
  70.  
  71.  
  72.          IDEAL
  73.  
  74. Public   FT_PUTKEY
  75.  
  76. EXTRN    __PARINFO:FAR
  77. EXTRN    __PARNI:FAR
  78. EXTRN    __RETL:FAR
  79.  
  80. SEGMENT  _NANFOR   WORD      PUBLIC    "CODE"
  81.          ASSUME    CS:_NANFOR
  82.  
  83. PROC     FT_PUTKEY  FAR
  84.  
  85.          XOR       AX,AX                     ; PREPARE TO COUNT PARAMS
  86.          PUSH      AX                        ; SAVE ON STACK
  87.          CALL      __PARINFO                 ; GET PARAM COUNT
  88.          ADD       SP,2                      ; REALIGN STACK
  89.          OR        AX,AX                     ; ZERO PARAMS?
  90.          JNZ       TEST1                     ; IF NOT, CONTINUE
  91.          JMP       DONE                      ; RETURN VALUE = FALSE, GO TO END
  92.  
  93. TEST1:   MOV       AX,1                      ; PREPARE TO CHECK PARAMETER #1
  94.          PUSH      AX                        ; SAVE PARAMETER # ON STACK
  95.          CALL      __PARINFO                 ; CALL PARAMETER INFO ROUTINE
  96.          ADD       SP,2                      ; REALIGN STACK
  97.          TEST      AX,2                      ; IS PARAMETER NUMERIC?
  98.          JNZ       GET1                      ; IF SO, CONTINUE
  99. BADPARAM:XOR       AX,AX                     ; SET RETURN VALUE TO FALSE
  100.          JMP       DONE                      ; GO TO END
  101.  
  102. GET1:    MOV       AX,1                      ; PREPARE TO RETRIEVE PARAMETER #1
  103.          PUSH      AX                        ; SAVE PARAMETER # ON STACK
  104.          CALL      __PARNI                   ; RETRIEVE PARAMETER
  105.          ADD       SP,2                      ; REALIGN STACK
  106.  
  107.          CMP       AX,385                    ; TEST HIGHEST INKEY()
  108.          JG        BadParam                  ; Bad INKEY() value
  109.          Cmp       AX,-39                    ; Test lowest INKEY()
  110.          JL        BadParam                  ; Process error
  111.  
  112. CtrlF1:  Mov       CL,0                      ; Set ASCII value to null
  113.          Cmp       AX,-10                    ; Is Ctrl F1 thru Alt F10?
  114.          JG        F2                        ; If not, check next range
  115.          Neg       AX                        ; Get absolute value of AX
  116.          Add       AL,74                     ; Translate INKEY() to scan code
  117.          Mov       CH,AL                     ; Move scan code to CH
  118.          JMP       StuffIt                   ; Stuff the keystroke
  119.  
  120. F2:      Or        AX,AX                     ; See if key is F2 thru F10
  121.          JNS       F1                        ; If not, check next range
  122.          Neg       AX                        ; Get absolute value of AX
  123.          Add       AL,59                     ; Translate INKEY() to scan code
  124.          Mov       CH,AL                     ; Move scan code to CH
  125.          JMP       StuffIt                   ; Stuff the keystroke
  126.  
  127. F1:      Cmp       AX,28                     ; See if key is F1
  128.          JNE       CtrlF                     ; If not, check next key
  129.          Mov       CH,59                     ; Supply scan code for F1
  130.          JMP       StuffIt                   ; Stuff the keystroke
  131.  
  132. CtrlF:   Cmp       AX,6                      ; See if key is Ctrl F or End
  133.          JNE       CtrlW                     ; If not, check next key
  134.          Mov       CH,79                     ; Supply scan code for End
  135.          JMP       StuffIt                   ; Stuff the keystroke
  136.  
  137. CtrlW:   Cmp       AX,23                     ; See if key is Ctrl W or Ctrl End
  138.          JNE       CtrlHome                  ; If not, check next key
  139.          Mov       CH,117                    ; Supply scan code for Ctrl End
  140.          JMP       Short StuffIt             ; Stuff the keystroke
  141.  
  142. CtrlHome:Cmp       AX,29                     ; See if key is Ctrl Home or Ctrl]
  143.          JNE       CtrlV                     ; If not, check next key
  144.          Mov       CH,119                    ; Supply scan code for Ctrl Home
  145.          JMP       Short StuffIt             ; Stuff the keystroke
  146.  
  147. CtrlV:   Cmp       AX,22                     ; See if key is Ins or Ctrl V
  148.          JNE       ShiftTab                  ; If not, check next key
  149.          Mov       CH,82                     ; Supply scan code for Ctrl V
  150.          JMP       Short StuffIt             ; Stuff the keystroke
  151.  
  152. ShiftTab:Cmp       AX,271                    ; See if key is Shift Tab
  153.          JNE       CtrlPgDn                  ; If not, check next key
  154.          Mov       CH,15                     ; Supply scan code for Shift Tab
  155.          JMP       Short StuffIt             ; Stuff the keystroke
  156.  
  157. CtrlPgDn:Cmp       AX,30                     ; See if key is Ctrl PgDn
  158.          JNE       CtrlPgUp                  ; If not, check next key
  159.          Mov       CH,118                    ; Supply scan code for Ctrl PgDn
  160.          JMP       Short StuffIt             ; Stuff the keystroke
  161.  
  162. CtrlPgUp:Cmp       AX,31                     ; See if key is Ctrl PgUp
  163.          JNE       AltQ                      ; If not, check next key
  164.          Mov       CH,132                    ; Supply scan code for Ctrl PgUp
  165.          JMP       Short StuffIt             ; Stuff the keystroke
  166.  
  167. AltQ:    Cmp       AX,272                    ; See if key is Alt Q . . .
  168.          JL        ASCII
  169.          Cmp       AX,281                    ; . . . thru Alt P
  170.          JG        AltA
  171.          Mov       CH,AL
  172.          JMP       Short StuffIt
  173.  
  174. AltA:    Cmp       AX,286                    ; See if key is Alt A . . .
  175.          JNL       AltL
  176.          JMP       BadParam
  177. AltL:    Cmp       AX,294                    ; . . . thru Alt L
  178.          JG        AltZ
  179.          Mov       CH,AL
  180.          JMP       Short StuffIt
  181.  
  182. AltZ:    Cmp       AX,300                    ; See if key is Alt Z . . .
  183.          JNL       AltM
  184.          JMP       BadParam
  185. AltM:    Cmp       AX,306                    ; . . . thru Alt M
  186.          JG        Alt1
  187.          Mov       CH,AL
  188.          Mov       CL,0
  189.          JMP       Short StuffIt
  190.  
  191. Alt1:    Cmp       AX,376                    ; See if key is Alt 1 . . .
  192.          JNL       AltNum
  193.          JMP       BadParam
  194. AltNum:  Mov       CH,AL
  195.          Mov       CL,0
  196.          JMP       Short StuffIt
  197.  
  198. ASCII:   Or        AH,AH                     ; See if key is plain ASCII
  199.          JZ        Okay
  200.          JMP       BadParam
  201. Okay:    Mov       CX,AX
  202.  
  203. StuffIt: CLI                                 ; Disable keyboard temporarily
  204.          Push      DS                        ; Save DS
  205.          Xor       AX,AX                     ; Clear AX
  206.          Mov       DS,AX                     ; Point DS to low RAM
  207.          Mov       AX,[Word Ptr 41Ch]        ; Get tail pointer
  208.          Add       AX,2                      ; Make room for keystroke
  209.          Cmp       AX,3Eh                    ; Need to wrap?
  210.          JNE       IsItFull                  ; No, so continue
  211.          Mov       AX,1Eh                    ; Wrap tail
  212. IsItFull:Cmp       AX,[Word Ptr 41Ah]        ; Is buffer full?
  213.          JNE       PutChar                   ; No, so continue
  214.          Xor       AX,AX                     ; Set return value to .F.
  215.          Jmp       Short Exit                ; Quit
  216.  
  217. PutChar: Mov       BX,[Word Ptr 41Ch]        ; Get tail pointer
  218.          Add       BX,400h                   ; Adjust offset by constant
  219.          Mov       [Word Ptr BX],CX          ; Stuff keystroke
  220.          Mov       [Word Ptr 41Ch],AX        ; Save new buffer tail
  221.          Mov       AX,1                      ; Set return value to .T.
  222.  
  223. Exit:    STI                                 ; Enable keystrokes again
  224.          Pop       DS                        ; Restore DS
  225.  
  226. Done:    Push      AX                        ; Save return value on stack
  227.          Call      __RetL                    ; Return it to Clipper app
  228.          Add       SP,2                      ; Realign stack
  229.          Ret
  230. Endp     FT_PutKey
  231. Ends     _NanFor
  232. End
  233.