Código fuente de enlace de teclado neto
Utilizar el sistema;
Utilizar el sistema. Tiempo de ejecución. InteropServices
Utiliza el sistema. Reflexionar;
Utilizar el sistema. Enhebrado;
Usa el sistema. Windows Forms
Usa el sistema. Diagnóstico;
Utilizar el sistema. recolectar. Genérico;
Enganche de espacio de nombres global
{
/// lt; Resumen gt
///Esta clase te permite Obtener todo eventos de teclado para un programa en ejecución.
///Y genera un evento .NET usando los parámetros KeyEventArgs y MouseEventArgs para que puedas usar la información fácilmente.
///lt;/summary gt;
/// lt;Remarksgt
///Modificar: lihx
/ //Después de la modificación: 04.11.8
/// lt;/Remarksgt
Libro de claves públicas
{
private const int WM _ KEYDOWN = 0x 100;
const privado int WM _ KEYUP = 0x 101;
const privado int WM _ SYSKEYDOWN = 0x 104; int WM _ SYSKEYUP = 0x 105;
//Evento global
Evento público KeyEventHandler OnKeyDownEvent
Evento público KeyEventHandler OnKeyUpEvent
Evento público keypress eventhandler onkeypress event;
static int hKeyboardHook = 0; //Controlador de gancho de teclado
//Constante del mouse
public const int WH _ Keyboard_LL = 13; //Constante de enlace de teclado
Procedimiento de enlace de teclado HookProc; //Declara el tipo de evento de enlace de teclado.
//Declara el tipo de estructura de clasificación del gancho del teclado.
[StructLayout(LayoutKind.Continuous)]
Clase pública KeyboardHookStruct
{
public int vkCode//Representa entre 1 y Virtual Códigos de teclado entre 254.
Public int scanCode//Representa el código de escaneo del hardware.
Indicador int público;
Hora int público;
dwExtraInfo público int
}
//Dispositivo Función de enlace
[DllImport("user32.dll ", CharSet = CharSet.Auto, convención de llamada = convención de llamada activada.
StdCall)]
public static extern int SetWindowsHookEx(int id hook, HookProc lpfn, IntPtr hInstance, int threadId);
//Función eliminar gancho
[DllImport("user32.dll ", CharSet = CharSet. Auto, convención de llamada = convención de llamada. StdCall)]
public static extern bool unhook windowshookex(int id hook);
//Siguiente función de enlace
[DllImport("user32.dll ", CharSet = CharSet. Auto, convención de llamada = convención de llamada. StdCall)]
público estático extern int CallNextHookEx(int id hook, int nCode, Int32 wParam, int ptr lParam);
[DllImport("user32")]
public static extern int to ascii( int uVirtKey, int uScanCode, byte[] lpbKeyState, byte[] lpwTransKey, int fuState);
[DllImport("user32")]
público externo estático int GetKeyboardState(byte[ ]pbKeyState);
[DllImport("kernel32.dll ", CharSet = CharSet.Automatic,
CallConvention = CallConvention.StdCall)]
externo estático privado IntPtr GetModuleHandle (string lpModuleName);
Delegado público int HookProc(int nCode, Int32 wParam, int ptr lParam);
//Tecla previamente presionada
Público Lista ltKeys gtpreKeys = nueva lista ltKeys gt();
/// lt; Resumengt
///El constructor predeterminado construye una instancia de la clase actual y la ejecuta automáticamente.
///lt;/summary gt;
PublicKeyBook()
{
start();
p>
}
//Destructor.
~ KeyBordHook()
{
stop();
}
Inicio de anulación pública()
{
//Instalar gancho de teclado
if (hKeyboardHook == 0)
{
teclado procedimiento de enlace = nuevo proceso de enlace (procesamiento de enlace de teclado);
//hKeyboardHook = SetWindowsHookEx(WH _Keyboard_LL, KeyboardHookProcedure, Marshal. GetHINSTANCE(assembly. GetExecutingAssembly(). GetModules()[0] ), 0) ;
Proceso curProcess = proceso. GetCurrentProcess();
módulo de proceso módulo cur = proceso cur. Módulo principal;
hKeyboardHook = SetWindowsHookEx(WH_Keyboard_LL, KeyboardHookProcedure, GetModuleHandle(curModule.ModuleName), 0);
if (hKeyboardHook == 0)
{
stop();
Lanzar nueva excepción ("SetWindowsHookEx falló.");
}
}
}
Sitio público no válido()
{
bool retKeyboard = true
if (hKeyboardHook ! = 0)
{
ret teclado = UnhookWindowsHookEx(hKeyboardHook);
hKeyboardHook = 0;
}
// Si la eliminación del gancho falla,
If (!(retKeyboard)) arroja una nueva excepción ("UnhookWindowsHookEx falló.");
}
private int KeyboardHookProc( int nCode, Int32 wParam, IntPtr lParam)
{
if((nCode >= 0) amp; amp(OnKeyDownEvent!= null || OnKeyUpEvent! = null || OnKeyPressEvent! = null))
{
estructura de gancho de teclado mi estructura de gancho de teclado =(estructura de gancho de teclado)Marshal. PtrToStructure(lParam, tipo de (estructura de gancho de teclado));
//Cuando hay OnKeyDownEvent o OnKeyPressEvent no es nulo, Ctrl Alt Shift Keyup es preKeys.
//Se añade la clave correspondiente.
if ((OnKeyDownEvent!= null || OnKeyPressEvent!= null) amp; amp(wParam == WM _ KEYDOWN | | wParam == WM _ SYSKEYDOWN))
{
Teclas keyData =(Keys)mykeyboardhookstruct código vk;
if(IsCtrlAltShiftKeys(key data) amp; amp prekey. IndexOf(keyData) == -1)
{
Preclave. add(datos clave);
}
}
//Raise OnKeyDownEvent
if (OnKeyDownEvent!= null amp amp(wParam = = WM_KEYDOWN | | wParam = = WM_SYSKEYDOWN))
{
Claves keyData =(Claves)mykeyboardhookstruct código vk;
KeyEventArgs e = new KeyEventArgs(. GetDownKeys(datos clave));
OnKeyDownEvent(this, e);
}
//Elevar OnKeyPressEvent
if (OnKeyPressEvent != null amp ampwParam == WM_KEYDOWN)
{
byte[] keyState = nuevo byte[256];
GetKeyboardState(estado de clave);
byte[] inBuffer = nuevo byte[2];
if(toa scii(mykeyboardhookstruct . código vk,
MyKeyboardHookStruct.scanCode,
Estado de la clave,
En el búfer,
mykeyboardhookstruct . flags)= = 1)
{
keypress eventargs e = nueva pulsación de tecla. eventargs((char)en buffer[0]);
OnKeyPressEvent(this, e);
}
}
/ /Cuando hay OnKeyDownEvent o OnKeyPressEvent no es nulo, la tecla Ctrl Alt Shift es preKeys.
//Eliminar la clave correspondiente.
if ((OnKeyDownEvent!= null || OnKeyPressEvent!= null) amp; amp(wParam == WM _ KEYUP | | wParam == WM _ SYSKEYUP))
{
Teclas keyData =(Keys)mykeyboardhookstruct .código vk;
if (IsCtrlAltShiftKeys(keyData))
{
for (int i = preKeys.count-1; i gt = 0; i-)
{
si (preKeys[i] == keyData)
{
Preclave. eliminar en(I);
}
}
}
}
//Raise OnKeyUpEvent
if (OnKeyUpEvent!= null amp amp(wParam == WM _ KEYUP | | wParam == WM _ SYSKEYUP))
{
Claves keyData =( Keys)mykeyboardhookstruct . código vk;
KeyEventArgs e = new KeyEventArgs(GetDownKeys(datos clave));
OnKeyUpEvent(this, e);
}
}
Devolver CallNextHookEx(hKeyboardHook, nCode, wParam, lParam
}
Clave privada GetDownKeys(Claves)
{
Claves rtnKey = Claves. Ninguno;
foreach(Keys keyTemp in pre Keys)
{
Interruptor (temperatura de la tecla)
{
Llave del cofre. LControlKey:
Clave de caja. RControlKey:
rtnKey = rtnKey | Control;
Romper;
Tecla de caja. LMenú:
Llave del cofre. RMenú:
rtnKey = rtnKey | Alt
Romper;
Tecla Caja. LShiftKey:
Tecla de caja. RShiftKey:
rtnKey = rtnKey | Mayús;
Interrupción;
Valor predeterminado:
Interrupción;
}
}
rtnKey = rtnKey | clave
Devolver rtnKey
}
IsCtrlAltShiftKeys booleano privado(Claves)
{
Interruptor (tecla)
{
Llave de la caja. LControlKey:
Clave de caja. RControlKey:
Clave de caja. LMenú:
Llave del cofre. RMenú:
Llave del cofre.
LShiftKey:
Tecla de caja. RShiftKey:
Devuelve verdadero
Valor predeterminado:
Devuelve falso
}
}
}
}