| |
| In diesem Forum haben Sie die Möglichkeit Kommentare, Fragen und Verbesserungsvorschläge zu den im vb@rchiv gelisteten Tipps und Workshops zu posten.
Hinweis: Ein neues Thema kann immer nur über die jeweilige Tipps & Tricks bzw. Workshop Seite eröffnet werden! | Fragen zu Tipps & Tricks und Workshops im vb@rchivTipp 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 !! | |
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 | |
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 | |
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 | |
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. | |
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! | |
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! | |
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! | |
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! | |
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! | |
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! | |
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. | |
Re: Alternative zur SendKeys-Anweisung | | | Autor: BT-Soft | Datum: 16.11.23 13:45 |
| @Andreas M und @Paul Schäfer,
mir auch anno 2023. Ohne Dein Feedback Paul hätte ich Andreas M Eintrag überlesen. Danke schön.
Anwendung starten
TaskID = Shell("Notepad.exe", vbNormalFocus) Anwendung beenden
AppActivate TaskID, True 'fremder anwendung focus zuweisen
DoEvents
keybd_event vbKeyMenu, 0, 0, 0 'alt-taste senden
SendKeysEx "{F4}" 'F4-Taste senden
keybd_event vbKeyMenu, 0, KEYEVENTF_KEYUP, 0 'ausführung | |
| Sie sind nicht angemeldet! Um einen neuen Beitrag schreiben zu können, müssen Sie sich zunächst anmelden.
Einloggen | Neu registrieren |
|
|
Neu! sevCoolbar 3.0
Professionelle Toolbars im modernen Design!
Mit sevCoolbar erstellen Sie in wenigen Minuten ansprechende und moderne Toolbars und passen diese optimal an das Layout Ihrer Anwendung an (inkl. große Symbolbibliothek) - für VB und MS-Access Weitere InfosTipp des Monats März 2024 Dieter OtterUTF-8 Konvertierung von Dateien und StringsVB6 selbst verfügt über keine Funktionen zur UTF-8 Konvertierung von Daten. Mit Hilfe des ADODB.Stream-Objekts lassen sich diese fehlenden Funktionen aber schnell nachrüsten. TOP Entwickler-Paket
TOP-Preis!!
Mit der Developer CD erhalten Sie insgesamt 24 Entwickler- komponenten und Windows-DLLs. Die Einzelkomponenten haben einen Gesamtwert von 1605.50 EUR...
Jetzt nur 599,00 EURWeitere Infos
|