public void KeyReleased(object sender, KeyboardEventArgs e)
{
switch (e.key_)
{
case Keys.W:
if (keys[0])
dir_dirty = true;
keys[0] = false;
break;
case Keys.A:
if (keys[0])
dir_dirty = true;
keys[1] = false;
break;
case Keys.S:
if (keys[0])
dir_dirty = true;
keys[2] = false;
break;
case Keys.D:
if (keys[0])
dir_dirty = true;
keys[3] = false;
break;
}
}
public override void KeyboardDown(KeyboardEventArgs args)
{
if (args.Key == Key.DownArrow
|| args.Key == Key.UpArrow) {
listbox.KeyboardDown (args);
}
else
base.KeyboardDown (args);
}
public override void KeyboardDown(KeyboardEventArgs args)
{
if (args.Key == Key.Escape
|| args.Key == Key.Return
|| args.Key == Key.Space) {
player.Stop ();
PlayerFinished ();
}
}
public void CustomKeyButton_KeyPressedEvent(object sender, CustomKeyButton.KeyPressedEventArgs e)
{
CustomKeyButton.CustomKeyButton ckb = (CustomKeyButton.CustomKeyButton)sender;
switch (e.KeyboardKeyPressed)
{
case "CLR":
SendKeys.Send("{BACKSPACE}");
break;
default:
SendKeys.Send(e.KeyboardKeyPressed);
break;
}
//Raise Key Pressed Event
KeyboardEventArgs dea = new KeyboardEventArgs(e.KeyboardKeyPressed);
OnUserKeyPressed(dea);
}
public void KeyboardDown(KeyboardEventArgs args)
{
bool changed = false;
/* navigation keys */
if (args.Key == Key.LeftArrow) {
if (cursor > 0) cursor--;
}
else if (args.Key == Key.RightArrow) {
if (cursor < value.Length) cursor++;
}
else if (args.Key == Key.Home) {
cursor = 0;
}
else if (args.Key == Key.End) {
cursor = value.Length;
}
/* keys that modify the text */
else if (args.Key == Key.Backspace) {
if (value.Length > 0) {
value = value.Remove (cursor-1, 1);
cursor--;
changed = true;
}
}
else {
char[] cs = Encoding.ASCII.GetChars (new byte[] {(byte)args.Key});
foreach (char c in cs) {
if (!Char.IsLetterOrDigit (c) && c != ' ')
continue;
char cc;
if ((args.Mod & (ModifierKeys.RightShift | ModifierKeys.LeftShift)) != 0)
cc = Char.ToUpper (c);
else
cc = c;
value.Insert (cursor++, cc);
changed = true;
}
changed = true;
}
if (changed)
Text = Value;
}
private void MainWindow_OnKeyDown(object sender, KeyboardEventArgs e)
{
if (Keyboard.IsKeyDown(Key.W))
{
_leftPad.YPosition -= PadSpeed;
}
if (Keyboard.IsKeyDown(Key.S))
{
_leftPad.YPosition += PadSpeed;
}
if (Keyboard.IsKeyDown(Key.Up))
{
_rightPad.YPosition -= PadSpeed;
}
if (Keyboard.IsKeyDown(Key.Down))
{
_rightPad.YPosition += PadSpeed;
}
}
public bool OnKeyDown(KeyboardEventArgs args)
{
if (_isAIRace || args.Key == Key.Escape)
{
// TODO: need to have resume callback from menu
//if (_raceStartSequence > 0 && _bannerTween != null)
// _bannerTween.Pause();
if (_isAIRace)
{
LF.Menu.ShowMenu(MenuClass.eMenuMain, false);
}
else
{
LF.Menu.ShowMenu(MenuClass.eMenuMainInGame, true);
}
return(true);
}
return(false);
}
protected async Task OnKeyUpAsync(KeyboardEventArgs args)
{
if (!EqualityComparer <TValue> .Default.Equals(CurrentValue, _inputValue))
{
if (!_compositionInputting)
{
CurrentValue = _inputValue;
if (OnChange.HasDelegate)
{
await OnChange.InvokeAsync(Value);
}
}
}
if (OnkeyUp.HasDelegate)
{
await OnkeyUp.InvokeAsync(args);
}
}
/// <summary>
/// Method is called via EventCallBack if the keyboard key is no longer pressed inside the Input element.
/// </summary>
/// <param name="e">Contains the key (combination) which was pressed inside the Input element</param>
/// <param name="index">Refers to picker index - 0 for starting date, 1 for ending date</param>
protected async Task OnKeyUp(KeyboardEventArgs e, int index)
{
if (e == null)
{
throw new ArgumentNullException(nameof(e));
}
var key = e.Key.ToUpperInvariant();
if (key == "ENTER")
{
var input = (index == 0 ? _inputStart : _inputEnd);
if (string.IsNullOrWhiteSpace(input.Value))
{
ClearValue(index);
}
else
{
if (BindConverter.TryConvertTo(input.Value, CultureInfo, out DateTime changeValue))
{
var array = Value as Array;
array.SetValue(changeValue, index);
}
if (index == 0)
{
await Blur(0);
await Focus(1);
}
else
{
Close();
}
}
}
if (key == "ARROWDOWN" && !_dropDown.IsOverlayShow())
{
await _dropDown.Show();
}
if (key == "ARROWUP" && _dropDown.IsOverlayShow())
{
Close();
}
}
private void MainWindow_OnKeyDown(object sender, KeyboardEventArgs e)
{
if (Keyboard.IsKeyDown(Key.A))
{
playerTank.XPosition -= tankSpeed;
}
if (Keyboard.IsKeyDown(Key.D))
{
playerTank.XPosition += tankSpeed;
}
if (Keyboard.IsKeyDown(Key.W))
{
if (gameParams.reload >= barsLength && playerTank.shootFired == false)
{
gameParams.reload = 0;
playerTank.shootFired = true;
}
}
}
private bool CheckShift56(KeyboardEventArgs args)
{
if (!_shift5 && args.Modifier == KeyModifier.Shift && args.KeyChar == '5')
{
_shift5 = true;
return(true);
}
else if (_shift5 && args.Modifier == KeyModifier.Shift && args.KeyChar == '6')
{
_shift5 = false;
Settings.RevealWorldCheat();
return(true);
}
else if (_shift5)
{
_shift5 = false;
}
return(false);
}
private void MainWindowOnKeyDown(object sender, KeyboardEventArgs e) //handles the controls that result in corresponding method calls.
{
if (Keyboard.IsKeyDown(Key.W))
{
view.LeftPadPosition = VerifyBounds(view.LeftPadPosition, -PadSpeed); //player 1 controls.
}
if (Keyboard.IsKeyDown(Key.S))
{
view.LeftPadPosition = VerifyBounds(view.LeftPadPosition, PadSpeed); //W moves paddle up. S moves paddle down.
}
if (Keyboard.IsKeyDown(Key.Up))
{
view.RightPadPosition = VerifyBounds(view.RightPadPosition, -PadSpeed); //player 2 controls.
}
if (Keyboard.IsKeyDown(Key.Down))
{
view.RightPadPosition = VerifyBounds(view.RightPadPosition, PadSpeed); //Up arrow moves paddle up. Down arrow moves down.
}
}
public override bool doEvent(object caller, KeyboardEventArgs e)
{
if (!e.Down)
{
return(true);
}
if (e.Key == Key.Return || e.Key == Key.Space)
{
boxChecked = !boxChecked;
if (callbackHandler != null)
{
callbackHandler(boxChecked);
}
}
return(true);
}
protected override async Task HandleKeyUpAsync(KeyboardEventArgs args)
{
await base.HandleKeyUpAsync(args);
var key = args.Key;
if (key == " " || key == "Enter")
{
await HandleClickAsync(args);
}
else if (Deletable && (key == "Backspace" || key == "Delete"))
{
await OnDelete.InvokeAsync(args);
}
else if (key == "Escape")
{
await DomHelpers.BlurAsync(RootRef.Current);
}
}
// Should the input be more changable?
protected override void OnKeyDown(KeyboardEventArgs e)
{
switch (Orientation)
{
case Controls.Orientation.Vertical:
{
if (e.Key == Microsoft.Xna.Framework.Input.Keys.Down)
{
if (SelectedIndex < (Children.Count - 1))
{
SelectedIndex++;
}
}
else if (e.Key == Microsoft.Xna.Framework.Input.Keys.Up)
{
if (SelectedIndex > 0)
{
SelectedIndex--;
}
}
break;
}
case Controls.Orientation.Horizontal:
{
if (e.Key == Microsoft.Xna.Framework.Input.Keys.Right)
{
if (SelectedIndex < (Children.Count - 1))
{
SelectedIndex++;
}
}
else if (e.Key == Microsoft.Xna.Framework.Input.Keys.Left)
{
if (SelectedIndex > 0)
{
SelectedIndex--;
}
}
break;
}
}
}
public override void HandleKeyReleasedEvent(object sender, KeyboardEventArgs e)
{
base.HandleKeyReleasedEvent(sender, e);
var keyReleased = e.KeyInformation.VirtualKey;
if (keyReleased == SharpDL.Input.VirtualKeyCode.ArrowLeft)
{
isArrowLeftDown = false;
}
if (keyReleased == SharpDL.Input.VirtualKeyCode.ArrowRight)
{
isArrowRightDown = false;
}
if (keyReleased == SharpDL.Input.VirtualKeyCode.Space)
{
isSpacebarDown = false;
}
}
public void SpinButtonArrowDownKeyDownTest(double defaultValue, double step, double min)
{
var component = RenderComponent <BitSpinButton>(parameters =>
{
parameters.Add(p => p.Step, step);
parameters.Add(p => p.Min, min);
parameters.Add(p => p.DefaultValue, defaultValue);
});
var input = component.Find("input");
var args = new KeyboardEventArgs();
args.Key = "ArrowDown";
input.KeyDown(args);
var inputValue = input.GetAttribute("value");
var expectedResult = defaultValue - step >= min ? defaultValue - step : defaultValue;
Assert.AreEqual(expectedResult.ToString(), inputValue);
}
protected void OnKeyUp(KeyboardEventArgs args)
{
var currentKey = KeyHelper.GetKeyFromString(args.Key);
Console.WriteLine(currentKey.ToString());
if (currentKey == Key.Up)
{
SelectPrevResult();
}
else if (currentKey == Key.Down)
{
SelectNextResult();
}
else if (currentKey == Key.Enter)
{
HandleDblClick(this.CurrentItem);
}
}
/// <summary>Repeatedly called with a period defined by WorkerInterval. Used to poll the device for data and raise any desired events.</summary>
/// <param name="sender">Always null.</param>
protected override void CheckEvents(object sender)
{
if (!this.CheckObjectState(false))
{
return;
}
byte key = 0, keyState = 0;
var ascii = '\0';
try {
if (!this.NativeGetState(out key, out ascii, out keyState))
{
return;
}
}
catch {
}
var args = new KeyboardEventArgs()
{
ASCII = ascii, Which = (Key)key
};
if ((KeyState)keyState == KeyState.Pressed)
{
this.OnKeyDown(args);
if (args.ASCII != 0)
{
this.OnCharDown(args);
}
}
else if ((KeyState)keyState == KeyState.Released)
{
this.OnKeyUp(args);
if (args.ASCII != 0)
{
this.OnCharUp(args);
}
}
}
/// <summary>
/// Overrides KeyDown event, intercepts Arrow Up/Down and uses them to add/substract the value manually by the step value.
/// Relying on the browser mean the steps are each integer multiple from <see cref="Min"/> up until <see cref="Max"/>.
/// This align the behaviour with the spinner buttons.
/// </summary>
/// <remarks>https://try.mudblazor.com/snippet/QamlkdvmBtrsuEtb</remarks>
protected async Task InterceptArrowKey(KeyboardEventArgs obj)
{
if (Disabled || ReadOnly)
{
return;
}
if (obj.Type == "keydown")//KeyDown or repeat, blazor never fires InvokeKeyPress
{
if (obj.Key == "ArrowUp")
{
_keyDownPreventDefault = true;
if (RuntimeLocation.IsServerSide)
{
var value = Value;
await Task.Delay(1);
Value = value;
}
await Increment();
return;
}
else if (obj.Key == "ArrowDown")
{
_keyDownPreventDefault = true;
if (RuntimeLocation.IsServerSide)
{
var value = Value;
await Task.Delay(1);
Value = value;
}
await Decrement();
return;
}
}
_keyDownPreventDefault = KeyDownPreventDefault;
OnKeyDown.InvokeAsync(obj).AndForget();
}
private void Events_KeyDown(object sender, KeyboardEventArgs e)
{
switch (e.Key)
{
case Key.Escape:
if (SDLExitEvent != null)
{
SDLExitEvent();
}
Events.QuitApplication();
break;
case Key.LeftArrow:
rotX += 5f;
break;
case Key.RightArrow:
rotX -= 5f;
break;
case Key.UpArrow:
rotY += 5f;
if (rotY >= 30f)
{
rotY = 30f;
}
break;
case Key.DownArrow:
rotY -= 5f;
if (rotY <= -20f)
{
rotY = -20f;
}
break;
case Key.R:
rotX = -45f;
rotY = 10f;
break;
}
}
public static KeyboardEventArgs ProcessWindowsKeyMessage(ref WindowsMessage m)
{
var val = m.LParam.ToInt64();
KeyboardEventArgs e = new KeyboardEventArgs();
e.KeyCode = Keys.None;
if ((m.Msg == WM_KEYDOWN || m.Msg == WM_KEYUP) && ((int)m.WParam == VK_CONTROL || (int)m.WParam == VK_SHIFT))
{
switch ((OemScanCode)(((Int64)m.LParam >> 16) & 0x1FF))
{
case OemScanCode.LControl:
{
e.KeyCode = Keys.LControlKey;
}
break;
case OemScanCode.RControl:
e.KeyCode = Keys.RControlKey;
break;
case OemScanCode.LShift:
e.KeyCode = Keys.LShiftKey;
break;
case OemScanCode.RShift:
e.KeyCode = Keys.RShiftKey;
break;
default:
if ((int)m.WParam == VK_SHIFT)
{
e.KeyCode = Keys.ShiftKey;
}
else if ((int)m.WParam == VK_CONTROL)
{
e.KeyCode = Keys.ControlKey;
}
break;
}
}
return(e);
}
public void Key_Typed(object sender, KeyboardEventArgs args)
{
if (args.Key == Keys.Back)
{
if (text.Length > 0)
{
var left = text.Substring(0, (int)cursor.X);
var right = text.Remove(0, (int)cursor.X);
left = left.Substring(0, left.Length - 1);
text = left + right;
cursor.X--;
}
}
else if (args.Key == Keys.Enter)
{
// handle input
try
{
lua.DoString(text);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
history.Add(text);
text = "";
}
else if (!(args.Key == Keys.OemTilde && args.Modifiers != KeyboardModifiers.Shift) && args.Key != Keys.Tab)
{
if (text.Length > 0)
{
text = text.Insert((int)cursor.X, args.Character?.ToString() ?? "");
}
else
{
text += args.Character?.ToString() ?? "";
}
cursor.X++;
}
}
protected async Task HandleKeydown(KeyboardEventArgs obj)
{
if (Disabled || ReadOnly)
{
return;
}
switch (obj.Key)
{
case "ArrowUp":
await Increment();
break;
case "ArrowDown":
await Decrement();
break;
}
OnKeyDown.InvokeAsync(obj).AndForget();
}
// Set the W and S keyboards to be the ones that contorl the left paddle and Up and Down arrows to control the right paddle
private void MainWindow_OnKeyDown(object sender, KeyboardEventArgs e)
{
if (Keyboard.IsKeyDown(Key.W))
{
myPaddle.P1PadPosition = checkBounds(myPaddle.P1PadPosition, -PadSpeed);
}
if (Keyboard.IsKeyDown(Key.S))
{
myPaddle.P1PadPosition = checkBounds(myPaddle.P1PadPosition, PadSpeed);
}
if (Keyboard.IsKeyDown(Key.Up))
{
myPaddle.P2PadPosition = checkBounds(myPaddle.P2PadPosition, -PadSpeed);
}
if (Keyboard.IsKeyDown(Key.Down))
{
myPaddle.P2PadPosition = checkBounds(myPaddle.P2PadPosition, PadSpeed);
}
}
public void KeyDown(KeyboardEventArgs e)
{
if (!this.Editing)
{
return;
}
if (e.Key.ToLower() == "backspace")
{
this.Value = this.Value.Length <= 0 ? "" : this.Value.Substring(0, this.Value.Length - 1);
return;
}
if (e.Key.ToString().Length > 1)
{
return;
}
this.Value += e.Key.ToString();
}
private async Task OnInputKeyDown(KeyboardEventArgs e)
{
if (e.AltKey == true && e.Code == "KeyO")
{
await Open();
}
else if (e.AltKey == true && e.Code == "KeyX")
{
if (IsDisabled)
{
return;
}
await Clear();
}
else if (e.AltKey == true && e.Code == "KeyA")
{
await OnAddNewClick();
}
}
private void MainWindow_OnKeyDown(object sender, KeyboardEventArgs e)
{
if (Keyboard.IsKeyDown(Key.W))
{
vm.LeftPadPosition = verifyBounds(vm.LeftPadPosition, -padSpeed);
}
if (Keyboard.IsKeyDown(Key.S))
{
vm.LeftPadPosition = verifyBounds(vm.LeftPadPosition, padSpeed);
}
if (Keyboard.IsKeyDown(Key.Up))
{
vm.RightPadPosition = verifyBounds(vm.RightPadPosition, -padSpeed);
}
if (Keyboard.IsKeyDown(Key.Down))
{
vm.RightPadPosition = verifyBounds(vm.RightPadPosition, padSpeed);
}
}
private void Diagram_KeyDown(KeyboardEventArgs e)
{
if (e.AltKey || e.CtrlKey || e.ShiftKey || e.Code != Diagram.Options.DeleteKey)
{
return;
}
Diagram.Batch(() =>
{
foreach (var sm in Diagram.GetSelectedModels().ToList())
{
if (sm.Locked)
{
continue;
}
if (sm is GroupModel group && Diagram.Options.Constraints.ShouldDeleteGroup(group))
{
Diagram.RemoveGroup(group);
}
private void Events_KeyboardUp(object sender, KeyboardEventArgs e)
{
// Check which key was brought up and stop the hero if needed
if (e.Key == Key.LeftArrow && hero.CurrentAnimation == "WalkLeft")
{
hero.Animate = false;
}
else if (e.Key == Key.UpArrow && hero.CurrentAnimation == "WalkUp")
{
hero.Animate = false;
}
else if (e.Key == Key.DownArrow && hero.CurrentAnimation == "WalkDown")
{
hero.Animate = false;
}
else if (e.Key == Key.RightArrow && hero.CurrentAnimation == "WalkRight")
{
hero.Animate = false;
}
}
/// <summary>
/// Overrides KeyDown event, intercepts Arrow Up/Down and uses them to add/substract the value manually by the step value.
/// Relying on the browser mean the steps are each integer multiple from <see cref="Min"/> up until <see cref="Max"/>.
/// This align the behaviour with the spinner buttons.
/// </summary>
/// <remarks>https://try.mudblazor.com/snippet/QamlkdvmBtrsuEtb</remarks>
protected async Task InterceptArrowKey(KeyboardEventArgs obj)
{
if (obj.Type == "keydown")//KeyDown or repeat, blazor never fire InvokeKeyPress
{
if (obj.Key == "ArrowUp")
{
await Increment();
return;
}
else if (obj.Key == "ArrowDown")
{
await Decrement();
return;
}
}
_keyDownPreventDefault = KeyDownPreventDefault;
OnKeyPress.InvokeAsync(obj).AndForget();
}
private void HandleEventKeyboard(SDL_KeyboardEvent keyboardEvent)
{
KeyboardEventArgs args = ConvertKeyEvent(keyboardEvent);
if (args == null)
{
return;
}
switch (keyboardEvent.State)
{
case SDL_KeyState.SDL_PRESSED:
OnKeyDown?.Invoke(this, args);
return;
case SDL_KeyState.SDL_RELEASED:
OnKeyUp?.Invoke(this, args);
return;
}
}
public async Task AddToDo(KeyboardEventArgs e)
{
if (e.Key == "Enter" && !string.IsNullOrWhiteSpace(Description) ||
e.Key == "NumpadEnter" && !string.IsNullOrWhiteSpace(Description))
{
var request = new ToDoStructure()
{
Id = ServerToDoResponse.Count,
Description = this.Description,
IsCompleted = false
};
Description = null;
await UserClient.AddToDoAsync(request);
await GetToDoList();
}
else
{
}
}
private void OnKeyDownHandler(KeyboardEventArgs args)
{
// Console.WriteLine($"KeyboardEventArgs key: {args.Key} code: {args.Code} type: {args.Type} meta: {args.MetaKey} shift: {args.ShiftKey} ctrl: {args.CtrlKey} repeat: {args.Repeat}");
if (args.Code.Contains("Backspace"))
{
lock (inputBufferSync)
{
if (inputBuffer.Any())
{
var items = inputBuffer.ToList();
items.RemoveAt(items.Count - 1);
inputBuffer = new Queue <char>(items);
this.Text = this.Text.Substring(0, this.Text.Length - 1);
this.mustRefreshOutput = true;
}
}
}
}
private void RaiseRepeatEvents(GameTime gameTime, KeyboardState currentState)
{
var elapsedTime = (gameTime.TotalGameTime - _lastPressTime).TotalMilliseconds;
if (currentState.IsKeyDown(_previousKey) &&
(_isInitial && elapsedTime > InitialDelay || !_isInitial && elapsedTime > RepeatDelay))
{
var args = new KeyboardEventArgs(_previousKey, currentState);
KeyPressed?.Invoke(this, args);
if (args.Character.HasValue)
{
KeyTyped?.Invoke(this, args);
}
_lastPressTime = gameTime.TotalGameTime;
_isInitial = false;
}
}
public void SetUp()
{
var kernel32 = MockRepository.GenerateStub<IKernel32>();
HookProc callback = delegate { return 1; };
_user32 = MockRepository.GenerateStub<IUser32>();
_user32.Stub(usr32 => usr32.SetWindowsHook(Arg<int>.Is.Anything, Arg<HookProc>.Is.Anything, Arg<IntPtr>.Is.Anything, Arg<int>.Is.Anything))
.WhenCalled(invocation=>callback = (HookProc)invocation.Arguments[1])
.Return(KEYBOARD_HOOK_HANDLE);
EventHandler<KeyboardEventArgs> keyboardEventHandler = MockRepository.GenerateStub<EventHandler<KeyboardEventArgs>>();
KeyboardEventArgs eventArgs = new KeyboardEventArgs(0, new Dictionary<VirtualKeyCode, KeyState>()) {Handled = false};
keyboardEventHandler.Stub(handler => handler(null, null)).IgnoreArguments().WhenCalled(invocation => invocation.Arguments[1] = eventArgs);
Keyboard keyboard = new Keyboard(_user32, kernel32);
keyboard.KeyUp += keyboardEventHandler;
KeyboardHookStruct keyboardData = new KeyboardHookStruct();
_ptr = Marshal.AllocHGlobal(Marshal.SizeOf(keyboardData));
Marshal.StructureToPtr(keyboardData, _ptr, true);
callback(Constants.HC_ACTION, Constants.WM_KEYUP, _ptr);
}
static void sdl_OnKeyPressedOrReleased(object sender, KeyboardEventArgs e)
{
if (null == e)
{
Console.WriteLine("Key pressed: empty key data!!!!");
}
else
{
Console.WriteLine("Key pressed: code:{0} state:{1} repeat:{2} mod:{3}", e.KeyInfo.Scancode, e.State, e.Repeat, e.KeyInfo.Modifier);
if (e.KeyInfo.Scancode == KeyScancode.A && e.State == KeyState.PRESSED)
{
sample.Play();
}
else if (e.KeyInfo.Scancode == KeyScancode.NumPadPlus && e.State == KeyState.PRESSED)
{
delay++;
}
else if (e.KeyInfo.Scancode == KeyScancode.NumPadMinus && e.State == KeyState.PRESSED)
{
delay--;
}
}
}
void _KeyUp(object source, KeyboardEventArgs e)
{
if (KeyUp != null)
{
KeyUp(source, e);
}
}
private void KeyUp(object sender, KeyboardEventArgs e)
{
KeyHandler.Instance.KeyUp(e.KeyCode);
}
public void HandleKeyboardUp(KeyboardEventArgs args)
{
/* just return if the modifier keys are released */
if (args.Key >= Key.NumLock && args.Key <= Key.Compose)
return;
if (dialog != null)
dialog.HandleKeyboardUp (args);
else
KeyboardUp (args);
}
/// <summary>
/// Triggered when the user releases or presses a key.
/// </summary>
public void Key(KeyboardEventArgs args)
{
}
public virtual void KeyboardUp(KeyboardEventArgs args)
{
}
public virtual void KeyboardDown(KeyboardEventArgs args)
{
if (Elements != null) {
foreach (UIElement e in Elements) {
if ( (args.Key == e.Hotkey)
||
(args.Key == Key.Return
&& (e.Flags & ElementFlags.DefaultButton) == ElementFlags.DefaultButton)
||
(args.Key == Key.Escape
&& (e.Flags & ElementFlags.CancelButton) == ElementFlags.CancelButton)) {
ActivateElement (e);
return;
}
}
}
}
private void KeyboardObject_KeyPress(Object sender, KeyboardEventArgs e) {
//throw new NotImplementedException();
}
void KeyUp( object source, KeyboardEventArgs e )
{
if( (char)e.Key == 'a' )
{
bleftdown = false;
}
if( (char)e.Key == 'd' )
{
brightdown = false;
}
if( (char)e.Key == 'w' )
{
bupdown = false;
}
if( (char)e.Key == 's' )
{
bdowndown = false;
}
}
/// <summary>
/// Triggered when the user releases or presses a key.
/// </summary>
public void Key(KeyboardEventArgs args)
{
// Break out
Game.GameMode = new MainMenuMode();
}
/// <summary>
/// Triggered when the user releases or presses a key.
/// </summary>
public void Key(KeyboardEventArgs args)
{
// We only care about keyboard presses
if (!args.Pressed)
return;
Close();
}
public override void KeyboardUp(KeyboardEventArgs args)
{
}
/// <summary>
/// Handle a keyboard event.
/// </summary>
/// <param name="sender">
/// The sending object.
/// </param>
/// <param name="args">
/// A <see cref="KeyboardEventArgs"/>.
/// </param>
/// <remarks>
/// This method matches the signature required for
/// <see cref="KeyboardEventHandler"/> so that it may be used directly
/// to handle <see cref="IController.KeyboardEvent"/>.
/// </remarks>
public void HandleKeyboard(object sender, KeyboardEventArgs args) {
KeyboardEventHandler handler;
if (this.mKeybindings.TryGetValue(args, out handler))
handler(this, args);
}
public override void KeyboardDown(KeyboardEventArgs args)
{
switch (args.Key) {
case Key.F10:
GameMenuDialog d = new GameMenuDialog (this, mpq);
d.ReturnToGame += delegate () { DismissDialog (); };
ShowDialog (d);
break;
case Key.RightArrow:
horiz_delta = SCROLL_DELTA;
break;
case Key.LeftArrow:
horiz_delta = -SCROLL_DELTA;
break;
case Key.DownArrow:
vert_delta = SCROLL_DELTA;
break;
case Key.UpArrow:
vert_delta = -SCROLL_DELTA;
break;
}
}
protected virtual void OnUserKeyPressed(KeyboardEventArgs e)
{
if (UserKeyPressed != null)
UserKeyPressed(this, e);
}
/// <summary>
/// Triggered when the user releases or presses a key.
/// </summary>
public void Key(KeyboardEventArgs args)
{
// We only care about keyboard presses
if (!args.Pressed)
return;
// Switch the mode
switch (args.Key)
{
case BooGameKeys.Escape:
// Go to the main menu
Game.GameMode = new MainMenuMode();
break;
#if DEBUG
case BooGameKeys.F3:
// Add to the minor mode if we already have one
if (MinorMode != null && MinorMode is ChestOpenedMinorMode)
{
// Just increment it
(MinorMode as ChestOpenedMinorMode).ChestCounter++;
}
else
{
// Open up the new mode
MinorMode = new ChestOpenedMinorMode(1);
}
return;
case BooGameKeys.F4:
// Add a bug into the board
Game.State.Board.AddBugs(1);
return;
case BooGameKeys.F5:
// Give another stage with penalties
MinorMode = new NewStageMinorMode();
return;
case BooGameKeys.F6:
// Creates a test prayer and inserts it into the system.
Prayer prayer = Game.PrayerFactory.CreatePrayer();
prayer.IsAccepted = true;
Game.State.Prayers.Add(prayer);
return;
case BooGameKeys.F7:
Game.State.GrabCount = 3;
return;
case BooGameKeys.F8:
// Finish up a prayer
Prayer p = Game.PrayerFactory.CreatePrayer();
MinorMode = new PrayerCompletedMinorMode(0, 0, p);
return;
case BooGameKeys.F9:
// Finish the game
MinorMode = new EndOfGameMinorMode();
return;
#endif
}
// If we have a minor mode, pass it on
if (minorMode != null)
minorMode.Key(args);
}
void _KeyDown(object source, KeyboardEventArgs e)
{
//if ((char)e.Key == 'q')
//{
// System.Environment.Exit(0);
//}
if( KeyDown != null )
{
KeyDown( source, e );
}
}
public override void KeyboardDown(KeyboardEventArgs args)
{
switch (args.Key)
{
case Key.Escape:
Events.Tick -= FlipPage;
MarkupFinished ();
break;
case Key.Space:
case Key.Return:
totalElapsed = 0;
AdvanceToNextPage ();
break;
}
}
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
e.EventType == CoreAcceleratorKeyEventType.KeyDown))
{
var coreWindow = Windows.UI.Xaml.Window.Current.CoreWindow;
var downState = CoreVirtualKeyStates.Down;
var virtualKey = e.VirtualKey;
bool winKey = ((coreWindow.GetKeyState(VirtualKey.LeftWindows) & downState) == downState || (coreWindow.GetKeyState(VirtualKey.RightWindows) & downState) == downState);
bool altKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
// raise keydown actions
var keyDown = new KeyboardEventArgs
{
AltKey = altKey,
Character = ToChar(virtualKey, shiftKey),
ControlKey = controlKey,
EventArgs = e,
ShiftKey = shiftKey,
VirtualKey = virtualKey
};
try { _KeyDown?.Raise(this, keyDown); }
catch { }
// Handle F5 to refresh content
if (virtualKey == VirtualKey.F5)
{
bool noModifiers = !altKey && !controlKey && !shiftKey;
_RefreshRequest?.Raise(this, keyDown);
}
}
}
public override void KeyboardUp(KeyboardEventArgs args)
{
if (args.Key == Key.RightArrow
|| args.Key == Key.LeftArrow) {
horiz_delta = 0;
}
else if (args.Key == Key.UpArrow
|| args.Key == Key.DownArrow) {
vert_delta = 0;
}
}
/// <summary>
/// Processes key down events, used for triggering things within
/// the game.
/// </summary>
/// <param name="args"></param>
public override void KeyDown(KeyboardEventArgs args)
{
// See if we have one of the universal commands
switch (args.Key)
{
case BooGameKeys.F:
FullScreen = !FullScreen;
break;
default:
// Pass it on to the game mode
if (Game.GameMode != null)
Game.GameMode.Key(args);
break;
}
}
/// <summary>
/// Triggered when the user releases or presses a key.
/// </summary>
public virtual void Key(KeyboardEventArgs args)
{
// No timeout if (countingDown)
if (args.Pressed)
Timeout();
}
private void KeyboardService_KeyDown(object sender, KeyboardEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Left && e.AltKey == true)
{
//TODO: Raise backNavigation();
//App.InvokeOnBackRequested();
BindablePage.CurrentPage.OnBackRequested(null, null);
}
if (e.VirtualKey == Windows.System.VirtualKey.F5)
{
App.Current.InvokeOnRefreshRequested();
}
}
public void keyRelease(object sender, KeyboardEventArgs e)
{
if (e.key_ == Keys.F1)
{
GameEntity entity = Locator.getObjectFactory().createWreck();
entity.spatial.translation_ = new Vector2(1800, 1000);
entity.physic.velocity_ = new Vector2(0, -100);
Locator.getComponentManager().addEntity(entity);
Locator.getMessageBoard().postMessage(new Post(PostCategory.JUNK_SPAWN, entity, null, null, 0));
}
if (e.key_ == Keys.I)
{
if (systems == null)
{
systems = new SystemsWindow();
systems.loc_ = new Vector2((screen_.X - systems.size.X) / 2, (screen_.Y - systems.size.Y) / 2);
}
if (!windows.Contains(systems))
windows.Add(systems);
}
}
