home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / progmisc / nfsrc21.zip / PUTKEY.ASM < prev    next >
Assembly Source File  |  1992-10-16  |  11KB  |  238 lines
  1. ; File......: PUTKEY.ASM
  2. ; Author....: Ted Means
  3. ; Date......: $Date:   16 Oct 1992 00:00:56  $
  4. ; Revision..: $Revision:   1.4  $
  5. ; Log file..: $Logfile:   C:/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:   C:/nanfor/src/putkey.asv  $
  14. ;  
  15. ;     Rev 1.4   16 Oct 1992 00:00:56   GLENN
  16. ;  Just making sure we have Ted's latest revisions.
  17. ;  
  18. ;     Rev 1.3   01 Jul 1992 01:07:02   GLENN
  19. ;  PUTKEY.ASM now bypasses the BIOS completely and uses Clipper's
  20. ;  internal event handler to stuff the keystroke.  Modifications by
  21. ;  Ted Means.
  22. ;  
  23. ;     Rev 1.2   15 Aug 1991 23:07:10   GLENN
  24. ;  Forest Belt proofread/edited/cleaned up doc
  25. ;  
  26. ;     Rev 1.1   14 Jun 1991 19:54:56   GLENN
  27. ;  Minor edit to file header
  28. ;  
  29. ;     Rev 1.0   01 Apr 1991 01:03:48   GLENN
  30. ;  Nanforum Toolkit
  31. ;  
  32.  
  33. ; $DOC$
  34. ; $FUNCNAME$
  35. ;     FT_PUTKEY()
  36. ; $CATEGORY$
  37. ;     Keyboard/Mouse
  38. ; $ONELINER$
  39. ;     Stuff a keystroke into the keyboard buffer
  40. ; $SYNTAX$
  41. ;     FT_PUTKEY( <nKeyValue> ) -> lResult
  42. ; $ARGUMENTS$
  43. ;     <nKeyValue> is the INKEY() value of the keystroke to be stuffed.
  44. ; $RETURNS$
  45. ;    .T. if the keystroke was put into the keyboard buffer.
  46. ;    .F. if nKeyValue was invalid or the buffer was full.
  47. ; $DESCRIPTION$
  48. ;    This function is similar to the KEYBOARD command, with a few
  49. ;    exceptions. First, this function does not clear the keyboard buffer
  50. ;    before inserting the keystroke.  In addition, since it uses the
  51. ;    Inkey() value, you can stuff any key, including function keys, into
  52. ;    the keyboard buffer. However, this also means that unlike the KEYBOARD
  53. ;    command, you can only stuff one keystroke at a time.
  54. ;
  55. ;    You can easily create a User-Defined Command that makes this function
  56. ;    even more like the KEYBOARD command.  For example,
  57. ;
  58. ;        #command KEYSTROKE <key> => FT_PUTKEY( <key> )
  59. ;
  60. ;    will create a command called KEYSTROKE that could be used as a
  61. ;    companion command to KEYBOARD.  The only difference is that it would
  62. ;    insert a single keystroke instead of a string.
  63. ;
  64. ;    Be aware that this function makes use of Clipper's internal event
  65. ;    handler.  If you don't like using internals, then don't use this
  66. ;    function, you sniveling coward.
  67. ;
  68. ;    This function is written to adhere to Turbo Assembler's IDEAL mode.
  69. ;    To use another assembler, rearrange the SEGMENT and PROC directives
  70. ;    and make any other necessary changes to the source code.
  71. ; $EXAMPLES$
  72. ;      FT_PUTKEY( -9 )   //  Stuff the F10 key
  73. ;      FT_PUTKEY( 276 )  //  Stuff the Alt T key
  74. ;      KEYSTROKE 28      //  Stuff the F1 key using a User-Defined Command
  75. ; $END$
  76.  
  77. IDEAL
  78.  
  79. Public   FT_PutKey
  80.  
  81. Extrn    __ParInfo:Far
  82. Extrn    __Parni:Far
  83. Extrn    __RetL:Far
  84. Extrn    __evLow:Far                         ; Internal!!  Sniveling cowards
  85.                                              ; beware!
  86.  
  87. Segment  _NanFor   Word      Public    "CODE"
  88.          Assume    CS:_NanFor
  89.  
  90. Proc     FT_PutKey Far
  91.  
  92.          Xor       AX,AX                     ; Prepare to count params
  93.          Push      AX                        ; Save on stack
  94.          Call      __ParInfo                 ; Get param count
  95.          Add       SP,2                      ; Realign stack
  96.          Or        AX,AX                     ; Zero params?
  97.          JNZ       Test1                     ; If not, continue
  98.          Jmp       Done                      ; Return value = false, go to end
  99.  
  100. Test1:   Mov       AX,1                      ; Prepare to check parameter #1
  101.          Push      AX                        ; Save parameter # on stack
  102.          Call      __ParInfo                 ; Call parameter info routine
  103.          Add       SP,2                      ; Realign stack
  104.          Test      AX,2                      ; Is parameter numeric?
  105.          JNZ       Get1                      ; If so, continue
  106. BadParam:Xor       AX,AX                     ; Set return value to false
  107.          Jmp       Done                      ; Go to end
  108.  
  109. Get1:    Mov       AX,1                      ; Prepare to retrieve parameter #1
  110.          Push      AX                        ; Save parameter # on stack
  111.          Call      __ParNI                   ; Retrieve parameter
  112.          Add       SP,2                      ; Realign stack
  113.  
  114.          Cmp       AX,385                    ; Test highest inkey()
  115.          JG        BadParam                  ; Bad INKEY() value
  116.          Cmp       AX,-39                    ; Test lowest INKEY()
  117.          JL        BadParam                  ; Bad INKEY() value
  118.  
  119. CtrlF1:  Mov       CL,0                      ; Set ASCII value to null
  120.          Cmp       AX,-10                    ; Is Ctrl F1 thru Alt F10?
  121.          JG        F2                        ; If not, check next range
  122.          Neg       AX                        ; Get absolute value of AX
  123.          Add       AL,74                     ; Translate INKEY() to scan code
  124.          Mov       CH,AL                     ; Move scan code to CH
  125.          Jmp       StuffIt                   ; Stuff the keystroke
  126.  
  127. F2:      Or        AX,AX                     ; See if key is F2 thru F10
  128.          JNS       F1                        ; If not, check next range
  129.          Neg       AX                        ; Get absolute value of AX
  130.          Add       AL,59                     ; Translate INKEY() to scan code
  131.          Mov       CH,AL                     ; Move scan code to CH
  132.          Jmp       StuffIt                   ; Stuff the keystroke
  133.  
  134. F1:      Cmp       AX,28                     ; See if key is F1
  135.          JNE       CtrlF                     ; If not, check next key
  136.          Mov       CH,59                     ; Supply scan code for F1
  137.          Jmp       StuffIt                   ; Stuff the keystroke
  138.  
  139. CtrlF:   Cmp       AX,6                      ; See if key is Ctrl F or End
  140.          JNE       CtrlW                     ; If not, check next key
  141.          Mov       CH,79                     ; Supply scan code for End
  142.          Jmp       StuffIt                   ; Stuff the keystroke
  143.  
  144. CtrlW:   Cmp       AX,23                     ; See if key is Ctrl W or Ctrl End
  145.          JNE       CtrlHome                  ; If not, check next key
  146.          Mov       CH,117                    ; Supply scan code for Ctrl End
  147.          Jmp       StuffIt                   ; Stuff the keystroke
  148.  
  149. CtrlHome:Cmp       AX,29                     ; See if key is Ctrl Home or Ctrl]
  150.          JNE       CtrlV                     ; If not, check next key
  151.          Mov       CH,119                    ; Supply scan code for Ctrl Home
  152.          Jmp       StuffIt                   ; Stuff the keystroke
  153.  
  154. CtrlV:   Cmp       AX,22                     ; See if key is Ins or Ctrl V
  155.          JNE       ShiftTab                  ; If not, check next key
  156.          Mov       CH,82                     ; Supply scan code for Ctrl V
  157.          Jmp       StuffIt                   ; Stuff the keystroke
  158.  
  159. ShiftTab:Cmp       AX,271                    ; See if key is Shift Tab
  160.          JNE       CtrlPgDn                  ; If not, check next key
  161.          Mov       CH,15                     ; Supply scan code for Shift Tab
  162.          Jmp       StuffIt                   ; Stuff the keystroke
  163.  
  164. CtrlPgDn:Cmp       AX,30                     ; See if key is Ctrl PgDn
  165.          JNE       CtrlPgUp                  ; If not, check next key
  166.          Mov       CH,118                    ; Supply scan code for Ctrl PgDn
  167.          Jmp       StuffIt                   ; Stuff the keystroke
  168.  
  169. CtrlPgUp:Cmp       AX,31                     ; See if key is Ctrl PgUp
  170.          JNE       AltQ                      ; If not, check next key
  171.          Mov       CH,132                    ; Supply scan code for Ctrl PgUp
  172.          Jmp       StuffIt                   ; Stuff the keystroke
  173.  
  174. AltQ:    Cmp       AX,272                    ; See if key is Alt Q . . .
  175.          JL        ASCII
  176.          Cmp       AX,281                    ; . . . thru Alt P
  177.          JG        AltA
  178.          Mov       CH,AL
  179.          Jmp       StuffIt
  180.  
  181. AltA:    Cmp       AX,286                    ; See if key is Alt A . . .
  182.          JNL       AltL
  183.          Jmp       BadParam
  184. AltL:    Cmp       AX,294                    ; . . . thru Alt L
  185.          JG        AltZ
  186.          Mov       CH,AL
  187.          Jmp       StuffIt
  188.  
  189. AltZ:    Cmp       AX,300                    ; See if key is Alt Z . . .
  190.          JNL       AltM
  191.          Jmp       BadParam
  192. AltM:    Cmp       AX,306                    ; . . . thru Alt M
  193.          JG        Alt1
  194.          Mov       CH,AL
  195.          Mov       CL,0
  196.          Jmp       StuffIt
  197.  
  198. Alt1:    Cmp       AX,376                    ; See if key is Alt 1 . . .
  199.          JNL       AltNum
  200.          Jmp       BadParam
  201. AltNum:  Mov       CH,AL
  202.          Mov       CL,0
  203.          Jmp       StuffIt
  204.  
  205. ASCII:   Or        AH,AH                     ; See if key is plain ASCII
  206.          JZ        Okay
  207.          Jmp       BadParam
  208. Okay:    Mov       CX,AX
  209.  
  210. StuffIt: Push      BP                        ; Save BP
  211.          Mov       BP,SP                     ; Set up stack reference
  212.          Sub       SP,10                     ; Allocate local structure
  213.          Mov       [Word Ptr BP - 10],5      ; Choose keystroke event
  214.          Mov       [Word Ptr BP - 8],0       ; Init flag word to 0
  215.          Mov       [Word Ptr BP - 6],CX      ; Store keystroke in structure
  216.          Mov       [Word Ptr BP - 4],0       ; Init mouse row to 0
  217.          Mov       [Word Ptr BP - 2],0       ; Init mouse col to 0
  218.          Push      SS                        ; Put structure segment on stack
  219.          LEA       AX,[BP - 10]              ; Load structure offset
  220.          Push      AX                        ; Put structure offset on stack
  221.          Mov       AX,3                      ; Post event subfunction code
  222.          Push      AX                        ; Place onto stack
  223.          Call      __evLow                   ; Call internal event handler
  224.          Dec       AX                        ; Convert error code . . .
  225.          Neg       AX                        ; . . . to a logical value
  226.          Mov       SP,BP                     ; Restore stack alignment
  227.          Pop       BP                        ; Restore BP
  228.  
  229. Done:    Push      AX                        ; Save return value on stack
  230.          Call      __RetL                    ; Return it to Clipper app
  231.          Add       SP,2                      ; Realign stack
  232.          Ret
  233. Endp     FT_PutKey
  234. Ends     _NanFor
  235. End
  236.  
  237.  
  238.