Mouse Mover

  • 1 Respuestas
  • 3464 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado Solid Water

  • *
  • Underc0der
  • Mensajes: 150
  • Actividad:
    13.33%
  • Country: 00
  • Reputación 6
  • (:{
    • Ver Perfil

Mouse Mover

  • 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: (csharp) [Seleccionar]
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:
Código: (csharp) [Seleccionar]
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
Código: (csharp) [Seleccionar]
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
Código: (csharp) [Seleccionar]
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,
« Última modificación: Diciembre 04, 2018, 09:57:36 am por solid water »

Desconectado Rad1us

  • *
  • Underc0der
  • Mensajes: 80
  • Actividad:
    0%
  • Country: 00
  • Reputación 2
    • Ver Perfil
    • Email

Re:Mouse Mover

  • en: Enero 14, 2019, 08:33:59 pm
Muy ingenioso si no tienes ratón jajajaja, me lo apunto!.