Este es un programita que hice hace muchos años, se los dejo tal cual lo postié en aquellos tiempos:
En mi casa solamente tengo un mouse y muchas veces me traen gabinetes para reparaciones (tengo otro teclado y monitor) pero debo estar moviendo el mouse de un PC al otro y a veces falla el Plug & Play y quedo solo con el teclado, en fín no es que no me agraden los shortcuts pero a veces me veo limitado para hacer algunas cosas o me lleva más tiempo de lo deseado.
Por eso hice este programa para manejar el mouse desde el teclado. Como usarlo:
W-A-S-D: Para las direcciones.
E: RightClick.
Q: LeftClick.
P: Apagar/prender (para poder seguir usando el teclado como tal).
R: Subir sensibilidad.
F: Bajar sensibilidad.
La clase globalKeyboardHook. cs, la tomé de CodeProject (http://www.codeproject.com/Articles/19004/A-Simple-C-Global-Low-Level-Keyboard-Hook) y su autor es StormySpike.
Lo único que le hice a ésta, fué borrarle la captura de Key_Up, ya que no iba a utilizarlo.
Form1.cs:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using Utilities;
namespace key_preview {
public partial class Form1 : Form {
globalKeyboardHook gkh = new globalKeyboardHook();
MouseMover MM = new MouseMover();
[DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
private const int MOUSEEVENTF_LEFTDOWN = 0x02;
private const int MOUSEEVENTF_LEFTUP = 0x04;
private const int MOUSEEVENTF_RIGHTDOWN = 0x08;
private const int MOUSEEVENTF_RIGHTUP = 0x10;
public Form1() {
InitializeComponent();
}
bool flag = true;
private void Form1_Load(object sender, EventArgs e) {
gkh.HookedKeys.Add(Keys.W);
gkh.HookedKeys.Add(Keys.A);
gkh.HookedKeys.Add(Keys.S);
gkh.HookedKeys.Add(Keys.D);
gkh.HookedKeys.Add(Keys.Q);
gkh.HookedKeys.Add(Keys.E);
gkh.HookedKeys.Add(Keys.R);
gkh.HookedKeys.Add(Keys.F);
gkh.HookedKeys.Add(Keys.D);
gkh.HookedKeys.Add(Keys.P);
gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
}
void gkh_KeyDown(object sender, KeyEventArgs e) {
if (flag == true)
{
switch (e.KeyCode)
{
case Keys.W:
MM.arriba();
break;
case Keys.S:
MM.abajo();
break;
case Keys.A:
MM.izquierda();
break;
case Keys.D:
MM.derecha();
break;
case Keys.F:
MM.bajarsens();
break;
case Keys.R:
MM.subirsens();
break;
case Keys.Q:
mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
break;
case Keys.E:
mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
break;
}
}
if (e.KeyCode == Keys.P)
{
if (flag == true)
{
flag = false;
}
else
{
flag = true;
}
}
e.Handled = true;
}
}
}
globalKeyboardHook. cs:
using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace Utilities {
/// <summary>
/// A class that manages a global low level keyboard hook
/// </summary>
class globalKeyboardHook {
#region Constant, Structure and Delegate Definitions
/// <summary>
/// defines the callback type for the hook
/// </summary>
public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
public struct keyboardHookStruct {
public int vkCode;
public int scanCode;
public int flags;
public int time;
public int dwExtraInfo;
}
const int WH_KEYBOARD_LL = 13;
const int WM_KEYDOWN = 0x100;
const int WM_SYSKEYDOWN = 0x104;
#endregion
#region Instance Variables
/// <summary>
/// The collections of keys to watch for
/// </summary>
public List<Keys> HookedKeys = new List<Keys>();
/// <summary>
/// Handle to the hook, need this to unhook and call the next hook
/// </summary>
IntPtr hhook = IntPtr.Zero;
#endregion
#region Events
/// <summary>
/// Occurs when one of the hooked keys is pressed
/// </summary>
public event KeyEventHandler KeyDown;
/// <summary>
/// Occurs when one of the hooked keys is released
/// </summary>
#endregion
#region Constructors and Destructors
/// <summary>
/// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
/// </summary>
public globalKeyboardHook() {
hook();
}
/// <summary>
/// Releases unmanaged resources and performs other cleanup operations before the
/// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
/// </summary>
~globalKeyboardHook() {
unhook();
}
#endregion
#region Public Methods
/// <summary>
/// Installs the global hook
/// </summary>
public void hook() {
IntPtr hInstance = LoadLibrary("User32");
hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
}
/// <summary>
/// Uninstalls the global hook
/// </summary>
public void unhook() {
UnhookWindowsHookEx(hhook);
}
/// <summary>
/// The callback for the keyboard hook
/// </summary>
/// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
/// <param name="wParam">The event type</param>
/// <param name="lParam">The keyhook event information</param>
/// <returns></returns>
public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
if (code >= 0) {
Keys key = (Keys)lParam.vkCode;
if (HookedKeys.Contains(key)) {
KeyEventArgs kea = new KeyEventArgs(key);
if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
KeyDown(this, kea) ;
}
if (kea.Handled)
return 1;
}
}
return CallNextHookEx(hhook, code, wParam, ref lParam);
}
#endregion
#region DLL imports
/// <summary>
/// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
/// </summary>
/// <param name="idHook">The id of the event you want to hook</param>
/// <param name="callback">The callback.</param>
/// <param name="hInstance">The handle you want to attach the event to, can be null</param>
/// <param name="threadId">The thread you want to attach the event to, can be null</param>
/// <returns>a handle to the desired hook</returns>
[DllImport("user32.dll")]
static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
/// <summary>
/// Unhooks the windows hook.
/// </summary>
/// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
/// <returns>True if successful, false otherwise</returns>
[DllImport("user32.dll")]
static extern bool UnhookWindowsHookEx(IntPtr hInstance);
/// <summary>
/// Calls the next hook.
/// </summary>
/// <param name="idHook">The hook id</param>
/// <param name="nCode">The hook code</param>
/// <param name="wParam">The wparam.</param>
/// <param name="lParam">The lparam.</param>
/// <returns></returns>
[DllImport("user32.dll")]
static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
/// <summary>
/// Loads the library.
/// </summary>
/// <param name="lpFileName">Name of the library</param>
/// <returns>A handle to the library</returns>
[DllImport("kernel32.dll")]
static extern IntPtr LoadLibrary(string lpFileName);
#endregion
}
}
MouseMover.cs
using System;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;
using System.Drawing;
namespace Utilities
{
class MouseMover
{
private int sens;
public MouseMover()
{
this.sens = 20;
}
public void derecha()
{
Cursor.Position = new Point(Cursor.Position.X + sens, Cursor.Position.Y);
}
public void izquierda()
{
Cursor.Position = new Point(Cursor.Position.X - sens, Cursor.Position.Y);
}
public void arriba()
{
Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - sens);
}
public void abajo()
{
Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + sens);
}
public void subirsens()
{
if (this.sens < 300)
{
this.sens = sens + 40;
}
}
public void bajarsens()
{
if (this.sens == 20)
{
this.sens = 10;
}
else
{
this.sens = 20;
}
}
}
}
}
Form1.Designer
namespace key_preview {
partial class Form1 {
/// <summary>
/// Required designer variable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Clean up any resources being used.
/// </summary>
/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
protected override void Dispose(bool disposing) {
if (disposing && (components != null)) {
components.Dispose();
}
base.Dispose(disposing);
}
#region Windows Form Designer generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InitializeComponent() {
this.SuspendLayout();
//
// Form1
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
ths.ClientSize = new System.Drawing.Size(292, 266);
this.KeyPreview = true;
this.Name = "Form1";
this.Text = "Form1";
this.Load += new System.EventHandler(this.Form1_Load);
this.ResumeLayout(false);
}
#endregion
}
}
Saludos,
Muy ingenioso si no tienes ratón jajajaja, me lo apunto!.