public void SetSettings(XmlNode node)
{
var element = (XmlElement)node;
GlobalHotkeysEnabled = SettingsHelper.ParseBool(element["GlobalHotkeysEnabled"]);
CounterTextColor = SettingsHelper.ParseColor(element["CounterTextColor"]);
CounterValueColor = SettingsHelper.ParseColor(element["CounterValueColor"]);
CounterFont = SettingsHelper.GetFontFromElement(element["CounterFont"]);
OverrideCounterFont = SettingsHelper.ParseBool(element["OverrideCounterFont"]);
OverrideTextColor = SettingsHelper.ParseBool(element["OverrideTextColor"]);
BackgroundColor = SettingsHelper.ParseColor(element["BackgroundColor"]);
BackgroundColor2 = SettingsHelper.ParseColor(element["BackgroundColor2"]);
GradientString = SettingsHelper.ParseString(element["BackgroundGradient"]);
CounterText = SettingsHelper.ParseString(element["CounterText"]);
InitialValue = SettingsHelper.ParseInt(element["InitialValue"]);
Increment = SettingsHelper.ParseInt(element["Increment"]);
XmlElement incrementElement = element["IncrementKey"];
IncrementKey = string.IsNullOrEmpty(incrementElement.InnerText) ? null : new KeyOrButton(incrementElement.InnerText);
XmlElement decrementElement = element["DecrementKey"];
DecrementKey = string.IsNullOrEmpty(decrementElement.InnerText) ? null : new KeyOrButton(decrementElement.InnerText);
XmlElement resetElement = element["ResetKey"];
ResetKey = string.IsNullOrEmpty(resetElement.InnerText) ? null : new KeyOrButton(resetElement.InnerText);
RegisterHotKeys();
}
public static void IsKeyTest(Key?key, MouseAction?mouseAction)
{
// ReSharper disable once PossibleInvalidOperationException
KeyOrButton kob = key.HasValue ? new KeyOrButton(key.Value) : new KeyOrButton(mouseAction.Value);
Assert.That(key.HasValue ? kob.IsKey : !kob.IsKey);
}
private Keybind(string id, string name, Binding type, KeyOrButton defaultKeyOrButton)
{
this.id = id;
Name = name;
this.type = type;
Default = defaultKeyOrButton;
}
private static Keybind Register(string id, string name, Binding type, KeyOrButton defaultKeyOrButton)
{
var bind = new Keybind(id, name, type, defaultKeyOrButton);
Debug.Assert(!bindings.Contains(bind), $"The binding '{bind.id}' is already defined.");
bindings.Add(bind);
return(bind);
}
private void RegisterScrolling(CompositeHook hook)
{
var mouse = hook.GetMouse();
var name = mouse.Information.InstanceName + " " + mouse.Information.InstanceGuid;
ScrollUp = new KeyOrButton(new GamepadButton(name, "Scroll_Up"));
ScrollDown = new KeyOrButton(new GamepadButton(name, "Scroll_Down"));
hook.RegisterHotKey(ScrollUp);
hook.RegisterHotKey(ScrollDown);
}
public static void ImplicitCastToKeyOrMouseButton_FromMouseAction()
{
const MouseAction mouseAction = MouseAction.XButton1;
KeyOrButton keyOrButton = mouseAction;
Assert.Multiple(() =>
{
Assert.That(!keyOrButton.IsKey);
Assert.That(keyOrButton.MouseButton, Is.EqualTo(mouseAction));
});
}
public static void JsonConstructor_Key()
{
KeyOrButton kob = new KeyOrButton(true, Key.Up, null);
Assert.Multiple(() =>
{
Assert.That(kob.IsKey);
Assert.That(kob.Key, Is.EqualTo(Key.Up));
Assert.That(kob.MouseButton, Is.EqualTo(null));
});
}
public static void JsonConstructor_MouseAction()
{
KeyOrButton kob = new KeyOrButton(false, null, MouseAction.XButton1);
Assert.Multiple(() =>
{
Assert.That(!kob.IsKey);
Assert.That(kob.Key, Is.EqualTo(null));
Assert.That(kob.MouseButton, Is.EqualTo(MouseAction.XButton1));
});
}
public void MouseButtonToKeyOrMouseButtonImplicitOperator()
{
const MouseAction mouseAction = MouseAction.XButton1;
KeyOrButton keyOrButton = mouseAction;
Assert.Multiple(() =>
{
Assert.That(!keyOrButton.IsKey);
Assert.That(keyOrButton.MouseButton, Is.EqualTo(mouseAction));
});
}
public void KeyToKeyOrMouseButtonImplicitOperator()
{
const Key key = Key.A;
KeyOrButton kob = key;
Assert.Multiple(() =>
{
Assert.That(kob.IsKey);
Assert.That(kob.Key, Is.EqualTo(key));
});
}
public static void ImplicitCastToKeyOrMouseButton_FromKey()
{
const Key key = Key.A;
KeyOrButton kob = key;
Assert.Multiple(() =>
{
Assert.That(kob.IsKey);
Assert.That(kob.Key, Is.EqualTo(key));
});
}
private void RegisterHotkey(CompositeHook hook, KeyOrButton key)
{
hook.RegisterHotKey(key);
if (DeactivateHotkeysForOtherPrograms && key.IsKey && GlobalHotkeysEnabled)
{
var args = new System.Windows.Forms.KeyEventArgs(key.Key);
var modifiers = (args.Alt ? ModifierKeys.Alt : ModifierKeys.None)
| (args.Shift ? ModifierKeys.Shift : ModifierKeys.None)
| (args.Control ? ModifierKeys.Control : ModifierKeys.None);
HotkeyHook.Instance.RegisterHotKey(modifiers, args.KeyCode);
}
}
private void RegisterHotkey(CompositeHook hook, KeyOrButton key, bool deactivateForOtherPrograms)
{
//hook.RegisterHotKey(key);
if (deactivateForOtherPrograms && key.IsKey)
{
var args = new Eto.Forms.KeyEventArgs(key.Key, Eto.Forms.KeyEventType.KeyUp);
var modifiers = (args.Alt ? Eto.Forms.Keys.Alt : Eto.Forms.Keys.None)
| (args.Shift ? Eto.Forms.Keys.Shift : Eto.Forms.Keys.None)
| (args.Control ? Eto.Forms.Keys.Control : Eto.Forms.Keys.None);
// HotkeyHook.Instance.RegisterHotKey(modifiers, args.KeyCode);
}
}
public CounterComponentSettings()
{
InitializeComponent();
Hook = new CompositeHook();
// Set default values.
GlobalHotkeysEnabled = false;
CounterFont = new Font("Segoe UI", 13, FontStyle.Regular, GraphicsUnit.Pixel);
OverrideCounterFont = false;
CounterTextColor = Color.FromArgb(255, 255, 255, 255);
CounterValueColor = Color.FromArgb(255, 255, 255, 255);
OverrideTextColor = false;
BackgroundColor = Color.Transparent;
BackgroundColor2 = Color.Transparent;
BackgroundGradient = GradientType.Plain;
CounterText = "Counter:";
InitialValue = 0;
Increment = 1;
// Hotkeys
IncrementKey = new KeyOrButton(Keys.Add);
DecrementKey = new KeyOrButton(Keys.Subtract);
ResetKey = new KeyOrButton(Keys.NumPad0);
// Set bindings.
txtIncrement.Text = FormatKey(IncrementKey);
txtDecrement.Text = FormatKey(DecrementKey);
txtReset.Text = FormatKey(ResetKey);
txtCounterText.DataBindings.Add("Text", this, "CounterText");
numInitialValue.DataBindings.Add("Value", this, "InitialValue");
numIncrement.DataBindings.Add("Value", this, "Increment");
chkGlobalHotKeys.DataBindings.Add("Checked", this, "GlobalHotkeysEnabled", false, DataSourceUpdateMode.OnPropertyChanged);
chkFont.DataBindings.Add("Checked", this, "OverrideCounterFont", false, DataSourceUpdateMode.OnPropertyChanged);
lblFont.DataBindings.Add("Text", this, "CounterFontString", false, DataSourceUpdateMode.OnPropertyChanged);
chkColor.DataBindings.Add("Checked", this, "OverrideTextColor", false, DataSourceUpdateMode.OnPropertyChanged);
btnColor.DataBindings.Add("BackColor", this, "CounterTextColor", false, DataSourceUpdateMode.OnPropertyChanged);
btnColor3.DataBindings.Add("BackColor", this, "CounterValueColor", false, DataSourceUpdateMode.OnPropertyChanged);
btnColor1.DataBindings.Add("BackColor", this, "BackgroundColor", false, DataSourceUpdateMode.OnPropertyChanged);
btnColor2.DataBindings.Add("BackColor", this, "BackgroundColor2", false, DataSourceUpdateMode.OnPropertyChanged);
cmbGradientType.DataBindings.Add("SelectedItem", this, "GradientString", false, DataSourceUpdateMode.OnPropertyChanged);
// Assign event handlers.
cmbGradientType.SelectedIndexChanged += cmbGradientType_SelectedIndexChanged;
chkFont.CheckedChanged += chkFont_CheckedChanged;
chkColor.CheckedChanged += chkColor_CheckedChanged;
chkGlobalHotKeys.CheckedChanged += chkGlobalHotKeys_CheckedChanged;
Load += CounterSettings_Load;
RegisterHotKeys();
}
public static void Clone(Key?key, MouseAction?mouseAction)
{
// ReSharper disable once PossibleInvalidOperationException
KeyOrButton kob = key.HasValue ? new KeyOrButton(key.Value) : new KeyOrButton(mouseAction.Value);
KeyOrButton clone = kob.Clone() as KeyOrButton;
Assert.Multiple(() =>
{
Assert.That(clone, Is.Not.Null);
Assert.That(kob.IsKey, Is.EqualTo(clone.IsKey));
Assert.That(kob.Key, Is.EqualTo(clone.Key));
Assert.That(kob.MouseButton, Is.EqualTo(clone.MouseButton));
});
}
void hook_KeyOrButtonPressed(object sender, KeyOrButton e)
{
if (_game == null || _game.HasExited || _map == null || _game.MainWindowHandle != GetForegroundWindow())
{
return;
}
foreach (KeyOrButton key in _hideMissionObjectivesKeys)
{
if (key == e && _map.Current.ToLower() == "mission_01")
{
_shouldStart = true;
break;
}
}
}
private string FormatKey(KeyOrButton key)
{
if (key == null)
{
return("None");
}
string str = key.ToString();
if (key.IsButton)
{
int length = str.LastIndexOf(' ');
if (length != -1)
{
str = str.Substring(0, length);
}
}
return(str);
}
private string FormatKey(KeyOrButton key)
{
if (key != null)
{
var keyString = key.ToString();
if (key.IsButton)
{
var lastSpaceIndex = keyString.LastIndexOf(' ');
if (lastSpaceIndex != -1)
{
keyString = keyString.Substring(0, lastSpaceIndex);
}
}
return(keyString);
}
return("None");
}
public static void JsonConstructor_IfBothDependsOnIsKey()
{
KeyOrButton kob1 = new KeyOrButton(false, Key.Up, MouseAction.XButton1);
Assert.Multiple(() =>
{
Assert.That(!kob1.IsKey);
Assert.That(kob1.Key, Is.EqualTo(null));
Assert.That(kob1.MouseButton, Is.EqualTo(MouseAction.XButton1));
});
KeyOrButton kob2 = new KeyOrButton(true, Key.Up, MouseAction.XButton1);
Assert.Multiple(() =>
{
Assert.That(kob2.IsKey);
Assert.That(kob2.Key, Is.EqualTo(Key.Up));
Assert.That(kob2.MouseButton, Is.EqualTo(null));
});
}
// Basic support for keyboard/button input.
private void Hook_KeyOrButtonPressed(object sender, KeyOrButton e)
{
if ((Form.ActiveForm == state.Form && !Settings.GlobalHotkeysEnabled) ||
Settings.GlobalHotkeysEnabled)
{
if (e == Settings.IncrementKey)
{
Counter.Increment();
}
if (e == Settings.DecrementKey)
{
Counter.Decrement();
}
if (e == Settings.ResetKey)
{
Counter.Reset();
}
}
}
public static bool EqualsTest([NotNull] KeyOrButton kob1, KeyOrButton kob2)
{
return(kob1.Equals(kob2));
}
/// <summary>
/// Create a new push button.
/// </summary>
/// <param name="keyOrButton">The key or button to target.</param>
/// <param name="input">The input manager.</param>
public PushButton(KeyOrButton keyOrButton, InputManager input) : base(keyOrButton, input)
{
}
// Behaviour essentially Lifted from LiveSplit Settings.
private void SetHotkeyHandlers(TextBox txtBox, Action <KeyOrButton> keySetCallback)
{
string oldText = txtBox.Text;
txtBox.Text = "Set Hotkey...";
txtBox.Select(0, 0);
KeyEventHandler handlerDown = null;
KeyEventHandler handlerUp = null;
EventHandler leaveHandler = null;
EventHandlerT <GamepadButton> gamepadButtonPressed = null;
// Remove Input handlers.
Action unregisterEvents = () =>
{
txtBox.KeyDown -= handlerDown;
txtBox.KeyUp -= handlerUp;
txtBox.Leave -= leaveHandler;
Hook.AnyGamepadButtonPressed -= gamepadButtonPressed;
};
// Handler for KeyDown
handlerDown = (s, x) =>
{
KeyOrButton keyOrButton = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
// No action for special keys.
if (x.KeyCode == Keys.ControlKey || x.KeyCode == Keys.ShiftKey || x.KeyCode == Keys.Menu)
{
return;
}
keySetCallback(keyOrButton);
unregisterEvents();
// Remove Focus.
txtBox.Select(0, 0);
chkGlobalHotKeys.Select();
txtBox.Text = FormatKey(keyOrButton);
// Re-Register inputs.
RegisterHotKeys();
};
// Handler for KeyUp (allows setting of special keys, shift, ctrl etc.).
handlerUp = (s, x) =>
{
KeyOrButton keyOrButton = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
// No action for normal keys.
if (x.KeyCode != Keys.ControlKey && x.KeyCode != Keys.ShiftKey && x.KeyCode != Keys.Menu)
{
return;
}
keySetCallback(keyOrButton);
unregisterEvents();
txtBox.Select(0, 0);
chkGlobalHotKeys.Select();
txtBox.Text = FormatKey(keyOrButton);
RegisterHotKeys();
};
leaveHandler = (s, x) =>
{
unregisterEvents();
txtBox.Text = oldText;
};
// Handler for gamepad/joystick inputs.
gamepadButtonPressed = (s, x) =>
{
KeyOrButton key = new KeyOrButton(x);
keySetCallback(key);
unregisterEvents();
Action keyOrButton = () =>
{
txtBox.Select(0, 0);
chkGlobalHotKeys.Select();
txtBox.Text = FormatKey(key);
RegisterHotKeys();
};
// May not be in the UI thread (likely).
if (InvokeRequired)
{
Invoke(keyOrButton);
}
else
{
keyOrButton();
}
};
txtBox.KeyDown += handlerDown;
txtBox.KeyUp += handlerUp;
txtBox.Leave += leaveHandler;
Hook.AnyGamepadButtonPressed += gamepadButtonPressed;
}
private void txtReset_Enter(object sender, EventArgs e)
{
SetHotkeyHandlers((TextBox)sender, x => ResetKey = x);
}
/// <summary>
/// Set the binding to a different key or button.
/// </summary>
/// <param name="keyOrButton">The new key or button.</param>
public void SetBinding(KeyOrButton keyOrButton)
{
KeyOrButton = keyOrButton;
}
public static bool GetHashCodeTest([NotNull] KeyOrButton kob1, KeyOrButton kob2)
{
return(kob1.GetHashCode() == kob2?.GetHashCode());
}
/// <summary>
/// Create a new toggle button.
/// </summary>
/// <param name="keyOrButton">The key or button to target.</param>
/// <param name="input">The input manager providing the input.</param>
public ToggleButton(KeyOrButton keyOrButton, InputManager input) : base(keyOrButton, input)
{
}
public static bool EqualsTest_Object([NotNull] KeyOrButton kob, object obj)
{
return(kob.Equals(obj));
}
private void SetHotkeyHandlers(TextBox txtBox, Action <KeyOrButton> keySetCallback)
{
var oldText = txtBox.Text;
txtBox.Text = "Set Hotkey...";
txtBox.Select(0, 0);
KeyEventHandler handlerDown = null;
KeyEventHandler handlerUp = null;
EventHandler leaveHandler = null;
EventHandlerT <GamepadButton> gamepadButtonPressed = null;
Action unregisterEvents = () =>
{
txtBox.KeyDown -= handlerDown;
txtBox.KeyUp -= handlerUp;
txtBox.Leave -= leaveHandler;
Hook.AnyGamepadButtonPressed -= gamepadButtonPressed;
};
handlerDown = (s, x) =>
{
var key = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
if (x.KeyCode == Keys.ControlKey || x.KeyCode == Keys.ShiftKey || x.KeyCode == Keys.Menu)
{
return;
}
keySetCallback(key);
unregisterEvents();
txtBox.Select(0, 0);
chkGlobalHotkeys.Select();
txtBox.Text = FormatKey(key);
};
handlerUp = (s, x) =>
{
var key = x.KeyCode == Keys.Escape ? null : new KeyOrButton(x.KeyCode | x.Modifiers);
if (x.KeyCode == Keys.ControlKey || x.KeyCode == Keys.ShiftKey || x.KeyCode == Keys.Menu)
{
keySetCallback(key);
unregisterEvents();
txtBox.Select(0, 0);
chkGlobalHotkeys.Select();
txtBox.Text = FormatKey(key);
}
};
leaveHandler = (s, x) =>
{
unregisterEvents();
txtBox.Text = oldText;
};
gamepadButtonPressed = (s, x) =>
{
var key = new KeyOrButton(x);
keySetCallback(key);
unregisterEvents();
Action action = () =>
{
txtBox.Select(0, 0);
chkGlobalHotkeys.Select();
txtBox.Text = FormatKey(key);
};
if (InvokeRequired)
{
Invoke(action);
}
else
{
action();
}
};
txtBox.KeyDown += handlerDown;
txtBox.KeyUp += handlerUp;
txtBox.Leave += leaveHandler;
Hook.AnyGamepadButtonPressed += gamepadButtonPressed;
}
/// <summary>
/// Create a new button.
/// </summary>
/// <param name="keyOrButton">The trigger key.</param>
/// <param name="input">The input manager.</param>
protected Button(KeyOrButton keyOrButton, InputManager input) : base(input)
{
KeyOrButton = keyOrButton;
}
