Sending Keys

You can easily send keys to the active window, as if the user was pressing keys on the keyboard
by using the SendKeys statement.

Shell "notepad", vbNormalFocus

SendKeys "This is a test string"

The code above runs notepad, and sends the keys 'This is a test string' to it. If you want to use special
keys, such as  ENTER or TAB, and keys that represent actions rather than characters, use the codes
shown below:

Key Code
BACKSPACE {BACKSPACE}, {BS}, or {BKSP}
BREAK {BREAK}
CAPS LOCK {CAPSLOCK}
DEL or DELETE {DELETE} or {DEL}
DOWN ARROW {DOWN}
END {END}
ENTER {ENTER}or ~
ESC {ESC}
HELP {HELP}
HOME {HOME}
INS or INSERT {INSERT} or {INS}
LEFT ARROW {LEFT}
NUM LOCK {NUMLOCK}
PAGE DOWN {PGDN}
PAGE UP {PGUP}
PRINT SCREEN {PRTSC}
RIGHT ARROW {RIGHT}
SCROLL LOCK {SCROLLLOCK}
TAB {TAB}
UP ARROW {UP}
F1 {F1}
F2 {F2}
F3 {F3}
F4 {F4}
F5 {F5}
F6 {F6}
F7 {F7}
F8 {F8}
F9 {F9}
F10 {F10}
F11 {F11}
F12 {F12}
F13 {F13}
F14 {F14}
F15 {F15}
F16 {F16}

To specify keys combined with any combination of the SHIFT, CTRL, and ALT keys, precede the key code
with one or more of the following codes:
Key Code
SHIFT +
CTRL ^
ALT %

To specify that any combination of SHIFT, CTRL, and ALT should be held down while several
other keys are pressed, enclose the code for those keys in parentheses. For example, to specify to
hold down SHIFT while E and C are pressed, use "+(EC)". To specify to hold down SHIFT
while E is pressed, followed by C without SHIFT, use "+EC".

To specify repeating keys, use the form {key number}. You must put a space between key and
number. For example, {LEFT 42} means press the LEFT ARROW key 42 times; {h 10} means
press H 10 times.
VBSendKeys - Send keys to any Windows and MS-DOS application
Private Declare Function OemKeyScan Lib "user32" (ByVal wOemChar As Integer)
As _
Long
Private Declare Function CharToOem Lib "user32" Alias "CharToOemA" (ByVal _
lpszSrc As String, ByVal lpszDst As String) As Long
Private Declare Function VkKeyScan Lib "user32" Alias "VkKeyScanA" (ByVal
cChar _
As Byte) As Integer
Private Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" _
(ByVal wCode As Long, ByVal wMapType As Long) As Long
Private Declare Sub keybd_event Lib "user32" (ByVal bVk As Byte, _
ByVal bScan As Byte, ByVal dwFlags As Long, ByVal dwExtraInfo As Long)

Private Const KEYEVENTF_KEYDOWN As Long = &H0

Private Const KEYEVENTF_KEYUP As Long = &H2

Type VKType
VKCode As Integer
scanCode As Integer
Control As Boolean
Shift As Boolean
Alt As Boolean
End Type

'---------------------------------------------------------------------
' Routine: VbSendKeys()
'
' Author: Bryan Wolf, 1999
'
' Purpose: Imitate VB's internal SendKeys statement, but add the
' ability to send keypresses to a DOS application. You
' can use SendKeys, to paste ASCII characters to a DOS
' window from the clipboard, but you can't send function
' keys. This module solves that problem and makes sending
' any keys to any Application, DOS or Windows, easy.
'
' Arguments: Keystrokes. Note that this does not implement the
' SendKeys's 'wait' argument. If you need to wait,
' try using a timing loop.
'
' The syntax for specifying keystrokes is the
' same as that of SendKeys - Please refer to VB's
' documentation for an in-depth description. Support
' for the following codes has been added, in addition
' to the standard set of codes suppored by SendKeys:
'
' KEY CODE
' break {CANCEL}
' escape {ESCAPE}
' left mouse button {LBUTTON}
' right mouse button {RBUTTON}
' middle mouse button {MBUTTON}
' clear {CLEAR}
' shift {SHIFT}
' control {CONTROL}
' alt {MENU} or {ALT}
' pause {PAUSE}
' space {SPACE}
' select {SELECT}
' execute {EXECUTE}
' snapshot {SNAPSHOT}
' number pad 0 {NUMPAD0}
' number pad 1 {NUMPAD1}
' number pad 2 {NUMPAD2}
' number pad 3 {NUMPAD3}
' number pad 4 {NUMPAD4}
' number pad 5 {NUMPAD5}
' number pad 6 {NUMPAD6}
' number pad 7 {NUMPAD7}
' number pad 8 {NUMPAD8}
' number pad 9 {NUMPAD9}
' number pad multiply {MULTIPLY}
' number pad add {ADD}
' number pad separator {SEPARATOR}
' number pad subtract {SUBTRACT}
' number pad decimal {DECIMAL}
' number pad divide {DIVIDE}
'
' Sample Calls:
' VbSendKeys "Dir~" ' View a directory of in DOS
'
' NOTE: there is a minor difference with SendKeys syntax. You can
' group multiple characters under the same shift key using
' curly brackets, while VB's SendKeys uses regular brackets.
' For example, to keep the SHIFT key pressed while you type
' A, B, and C keys, you must run the following statement
' VBSendKeys "+{abc}"
' while the syntax of the built-in VB function is
' SendKeys "+(abc)"
'---------------------------------------------------------------------

Sub VbSendKeys(ByVal sKeystrokes As String)

Dim iKeyStrokesLen As Integer
Dim lRepetitions As Long
Dim bShiftKey As Boolean
Dim bControlKey As Boolean
Dim bAltKey As Boolean
Dim lResult As Long
Dim sKey As String
Dim iAsciiKey As Integer
Dim iVirtualKey As Integer
Dim i As Long
Dim j As Long

Static bInitialized As Boolean

Static AsciiKeys(0 To 255) As VKType
Static VirtualKeys(0 To 255) As VKType
On Error GoTo 0

If Not bInitialized Then

Dim iKey As Integer
Dim OEMChar As String
Dim keyScan As Integer

' Initialize AsciiKeys()

For iKey = LBound(AsciiKeys) To UBound(AsciiKeys)
keyScan = VkKeyScan(iKey)
AsciiKeys(iKey).VKCode = keyScan And &HFF ' low-byte of key scan
' code
AsciiKeys(iKey).Shift = (keyScan And &H100)
AsciiKeys(iKey).Control = (keyScan And &H200)
AsciiKeys(iKey).Alt = (keyScan And &H400)
' Get the ScanCode
OEMChar = " " ' 2 Char
CharToOem Chr(iKey), OEMChar
AsciiKeys(iKey).scanCode = OemKeyScan(Asc(OEMChar)) And &HFF
Next iKey

' Initialize VirtualKeys()

For iKey = LBound(VirtualKeys) To UBound(VirtualKeys)
VirtualKeys(iKey).VKCode = iKey
VirtualKeys(iKey).scanCode = MapVirtualKey(iKey, 0)
' no use in initializing remaining elements
Next iKey
bInitialized = True ' don't run this code twice
End If ' End of initialization routine

' Parse the string in the same way that SendKeys() would
Do While Len(sKeystrokes)
lRepetitions = 1 ' Default number of repetitions for each character
bShiftKey = False
bControlKey = False
bAltKey = False

' Pull off Control, Alt or Shift specifiers

sKey = Left$(sKeystrokes, 1)
sKeystrokes = Mid$(sKeystrokes, 2)

Do While InStr(" ^%+", sKey) > 1 ' The space in " ^%+" is necessary
If sKey = "+" Then
bShiftKey = True
ElseIf sKey = "^" Then
bControlKey = True
ElseIf sKey = "%" Then
bAltKey = True
End If
sKey = Left$(sKeystrokes, 1)
sKeystrokes = Mid$(sKeystrokes, 2)
Loop

' Look for "{}"

If sKey = "{" Then
' Look for the "}"
i = InStr(sKeystrokes, "}")
 If i > 0 Then
sKey = Left$(sKeystrokes, i - 1) ' extract the content between
' the {}
sKeystrokes = Mid$(sKeystrokes, i + 1) ' Remove the }
End If

' Look for repetitions

i = Len(sKey)
Do While Mid$(sKey, i, 1) >= "0" And Mid$(sKey, i, _
1) <= "9" And i >= 3
i = i - 1
Loop

If i < Len(sKey) Then ' If any digits were found...

If i >= 2 Then ' If there is something preceding it...
If Mid$(sKey, i, 1) = " " Then ' If a space precedes the
' digits...
On Error Resume Next ' On overflow, ignore the value
lRepetitions = CLng(Mid$(sKey, i + 1))
On Error GoTo 0
sKey = Left$(sKey, i - 1)
End If
End If
End If
End If

' Look for special words

Select Case UCase$(sKey)
Case "LBUTTON" ' New
iVirtualKey = vbKeyLButton
Case "RBUTTON" ' New
iVirtualKey = vbKeyRButton
Case "BREAK", "CANCEL"
iVirtualKey = vbKeyCancel
Case "MBUTTON" ' New
iVirtualKey = vbKeyMButton
Case "BACKSPACE", "BS", "BKSP"
iVirtualKey = vbKeyBack
Case "TAB"
iVirtualKey = vbKeyTab
Case "CLEAR" ' New
iVirtualKey = vbKeyClear
Case "ENTER", "~"
iVirtualKey = vbKeyReturn
Case "SHIFT" ' New
iVirtualKey = vbKeyShift
Case "CONTROL" ' New
iVirtualKey = vbKeyControl
Case "MENU", "ALT" ' New
iVirtualKey = vbKeyMenu
Case "PAUSE" ' New
iVirtualKey = vbKeyPause
Case "CAPSLOCK"
iVirtualKey = vbKeyCapital
Case "ESCAPE", "ESC"
iVirtualKey = vbKeyEscape
Case "SPACE" ' New
 iVirtualKey = vbKeySpace
Case "PGUP"
iVirtualKey = vbKeyPageUp
Case "PGDN"
iVirtualKey = vbKeyPageDown
Case "END"
iVirtualKey = vbKeyEnd
Case "HOME" ' New
iVirtualKey = vbKeyHome
Case "LEFT"
iVirtualKey = vbKeyLeft
Case "UP"
iVirtualKey = vbKeyUp
Case "RIGHT"
iVirtualKey = vbKeyRight
Case "DOWN"
iVirtualKey = vbKeyDown
Case "SELECT" ' New
iVirtualKey = vbKeySelect
Case "PRTSC"
iVirtualKey = vbKeyPrint
Case "EXECUTE" ' New
iVirtualKey = vbKeyExecute
Case "SNAPSHOT" ' New
iVirtualKey = vbKeySnapshot
Case "INSERT", "INS"
iVirtualKey = vbKeyInsert
Case "DELETE", "DEL"
iVirtualKey = vbKeyDelete
Case "HELP"
iVirtualKey = vbKeyHelp
Case "NUMLOCK"
iVirtualKey = vbKeyNumlock
Case "SCROLLLOCK"
iVirtualKey = vbKeyScrollLock
Case "NUMPAD0" ' New
iVirtualKey = vbKeyNumpad0
Case "NUMPAD1" ' New
iVirtualKey = vbKeyNumpad1
Case "NUMPAD2" ' New
iVirtualKey = vbKeyNumpad2
Case "NUMPAD3" ' New
iVirtualKey = vbKeyNumpad3
Case "NUMPAD4" ' New
iVirtualKey = vbKeyNumpad4
Case "NUMPAD5" ' New
iVirtualKey = vbKeyNumpad5
Case "NUMPAD6" ' New
iVirtualKey = vbKeyNumpad6
Case "NUMPAD7" ' New
iVirtualKey = vbKeyNumpad7
Case "NUMPAD8" ' New
iVirtualKey = vbKeyNumpad8
Case "NUMPAD9" ' New
iVirtualKey = vbKeyNumpad9
Case "MULTIPLY" ' New
iVirtualKey = vbKeyMultiply
 Case "ADD" ' New
iVirtualKey = vbKeyAdd
Case "SEPARATOR" ' New
iVirtualKey = vbKeySeparator
Case "SUBTRACT" ' New
iVirtualKey = vbKeySubtract
Case "DECIMAL" ' New
iVirtualKey = vbKeyDecimal
Case "DIVIDE" ' New
iVirtualKey = vbKeyDivide
Case "F1"
iVirtualKey = vbKeyF1
Case "F2"
iVirtualKey = vbKeyF2
Case "F3"
iVirtualKey = vbKeyF3
Case "F4"
iVirtualKey = vbKeyF4
Case "F5"
iVirtualKey = vbKeyF5
Case "F6"
iVirtualKey = vbKeyF6
Case "F7"
iVirtualKey = vbKeyF7
Case "F8"
iVirtualKey = vbKeyF8
Case "F9"
iVirtualKey = vbKeyF9
Case "F10"
iVirtualKey = vbKeyF10
Case "F11"
iVirtualKey = vbKeyF11
Case "F12"
iVirtualKey = vbKeyF12
Case "F13"
iVirtualKey = vbKeyF13
Case "F14"
iVirtualKey = vbKeyF14
Case "F15"
iVirtualKey = vbKeyF15
Case "F16"
iVirtualKey = vbKeyF16
Case Else
' Not a virtual key
iVirtualKey = -1
End Select

' Turn on CONTROL, ALT and SHIFT keys as needed

If bShiftKey Then
keybd_event VirtualKeys(vbKeyShift).VKCode, _
VirtualKeys(vbKeyShift).scanCode, KEYEVENTF_KEYDOWN, 0
End If

If bControlKey Then
keybd_event VirtualKeys(vbKeyControl).VKCode, _
VirtualKeys(vbKeyControl).scanCode, KEYEVENTF_KEYDOWN, 0
End If
If bAltKey Then
keybd_event VirtualKeys(vbKeyMenu).VKCode, _
VirtualKeys(vbKeyMenu).scanCode, KEYEVENTF_KEYDOWN, 0
End If

' Send the keystrokes

For i = 1 To lRepetitions
If iVirtualKey > -1 Then
' Virtual key
keybd_event VirtualKeys(iVirtualKey).VKCode, _
VirtualKeys(iVirtualKey).scanCode, KEYEVENTF_KEYDOWN, 0
keybd_event VirtualKeys(iVirtualKey).VKCode, _
VirtualKeys(iVirtualKey).scanCode, KEYEVENTF_KEYUP, 0
Else
' ASCII Keys
For j = 1 To Len(sKey)
iAsciiKey = Asc(Mid$(sKey, j, 1))
' Turn on CONTROL, ALT and SHIFT keys as needed
If Not bShiftKey Then
If AsciiKeys(iAsciiKey).Shift Then
keybd_event VirtualKeys(vbKeyShift).VKCode, _
VirtualKeys(vbKeyShift).scanCode, _
KEYEVENTF_KEYDOWN, 0
End If
End If

If Not bControlKey Then

If AsciiKeys(iAsciiKey).Control Then
keybd_event VirtualKeys(vbKeyControl).VKCode, _
VirtualKeys(vbKeyControl).scanCode, _
KEYEVENTF_KEYDOWN, 0
End If
End If

If Not bAltKey Then

If AsciiKeys(iAsciiKey).Alt Then
keybd_event VirtualKeys(vbKeyMenu).VKCode, _
VirtualKeys(vbKeyMenu).scanCode, _
KEYEVENTF_KEYDOWN, 0
End If
End If

' Press the key

keybd_event AsciiKeys(iAsciiKey).VKCode, _
AsciiKeys(iAsciiKey).scanCode, KEYEVENTF_KEYDOWN, 0
keybd_event AsciiKeys(iAsciiKey).VKCode, _
AsciiKeys(iAsciiKey).scanCode, KEYEVENTF_KEYUP, 0

' Turn on CONTROL, ALT and SHIFT keys as needed

If Not bShiftKey Then
If AsciiKeys(iAsciiKey).Shift Then
keybd_event VirtualKeys(vbKeyShift).VKCode, _
VirtualKeys(vbKeyShift).scanCode, _
KEYEVENTF_KEYUP, 0
End If
End If
 If Not bControlKey Then
If AsciiKeys(iAsciiKey).Control Then
keybd_event VirtualKeys(vbKeyControl).VKCode, _
VirtualKeys(vbKeyControl).scanCode, _
KEYEVENTF_KEYUP, 0
End If
End If

If Not bAltKey Then

If AsciiKeys(iAsciiKey).Alt Then
keybd_event VirtualKeys(vbKeyMenu).VKCode, _
VirtualKeys(vbKeyMenu).scanCode, _
KEYEVENTF_KEYUP, 0
End If
End If
Next j ' Each ASCII key
End If ' ASCII keys
Next i ' Repetitions

' Turn off CONTROL, ALT and SHIFT keys as needed

If bShiftKey Then
keybd_event VirtualKeys(vbKeyShift).VKCode, _
VirtualKeys(vbKeyShift).scanCode, KEYEVENTF_KEYUP, 0
End If

If bControlKey Then
keybd_event VirtualKeys(vbKeyControl).VKCode, _
VirtualKeys(vbKeyControl).scanCode, KEYEVENTF_KEYUP, 0
End If

If bAltKey Then
keybd_event VirtualKeys(vbKeyMenu).VKCode, _
VirtualKeys(vbKeyMenu).scanCode, KEYEVENTF_KEYUP, 0
End If

Loop ' sKeyStrokes

End Sub

Bryan Wolf
SendKeys

If you want set focus without sending keys.

SendKeys.Send("", SendKeys.GetWinHandles("New Text Document - _

Notepad", 1, "Edit", 1), False)

If you want to get the number of keys sent.

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("New Text Document - Notepad", 1, "Edit", 1)
Dim sent As Int32 = SendKeys.Send("Hello", w)
MessageBox.Show(sent.ToString & " keys sent")

If you want to view available commands.

SendKeys.GetCommands()

If you want to open a file menu. (Alt + f)

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("New Text Document - Notepad")
SendKeys.Send("%(f)", w, False)

If you want to access sub menu shortcuts. (Alt + fx)

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("New Text Document - Notepad")
SendKeys.Send("%(fx)", w, False)

If you want capitalize a letter. (Shift + a)

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("New Text Document - Notepad")
SendKeys.Send("+(a)", w, False)

If you want print the current document. (Ctrl + p)

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("New Text Document - Notepad")
SendKeys.Send("^(p)", w, False)

If you want to open the system menu of a notepad and Maximize screen. (Alt + Space)

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("New Text Document - Notepad")
SendKeys.Send("%({space}x)", w, False)
If you want to open start menu. (Ctrl + Escape)

SendKeys.Send("^({escape})", Nothing, False)

If you want to open Task manager. (Ctrl+Shift+Escape)

SendKeys.Send("^(+({escape}))", Nothing, False)

If you want to log off of 2000/XP immediately. (Win + L)
SendKeys.Send("#(l)", Nothing, False)
Important Note: Different versions of VB.NET have different names for certain keys. For
example, the {enter} key on VB.NET 2003 is now the {return} key on VB.NET 2005. I
recommend checking what the key names are for your version of VB.NET, by using the
GetCommands sub.

Here is a complete list of key commands for 2005 with the 2.0 framework:

KeyCode Command KeyCode Command KeyCode Command

0 None 85 U 171 BrowserFavorites
1 LButton 86 V 172 BrowserHome
2 RButton 87 W 173 VolumeMute
3 Cancel 88 X 174 VolumeDown
4 MButton 89 Y 175 VolumeUp
5 XButton1 90 Z 176 MediaNextTrack
6 XButton2 91 LWin 177 MediaPreviousTrack
7 LButton, 92 RWin 178 MediaStop
XButton2
8 Back 93 Apps 179 MediaPlayPause
9 Tab 94 RButton, RWin 180 LaunchMail
10 LineFeed 95 Sleep 181 SelectMedia
11 LButton, LineFeed 96 NumPad0 182 LaunchApplication1
12 Clear 97 NumPad1 183 LaunchApplication2
13 Return 98 NumPad2 184 Back, MediaNextTrack
14 RButton, Clear 99 NumPad3 185 Back,
MediaPreviousTrack
15 RButton, Return 100 NumPad4 186 Oem1
16 ShiftKey 101 NumPad5 187 Oemplus
17 ControlKey 102 NumPad6 188 Oemcomma
18 Menu 103 NumPad7 189 OemMinus
19 Pause 104 NumPad8 190 OemPeriod
20 Capital 105 NumPad9 191 OemQuestion
21 KanaMode 106 Multiply 192 Oemtilde
22 RButton, Capital 107 Add 193 LButton, Oemtilde
23 JunjaMode 108 Separator 194 RButton, Oemtilde
24 FinalMode 109 Subtract 195 Cancel, Oemtilde
25 HanjaMode 110 Decimal 196 MButton, Oemtilde
26 RButton, 111 Divide 197 XButton1, Oemtilde
FinalMode
27 Escape 112 F1 198 XButton2, Oemtilde
28 IMEConvert 113 F2 199 LButton, XButton2,
Oemtilde
29 IMENonconvert 114 F3 200 Back, Oemtilde
30 IMEAceept 115 F4 201 Tab, Oemtilde
31 IMEModeChange 116 F5 202 LineFeed, Oemtilde
32 Space 117 F6 203 LButton, LineFeed,
Oemtilde
33 PageUp 118 F7 204 Clear, Oemtilde
34 Next 119 F8 205 Return, Oemtilde
35 End 120 F9 206 RButton, Clear,
Oemtilde
36 Home 121 F10 207 RButton, Return,
Oemtilde
37 Left 122 F11 208 ShiftKey, Oemtilde
38 Up 123 F12 209 ControlKey, Oemtilde
39 Right 124 F13 210 Menu, Oemtilde
40 Down 125 F14 211 Pause, Oemtilde
41 Select 126 F15 212 Capital, Oemtilde
42 Print 127 F16 213 KanaMode, Oemtilde
43 Execute 128 F17 214 RButton, Capital,
Oemtilde
44 PrintScreen 129 F18 215 JunjaMode, Oemtilde
45 Insert 130 F19 216 FinalMode, Oemtilde
46 Delete 131 F20 217 HanjaMode, Oemtilde
47 Help 132 F21 218 RButton, FinalMode,
Oemtilde
48 D0 133 F22 219 OemOpenBrackets
49 D1 134 F23 220 Oem5
50 D2 135 F24 221 Oem6
51 D3 136 Back, F17 222 Oem7
52 D4 137 Back, F18 223 Oem8
53 D5 138 Back, F19 224 Space, Oemtilde
54 D6 139 Back, F20 225 PageUp, Oemtilde
55 D7 140 Back, F21 226 OemBackslash
56 D8 141 Back, F22 227 LButton,
OemBackslash
57 D9 142 Back, F23 228 Home, Oemtilde
58 RButton, D8 143 Back, F24 229 ProcessKey
59 RButton, D9 144 NumLock 230 MButton,
OemBackslash
60 MButton, D8 145 Scroll 231 Packet
61 MButton, D9 146 RButton, NumLock 232 Down, Oemtilde
62 XButton2, D8 147 RButton, Scroll 233 Select, Oemtilde
63 XButton2, D9 148 MButton, 234 Back, OemBackslash
NumLock
64 64 149 MButton, Scroll 235 Tab, OemBackslash
65 A 150 XButton2, 236 PrintScreen, Oemtilde
NumLock
66 B 151 XButton2, Scroll 237 Back, ProcessKey
67 C 152 Back, NumLock 238 Clear, OemBackslash
68 D 153 Back, Scroll 239 Back, Packet
69 E 154 LineFeed, 240 D0, Oemtilde
NumLock
70 F 155 LineFeed, Scroll 241 D1, Oemtilde
71 G 156 Clear, NumLock 242 ShiftKey,
OemBackslash
72 H 157 Clear, Scroll 243 ControlKey,
OemBackslash
73 I 158 RButton, Clear, 244 D4, Oemtilde
 NumLock
74 J 159 RButton, Clear, 245 ShiftKey, ProcessKey
Scroll
75 K 160 LShiftKey 246 Attn
76 L 161 RShiftKey 247 Crsel
77 M 162 LControlKey 248 Exsel
78 N 163 RControlKey 249 EraseEof
79 O 164 LMenu 250 Play
80 P 165 RMenu 251 Zoom
81 Q 166 BrowserBack 252 NoName
82 R 167 BrowserForward 253 Pa1
83 S 168 BrowserRefresh 254 OemClear
84 T 169 BrowserStop 255 LButton, OemClear
    170 BrowserSearch    

Mouse Functions

If you want to get the windows that have mouse focus. The main window and child under the
cursor.

SendKeys.Sleep(3000)
Dim w As SendKeys.WINFOCUS = SendKeys.GetWinFocus(True, False)
MessageBox.Show(w.Foreground.ToString & vbCrLf & w.Focus.ToString)

If you want to click a button or other window.

Dim w As New SendKeys.WINFOCUS

w = SendKeys.GetWinHandles("Form1", 1, "GroupBox1", 1, "GroupBox2", _
1, "GroupBox3", 1, "Start", 1)
SendKeys.Click(Buttons.LeftClick, w)

If you want to move from current cursor position.

SendKeys.Click(Buttons.Move, Nothing, False, False, True, 100, 100)

If you want to move the cursor to screen coordinates.

SendKeys.Click(Buttons.MoveAbsolute, Nothing, False, False, True, _

100, 100)

If you want to click the 12th menu item, as a command message.

SendKeys.ClickMenu(True, "Form1", 1, "File", 1, "Item2", 1, "Item6", _

1, "Item9", 1, "Item10", 1, "Item12", 1)

If you want to click the 23rd menu item.

SendKeys.ClickMenu(True, "Form1", 1, "Edit", 1, "Item15", 1, _

"Item21", 1, "Item23", 1)

If you want to click the 12th menu item, by specifying the indexes only and no name.

SendKeys.ClickMenu(True, "Form1", 1, "", 1, "", 1, "", 3, "", 2, _

"", 1, "", 2)

If you want to click an item by specifying both captions and indexes.

SendKeys.ClickMenu(True, "Form1", 1, "Edit", 1, "Item15", 1, _

"Item18", 2)

If you want to wait for a window to exist before moving on, use the WaitForWindow function.

SendKeys.WaitForWindow("Print")

What's Under the Hood?

This module is built upon previous classes, such as InputToWin and SendKeysToWindow,
which were pretty reliable compared to SendKeys.Send but were still incomplete. The most
reliable methods for sending keys are Text and Message. Another dependable method is the new
Send method; it sends messages or uses a keyboard hook to ensure that the foreground window
is maintained, and only the keys sent from inside the module are allowed. It also can use the
AttachThreadInput API when the intended focus window is an external application. You now
can send keys directly to a child window by using the GetWinHandles or GetWinFocus(False)
methods, with the WINFOCUS structure. The SendKeys module is fully commented line by
line, to make it easier for others to learn and understand what's going on behind the scenes.

Advantages of the SendKeys Module over the SendKeys Class

Keyboard focus is maintained on the application by using a keyboard hook and

SetForegroundWindow. When keys are sent from this module, external keys entered by the user
are ignored by the hook. Other applications are locked out from using the SetForegroundWindow
function while keys are being sent. The foregroundwindow can be returned to its original
position. When a key being pressed represents an action that starts a new window, you can wait
until that window exists before sending more keys. Win+key combos are now possible
(2000/Xp) and are expressed as a string: "#(l)" (Win+L). All keys between 0 and 255 can be
called! See the GetCommands sub for all available commands. GetWinHandles can find and
verify any window handle, or start an executable path. See the GetCommands sub. The Sleep
method provides a unique way to overcome timing issues. Complex key combinations are
possible. Keys can be sent to a disabled, minimized, or hidden window. Strings can be repeated;
in other words, "{hello 10}" repeats the hello string ten times.

Disadvantages of the SendKeys Module Compared to the SendKeys Class

None yet known. Let me know if you find any!

Author name: Shane Findley