Merge pull request #22111 from ramezgerges/textbox_drops_keydown

fix(textbox): prevent keys from dropping when input is too quick

Author: ramezgerges

src/Uno.UI.RuntimeTests/Tests/Windows_UI_Xaml_Controls/Given_TextBox.skia.cs

@@ -117,6 +117,27 @@ public async Task When_Basic_Input_Event_Sequence()
                 """.Replace("\r\n", "\n"), eventLog);
 		}
 
+		[TestMethod]
+		public async Task When_Public_KeyDown_Subscription_Changes_Text()
+		{
+			using var _ = new TextBoxFeatureConfigDisposable();
+
+			var SUT = new TextBox();
+			SUT.KeyDown += (sender, args) =>
+			{
+				if (args.Key == VirtualKey.T)
+				{
+					SUT.Text = "Ramez";
+				}
+			};
+
+			await UITestHelper.Load(SUT);
+
+			await KeyboardHelper.PressKeySequence("t", SUT);
+
+			Assert.AreEqual("tRamez", SUT.Text);
+		}
+
 		[TestMethod]
 		public async Task When_Basic_Input_With_ArrowKeys()
 		{

src/Uno.UI/UI/Xaml/Controls/AutoSuggestBox/AutoSuggestBox.cs

@@ -300,7 +300,7 @@ void RegisterEvents()
 		{
 			if (_textBox != null)
 			{
-				_textBox.KeyDown += OnTextBoxKeyDown;
+				_textBox.PostKeyDown += OnTextBoxPostKeyDown;
 				_queryButton = _textBox.GetTemplateChild<Button>("QueryButton");
 			}
 
@@ -332,7 +332,7 @@ void UnregisterEvents()
 			_textBoxLoadedDisposable?.Dispose();
 			if (_textBox != null)
 			{
-				_textBox.KeyDown -= OnTextBoxKeyDown;
+				_textBox.PostKeyDown -= OnTextBoxPostKeyDown;
 			}
 
 			if (_queryButton != null)
@@ -448,7 +448,7 @@ private void SubmitSearch(object item)
 			IsSuggestionListOpen = false;
 		}
 
-		private void OnTextBoxKeyDown(object sender, KeyRoutedEventArgs e)
+		private void OnTextBoxPostKeyDown(object sender, KeyRoutedEventArgs e)
 		{
 			if (e.Key == VirtualKey.Enter)
 			{

src/Uno.UI/UI/Xaml/Controls/Control/Control.cs

@@ -40,6 +40,7 @@ public partial class Control : FrameworkElement
 		private void InitializeControl()
 		{
 			SubscribeToOverridenRoutedEvents();
+			SubscribeToPostKeyDown();
 			OnIsFocusableChanged();
 
 			DefaultStyleKey = typeof(Control);
@@ -329,6 +330,15 @@ private protected override void OnPostLoading()
 #endif
 
 #if !__NETSTD_REFERENCE__
+		[System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2072", Justification = "Types manipulated here have been marked earlier")]
+		private void SubscribeToPostKeyDown()
+		{
+			if (GetIsEventOverrideImplemented(GetType(), nameof(OnPostKeyDown), _keyArgsType))
+			{
+				PostKeyDown += OnPostKeyDownHandler;
+			}
+		}
+
 		[UnconditionalSuppressMessage("Trimming", "IL2072", Justification = "Types manipulated here have been marked earlier")]
 		private void SubscribeToOverridenRoutedEvents()
 		{
@@ -1031,6 +1041,7 @@ protected virtual void OnPreviewKeyDown(KeyRoutedEventArgs e) { }
 		protected virtual void OnPreviewKeyUp(KeyRoutedEventArgs e) { }
 #endif
 		protected virtual void OnKeyDown(KeyRoutedEventArgs e) { }
+		private protected virtual void OnPostKeyDown(KeyRoutedEventArgs e) { }
 		protected virtual void OnKeyUp(KeyRoutedEventArgs e) { }
 		protected virtual void OnGotFocus(RoutedEventArgs e) { }
 		protected virtual void OnLostFocus(RoutedEventArgs e) { }
@@ -1117,6 +1128,9 @@ protected virtual void OnLostFocus(RoutedEventArgs e) { }
 				}
 			};
 
+		private static readonly KeyEventHandler OnPostKeyDownHandler =
+			(object sender, KeyRoutedEventArgs args) => ((Control)sender).OnPostKeyDown(args);
+
 		private static readonly KeyEventHandler OnKeyUpHandler =
 			(object sender, KeyRoutedEventArgs args) => ((Control)sender).OnKeyUp(args);
 

src/Uno.UI/UI/Xaml/Controls/TextBox/TextBox.cs

@@ -1159,10 +1159,27 @@ protected override void OnTapped(TappedRoutedEventArgs e)
 
 		partial void OnTappedPartial();
 
-		/// <inheritdoc />
+		partial void OnKeyDownPartial(KeyRoutedEventArgs args);
+
 		protected override void OnKeyDown(KeyRoutedEventArgs args)
 		{
+			base.OnKeyDown(args);
+
 			OnKeyDownPartial(args);
+		}
+
+		private protected override void OnPostKeyDown(KeyRoutedEventArgs args)
+		{
+#if __SKIA__
+			if (_isSkiaTextBox)
+			{
+				OnKeyDownSkia(args);
+			}
+			else
+#endif
+			{
+				OnKeyDownNonSkia(args);
+			}
 
 			var modifiers = CoreImports.Input_GetKeyboardModifiers();
 			if (!args.Handled && KeyboardAcceleratorUtility.IsKeyValidForAccelerators(args.Key, KeyboardAcceleratorUtility.MapVirtualKeyModifiersToIntegersModifiers(modifiers)))
@@ -1175,17 +1192,8 @@ protected override void OnKeyDown(KeyRoutedEventArgs args)
 			}
 		}
 
-		partial void OnKeyDownPartial(KeyRoutedEventArgs args);
-
-#if !__SKIA__
-		partial void OnKeyDownPartial(KeyRoutedEventArgs args) => OnKeyDownInternal(args);
-#endif
-
-		private void OnKeyDownInternal(KeyRoutedEventArgs args)
+		private void OnKeyDownNonSkia(KeyRoutedEventArgs args)
 		{
-			base.OnKeyDown(args);
-
-
 			// On skia, sometimes SelectionStart is updated to a new value before KeyDown is fired, so
 			// we need to get selectionStart from another source on Skia.
 #if __SKIA__

src/Uno.UI/UI/Xaml/Controls/TextBox/TextBox.skia.cs

@@ -436,14 +436,80 @@ private void UpdateScrolling(bool putSelectionEndInVisibleViewport)
 
 	partial void OnKeyDownPartial(KeyRoutedEventArgs args)
 	{
+		// This is a minimal copy of OnkeyDownSkia that just sets args.Handled without doing any work.
+		// This is to match WinUI behavior where Handled is set for certain keys before public
+		// subscribers get the event, but before any actual text processing is done.
 		if (!_isSkiaTextBox)
 		{
-			OnKeyDownInternal(args);
 			return;
 		}
 
-		base.OnKeyDown(args);
+		var (selectionStart, selectionLength) = _selection.selectionEndsAtTheStart ? (_selection.start + _selection.length, -_selection.length) : (_selection.start, _selection.length);
+		var text = Text;
+		var shift = args.KeyboardModifiers.HasFlag(VirtualKeyModifiers.Shift);
+		var ctrl = args.KeyboardModifiers.HasFlag(_platformCtrlKey);
+		switch (args.Key)
+		{
+			case VirtualKey.Escape:
+				if (HasPointerCapture)
+				{
+					args.Handled = true;
+				}
+				return;
+			case VirtualKey.Z when ctrl:
+			case VirtualKey.Y when ctrl:
+			case VirtualKey.Delete when !IsReadOnly:
+			case VirtualKey.A when ctrl:
+				if (!HasPointerCapture)
+				{
+					args.Handled = true;
+				}
+				return;
+			case VirtualKey.Up:
+				// on macOS start of document is `Command` and `Up`
+				if (ctrl && OperatingSystem.IsMacOS())
+				{
+					KeyDownHome(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				}
+				else
+				{
+					KeyDownUpArrow(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				}
+				break;
+			case VirtualKey.Down:
+				// on macOS end of document is `Command` and `Down`
+				if (ctrl && OperatingSystem.IsMacOS())
+				{
+					KeyDownEnd(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				}
+				else
+				{
+					KeyDownDownArrow(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				}
+				break;
+			case VirtualKey.Left when !TextBoxView.DisplayBlock.ParsedText.IsBaseDirectionRightToLeft:
+			case VirtualKey.Right when TextBoxView.DisplayBlock.ParsedText.IsBaseDirectionRightToLeft:
+				KeyDownLeftArrow(args, text, shift, ctrl, ref selectionStart, ref selectionLength);
+				break;
+			case VirtualKey.Left when TextBoxView.DisplayBlock.ParsedText.IsBaseDirectionRightToLeft:
+			case VirtualKey.Right when !TextBoxView.DisplayBlock.ParsedText.IsBaseDirectionRightToLeft:
+				KeyDownRightArrow(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				break;
+			case VirtualKey.Home:
+				KeyDownHome(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				break;
+			case VirtualKey.End:
+				KeyDownEnd(args, text, ctrl, shift, ref selectionStart, ref selectionLength);
+				break;
+			// TODO: PageUp/Down
+			case VirtualKey.Back when !IsReadOnly:
+				KeyDownBack(args, ref text, ctrl, shift, ref selectionStart, ref selectionLength);
+				break;
+		}
+	}
 
+	private void OnKeyDownSkia(KeyRoutedEventArgs args)
+	{
 		if (_selection.length != 0 &&
 			args.Key is not (VirtualKey.Up or VirtualKey.Down or VirtualKey.Left or VirtualKey.Right))
 		{
@@ -588,31 +654,26 @@ args.Key is not (VirtualKey.Up or VirtualKey.Down or VirtualKey.Left or VirtualK
 		selectionStart = Math.Max(0, Math.Min(text.Length, selectionStart));
 		selectionLength = Math.Max(-selectionStart, Math.Min(text.Length - selectionStart, selectionLength));
 
-		// This is queued in order to run after public KeyDown callbacks are fired and is enqueued on High to run
-		// before the next TextChanged+KeyUp sequence.
-		DispatcherQueue.TryEnqueue(DispatcherQueuePriority.High, () =>
-		{
-			var caretXOffset = _caretXOffset;
+		var caretXOffset = _caretXOffset;
 
-			_suppressCurrentlyTyping = true;
-			_clearHistoryOnTextChanged = false;
-			if (!HasPointerCapture)
-			{
-				_pendingSelection = (selectionStart, selectionLength);
-			}
+		_suppressCurrentlyTyping = true;
+		_clearHistoryOnTextChanged = false;
+		if (!HasPointerCapture)
+		{
+			_pendingSelection = (selectionStart, selectionLength);
+		}
 
-			ProcessTextInput(text);
-			_clearHistoryOnTextChanged = true;
-			_suppressCurrentlyTyping = false;
+		ProcessTextInput(text);
+		_clearHistoryOnTextChanged = true;
+		_suppressCurrentlyTyping = false;
 
-			// don't change the caret offset when moving up and down
-			if (args.Key is VirtualKey.Up or VirtualKey.Down)
-			{
-				// this condition is accurate in the case of hitting Down on the last line
-				// or up on the first line. On WinUI, the caret offset won't change.
-				_caretXOffset = caretXOffset;
-			}
-		});
+		// don't change the caret offset when moving up and down
+		if (args.Key is VirtualKey.Up or VirtualKey.Down)
+		{
+			// this condition is accurate in the case of hitting Down on the last line
+			// or up on the first line. On WinUI, the caret offset won't change.
+			_caretXOffset = caretXOffset;
+		}
 	}
 
 	internal void SetPendingSelection(int selectionStart, int selectionLength)

src/Uno.UI/UI/Xaml/UIElement.RoutedEvents.cs

@@ -437,6 +437,8 @@ public event KeyEventHandler KeyDown
 			remove => RemoveHandler(KeyDownEvent, value);
 		}
 
+		internal event KeyEventHandler PostKeyDown;
+
 		public event KeyEventHandler KeyUp
 		{
 			add => AddHandler(KeyUpEvent, value, false);
@@ -647,6 +649,11 @@ internal bool RaiseEvent(RoutedEvent routedEvent, RoutedEventArgs args, Bubbling
 				}
 			}
 
+			if (routedEvent == KeyDownEvent)
+			{
+				PostKeyDown?.Invoke(this, (KeyRoutedEventArgs)args);
+			}
+
 			if (routedEvent.IsTunnelingEvent || ctx.ModeHasFlag(BubblingMode.IgnoreParents) || ctx.Root == this)
 			{
 				return isHandled;