procesamiento del teclado
Enganche de teclado global, de la siguiente manera, puede obtener los datos del gancho de teclado en el cuadro de texto.
usando System;
usando System.Runtime.InteropServices;
usando System.Reflection;
usando System.Threading;
usando System.Runtime.InteropServices;
usando System.Reflection;
usando System.Threading;
p>usando System.Windows. Formularios;
usando System.Diagnostics;
usando System.Collections.Generic;
espacio de nombres HookGlobal
{
/// lt; resumengt;
/// Esta clase le permite obtener todos los eventos de teclado de un programa en ejecución
/// Y generar un evento .NET con KeyEventArgs. y parámetros MouseEventArgs para que pueda utilizar fácilmente esta información
/// lt;/summarygt;
/// commentsgt; Modificación: lihx
/// Hora de modificación: 04.11.8
/// lt;/remarksgt
public class KeyBordHook
const privada int WM_KEYDOWN = 0x100;
const privada int WM_KEYUP = 0x101
const privada WM_SYSKEYDOWN = 0x104; > private const int WM_SYSKEYUP = 0x105;
//Eventos globales
evento público KeyEventHandler OnKeyDownEvent
evento público KeyEventHandler OnKeyUpEvent; evento público KeyPressEventHandler OnKeyPressEvent;
static int hKeyboardHook = 0; // Controlador de gancho de teclado
// Constantes del mouse
public const int WH_KEYBOARD_LL = 13; constante de enlace de teclado
HookProc KeyboardHookProcedure; //Declarar el tipo de evento de enlace de teclado.
//Declarar la estructura de clasificación del tipo de enlace de teclado
[StructLayout( LayoutKind.Sequential)]
clase pública KeyboardHookStruct
{
public int VkCode
; //Representa un código de teclado virtual entre 1 y 254
public int scanCode; //Representa un código de escaneo de hardware
public int flags;
public int time;
public int dwExtraInfo;
}
//Función para instalar el gancho
[DllImport("user32.dll " , CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern int SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
/ /Función para desenganchar
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern bool UnhookWindowsHookEx(int idHook ) ;
//Siguiente función enlazada
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern int CallNextHookEx(int idHook, int nCode, Int32 wParam, IntPtr lParam);
[DllImport("user32")]
public static extern int ToAscii(int uVirtKey, int uScanCode, byte[] lpbKeyState, byte[] lpwTransKey, int fuState);
[DllImport("user32")]
public static extern int GetKeyboardState(byte[] pbKeyState);
[DllImport("kernel32.dll", CharSet = CharSet.Auto,
CallingConvention = CallingConvention.StdCall)]
IntPtr externo estático privado GetModuleHandle(cadena lpModuleName);
p
delegado público int HookProc(int nCode, Int32 wParam, IntPtr lParam);
//Teclas previamente presionadas
public Keysgt; preKeys = new Keysgt () ;
/// lt；summarygt;
/// El constructor MoCui construye una instancia de la clase actual y la ejecuta automáticamente
// /lt; /summarygt;
public KeyBordHook()
{
Inicio()
}
// Destructor
~KeyBordHook()
{
Stop()
}
inicio público vacío. ()
{
//Instalar gancho de teclado
if (hKeyboardHook == 0)
{
KeyboardHookProcedure = new HookProc(KeyboardHookProc);
//hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, Marshal.GetHINSTANCE(Assembly.GetExecutingAssembly().GetModules()[0]),
Proceso curProcess = Process.GetCurrentProcess();
ProcessModule curModule = curProcess.MainModule;
hKeyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL, KeyboardHookProcedure, GetModuleHandle(curModule .ModuleName), 0 );
if (hKeyboardHook == 0)
{
Stop();
lanza una nueva excepción ("SetWindowsHookEx falló .");
}
}
}
public void Stop()
{
bool retKeyboard = true;
if (hKeyboardHook != 0)
{
retKeyboard = UnhookWindowsHookEx(hKeyboardHook);
hKeyboardHook = 0;
}
//Si no se puede eliminar el gancho
if (!(retKeyboard)) throw new Exception("UnhookWindowsHookEx falló.");
}
private int KeyboardHookProc(int nCode, Int32 wParam, IntPtr lParam)
{
if ((nCode gt; = 0) amp; amp; (OnKeyDownEvent != null || OnKeyUpEvent != null || OnKeyPressEvent != null))
{
KeyboardHookStruct MyKeyboardHookStruct = (KeyboardHookStruct)Marshal.PtrToStructure(lParam, typeof(KeyboardHookStruct));
//Cuando hay OnKeyDownEvent o OnKeyPressEvent no es nulo, ctrl alt shift keyup Cuando preKeys
//La tecla correspondiente aumenta
if ((OnKeyDownEvent != null || OnKeyPressEvent != null) amp; amp; (wParam == WM_KEYDOWN | | wParam == WM_SYSKEYDOWN))
{
Claves keyData = (Keys)MyKeyboardHookStruct.vkCode
if (IsCtrlAltShiftKeys(keyData) amp; amp; preKeys .IndexOf (keyData) == -1)
{
preKeys.Add(keyData);
}
}
//Elevar OnKeyDownEvent
if (OnKeyDownEvent != null amp; amp; (wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN))
{
Claves keyData = (Keys)MyKeyboardHookStruct.vkCode;
KeyEventArgs e = new KeyEventArgs(GetDownKeys(keyData));
OnKeyDownEvent(this, e);
}
//Elevar OnKeyPressEvent
if (OnKeyPressEvent != null amp; amp; wParam == WM_KEYDOWN)
{
byte[] keyState = nuevo byte[256];
GetKeyboardState(keyState);
byte[] inBuffer = nuevo byte[2];
if (ToAscii(MyKeyboardHookStruct.vkCode,
MyKeyboardHookStruct.scanCode,
keyState,
inBuffer,
MyKeyboardHookStruct. banderas) == 1)
{
KeyPressEventArgs e = new KeyPressEventArgs((char)inBuffer[0]);
OnKeyPressEvent(this, e);
}
}
//Cuando hay OnKeyDownEvent o OnKeyPressEvent no es nulo, ctrl alt shift keyup preKeys
// El la clave correspondiente se elimina
si ((OnKeyDownEvent !=
nulo || OnKeyPressEvent != nulo) amp; (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
{
Claves keyData = (Claves)MyKeyboardHookStruct.vkCode;
if (IsCtrlAltShiftKeys(keyData))
{
for (int i = preKeys.Count - 1; i gt; = 0; i--)
{
if (preKeys[i] == keyData)
{
preKeys.RemoveAt(i);
}
}
}
}
//Activar OnKeyUpEvent
if (OnKeyUpEvent != null & (wParam == WM_KEYUP || wParam == WM_SYSKEYUP))
{
Claves keyData = (Claves)MyKeyboardHookStruct.vkCode;
KeyEventArgs e = new KeyEventArgs(GetDownKeys(keyData));
OnKeyUpEvent(this, e
}
}
return; CallNextHookEx(hKeyboardHook, nCode, wParam, lParam);
}
Claves privadas GetDownKeys(Teclas clave)
{
Claves rtnKey = Keys.None;
foreach (Keys keyTemp en preKeys)
{
cambiar (keyTemp)
{
case Keys.LControlKey:
case Keys.RControlKey:
rtnKey = rtnKeys.Control;
break;
case Keys.LMenu:
case Keys.RMenu:
rtnKey = rtnKeys.Alt
break; >
caso Keys.LShiftKey:
caso Keys.RShiftKey:
rtnKey = rtnKeys.Shift;
romper;
predeterminado:
romper
}
}
rtnKey = rtnKey | rtnKey;
}
privado booleano IsCtrlAltShiftKeys(tecla Teclas)
{
interruptor (tecla)
{
caso Teclas.LControlKey:
caso Teclas.RControlKey:
caso Teclas.LMenu:
caso Teclas.RMenu:
case Keys.LShiftKey:
case Keys.RShiftKey:
devuelve verdadero
predeterminado:
devuelve; falso;
}
}
}
}