private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (!IsEnabled)
{
return;
}
if (args.Handled)
{
return;
}
if (this.ShiftKey && (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) != CoreVirtualKeyStates.Down)
{
return;
}
if (this.CtrlKey && (Window.Current.CoreWindow.GetKeyState(VirtualKey.Control) & CoreVirtualKeyStates.Down) != CoreVirtualKeyStates.Down)
{
return;
}
if (this.Key == args.VirtualKey)
{
foreach (var action in Actions)
{
(action as IAction).Execute(this.AssociatedObject, args);
}
args.Handled = true;
}
}
private void Charac_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
if (!isFalling)
{
if (e.VirtualKey == Windows.System.VirtualKey.A || e.VirtualKey == Windows.System.VirtualKey.Left)
{
moveLeft = true;
}
else if (e.VirtualKey == Windows.System.VirtualKey.D || e.VirtualKey == Windows.System.VirtualKey.Right)
{
moveRight = true;
}
if (e.VirtualKey == Windows.System.VirtualKey.W || e.VirtualKey == Windows.System.VirtualKey.Up)
{
Jump();
}
}
else
{
if (e.VirtualKey == Windows.System.VirtualKey.A || e.VirtualKey == Windows.System.VirtualKey.Left)
{
prepLeft = true;
}
else if (e.VirtualKey == Windows.System.VirtualKey.D || e.VirtualKey == Windows.System.VirtualKey.Right)
{
prepRight = true;
}
}
}
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (args.VirtualKey == Windows.System.VirtualKey.F12)
{
args.Handled = true;
var view = ApplicationView.GetForCurrentView();
if (view.IsFullScreenMode)
{
fullscreen = false;
view.ExitFullScreenMode();
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.Auto;
// The SizeChanged event will be raised when the exit from full-screen mode is complete.
}
else
{
if (view.TryEnterFullScreenMode())
{
fullscreen = true;
ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.FullScreen;
// The SizeChanged event will be raised when the entry to full-screen mode is complete.
}
}
}
else
{
Sprite.SendKeyPressed(args);
}
}
private void Page_KeyRouted(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (args.VirtualKey >= Windows.System.VirtualKey.GamepadA && args.VirtualKey <= Windows.System.VirtualKey.GamepadRightThumbstickLeft)
{
args.Handled = true;
}
}
private void HandleKeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (args.VirtualKey == Windows.System.VirtualKey.Right)
{
MqttPublish("turn right");
}
else if (args.VirtualKey == Windows.System.VirtualKey.Left)
{
MqttPublish("turn left");
}
else if (args.VirtualKey == Windows.System.VirtualKey.Up)
{
MqttPublish("move forward");
}
else if (args.VirtualKey == Windows.System.VirtualKey.Down)
{
MqttPublish("move backward");
}
else if (args.VirtualKey == Windows.System.VirtualKey.Escape)
{
MqttPublish("stop");
}
else if (args.VirtualKey == Windows.System.VirtualKey.R)
{
MqttPublish("rotate right");
}
else if (args.VirtualKey == Windows.System.VirtualKey.L)
{
MqttPublish("rotate left");
}
}
//Metoda aktywowana po wcisnieciu klawisza na klawiaturze
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
switch (args.VirtualKey)
{
case Windows.System.VirtualKey.Down:
tetriminos.Last().MoveDown();
break;
case Windows.System.VirtualKey.Left:
tetriminos.Last().MoveLeft();
break;
case Windows.System.VirtualKey.Right:
tetriminos.Last().MoveRight();
break;
case Windows.System.VirtualKey.S:
tetriminos.Last().MoveToGround();
break;
case Windows.System.VirtualKey.A:
tetriminos.Last().Rotate();
break;
}
}
private void CoreWindow_KeyDown(CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (IsInTransitionState)
{
return;
}
if (NavigateUsingKeyboard(args, this, Orientation))
{
return;
}
string gestureKey = MapInputToGestureKey(args.VirtualKey);
if (gestureKey == null)
{
return;
}
if (MenuItemInputGestureCache.ContainsKey(gestureKey))
{
var cachedMenuItem = MenuItemInputGestureCache[gestureKey];
if (cachedMenuItem is MenuFlyoutItem)
{
var menuFlyoutItem = (MenuFlyoutItem)cachedMenuItem;
menuFlyoutItem.Command?.Execute(menuFlyoutItem.CommandParameter);
}
}
}
public void KeyDown(KeyEventArgs arg)
{
if (game.gameState == GameController.GameState.Stopped) return;
switch (arg.VirtualKey)
{
case VirtualKey.A: if (panEnabled) { PanLeft(); } break;
case VirtualKey.D: if (panEnabled) { PanRight(); } break;
case VirtualKey.W: if (panEnabled) { PanForward(); } break;
case VirtualKey.S: if (panEnabled) { PanBackward(); }break;
case VirtualKey.Q: if (panEnabled) { PanDown(); }break;
case VirtualKey.E: if (panEnabled) { PanUp(); }break;
case VirtualKey.I: if (rotateEnabled) { RotateUp(); } break;
case VirtualKey.K: if (rotateEnabled) { RotateDown(); }break;
//case VirtualKey.J: if (rotateEnabled) { RotateLeft(); }break;
//case VirtualKey.L: if (rotateEnabled) { RotateRight(); } break;
case VirtualKey.Z: ZoomIn(); break;
case VirtualKey.X: ZoomOut(); break;
case VirtualKey.O: MoveToOrigin(); break;
case VirtualKey.P: MoveToPlayer(); break;
// Disable pan while following player
case VirtualKey.F: toggleFollowPlayer(); togglePan(); break;
//case VirtualKey.H: toggleRotation(); break;
//case VirtualKey.G: togglePan(); break;
}
}
void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
switch (e.VirtualKey)
{
case Windows.System.VirtualKey.Escape:
case Windows.System.VirtualKey.GamepadB:
//Se cambia de página
if (firstPerson)
{
firstPerson = false;
BetweenPageParameter param = new BetweenPageParameter();
param.Time = seconds;
this.Frame.Navigate(typeof(InGameMap), param);
}
break;
case Windows.System.VirtualKey.Space:
//Daño demostrativo de la barra de vida
UpdateHealth(10);
break;
case Windows.System.VirtualKey.Tab:
//Se expande/se minimiza el mapa
UpdateMap();
break;
default:
break;
}
}
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (OnlyWhenFocus != null && !_NowFocusing_OnlyWhenFocus)
{
return;
}
if (!IsEnabled)
{
return;
}
if (args.Handled)
{
return;
}
if (this.ShiftKey && (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) != CoreVirtualKeyStates.Down)
{
return;
}
if (this.CtrlKey && (Window.Current.CoreWindow.GetKeyState(VirtualKey.Control) & CoreVirtualKeyStates.Down) != CoreVirtualKeyStates.Down)
{
return;
}
if (!IsEnableUINavigationButtons)
{
if (NavigationButtonVirtualKeyList.Any(x => x == args.VirtualKey))
{
return;
}
var keycode = (int)args.VirtualKey;
if (IgnoreVirtualKeyList.Any(x => x == keycode))
{
return;
}
}
if (this.Key == VirtualKey.None || this.Key == args.VirtualKey)
{
foreach (var action in this.Actions.Cast <IAction>())
{
var result = action.Execute(this, args);
if (result is bool)
{
var isExecuted = (bool)result;
if (!isExecuted)
{
return;
}
args.Handled = true;
}
else
{
args.Handled = true;
}
}
}
}
public void OnKeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Enter)
{
this.userGuid = Hasher.GetSmartCardHash(sb.ToString());
Debug.WriteLine(userGuid);
KegLogger.KegLogTrace("User", "UserScan", Microsoft.ApplicationInsights.DataContracts.SeverityLevel.Information, new Dictionary <string, string>()
{
{ "hashcode", this.userGuid }
});
//resetting
sb.Clear();
bool status = CheckKegStatus();
if (!status)
{
//Appropriate messages are handled in above method
this.userGuid = string.Empty;
return;
}
Window.Current.CoreWindow.KeyDown -= OnKeyDown;
//cardDetected = true;
this.Frame.Navigate(typeof(Page2), $"FromMain:{userGuid}");
}
else
{
sb.Append((int)e.VirtualKey - 48);
}
}
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (!_listening && !_gamepadViewDown && args.VirtualKey == Windows.System.VirtualKey.GamepadView)
{
_gamepadViewDown = true;
_keyTimer.Start();
}
}
private void Canvas_KeyUp(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Left)
{
}
else if (e.VirtualKey == Windows.System.VirtualKey.Right)
{
}
}
public static KeyEventArgs ToEto(this wuc.KeyEventArgs e, KeyEventType keyType)
{
var key = KeyMap.Convert(e.Key, swi.Keyboard.Modifiers);
return(new KeyEventArgs(key, keyType)
{
Handled = e.Handled
});
}
private void OnKeyUp(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
var key = MapKey(args.VirtualKey);
// ignore key presses that are not related to the keypad
if (KeyPressed != null && key != KeyPadKey.Unknown)
{
KeyPressed(key);
}
}
private void CoreWindow_KeyUp(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
switch (args.VirtualKey)
{
case VirtualKey.Space:
keys[space] = false;
break;
}
args.Handled = true; // tell the system we handled this event.
}
void CoreWindow_KeyUp(CoreWindow sender, KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Left)
{
playerIsMovingLeft = false;
} else if (e.VirtualKey == Windows.System.VirtualKey.Right)
{
playerIsMovingRight = false;
}
}
#pragma warning disable CC0057 // Unused parameters
public static void OnKeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
#pragma warning restore CC0057 // Unused parameters
{
//var logicalFocus = FocusManager.GetFocusedElement();
//System.Diagnostics.Debug.WriteLine("=========== Windows.UI.Xaml.Input.FocusManager.FocusedElement=" + logicalFocus);
//if (logicalFocus == this)
// System.Diagnostics.Debug.WriteLine(" THIS ");
args.Handled = ProcessVirualKey(HardwareKeyPage.FocusedElement ?? HardwareKeyPage.DefaultFocusedElement, args.VirtualKey);
}
void KeyboardListenerService_KeyUp(CoreWindow sender, KeyEventArgs args)
{
if (!CanListen) return;
for (int i = 0; i < MaxVirtualKeys; i++)
{
if (virtualKeys[i] == args.VirtualKey)
{
virtualKeys[i] = VirtualKey.None;
}
}
}
internal void GlobalKeyDown(CoreWindow sender, KeyEventArgs args)
{
if (args.VirtualKey == Windows.System.VirtualKey.Right)
{
navigateNext();
}
else if (args.VirtualKey == Windows.System.VirtualKey.Left)
{
navigatePrevious();
}
}
private void Canvas_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Right)
{
Si.MoveShipLeft(false);
}
else if (e.VirtualKey == Windows.System.VirtualKey.Left)
{
Si.MoveShipRight(false);
}
}
private void OnKeyUp(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
//private void OnKeyUp(object sender, KeyRoutedEventArgs e)
{
if (haveFocus == false)
{
return;
}
//var virtualKey = e.VirtualKey;
//switch (e.KeyStatus.ScanCode)
//{
// case 44: // W en français, Z en anglais, ..
// virtualKey = VirtualKey.W;
// break;
// case 45: // X en français, ? en anglais, ..
// virtualKey = VirtualKey.X;
// break;
//}
switch (e.VirtualKey)
{
case VirtualKey.Up:
keyboardGamepad.Release(GamepadKeys.Up);
break;
case VirtualKey.Down:
keyboardGamepad.Release(GamepadKeys.Down);
break;
case VirtualKey.Right:
keyboardGamepad.Release(GamepadKeys.Right);
break;
case VirtualKey.Left:
keyboardGamepad.Release(GamepadKeys.Left);
break;
// pour prendre en compte les clavier Qwerty/Azerty/Qwertz
case VirtualKey.Z:
case VirtualKey.W:
case VirtualKey.Y:
keyboardGamepad.Release(GamepadKeys.ButtonA);
break;
case VirtualKey.X:
keyboardGamepad.Release(GamepadKeys.ButtonB);
break;
case VirtualKey.Space:
keyboardGamepad.Release(GamepadKeys.ButtonStart);
break;
}
}
public void OnKeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
var logicalFocus = FocusManager.GetFocusedElement();
System.Diagnostics.Debug.WriteLine("=========== Windows.UI.Xaml.Input.FocusManager.FocusedElement=" + logicalFocus);
if (logicalFocus == this)
{
System.Diagnostics.Debug.WriteLine(" THIS ");
}
args.Handled = ProcessVirualKey(HardwareKeyPage.FocusedElement ?? HardwareKeyPage.DefaultFocusedElement, args.VirtualKey);
}
private void OnKeyDown(CoreWindow sender, KeyEventArgs args)
{
if (args.VirtualKey == VirtualKey.Up)
{
this.isAuto = false;
this.Add();
}
if (args.VirtualKey == VirtualKey.Down)
{
this.isAuto = false;
this.Remove();
}
}
// CoreWindow.KeyDown event handler only used in this page.
private void KeyDownHandle(object send, Windows.UI.Core.KeyEventArgs e)
{
switch (e.VirtualKey)
{
case VirtualKey.Right:
NextImage();
break;
case VirtualKey.Left:
PreviousImage();
break;
}
}
private void TraceKeyEvent(string message, KeyEventArgs e)
{
string item = message +
"| VKey: " + e.VirtualKey.ToString() +
"| Scan code: " + e.KeyStatus.ScanCode.ToString() +
"| Extended key : " + e.KeyStatus.IsExtendedKey.ToString() +
"| Is Key Released : " + e.KeyStatus.IsKeyReleased.ToString() +
"| Is Menu Key Down : " + e.KeyStatus.IsMenuKeyDown.ToString() +
"| Repeat Count : " + e.KeyStatus.RepeatCount.ToString() + //RepeatCount will always return 0
"| Scancode : " + e.KeyStatus.ScanCode.ToString() +
"| WasKeyDown : " + e.KeyStatus.WasKeyDown.ToString(); //WasKeyDown will always return false
Debug.WriteLine(item);
}
private void Grid_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
var ctrl = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control).HasFlag(CoreVirtualKeyStates.Down);
if (ctrl && args.VirtualKey == Windows.System.VirtualKey.Z)
{
List <UIElement> UI = Scripts.action_Memory.Back();
foreach (UIElement i in UI)
{
canvas.Children.Remove(i);
}
}
}
public void KeyDown(KeyEventArgs arg)
{
switch (arg.VirtualKey)
{
case VirtualKey.Number1: switchToGameLevel(1, true); break;
case VirtualKey.Number2: switchToGameLevel(2, true); break;
case VirtualKey.Number3: switchToGameLevel(3, true); break;
case VirtualKey.Number4: switchToGameLevel(4, true); break;
case VirtualKey.Number5: switchToGameLevel(5, true); break;
case VirtualKey.Number6: switchToGameLevel(6, true); break;
case VirtualKey.Number7: switchToGameLevel(7, true); break;
case VirtualKey.R: restartLevel(); break;
}
}
void SearchPageViewModel_KeyDown(CoreWindow sender, KeyEventArgs args)
{
int keyCode = (int)args.VirtualKey;
if (keyCode == 0
|| (keyCode > 0 && keyCode < 32)
|| (keyCode > 33 && keyCode < 47)
|| (keyCode > 91 && keyCode < 165)
|| keyCode == 91 || keyCode > 166)
return; //if the entered key is not a letter/number, ignore it.
string initialchar = Enum.GetName(typeof(Windows.System.VirtualKey), args.VirtualKey);
SetupSearch(initialchar); //Start the search procedure
}
void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs e)
{
if(e.VirtualKey == Windows.System.VirtualKey.Left)
{
playerIsMovingRight = false;
playerIsMovingLeft = true;
} else if(e.VirtualKey == Windows.System.VirtualKey.Right)
{
playerIsMovingLeft = false;
playerIsMovingRight = true;
} else if(e.VirtualKey == Windows.System.VirtualKey.Space)
{
//player.shoot();
}
}
private void CoreWindow_KeyUp(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (!_listening && args.VirtualKey == Windows.System.VirtualKey.Q)
{
if (Window.Current.CoreWindow.GetKeyState(Windows.System.VirtualKey.Control).HasFlag(CoreVirtualKeyStates.Down))
{
WakeUpAndListen();
}
}
if (args.VirtualKey == Windows.System.VirtualKey.GamepadView)
{
_gamepadViewDown = false;
_keyTimer.Stop();
}
}
// Keyboard event
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (args.VirtualKey == Windows.System.VirtualKey.Enter)
{
_manager.Move(_tempPositionY, _tempPositionX, this);
}
else if (args.VirtualKey == Windows.System.VirtualKey.Up)
{
if (_tempPositionY - 1 >= 0)
{
FocusLost();
_tempPositionY--;
CellInFocus();
}
}
else if (args.VirtualKey == Windows.System.VirtualKey.Down)
{
if (_tempPositionY + 1 < 10)
{
FocusLost();
_tempPositionY++;
CellInFocus();
}
}
else if (args.VirtualKey == Windows.System.VirtualKey.Right)
{
if (_tempPositionX + 1 < 10)
{
FocusLost();
_tempPositionX++;
CellInFocus();
}
}
else if (args.VirtualKey == Windows.System.VirtualKey.Left)
{
if (_tempPositionX - 1 >= 0)
{
FocusLost();
_tempPositionX--;
CellInFocus();
}
}
}
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender,
Windows.UI.Core.KeyEventArgs args)
{
switch (args.VirtualKey)
{
case VirtualKey.Up:
keys[up] = true;
keys[down] = false;
keys[left] = false;
keys[right] = false;
keys[space] = false;
break;
case VirtualKey.Down:
keys[up] = false;
keys[down] = true;
keys[left] = false;
keys[right] = false;
keys[space] = false;
break;
case VirtualKey.Left:
keys[up] = false;
keys[down] = false;
keys[left] = true;
keys[right] = false;
keys[space] = false;
break;
case VirtualKey.Right:
keys[up] = false;
keys[down] = false;
keys[left] = false;
keys[right] = true;
keys[space] = false;
break;
case VirtualKey.Space:
keys[space] = true;
break;
}
args.Handled = true; // tell the system we handled this event.
}
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
if (!IsEnabled)
{
return;
}
if (args.Handled)
{
return;
}
if (this.ShiftKey && (Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) != CoreVirtualKeyStates.Down)
{
return;
}
if (this.CtrlKey && (Window.Current.CoreWindow.GetKeyState(VirtualKey.Control) & CoreVirtualKeyStates.Down) != CoreVirtualKeyStates.Down)
{
return;
}
if (this.Key == args.VirtualKey)
{
foreach (var action in this.Actions.Cast <IAction>())
{
var result = action.Execute(this, args);
if (result is bool)
{
var isExecuted = (bool)result;
if (!isExecuted)
{
return;
}
args.Handled = true;
}
else
{
args.Handled = true;
}
}
}
}
public void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
VirtualKey pressedKey = e.VirtualKey;
if (pressedKey == VirtualKey.Escape || pressedKey == VirtualKey.GamepadB)
{
if (uiController.IsMainMenuShown)
{
uiController.RemoveMainMenu();
}
else if (uiController.IsDialogShown)
{
uiController.RemoveDialog();
}
else if (!uiController.IsMainMenuShown)
{
uiController.ShowMainMenu();
}
}
}
//tapahtuman käsittelijä napin painallukselle
private void CoreWindow_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs args)
{
switch (args.VirtualKey)
{
case VirtualKey.Up:
UpPressed = true;
break;
case VirtualKey.Left:
LeftPressed = true;
break;
case VirtualKey.Right:
RightPressed = true;
break;
default:
break;
}
}
private async void MyPage_KeyDown(CoreWindow sender, KeyEventArgs args)
{
switch (args.VirtualKey)
{
case Windows.System.VirtualKey.W:
{
await drone.Forward();
break;
}
case Windows.System.VirtualKey.S:
{
await drone.Backward();
break;
}
case Windows.System.VirtualKey.A:
{
await drone.Left();
break;
}
case Windows.System.VirtualKey.D:
{
await drone.Right();
break;
}
case Windows.System.VirtualKey.Space:
{
await drone.Up();
break;
}
case Windows.System.VirtualKey.X:
{
await drone.Down();
break;
}
default:
{
break;
}
}
}
private void KeyDownEventHandler(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
Frame frame = Window.Current.Content as Frame;
frame.ContentTransitions = new TransitionCollection();
frame.ContentTransitions.Add(new NavigationThemeTransition());
switch (e.VirtualKey)
{
// switch full screen mode
case Windows.System.VirtualKey.F:
if (Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().IsFullScreenMode)
{
Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().ExitFullScreenMode();
}
else
{
Windows.UI.ViewManagement.ApplicationView.GetForCurrentView().TryEnterFullScreenMode();
}
break;
// change cursor mode
case Windows.System.VirtualKey.B:
AutoHideCursor.SwitchCursorMode();
break;
// go to start page
case Windows.System.VirtualKey.Escape:
// change mode to blank mode
frame.ContentTransitions = new TransitionCollection();
frame.ContentTransitions.Add(new NavigationThemeTransition());
frame.Navigate(typeof(StartPage));
frame.BackStack.Clear();
break;
// for debug!
case Windows.System.VirtualKey.D:
Debug.WriteLine(GetMode());
break;
}
}
internal void GlobalKeyDown(CoreWindow sender, KeyEventArgs args)
{
try
{
if (args.VirtualKey == Windows.System.VirtualKey.Right)
{
NavigateNext();
}
else if (args.VirtualKey == Windows.System.VirtualKey.Left)
{
NavigatePrevious();
}
}
catch (Exception ex)
{
var tc = new Microsoft.ApplicationInsights.TelemetryClient();
var properties = new Dictionary<String, string> { { "Module", "Navigation" } };
tc.TrackException(ex, properties);
System.Diagnostics.Debugger.Break();
}
}
private void Charac_KeyUp(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.A || e.VirtualKey == Windows.System.VirtualKey.Left)
{
moveLeft = false;
IsWalking = false;
if (isFalling)
{
prepLeft = false;
}
}
else if (e.VirtualKey == Windows.System.VirtualKey.D || e.VirtualKey == Windows.System.VirtualKey.Right)
{
moveRight = false;
IsWalking = false;
if (isFalling)
{
prepRight = false;
}
}
}
private void Canvas_KeyDown(Windows.UI.Core.CoreWindow sender, Windows.UI.Core.KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Left || e.VirtualKey == Windows.System.VirtualKey.GamepadDPadLeft)
{
Frogger.frogger.FroggerLeft();
playSound();
}
else if (e.VirtualKey == Windows.System.VirtualKey.Right || e.VirtualKey == Windows.System.VirtualKey.GamepadDPadRight)
{
Frogger.frogger.FroggerRight();
playSound();
}
else if (e.VirtualKey == Windows.System.VirtualKey.Up || e.VirtualKey == Windows.System.VirtualKey.GamepadDPadUp)
{
Frogger.frogger.FroggerUp();
playSound();
}
else if (e.VirtualKey == Windows.System.VirtualKey.Down || e.VirtualKey == Windows.System.VirtualKey.GamepadDPadDown)
{
Frogger.frogger.FroggerDown();
playSound();
}
else if (e.VirtualKey == Windows.System.VirtualKey.U)
{
Frogger.car_row_10.EnableCheats();
}
else if (e.VirtualKey == Windows.System.VirtualKey.I)
{
Frogger.car_row_9.EnableCheats();
}
else if (e.VirtualKey == Windows.System.VirtualKey.O)
{
Frogger.car_row_8.EnableCheats();
}
else if (e.VirtualKey == Windows.System.VirtualKey.P)
{
Frogger.car_row_7.EnableCheats();
}
}
private void RootFrame_KeyDown( CoreWindow sender, KeyEventArgs e )
{
KeyDown?.Invoke( sender, e );
HoldingKeys[ e.VirtualKey ] = true;
List<VirtualKey> Keys = new List<VirtualKey>();
foreach( KeyValuePair<VirtualKey, bool> Key in HoldingKeys )
{
if ( Key.Key == VirtualKey.Menu ) continue;
if ( Key.Value ) Keys.Add( Key.Key );
}
string KeyCombo = GetComboHash( Keys );
#if DEBUG
Logger.Log( ID, "Key: " + e.VirtualKey.ToString(), LogType.DEBUG );
#endif
if ( RegisteredCombinations.ContainsKey( KeyCombo ) )
{
ResetSequence();
}
else if( TrySelectSequence( e.VirtualKey, out Keys ) )
{
KeyCombo = GetSeqHash( Keys );
ResetSequence();
}
else
{
return;
}
KeyCombinationEventArgs d = new KeyCombinationEventArgs( Keys.ToArray() );
foreach( Action<KeyCombinationEventArgs> P in RegisteredCombinations[ KeyCombo ] )
{
P( d );
if ( d.Handled ) break;
}
}
private void OnKeyDown(object sender, KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Up)
{
ScrollMap(new Vector2(0.0f, -1.0f));
}
else if (e.VirtualKey == Windows.System.VirtualKey.Down)
{
ScrollMap(new Vector2(0.0f, +1.0f));
}
else if (e.VirtualKey == Windows.System.VirtualKey.Left)
{
ScrollMap(new Vector2(-1.0f, 0.0f));
}
else if (e.VirtualKey == Windows.System.VirtualKey.Right)
{
ScrollMap(new Vector2(+1.0f, 0.0f));
}
MapCanvas.Invalidate();
e.Handled = true;
}
private void KeyDown_UIThread(CoreWindow sender, KeyEventArgs args)
{
// This event runs on the UI thread. If we want to process data structures that are
// accessed on the game loop thread then we need to use some kind of thread
// synchronization to ensure that the UI thread and game loop thread are not accessing
// the same data at the same time.
//
// The two main options here would be to use locks / critical sections or to use
// RunOnGameLoopThreadAsync to cause code to execute on the game loop thread. This
// example uses RunOnGameLoopThreadAsync.
//
// Since KeyEventArgs is not agile we cannot simply pass args to the game loop thread.
// Although doing this may appear to work, it may have some surprising behavior. For
// example, calling a method on args may result in the method executing on the UI
// thread (and so blocking the game loop thread). There will also be surprising races
// about which thread gets to set Handled first.
//
// Instead, we do as much processing as possible on the UI thread before passing
// control to the game loop thread.
if (!InputManager.IsRelevantKey(args.VirtualKey))
{
// It wasn't a relevant key that was pressed, so we don't handle this event
return;
}
// Mark that we've handled this event. It is important to do this synchronously inside
// this event handler since the framework uses the Handled flag to determine whether or
// not to send this event to other handlers.
args.Handled = true;
// Now schedule code to run on the game loop thread to handle the pressed key. The
// animated control will execute this before the next Update.
VirtualKey key = args.VirtualKey;
var action = this.canvas.RunOnGameLoopThreadAsync(
() => this.world.InputManager.KeyDown(key));
}
void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs e)
{
if (e.VirtualKey == Windows.System.VirtualKey.Left)
{
playerIsMovingRight = false;
playerIsMovingLeft = true;
}
else if (e.VirtualKey == Windows.System.VirtualKey.Right)
{
playerIsMovingLeft = false;
playerIsMovingRight = true;
}
else if (e.VirtualKey == Windows.System.VirtualKey.Up)
{
if (!playerBullet.getBulletState() && !canvas.Children.Contains(playerBullet.bullet))
{
canvas.Children.Add(playerBullet.getBullet());
Debug.WriteLine(playerBullet.getBullet().Width);
playerBullet.shoot((Canvas.GetLeft(player.getPlayer())) + ((player.getPlayer().Width / 2) - 2), Canvas.GetTop(player.getPlayer()));
playerBullet.setBulletState(true);
}
}
}
async void KeyboardListenerService_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!CanListen) return;
// Guidelines:
// If first VirtualKey is Ctrl, Alt, or Shift, then we're waiting for another key
var i = 0;
while (i < MaxVirtualKeys && virtualKeys[i] != VirtualKey.None)
{
i++;
}
if (i == MaxVirtualKeys)
virtualKeys = new VirtualKey[3];
else
virtualKeys[i] = args.VirtualKey;
switch (args.VirtualKey)
{
case VirtualKey.Control:
Debug.WriteLine("Ctrl key was pressed, waiting another key ...");
break;
case VirtualKey.Shift:
Debug.WriteLine("Shift key was pressed, waiting another key ...");
break;
default:
Debug.WriteLine("OneShot key was pressed");
// look in the db for a match
var action = await Locator.SettingsVM.KeyboardActionDatabase.GetKeyboardAction(virtualKeys[0], virtualKeys[1]);
if (action != null)
{
// if there's a match, get the ActionId
await DoKeyboardAction(action);
}
break;
}
}
void MyPage_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (args.VirtualKey == VirtualKey.Escape ||
args.VirtualKey == VirtualKey.GoBack)
Messenger.Default.Send(MessengerMessage.GoBack);
}
private void OnKeyPressed(CoreWindow sender, KeyEventArgs args)
{
//
// TODO: Bluetooth keyboards are supported by HoloLens. You can use this method for
// keyboard input if you want to support it as an optional input method for
// your holographic app.
//
}
private static void OnKeyDown(CoreWindow sender, KeyEventArgs args)
{
_keyDown.OnNext(new KeyDownEvent(args.VirtualKey, args.KeyStatus));
}
public virtual void KeyDown(KeyEventArgs arg)
{
}
//----------------------------------------------------------------------
private void HandleKeyDown( CoreWindow sender, KeyEventArgs e )
{
if( e.VirtualKey == Windows.System.VirtualKey.Back ||
e.VirtualKey == Windows.System.VirtualKey.GoBack )
{
bool theHandle = e.Handled;
BackRequested( ref theHandle );
e.Handled = theHandle;
}
else if( e.VirtualKey == Windows.System.VirtualKey.Escape )
{
var theCurrentView = ApplicationView.GetForCurrentView();
if( theCurrentView.IsFullScreenMode )
{
theCurrentView.ExitFullScreenMode();
}
}
}
private void RootFrame_KeyUp( CoreWindow sender, KeyEventArgs e )
{
HoldingKeys[ e.VirtualKey ] = false;
}
private void KeyUp_UIThread(CoreWindow sender, KeyEventArgs args)
{
if (!InputManager.IsRelevantKey(args.VirtualKey))
{
return;
}
args.Handled = true;
VirtualKey key = args.VirtualKey;
var action = this.canvas.RunOnGameLoopThreadAsync(
() => this.world.InputManager.KeyUp(key));
}
// Testing, will map to tablet sensors later
public override void KeyUp(KeyEventArgs arg)
{
switch (arg.VirtualKey)
{
case VirtualKey.Left: accX = 0; break;
case VirtualKey.Right: accX = 0; break;
case VirtualKey.Up: accY = 0; break;
case VirtualKey.Down: accY = 0; break;
case VirtualKey.Space: isShooting = false; break;
}
}
// Testing, will map to tablet sensors later
public override void KeyDown(KeyEventArgs arg)
{
switch (arg.VirtualKey)
{
case VirtualKey.Left: accX = -acceleration; break;// hasTargetX = false; hasTargetY = false; break;
case VirtualKey.Right: accX = acceleration; break;// hasTargetX = false; hasTargetY = false; break;
case VirtualKey.Up: accY = acceleration; break;// hasTargetX = false; hasTargetY = false; break;
case VirtualKey.Down: accY = -acceleration; break;// hasTargetX = false; hasTargetY = false; break;
case VirtualKey.Space: isShooting = true; break;
}
}
public virtual void KeyUp(KeyEventArgs arg)
{
}
private void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
Object a = new Object();
RoutedEventArgs b = new RoutedEventArgs();
switch (args.VirtualKey)
{
case Windows.System.VirtualKey.Delete:
if (btn_delete.IsEnabled == true)
{
btn_delete_Click(a, b);
}
break;
}
}
private void OnInterceptorKeyUp(KeyboardDeliveryInterceptor sender, KeyEventArgs e)
{
TraceKeyEvent("Interceptor-KeyUp", e);
}
private void OnKeyUp(CoreWindow window, KeyEventArgs args)
{
//throw new NotImplementedException();
}
private void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (AcceptUserInputTimer.IsEnabled == false)
{
this.Frame.Navigate(typeof(MainPage));
}
}
