ABOUT Visual Basic Programmieren Programmierung Download Downloads Tips & Tricks Tipps & Tricks Know-How Praxis VB VBA Visual Basic for Applications VBS VBScript Scripting Windows ActiveX COM OLE API ComputerPC Microsoft Office Microsoft Office 97 Office 2000 Access Word Winword Excel Outlook Addins ASP Active Server Pages COMAddIns ActiveX-Controls OCX UserControl UserDocument Komponenten DLL EXE
Diese Seite wurde zuletzt aktualisiert am 06.07.2001

Diese Seite wurde zuletzt aktualisiert am 06.07.2001
Aktuell im ABOUT Visual Basic-MagazinGrundlagenwissen und TechnologienKnow How, Tipps und Tricks rund um Visual BasicActiveX-Komponenten, Controls, Klassen und mehr...AddIns für die Visual Basic-IDE und die VBA-IDEVBA-Programmierung in MS-Office und anderen AnwendungenScripting-Praxis für den Windows Scripting Host und das Scripting-ControlTools, Komponenten und Dienstleistungen des MarktesRessourcen für Programmierer (Bücher, Job-Börse)Dies&Das...

Themen und Stichwörter im ABOUT Visual Basic-Magazin
Code, Beispiele, Komponenten, Tools im Überblick, Shareware, Freeware
Ihre Service-Seite, Termine, Job-Börse
Melden Sie sich an, um in den vollen Genuss des ABOUT Visual Basic-Magazins zu kommen!
Informationen zum ABOUT Visual Basic-Magazin, Kontakt und Impressum

Zurück...

Tasten senden

Zurück...


Anzeige

(-hg) mailto:hg_sendkeys@aboutvb.de

Vielleicht werden sie schon darüber gestolpert sein, dass die Sendkeys-Anweisung unter Windows 2000 manchmal nicht so funktioniert wie erwartet. Dahinter steckt ein Bug, der Microsoft bereits bekannt ist - der Knowledge-Base: Artikel Q276346Artikel Q276346 der Knowledge-Base weist darauf hin. Darin werden auch Wege zur Umgehung des Problems angedeutet - sehr hilfreich und ein wirklicher Ersatz für die SendKeys-Anweisung sind sie jedoch nicht.

Der Ansatz, ein einzelnes Tastatur-Ereignis über die API-Funktion keybd_event zu versenden, ist allerdings goldrichtig. Dabei ist "Tastatur-Ereignis" durchaus wörtlich zu verstehen: Das Niederdrücken und das Loslassen einer Taste sind zwei verschiedene Ereignisse. Wie bei SendKeys auch werden die gesendeten Tastendrücke an das Fenster bzw. Steuerelement übergeben, das gerade den Fokus inne hat. Zum Simulieren des Niederdrückens einer Taste übergeben Sie der Funktion keybd_event im ersten Parameter den zu sendenden KeyCode der Taste - in den übrigen Parametern übergeben Sie 0. Zum Simulieren des Loslassens einer Taste übergeben Sie ebenfalls den KeyCode im ersten Parameter, und dazu im dritten Parameter die Konstante KEYEVENTF_KEYUP. Die Tabulator-Taste senden Sie beispielsweise so:

Private Declare Sub keybd_event Lib "user32" (ByVal bVk As Byte, _
 ByVal bScan As Byte, ByVal dwFlags As Long, _
 ByVal dwExtraInfo As Long)

keybd_event vbKeyTab, 0, 0, 0
keybd_event vbKeyTab, 0, KEYEVENTF_KEYUP, 0

Genau so, wie Sie in den KeyDown- und KeyUp-Ereignissen über das Niederdrücken oder Loslassen der Umschalt-Taste, der Strg-Taste und der Alt-Taste informiert werden, müssen Sie auch per keybd_event das Niederdrücken und Loslassen dieser Tastens senden. Den Großbuchstaben "A" senden Sie demzufolge so:

keybd_event vbKeyShift, 0, 0, 0
keybd_event vbKeyA, 0, 0, 0
keybd_event vbKeyA, 0, KEYEVENTF_KEYUP, 0
keybd_event vbKeyShift, 0, KEYEVENTF_KEYUP, 0

Im Vergleich zu SendKeys ist das natürlich eine sehr mühselige Angelegenheit. Die folgende Prozedur SendKey vereinfacht das Senden einer Taste um einiges. Im ersten Parameter übergeben Sie den KeyCode und im optionalen zweiten Parameter können Sie eine Kombination der Shift-Masken (Konstanten ShiftConstants: vbShiftMask, vbCtrlMask, vbAltMask) angeben. Im letzten optionalen Parameter Repeats können Sie noch festlegen, wie oft der Tastendruck wiederholt werden soll.

Public Sub SendKey(ByVal KeyCode As KeyCodeConstants, _
 Optional ByVal Shift As ShiftConstants, _
 Optional ByVal Repeats As Long = 1)

  Dim l As Long
  
  Const KEYEVENTF_KEYUP = &H2

  If Repeats >= 1 Then
    If CBool(Shift And vbShiftMask) Then
      keybd_event vbKeyShift, 0, 0, 0
    End If
    If CBool(Shift And vbCtrlMask) Then
      keybd_event vbKeyControl, 0, 0, 0
    End If
    If CBool(Shift And vbAltMask) Then
      keybd_event vbKeyMenu, 0, 0, 0
    End If
    For l = 1 To Repeats
      keybd_event KeyCode, 0, 0, 0
      keybd_event KeyCode, 0, KEYEVENTF_KEYUP, 0
    Next 'l
    If CBool(Shift And vbAltMask) Then
      keybd_event vbKeyMenu, 0, KEYEVENTF_KEYUP, 0
    End If
    If CBool(Shift And vbCtrlMask) Then
      keybd_event vbKeyControl, 0, KEYEVENTF_KEYUP, 0
    End If
    If CBool(Shift And vbShiftMask) Then
      keybd_event vbKeyShift, 0, KEYEVENTF_KEYUP, 0
    End If
  End If
End Sub

Einen kleinen Haken hat diese Prozedur allerdings. Woher bekommen Sie die KeyCodes für alle Tasten? In den KeyCode-Konstanten in Visual Basic finden sie bereits eine ganze Reihe von KeyCodes vordefiniert - aber bei weitem nicht alle. Neben den KeyCodes für die Tasten A bis Z und die Tasten 0 bis 9 finden Sie auch nahezu alle Sondertasten. Doch es fehlen beispielsweise die KeyCodes für die Umlaute, die Interpunktionszeichen, die Zeichen ab Ascii 128 und mehr. Natürlich können Sie diese ermitteln, indem Sie sich die entsprechenden KeyCodes in einem KeyDown-Ereignis ansehen.

Einfacher und sicherer ist es jedoch, diese Ermittlungs-Arbeit Windows zu überlassen, genauer gesagt, der API-Funktion VkKeyScan, der Sie den Ascii-Wert eines Zeichens übergeben können. Im Rückgabewert der Funktion finden Sie sowohl den zu einem Zeichen passenden KeyCode als auch die Information darüber, welche Shift-Tastenkombination zur Erzeugung des Zeichens benötigt wird. Der Rückgabewert ist allerdings nicht sehr VB-freundlich. Es ist ein Integer-Wert, in dessen niederwertigem Byte der KeyCode und in dessen höherwertigem Byte die Shift-Kombination abgelegt sind.

Ein einfacher Trick zur Zerlegung eines solchen Integer-Wertes nutzt zwei benutzerdefinierte Variablen. Die eine besteht nur aus einem Integer-Element, die andere aus zwei Byte-Elementen. Sie weisen dem Integer-Element den Integer-Wert zu, übertragen den Inhalt der Variablen mit der VB-Anweisung LSet an die andere Variable, und schon können Sie aus dieser die beiden Byte-Bestandteile ohne Schwierigkeit auslesen. Auch das alles packen wir wieder in eine kompakte Funktion:

Private Declare Function VkKeyScan Lib "user32" _
 Alias "VkKeyScanA" (ByVal cChar As Byte) As Integer

Private Type IntegerType
  i As Integer
End Type

Private Type HiLowByteType
  LowByte As Byte
  HiByte As Byte
End Type

Public Function GetKeyCodeFromAscii(ByVal KeyAscii As Long, _
 ShiftState As Long)

  Dim nHL As HiLowByteType
  Dim nI As IntegerType
  
  nI.i = VkKeyScan(KeyAscii)
  LSet nHL = nI
  ShiftState = ShiftState Or nHL.HiByte
  GetKeyCodeFromAscii = nHL.LowByte
End Function

Das Senden des Zeichens "Ö" sähe nun unter Verwendung dieser Funktion und der Prozedur SendKey so aus:

Dim nKeyCode As Long
Dim nShift As Long

nKeyCode = GetKeyCodeFromAscii(Asc("Ö"), nShift)
SendKey nKeyCode, nShift

Ist Ihnen das auch immer noch zu umständlich? Keine Frage - auch dafür gibt es eine vereinfachende Prozedur:

Public Sub SendAscii(ByVal Ascii As Long, _
 Optional ByVal Shift As ShiftConstants, _
 Optional ByVal Repeats As Long = 1)

  Dim nKeyCode As Long
  
  nKeyCode = GetKeyCodeFromAscii(Ascii, Shift)
  SendKey nKeyCode, Shift, Repeats
End Sub

Oder wenn Sie ein Zeichen nicht als Ascii-Code, sondern gleich als String übergeben möchten, verwenden Sie die leicht modifizierte Alternative SendChar, zusammen mit der ebenfalls leicht modifizierten Variante GetKeyCodeFromChar:

Public Sub SendChar(Char As String, _
 Optional ByVal Shift As ShiftConstants, _
 Optional ByVal Repeats As Long = 1)

  Dim nKeyCode As Long
  
  nKeyCode = GetKeyCodeFromChar(Char, Shift)
  SendKey nKeyCode, Shift, Repeats
End Sub

Public Function GetKeyCodeFromChar(Char As String, _
 ShiftState As Long)

  Dim nHL As HiLowByteType
  Dim nI As IntegerType
  
  nI.i = VkKeyScan(Asc(Char))
  LSet nHL = nI
  ShiftState = ShiftState Or nHL.HiByte
  GetKeyCodeFromChar = nHL.LowByte
End Function

Nun ist es wohl immer noch viel zu umständlich, Zeichen für Zeichen einzeln zu senden. Aber auch dafür haben wir schon eine kleine Prozedur für Sie vorbereitet:

Public Sub SendString(Str As String, _
 Optional Shift As ShiftConstants)

  Dim l As Long
  
  For l = 1 To Len(Str)
    SendChar Mid$(Str, l, 1), Shift
  Next 'l
End Sub

Sie wundern sich vielleicht ein wenig über die Shift-Parameter der Prozeduren SendAscii, SendChar und SendString. Sie haben ja recht - eigentlich könnten diese durchaus entfallen. Doch so haben Sie die Möglichkeit, ein Zeichen unabhängig von der Groß-/Kleinschreibung anzugeben und diese statt dessen im Shift-Parameter festzulegen. Und natürlich brauchen Sie die Shift-Konstanten, wenn Sie eine Kombination aus Zeichen und Strg- und/oder Alt-Taste senden möchten.

Den Komfort des VB-SendKeys haben wir allerdings immer noch nicht ganz erreicht. Sie können zwar mittlerweile ganze Zeichenfolgen senden, aber nicht mittendrin Sondertasten etwa zur Cursor-Steuerung unterbringen. Wie wäre es damit, wenn Sie ein Array übergeben könnten, das Zeichen, Zeichenfolgen und KeyCodes von Zeichen und Sondertasten bunt gemischt enthält? Oder wenn Sie diese Elemente in einer Collection sammeln und diese übergeben könnten? Oder wenn Sie alles wirklich bunt mischen könnten, also Arrays, Collections, einzelne Zeichen, Zeichenfolgen und KeyCodes? Selbstverständlich ist auch das kein Problem - die Prozedur SendKeystrokes und ihre Varianten sind ungemein flexibel:

Public Enum ShiftStateConstants
  skShiftStateShift = 256
  skShiftStateCtrl = 512
  skShiftStateAlt = 1024
  skShiftStateOn = 2048
  skShiftStateShiftOn = 256 Or skShiftStateOn
  skShiftStateCtrlOn = 512 Or skShiftStateOn
  skShiftStateAltOn = 1024 Or skShiftStateOn
  skShiftStateOff = 4096
  skShiftStateShiftOff = 256 Or skShiftStateOff
  skShiftStateCtrlOff = 512 Or skShiftStateOff
  skShiftStateAltOff = 1024 Or skShiftStateOff
  skShiftStateAscii = 8192
End Enum

Public Sub SendKeystrokes(Keystroke As Variant, _
 Optional ShiftState As Long)

  Dim l As Long
  Dim nI As IntegerType
  Dim nHL As HiLowByteType
  Dim nShift As Long
  Dim nKeyCode As Long
  Dim nAscii As Long
  
  Const kShiftStateOn = 8
  Const kShiftStateOff = 16
  Const kShiftStateAscii = 32
  Const kShiftMask = vbShiftMask Or vbCtrlMask Or vbAltMask
  
  If IsArray(Keystroke) Then
    SendKeystrokesArr Keystroke, ShiftState
  ElseIf IsObject(Keystroke) Then
    If TypeOf Keystroke Is Collection Then
      SendKeystrokesColl CVar(Keystroke), ShiftState
    End If
  Else
    Select Case VarType(Keystroke)
      Case vbString
        SendString CStr(Keystroke), ShiftState
      Case vbByte, vbLong, vbInteger
        If IsNumeric(Keystroke) Then
          nI.i = CInt(Keystroke)
          LSet nHL = nI
          nShift = nHL.HiByte And kShiftMask
          If (nHL.HiByte And kShiftStateOn) = kShiftStateOn Then
            ShiftState = ShiftState Or nShift
            nShift = ShiftState
          ElseIf (nHL.HiByte And kShiftStateOff) = _
           kShiftStateOff Then
            ShiftState = ShiftState And Not nShift
            nShift = ShiftState
          End If
          If (nHL.HiByte And kShiftStateAscii) Then
            SendAscii nHL.LowByte, nShift
          Else
            SendKey nHL.LowByte, nShift
          End If
        End If
    End Select
  End If
End Sub

Public Sub SendKeystrokesArr(Keystrokes As Variant, _
 Optional ByVal ShiftState As Long)

  Dim nKeyStroke As Variant
  
  For Each nKeyStroke In Keystrokes
    SendKeystrokes nKeyStroke, ShiftState
  Next
End Sub

Public Sub SendKeystrokesColl(Keystrokes As Collection, _
 Optional ByVal ShiftState As Long)

  Dim nKeyStroke As Variant
  
  For Each nKeyStroke In Keystrokes
    SendKeystrokes nKeyStroke, ShiftState
  Next
End Sub

Public Sub SendKeystrokesList _
 (ParamArray Keystrokes() As Variant)

  Dim nKeyStroke As Variant
  Dim nShiftState As Long
  
  For Each nKeyStroke In Keystrokes
    SendKeystrokes nKeyStroke, nShiftState
  Next
End Sub

Habe ich Sie mit der Enumeration ShiftStateConstants und den diversen Auswertungen in der Prozedur SendKeystrokes verwirrt? Dann will Sie sofort darüber aufklären, was es damit auf sich hat. Das damit gelöste Problem ist nämlich folgendes: Sie brauchen eine Möglichkeit, zu einem einzelnen KeyCode einen ShiftStatus angeben zu können. Denn die SendKey-Prozedur sendet ja jedes Zeichen einzeln und erwartet dazu auch den gewünschten ShiftStatus. Wir machen es dazu ähnlich wie die API-Funktion VkKeyScan, indem wir die benötigten Informationen in einen einzigen Wert hineinstopfen. Da für KeyCodes ja nur die Werte bis 255 verwendet werden, haben wir bei einem Integer- oder Long-Wert noch jede Menge Bits übrig.

Kombinieren Sie nun statt der gewohnten Shift-Konstanten die neuen Enumerations-Konstanten skShiftStateShift, skShiftStateCtrl und skShiftStateAlt mit einem KeyCode - in SendKeystrokes wird für die Auswertung gesorgt. Wollen Sie statt eines KeyCodes einen Ascii-Code übergeben, kombinieren Sie das ganze noch mit der Konstanten skShiftStateAscii. Wollen Sie gleich eine ganze Reihe von Zeichen mit der gleichen Shift-Kombination senden, kombinieren Sie den ersten Wert einer solchen Reihe noch mit der Konstanten skShiftStateOn, und den letzten Wert der Reihe mit skShiftStateOff. Oder fügen Sie die beiden Konstanten nur mit einer ShiftState-Kombination und ohne KeyCode- oder Ascii-Wert paarweise ein, und dazwischen schieben Sie andere Elemente, oder gar wieder ein ganzes Array oder eine ganze Collection - alle sich darunter bzw. darin befindlichen Werte werden automatisch mit der eingeschalteten ShiftState-Kombination gesendet, außer sie haben bei einem Wert ausdrücklich eine eigene Kombination angegeben.

Das klingt fürchterlich kompliziert - ist aber halb so schlimm. Schauen wir uns dazu einmal ein paar Beispiele an.

Am einfachsten ist die Prozedur SendKeystrokesList handzuhaben. Ihr übergeben Sie einfach eine Reihe von Elementen, jeweils durch Kommata getrennt - eben eine einfache Parameter-Liste:

SendKeystrokesList "H", "a", "ll", "o", "Welt", "!"

Oder das gleiche Ergebnis, anders "formuliert":

SendKeystrokesList skShiftStateShift Or vbKeyH, _
 "a", "ll", "o ", Array("Welt", "!")

Oder wenn die Welt "groß" sein soll:

SendKeystrokesList skShiftStateShift Or vbKeyH, _
 "a", "ll", "o ", skShiftStateShiftOn, Array("Welt", "!"), _
 skShiftStateShiftOff

Hierbei können Sie auch das letzte Element weglassen - das abschließende Abschalten des Shift-Zustandes ist nicht notwendig.

Nehmen wir eine Collection hinzu und gehen zur Prozedur SendKeyStrokesArr über:

Dim nColl As Collection

Set nColl = New Collection
With nColl
  .Add "l"
  .Add "lo"
  .Add vbKeySpace
End With
SendKeystrokesArr Array(skShiftStateShift Or vbKeyH, "a", _
 nColl, Array("Welt", "!")

Oder sollen die beiden Wörter durch eine Zeilenschaltung getrennt werden?

Dim nColl As Collection

Set nColl = New Collection
With nColl
  .Add "Hallo"
  .Add vbKeyReturn
  .Add Array(skShiftStateShift Or skShiftStateAscii _
   Or Asc("w"), "elt")
  .Add "!"
End With
SendKeystrokesColl nColl

Sie sehen, es gibt vielfältige Möglichkeiten, die Welt zu begrüßen... Ach, Sie hätten doch lieber eine kompatible SendKeys-Prozedur, damit Sie Ihre mühsam ausgetüftelten SendKeys-Strings weiterhin und unverändert verwenden können? Na gut - hier haben Sie diese auch noch. Aber machen Sie mich bitte nicht dafür verantwortlich, wenn nicht alle Ihre Tricksereien Ihrer SendKeys-Strings einwandfrei umgesetzt werden. Ich habe mich lediglich an die Dokumentation gehalten und keine (!) ausgiebigen Tests mit den verschiedensten Anwendungen durchgeführt.

Public Sub SendKeys(Keys As String)
  Dim l As Long
  Dim nPos As Long
  Dim nKey As String
  Dim nShiftState As ShiftConstants
  Dim nKeyCode As KeyCodeConstants
  Dim nPosSpace As Long
  Dim nChar As String
  Dim nRepeat As String
  Dim nRepeats As Long
  Dim ll As Long
  Dim nShift As Long
  
  l = 1
  Do
    DoEvents
    nChar = Mid$(Keys, l, 1)
    Select Case nChar
      Case "+"
        nShiftState = nShiftState Or vbShiftMask
        l = l + 1
      Case "^"
        nShiftState = nShiftState Or vbCtrlMask
        l = l + 1
      Case "%"
        nShiftState = nShiftState Or vbAltMask
        l = l + 1
      Case "~"
        SendKey vbKeyReturn, nShiftState
        nShiftState = 0
        l = l + 1
      Case "{"
        nRepeats = 1
        nPos = InStr(l + 1, Keys, "}")
        nKey = Trim$(Mid$(Keys, l + 1, nPos - l - 1))
        If Len(nKey) = 0 Then
          If Mid$(Keys, nPos + 1, 1) = "}" Then
            nKey = "}"
          End If
        End If
        If Len(nKey) Then
          Select Case UCase$(nKey)
            Case "SHIFT", "UMSCHALT", "UMSCH"
              nKeyCode = vbKeyShift
            Case "CTRL", "STRG", "CONTROL"
              nKeyCode = vbKeyControl
            Case "ALT"
              nKeyCode = vbKeyMenu
            Case "BACKSPACE", "BS", "BKSP", "BACK"
              nKeyCode = vbKeyBack
            Case "BREAK"
              nKeyCode = vbKeyPause
            Case "CAPSLOCK"
              nKeyCode = vbKeyCapital
            Case "DELETE", "DEL"
              nKeyCode = vbKeyDelete
            Case "DOWN"
              nKeyCode = vbKeyDown
            Case "END"
              nKeyCode = vbKeyEnd
            Case "ENTER"
              nKeyCode = vbKeyReturn
            Case "ESC", "ESCAPE"
              nKeyCode = vbKeyEscape
            Case "HOME"
              nKeyCode = vbKeyHome
            Case "INSERT", "INS"
              nKeyCode = vbKeyInsert
            Case "LEFT"
              nKeyCode = vbKeyLeft
            Case "NUMLOCK"
              nKeyCode = vbKeyNumlock
            Case "PGDN"
              nKeyCode = vbKeyPageDown
            Case "PGUP"
              nKeyCode = vbKeyPageUp
            Case "PRTSC"
              nKeyCode = vbKeySnapshot
            Case "RIGHT"
              nKeyCode = vbKeyRight
            Case "SCROLLLOCK"
              nKeyCode = vbKeyScrollLock
            Case "TAB"
              nKeyCode = vbKeyTab
            Case "UP"
              nKeyCode = vbKeyUp
            Case "F1"
              nKeyCode = vbKeyF1
            Case "F2"
              nKeyCode = vbKeyF2
            Case "F3"
              nKeyCode = vbKeyF3
            Case "F4"
              nKeyCode = vbKeyF4
            Case "F5"
              nKeyCode = vbKeyF5
            Case "F6"
              nKeyCode = vbKeyF6
            Case "F7"
              nKeyCode = vbKeyF7
            Case "F8"
              nKeyCode = vbKeyF8
            Case "F9"
              nKeyCode = vbKeyF9
            Case "F10"
              nKeyCode = vbKeyF10
            Case "F11"
              nKeyCode = vbKeyF11
            Case "F12"
              nKeyCode = vbKeyF12
            Case "F13"
              nKeyCode = vbKeyF13
            Case "F14"
              nKeyCode = vbKeyF14
            Case "F15"
              nKeyCode = vbKeyF15
            Case "F16"
              nKeyCode = vbKeyF16
            Case "{", "}", "[", "]", "+", "^", "%"
              nKeyCode = GetKeyCodeFromAscii(nKey, nShiftState)
            Case Else
              nPosSpace = InStr(nKey, " ")
              If nPosSpace Then
                nRepeat = Trim$(Mid$(nKey, nPosSpace + 1))
                If IsNumeric(nRepeat) Then
                  nKey = Left$(nKey, nPosSpace - 1)
                  Select Case UCase$(nKey)
                    Case "BACKSPACE", "BS", "BKSP"
                      nKeyCode = vbKeyBack
                    Case "BREAK"
                      'nKeyCode
                    Case "CAPSLOCK"
                      'nKeyCode=
                    Case "DELETE", "DEL"
                      nKeyCode = vbKeyDelete
                    Case "DOWN"
                      nKeyCode = vbKeyDown
                    Case "END"
                      nKeyCode = vbKeyEnd
                    Case "ENTER", "~"
                      nKeyCode = vbKeyReturn
                    Case "ESC", "ESCAPE"
                      nKeyCode = vbKeyEscape
                    Case "HOME"
                      nKeyCode = vbKeyHome
                    Case "INSERT", "INS"
                      nKeyCode = vbKeyInsert
                    Case "LEFT"
                      nKeyCode = vbKeyLeft
                    Case "NUMLOCK"
                      nKeyCode = vbKeyNumlock
                    Case "PGDN"
                      nKeyCode = vbKeyPageDown
                    Case "PGUP"
                      nKeyCode = vbKeyPageUp
                    Case "PRTSC"
                      nKeyCode = vbKeyPrint
                    Case "RIGHT"
                      nKeyCode = vbKeyRight
                    Case "SCOLLLOCK"
                      nKeyCode = vbKeyScrollLock
                    Case "TAB"
                      nKeyCode = vbKeyTab
                    Case "UP"
                      nKeyCode = vbKeyUp
                    Case "F1"
                      nKeyCode = vbKeyF1
                    Case "F2"
                      nKeyCode = vbKeyF2
                    Case "F3"
                      nKeyCode = vbKeyF3
                    Case "F4"
                      nKeyCode = vbKeyF4
                    Case "F5"
                      nKeyCode = vbKeyF5
                    Case "F6"
                      nKeyCode = vbKeyF6
                    Case "F7"
                      nKeyCode = vbKeyF7
                    Case "F8"
                      nKeyCode = vbKeyF8
                    Case "F9"
                      nKeyCode = vbKeyF9
                    Case "F10"
                      nKeyCode = vbKeyF10
                    Case "F11"
                      nKeyCode = vbKeyF11
                    Case "F12"
                      nKeyCode = vbKeyF12
                    Case "F13"
                      nKeyCode = vbKeyF13
                    Case "F14"
                      nKeyCode = vbKeyF14
                    Case "F15"
                      nKeyCode = vbKeyF15
                    Case "F16"
                      nKeyCode = vbKeyF16
                    Case Else
                      nKeyCode = _
                       GetKeyCodeFromAscii(nKey, nShiftState)
                  End Select
                  nRepeats = CLng(nRepeat)
                End If
              Else
                nKeyCode = GetKeyCodeFromAscii(nKey, nShiftState)
              End If
          End Select
          If nKeyCode Then
            SendKey nKeyCode, nShiftState, nRepeats
          End If
        End If
        nShiftState = 0
        l = nPos + 1
      Case "("
        nPos = InStr(l + 1, Keys, ")")
        nKey = Trim$(Mid$(Keys, l + 1, nPos - l - 1))
        For ll = 1 To Len(nKey)
          nShift = nShiftState
          nKeyCode = _
           GetKeyCodeFromAscii(Mid$(nKey, ll, 1), nShift)
          SendKey nKeyCode, nShift
        Next 'll
        nShiftState = 0
        l = nPos + 1
      Case Else
        nKeyCode = GetKeyCodeFromAscii(nChar, nShiftState)
        SendKey nKeyCode, nShiftState
        nShiftState = 0
        l = l + 1
    End Select
  Loop Until l > Len(Keys)
End Sub

Modul modSendKeys (modSendKeys.bas - ca. 16,2 KB)


Artikel
Zum Download-Bereich dieses Artikel
Mail an den Autor dieses Artikels

KnowHow
Zur KnowHow-Übersicht

KnowHow-Themen
Themen - Allgemeines
Themen - Entwicklungsumgebung (VB-IDE)
Themen - Forms
Themen - Steuerelemente (Controls)
Themen - Grafik
Themen - Dateien
Themen - UserControls
Themen - Einsteiger-Tipps
Themen - Wussten Sie...?

Übersicht nach Titeln in alphabetischer Reihenfolge
Übersicht nach Erscheinungsdatum

Schnellsuche




Zum Seitenanfang

Copyright © 1999 - 2017 Harald M. Genauck, ip-pro gmbh  /  Impressum

Zum Seitenanfang

Zurück...

Zurück...

Download Internet Explorer