/// <summary>
/// Invoked on every keystroke, including system keys such as Alt key combinations, when
/// this page is active and occupies the entire window. Used to detect keyboard navigation
/// between pages even when the page itself doesn't have focus.
/// </summary>
/// <param name="sender">Instance that triggered the event.</param>
/// <param name="e">Event data describing the conditions that led to the event.</param>
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
VirtualKey virtualKey = e.VirtualKey;
// Only investigate further when Left, Right, or the dedicated Previous or Next keys
// are pressed
if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
e.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right ||
(int)virtualKey == 166 || (int)virtualKey == 167))
{
CoreWindow coreWindow = Window.Current.CoreWindow;
CoreVirtualKeyStates downState = CoreVirtualKeyStates.Down;
bool menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
bool noModifiers = !menuKey && !controlKey && !shiftKey;
bool onlyAlt = menuKey && !controlKey && !shiftKey;
if (((int)virtualKey == 166 && noModifiers) ||
(virtualKey == VirtualKey.Left && onlyAlt))
{
// When the previous key or Alt+Left are pressed navigate back
e.Handled = true;
GoBackCommand.Execute(null);
}
else if (((int)virtualKey == 167 && noModifiers) ||
(virtualKey == VirtualKey.Right && onlyAlt))
{
// When the next key or Alt+Right are pressed navigate forward
e.Handled = true;
GoForwardCommand.Execute(null);
}
}
}
void OnAcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
{
if ((args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
args.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(args.VirtualKey == VirtualKey.C || args.VirtualKey == VirtualKey.V))
{
CoreWindow window = Window.Current.CoreWindow;
CoreVirtualKeyStates down = CoreVirtualKeyStates.Down;
// Only want case where Ctrl is down
if ((window.GetKeyState(VirtualKey.Shift) & down) == down ||
(window.GetKeyState(VirtualKey.Control) & down) != down ||
(window.GetKeyState(VirtualKey.Menu) & down) == down)
{
return;
}
if (args.VirtualKey == VirtualKey.C)
{
OnCopyAppBarButtonClick(null, null);
}
else if (args.VirtualKey == VirtualKey.V)
{
OnPasteAppBarButtonClick(pasteAppBarButton, null);
}
}
}
public void HandleInput(CoreWindow coreWindow)
{
MoveLeft = coreWindow.GetKeyState(PLAYER_KEY_LEFT).HasFlag(CoreVirtualKeyStates.Down);
MoveRight = coreWindow.GetKeyState(PLAYER_KEY_RIGHT).HasFlag(CoreVirtualKeyStates.Down);
if (Cooldown <= 0 && coreWindow.GetKeyState(PLAYER_KEY_SHOOT).HasFlag(CoreVirtualKeyStates.Down))
{
Game.Model.AddEntity(new Bullet(new Point(Position.X + Width / 2, Position.Y)));
Cooldown = PLAYER_COOLDOWN;
}
}
private void OnWindowKeyUp(CoreWindow sender, KeyEventArgs e)
{
var playbackSession = mediaElement.MediaPlayer.PlaybackSession;
if (playbackSession == null)
{
return;
}
var delta = 10d;
if (sender.GetKeyState(VirtualKey.Shift) == CoreVirtualKeyStates.Down)
{
delta = 1;
}
if (e.VirtualKey == VirtualKey.Left)
{
playbackSession.Position = TimeSpan.FromSeconds(Math.Max(playbackSession.Position.TotalSeconds - delta, 0));
}
if (e.VirtualKey == VirtualKey.Right)
{
playbackSession.Position = TimeSpan.FromSeconds(Math.Min(playbackSession.Position.TotalSeconds + delta, playbackSession.NaturalDuration.TotalSeconds));
}
if (e.VirtualKey == VirtualKey.Space)
{
e.Handled = true;
TogglePlayPause();
}
}
private KeyboardEventArgs KeyboardEventArgs(VirtualKey key)
{
var alt = (_window.GetKeyState(VirtualKey.Menu) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var shift = (_window.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var control = (_window.GetKeyState(VirtualKey.Control) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var windows = ((_window.GetKeyState(VirtualKey.LeftWindows) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down) ||
((_window.GetKeyState(VirtualKey.RightWindows) & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down);
return(new KeyboardEventArgs
{
AltKey = alt,
ControlKey = control,
ShiftKey = shift,
WindowsKey = windows,
VirtualKey = key
});
}
private void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (sender.GetKeyState(VirtualKey.Control) == CoreVirtualKeyStates.Down &&
args.VirtualKey == VirtualKey.S)
{
var vm = this.DataContext as MainViewModel;
vm?.GoToSettingsCommand?.Execute(null);
}
}
private async void TabViewContainer_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!QueueContentDialog.IsRunningOrWaiting)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.W when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
if (TabViewControl.SelectedItem is TabViewItem Tab)
{
args.Handled = true;
await CleanUpAndRemoveTabItem(Tab);
}
return;
}
}
if (CurrentNavigationControl?.Content is ThisPC PC)
{
switch (args.VirtualKey)
{
case VirtualKey.T when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
await CreateNewTabAsync();
args.Handled = true;
break;
}
case VirtualKey.Space when SettingControl.IsQuicklookEnable:
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (await Exclusive.Controller.CheckIfQuicklookIsAvaliableAsync())
{
if (PC.DeviceGrid.SelectedItem is DriveRelatedData Device && !string.IsNullOrEmpty(Device.Folder.Path))
{
await Exclusive.Controller.ViewWithQuicklookAsync(Device.Folder.Path);
}
else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library && !string.IsNullOrEmpty(Library.Folder.Path))
{
await Exclusive.Controller.ViewWithQuicklookAsync(Library.Folder.Path);
}
}
}
args.Handled = true;
break;
}
void OnAcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
{
if ((args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
args.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(args.VirtualKey == VirtualKey.Left ||
args.VirtualKey == VirtualKey.Right ||
(int)args.VirtualKey == 166 ||
(int)args.VirtualKey == 167))
{
CoreWindow window = Window.Current.CoreWindow;
CoreVirtualKeyStates down = CoreVirtualKeyStates.Down;
// Ignore key combinations where Shift or Ctrl is down
if ((window.GetKeyState(VirtualKey.Shift) & down) == down ||
(window.GetKeyState(VirtualKey.Control) & down) == down)
{
return;
}
// Get alt key state
bool alt = (window.GetKeyState(VirtualKey.Menu) & down) == down;
// Go back for Alt-Left key or browser left key
if (args.VirtualKey == VirtualKey.Left && alt ||
(int)args.VirtualKey == 166 && !alt)
{
GoBack();
args.Handled = true;
}
// Go forward for Alt-Right key or browser right key
if (args.VirtualKey == VirtualKey.Right && alt ||
(int)args.VirtualKey == 167 && !alt)
{
GoForward();
args.Handled = true;
}
}
}
private static bool CheckModifier(CoreWindow target, VirtualKey?key, VirtualKey leftKey, VirtualKey rightKey, KeyPressedState state)
{
if (state == KeyPressedState.All)
{
return(true);
}
var downState = CoreVirtualKeyStates.Down;
if (state == KeyPressedState.Pressed)
{
if (!key.HasValue)
{
var l = (target.GetKeyState(leftKey) & downState) == downState;
var r = (target.GetKeyState(rightKey) & downState) == downState;
return(l || r);
}
var pressed = (target.GetKeyState(key.Value) & downState) == downState;
return(pressed);
}
var left = (target.GetKeyState(leftKey) & downState) == downState;
var right = (target.GetKeyState(rightKey) & downState) == downState;
if (left)
{
if (right)
{
return(state == KeyPressedState.Both);
}
return(state == KeyPressedState.LeftOnly);
}
if (right)
{
return(state == KeyPressedState.RightOnly);
}
return(state == KeyPressedState.None);
}
/// <summary>
/// Handles KeyDown events for the current window.
/// </summary>
/// <param name="sender">The CoreWindow that dispatched the event.</param>
/// <param name="args">KeyEventArgs for the event.</param>
private async void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates ctrlState = sender.GetKeyState(VirtualKey.Control);
if ((ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down)
{
CoreVirtualKeyStates shiftState = sender.GetKeyState(VirtualKey.Shift);
bool shiftDown = (shiftState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
// Handle accelerator (Ctrl) hotkeys
switch (args.VirtualKey)
{
case VirtualKey.O:
if (!shiftDown)
{
// Prompt to open a file
args.Handled = true;
await PickFileForOpenAsync(
file =>
{
OpenFile(file);
}
);
}
break;
default:
args.Handled = ((PassKeepPage)this.contentFrame.Content).HandleAcceleratorKey(args.VirtualKey, shiftDown);
break;
}
}
else
{
if (args.VirtualKey == VirtualKey.Escape)
{
ViewModel.TaskNotificationService.RequestCancellation();
}
}
}
private async void UserInputBar_OnEnterKeyPressed()
{
CoreWindow coreWindow = CoreWindow.GetForCurrentThread();
bool shift = coreWindow.GetKeyState(VirtualKey.Shift).HasFlag(CoreVirtualKeyStates.Down);
bool control = coreWindow.GetKeyState(VirtualKey.Control).HasFlag(CoreVirtualKeyStates.Down);
// If SendMessageWithEnterSetting is true then add new if shift key is pressed.
// If SendMessageWithEnterSetting is false then send message if control key is pressed.
if (GlobalSettingsManager.SendMessageWithEnterSetting ? shift : !control)
{
UserInputBar.AddLinefeed();
}
else
{
bool sendMessageResult = await GetMainPageVm().SendMessage(UserInputBar.InputText, SelectedFile);
if (sendMessageResult)
{
ResetInput();
}
}
}
private void SearchPage_KeyDown(CoreWindow sender, KeyEventArgs args)
{
SearchCommandFlyout.Hide();
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.L when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Location_Click(null, null);
break;
}
}
}
public static byte GetModifierFlags()
{
byte flags;
CoreWindow win = CoreWindow.GetForCurrentThread();
flags = 0;
if ((win.GetKeyState(VirtualKey.Shift) & CoreVirtualKeyStates.Down) != 0)
{
flags |= (byte)Modifier.ModifierShift;
}
if ((win.GetKeyState(VirtualKey.Menu) & CoreVirtualKeyStates.Down) != 0)
{
flags |= (byte)Modifier.ModifierAlt;
}
if ((win.GetKeyState(VirtualKey.Control) & CoreVirtualKeyStates.Down) != 0)
{
flags |= (byte)Modifier.ModifierCtrl;
}
return(flags);
}
/// <summary>
/// 当此页处于活动状态并占用整个窗口时，在每次
/// 击键(包括系统键，如 Alt 组合键)时调用。 用于检测页之间的键盘
/// 导航(即使在页本身没有焦点时)。
/// </summary>
/// <param name="sender">触发事件的实例。</param>
/// <param name="e">描述导致事件的条件的事件数据。</param>
private void CoreDispatcher_AcceleratorKeyActivated(Windows.UI.Core.CoreDispatcher sender,
AcceleratorKeyEventArgs e)
{
var virtualKey = e.VirtualKey;
// 仅当按向左、向右或专用上一页或下一页键时才进一步
// 调查
if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
e.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right ||
(int)virtualKey == 166 || (int)virtualKey == 167))
{
CoreWindow coreWindow = Window.Current.CoreWindow;
var downState = CoreVirtualKeyStates.Down;
bool menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
bool noModifiers = !menuKey && !controlKey && !shiftKey;
bool onlyAlt = menuKey && !controlKey && !shiftKey;
if (((int)virtualKey == 166 && noModifiers) ||
(virtualKey == VirtualKey.Left && onlyAlt))
{
// 在按上一页键或 Alt+向左键时向后导航
e.Handled = true;
GoBackCommand.Execute(null);
}
else if (((int)virtualKey == 167 && noModifiers) ||
(virtualKey == VirtualKey.Right && onlyAlt))
{
// 在按下一页键或 Alt+向右键时向前导航
e.Handled = true;
GoForwardCommand.Execute(null);
}
}
}
private void SecureArea_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
SecureGridView.SelectAll();
break;
}
case VirtualKey.Delete when SecureGridView.SelectedItems.Count > 0:
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down) && SecureGridView.SelectedItems.Count > 0:
{
DeleteFile_Click(null, null);
break;
}
}
}
private void RecycleBin_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
ListViewControl.SelectAll();
break;
}
case VirtualKey.Delete when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
PermanentDelete_Click(null, null);
break;
}
}
}
private void SearchPage_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CloseAllFlyout();
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.L when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Location_Click(null, null);
break;
}
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
SearchResultList.SelectAll();
break;
}
case VirtualKey.C when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Copy_Click(null, null);
break;
}
case VirtualKey.X when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Cut_Click(null, null);
break;
}
case VirtualKey.Delete:
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Delete_Click(null, null);
break;
}
}
}
private void RecycleBin_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!LoadingControl.IsLoading)
{
SelectFlyout.Hide();
EmptyFlyout.Hide();
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
ListViewControl.SelectAll();
break;
}
case VirtualKey.Delete:
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
PermanentDelete_Click(null, null);
break;
}
case VirtualKey.R when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
RestoreRecycle_Click(null, null);
break;
}
case VirtualKey.E when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
ClearRecycleBin_Click(null, null);
break;
}
}
}
}
private InputButton MapKeyState(VirtualKey key, InputButton resultKey) => _window.GetKeyState(key).HasFlag(CoreVirtualKeyStates.Down) ? resultKey : 0;
private async void TabViewContainer_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!QueueContentDialog.IsRunningOrWaiting)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.W when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
if (TabViewControl.SelectedItem is TabViewItem Tab)
{
args.Handled = true;
await CleanUpAndRemoveTabItem(Tab).ConfigureAwait(true);
}
return;
}
}
if (CurrentTabNavigation?.Content is ThisPC PC)
{
switch (args.VirtualKey)
{
case VirtualKey.Space when SettingControl.IsQuicklookAvailable && SettingControl.IsQuicklookEnable:
{
if (PC.DeviceGrid.SelectedItem is HardDeviceInfo Device)
{
await FullTrustProcessController.Current.ViewWithQuicklookAsync(Device.Folder.Path).ConfigureAwait(false);
}
else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library)
{
await FullTrustProcessController.Current.ViewWithQuicklookAsync(Library.Folder.Path).ConfigureAwait(false);
}
break;
}
case VirtualKey.Enter:
{
if (PC.DeviceGrid.SelectedItem is HardDeviceInfo Device)
{
if (string.IsNullOrEmpty(Device.Folder.Path))
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_MTP_CouldNotAccess_Content"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_ContinueButton"),
CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton")
};
if ((await Dialog.ShowAsync().ConfigureAwait(true)) == ContentDialogResult.Primary)
{
await Launcher.LaunchFolderAsync(Device.Folder);
}
}
else
{
if (AnimationController.Current.IsEnableAnimation)
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Device.Folder.Path), new DrillInNavigationTransitionInfo());
}
else
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Device.Folder.Path), new SuppressNavigationTransitionInfo());
}
}
args.Handled = true;
}
else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library)
{
if (AnimationController.Current.IsEnableAnimation)
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Library.Folder.Path), new DrillInNavigationTransitionInfo());
}
else
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Library.Folder.Path), new SuppressNavigationTransitionInfo());
}
args.Handled = true;
}
break;
}
case VirtualKey.F5:
{
PC.Refresh_Click(null, null);
args.Handled = true;
break;
}
}
}
}
}
private void OnKeyDown(CoreWindow sender, KeyEventArgs args)
{
var shiftState = sender.GetKeyState(VirtualKey.Shift);
var shiftIsDown = (shiftState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var altState = sender.GetKeyState(VirtualKey.LeftMenu);
var altIsDown = (altState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var gamepadViewState = sender.GetKeyState(VirtualKey.GamepadView);
var gamepadViewIsDown = (gamepadViewState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
switch (args.VirtualKey)
{
//By default the gamepad's B button is treated as a hardware back button.
//Handling the KeyDown event disables this.
//We want this to happen only in the game page and not in the rest of the UI
case VirtualKey.GamepadB:
args.Handled = true;
break;
//Alt+Enter: enter fullscreen
case VirtualKey.Enter:
if (shiftIsDown)
{
FullScreenChangeRequested(this, new FullScreenChangeEventArgs(FullScreenChangeType.Toggle));
args.Handled = true;
}
break;
case VirtualKey.Escape:
FullScreenChangeRequested(this, new FullScreenChangeEventArgs(FullScreenChangeType.Exit));
args.Handled = true;
break;
case VirtualKey.Space:
PauseToggleRequested(this);
args.Handled = true;
break;
case VirtualKey.GamepadMenu:
if (gamepadViewIsDown)
{
PauseToggleRequested(this);
args.Handled = true;
}
break;
case VirtualKey.F1:
HandleFunctionKeyPress(shiftIsDown, 1, args);
break;
case VirtualKey.F2:
HandleFunctionKeyPress(shiftIsDown, 2, args);
break;
case VirtualKey.F3:
HandleFunctionKeyPress(shiftIsDown, 3, args);
break;
case VirtualKey.F4:
HandleFunctionKeyPress(shiftIsDown, 4, args);
break;
case VirtualKey.F5:
HandleFunctionKeyPress(shiftIsDown, 5, args);
break;
case VirtualKey.F6:
HandleFunctionKeyPress(shiftIsDown, 6, args);
break;
}
}
private static void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender,
AcceleratorKeyEventArgs e)
{
var downState = CoreVirtualKeyStates.Down;
CoreWindow coreWindow = Window.Current.CoreWindow;
bool menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
bool noModifiers = !menuKey && !controlKey && !shiftKey;
if (noModifiers && e.EventType == CoreAcceleratorKeyEventType.KeyDown &&
(e.VirtualKey == VirtualKey.Enter ||
e.VirtualKey == VirtualKey.Escape))
{
var frame = Window.Current.Content as Frame;
if (frame == null)
{
return;
}
var currentPage = frame.Content as Page;
if (currentPage == null)
{
return;
}
if (e.VirtualKey == VirtualKey.Enter)
{
// Quick check to avoid TextBox with ENTER support
var tb = FocusManager.GetFocusedElement() as TextBox;
if (tb != null && tb.AcceptsReturn)
{
return;
}
var defaultButton = currentPage.GetValue(DefaultButtonProperty) as Button;
if (defaultButton != null && defaultButton.IsEnabled)
{
var peer = new ButtonAutomationPeer(defaultButton);
var invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
if (invokeProv != null)
{
invokeProv.Invoke();
}
}
}
else
{
var cancelButton = currentPage.GetValue(CancelButtonProperty) as Button;
if (cancelButton != null && cancelButton.IsEnabled)
{
var peer = new ButtonAutomationPeer(cancelButton);
var invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
if (invokeProv != null)
{
invokeProv.Invoke();
}
}
}
}
}
void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
// Do not process keyboard input if the custom edit control does not
// have focus.
if (!_internalFocus)
{
return;
}
// This holds the range we intend to operate on, or which we intend
// to become the new selection. Start with the current selection.
CoreTextRange range = _selection;
// For the purpose of this sample, we will support only the left and right
// arrow keys and the backspace key. A more complete text edit control
// would also handle keys like Home, End, and Delete, as well as
// hotkeys like Ctrl+V to paste.
//
// Note that this sample does not properly handle surrogate pairs
// nor does it handle grapheme clusters.
switch (args.VirtualKey)
{
// Backspace
case VirtualKey.Back:
// If there is a selection, then delete the selection.
if (HasSelection())
{
// Set the text in the selection to nothing.
ReplaceText(range, "");
}
else
{
// Delete the character to the left of the caret, if one exists,
// by creating a range that encloses the character to the left
// of the caret, and setting the contents of that range to nothing.
range.StartCaretPosition = Math.Max(0, range.StartCaretPosition - 1);
ReplaceText(range, "");
}
break;
// Left arrow
case VirtualKey.Left:
// If the shift key is down, then adjust the size of the selection.
if (_coreWindow.GetKeyState(VirtualKey.Shift).HasFlag(CoreVirtualKeyStates.Down))
{
// If this is the start of a selection, then remember which edge we are adjusting.
if (!HasSelection())
{
_extendingLeft = true;
}
// Adjust the selection and notify CoreTextEditContext.
AdjustSelectionEndpoint(-1);
}
else
{
// The shift key is not down. If there was a selection, then snap the
// caret at the left edge of the selection.
if (HasSelection())
{
range.EndCaretPosition = range.StartCaretPosition;
SetSelectionAndNotify(range);
}
else
{
// There was no selection. Move the caret left one code unit if possible.
range.StartCaretPosition = Math.Max(0, range.StartCaretPosition - 1);
range.EndCaretPosition = range.StartCaretPosition;
SetSelectionAndNotify(range);
}
}
break;
// Right arrow
case VirtualKey.Right:
// If the shift key is down, then adjust the size of the selection.
if (_coreWindow.GetKeyState(VirtualKey.Shift).HasFlag(CoreVirtualKeyStates.Down))
{
// If this is the start of a selection, then remember which edge we are adjusting.
if (!HasSelection())
{
_extendingLeft = false;
}
// Adjust the selection and notify CoreTextEditContext.
AdjustSelectionEndpoint(+1);
}
else
{
// The shift key is not down. If there was a selection, then snap the
// caret at the right edge of the selection.
if (HasSelection())
{
range.StartCaretPosition = range.EndCaretPosition;
SetSelectionAndNotify(range);
}
else
{
// There was no selection. Move the caret right one code unit if possible.
range.StartCaretPosition = Math.Min(_text.Length, range.StartCaretPosition + 1);
range.EndCaretPosition = range.StartCaretPosition;
SetSelectionAndNotify(range);
}
}
break;
}
}
private bool KeyIsDown(CoreWindow window, VirtualKey key)
{
var output = window.GetKeyState(key).HasFlag(CoreVirtualKeyStates.Down);
return(output);
}
