/// <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); }