Fixes # 3966. TextField crashes app when pasting unicode surrogate pair

Terminal.Gui/ConsoleDrivers/ConsoleDriver.cs

@@ -691,6 +691,40 @@ public void OnMouseEvent (MouseEventArgs a)
     /// <param name="ctrl">If <see langword="true"/> simulates the Ctrl key being pressed.</param>
     public abstract void SendKeys (char keyChar, ConsoleKey key, bool shift, bool alt, bool ctrl);
 
+    internal char _highSurrogate = '\0';
+
+    internal bool IsValidInput (KeyCode keyCode, out KeyCode result)
+    {
+        result = keyCode;
+
+        if (char.IsHighSurrogate ((char)keyCode))
+        {
+            _highSurrogate = (char)keyCode;
+
+            return false;
+        }
+
+        if (_highSurrogate > 0 && char.IsLowSurrogate ((char)keyCode))
+        {
+            result = (KeyCode)new Rune (_highSurrogate, (char)keyCode).Value;
+            _highSurrogate = '\0';
+
+            return true;
+        }
+
+        if (char.IsSurrogate ((char)keyCode))
+        {
+            return false;
+        }
+
+        if (_highSurrogate > 0)
+        {
+            _highSurrogate = '\0';
+        }
+
+        return true;
+    }
+
     #endregion
 
     private AnsiRequestScheduler? _scheduler;

Terminal.Gui/ConsoleDrivers/CursesDriver/CursesDriver.cs

@@ -729,7 +729,7 @@
                 while (wch2 == Curses.KeyMouse)
                 {
                     // BUGBUG: Fix this nullable issue.
                     Key kea = null;
 
                     ConsoleKeyInfo [] cki =
                     {
@@ -739,7 +739,7 @@
                     };
                     code = 0;
                     // BUGBUG: Fix this nullable issue.
                     HandleEscSeqResponse (ref code, ref k, ref wch2, ref kea, ref cki);
                 }
 
                 return;
@@ -797,7 +797,7 @@
             }
 
             // BUGBUG: Fix this nullable issue.
             Key key = null;
 
             if (code == 0)
             {
@@ -828,7 +828,7 @@
                         new ((char)KeyCode.Esc, 0, false, false, false), new ((char)wch2, 0, false, false, false)
                     ];
                     // BUGBUG: Fix this nullable issue.
                     HandleEscSeqResponse (ref code, ref k, ref wch2, ref key, ref cki);
 
                     return;
                 }
@@ -924,8 +924,11 @@
                 k &= ~KeyCode.Space;
             }
 
-            OnKeyDown (new Key (k));
-            OnKeyUp (new Key (k));
+            if (IsValidInput (k, out k))
+            {
+                OnKeyDown (new (k));
+                OnKeyUp (new (k));
+            }
         }
     }
 
@@ -980,7 +983,7 @@
                 EscSeqUtils.DecodeEscSeq (
                                           ref consoleKeyInfo,
                                           ref ck,
                                           cki,
                                           ref mod,
                                           out _,
                                           out _,
@@ -1001,7 +1004,7 @@
                     }
 
                     // BUGBUG: Fix this nullable issue.
                     cki = null;
 
                     if (wch2 == 27)
                     {

Terminal.Gui/ConsoleDrivers/FakeDriver/FakeDriver.cs

@@ -352,8 +352,12 @@ private void MockKeyPressedHandler (ConsoleKeyInfo consoleKeyInfo)
         }
 
         KeyCode map = MapKey (consoleKeyInfo);
-        OnKeyDown (new Key (map));
-        OnKeyUp (new Key (map));
+
+        if (IsValidInput (map, out map))
+        {
+            OnKeyDown (new (map));
+            OnKeyUp (new (map));
+        }
 
         //OnKeyPressed (new KeyEventArgs (map));
     }

Terminal.Gui/ConsoleDrivers/NetDriver/NetDriver.cs

@@ -226,7 +226,7 @@
 
     // BUGBUG: Fix this nullable issue.
     /// <inheritdoc />
     internal override IAnsiResponseParser GetParser () => _mainLoopDriver._netEvents.Parser;
     internal NetMainLoop? _mainLoopDriver;
 
     /// <inheritdoc />
@@ -321,8 +321,11 @@
                     break;
                 }
 
-                OnKeyDown (new (map));
-                OnKeyUp (new (map));
+                if (IsValidInput (map, out map))
+                {
+                    OnKeyDown (new (map));
+                    OnKeyUp (new (map));
+                }
 
                 break;
             case EventType.Mouse:

Terminal.Gui/ConsoleDrivers/WindowsDriver/WindowsDriver.cs

@@ -507,9 +507,12 @@ internal void ProcessInputAfterParsing (WindowsConsole.InputRecord inputEvent)
                     break;
                 }
 
-                // This follows convention in NetDriver
-                OnKeyDown (new Key (map));
-                OnKeyUp (new Key (map));
+                if (IsValidInput (map, out map))
+                {
+                    // This follows convention in NetDriver
+                    OnKeyDown (new (map));
+                    OnKeyUp (new (map));
+                }
 
                 break;
 

Terminal.Gui/Input/Keyboard/Key.cs

@@ -138,6 +138,44 @@ public Key (string str)
         KeyCode = key.KeyCode;
     }
 
+    /// <summary>
+    ///     Constructs a new Key from an integer describing the key.
+    ///     It parses the integer as Key by calling the constructor with a char or calls the constructor with a
+    ///     KeyCode.
+    /// </summary>
+    /// <remarks>
+    ///     Don't rely on <paramref name="value"/> passed from <see cref="KeyCode.A"/> to <see cref="KeyCode.Z"/> because
+    ///     would not return the expected keys from 'a' to 'z'.
+    /// </remarks>
+    /// <param name="value">The integer describing the key.</param>
+    /// <exception cref="ArgumentOutOfRangeException"></exception>
+    /// <exception cref="ArgumentException"></exception>
+    public Key (int value)
+    {
+        if (value < 0 || value > RuneExtensions.MaxUnicodeCodePoint)
+        {
+            throw new ArgumentOutOfRangeException (@$"Invalid key value: {value}", nameof (value));
+        }
+
+        if (char.IsSurrogate ((char)value))
+        {
+            throw new ArgumentException (@$"Surrogate key not allowed: {value}", nameof (value));
+        }
+
+        Key key;
+
+        if (((Rune)value).IsBmp)
+        {
+            key = new ((char)value);
+        }
+        else
+        {
+            key = new ((KeyCode)value);
+        }
+
+        KeyCode = key.KeyCode;
+    }
+
     /// <summary>
     ///     The key value as a Rune. This is the actual value of the key pressed, and is independent of the modifiers.
     ///     Useful for determining if a key represents is a printable character.
@@ -388,6 +426,11 @@ public static Rune ToRune (KeyCode key)
     /// <param name="str"></param>
     public static implicit operator Key (string str) { return new (str); }
 
+    /// <summary>Cast <see langword="int"/> to a <see cref="Key"/>.</summary>
+    /// <remarks>See <see cref="Key(int)"/> for more information.</remarks>
+    /// <param name="value"></param>
+    public static implicit operator Key (int value) { return new (value); }
+
     /// <summary>Cast a <see cref="Key"/> to a <see langword="string"/>.</summary>
     /// <remarks>See <see cref="Key(string)"/> for more information.</remarks>
     /// <param name="key"></param>
@@ -550,7 +593,7 @@ private static string TrimEndSeparator (string input, Rune separator)
         // "Ctrl+" (trim)
         // "Ctrl++" (trim)
 
-        if (input.Length > 1 && new Rune (input [^1]) == separator && new Rune (input [^2]) != separator)
+        if (input.Length > 1 && !char.IsHighSurrogate (input [^2]) && new Rune (input [^1]) == separator && new Rune (input [^2]) != separator)
         {
             return input [..^1];
         }
@@ -640,6 +683,13 @@ public static bool TryParse (string text, out Key key)
             return false;
         }
 
+        if (text.Length == 2 && char.IsHighSurrogate (text [^2]) && char.IsLowSurrogate (text [^1]))
+        {
+            // It's a surrogate pair and there is no modifiers
+            key = new (new Rune (text [^2], text [^1]).Value);
+            return true;
+        }
+
         // e.g. "Ctrl++"
         if ((Rune)text [^1] != separator && parts.Any (string.IsNullOrEmpty))
         {

Terminal.Gui/Views/TextField.cs

@@ -730,21 +730,11 @@ public virtual void DeleteCharRight ()
     /// <param name="useOldCursorPos">Use the previous cursor position.</param>
     public void InsertText (string toAdd, bool useOldCursorPos = true)
     {
-        foreach (char ch in toAdd)
+        foreach (Rune rune in toAdd.EnumerateRunes ())
         {
-            Key key;
-
-            try
-            {
-                key = ch;
-            }
-            catch (Exception)
-            {
-                throw new ArgumentException (
-                                             $"Cannot insert character '{ch}' because it does not map to a Key"
-                                            );
-            }
-
+            // All rune can be mapped to a Key and no exception will throw here because
+            // EnumerateRunes will replace a surrogate char with the Rune.ReplacementChar
+            Key key = rune.Value;
             InsertText (key, useOldCursorPos);
         }
     }
@@ -1114,7 +1104,7 @@ public virtual void Paste ()
             TextModel.SetCol (ref col, Viewport.Width - 1, cols);
         }
 
-        int pos = _cursorPosition - ScrollOffset + Math.Min (Viewport.X, 0);
+        int pos = col - ScrollOffset + Math.Min (Viewport.X, 0);
         Move (pos, 0);
 
         return new Point (pos, 0);

Tests/UnitTests/ConsoleDrivers/ConsoleDriverTests.cs

@@ -283,4 +283,115 @@ public void TerminalResized_Simulation (Type driverType)
     //			Application.Run (win);
     //			Application.Shutdown ();
     //		}
+
+    [Theory]
+    [InlineData ('\ud83d', '\udcc4')] // This seems right sequence but Stack is LIFO
+    [InlineData ('\ud83d', '\ud83d')]
+    [InlineData ('\udcc4', '\udcc4')]
+    public void FakeDriver_IsValidInput_Wrong_Surrogate_Sequence (char c1, char c2)
+    {
+        var driver = (IConsoleDriver)Activator.CreateInstance (typeof (FakeDriver));
+        Application.Init (driver);
+
+        Stack<ConsoleKeyInfo> mKeys = new (
+                                           [
+                                               new ('a', ConsoleKey.A, false, false, false),
+                                               new (c1, ConsoleKey.None, false, false, false),
+                                               new (c2, ConsoleKey.None, false, false, false)
+                                           ]);
+
+        Console.MockKeyPresses = mKeys;
+
+        Toplevel top = new ();
+        var view = new View { CanFocus = true };
+        var rText = "";
+        var idx = 0;
+
+        view.KeyDown += (s, e) =>
+                        {
+                            Assert.Equal (new ('a'), e.AsRune);
+                            Assert.Equal ("a", e.AsRune.ToString ());
+                            rText += e.AsRune;
+                            e.Handled = true;
+                            idx++;
+                        };
+        top.Add (view);
+
+        Application.Iteration += (s, a) =>
+                                 {
+                                     if (mKeys.Count == 0)
+                                     {
+                                         Application.RequestStop ();
+                                     }
+                                 };
+
+        Application.Run (top);
+
+        Assert.Equal ("a", rText);
+        Assert.Equal (1, idx);
+        Assert.Equal (0, ((FakeDriver)driver)._highSurrogate);
+
+        top.Dispose ();
+
+        // Shutdown must be called to safely clean up Application if Init has been called
+        Application.Shutdown ();
+    }
+
+    [Fact]
+    public void FakeDriver_IsValidInput_Correct_Surrogate_Sequence ()
+    {
+        var driver = (IConsoleDriver)Activator.CreateInstance (typeof (FakeDriver));
+        Application.Init (driver);
+
+        Stack<ConsoleKeyInfo> mKeys = new (
+                                           [
+                                               new ('a', ConsoleKey.A, false, false, false),
+                                               new ('\udcc4', ConsoleKey.None, false, false, false),
+                                               new ('\ud83d', ConsoleKey.None, false, false, false)
+                                           ]);
+
+        Console.MockKeyPresses = mKeys;
+
+        Toplevel top = new ();
+        var view = new View { CanFocus = true };
+        var rText = "";
+        var idx = 0;
+
+        view.KeyDown += (s, e) =>
+                        {
+                            if (idx == 0)
+                            {
+                                Assert.Equal (new (0x1F4C4), e.AsRune);
+                                Assert.Equal ("📄", e.AsRune.ToString ());
+                            }
+                            else
+                            {
+                                Assert.Equal (new ('a'), e.AsRune);
+                                Assert.Equal ("a", e.AsRune.ToString ());
+                            }
+
+                            rText += e.AsRune;
+                            e.Handled = true;
+                            idx++;
+                        };
+        top.Add (view);
+
+        Application.Iteration += (s, a) =>
+                                 {
+                                     if (mKeys.Count == 0)
+                                     {
+                                         Application.RequestStop ();
+                                     }
+                                 };
+
+        Application.Run (top);
+
+        Assert.Equal ("📄a", rText);
+        Assert.Equal (2, idx);
+
+        top.Dispose ();
+
+        // Shutdown must be called to safely clean up Application if Init has been called
+        Application.Shutdown ();
+    }
 }

Tests/UnitTests/Views/TextFieldTests.cs

@@ -2178,4 +2178,33 @@ public void Draw_Esc_Rune ()
 
         tf.Dispose ();
     }
+
+    [Fact]
+    public void InsertText_Bmp_SurrogatePair_Non_Bmp_Invalid_SurrogatePair ()
+    {
+        var tf = new TextField ();
+
+        //📄 == \ud83d\udcc4 == \U0001F4C4
+        // � == Rune.ReplacementChar
+        tf.InsertText ("aA,;\ud83d\udcc4\U0001F4C4\udcc4\ud83d");
+        Assert.Equal ("aA,;📄📄��", tf.Text);
+    }
+
+    [Fact]
+    public void PositionCursor_Respect_GetColumns ()
+    {
+        var tf = new TextField { Width = 5 };
+        tf.BeginInit ();
+        tf.EndInit ();
+
+        tf.NewKeyDownEvent (new ("📄"));
+        Assert.Equal (1, tf.CursorPosition);
+        Assert.Equal (new (2, 0), tf.PositionCursor ());
+        Assert.Equal ("📄", tf.Text);
+
+        tf.NewKeyDownEvent (new (KeyCode.A));
+        Assert.Equal (2, tf.CursorPosition);
+        Assert.Equal (new (3, 0), tf.PositionCursor ());
+        Assert.Equal ("📄a", tf.Text);
+    }
 }