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 applicationPrivate Declare Function OemKeyScan Lib "user32" (ByVal wOemChar As Integer) As _ LongPrivate Declare Function CharToOem Lib "user32" Alias "CharToOemA" (ByVal _ lpszSrc As String, ByVal lpszDst As String) As LongPrivate Declare Function VkKeyScan Lib "user32" Alias "VkKeyScanA" (ByVal cChar _ As Byte) As IntegerPrivate Declare Function MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" _ (ByVal wCode As Long, ByVal wMapType As Long) As LongPrivate 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 = &H0Private Const KEYEVENTF_KEYUP As Long = &H2

Type VKType VKCode As Integer scanCode As Integer Control As Boolean Shift As Boolean Alt As BooleanEnd 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 ' sKeyStrokesEnd 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.WINFOCUSw = 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.WINFOCUSw = 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.WINFOCUSw = SendKeys.GetWinHandles("New Text Document - Notepad")SendKeys.Send("%(fx)", w, False)

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

Dim w As New SendKeys.WINFOCUSw = 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.WINFOCUSw = 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.WINFOCUSw = 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, XButton2

92 RWin 178 MediaStop

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, FinalMode

111 Divide 197 XButton1, Oemtilde

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, NumLock

234 Back, OemBackslash

64 64 149 MButton, Scroll 235 Tab, OemBackslash

65 A 150 XButton2, NumLock

236 PrintScreen, Oemtilde

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, NumLock

240 D0, Oemtilde

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, Scroll

245 ShiftKey, ProcessKey

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.WINFOCUSw = 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