comment
IRC Chat
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Mouse Mover

  • 0 Respuestas
  • 372 Vistas

0 Usuarios y 2 Visitantes están viendo este tema.

Desconectado solid water

  • *
  • Underc0der
  • Mensajes: 55
  • Actividad:
    16.67%
  • Reputación 1
    • Ver Perfil
« en: Diciembre 04, 2018, 09:55:37 am »
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 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:
Código: C#
  1. using System;
  2. using System.Collections.Generic;
  3. using System.ComponentModel;
  4. using System.Data;
  5. using System.Drawing;
  6. using System.Text;
  7. using System.Windows.Forms;
  8. using System.Runtime.InteropServices;
  9. using Utilities;
  10.  
  11. namespace key_preview {
  12.         public partial class Form1 : Form {
  13.                 globalKeyboardHook gkh = new globalKeyboardHook();
  14.  
  15.         MouseMover MM = new MouseMover();
  16.  
  17.         [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
  18.         public static extern void mouse_event(int dwFlags, int dx, int dy, int cButtons, int dwExtraInfo);
  19.  
  20.         private const int MOUSEEVENTF_LEFTDOWN = 0x02;
  21.         private const int MOUSEEVENTF_LEFTUP = 0x04;
  22.         private const int MOUSEEVENTF_RIGHTDOWN = 0x08;
  23.         private const int MOUSEEVENTF_RIGHTUP = 0x10;
  24.  
  25.                 public Form1() {
  26.                         InitializeComponent();
  27.                 }
  28.  
  29.         bool flag = true;
  30.  
  31.                 private void Form1_Load(object sender, EventArgs e) {
  32.                        
  33.             gkh.HookedKeys.Add(Keys.W);
  34.             gkh.HookedKeys.Add(Keys.A);
  35.             gkh.HookedKeys.Add(Keys.S);
  36.             gkh.HookedKeys.Add(Keys.D);
  37.             gkh.HookedKeys.Add(Keys.Q);
  38.             gkh.HookedKeys.Add(Keys.E);
  39.             gkh.HookedKeys.Add(Keys.R);
  40.             gkh.HookedKeys.Add(Keys.F);
  41.             gkh.HookedKeys.Add(Keys.D);
  42.             gkh.HookedKeys.Add(Keys.P);
  43.  
  44.  
  45.                         gkh.KeyDown += new KeyEventHandler(gkh_KeyDown);
  46.                
  47.  
  48.                 }
  49.  
  50.  
  51.  
  52.                 void gkh_KeyDown(object sender, KeyEventArgs e) {
  53.  
  54.             if (flag == true)
  55.             {
  56.                 switch (e.KeyCode)
  57.                 {
  58.                     case Keys.W:
  59.                         MM.arriba();
  60.                         break;
  61.  
  62.                     case Keys.S:
  63.                         MM.abajo();
  64.                         break;
  65.  
  66.                     case Keys.A:
  67.                         MM.izquierda();
  68.                         break;
  69.  
  70.                     case Keys.D:
  71.                         MM.derecha();
  72.                         break;
  73.  
  74.                     case Keys.F:
  75.                         MM.bajarsens();
  76.                         break;
  77.  
  78.                     case Keys.R:
  79.                         MM.subirsens();
  80.                         break;
  81.  
  82.                     case Keys.Q:
  83.                         mouse_event(MOUSEEVENTF_LEFTDOWN | MOUSEEVENTF_LEFTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
  84.  
  85.                         break;
  86.  
  87.                     case Keys.E:
  88.                         mouse_event(MOUSEEVENTF_RIGHTDOWN | MOUSEEVENTF_RIGHTUP, Cursor.Position.X, Cursor.Position.Y, 0, 0);
  89.  
  90.                         break;
  91.                 }
  92.             }
  93.  
  94.             if (e.KeyCode == Keys.P)
  95.             {
  96.                 if (flag == true)
  97.                 {
  98.                     flag = false;
  99.                 }
  100.                 else
  101.                 {
  102.                     flag = true;
  103.                 }
  104.  
  105.             }
  106.            
  107.                         e.Handled = true;
  108.                 }
  109.  
  110.    
  111.         }
  112. }


globalKeyboardHook. cs:
Código: C#
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Runtime.InteropServices;
  5. using System.Windows.Forms;
  6.  
  7. namespace Utilities {
  8.         /// <summary>
  9.         /// A class that manages a global low level keyboard hook
  10.         /// </summary>
  11.         class globalKeyboardHook {
  12.                 #region Constant, Structure and Delegate Definitions
  13.                 /// <summary>
  14.                 /// defines the callback type for the hook
  15.                 /// </summary>
  16.                 public delegate int keyboardHookProc(int code, int wParam, ref keyboardHookStruct lParam);
  17.  
  18.                 public struct keyboardHookStruct {
  19.                         public int vkCode;
  20.                         public int scanCode;
  21.                         public int flags;
  22.                         public int time;
  23.                         public int dwExtraInfo;
  24.                 }
  25.  
  26.                 const int WH_KEYBOARD_LL = 13;
  27.                 const int WM_KEYDOWN = 0x100;          
  28.                 const int WM_SYSKEYDOWN = 0x104;
  29.                 #endregion
  30.  
  31.                 #region Instance Variables
  32.                 /// <summary>
  33.                 /// The collections of keys to watch for
  34.                 /// </summary>
  35.                 public List<Keys> HookedKeys = new List<Keys>();
  36.                 /// <summary>
  37.                 /// Handle to the hook, need this to unhook and call the next hook
  38.                 /// </summary>
  39.                 IntPtr hhook = IntPtr.Zero;
  40.                 #endregion
  41.  
  42.                 #region Events
  43.                 /// <summary>
  44.                 /// Occurs when one of the hooked keys is pressed
  45.                 /// </summary>
  46.                 public event KeyEventHandler KeyDown;
  47.                 /// <summary>
  48.                 /// Occurs when one of the hooked keys is released
  49.                 /// </summary>
  50.        
  51.                 #endregion
  52.  
  53.                 #region Constructors and Destructors
  54.                 /// <summary>
  55.                 /// Initializes a new instance of the <see cref="globalKeyboardHook"/> class and installs the keyboard hook.
  56.                 /// </summary>
  57.                 public globalKeyboardHook() {
  58.                         hook();
  59.                 }
  60.  
  61.                 /// <summary>
  62.                 /// Releases unmanaged resources and performs other cleanup operations before the
  63.                 /// <see cref="globalKeyboardHook"/> is reclaimed by garbage collection and uninstalls the keyboard hook.
  64.                 /// </summary>
  65.                 ~globalKeyboardHook() {
  66.                         unhook();
  67.                 }
  68.                 #endregion
  69.  
  70.                 #region Public Methods
  71.                 /// <summary>
  72.                 /// Installs the global hook
  73.                 /// </summary>
  74.                 public void hook() {
  75.                         IntPtr hInstance = LoadLibrary("User32");
  76.                         hhook = SetWindowsHookEx(WH_KEYBOARD_LL, hookProc, hInstance, 0);
  77.                 }
  78.  
  79.                 /// <summary>
  80.                 /// Uninstalls the global hook
  81.                 /// </summary>
  82.                 public void unhook() {
  83.                         UnhookWindowsHookEx(hhook);
  84.                 }
  85.  
  86.                 /// <summary>
  87.                 /// The callback for the keyboard hook
  88.                 /// </summary>
  89.                 /// <param name="code">The hook code, if it isn't >= 0, the function shouldn't do anyting</param>
  90.                 /// <param name="wParam">The event type</param>
  91.                 /// <param name="lParam">The keyhook event information</param>
  92.                 /// <returns></returns>
  93.                 public int hookProc(int code, int wParam, ref keyboardHookStruct lParam) {
  94.                         if (code >= 0) {
  95.                                 Keys key = (Keys)lParam.vkCode;
  96.                                 if (HookedKeys.Contains(key)) {
  97.                                         KeyEventArgs kea = new KeyEventArgs(key);
  98.                                         if ((wParam == WM_KEYDOWN || wParam == WM_SYSKEYDOWN) && (KeyDown != null)) {
  99.                                                 KeyDown(this, kea) ;
  100.                                         }
  101.                                         if (kea.Handled)
  102.                                                 return 1;
  103.                                 }
  104.                         }
  105.                         return CallNextHookEx(hhook, code, wParam, ref lParam);
  106.                 }
  107.                 #endregion
  108.  
  109.                 #region DLL imports
  110.                 /// <summary>
  111.                 /// Sets the windows hook, do the desired event, one of hInstance or threadId must be non-null
  112.                 /// </summary>
  113.                 /// <param name="idHook">The id of the event you want to hook</param>
  114.                 /// <param name="callback">The callback.</param>
  115.                 /// <param name="hInstance">The handle you want to attach the event to, can be null</param>
  116.                 /// <param name="threadId">The thread you want to attach the event to, can be null</param>
  117.                 /// <returns>a handle to the desired hook</returns>
  118.                 [DllImport("user32.dll")]
  119.                 static extern IntPtr SetWindowsHookEx(int idHook, keyboardHookProc callback, IntPtr hInstance, uint threadId);
  120.  
  121.                 /// <summary>
  122.                 /// Unhooks the windows hook.
  123.                 /// </summary>
  124.                 /// <param name="hInstance">The hook handle that was returned from SetWindowsHookEx</param>
  125.                 /// <returns>True if successful, false otherwise</returns>
  126.                 [DllImport("user32.dll")]
  127.                 static extern bool UnhookWindowsHookEx(IntPtr hInstance);
  128.  
  129.                 /// <summary>
  130.                 /// Calls the next hook.
  131.                 /// </summary>
  132.                 /// <param name="idHook">The hook id</param>
  133.                 /// <param name="nCode">The hook code</param>
  134.                 /// <param name="wParam">The wparam.</param>
  135.                 /// <param name="lParam">The lparam.</param>
  136.                 /// <returns></returns>
  137.                 [DllImport("user32.dll")]
  138.                 static extern int CallNextHookEx(IntPtr idHook, int nCode, int wParam, ref keyboardHookStruct lParam);
  139.  
  140.                 /// <summary>
  141.                 /// Loads the library.
  142.                 /// </summary>
  143.                 /// <param name="lpFileName">Name of the library</param>
  144.                 /// <returns>A handle to the library</returns>
  145.                 [DllImport("kernel32.dll")]
  146.                 static extern IntPtr LoadLibrary(string lpFileName);
  147.                 #endregion
  148.         }
  149. }

MouseMover.cs
Código: C#
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Windows.Forms;
  5. using System.Drawing;
  6.  
  7.  
  8. namespace Utilities
  9. {
  10.     class MouseMover
  11.     {
  12.         private int sens;
  13.  
  14.         public MouseMover()
  15.         {
  16.             this.sens = 20;
  17.         }
  18.  
  19.         public void derecha()
  20.         {
  21.             Cursor.Position = new Point(Cursor.Position.X + sens, Cursor.Position.Y);    
  22.         }
  23.  
  24.         public void izquierda()
  25.         {
  26.             Cursor.Position = new Point(Cursor.Position.X - sens, Cursor.Position.Y);
  27.         }
  28.  
  29.         public void arriba()
  30.         {
  31.             Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - sens);
  32.         }
  33.  
  34.         public void abajo()
  35.         {
  36.             Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + sens);
  37.         }
  38.  
  39.         public void subirsens()
  40.         {
  41.            
  42.          if (this.sens < 300)
  43.             {
  44.                 this.sens = sens + 40;
  45.             }
  46.         }
  47.  
  48.         public void bajarsens()
  49.         {
  50.  
  51.             if (this.sens == 20)
  52.             {
  53.                 this.sens = 10;
  54.             }
  55.             else
  56.             {
  57.                 this.sens = 20;
  58.             }
  59.            
  60.         }
  61.  
  62.     }
  63. }
  64.  
  65. }

Form1.Designer
Código: C#
  1. namespace key_preview {
  2.         partial class Form1 {
  3.                 /// <summary>
  4.                 /// Required designer variable.
  5.                 /// </summary>
  6.                 private System.ComponentModel.IContainer components = null;
  7.  
  8.                 /// <summary>
  9.                 /// Clean up any resources being used.
  10.                 /// </summary>
  11.                 /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
  12.                 protected override void Dispose(bool disposing) {
  13.                         if (disposing && (components != null)) {
  14.                                 components.Dispose();
  15.                         }
  16.                         base.Dispose(disposing);
  17.                 }
  18.  
  19.                 #region Windows Form Designer generated code
  20.  
  21.                 /// <summary>
  22.                 /// Required method for Designer support - do not modify
  23.                 /// the contents of this method with the code editor.
  24.                 /// </summary>
  25.                 private void InitializeComponent() {
  26.             this.SuspendLayout();
  27.             //
  28.             // Form1
  29.             //
  30.             this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
  31.             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
  32.             ths.ClientSize = new System.Drawing.Size(292, 266);
  33.             this.KeyPreview = true;
  34.             this.Name = "Form1";
  35.             this.Text = "Form1";
  36.             this.Load += new System.EventHandler(this.Form1_Load);
  37.             this.ResumeLayout(false);
  38.  
  39.                 }
  40.  
  41.                 #endregion
  42.  
  43.     }
  44. }

Saludos,
« Última modificación: Diciembre 04, 2018, 09:57:36 am por solid water »

 

¿Te gustó el post? COMPARTILO!



Lock File - Prevenir Ejecutar, Mover, Eliminar, Cortar, Renombrar, Sobreescribir

Iniciado por 79137913

Respuestas: 0
Vistas: 1501
Último mensaje Agosto 07, 2017, 12:50:12 pm
por 79137913