using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Threading;
using InputSimulatorStandard.Native;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: InternalsVisibleTo("InputSimulatorStandard.Tests")]
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
[assembly: AssemblyCompany("Michael Noonan, Theodoros Chatzigiannakis, Gregor Sindl")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright 2009-2019")]
[assembly: AssemblyDescription("This package is a fork of the Windows Input Simulator package. If you have encountered applications that do not receive input from the original Windows Input Simulator, try replacing it with this package instead.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+e40cbb1b4b0c6b34b0698e1c4877f96742565352")]
[assembly: AssemblyProduct("InputSimulatorStandard")]
[assembly: AssemblyTitle("InputSimulatorStandard")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace InputSimulatorStandard
{
	public interface IInputDeviceStateAdapter
	{
		bool IsKeyDown(VirtualKeyCode keyCode);

		bool IsKeyUp(VirtualKeyCode keyCode);

		bool IsHardwareKeyDown(VirtualKeyCode keyCode);

		bool IsHardwareKeyUp(VirtualKeyCode keyCode);

		bool IsTogglingKeyInEffect(VirtualKeyCode keyCode);
	}
	internal interface IInputMessageDispatcher
	{
		void DispatchInput(Input[] inputs);
	}
	public interface IInputSimulator
	{
		IKeyboardSimulator Keyboard { get; }

		IMouseSimulator Mouse { get; }

		IInputDeviceStateAdapter InputDeviceState { get; }
	}
	public interface IKeyboardSimulator
	{
		IKeyboardSimulator KeyDown(VirtualKeyCode keyCode);

		IKeyboardSimulator KeyPress(VirtualKeyCode keyCode);

		IKeyboardSimulator KeyPress(params VirtualKeyCode[] keyCodes);

		IKeyboardSimulator KeyUp(VirtualKeyCode keyCode);

		IKeyboardSimulator ModifiedKeyStroke(IEnumerable<VirtualKeyCode> modifierKeyCodes, IEnumerable<VirtualKeyCode> keyCodes);

		IKeyboardSimulator ModifiedKeyStroke(IEnumerable<VirtualKeyCode> modifierKeyCodes, VirtualKeyCode keyCode);

		IKeyboardSimulator ModifiedKeyStroke(VirtualKeyCode modifierKey, IEnumerable<VirtualKeyCode> keyCodes);

		IKeyboardSimulator ModifiedKeyStroke(VirtualKeyCode modifierKeyCode, VirtualKeyCode keyCode);

		IKeyboardSimulator TextEntry(string text);

		IKeyboardSimulator TextEntry(char character);

		IKeyboardSimulator Sleep(int millisecondsTimeout);

		IKeyboardSimulator Sleep(TimeSpan timeout);
	}
	public interface IMouseSimulator
	{
		int MouseWheelClickSize { get; set; }

		IMouseSimulator MoveMouseBy(int pixelDeltaX, int pixelDeltaY);

		IMouseSimulator MoveMouseTo(double absoluteX, double absoluteY);

		IMouseSimulator MoveMouseToPositionOnVirtualDesktop(double absoluteX, double absoluteY);

		IMouseSimulator LeftButtonDown();

		IMouseSimulator LeftButtonUp();

		IMouseSimulator LeftButtonClick();

		IMouseSimulator LeftButtonDoubleClick();

		IMouseSimulator MiddleButtonDown();

		IMouseSimulator MiddleButtonUp();

		IMouseSimulator MiddleButtonClick();

		IMouseSimulator MiddleButtonDoubleClick();

		IMouseSimulator RightButtonDown();

		IMouseSimulator RightButtonUp();

		IMouseSimulator RightButtonClick();

		IMouseSimulator RightButtonDoubleClick();

		IMouseSimulator XButtonDown(int buttonId);

		IMouseSimulator XButtonUp(int buttonId);

		IMouseSimulator XButtonClick(int buttonId);

		IMouseSimulator XButtonDoubleClick(int buttonId);

		IMouseSimulator VerticalScroll(int scrollAmountInClicks);

		IMouseSimulator HorizontalScroll(int scrollAmountInClicks);

		IMouseSimulator Sleep(int millisecondsTimeout);

		IMouseSimulator Sleep(TimeSpan timeout);
	}
	internal class InputBuilder : IEnumerable<Input>, IEnumerable
	{
		private readonly List<Input> inputList;

		private static readonly IReadOnlyList<VirtualKeyCode> ExtendedKeys = new List<VirtualKeyCode>
		{
			VirtualKeyCode.MENU,
			VirtualKeyCode.RMENU,
			VirtualKeyCode.CONTROL,
			VirtualKeyCode.RCONTROL,
			VirtualKeyCode.INSERT,
			VirtualKeyCode.DELETE,
			VirtualKeyCode.HOME,
			VirtualKeyCode.END,
			VirtualKeyCode.PRIOR,
			VirtualKeyCode.NEXT,
			VirtualKeyCode.RIGHT,
			VirtualKeyCode.UP,
			VirtualKeyCode.LEFT,
			VirtualKeyCode.DOWN,
			VirtualKeyCode.NUMLOCK,
			VirtualKeyCode.CANCEL,
			VirtualKeyCode.SNAPSHOT,
			VirtualKeyCode.DIVIDE
		};

		public Input this[int position] => inputList[position];

		public InputBuilder()
		{
			inputList = new List<Input>();
		}

		public Input[] ToArray()
		{
			return inputList.ToArray();
		}

		public IEnumerator<Input> GetEnumerator()
		{
			return inputList.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public static bool IsExtendedKey(VirtualKeyCode keyCode)
		{
			return ExtendedKeys.Contains(keyCode);
		}

		public InputBuilder AddKeyDown(VirtualKeyCode keyCode)
		{
			Input item = new Input
			{
				Type = 1u,
				Data = 
				{
					Keyboard = new KeyboardInput
					{
						KeyCode = (ushort)keyCode,
						Scan = (ushort)(NativeMethods.MapVirtualKey((uint)keyCode, 0u) & 0xFF),
						Flags = (IsExtendedKey(keyCode) ? 1u : 0u),
						Time = 0u,
						ExtraInfo = IntPtr.Zero
					}
				}
			};
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddKeyUp(VirtualKeyCode keyCode)
		{
			Input item = new Input
			{
				Type = 1u,
				Data = 
				{
					Keyboard = new KeyboardInput
					{
						KeyCode = (ushort)keyCode,
						Scan = (ushort)(NativeMethods.MapVirtualKey((uint)keyCode, 0u) & 0xFF),
						Flags = (IsExtendedKey(keyCode) ? 3u : 2u),
						Time = 0u,
						ExtraInfo = IntPtr.Zero
					}
				}
			};
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddKeyPress(VirtualKeyCode keyCode)
		{
			AddKeyDown(keyCode);
			AddKeyUp(keyCode);
			return this;
		}

		public InputBuilder AddCharacter(char character)
		{
			ushort num = character;
			Input item = new Input
			{
				Type = 1u,
				Data = 
				{
					Keyboard = new KeyboardInput
					{
						KeyCode = 0,
						Scan = num,
						Flags = 4u,
						Time = 0u,
						ExtraInfo = IntPtr.Zero
					}
				}
			};
			Input item2 = new Input
			{
				Type = 1u,
				Data = 
				{
					Keyboard = new KeyboardInput
					{
						KeyCode = 0,
						Scan = num,
						Flags = 6u,
						Time = 0u,
						ExtraInfo = IntPtr.Zero
					}
				}
			};
			if ((num & 0xFF00) == 57344)
			{
				item.Data.Keyboard.Flags |= 1u;
				item2.Data.Keyboard.Flags |= 1u;
			}
			inputList.Add(item);
			inputList.Add(item2);
			return this;
		}

		public InputBuilder AddCharacters(IEnumerable<char> characters)
		{
			foreach (char character in characters)
			{
				AddCharacter(character);
			}
			return this;
		}

		public InputBuilder AddCharacters(string characters)
		{
			return AddCharacters(characters.ToCharArray());
		}

		public InputBuilder AddRelativeMouseMovement(int x, int y)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 1u;
			item.Data.Mouse.X = x;
			item.Data.Mouse.Y = y;
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddAbsoluteMouseMovement(int absoluteX, int absoluteY)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 32769u;
			item.Data.Mouse.X = absoluteX;
			item.Data.Mouse.Y = absoluteY;
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddAbsoluteMouseMovementOnVirtualDesktop(int absoluteX, int absoluteY)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 49153u;
			item.Data.Mouse.X = absoluteX;
			item.Data.Mouse.Y = absoluteY;
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddMouseButtonDown(MouseButton button)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = (uint)ToMouseButtonDownFlag(button);
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddMouseXButtonDown(int xButtonId)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 128u;
			item.Data.Mouse.MouseData = (uint)xButtonId;
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddMouseButtonUp(MouseButton button)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = (uint)ToMouseButtonUpFlag(button);
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddMouseXButtonUp(int xButtonId)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 256u;
			item.Data.Mouse.MouseData = (uint)xButtonId;
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddMouseButtonClick(MouseButton button)
		{
			return AddMouseButtonDown(button).AddMouseButtonUp(button);
		}

		public InputBuilder AddMouseXButtonClick(int xButtonId)
		{
			return AddMouseXButtonDown(xButtonId).AddMouseXButtonUp(xButtonId);
		}

		public InputBuilder AddMouseButtonDoubleClick(MouseButton button)
		{
			return AddMouseButtonClick(button).AddMouseButtonClick(button);
		}

		public InputBuilder AddMouseXButtonDoubleClick(int xButtonId)
		{
			return AddMouseXButtonClick(xButtonId).AddMouseXButtonClick(xButtonId);
		}

		public InputBuilder AddMouseVerticalWheelScroll(int scrollAmount)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 2048u;
			item.Data.Mouse.MouseData = (uint)scrollAmount;
			inputList.Add(item);
			return this;
		}

		public InputBuilder AddMouseHorizontalWheelScroll(int scrollAmount)
		{
			Input item = new Input
			{
				Type = 0u
			};
			item.Data.Mouse.Flags = 4096u;
			item.Data.Mouse.MouseData = (uint)scrollAmount;
			inputList.Add(item);
			return this;
		}

		private static MouseFlag ToMouseButtonDownFlag(MouseButton button)
		{
			return button switch
			{
				MouseButton.LeftButton => MouseFlag.LeftDown, 
				MouseButton.MiddleButton => MouseFlag.MiddleDown, 
				MouseButton.RightButton => MouseFlag.RightDown, 
				_ => MouseFlag.LeftDown, 
			};
		}

		private static MouseFlag ToMouseButtonUpFlag(MouseButton button)
		{
			return button switch
			{
				MouseButton.LeftButton => MouseFlag.LeftUp, 
				MouseButton.MiddleButton => MouseFlag.MiddleUp, 
				MouseButton.RightButton => MouseFlag.RightUp, 
				_ => MouseFlag.LeftUp, 
			};
		}
	}
	public class InputSimulator : IInputSimulator
	{
		public IKeyboardSimulator Keyboard { get; }

		public IMouseSimulator Mouse { get; }

		public IInputDeviceStateAdapter InputDeviceState { get; }

		public InputSimulator()
			: this(new KeyboardSimulator(), new MouseSimulator(), new WindowsInputDeviceStateAdapter())
		{
		}

		public InputSimulator(IKeyboardSimulator keyboardSimulator, IMouseSimulator mouseSimulator, IInputDeviceStateAdapter inputDeviceStateAdapter)
		{
			Keyboard = keyboardSimulator ?? throw new ArgumentNullException("keyboardSimulator");
			Mouse = mouseSimulator ?? throw new ArgumentNullException("mouseSimulator");
			InputDeviceState = inputDeviceStateAdapter ?? throw new ArgumentNullException("inputDeviceStateAdapter");
		}
	}
	public class KeyboardSimulator : IKeyboardSimulator
	{
		private readonly IInputMessageDispatcher messageDispatcher;

		public KeyboardSimulator()
			: this(new WindowsInputMessageDispatcher())
		{
		}

		internal KeyboardSimulator(IInputMessageDispatcher messageDispatcher)
		{
			this.messageDispatcher = messageDispatcher ?? throw new InvalidOperationException(string.Format("The {0} cannot operate with a null {1}. Please provide a valid {1} instance to use for dispatching {2} messages.", typeof(KeyboardSimulator).Name, typeof(IInputMessageDispatcher).Name, typeof(Input).Name));
		}

		public IKeyboardSimulator KeyDown(VirtualKeyCode keyCode)
		{
			Input[] inputList = new InputBuilder().AddKeyDown(keyCode).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IKeyboardSimulator KeyUp(VirtualKeyCode keyCode)
		{
			Input[] inputList = new InputBuilder().AddKeyUp(keyCode).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IKeyboardSimulator KeyPress(VirtualKeyCode keyCode)
		{
			Input[] inputList = new InputBuilder().AddKeyPress(keyCode).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IKeyboardSimulator KeyPress(params VirtualKeyCode[] keyCodes)
		{
			InputBuilder inputBuilder = new InputBuilder();
			KeysPress(inputBuilder, keyCodes);
			SendSimulatedInput(inputBuilder.ToArray());
			return this;
		}

		public IKeyboardSimulator ModifiedKeyStroke(VirtualKeyCode modifierKeyCode, VirtualKeyCode keyCode)
		{
			ModifiedKeyStroke(new VirtualKeyCode[1] { modifierKeyCode }, new VirtualKeyCode[1] { keyCode });
			return this;
		}

		public IKeyboardSimulator ModifiedKeyStroke(IEnumerable<VirtualKeyCode> modifierKeyCodes, VirtualKeyCode keyCode)
		{
			ModifiedKeyStroke(modifierKeyCodes, new VirtualKeyCode[1] { keyCode });
			return this;
		}

		public IKeyboardSimulator ModifiedKeyStroke(VirtualKeyCode modifierKey, IEnumerable<VirtualKeyCode> keyCodes)
		{
			ModifiedKeyStroke(new VirtualKeyCode[1] { modifierKey }, keyCodes);
			return this;
		}

		public IKeyboardSimulator ModifiedKeyStroke(IEnumerable<VirtualKeyCode> modifierKeyCodes, IEnumerable<VirtualKeyCode> keyCodes)
		{
			InputBuilder inputBuilder = new InputBuilder();
			ModifiersDown(inputBuilder, modifierKeyCodes);
			KeysPress(inputBuilder, keyCodes);
			ModifiersUp(inputBuilder, modifierKeyCodes);
			SendSimulatedInput(inputBuilder.ToArray());
			return this;
		}

		public IKeyboardSimulator TextEntry(string text)
		{
			if ((long)text.Length > 2147483647L)
			{
				throw new ArgumentException($"The text parameter is too long. It must be less than {2147483647u} characters.", "text");
			}
			Input[] inputList = new InputBuilder().AddCharacters(text).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IKeyboardSimulator TextEntry(char character)
		{
			Input[] inputList = new InputBuilder().AddCharacter(character).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IKeyboardSimulator Sleep(int millisecondsTimeout)
		{
			return Sleep(TimeSpan.FromMilliseconds(millisecondsTimeout));
		}

		public IKeyboardSimulator Sleep(TimeSpan timeout)
		{
			Thread.Sleep(timeout);
			return this;
		}

		private void ModifiersDown(InputBuilder builder, IEnumerable<VirtualKeyCode> modifierKeyCodes)
		{
			if (modifierKeyCodes == null)
			{
				return;
			}
			foreach (VirtualKeyCode modifierKeyCode in modifierKeyCodes)
			{
				builder.AddKeyDown(modifierKeyCode);
			}
		}

		private void ModifiersUp(InputBuilder builder, IEnumerable<VirtualKeyCode> modifierKeyCodes)
		{
			if (modifierKeyCodes != null)
			{
				Stack<VirtualKeyCode> stack = new Stack<VirtualKeyCode>(modifierKeyCodes);
				while (stack.Count > 0)
				{
					builder.AddKeyUp(stack.Pop());
				}
			}
		}

		private void KeysPress(InputBuilder builder, IEnumerable<VirtualKeyCode> keyCodes)
		{
			if (keyCodes == null)
			{
				return;
			}
			foreach (VirtualKeyCode keyCode in keyCodes)
			{
				builder.AddKeyPress(keyCode);
			}
		}

		private void SendSimulatedInput(Input[] inputList)
		{
			messageDispatcher.DispatchInput(inputList);
		}
	}
	public enum MouseButton
	{
		LeftButton,
		MiddleButton,
		RightButton
	}
	public class MouseSimulator : IMouseSimulator
	{
		private readonly IInputMessageDispatcher messageDispatcher;

		public int MouseWheelClickSize { get; set; } = 120;

		public MouseSimulator()
			: this(new WindowsInputMessageDispatcher())
		{
		}

		internal MouseSimulator(IInputMessageDispatcher messageDispatcher)
		{
			this.messageDispatcher = messageDispatcher ?? throw new InvalidOperationException(string.Format("The {0} cannot operate with a null {1}. Please provide a valid {1} instance to use for dispatching {2} messages.", typeof(MouseSimulator).Name, typeof(IInputMessageDispatcher).Name, typeof(Input).Name));
		}

		public IMouseSimulator MoveMouseBy(int pixelDeltaX, int pixelDeltaY)
		{
			Input[] inputList = new InputBuilder().AddRelativeMouseMovement(pixelDeltaX, pixelDeltaY).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator MoveMouseTo(double absoluteX, double absoluteY)
		{
			Input[] inputList = new InputBuilder().AddAbsoluteMouseMovement((int)Math.Truncate(absoluteX), (int)Math.Truncate(absoluteY)).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator MoveMouseToPositionOnVirtualDesktop(double absoluteX, double absoluteY)
		{
			Input[] inputList = new InputBuilder().AddAbsoluteMouseMovementOnVirtualDesktop((int)Math.Truncate(absoluteX), (int)Math.Truncate(absoluteY)).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator LeftButtonDown()
		{
			return ButtonDown(MouseButton.LeftButton);
		}

		public IMouseSimulator LeftButtonUp()
		{
			return ButtonUp(MouseButton.LeftButton);
		}

		public IMouseSimulator LeftButtonClick()
		{
			return ButtonClick(MouseButton.LeftButton);
		}

		public IMouseSimulator LeftButtonDoubleClick()
		{
			return ButtonDoubleClick(MouseButton.LeftButton);
		}

		public IMouseSimulator MiddleButtonDown()
		{
			return ButtonDown(MouseButton.MiddleButton);
		}

		public IMouseSimulator MiddleButtonUp()
		{
			return ButtonUp(MouseButton.MiddleButton);
		}

		public IMouseSimulator MiddleButtonClick()
		{
			return ButtonClick(MouseButton.MiddleButton);
		}

		public IMouseSimulator MiddleButtonDoubleClick()
		{
			return ButtonDoubleClick(MouseButton.MiddleButton);
		}

		public IMouseSimulator RightButtonDown()
		{
			return ButtonDown(MouseButton.RightButton);
		}

		public IMouseSimulator RightButtonUp()
		{
			return ButtonUp(MouseButton.RightButton);
		}

		public IMouseSimulator RightButtonClick()
		{
			return ButtonClick(MouseButton.RightButton);
		}

		public IMouseSimulator RightButtonDoubleClick()
		{
			return ButtonDoubleClick(MouseButton.RightButton);
		}

		public IMouseSimulator XButtonDown(int buttonId)
		{
			Input[] inputList = new InputBuilder().AddMouseXButtonDown(buttonId).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator XButtonUp(int buttonId)
		{
			Input[] inputList = new InputBuilder().AddMouseXButtonUp(buttonId).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator XButtonClick(int buttonId)
		{
			Input[] inputList = new InputBuilder().AddMouseXButtonClick(buttonId).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator XButtonDoubleClick(int buttonId)
		{
			Input[] inputList = new InputBuilder().AddMouseXButtonDoubleClick(buttonId).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator VerticalScroll(int scrollAmountInClicks)
		{
			Input[] inputList = new InputBuilder().AddMouseVerticalWheelScroll(scrollAmountInClicks * MouseWheelClickSize).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator HorizontalScroll(int scrollAmountInClicks)
		{
			Input[] inputList = new InputBuilder().AddMouseHorizontalWheelScroll(scrollAmountInClicks * MouseWheelClickSize).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		public IMouseSimulator Sleep(int millisecondsTimeout)
		{
			return Sleep(TimeSpan.FromMilliseconds(millisecondsTimeout));
		}

		public IMouseSimulator Sleep(TimeSpan timeout)
		{
			Thread.Sleep(timeout);
			return this;
		}

		private void SendSimulatedInput(Input[] inputList)
		{
			messageDispatcher.DispatchInput(inputList);
		}

		private IMouseSimulator ButtonDown(MouseButton mouseButton)
		{
			Input[] inputList = new InputBuilder().AddMouseButtonDown(mouseButton).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		private IMouseSimulator ButtonUp(MouseButton mouseButton)
		{
			Input[] inputList = new InputBuilder().AddMouseButtonUp(mouseButton).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		private IMouseSimulator ButtonClick(MouseButton mouseButton)
		{
			Input[] inputList = new InputBuilder().AddMouseButtonClick(mouseButton).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}

		private IMouseSimulator ButtonDoubleClick(MouseButton mouseButton)
		{
			Input[] inputList = new InputBuilder().AddMouseButtonDoubleClick(mouseButton).ToArray();
			SendSimulatedInput(inputList);
			return this;
		}
	}
	public class WindowsInputDeviceStateAdapter : IInputDeviceStateAdapter
	{
		public bool IsKeyDown(VirtualKeyCode keyCode)
		{
			return NativeMethods.GetKeyState((ushort)keyCode) < 0;
		}

		public bool IsKeyUp(VirtualKeyCode keyCode)
		{
			return !IsKeyDown(keyCode);
		}

		public bool IsHardwareKeyDown(VirtualKeyCode keyCode)
		{
			return NativeMethods.GetAsyncKeyState((ushort)keyCode) < 0;
		}

		public bool IsHardwareKeyUp(VirtualKeyCode keyCode)
		{
			return !IsHardwareKeyDown(keyCode);
		}

		public bool IsTogglingKeyInEffect(VirtualKeyCode keyCode)
		{
			return (NativeMethods.GetKeyState((ushort)keyCode) & 1) == 1;
		}
	}
	internal class WindowsInputMessageDispatcher : IInputMessageDispatcher
	{
		public void DispatchInput(Input[] inputs)
		{
			if (inputs == null)
			{
				throw new ArgumentNullException("inputs");
			}
			if (inputs.Length == 0)
			{
				throw new ArgumentException("The input array was empty", "inputs");
			}
			if (NativeMethods.SendInput((uint)inputs.Length, inputs, Marshal.SizeOf(typeof(Input))) != inputs.Length)
			{
				throw new Exception("Some simulated input commands were not sent successfully. The most common reason for this happening are the security features of Windows including User Interface Privacy Isolation (UIPI). Your application can only send commands to applications of the same or lower elevation. Similarly certain commands are restricted to Accessibility/UIAutomation applications. Refer to the project home page and the code samples for more information.");
			}
		}
	}
}
namespace InputSimulatorStandard.Native
{
	internal struct HardwareInput
	{
		public uint Msg;

		public ushort ParamL;

		public ushort ParamH;
	}
	internal struct Input
	{
		public uint Type;

		public MouseKeyboardHardwareInput Data;
	}
	internal enum InputType : uint
	{
		Mouse,
		Keyboard,
		Hardware
	}
	[Flags]
	internal enum KeyboardFlag : uint
	{
		ExtendedKey = 1u,
		KeyUp = 2u,
		Unicode = 4u,
		ScanCode = 8u
	}
	internal struct KeyboardInput
	{
		public ushort KeyCode;

		public ushort Scan;

		public uint Flags;

		public uint Time;

		public IntPtr ExtraInfo;
	}
	[Flags]
	internal enum MouseFlag : uint
	{
		Move = 1u,
		LeftDown = 2u,
		LeftUp = 4u,
		RightDown = 8u,
		RightUp = 0x10u,
		MiddleDown = 0x20u,
		MiddleUp = 0x40u,
		XDown = 0x80u,
		XUp = 0x100u,
		VerticalWheel = 0x800u,
		HorizontalWheel = 0x1000u,
		VirtualDesk = 0x4000u,
		Absolute = 0x8000u
	}
	internal struct MouseInput
	{
		public int X;

		public int Y;

		public uint MouseData;

		public uint Flags;

		public uint Time;

		public IntPtr ExtraInfo;
	}
	[StructLayout(LayoutKind.Explicit)]
	internal struct MouseKeyboardHardwareInput
	{
		[FieldOffset(0)]
		public MouseInput Mouse;

		[FieldOffset(0)]
		public KeyboardInput Keyboard;

		[FieldOffset(0)]
		public HardwareInput Hardware;
	}
	internal static class NativeMethods
	{
		[DllImport("user32.dll", SetLastError = true)]
		public static extern short GetAsyncKeyState(ushort virtualKeyCode);

		[DllImport("user32.dll", SetLastError = true)]
		public static extern short GetKeyState(ushort virtualKeyCode);

		[DllImport("user32.dll", SetLastError = true)]
		public static extern uint SendInput(uint numberOfInputs, Input[] inputs, int sizeOfInputStructure);

		[DllImport("user32.dll")]
		public static extern IntPtr GetMessageExtraInfo();

		[DllImport("user32.dll")]
		public static extern uint MapVirtualKey(uint uCode, uint uMapType);
	}
	public enum VirtualKeyCode
	{
		LBUTTON = 1,
		RBUTTON = 2,
		CANCEL = 3,
		MBUTTON = 4,
		XBUTTON1 = 5,
		XBUTTON2 = 6,
		BACK = 8,
		TAB = 9,
		CLEAR = 12,
		RETURN = 13,
		SHIFT = 16,
		CONTROL = 17,
		MENU = 18,
		PAUSE = 19,
		CAPITAL = 20,
		KANA = 21,
		HANGEUL = 21,
		HANGUL = 21,
		JUNJA = 23,
		FINAL = 24,
		HANJA = 25,
		KANJI = 25,
		ESCAPE = 27,
		CONVERT = 28,
		NONCONVERT = 29,
		ACCEPT = 30,
		MODECHANGE = 31,
		SPACE = 32,
		PRIOR = 33,
		NEXT = 34,
		END = 35,
		HOME = 36,
		LEFT = 37,
		UP = 38,
		RIGHT = 39,
		DOWN = 40,
		SELECT = 41,
		PRINT = 42,
		EXECUTE = 43,
		SNAPSHOT = 44,
		INSERT = 45,
		DELETE = 46,
		HELP = 47,
		VK_0 = 48,
		VK_1 = 49,
		VK_2 = 50,
		VK_3 = 51,
		VK_4 = 52,
		VK_5 = 53,
		VK_6 = 54,
		VK_7 = 55,
		VK_8 = 56,
		VK_9 = 57,
		VK_A = 65,
		VK_B = 66,
		VK_C = 67,
		VK_D = 68,
		VK_E = 69,
		VK_F = 70,
		VK_G = 71,
		VK_H = 72,
		VK_I = 73,
		VK_J = 74,
		VK_K = 75,
		VK_L = 76,
		VK_M = 77,
		VK_N = 78,
		VK_O = 79,
		VK_P = 80,
		VK_Q = 81,
		VK_R = 82,
		VK_S = 83,
		VK_T = 84,
		VK_U = 85,
		VK_V = 86,
		VK_W = 87,
		VK_X = 88,
		VK_Y = 89,
		VK_Z = 90,
		LWIN = 91,
		RWIN = 92,
		APPS = 93,
		SLEEP = 95,
		NUMPAD0 = 96,
		NUMPAD1 = 97,
		NUMPAD2 = 98,
		NUMPAD3 = 99,
		NUMPAD4 = 100,
		NUMPAD5 = 101,
		NUMPAD6 = 102,
		NUMPAD7 = 103,
		NUMPAD8 = 104,
		NUMPAD9 = 105,
		MULTIPLY = 106,
		ADD = 107,
		SEPARATOR = 108,
		SUBTRACT = 109,
		DECIMAL = 110,
		DIVIDE = 111,
		F1 = 112,
		F2 = 113,
		F3 = 114,
		F4 = 115,
		F5 = 116,
		F6 = 117,
		F7 = 118,
		F8 = 119,
		F9 = 120,
		F10 = 121,
		F11 = 122,
		F12 = 123,
		F13 = 124,
		F14 = 125,
		F15 = 126,
		F16 = 127,
		F17 = 128,
		F18 = 129,
		F19 = 130,
		F20 = 131,
		F21 = 132,
		F22 = 133,
		F23 = 134,
		F24 = 135,
		NUMLOCK = 144,
		SCROLL = 145,
		LSHIFT = 160,
		RSHIFT = 161,
		LCONTROL = 162,
		RCONTROL = 163,
		LMENU = 164,
		RMENU = 165,
		BROWSER_BACK = 166,
		BROWSER_FORWARD = 167,
		BROWSER_REFRESH = 168,
		BROWSER_STOP = 169,
		BROWSER_SEARCH = 170,
		BROWSER_FAVORITES = 171,
		BROWSER_HOME = 172,
		VOLUME_MUTE = 173,
		VOLUME_DOWN = 174,
		VOLUME_UP = 175,
		MEDIA_NEXT_TRACK = 176,
		MEDIA_PREV_TRACK = 177,
		MEDIA_STOP = 178,
		MEDIA_PLAY_PAUSE = 179,
		LAUNCH_MAIL = 180,
		LAUNCH_MEDIA_SELECT = 181,
		LAUNCH_APP1 = 182,
		LAUNCH_APP2 = 183,
		OEM_1 = 186,
		OEM_PLUS = 187,
		OEM_COMMA = 188,
		OEM_MINUS = 189,
		OEM_PERIOD = 190,
		OEM_2 = 191,
		OEM_3 = 192,
		OEM_4 = 219,
		OEM_5 = 220,
		OEM_6 = 221,
		OEM_7 = 222,
		OEM_8 = 223,
		OEM_102 = 226,
		PROCESSKEY = 229,
		PACKET = 231,
		ATTN = 246,
		CRSEL = 247,
		EXSEL = 248,
		EREOF = 249,
		PLAY = 250,
		ZOOM = 251,
		NONAME = 252,
		PA1 = 253,
		OEM_CLEAR = 254
	}
	internal enum XButton : uint
	{
		XButton1 = 1u,
		XButton2
	}
}