public KeyControl(KeyRebindControl parent, BoundKeyFunction function) { Function = function; var name = new Label { Text = Loc.GetString( $"ui-options-function-{CaseConversion.PascalToKebab(function.FunctionName)}"), HorizontalExpand = true, HorizontalAlignment = HAlignment.Left }; BindButton1 = new BindButton(parent, this, StyleBase.ButtonOpenRight); BindButton2 = new BindButton(parent, this, StyleBase.ButtonOpenLeft); ResetButton = new Button { Text = Loc.GetString("ui-options-bind-reset"), StyleClasses = { StyleBase.ButtonCaution } }; var hBox = new BoxContainer { Orientation = LayoutOrientation.Horizontal, Children = { new Control { MinSize = (5, 0) },
/// <summary> /// Inserts an Input Command into the simulation. /// </summary> /// <param name="session">Player session that raised the command. On client, this is always the LocalPlayer session.</param> /// <param name="function">Function that is being changed.</param> /// <param name="message">Arguments for this event.</param> /// <param name="replay">if true, current cmd state will not be checked or updated - use this for "replaying" an /// old input that was saved or buffered until further processing could be done</param> public bool HandleInputCommand(ICommonSession session, BoundKeyFunction function, FullInputCmdMessage message, bool replay = false) { #if DEBUG var funcId = _inputManager.NetworkBindMap.KeyFunctionID(function); DebugTools.Assert(funcId == message.InputFunctionId, "Function ID in message does not match function."); #endif if (!replay) { // set state, state change is updated regardless if it is locally bound if (_cmdStates.GetState(function) == message.State) { return(false); } _cmdStates.SetState(function, message.State); } // handle local binds before sending off foreach (var handler in BindRegistry.GetHandlers(function)) { // local handlers can block sending over the network. if (handler.HandleCmdMessage(session, message)) { return(true); } } // send it off to the server DispatchInputCommand(message); return(false); }
public GUIBoundKeyEventArgs(BoundKeyFunction function, BoundKeyState state, ScreenCoordinates pointerLocation, bool canFocus, Vector2 relativePosition, Vector2 relativePixelPosition) : base(function, state, pointerLocation, canFocus) { RelativePosition = relativePosition; RelativePixelPosition = relativePixelPosition; }
public void ThrowsError_WhenCircularDependency() { var registry = new CommandBindRegistry(); var bkf = new BoundKeyFunction("test"); var aHandler1 = new TestInputCmdHandler(); var aHandler2 = new TestInputCmdHandler(); var bHandler1 = new TestInputCmdHandler(); var bHandler2 = new TestInputCmdHandler(); var cHandler1 = new TestInputCmdHandler(); var cHandler2 = new TestInputCmdHandler(); CommandBinds.Builder .Bind(bkf, aHandler1) .BindAfter(bkf, aHandler2, typeof(TypeB), typeof(TypeC)) .Register <TypeA>(registry); CommandBinds.Builder .Bind(bkf, bHandler1) .Bind(bkf, bHandler2) .Register <TypeB>(registry); CommandBinds.Builder .Bind(bkf, cHandler1) .BindAfter(bkf, cHandler2, typeof(TypeA)) .Register <TypeC>(registry); Assert.Throws <InvalidOperationException>(registry.RebuildGraph); }
/// <inheritdoc /> public IKeyBinding GetKeyBinding(BoundKeyFunction function) { if (TryGetKeyBinding(function, out var binding)) { return(binding); } throw new KeyNotFoundException($"No keys are bound for function '{function}'"); }
/// <inheritdoc /> public IEnumerable <InputCmdHandler> GetHandlers(BoundKeyFunction function) { if (_bindingsForKey.TryGetValue(function, out var handlers)) { return(handlers); } return(Enumerable.Empty <InputCmdHandler>()); }
/// <summary> /// A binding of a handler to the indicated key function, with the indicated dependencies. /// </summary> /// <param name="boundKeyFunction">key function this handler should handle</param> /// <param name="handler">handler to handle the input</param> /// <param name="before">If other types register bindings for this key function, this handler will always fire /// before them if they appear in this list.</param> /// <param name="after">If other types register bindings for this key function, this handler will always fire /// after them if they appear in this list.</param> public CommandBind(BoundKeyFunction boundKeyFunction, InputCmdHandler handler, IEnumerable <Type>?before = null, IEnumerable <Type>?after = null) { _boundKeyFunction = boundKeyFunction; _after = after ?? Enumerable.Empty <Type>(); _before = before ?? Enumerable.Empty <Type>(); _handler = handler; }
public void ResolvesHandlers_WhenNoDependencies(int handlersPerType, int numFunctions) { var registry = new CommandBindRegistry(); var allHandlers = new Dictionary <BoundKeyFunction, List <InputCmdHandler> >(); for (int i = 0; i < numFunctions; i++) { var bkf = new BoundKeyFunction(i.ToString()); var theseHandlers = new List <InputCmdHandler>(); allHandlers[bkf] = theseHandlers; var aHandlers = new List <InputCmdHandler>(); var bHandlers = new List <InputCmdHandler>(); var cHandlers = new List <InputCmdHandler>(); for (int j = 0; j < handlersPerType; j++) { aHandlers.Add(new TestInputCmdHandler(typeof(TypeA))); bHandlers.Add(new TestInputCmdHandler(typeof(TypeB))); cHandlers.Add(new TestInputCmdHandler(typeof(TypeC))); } theseHandlers.AddRange(aHandlers); theseHandlers.AddRange(bHandlers); theseHandlers.AddRange(cHandlers); CommandBinds.Builder .Bind(bkf, aHandlers) .Register <TypeA>(registry); CommandBinds.Builder .Bind(bkf, bHandlers) .Register <TypeB>(registry); CommandBinds.Builder .Bind(bkf, cHandlers) .Register <TypeC>(registry); } //order doesn't matter, just verify that all handlers are returned foreach (var bkfToExpectedHandlers in allHandlers) { var bkf = bkfToExpectedHandlers.Key; var expectedHandlers = bkfToExpectedHandlers.Value; HashSet <InputCmdHandler> returnedHandlers = registry.GetHandlers(bkf).ToHashSet(); CollectionAssert.AreEqual(returnedHandlers, expectedHandlers); } // type b stuff should no longer fire CommandBinds.Unregister <TypeB>(registry); foreach (var bkfToExpectedHandlers in allHandlers) { var bkf = bkfToExpectedHandlers.Key; var expectedHandlers = bkfToExpectedHandlers.Value; expectedHandlers.RemoveAll(handler => ((TestInputCmdHandler)handler).ForType == typeof(TypeB)); HashSet <InputCmdHandler> returnedHandlers = registry.GetHandlers(bkf).ToHashSet(); CollectionAssert.AreEqual(returnedHandlers, expectedHandlers); } }
/// <inheritdoc /> public InputCmdHandler GetInputCommand(BoundKeyFunction function) { if (_commands.TryGetValue(function, out var val)) { return(val); } return(null); }
/// <summary> /// Bind the indicated handlers to the indicated function, with no /// particular dependency on bindings from other owner types. /// /// If multiple /// handlers in this builder are registered to the same key function, /// the handlers will fire in the order in which they were added to this builder. /// </summary> public BindingsBuilder Bind(BoundKeyFunction function, IEnumerable <InputCmdHandler> commands) { foreach (var command in commands) { Bind(new CommandBind(function, command)); } return(this); }
public string GetKeyFunctionButtonString(BoundKeyFunction function) { if (!TryGetKeyBinding(function, out var bind)) { return(Loc.GetString("<not bound>")); } return(bind.GetKeyString()); }
public KeyBinding(BoundKeyFunction function, KeyBindingType bindingType, Keyboard.Key baseKey, Keyboard.Key mod1 = Keyboard.Key.Unknown, Keyboard.Key mod2 = Keyboard.Key.Unknown, Keyboard.Key mod3 = Keyboard.Key.Unknown) { Function = function; BindingType = bindingType; PackedKeyCombo = PackKeyCombo(baseKey, mod1, mod2, mod3); }
public string GetKeyFunctionButtonString(BoundKeyFunction function) { IKeyBinding bind; try { bind = GetKeyBinding(function); } catch (KeyNotFoundException) { return(Loc.GetString("<not bound>")); } return(bind.GetKeyString()); }
public KeyBinding(BoundKeyFunction function, KeyBindingType bindingType, Keyboard.Key baseKey, bool canFocus, bool canRepeat, Keyboard.Key mod1 = Keyboard.Key.Unknown, Keyboard.Key mod2 = Keyboard.Key.Unknown, Keyboard.Key mod3 = Keyboard.Key.Unknown) { Function = function; BindingType = bindingType; CanFocus = canFocus; CanRepeat = canRepeat; PackedKeyCombo = PackKeyCombo(baseKey, mod1, mod2, mod3); }
public KeyBinding(InputManager inputManager, BoundKeyFunction function, KeyBindingType bindingType, Key baseKey, bool canFocus, bool canRepeat, int priority, Key mod1 = Key.Unknown, Key mod2 = Key.Unknown, Key mod3 = Key.Unknown) { Function = function; BindingType = bindingType; CanFocus = canFocus; CanRepeat = canRepeat; Priority = priority; _inputManager = inputManager; PackedKeyCombo = new PackedKeyCombo(baseKey, mod1, mod2, mod3); }
/// <summary> /// Inserts an Input Command into the simulation. /// </summary> /// <param name="session">Player session that raised the command. On client, this is always the LocalPlayer session.</param> /// <param name="function">Function that is being changed.</param> /// <param name="message">Arguments for this event.</param> public void HandleInputCommand(ICommonSession session, BoundKeyFunction function, FullInputCmdMessage message) { // set state, state change is updated regardless if it is locally bound _cmdStates.SetState(function, message.State); // handle local binds before sending off if (_bindMap.TryGetHandler(function, out var handler)) { // local handlers can block sending over the network. if (handler.HandleCmdMessage(session, message)) { return; } } RaiseNetworkEvent(message); }
private KeyBindingRegistration CreateMacroBinding(BoundKeyFunction function, string macroName) { macroName = macroName.Replace("SHIFT+", String.Empty); macroName = macroName.Replace("CTRL+", String.Empty); macroName = macroName.Replace("ALT+", String.Empty); macroName = macroName.Replace("+UP", String.Empty); macroName = macroName.Replace("+REP", String.Empty); //TODO: modifiers var key = KeyNameToKey(macroName); if (key == Key.Unknown) { Logger.Warning($"Unknown key: {macroName}"); return(null); } return(new KeyBindingRegistration() { BaseKey = key, Function = function }); }
public KeyControl(KeyRebindControl parent, string niceName, BoundKeyFunction function) { Function = function; var name = new Label { Text = Loc.GetString(niceName), SizeFlagsHorizontal = SizeFlags.Expand }; BindButton1 = new BindButton(parent, this, StyleBase.ButtonOpenRight); BindButton2 = new BindButton(parent, this, StyleBase.ButtonOpenLeft); ResetButton = new Button { Text = "Reset", StyleClasses = { StyleBase.ButtonCaution } }; var hBox = new HBoxContainer { Children = { new Control { CustomMinimumSize = (5, 0) },
/// <summary> /// Inserts an Input Command into the simulation. /// </summary> /// <param name="session">Player session that raised the command. On client, this is always the LocalPlayer session.</param> /// <param name="function">Function that is being changed.</param> /// <param name="message">Arguments for this event.</param> public void HandleInputCommand(ICommonSession session, BoundKeyFunction function, FullInputCmdMessage message) { #if DEBUG var funcId = _inputManager.NetworkBindMap.KeyFunctionID(function); DebugTools.Assert(funcId == message.InputFunctionId, "Function ID in message does not match function."); #endif // set state, state change is updated regardless if it is locally bound _cmdStates.SetState(function, message.State); // handle local binds before sending off if (_bindMap.TryGetHandler(function, out var handler)) { // local handlers can block sending over the network. if (handler.HandleCmdMessage(session, message)) { return; } } RaiseNetworkEvent(message); }
public TopButton(Texture texture, BoundKeyFunction function, IInputManager inputManager) { _function = function; _inputManager = inputManager; TooltipDelay = CustomTooltipDelay; AddChild( new BoxContainer { Orientation = BoxContainer.LayoutOrientation.Vertical, Children = { (_textureRect = new TextureRect { TextureScale = (0.5f, 0.5f), Texture = texture, HorizontalAlignment = HAlignment.Center, VerticalAlignment = VAlignment.Center, VerticalExpand = true, Margin = new Thickness(0, VertPad), ModulateSelfOverride = NormalColor, Stretch = TextureRect.StretchMode.KeepCentered }),
public KeyControl(KeyRebindControl parent, string niceName, BoundKeyFunction function) { Function = function; var name = new Label { Text = Loc.GetString(niceName), HorizontalExpand = true, HorizontalAlignment = HAlignment.Left }; BindButton1 = new BindButton(parent, this, StyleBase.ButtonOpenRight); BindButton2 = new BindButton(parent, this, StyleBase.ButtonOpenLeft); ResetButton = new Button { Text = Loc.GetString("Reset"), StyleClasses = { StyleBase.ButtonCaution } }; var hBox = new HBoxContainer { Children = { new Control { MinSize = (5, 0) },
public void LoadMacroSets(List <MacroSetDescriptor> macroSets) { IInputContextContainer contexts = _inputManager.Contexts; foreach (MacroSetDescriptor macroSet in macroSets) { IInputCmdContext context = contexts.New(InputContextPrefix + macroSet.Name, "common"); foreach (MacroDescriptor macro in macroSet.Macros) { BoundKeyFunction function = new BoundKeyFunction(macro.Id); KeyBindingRegistration binding = CreateMacroBinding(function, macro.Name); if (binding == null) { continue; } context.AddFunction(function); _inputManager.RegisterBinding(in binding); _inputManager.SetInputCommand(function, InputCmdHandler.FromDelegate(_ => OnMacroPress(macro), _ => OnMacroRelease(macro))); } } }
public void ResolvesHandlers_WithDependency(bool before, bool after) { var registry = new CommandBindRegistry(); var bkf = new BoundKeyFunction("test"); var aHandler1 = new TestInputCmdHandler( ); var aHandler2 = new TestInputCmdHandler(); var bHandler1 = new TestInputCmdHandler(); var bHandler2 = new TestInputCmdHandler(); var cHandler1 = new TestInputCmdHandler(); var cHandler2 = new TestInputCmdHandler(); // a handler 2 should run after both b and c handlers for all the below cases if (before && after) { CommandBinds.Builder .Bind(bkf, aHandler1) .BindAfter(bkf, aHandler2, typeof(TypeB), typeof(TypeC)) .Register <TypeA>(registry); CommandBinds.Builder .BindBefore(bkf, bHandler1, typeof(TypeA)) .BindBefore(bkf, bHandler2, typeof(TypeA)) .Register <TypeB>(registry); CommandBinds.Builder .BindBefore(bkf, cHandler1, typeof(TypeA)) .BindBefore(bkf, cHandler2, typeof(TypeA)) .Register <TypeC>(registry); } else if (before) { CommandBinds.Builder .Bind(bkf, aHandler1) .Bind(bkf, aHandler2) .Register <TypeA>(registry); CommandBinds.Builder .BindBefore(bkf, bHandler1, typeof(TypeA)) .BindBefore(bkf, bHandler2, typeof(TypeA)) .Register <TypeB>(registry); CommandBinds.Builder .BindBefore(bkf, cHandler1, typeof(TypeA)) .BindBefore(bkf, cHandler2, typeof(TypeA)) .Register <TypeC>(registry); } else if (after) { CommandBinds.Builder .Bind(bkf, aHandler1) .BindAfter(bkf, aHandler2, typeof(TypeB), typeof(TypeC)) .Register <TypeA>(registry); CommandBinds.Builder .Bind(bkf, bHandler1) .Bind(bkf, bHandler2) .Register <TypeB>(registry); CommandBinds.Builder .Bind(bkf, cHandler1) .Bind(bkf, cHandler2) .Register <TypeC>(registry); } var returnedHandlers = registry.GetHandlers(bkf); // b1 , b2, c1, c2 should be fired before a2 bool foundB1 = false, foundB2 = false, foundC1 = false, foundC2 = false; foreach (var returnedHandler in returnedHandlers) { if (returnedHandler == bHandler1) { foundB1 = true; } else if (returnedHandler == bHandler2) { foundB2 = true; } else if (returnedHandler == cHandler1) { foundC1 = true; } else if (returnedHandler == cHandler2) { foundC2 = true; } else if (returnedHandler == aHandler2) { Assert.True(foundB1 && foundB2 && foundC1 && foundC2, "bind registry didn't respect" + " handler dependency order"); } } var expectedHandlers = new [] { aHandler1, aHandler2, bHandler1, bHandler2, cHandler1, cHandler2 }; var returnedHandlerSet = new HashSet <InputCmdHandler>(returnedHandlers); foreach (var expectedHandler in expectedHandlers) { Assert.True(returnedHandlerSet.Contains(expectedHandler)); } }
public BoundKeyChangedMsg(BoundKeyFunction function, BoundKeyState state) { Directed = true; Function = function; State = state; }
/// <inheritdoc /> public void SetInputCommand(BoundKeyFunction function, InputCommand command) { _commands[function] = command; }
/// <inheritdoc /> public bool TryGetKeyBinding(BoundKeyFunction function, out IKeyBinding binding) { binding = _bindings.FirstOrDefault(k => k.Function == function); return(binding != null); }
/// <inheritdoc /> public void SetInputCommand(BoundKeyFunction function, InputCmdHandler cmdHandler) { _commands[function] = cmdHandler; }
/// <summary> /// Bind the indicated handler to the indicated function, with no /// particular dependency on bindings from other owner types. If multiple /// handlers in this builder are registered to the same key function, /// the handlers will fire in the order in which they were added to this builder. /// </summary> public BindingsBuilder Bind(BoundKeyFunction function, InputCmdHandler command) { return(Bind(new CommandBind(function, command))); }
/// <summary> /// Bind the indicated handler to the indicated function. If other owner types register bindings for this key /// function, this handler will always fire before them if they appear in the "before" list. /// /// If multiple handlers in this builder are registered to the same key function, /// the handlers will fire in the order in which they were added to this builder. /// </summary> /// <param name="before">If other owner types register bindings for this key /// function, this handler will always fire before them if they appear in this list</param> public BindingsBuilder BindBefore(BoundKeyFunction function, InputCmdHandler command, params Type[] before) { return(Bind(new CommandBind(function, command, before))); }
/// <summary> /// Bind the indicated handler to the indicated function. If other owner types register bindings for this key /// function, this handler will always fire after them if they appear in the "after" list. /// /// If multiple handlers in this builder are registered to the same key function, /// the handlers will fire in the order in which they were added to this builder. /// </summary> /// <param name="after">If other owner types register bindings for this key /// function, this handler will always fire after them if they appear in this list</param> public BindingsBuilder BindAfter(BoundKeyFunction function, InputCmdHandler command, params Type[] after) { return(Bind(new CommandBind(function, command, after: after))); }