Quiero participar en un concurso de trabajo en informática para estudiantes de secundaria. Quiero hacer programación en VB. ¿Qué materia tiene más probabilidades de ganar?
Los eventos del teclado finalmente se envían a la ventana activa y luego hacen que el programa de destino responda. Entonces, el método de simulación más directo es falsificar directamente un mensaje de teclado y enviarlo al programa de destino. Jaja, esto es realmente simple. Windows proporciona varias funciones API que pueden enviar mensajes directamente al programa de destino. Las más utilizadas son SendMessage y PostMessage. La diferencia entre ellas es que la función PostMessage envía mensajes directamente al programa de destino y los ignora. it, y después de que SendMessage envíe el mensaje, todavía tiene que esperar a que el programa de destino devuelva algo. Lo que se debe tener en cuenta aquí es que para simular mensajes de teclado, debe usar la función PostMessage. ¡El uso de SendMessage es incorrecto! La declaración VB de la función PostMessage es la siguiente:
Declare Function PostMessage Lib "user32" Alias "PostMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any ) As Long
El parámetro hwnd es el identificador de un control en el programa de destino al que desea enviar el mensaje. El parámetro wMsg es el tipo de mensaje, que indica qué tipo de mensaje desea enviar. Finalmente, los dos parámetros wParam y lParam se adjuntan al mensaje y el contenido específico lo determina el mensaje.
Echemos un vistazo al parámetro wMsg nuevamente. Esto es lo que necesita para simular pulsaciones de teclas. Los mensajes de teclado más utilizados son los siguientes:
WM_KEYDOWN indica que se presiona una tecla normal
WM_KEYUP indica que se suelta una tecla normal
WM_SYSKEYDOWN indica una tecla del sistema se presiona, como la tecla Alt
WM_SYSKEYUP indica que se ha liberado una tecla del sistema, como la tecla Alt
Si está seguro de que desea enviar los mensajes de teclado anteriores, luego echemos un vistazo a cómo determinar el teclado. Los dos parámetros wParam y lParam en el mensaje. En un mensaje de teclado, el significado del parámetro wParam es relativamente simple. Representa el código virtual clave del evento de teclado que desea enviar. Por ejemplo, si desea simular presionar la tecla A al programa de destino, entonces el valor. del parámetro wParam se establece en VK_A. En cuanto a lParam, este parámetro es más complicado porque contiene varios datos. Generalmente, se puede establecer en 0, pero si desea que su simulación sea más realista, se recomienda que lo haga. establezca este parámetro. Así que echemos un vistazo más de cerca a lParam. lParam es un parámetro de tipo largo, que ocupa 4 bytes en la memoria. Escrito en binario, es 00000000 00000000 00000000 00000000. A*** tiene 32 bits, contamos de derecha a izquierda, asumiendo que el bit más a la derecha es el bit 0 (. Tenga en cuenta que el conteo comienza desde 0 en lugar de 1), el más a la izquierda es el bit 31, luego los bits 0-15 de este parámetro representan la información extendida, como el número de veces que se envía la clave, los bits 16-23 son el El código de escaneo de la tecla, 24 bits 31, indica si la tecla se presiona o se suelta. Generalmente estamos acostumbrados a escribirlo en hexadecimal, por lo que debería ser amp H00 00 00 00. Los bits 0-15 son generalmente amp H0001, entonces los bits 24-31 son amp; Se libera la clave, es HC0, entonces, ¿cómo podemos obtener el código de escaneo de 16 a 23 dígitos? Esto requiere el uso de una función API MapVirtualKey. Esta función puede convertir códigos virtuales en códigos de escaneo, o códigos de escaneo en códigos virtuales, y también puede convertir códigos virtuales en el código ASCII del carácter correspondiente.
Su declaración VB es la siguiente:
Declarar función MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long
El parámetro wCode representa el valor que se va a convertir en código, el parámetro wMapType indica desde qué convertir. Si es un código virtual convertido a un código de escaneo, entonces wMapType se establece en 0. Si es un código de escaneo virtual convertido a un código virtual, entonces. wMapType se establece en 1. Si es un código virtual convertido a código ASCII, entonces wMapType se establece en 2. Creo que con esto podemos construir el parámetro lParam del evento de teclado. La siguiente es una función que construye parámetros lParam:
Declarar función MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long
Función MakeKeyLparam (ByVal VirtualKey As Long, ByVal flag As Long) As Long
'El parámetro VirtualKey representa el código virtual de la clave y el indicador representa si la tecla se presiona o suelta, representado por las dos constantes WM_KEYDOWN y WM_KEYUP
Dim s As String
Dim Firstbyte As String 'Bit 24-31 del parámetro lparam
If flag = WM_KEYDOWN Then 'Si se presiona la tecla
Primer byte = "00"
Else
Primer byte = "C0" 'Si es una clave de liberación
Fin Si
Dim Scancode As Long
'Obtener el código de escaneo de la clave
Scancode = MapVirtualKey(VirtualKey, 0)
Dim Secondbyte As String '16-23 bits del parámetro lparam, es decir, código de escaneo de clave virtual
Segundo byte = Derecha("00" amp; Hex(Scancode), 2)
s = Primer byte amp; Secondbyte amp; "0001" '0001 es lparam Bits 0-15 del parámetro, es decir, el número de veces de envío y otra información extendida
MakeKeyLparam = Val("amp; H" amp; s)
Función Finalizada
Esta función se llama así, por ejemplo, si se presiona la tecla A, entonces lParam=MakeKeyLparam(VK_A, WM_KEYDOWN), es muy simple. Vale la pena señalar que incluso si establece el valor del parámetro lParam al enviar el mensaje, el sistema aún puede restablecer el parámetro según la situación al entregar el mensaje. Entonces el valor de lParam en el mensaje recibido por el programa de destino puede. Ser diferente al tuyo. Se diferencia cuando se envía. Entonces, si eres vago, configúralo en 0. No afectará a la mayoría de los programas, jaja.
Bien, después de hacer lo anterior, ahora podemos enviar mensajes de teclado al programa de destino. Primero, obtenga el identificador del control que el programa de destino acepta este mensaje. Por ejemplo, el identificador de destino es 12345. Luego simulamos presionar y soltar la tecla A en el objetivo, así: (En aras de la simplicidad, lParam. el parámetro no se construye y se pasa 0 directamente)
PostMessage 12345, WM_KEYDOWN, VK_A, 0amp; Suelta la tecla A
Está bien, se hace con solo presionar una tecla. Ahora puede abrir con entusiasmo el Bloc de notas para realizar experimentos. Primero, use funciones API como FindWindowEx para encontrar el identificador del programa Bloc de notas y luego envíele mensajes de teclado, con la esperanza de que los caracteres aparezcan automáticamente en el Bloc de notas. Pero inmediatamente te decepcionaste. Oye, ¿por qué no hubo ninguna reacción? Engañas tus sentimientos~~~~~~~~~~55555555555555 No, sigue leyendo.
Generalmente, el programa de destino contendrá múltiples controles y no todos los controles responderán a los mensajes del teclado. Sólo enviando mensajes de teclado al control que los acepta obtendrá la respuesta deseada. En cuanto al Bloc de notas, su cuadro de edición es en realidad una clase de edición. Solo este control responde a los eventos del teclado. Si simplemente envía mensajes al formulario del Bloc de notas, es inútil. Ahora encuentra el identificador del cuadro de edición en el Bloc de notas, por ejemplo 54321, luego escribe el siguiente código:
PostMessage 54321, WM_KEYDOWN, VK_F1, 0amp 'Presiona la tecla F1
PostMessage 54321, WM_UP, VK_F1, 0amp; 'Suelta la tecla F1
¿Qué tal? ¿Abre la información de "Ayuda" del Bloc de notas? Esto significa que el programa de destino ha recibido el mensaje que enviaste, nada mal ~~~~~~~~
Afortunadamente, aparecerá una nueva pregunta. ¿Quieres simular presionar la tecla A en el Bloc de notas? , los caracteres se ingresaron automáticamente en el Bloc de notas, ¡pero no pasó nada! ¿Qué está sucediendo?
Resulta que si desea enviar caracteres al programa de destino, no basta con confiar en los dos eventos WM_KEYDOWN y WM_UP. También necesita un evento: WM_CHAR. Este mensaje representa un carácter. el programa necesita confiar en él para aceptar caracteres. Generalmente, solo las teclas como A, B, C, etc. tienen mensajes WM_CHAR. Otras teclas (como las teclas de dirección y de función) no tienen este mensaje. El mensaje WM_CHAR generalmente aparece después del mensaje WM_KEYDOWN.
El significado del parámetro lParam del mensaje WM_CHAR es el mismo que el de otros mensajes del teclado, y su wParam representa el código ASCII del carácter correspondiente (puede ingresar chino ^_^ Ahora puede escribir una escritura automática completa en). Programa de caracteres del Bloc de notas, el siguiente es un ejemplo, con los valores específicos de estas constantes de mensaje:
Declarar función PostMessage Lib "user32" Alias "PostMessageA" (ByVal hwnd As Long, ByVal wMsg As Long, ByVal wParam As Long, lParam As Any) As Long
Declarar función MapVirtualKey Lib "user32" Alias "MapVirtualKeyA" (ByVal wCode As Long, ByVal wMapType As Long) As Long
Const pública WM_KEYDOWN = amp; H100
Const pública WM_KEYUP = amp; H101
Const pública WM_CHAR = amp; = amp H41
Función MakeKeyLparam(ByVal VirtualKey As Long, ByVal flag As Long) As Long
Dim s As String
Dim Firstbyte As String 'Bits; 24-31 del parámetro lparam
Si flag = WM_KEYDOWN Entonces 'Si se presiona la tecla
Primer byte = "00"
De lo contrario
Firstbyte = "C0" ' Si es una clave de liberación
Fin si
Dim Scancode As Long
'Obtiene el código de escaneo de la clave
Scancode = MapVirtualKey(VirtualKey, 0)
Dim Secondbyte As String '16-23 bits del parámetro lparam, que es el código de escaneo de la clave virtual
Secondbyte = Right("00" amp; Hex(Scancode), 2)
s = Primer byte amp; Segundo byte "0001" '0001 son los bits 0-15 del parámetro lparam, es decir, el número de veces de envío y otra información extendida
MakeKeyLparam = Val("amp; H" amp; s)
End Function
Private Sub Form_Load()
dim hwnd as long
hwnd = XXXXXX 'XXXXX Representa el identificador del cuadro de edición del Bloc de notas
PostMessage hwnd, WM_KEYDOWN, VK_A, MakeKeyLparam(V
K_A, WM_KEYDOWN) 'Presiona la tecla A
PostMessage hwnd, WM_CHAR, ASC("A"), MakeKeyLparam(VK_A, WM_KEYDOWN) 'Ingresa el carácter A
PostMessage hwnd, WM_UP, VK_A, MakeKeyLparam(VK_A, WM_UP) 'Suelta la tecla A
End Sub
Esto es para simular pulsaciones de teclas a través de mensajes del teclado local. Este método tiene una gran ventaja, es decir: puede realizar pulsaciones de botones en segundo plano, lo que significa que no tendrá ningún impacto en sus operaciones en primer plano. Por ejemplo, puedes usar este método para crear un programa que simule presionar teclas en el juego para realizar continuamente ciertas operaciones repetitivas, mientras bebes té y charlas animadamente con chicas en QQ, y no afectará tu recepción en absoluto. operar. No tiene ningún efecto si el programa de destino recibe foco o no. Este es el principio de las pulsaciones de teclas de simulación en segundo plano~~~~
2. El método anterior para simular pulsaciones de teclas no es efectivo para todos los programas. Para algunos programas, le envías muchos mensajes, pero no responde en absoluto. ¿Qué está sucediendo? Esto depende de la situación específica. Algunos programas (especialmente algunos juegos) prohibirán a los usuarios utilizar programas de pulsación de teclas simulados por algunas razones. Por ejemplo, puedes comprobarlo en el programa. Si descubres que no es la ventana activa, no aceptará mensajes de teclado. O revise cuidadosamente los mensajes de teclado recibidos, encontrará que siempre hay algunas pequeñas diferencias entre las pulsaciones de teclas reales y los mensajes de pulsaciones de teclas simuladas. A partir de estas pequeñas diferencias, el programa de destino puede juzgar: ¡Esto es falso! ¡Es falso! ! Por lo tanto, si el uso de PostMessage para enviar mensajes locales para simular pulsaciones de teclas no tiene éxito, puede probar mensajes de teclado a nivel global para ver si puede engañar al programa de destino.
Existen algunas formas comunes de simular mensajes de teclado globales:
(1) Utilice la función API keybd_event. Esta función se puede utilizar para simular un evento de teclado. Su declaración VB es:
Declarar Sub keybd_event Lib "user32" (ByVal bVk As Byte, ByVal bScan As Byte, ByVal dwFlags As Long, ByVal dwExtraInfo As Long)
El parámetro bVk representa la clave que se Código virtual simulado, bScan representa el código de escaneo del botón (generalmente se puede pasar 0), dwFlags representa si la tecla se presiona o suelta (la tecla presionada es 0, la tecla liberada es 2), dwExtraInfo es el indicador de extensión, que generalmente es inútil. Por ejemplo, para simular presionar la tecla A, puedes hacer esto:
Const KEYEVENTF_KEYUP = amp H2
keybd_event VK_A, 0, 0, 0 'Presiona la tecla A
keybd_event VK_A, 0, KEYEVENTF_KEYUP, 0 'Suelta la tecla A
Tenga cuidado de no presionar la tecla demasiado rápido, de lo contrario ocurrirán problemas. Puede usar la función API Suspender para retrasar. la declaración es la siguiente:
p>Declarar Sub Sleep Lib "kernel32" (ByVal dwMillisegundos As Long)
El parámetro dwMillisegundos representa el tiempo de retraso, en milisegundos.
Entonces, ¿qué haces si quieres simular presionar una tecla de función? Por ejemplo, si desea presionar Ctrl C para realizar la función de copia, puede hacer esto:
keybd_event VK_Ctrl, 0, 0, 0 'Presione la tecla Ctrl
keybd_event VK_C , 0, 0, 0 ' Pulsa la tecla C
Dormir 500 'Retraso 500 milisegundos
keybd_event VK_C, 0, KEYEVENTF_KEYUP, 0 'Suelta la tecla C
keybd_event VK_Ctrl, 0, KEYEVENTF_KEYUP , 0 'Suelta la tecla Ctrl
Bien, ahora puedes intentar ver si puedes engañar al programa de destino. Esta función es efectiva para la mayoría de los programas de ventana, pero todavía los hay. algunos juegos que provocan eventos de teclado se ignoran. En este momento, debe utilizar el parámetro bScan. Generalmente, bScan pasa 0, pero si el programa de destino son algunos juegos DirectX, entonces debes usar este parámetro correctamente para pasar el código de escaneo. Úsalo para generar el mensaje de evento de hardware correcto para que el juego lo reconozca. En este caso, se puede escribir así:
keybd_event VK_A, MapVirtualKey(VK_A, 0), 0, 0 'Presiona la tecla A
keybd_event VK_A, MapVirtualKey(VK_A, 0), KEYEVENTF_KEYUP, 0 'Suelta la tecla A
Lo anterior es usar la función keybd_event para simular eventos de teclado. Además de esta función, la función SendInput también puede simular eventos de teclado globales. SendInput puede insertar mensajes directamente en la cola de mensajes, que es de nivel relativamente bajo. Su declaración VB es la siguiente:
Declarar Función SendInput Lib "user32.dll" (ByVal nInputs As Long, pInputs As GENERALINPUT, ByVal cbSize As Long) As Long
Parámetros:
p>nlnprts: Define el número de estructuras a las que apuntan plnputs.
plnputs: Puntero a la matriz de estructura INPUT. Cada estructura representa un evento insertado en el flujo de entrada del teclado o del mouse.
cbSize: Define el tamaño de la estructura INPUT. Si cbSize no es el tamaño de la estructura INPUT, la llamada a la función falla.
Valor de retorno: la función devuelve el número de eventos que se insertan correctamente en el flujo de entrada del teclado o del mouse. Para obtener más información sobre el error, puede llamar a la función GetlastError.
Observaciones: La función Sendlnput inserta secuencialmente los eventos en la estructura INPUT en el flujo de entrada del teclado o del mouse. Estos eventos son incompatibles con flujos de entrada insertados por el usuario (con mouse o teclado) o con teclado o mouse que llaman a keybd_event, mouse_event u otro Sendlnput.
Bueno, esta función es bastante complicada de usar, porque sus parámetros son todos punteros. Para usarlo para simular la entrada del teclado, primero debe construir un conjunto de estructuras de datos, colocar en él los mensajes del teclado que desea simular y luego pasárselos.
Por conveniencia, hágalo en un proceso y llámelo directamente cuando quiera usarlo. El código es el siguiente:
Declare Function SendInput Lib "user32.dll" (ByVal nInputs As Long, pInputs como GENERALINPUT, ByVal cbSize As Long) As Long
Declarar Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (pDst As Any, pSrc As Any, ByVal ByteLen As Long)
Escriba GENERALINPUT
dwType tan largo
xi(0 a 23) como byte
Tipo final
Escriba KEYBDINPUT
wVk como entero
wScan como entero
dwFlags mientras
tiempo mientras
dwExtraInfo mientras
Tipo de fin
Const INPUT_KEYBOARD = 1
Sub MySendKey(bkey As Long)
'Pase el parámetro bkey al código virtual de la clave a simular para simular presionar la tecla especificada
Dim GInput(0 To 1) As GENERALINPUT
Dim KInput As KEYBDINPUT
KInput.wVk = bkey 'La tecla que desea simular
KInput.dwFlags = 0 'Presione la bandera de tecla
GInput(0).dwType = INPUT_KEYBOARD
CopyMemory GInput(0).xi (0), KInput, Len(KInput ) 'Esta función se utiliza para copiar los datos de KInput en la memoria a GInput
KInput.wVk = bkey
KInput.dwFlags = KEYEVENTF_KEYUP ' Suelta la tecla
GInput (1).dwType = INPUT_KEYBOARD 'Indica que el mensaje es un mensaje de teclado
CopyMemory GInput(1).xi(0), KInput, Len(KInput )
'El trabajo anterior maneja el botón ***2 mensajes de teclado de la tecla hacia abajo y la tecla de liberación se agregan a la estructura de datos GInput
SendInput 2, GInput(0), Len(GInput(0)) 'Inserta el mensaje almacenado en GInput en la cola de mensajes
End Sub
Además de lo anterior, los enlaces globales también se pueden usar para simular mensajes de teclado. . Si ya conoce el uso de ganchos de mensajes en Windows, puede simular mensajes de teclado configurando un gancho global. Por ejemplo, puede usar el gancho WH_JOURNALPLAYBACK para simular pulsaciones de teclas.
WH_JOURNALLPLAYBACK es un enlace global a nivel de sistema. Su función es relativa a la de WH_JOURNALRECORD. Se usan comúnmente para grabar y reproducir operaciones del teclado y el mouse. El gancho WH_JOURNALRECORD se utiliza para registrar fielmente las operaciones del teclado y el mouse. La información registrada se puede guardar en un archivo y WH_JOURNALRECORD puede reproducir estas operaciones. Por supuesto, también puedes usar WH_JOURNALPLAYBACK solo para simular las operaciones del teclado. Primero debe declarar la función SetWindowsHookEx, que se puede utilizar para instalar enlaces de mensajes:
Declarar función SetWindowsHookEx Lib "user32" Alias "SetWindowsHookExA" (ByVal idHook As Long, ByVal lpfn As Long, ByVal hmod As Long, ByVal dwThreadId As Long) As Long
Primero instale el enlace WH_JOURNALPLAYBACK y luego deberá escribir una función de enlace usted mismo. Cuando el sistema lo llame, pase el evento que desea simular al. En el área EVENTMSG señalada por el parámetro de enlace lParam, puede lograr el efecto de simular pulsaciones de teclas. Sin embargo, usar este gancho para simular eventos de teclado tiene un efecto secundario, es decir, bloqueará el mouse y el teclado reales. Sin embargo, si solo desea evitar que las operaciones reales del teclado le molesten durante la simulación, entonces usarlo es una buena idea. .
Bien, creo que su programa de pulsación de teclas simulada está casi completo en este punto. Pruébelo y vea si es muy efectivo.