private static LogicalKey CreateKey(VirtualKeyCode keyCode, IInputSimulator inputSimulator, KeyBehaviour keyType, VirtualKeyCollection chordKeys, string outputText)
{
LogicalKey result = null;
switch (keyType)
{
case KeyBehaviour.VirtualKey:
result = CreateVirtualKey(keyCode, inputSimulator);
break;
case KeyBehaviour.Chord:
result = CreateChordKey(keyCode, inputSimulator, chordKeys);
break;
case KeyBehaviour.Text:
result = CreateTextKey(keyCode, inputSimulator, outputText);
break;
case KeyBehaviour.InstantaneousModifier:
result = CreateInstantaneousModifierKey(keyCode, inputSimulator);
break;
case KeyBehaviour.TogglingModifier:
result = CreateTogglingModifierKey(keyCode, inputSimulator);
break;
default:
break;
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="MouseSimulator"/> class using an instance of a <see cref="WindowsInputMessageDispatcher"/> for dispatching <see cref="INPUT"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
public MouseSimulator(IInputSimulator inputSimulator)
{
if (inputSimulator == null) throw new ArgumentNullException("inputSimulator");
_inputSimulator = inputSimulator;
_messageDispatcher = new WindowsInputMessageDispatcher();
}
public ScreenKeyboardControlViewModel(Layout symbolBlock, List <Layout> languageBlocks, Layout numbersBlock,
List <Layout> additionalBlocks, List <string> quickAccessPanelLayout, IInputSimulator inputSimulator)
{
_inputSimulator = inputSimulator;
RegisterKeyInputCommand = new DelegateCommand(RegisterKeyInputExecute);
ChangeTabCommand = new DelegateCommand(ChangeTabExecute);
TabsButtons = new List <string>();
LanguageBlocks = languageBlocks;
InitKeyInputCommands(LanguageBlocks);
CurrentLayout = LanguageBlocks[0];
SymbolBlock = symbolBlock;
InitKeyInputCommands(new List <Layout>(1)
{
SymbolBlock
});
NumbersBlock = numbersBlock;
InitKeyInputCommands(new List <Layout>(1)
{
NumbersBlock
});
IsLangMode = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="MouseSimulator"/> class using the specified <see cref="IInputMessageDispatcher"/> for dispatching <see cref="INPUT"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
/// <param name="messageDispatcher">The <see cref="IInputMessageDispatcher"/> to use for dispatching <see cref="INPUT"/> messages.</param>
/// <exception cref="InvalidOperationException">If null is passed as the <paramref name="messageDispatcher"/>.</exception>
internal MouseSimulator(IInputSimulator inputSimulator, IInputMessageDispatcher messageDispatcher)
{
_inputSimulator = inputSimulator ?? throw new ArgumentNullException("inputSimulator");
_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));
}
protected EmulatorDisplayInputControllerBase(IInputSimulator inputSimulator)
{
_inputSimulator = inputSimulator;
PauseDurationAfterSendingKeyPress = DefaultPauseDurationAfterAction;
PauseDurationAfterSettingForegroundWindow = DefaultPauseDurationAfterAction;
PauseDurationAfterPerformingGesture = DefaultPauseDurationAfterAction;
PauseDurationAfterTextEntry = DefaultPauseDurationAfterAction;
}
public AnalogKeyboardSimulator(IInputSimulator inputSimulator) : base(inputSimulator)
{
this.currentlyDownKeys = new ConcurrentDictionary <VirtualKeyCode, BackgroundWorker>();
this.currentlyDownAmounts = new ConcurrentDictionary <VirtualKeyCode, double>();
this.pwmWorker = new BackgroundWorker();
PwmIntervalNanoseconds = 10000;
}
private static TextKey CreateTextKey(VirtualKeyCode keyCode, IInputSimulator inputSimulator, string outputText)
{
if (string.IsNullOrEmpty(outputText))
{
return(null);
}
return(new TextKey(inputSimulator, keyCode, outputText));
}
protected EmulatorDisplayInputControllerBase(IInputSimulator inputSimulator)
{
_inputSimulator = inputSimulator;
PauseDurationAfterSendingKeyPress = DefaultPauseDurationAfterAction;
PauseDurationAfterSettingForegroundWindow = DefaultPauseDurationAfterAction;
PauseDurationAfterPerformingGesture = DefaultPauseDurationAfterAction;
PauseDurationAfterTextEntry = DefaultPauseDurationAfterAction;
}
private static ChordKey CreateChordKey(VirtualKeyCode keyCode, IInputSimulator inputSimulator, VirtualKeyCollection chordKeys)
{
if (chordKeys == null || !chordKeys.Any())
{
return(null);
}
return(new ChordKey(inputSimulator, keyCode, chordKeys));
}
public ChordKey(IInputSimulator inputSimulator, VirtualKeyCode key, VirtualKeyCollection modifierKeys) : base(inputSimulator, key)
{
this.modifierKeys = new List <WindowsInput.Native.VirtualKeyCode>();
foreach (VirtualKeyCode keyCode in modifierKeys)
{
this.modifierKeys.Add((WindowsInput.Native.VirtualKeyCode)keyCode);
}
}
private static VirtualKey CreateVirtualKey(VirtualKeyCode keyCode, IInputSimulator inputSimulator)
{
if (keyCode == VirtualKeyCode.None)
{
return(null);
}
return(new VirtualKey(inputSimulator, keyCode));
}
public KeyboardSimulator(IInputSimulator inputSimulator) {
if (inputSimulator == null) {
throw new ArgumentNullException(nameof(inputSimulator));
}
_inputSimulator = inputSimulator;
_messageDispatcher = new WindowsInputMessageDispatcher();
}
public void SendKeyboardAction(IInputSimulator simulator, VirtualKeyCode key)
{
if (simulator == null)
{
throw new ArgumentNullException();
}
simulator.Keyboard.KeyPress(key);
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyboardSimulator"/> class using the specified <see cref="IInputMessageDispatcher"/> for dispatching <see cref="INPUT"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
/// <param name="messageDispatcher">The <see cref="IInputMessageDispatcher"/> to use for dispatching <see cref="INPUT"/> messages.</param>
/// <exception cref="InvalidOperationException">If null is passed as the <paramref name="messageDispatcher"/>.</exception>
internal KeyboardSimulator(IInputSimulator inputSimulator, IInputMessageDispatcher messageDispatcher)
{
_inputSimulator = inputSimulator ?? throw new ArgumentNullException(nameof(inputSimulator));
_messageDispatcher = messageDispatcher ?? throw new InvalidOperationException(
$"The {nameof(KeyboardSimulator)} cannot operate " +
$"with a null {nameof(IInputMessageDispatcher)}. " +
$"Please provide a valid {nameof(IInputMessageDispatcher)} instance " +
$"to use for dispatching {nameof(INPUT)} messages.");
}
public KeyboardSimulator(IInputSimulator inputSimulator)
{
if (inputSimulator == null)
{
throw new ArgumentNullException(nameof(inputSimulator));
}
_inputSimulator = inputSimulator;
_messageDispatcher = new WindowsInputMessageDispatcher();
}
/// <summary>
/// Initializes a new instance of the <see cref="MouseSimulator"/> class using an instance of a <see cref="WindowsInputMessageDispatcher"/> for dispatching <see cref="INPUT"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
public MouseSimulator(IInputSimulator inputSimulator)
{
if (inputSimulator == null)
{
throw new ArgumentNullException("inputSimulator");
}
_inputSimulator = inputSimulator;
_messageDispatcher = new WindowsInputMessageDispatcher();
}
internal KeyboardSimulator(IInputSimulator inputSimulator,
IInputMessageDispatcher messageDispatcher)
{
_inputSimulator = inputSimulator ?? throw new ArgumentNullException(nameof(inputSimulator));
_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.",
nameof(KeyboardSimulator), nameof(IInputMessageDispatcher),
nameof(Win32Types.INPUT)));
}
/// <summary>
/// Initializes a new instance of the <see cref="MouseSimulator"/> class using the specified <see cref="IInputMessageDispatcher"/> for dispatching <see cref="InputEntry"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
/// <param name="messageDispatcher">The <see cref="IInputMessageDispatcher"/> to use for dispatching <see cref="InputEntry"/> messages.</param>
/// <exception cref="InvalidOperationException">If null is passed as the <paramref name="messageDispatcher"/>.</exception>
internal MouseSimulator(IInputSimulator inputSimulator, IInputMessageDispatcher messageDispatcher) {
if (inputSimulator == null) throw new ArgumentNullException(nameof(inputSimulator));
if (messageDispatcher == null)
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(InputEntry).Name));
_inputSimulator = inputSimulator;
_messageDispatcher = messageDispatcher;
}
public TRexBrain()
{
Console.WriteLine("Press any key to boot up!");
Console.ReadKey();
Console.WriteLine("=== Brain has been booted ===");
imageProcessor = new TRexImageProcessor();
inputSimulator = new InputSimulator();
TRex = new TRex(inputSimulator);
increasePredictionTimer = new Timer(1000);
Play();
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyboardSimulator"/> class using an instance of a <see cref="WindowsInputMessageDispatcher"/> for dispatching <see cref="INPUT"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
/// <param name="UseScanCodes">Tells the simulator to use ScanCodes instead of keycodes.</param>
public KeyboardSimulator(IInputSimulator inputSimulator, bool useScanCodes = false)
{
if (inputSimulator == null)
{
throw new ArgumentNullException("inputSimulator");
}
_inputSimulator = inputSimulator;
_messageDispatcher = new WindowsInputMessageDispatcher();
UseScanCodes = useScanCodes;
}
public InputListener(ISubject <ServerState> serverState, ILogger <InputListener> logger,
IInputSimulator inputSimulator, ApplicationSettings applicationSettings,
ICommandParser commandParser)
{
this.serverState = serverState;
serverState.Subscribe(OnNext);
this.logger = logger;
this.inputSimulator = inputSimulator;
this.applicationSettings = applicationSettings;
this.commandParser = commandParser;
sessionList = new List <Session>();
}
private int _corrY; //correction for Y
public InputService(IEventAggregator eventAggregator, IInputSimulator simulator)
{
_eventAggregator = eventAggregator;
_simulator = simulator;
_rndX = new Random();
_rndY = new Random();
_corrX = 0;
_corrY = 55;
_eventAggregator.GetEvent <UpdateControlsEvent>().Subscribe(OnUpdateControls);
}
private static async Task RefreshPressEvery(IInputSimulator inputSimulator, TimeSpan delay, CancellationToken ct, TimeSpan?showMessageTime = null)
{
if (delay.TotalSeconds < 1)
{
throw new ArgumentException("The delay has to be at least one second long", nameof(delay));
}
// set delay for showing the messsage
TimeSpan showMsgTime;
if (showMessageTime.HasValue)
{
showMsgTime = showMessageTime.Value;
if (delay.TotalSeconds <= showMsgTime.TotalSeconds)
{
throw new ArgumentException("The show-message-time has to be shorter than the delay.", nameof(showMessageTime));
}
}
else
{
TimeSpan fraction = delay.Divide(20);
showMsgTime = fraction.TotalSeconds < MAX_SHOW_MESSAGE_DELAY ? fraction : TimeSpan.FromSeconds(MAX_SHOW_MESSAGE_DELAY);
}
delay = delay.Add(showMsgTime.Negate());
while (!ct.IsCancellationRequested)
{
if (inputSimulator.InputDeviceState.IsKeyDown(VirtualKeyCode.RBUTTON))
{
PrintOnCurrentLine("Right mouse button is already being held down. No action taken.");
}
else
{
inputSimulator.Mouse.RightButtonDown();
PrintOnCurrentLine("Start holding down right mouse button.");
}
// show message for a bit
try
{
await Task.Delay(showMsgTime, ct);
}
catch (TaskCanceledException)
{
return;
}
// count down to next refresh
await CountDown("Next refresh in {0:hh\\:mm\\:ss}", delay, ct);
}
}
public InputListenerV2(
ISubject <ServerState> serverState,
ILogger <InputListener> logger,
IInputSimulator inputSimulator,
ApplicationSettings applicationSettings,
ICommandParser commandParser)
{
this.serverState = serverState;
this.logger = logger;
this.inputSimulator = inputSimulator;
this.applicationSettings = applicationSettings;
this.commandParser = commandParser;
}
/// <summary>
/// Initializes a new instance of the <see cref="KeyboardSimulator"/> class using the specified <see cref="IInputMessageDispatcher"/> for dispatching <see cref="INPUT"/> messages.
/// </summary>
/// <param name="inputSimulator">The <see cref="IInputSimulator"/> that owns this instance.</param>
/// <param name="messageDispatcher">The <see cref="IInputMessageDispatcher"/> to use for dispatching <see cref="INPUT"/> messages.</param>
/// <exception cref="InvalidOperationException">If null is passed as the <paramref name="messageDispatcher"/>.</exception>
internal KeyboardSimulator(IInputSimulator inputSimulator, IInputMessageDispatcher messageDispatcher)
{
if (inputSimulator == null)
{
throw new ArgumentNullException(nameof(inputSimulator));
}
if (messageDispatcher == null)
{
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));
}
_inputSimulator = inputSimulator;
_messageDispatcher = messageDispatcher;
}
public void SendKeyboardAction(IInputSimulator simulator, IEnumerable <VirtualKeyCode> modKeys, IEnumerable <VirtualKeyCode> signKeys)
{
if (simulator == null)
{
throw new ArgumentNullException();
}
if (modKeys.Any())
{
if (signKeys.Count() > 1 && signKeys.LastOrDefault() == VirtualKeyCode.LEFT)
{
var offset = signKeys.Count() - 1;
var signKeysWithModKeys = signKeys.Take(offset);
simulator.Keyboard.ModifiedKeyStroke(modKeys, signKeysWithModKeys);
simulator.Keyboard.KeyPress(signKeys.Last());
}
else
{
if (signKeys.Any())
{
simulator.Keyboard.ModifiedKeyStroke(modKeys, signKeys);
}
else
{
OnlyModKeyAction = true;
}
}
}
else
{
var modKeysToPressOnce = Globals.GetModKeysToPressOnce().ToList();
var modKeysToUse = Globals.GetModKeysToHoldDown().ToList();
modKeysToUse.AddRange(modKeysToPressOnce);
if (modKeysToUse.Any())
{
simulator.Keyboard.ModifiedKeyStroke(modKeysToUse, signKeys);
}
else
{
simulator.Keyboard.KeyPress(signKeys.ToArray());
}
}
}
public CopypastaController(IClipboard clipboard, IClipboardHistoryManager clipboardHistoryManager,
IClipboardBindingManager clipboardBindingManager, IHotkey ctrlVHotkey, IHotkey ctrlCHotkey, IHotkey escHotkey,
IKeyTracker keyTracker, IInputSimulator inputSimulator, INotificationDispatcher notificationDispatcher)
{
_clipboard = clipboard;
_clipboardHistoryManager = clipboardHistoryManager;
_clipboardBindingManager = clipboardBindingManager;
_ctrlVHotkey = ctrlVHotkey;
_ctrlCHotkey = ctrlCHotkey;
_escHotkey = escHotkey;
_keyTracker = keyTracker;
_inputSimulator = inputSimulator;
_notificationDispatcher = notificationDispatcher;
_copypastaStateMachine = new StateMachine <CopypastaState, CopypastaTrigger>(CopypastaState.Idle);
_keyPressedTrigger = _copypastaStateMachine.SetTriggerParameters <Key>(CopypastaTrigger.KeyPressed);
ConfigureCopypastaStateMachine();
ConfigureEventTriggers();
}
public override void EndInit()
{
inputSimulator = CreateInputSimulator();
keys = new Dictionary <UIElement, LogicalKey>();
modifierKeys = new List <ModifierKeyBase>();
foreach (UIElement child in Children)
{
VirtualKeyCode keyCode = (VirtualKeyCode)child.GetValue(KeyCodeProperty);
KeyBehaviour keyBehaviour = (KeyBehaviour)child.GetValue(KeyBehaviourProperty);
VirtualKeyCollection chordKeys = (VirtualKeyCollection)child.GetValue(ChordKeysProperty);
string outputText = (string)child.GetValue(OutputTextProperty);
if (keyBehaviour == KeyBehaviour.None)
{
// skip to the next child element
continue;
}
LogicalKey key = CreateKey(keyCode, inputSimulator, keyBehaviour, chordKeys, outputText);
if (key == null)
{
// skip to the next child element
continue;
}
ConnectToChildControl(child);
keys.Add(child, key);
key.KeyPressed += LogicalKeyPressed;
if (keyBehaviour == KeyBehaviour.InstantaneousModifier || keyBehaviour == KeyBehaviour.TogglingModifier)
{
modifierKeys.Add(key as ModifierKeyBase);
}
}
SynchroniseModifierKeyState();
base.EndInit();
}
public WiimoteInputControl()
{
#if DUMMY_INPUT
sim = new DummyInputSimulator();
#else
sim = new InputSimulator();
#endif
buttonInputs = new IInputButton[(int)WiimoteButton.Count];
overlayButtonInputs = new IInputButton[(int)WiimoteButton.Count];
analogInputs = new IInputAnalog[(int)WiimoteAnalog.Count];
WiimoteManager.Connected += OnWiimoteConnected;
WiimoteManager.Discovered += OnWiimoteDiscovered;
WiimoteManager.AutoDiscoveryCount = 1;
//FIXME: UnpairOnDisconnect is broken on Windows 10, it'll cause
// more problems than solve them at this point in time.
WiimoteManager.UnpairOnDisconnect = false; // true;
WiimoteManager.PairOnDiscover = false; // true;
//WiimoteManager.AutoConnect = false;
//TODO: This control REALLY should not be messing with static settings. BAD!
WiimoteManager.DolphinBarMode = true;
WiimoteManager.BluetoothMode = true;
WiimoteManager.StartDiscovery();
}
protected WindowsEmulatorDisplayInputControllerBase(IInputSimulator inputSimulator)
: base(inputSimulator)
{
}
public TextKey(IInputSimulator inputSimulator, VirtualKeyCode key, string text) : base(inputSimulator, key)
{
Text = text;
}
public VirtualKey(IInputSimulator inputSimulator, VirtualKeyCode key)
: base(inputSimulator, key)
{
}
public void SendMouseAction(IInputSimulator simulator,
IEnumerable <VirtualKeyCode> modKeys,
IEnumerable <VirtualKeyCode> mouseKeys)
{
throw new System.NotImplementedException();
}
public Task SendKeyboardActionAsync(IInputSimulator simulator, IEnumerable <VirtualKeyCode> modKeys, IEnumerable <VirtualKeyCode> signKeys)
{
throw new System.NotImplementedException();
}
protected WindowsEmulatorDisplayInputControllerBase(IInputSimulator inputSimulator)
: base(inputSimulator)
{
}
