Win32/Input/InputSender.cs

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Input;


namespace libWin32.Win32.Input
{
    public class InputSender
    {

        public const int KEYUP_WAIT_TIME = 0;

        #region INPUTTYPE CONSTANTS
        public const uint INPUT_MOUSE = 0x0;
        public const int INPUT_KEYBOARD = 0x1;
        public const int INPUT_HARDWARE = 0x2;
        #endregion
        #region KEYEVENTF CONSTANTS
        public const uint KEYEVENTF_EXTENDEDKEY = 0x1;
        public const uint KEYEVENTF_KEYDOWN = 0x0;
        public const uint KEYEVENTF_KEYUP = 0x2;
        public const uint KEYEVENTF_UNICODE = 0x4;
        public const uint KEYEVENTF_SCANCODE = 0x8;
        #endregion
        #region XBUTTON CONSTANTS
        public const uint XBUTTON1 = 0x1;
        public const uint XBUTTON2 = 0x2;
        #endregion
        #region MOUSEEVENTF CONSTANTS
        public const uint MOUSEEVENTF_MOVE = 0x1;
        public const uint MOUSEEVENTF_LEFTDOWN = 0x2;
        public const uint MOUSEEVENTF_LEFTUP = 0x4;
        public const uint MOUSEEVENTF_RIGHTDOWN = 0x8;
        public const uint MOUSEEVENTF_RIGHTUP = 0x10;
        public const uint MOUSEEVENTF_MIDDLEDOWN = 0x20;
        public const uint MOUSEEVENTF_MIDDLEUP = 0x40;
        public const uint MOUSEEVENTF_XDOWN = 0x80;
        public const uint MOUSEEVENTF_XUP = 0x100;
        public const uint MOUSEEVENTF_WHEEL = 0x800;
        public const uint MOUSEEVENTF_VIRTUALDESK = 0x4000;
        public const uint MOUSEEVENTF_ABSOLUTE = 0x8000;
        #endregion

        [StructLayout(LayoutKind.Explicit)]
        struct INPUT
        {
            [FieldOffset(0)]
            public int dwType;
            [FieldOffset(4)]
            public MOUSEINPUT mouseInput;
            [FieldOffset(4)]
            public KEYBDINPUT keyboardInput;
            [FieldOffset(4)]
            public HARDWAREINPUT hardwareInput;
        }
        [StructLayout(LayoutKind.Explicit)]
        struct KEYBDINPUT
        {
            [FieldOffset(0)]
            public short wVk;
            [FieldOffset(2)]
            public short wScan;
            [FieldOffset(4)]
            public uint dwFlags;
            [FieldOffset(8)]
            public int time;
            [FieldOffset(12)]
            public IntPtr dwExtraInfo;
        }
        [StructLayout(LayoutKind.Explicit)]
        struct HARDWAREINPUT
        {
            [FieldOffset(0)]
            public int uMsg;
            [FieldOffset(4)]
            public short wParamL;
            [FieldOffset(6)]
            public short wParamH;
        }
        /// <summary>
        /// The mouse data structure
        /// </summary>
        [StructLayout(LayoutKind.Explicit)]
        struct MOUSEINPUT
        {
            [FieldOffset(0)]
            public int dx;
            [FieldOffset(4)]
            public int dy;
            [FieldOffset(8)]
            public int mouseData;
            [FieldOffset(12)]
            public int dwFlags;
            [FieldOffset(16)]
            public int time;
            [FieldOffset(20)]
            public IntPtr dwExtraInfo;
        }

        [DllImport("user32.dll")]
        static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
        [DllImport("user32.dll", SetLastError = true)]
        static extern uint SendInput(uint nInputs, ref INPUT pInputs, int cbSize);
        [DllImport("user32.dll")]
        static extern bool BlockInput(bool fBlockIt);

        public void BlockUserInput() { BlockInput(true); }
        public void UnBlockUserInput() { BlockInput(false); }


        public static bool isExtendedVKKey(Key VKKey)
        {
            if (VKKey == Key.Insert || VKKey == Key.Left || VKKey == Key.Home || VKKey == Key.End ||
                VKKey == Key.Up || VKKey == Key.Down || VKKey == Key.PageUp || VKKey == Key.PageDown || VKKey == Key.Right)
            {
                return true;
            }
            return false;

        }
        public static bool isExtendedScanCode(short ScanCode)
        {
            DXKeysToScanCodes t = (DXKeysToScanCodes)ScanCode;
            if (ScanCode == 0)
                t = DXKeysToScanCodes.DIK_UNKOWN;
            if (t == DXKeysToScanCodes.DIK_UP ||
                 t == DXKeysToScanCodes.DIK_DOWN ||
                 t == DXKeysToScanCodes.DIK_LEFT ||
                 t == DXKeysToScanCodes.DIK_RIGHT ||
                 t == DXKeysToScanCodes.DIK_HOME ||
                 t == DXKeysToScanCodes.DIK_END ||
                 t == DXKeysToScanCodes.DIK_NUMPADENTER ||
                 t == DXKeysToScanCodes.DIK_RCONTROL ||
                 t == DXKeysToScanCodes.DIK_RMENU ||
                 t == DXKeysToScanCodes.DIK_LEFT ||
                 t == DXKeysToScanCodes.DIK_PRIOR ||
                 t == DXKeysToScanCodes.DIK_NEXT ||
                 t == DXKeysToScanCodes.DIK_INSERT ||
                 t == DXKeysToScanCodes.DIK_DELETE)
            {
                return true;
            }
            return false; 
        }
        static void DXKeyDown(short DXScanCode)
        {
            INPUT inputs = new INPUT();
            inputs.dwType = INPUT_KEYBOARD;

            if (isExtendedScanCode(DXScanCode))
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYDOWN | KEYEVENTF_EXTENDEDKEY;
            }
            else
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYDOWN;
            }


            inputs.keyboardInput.wScan = DXScanCode;
            int cbSize = Marshal.SizeOf(typeof(INPUT));
            SendInput(1, ref inputs, cbSize);
        }
        static void DXKeyUp(short DXScanCode, TimeSpan wait)
        {
            if (wait.TotalMilliseconds > 0)
                Thread.Sleep(wait);

            INPUT inputs = new INPUT();
            inputs.dwType = INPUT_KEYBOARD;
            if (isExtendedScanCode(DXScanCode))
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
            }
            else
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP;
            }
            inputs.keyboardInput.wScan = DXScanCode;
            int cbSize = Marshal.SizeOf(typeof(INPUT));
            SendInput(1, ref inputs, cbSize);
        }

        public static void SendDXKey(short DXKey)
        {
            PressDXKey(DXKey);
        }
        public static void SendDXKey(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                PressDXKey(DXKey);
            }
        }
        public static void PressDXKey(short DXKey)
        {
            DXKeyDown((short)DXKey);
            DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(250));
        }
        public static void PressDXKey(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                DXKeyDown((short)DXKey);
                DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(250));
            }
        }

        public static void PressDXKey_NoRelease(short DXKey)
        {
            DXKeyDown((short)DXKey);
            //DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
        }
        public static void PressDXKey_NoRelease(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                DXKeyDown((short)DXKey);
                //DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
            }
        }
        public static void ReleaseDXKey(short DXKey)
        {
            //DXKeyDown((short)DXKey);
            DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
        }
        public static void ReleaseDXKey(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                //DXKeyDown((short)DXKey);
                DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
            }
        }
    }
}
Revision:	88
Committed:	Wed May 9 20:52:20 2012 UTC (11 years, 4 months ago) by william
File size:	8395 byte(s)
Log Message:
#	User	Rev	Content
1	william	88	using System;
2			using System.Collections.Generic;
3			using System.Text;
4			using System.Runtime.InteropServices;
5			using System.Threading;
6			using System.Windows.Input;
7
8
9			namespace libWin32.Win32.Input
10			{
11			public class InputSender
12			{
13
14			public const int KEYUP_WAIT_TIME = 0;
15
16			#region INPUTTYPE CONSTANTS
17			public const uint INPUT_MOUSE = 0x0;
18			public const int INPUT_KEYBOARD = 0x1;
19			public const int INPUT_HARDWARE = 0x2;
20			#endregion
21			#region KEYEVENTF CONSTANTS
22			public const uint KEYEVENTF_EXTENDEDKEY = 0x1;
23			public const uint KEYEVENTF_KEYDOWN = 0x0;
24			public const uint KEYEVENTF_KEYUP = 0x2;
25			public const uint KEYEVENTF_UNICODE = 0x4;
26			public const uint KEYEVENTF_SCANCODE = 0x8;
27			#endregion
28			#region XBUTTON CONSTANTS
29			public const uint XBUTTON1 = 0x1;
30			public const uint XBUTTON2 = 0x2;
31			#endregion
32			#region MOUSEEVENTF CONSTANTS
33			public const uint MOUSEEVENTF_MOVE = 0x1;
34			public const uint MOUSEEVENTF_LEFTDOWN = 0x2;
35			public const uint MOUSEEVENTF_LEFTUP = 0x4;
36			public const uint MOUSEEVENTF_RIGHTDOWN = 0x8;
37			public const uint MOUSEEVENTF_RIGHTUP = 0x10;
38			public const uint MOUSEEVENTF_MIDDLEDOWN = 0x20;
39			public const uint MOUSEEVENTF_MIDDLEUP = 0x40;
40			public const uint MOUSEEVENTF_XDOWN = 0x80;
41			public const uint MOUSEEVENTF_XUP = 0x100;
42			public const uint MOUSEEVENTF_WHEEL = 0x800;
43			public const uint MOUSEEVENTF_VIRTUALDESK = 0x4000;
44			public const uint MOUSEEVENTF_ABSOLUTE = 0x8000;
45			#endregion
46
47			[StructLayout(LayoutKind.Explicit)]
48			struct INPUT
49			{
50			[FieldOffset(0)]
51			public int dwType;
52			[FieldOffset(4)]
53			public MOUSEINPUT mouseInput;
54			[FieldOffset(4)]
55			public KEYBDINPUT keyboardInput;
56			[FieldOffset(4)]
57			public HARDWAREINPUT hardwareInput;
58			}
59			[StructLayout(LayoutKind.Explicit)]
60			struct KEYBDINPUT
61			{
62			[FieldOffset(0)]
63			public short wVk;
64			[FieldOffset(2)]
65			public short wScan;
66			[FieldOffset(4)]
67			public uint dwFlags;
68			[FieldOffset(8)]
69			public int time;
70			[FieldOffset(12)]
71			public IntPtr dwExtraInfo;
72			}
73			[StructLayout(LayoutKind.Explicit)]
74			struct HARDWAREINPUT
75			{
76			[FieldOffset(0)]
77			public int uMsg;
78			[FieldOffset(4)]
79			public short wParamL;
80			[FieldOffset(6)]
81			public short wParamH;
82			}
83			/// <summary>
84			/// The mouse data structure
85			/// </summary>
86			[StructLayout(LayoutKind.Explicit)]
87			struct MOUSEINPUT
88			{
89			[FieldOffset(0)]
90			public int dx;
91			[FieldOffset(4)]
92			public int dy;
93			[FieldOffset(8)]
94			public int mouseData;
95			[FieldOffset(12)]
96			public int dwFlags;
97			[FieldOffset(16)]
98			public int time;
99			[FieldOffset(20)]
100			public IntPtr dwExtraInfo;
101			}
102
103			[DllImport("user32.dll")]
104			static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
105			[DllImport("user32.dll", SetLastError = true)]
106			static extern uint SendInput(uint nInputs, ref INPUT pInputs, int cbSize);
107			[DllImport("user32.dll")]
108			static extern bool BlockInput(bool fBlockIt);
109
110			public void BlockUserInput() { BlockInput(true); }
111			public void UnBlockUserInput() { BlockInput(false); }
112
113
114			public static bool isExtendedVKKey(Key VKKey)
115			{
116			if (VKKey == Key.Insert \|\| VKKey == Key.Left \|\| VKKey == Key.Home \|\| VKKey == Key.End \|\|
117			VKKey == Key.Up \|\| VKKey == Key.Down \|\| VKKey == Key.PageUp \|\| VKKey == Key.PageDown \|\| VKKey == Key.Right)
118			{
119			return true;
120			}
121			return false;
122
123			}
124			public static bool isExtendedScanCode(short ScanCode)
125			{
126			DXKeysToScanCodes t = (DXKeysToScanCodes)ScanCode;
127			if (ScanCode == 0)
128			t = DXKeysToScanCodes.DIK_UNKOWN;
129			if (t == DXKeysToScanCodes.DIK_UP \|\|
130			t == DXKeysToScanCodes.DIK_DOWN \|\|
131			t == DXKeysToScanCodes.DIK_LEFT \|\|
132			t == DXKeysToScanCodes.DIK_RIGHT \|\|
133			t == DXKeysToScanCodes.DIK_HOME \|\|
134			t == DXKeysToScanCodes.DIK_END \|\|
135			t == DXKeysToScanCodes.DIK_NUMPADENTER \|\|
136			t == DXKeysToScanCodes.DIK_RCONTROL \|\|
137			t == DXKeysToScanCodes.DIK_RMENU \|\|
138			t == DXKeysToScanCodes.DIK_LEFT \|\|
139			t == DXKeysToScanCodes.DIK_PRIOR \|\|
140			t == DXKeysToScanCodes.DIK_NEXT \|\|
141			t == DXKeysToScanCodes.DIK_INSERT \|\|
142			t == DXKeysToScanCodes.DIK_DELETE)
143			{
144			return true;
145			}
146			return false;
147			}
148			static void DXKeyDown(short DXScanCode)
149			{
150			INPUT inputs = new INPUT();
151			inputs.dwType = INPUT_KEYBOARD;
152
153			if (isExtendedScanCode(DXScanCode))
154			{
155			inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE \| KEYEVENTF_KEYDOWN \| KEYEVENTF_EXTENDEDKEY;
156			}
157			else
158			{
159			inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE \| KEYEVENTF_KEYDOWN;
160			}
161
162
163			inputs.keyboardInput.wScan = DXScanCode;
164			int cbSize = Marshal.SizeOf(typeof(INPUT));
165			SendInput(1, ref inputs, cbSize);
166			}
167			static void DXKeyUp(short DXScanCode, TimeSpan wait)
168			{
169			if (wait.TotalMilliseconds > 0)
170			Thread.Sleep(wait);
171
172			INPUT inputs = new INPUT();
173			inputs.dwType = INPUT_KEYBOARD;
174			if (isExtendedScanCode(DXScanCode))
175			{
176			inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE \| KEYEVENTF_KEYUP \| KEYEVENTF_EXTENDEDKEY;
177			}
178			else
179			{
180			inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE \| KEYEVENTF_KEYUP;
181			}
182			inputs.keyboardInput.wScan = DXScanCode;
183			int cbSize = Marshal.SizeOf(typeof(INPUT));
184			SendInput(1, ref inputs, cbSize);
185			}
186
187			public static void SendDXKey(short DXKey)
188			{
189			PressDXKey(DXKey);
190			}
191			public static void SendDXKey(List<short> DXKeys)
192			{
193			foreach (short DXKey in DXKeys)
194			{
195			PressDXKey(DXKey);
196			}
197			}
198			public static void PressDXKey(short DXKey)
199			{
200			DXKeyDown((short)DXKey);
201			DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(250));
202			}
203			public static void PressDXKey(List<short> DXKeys)
204			{
205			foreach (short DXKey in DXKeys)
206			{
207			DXKeyDown((short)DXKey);
208			DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(250));
209			}
210			}
211
212			public static void PressDXKey_NoRelease(short DXKey)
213			{
214			DXKeyDown((short)DXKey);
215			//DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
216			}
217			public static void PressDXKey_NoRelease(List<short> DXKeys)
218			{
219			foreach (short DXKey in DXKeys)
220			{
221			DXKeyDown((short)DXKey);
222			//DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
223			}
224			}
225			public static void ReleaseDXKey(short DXKey)
226			{
227			//DXKeyDown((short)DXKey);
228			DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
229			}
230			public static void ReleaseDXKey(List<short> DXKeys)
231			{
232			foreach (short DXKey in DXKeys)
233			{
234			//DXKeyDown((short)DXKey);
235			DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
236			}
237			}
238			}
239			}