vb@rchiv
VB Classic
VB.NET
ADO.NET
VBA
C#
vb@rchiv Offline-Reader - exklusiv auf der vb@rchiv CD Vol.4  
 
zurück

In diesem Forum haben Sie die Möglichkeit Kommentare, Fragen und Verbesserungsvorschläge zu den im [email protected] gelisteten Tipps und Workshops zu posten.

Hinweis:
Ein neues Thema kann immer nur über die jeweilige Tipps & Tricks bzw. Workshop Seite eröffnet werden!

 Sie sind aktuell nicht angemeldet.Funktionen: Einloggen  |  Neu registrieren  |  Suchen

Fragen zu Tipps & Tricks und Workshops im [email protected]
Tipp 542: Alternative zur SendKeys-Anweisung 
Autor: Kartoffel
 Tipp anzeigenDatum: 30.06.08 11:38

Hallo,
ich benutze auch die alternative keybd Anweisung,

keybd_event (Taste), 0, 0, 0

habe jedoch ein Problem
das die Taste nur 1x bei jedem Aufruf an mein Fenster gesendet wird.

Wie kann ich einen dauernden Tastendruck simulieren ??

Hinweis:
Ich möchte keine Schleifenwiederholung eines Tastendrucks, sondern das eine Taste solange gedrückt bleibt bis ich KEYUP auslöse.

keybd_event (Taste), 0, KEYEVENTF_KEYUP, 0

Wenn ich z.b. in einer Anwendung eine Taste gedrückt halte, schreibt er diese Taste solange in den Tastaturpuffer bis ich loslasse, nicht so bei der keybd Anweisung.
Mache ich vielleicht etwas falsch oder gibt es eine andere Möglichkeit.

Ich hoffe es kann mir einer bei meinem Problem helfen. Danke !!
Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: Bazi
Datum: 20.04.10 19:05

Hallo,

wie sende ich mit SendKeysEx eine Tastenkombination mit
[Strg] + [Alt] + l ?
Bekomme es einfach nicht hin
Danke im voraus
Christian

Danke für die Hilfe

Gruß Christian

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: Andreas M.
Datum: 09.07.11 12:46

Hallo,

erstmal vielen Dank für die "Alternative zur SendKeys-Anweisung"
hat mir bei Windows 7 sehr geholfen.

Aber wie verwendet man die SHIFT-Taste in Kombination mit der TAB-Taste

SendKeysEx "{TAB}" funzt
SendKeysEx "+{TAB}" funzt nicht

Bitte um Hilfe
Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: Andreas M.
Datum: 09.07.11 20:18

Hat sich erledigt nach längerem Googeln

keybd_event vbKeyShift, 0, 0, 0
SendKeysEx "{TAB}"
keybd_event vbKeyShift, 0, KEYEVENTF_KEYUP, 0


Und nicht vergessen die

Private Declare Sub keybd_event
Privat Const KEYEVENTF_KEYUP = &H2


auf Public zu ändern
Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: stev-e87
Datum: 19.09.12 13:37

Hallo,

also so wie ich den Source lese, sollte es doch ohne diesen Umweg gehen, da dei Steuerzeichen +,%,^ abgefragt werden. Ich bekomme es aber auch nicht hin irgendwas mit diesen Zeichen einzuleiten.

Sendkeysex "^v" sendet ein "v" an das Textfeld usw.
Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: NoRoutine
Datum: 23.05.14 22:55

Hallo,
interessant, wie aktuell ein 2002 verfaßter Beitrag auch nach 12 Jahren noch ist.
Für die Veröffentlichung kann ich mich jedenfalls nur bedanken, da ich sonst ziemlich aufgeschmissen gewesen wäre. Funktionsbibliotheken sind für mich terra incognita.
Mein Problem ist, daß ich geschützten Code in Excel-Formularen pflegen muß. Blöd genug, daß in Anwenderdateien überhaupt Code enthalten ist, läßt sich aber nicht vermeiden, da die Formulare auf eine zentrale Datenbasis zugreifen.
Programmieren ist eigentlich eher mein Privatvergnügen, aber mit den Jahren habe ich doch eine Menge Erfahrungen gesammelt, die ich in meinem Job gerne einbringe. So wird Arbeit zu Spaß! Eine ganz neue Herausforderung ist, Anwendungen zu erstellen, die von Kollegen genutzt werden.
Im Wesentlichen arbeite ich mit den Möglichkeiten, die VBA in MS Office zur Verfügung stellt.
Wie eigentlich klar sein dürfte, bin ich an der mangelnden Zuverlässigkeit der Sendkeys-Anweisung gescheitert und bei der Suche nach Alternativen auf die hier veröffentlichte Lösung gestoßen.
Die rudimentäre Funktionalität hat mich gestört. So habe ich mir den Code genauer angesehen und festgestellt, daß die Grundlagen gut abgebildet werden, die erweiterten Funktionen aber nicht umgesetzt sind.
Da ich so nicht damit arbeiten konnte, lag es nahe, die fehlenden Teile zu ergänzen. Das Ergebnis möchte ich Euch nicht vorenthalten und so auch etwas zurückgeben.
Nach ausführlichen Tests gehe ich davon aus, daß die Funktionen wie erwartet arbeiten. Falls jemand Spaß an der Lösung hat und noch Verbesserungspotential entdecken sollte, wäre ich für ein Feedback dankbar.
So, hier kommt der Code. Der Ursprung dürfte klar erkennbar sein.
Die zu sendende Zeichenkette wird in der Variablen sText an SendKeyStr übergeben.

Georg

Option Explicit
 
' Required API-Declarations
Public Declare Sub keybd_event Lib "User32" ( _
    ByVal bVk As Byte, _
    ByVal bScan As Byte, _
    ByVal dwFlags As Long, _
    ByVal dwExtraInfo As Long)                                      ' 
    ' Synthesize Keystroke
 
Private Declare Function VkKeyScan Lib "User32" _
    Alias "VkKeyScanA" ( _
    ByVal cChar As Byte) As Integer                                 ' Translate 
    ' Character into Virtual-Key Code and SHIFT State
 
Private Declare Function MapVirtualKey Lib "User32" _
    Alias "MapVirtualKeyA" ( _
    ByVal wCode As Long, _
    ByVal wMapType As Long) As Long                                 ' Translate 
    ' Virtual-Key Code into Scan Code or Character Value
 
Public Const KEYEVENTF_KEYUP = &H2                                  ' Keystroke 
' Flag for KeyUp
Private Const KEYEVENTF_EXTENDEDKEY = &H1                           ' Keystroke 
' Flag for Extended Key
 
' Virtual KeyCodes
Private Enum eVirtualKeyCode
    VK_BAK = &H8
    VK_TAB = &H9
    VK_CLEAR = &HC
    VK_RETURN = &HD
    VK_SHIFT = &H10
    VK_CONTROL = &H11
    VK_MENU = &H12
    VK_PAUSE = &H13
    VK_CAPITAL = &H14
    VK_ESCAPE = &H1B
    VK_PRIOR = &H21
    VK_NEXT = &H22
    VK_END = &H23
    VK_HOME = &H24
    VK_LEFT = &H25
    VK_UP = &H26
    VK_RIGHT = &H27
    VK_DOWN = &H28
    VK_SELECT = &H29
    VK_SNAPSHOT = &H2C                                              ' Print Key
    VK_INSERT = &H2D
    VK_DELETE = &H2E
    VK_HELP = &H2F
    VK_F1 = &H70
    VK_F2 = &H71
    VK_F3 = &H72
    VK_F4 = &H73
    VK_F5 = &H74
    VK_F6 = &H75
    VK_F7 = &H76
    VK_F8 = &H77
    VK_F9 = &H78
    VK_F10 = &H79
    VK_F11 = &H7A
    VK_F12 = &H7B
    VK_F13 = &H7C
    VK_F14 = &H7D
    VK_F15 = &H7E
    VK_F16 = &H7F
    VK_NUMLOCK = &H90
    VK_SCROLL = &H91
    VK_WIN = &H5B                                                   ' Windows 
    ' Key
    VK_APPS = &H5D                                                  ' Key for 
    ' Context Menu1
End Enum
 
Dim bShift As Boolean, bAlt As Boolean, bCtrl As Boolean            ' Flags for 
' Shift, Alt, Ctrl
Dim bShiftd As Boolean, bAltd As Boolean, bCtrld As Boolean         ' Flags for 
' KEYDOWN State of Control Keys
Dim bRound As Boolean, bCurly As Boolean                            ' Flags for 
' Brackets
Dim SendKeyDebug As Boolean                                         ' Flag for 
' Debugging
Uh, die Beschränkung der Zeilenlänge beeinträchtigt die Lesbarkeit des Codes etwas.

Das muß doch irgendwie gehen!

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: NoRoutine
Datum: 23.05.14 22:57

Zweiter Teil
Public Sub SendKeyStr(ByVal sText As String)                        ' Send Text 
' to active Control by simulating Key Strokes
Dim sChar As String, sString As String, sRep As String              ' Character 
' to analyze, String to send, Repetitions
Dim I As Integer, J As Integer, iRep As Integer, iPos As Integer    ' Loop 
' Counters, Number of Repetitions, Position within String
Dim bRep As Boolean                                                 ' Flag for 
' last Repetition
 
SendKeyDebug = False
 
    If SendKeyDebug Then Kdebug "Start with " & sText
    sRep = "0"                                                      ' Initialize
    For I = 1 To Len(sText)                                         ' Loop: 
    ' process String
        sChar = Mid(sText, I, 1)                                    ' Get 
        ' Character
 
'       Analyse Character; check +%^, if any set Flag. Multiple +%^ have no 
' effect
        If sChar = "+" Then                                         ' Shift
            bShift = True
            sChar = ""
        ElseIf sChar = "%" Then                                     ' ALT
            bAlt = True
            sChar = ""
        ElseIf sChar = "^" Then                                     ' STRG
            bCtrl = True
            sChar = ""
        End If
        If (bShift And Not bShiftd) Or (bAlt And Not bAltd) Or (bCtrl And Not _
          bCtrld) Then
            If SendKeyDebug Then Kdebug "before send Control Key; " & sChar
            SendKeysEx bRep, sChar                                  ' Send 
            ' Control Keys if any
            If SendKeyDebug Then Kdebug "after send Control Key"
        Else
            If sChar = "(" Then                                     ' Round 
            ' Bracket found?
                bRound = True
                I = I + 1
            ElseIf sChar = "{" Then                                 ' Curly 
            ' Bracket found?
                bCurly = True                                                   _
                      ' Is evaluated in SendKeysEx
                If InStr(I + 1, sText, "}") > 0 Then                         _
                       ' Closing curly Bracket found?
                    sString = Mid(sText, I + 1, InStr(I + 1, sText, "}") - I - _
                    1)   ' Get Text inside curly Brackets
                    I = I + Len(sString) + 1                                    _
                        ' Set Index to closing curly Bracket before altering 
                    ' sString
                    iPos = InStrRev(sString, " ")                               _
                          ' Find Delimiter from Text to Number of Replications
                    If iPos > 0 Then
                        sRep = Mid(sString, iPos + 1, Len(sString) - iPos)      _
                              ' Number of Replications
                        If IsNumber(sRep) Then
                            sString = Left(sString, iPos - 1)                   _
                                  ' Raw Text to send
                        End If
                    End If
                    If sRep = "0" Then                                          _
                          ' Determine Number of Repetitions
                        iRep = 1
                    Else
                        iRep = CInt(sRep)
                    End If
                    For J = 1 To iRep
                        If J = iRep Then bRep = True                            _
                              ' last repetition reached, reset Control Keys
                        If SendKeyDebug Then Kdebug "before send Output within" & _
                        "curly Brackets; bcurly: " & bCurly & "; " & sString
                        SendKeysEx bRep, sString                                _
                            ' Send Output within curly Brackets
                        If SendKeyDebug Then Kdebug "after send Output within" & _
                        "curly Brackets; bcurly: " & bCurly & "; " & sString
                    Next
                    bRep = False
                    sRep = "0"                                                  _
                          ' Reset Number of Repetitions
                    bCurly = False                                              _
                        ' Reset Flag
                End If
            End If
 
'           Send each single Character up to next ) or {
            sChar = Mid(sText, I, 1)                                ' Determine 
            ' current Character

Das muß doch irgendwie gehen!

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: NoRoutine
Datum: 23.05.14 23:00

Dritter Teil
Oha! Drei reichen ja immer noch nicht! Hoffentlich geht beim zerhacken nichts verloren.

            If sChar = ")" Then                                     ' Reset 
            ' Control Keys if closing round Bracket found
                If bRound Then
                    sChar = ""                                      ' No 
                    ' Character to be sent
                    bRep = True                                     ' Last 
                    ' Repetition; used for resetting of Control Keys
                    If SendKeyDebug Then Kdebug "before Reset Control Keys" & _
                      "ahead round Brackets; " & sChar
                    SendKeysEx bRep, sChar                          ' Reset 
                    ' Control Keys
                    If SendKeyDebug Then Kdebug "after Reset Control Keys ahead" & _
                      "round Brackets"
                    bRep = False
                    bRound = False
                Else
                    I = I + 1                                       ' Ignore 
                    ' and get next Character
                    sChar = Mid(sText, I, 1)
                End If
            End If
            If InStr("()[]}~+%^", sChar) = 0 Then                   ' Control 
            ' Characters as Output only allowed inside curly Brackets; treated 
            ' above, ignore here
                If SendKeyDebug Then Kdebug "before send single Character; " & _
                  sChar
                SendKeysEx bRep, sChar                              ' Send 
                ' single Character
                If SendKeyDebug Then Kdebug "after send single Character"
                If Not bRound And (bShift Or bAlt Or bCtrl) Then
                    If SendKeyDebug Then Kdebug "before reset Control Keys" & _
                      "after sending single Character; " & sChar
                    SendKeysEx True, ""                             ' Reset all 
                    ' Control Keys (for example in Case shifted single 
                    ' Character had been sent)
                    If SendKeyDebug Then Kdebug "after reset Control Keys after" & _
                      "sending single Character"
                End If
            ElseIf sChar = "{" Then                                 ' Handle in 
            ' next loop run
                I = I - 1
            End If
        End If
    Next
End Sub                                                             ' SendKeyStr
 
Sub SendKeysEx(bRep As Boolean, sString As String)
Dim VK As eVirtualKeyCode, VK_Special As eVirtualKeyCode, strChar As String
Dim J As Integer, VKStart As Integer, VKLen As Integer          ' Loop Counter, 
' Start and Length of Special Key
Dim bShiftS As Boolean                                          ' Flag for 
' single Capital Letter
Dim nScan As Long
Dim nExtended As Long
 
'   Send Control Key(s) if any
    If bShift And Not bShiftd Then
        keybd_event VK_SHIFT, 0, 0, 0
        bShiftd = True                                          ' Set 
        ' "pressed"-Flag
    End If
    If bCtrl And Not bCtrld Then
        keybd_event VK_CONTROL, 0, 0, 0
        bCtrld = True
    End If
    If bAlt And Not bAltd Then
        keybd_event VK_MENU, 0, 0, 0
        bAltd = True
    End If

Das muß doch irgendwie gehen!

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: NoRoutine
Datum: 23.05.14 23:03

Vierter Teil

    For J = 1 To Len(sString)
        If bCurly Then                                          ' Process 
        ' Characters in curly Brackets
            If VKStart = 0 Then                                 ' ... process 
            ' Special Key if present
                If InStr(J, sString, "BACKSPACE") > 0 Then
                    VK_Special = VK_BAK:        VKStart = InStr(J, sString, _
                      "BACKSPACE"):   VKLen = 9
                ElseIf InStr(J, sString, "BS") > 0 Then
                    VK_Special = VK_BAK:        VKStart = InStr(J, sString, _
                      "BS"):      VKLen = 2
                ElseIf InStr(J, sString, "BKSP") > 0 Then
                    VK_Special = VK_BAK:        VKStart = InStr(J, sString, _
                      "BKSP"):    VKLen = 4
                ElseIf InStr(J, sString, "BREAK") > 0 Then
                    VK_Special = VK_PAUSE:      VKStart = InStr(J, sString, _
                      "BREAK"):   VKLen = 5
                ElseIf InStr(J, sString, "CAPSLOCK") > 0 Then
                    VK_Special = VK_CAPITAL:    VKStart = InStr(J, sString, _
                      "CAPSLOCK"):    VKLen = 8
                ElseIf InStr(J, sString, "DELETE") > 0 Then
                    VK_Special = VK_DELETE:     VKStart = InStr(J, sString, _
                      "DELETE"):  VKLen = 6
                ElseIf InStr(J, sString, "DEL") > 0 Then
                    VK_Special = VK_DELETE:     VKStart = InStr(J, sString, _
                      "DEL"):     VKLen = 3
                ElseIf InStr(J, sString, "DOWN") > 0 Then
                    VK_Special = VK_DOWN:       VKStart = InStr(J, sString, _
                      "DOWN"):    VKLen = 4
                ElseIf InStr(J, sString, "UP") > 0 Then
                    VK_Special = VK_UP:         VKStart = InStr(J, sString, _
                      "UP"):      VKLen = 2
                ElseIf InStr(J, sString, "LEFT") > 0 Then
                    VK_Special = VK_LEFT:       VKStart = InStr(J, sString, _
                      "LEFT"):    VKLen = 4
                ElseIf InStr(J, sString, "RIGHT") > 0 Then
                    VK_Special = VK_RIGHT:      VKStart = InStr(J, sString, _
                      "RIGHT"):   VKLen = 5
                ElseIf InStr(J, sString, "END") > 0 Then
                    VK_Special = VK_END:        VKStart = InStr(J, sString, _
                      "END"):     VKLen = 3
                ElseIf InStr(J, sString, "ENTER") > 0 Then
                    VK_Special = VK_RETURN:     VKStart = InStr(J, sString, _
                      "ENTER"):   VKLen = 5
                ElseIf InStr(J, sString, "~") > 0 Then
                    VK_Special = VK_RETURN:     VKStart = InStr(J, sString, _
                      "~"):       VKLen = 1
                ElseIf InStr(J, sString, "HOME") > 0 Then
                    VK_Special = VK_HOME:       VKStart = InStr(J, sString, _
                      "HOME"):    VKLen = 4
                ElseIf InStr(J, sString, "ESC") > 0 Then
                    VK_Special = VK_ESCAPE:     VKStart = InStr(J, sString, _
                      "ESC"):     VKLen = 3
                ElseIf InStr(J, sString, "HELP") > 0 Then
                    VK_Special = VK_HELP:       VKStart = InStr(J, sString, _
                      "HELP"):    VKLen = 4
                ElseIf InStr(J, sString, "INSERT") > 0 Then
                    VK_Special = VK_INSERT:     VKStart = InStr(J, sString, _
                      "INSERT"):  VKLen = 6
                ElseIf InStr(J, sString, "INS") > 0 Then
                    VK_Special = VK_INSERT:     VKStart = InStr(J, sString, _
                      "INS"):     VKLen = 3
                ElseIf InStr(J, sString, "NUMLOCK") > 0 Then
                    VK_Special = VK_NUMLOCK:    VKStart = InStr(J, sString, _
                      "NUMLOCK"): VKLen = 7
                ElseIf InStr(J, sString, "PGUP") > 0 Then
                    VK_Special = VK_PRIOR:      VKStart = InStr(J, sString, _
                      "PGUP"):    VKLen = 4
                ElseIf InStr(J, sString, "PGDN") > 0 Then
                    VK_Special = VK_NEXT:       VKStart = InStr(J, sString, _
                      "PGDN"):    VKLen = 4
                ElseIf InStr(J, sString, "SCROLLLOCK") > 0 Then
                    VK_Special = VK_SCROLL:     VKStart = InStr(J, sString, _
                      "SCROLLLOCK"):  VKLen = 10
                ElseIf InStr(J, sString, "TAB") > 0 Then
                    VK_Special = VK_TAB:        VKStart = InStr(J, sString, _
                      "TAB"):     VKLen = 3

Das muß doch irgendwie gehen!

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: NoRoutine
Datum: 23.05.14 23:04

Fünfter und hoffentlich letzter Teil

                ElseIf InStr(J, sString, "F1") > 0 Then
                    VK_Special = VK_F1:         VKStart = InStr(J, sString, _
                      "F1"):      VKLen = 2
                ElseIf InStr(J, sString, "F2") > 0 Then
                    VK_Special = VK_F2:         VKStart = InStr(J, sString, _
                      "F2"):      VKLen = 2
                ElseIf InStr(J, sString, "F3") > 0 Then
                    VK_Special = VK_F3:         VKStart = InStr(J, sString, _
                      "F3"):      VKLen = 2
                ElseIf InStr(J, sString, "F4") > 0 Then
                    VK_Special = VK_F4:         VKStart = InStr(J, sString, _
                      "F4"):      VKLen = 2
                ElseIf InStr(J, sString, "F5") > 0 Then
                    VK_Special = VK_F5:         VKStart = InStr(J, sString, _
                      "F5"):      VKLen = 2
                ElseIf InStr(J, sString, "F6") > 0 Then
                    VK_Special = VK_F6:         VKStart = InStr(J, sString, _
                      "F6"):      VKLen = 2
                ElseIf InStr(J, sString, "F7") > 0 Then
                    VK_Special = VK_F7:         VKStart = InStr(J, sString, _
                      "F7"):      VKLen = 2
                ElseIf InStr(J, sString, "F8") > 0 Then
                    VK_Special = VK_F8:         VKStart = InStr(J, sString, _
                      "F8"):      VKLen = 2
                ElseIf InStr(J, sString, "F9") > 0 Then
                    VK_Special = VK_F9:         VKStart = InStr(J, sString, _
                      "F9"):      VKLen = 2
                ElseIf InStr(J, sString, "F10") > 0 Then
                    VK_Special = VK_F10:        VKStart = InStr(J, sString, _
                      "F10"):     VKLen = 3
                ElseIf InStr(J, sString, "F11") > 0 Then
                    VK_Special = VK_F11:        VKStart = InStr(J, sString, _
                      "F11"):     VKLen = 3
                ElseIf InStr(J, sString, "F12") > 0 Then
                    VK_Special = VK_F12:        VKStart = InStr(J, sString, _
                      "F12"):     VKLen = 3
                ElseIf InStr(J, sString, "F13") > 0 Then
                    VK_Special = VK_F13:        VKStart = InStr(J, sString, _
                      "F13"):     VKLen = 3
                ElseIf InStr(J, sString, "F14") > 0 Then
                    VK_Special = VK_F14:        VKStart = InStr(J, sString, _
                      "F14"):     VKLen = 3
                ElseIf InStr(J, sString, "F15") > 0 Then
                    VK_Special = VK_F15:        VKStart = InStr(J, sString, _
                      "F15"):     VKLen = 3
                ElseIf InStr(J, sString, "F16") > 0 Then
                    VK_Special = VK_F16:        VKStart = InStr(J, sString, _
                      "F16"):     VKLen = 3
                ElseIf InStr(J, sString, "WIN") > 0 Then
                    VK_Special = VK_WIN:        VKStart = InStr(J, sString, _
                      "WIN"):     VKLen = 3   ' Windows Key
                ElseIf InStr(J, sString, "APPS") > 0 Then
                    VK_Special = VK_APPS:       VKStart = InStr(J, sString, _
                      "APPS"):    VKLen = 4   ' Context Menu
                ElseIf InStr(J, sString, "PRINT") > 0 Then
                    VK_Special = VK_SNAPSHOT:   VKStart = InStr(J, sString, _
                      "PRINT"):   VKLen = 5   ' PrintScreen Key
                End If                                          ' Special Key
            End If                                              ' VKStart
        End If                                                  ' bCurly
        If J < VKStart Or J >= VKStart + VKLen Then             ' Process 
        ' single Key
            strChar = Mid(sString, J, 1)                        ' Get single 
            ' Character
            VK = VkKeyScan(Asc(strChar))                        ' Determine 
            ' Virtual KeyCode ...
        ElseIf J = VKStart Then                                 ' Start of 
        ' Special Key
            VK = VK_Special                                     ' Assign 
            ' Special Key
            J = J + VKLen - 1                                   ' Set J to last 
            ' Character of Special Key
            VKStart = 0                                         ' Another 
            ' Special Key might occur
        End If

Das muß doch irgendwie gehen!

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: NoRoutine
Datum: 23.05.14 23:04

Grrr! Endlich!

        nScan = MapVirtualKey(VK, 2)                            ' unshifted 
        ' Character Value in low-Order Word of Return Value. No Translation => 0
        nExtended = 0                                           ' Preset Key 
        ' for Switch
        If nScan = 0 Then nExtended = KEYEVENTF_EXTENDEDKEY     ' KeyDown Switch
        nScan = MapVirtualKey(VK, 0)                            ' Hardware Scan 
        ' Code. No Translation => 0
 
        bShiftS = (VK And &H100)                                ' Capital 
        ' Letter; add SHIFT Key; a second Flag must be set here to distinguish 
        ' from Control Key
        VK = (VK And &HFF)                                      ' Reduce VK to 
        ' lower Byte
 
'       Press Shift Key for single Character only if Shift Key for String isn't _
  set
        If Not bShift And bShiftS Then keybd_event VK_SHIFT, 0, 0, 0
 
'       Press and release Character resp. Special Key
        keybd_event VK, nScan, nExtended, 0
        keybd_event VK, nScan, KEYEVENTF_KEYUP Or nExtended, 0
 
'       Release Shift Key for single Character only if Shift Key for String 
' isn't set
        If Not bShift And bShiftS Then
            keybd_event VK_SHIFT, 0, KEYEVENTF_KEYUP, 0
            bShiftS = False
        End If
    Next J
 
'   Release Control Key(s) after last (as may be only one) Repetition of String
    If bRep Then
        If bShift And bShiftd Then
            keybd_event VK_SHIFT, 0, KEYEVENTF_KEYUP, 0
            bShift = False                                      ' Reset Flags
            bShiftd = False
        End If
        If bCtrl And bCtrld Then
            keybd_event VK_CONTROL, 0, KEYEVENTF_KEYUP, 0
            bCtrl = False
            bCtrld = False
        End If
        If bAlt And bAltd Then
            keybd_event VK_MENU, 0, KEYEVENTF_KEYUP, 0
            bAlt = False
            bAltd = False
        End If
    End If
 
End Sub                                                         ' SendKeysEx
 
Function IsNumber(CString As String)                            ' Check String 
' whether only Numbers occur
Dim Nr As Integer, CAsc As String
 
    For Nr = 1 To Len(CString)
        CAsc = Asc(Mid(CString, Nr, 1))
        If CAsc < 48 Or CAsc > 57 Then
            Exit Function
        End If
    Next
    IsNumber = True
 
End Function                                                    ' IsNumber
 
Sub Kdebug(Msg As String)
Debug.Print Msg
Debug.Print "bshift : " & bShift & vbTab & "bCtrl : " & bCtrl & vbTab & "bAlt :" & _
  "" & bAlt
Debug.Print "bshiftd: " & bShiftd & vbTab & "bCtrld: " & bCtrld & vbTab & _
"bAltd: " & bAltd & vbLf
End Sub
 
Sub test()
Dim strTest As String
Worksheets("Tabelle1").Activate
strTest = Cells(1, 10)
Cells(12, 10).Select
SendKeyStr strTest
End Sub

Das muß doch irgendwie gehen!

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Re: Alternative zur SendKeys-Anweisung 
Autor: Paul Schäfer
Datum: 01.03.22 09:54

Das hier, Andreas M., hat mir sogar noch heute geholfen.
Denn wie stev-e87 schreibt, fkt. 2 Zeichen (z.B. ^z) in SendKeysEx bei mir auch nicht (es kommt nur z).
Desgleichen auch beim Tipp https://www.vbarchiv.net/tipps/tipp_542-alternative-zur-sendkeys-anweisung.html.
Aber einzeln abarbeiten geht prima.

Also danke!

Grüße von Paul

Beitrag wurde zuletzt am 01.03.22 um 09:56:28 editiert.

Themenbaum einblendenGesamtübersicht  |  Zum Thema  |  Suchen

Sie sind nicht angemeldet!
Um einen neuen Beitrag schreiben zu können, müssen Sie sich zunächst anmelden.

Einloggen  |  Neu registrieren

Funktionen:  Zum Thema  |  GesamtübersichtSuchen 

nach obenzurück
 
   

Copyright ©2000-2022 [email protected] Dieter Otter
Alle Rechte vorbehalten.
Microsoft, Windows und Visual Basic sind entweder eingetragene Marken oder Marken der Microsoft Corporation in den USA und/oder anderen Ländern. Weitere auf dieser Homepage aufgeführten Produkt- und Firmennamen können geschützte Marken ihrer jeweiligen Inhaber sein.

Diese Seiten wurden optimiert für eine Bildschirmauflösung von mind. 1280x1024 Pixel