AnsiResponseParser now handles net event keyboard inputs for cursor keys

Author: tznind

Terminal.Gui/ConsoleDrivers/AnsiResponseParser/AnsiKeyboardParser.cs

@@ -0,0 +1,44 @@
+using System.Text.RegularExpressions;
+
+namespace Terminal.Gui;
+
+public class AnsiKeyboardParser
+{
+    // Regex patterns for ANSI arrow keys (Up, Down, Left, Right)
+    private readonly Regex _arrowKeyPattern = new (@"\u001b\[(A|B|C|D)", RegexOptions.Compiled);
+
+    /// <summary>
+    ///     Parses an ANSI escape sequence into a keyboard event. Returns null if input
+    ///     is not a recognized keyboard event or its syntax is not understood.
+    /// </summary>
+    /// <param name="input"></param>
+    /// <returns></returns>
+    public Key ProcessKeyboardInput (string input)
+    {
+        // Match arrow key events
+        Match match = _arrowKeyPattern.Match (input);
+
+        if (match.Success)
+        {
+            char direction = match.Groups [1].Value [0];
+
+            return direction switch
+                   {
+                       'A' => Key.CursorUp,
+                       'B' => Key.CursorDown,
+                       'C' => Key.CursorRight,
+                       'D' => Key.CursorDown,
+                       _ => default(Key)
+                   };
+
+        }
+
+        // It's an unrecognized keyboard event
+        return null;
+    }
+
+    public bool IsKeyboard (string cur)
+    {
+        return _arrowKeyPattern.IsMatch (cur);
+    }
+}

Terminal.Gui/ConsoleDrivers/AnsiResponseParser/AnsiMouseParser.cs

@@ -13,6 +13,18 @@ public class AnsiMouseParser
     // Regex patterns for button press/release, wheel scroll, and mouse position reporting
     private readonly Regex _mouseEventPattern = new (@"\u001b\[<(\d+);(\d+);(\d+)(M|m)", RegexOptions.Compiled);
 
+    /// <summary>
+    /// Returns true if it is a mouse event
+    /// </summary>
+    /// <param name="cur"></param>
+    /// <returns></returns>
+    public bool IsMouse (string cur)
+    {
+        // Typically in this format
+        // ESC [ < {button_code};{x_pos};{y_pos}{final_byte}
+        return cur.EndsWith ('M') || cur.EndsWith ('m');
+    }
+
     /// <summary>
     ///     Parses a mouse ansi escape sequence into a mouse event. Returns null if input
     ///     is not a mouse event or its syntax is not understood.

Terminal.Gui/ConsoleDrivers/AnsiResponseParser/AnsiResponseParser.cs

@@ -7,6 +7,7 @@ namespace Terminal.Gui;
 internal abstract class AnsiResponseParserBase : IAnsiResponseParser
 {
     private readonly AnsiMouseParser _mouseParser = new  ();
+    private readonly AnsiKeyboardParser _keyboardParser = new ();
     protected object _lockExpectedResponses = new();
 
     protected object _lockState = new ();
@@ -16,12 +17,22 @@ internal abstract class AnsiResponseParserBase : IAnsiResponseParser
     /// </summary>
     public event EventHandler<MouseEventArgs> Mouse;
 
+    /// <summary>
+    /// Event raised when keyboard event is detected (e.g. cursors) - requires setting <see cref="HandleKeyboard"/>
+    /// </summary>
+    public event Action<object, Key> Keyboard;
+
     /// <summary>
     /// True to explicitly handle mouse escape sequences by passing them to <see cref="Mouse"/> event.
     /// Defaults to <see langword="false"/>
     /// </summary>
     public bool HandleMouse { get; set; } = false;
 
+    /// <summary>
+    /// True to explicitly handle keyboard escape sequences (such as cursor keys) by passing them to <see cref="Keyboard"/> event
+    /// </summary>
+    public bool HandleKeyboard { get; set; } = false;
+
     /// <summary>
     ///     Responses we are expecting to come in.
     /// </summary>
@@ -208,6 +219,15 @@ protected bool ShouldReleaseHeldContent ()
                 return false;
             }
 
+            if (HandleKeyboard && IsKeyboard (cur))
+            {
+                RaiseKeyboardEvent (cur);
+                ResetState ();
+
+                Logging.Logger.LogTrace ($"AnsiResponseParser handled as keyboard '{cur}'");
+                return false;
+            }
+
             lock (_lockExpectedResponses)
             {
                 // Look for an expected response for what is accumulated so far (since Esc)
@@ -281,11 +301,20 @@ private void RaiseMouseEvent (string cur)
 
     private bool IsMouse (string cur)
     {
-        // Typically in this format
-        // ESC [ < {button_code};{x_pos};{y_pos}{final_byte}
-        return cur.EndsWith ('M') || cur.EndsWith ('m');
+        return _mouseParser.IsMouse (cur);
+    }
+    private void RaiseKeyboardEvent (string cur)
+    {
+        var k = _keyboardParser.ProcessKeyboardInput (cur);
+        Keyboard?.Invoke (this, k);
+    }
+    private bool IsKeyboard (string cur)
+    {
+        return _keyboardParser.IsKeyboard (cur);
     }
 
+
+
     /// <summary>
     ///     <para>
     ///         When overriden in a derived class, indicates whether the unexpected response
@@ -390,6 +419,7 @@ public AnsiResponseParser () : base (new GenericHeld<T> ()) { }
     /// <inheritdoc cref="AnsiResponseParser.UnknownResponseHandler"/>
     public Func<IEnumerable<Tuple<char, T>>, bool> UnexpectedResponseHandler { get; set; } = _ => false;
 
+
     public IEnumerable<Tuple<char, T>> ProcessInput (params Tuple<char, T> [] input)
     {
         List<Tuple<char, T>> output = new ();
@@ -451,6 +481,7 @@ public void ExpectResponseT (string terminator, Action<IEnumerable<Tuple<char, T
 
     /// <inheritdoc/>
     protected override bool ShouldSwallowUnexpectedResponse () { return UnexpectedResponseHandler.Invoke (HeldToEnumerable ()); }
+
 }
 
 internal class AnsiResponseParser () : AnsiResponseParserBase (new StringHeld ())

Terminal.Gui/ConsoleDrivers/V2/InputProcessor.cs

@@ -63,6 +63,14 @@ public InputProcessor (ConcurrentQueue<T> inputBuffer)
         InputBuffer = inputBuffer;
         Parser.HandleMouse = true;
         Parser.Mouse += (s, e) => OnMouseEvent (e);
+
+        Parser.HandleKeyboard = true;
+        Parser.Keyboard += (s,k)=>
+                          {
+                              OnKeyDown (k);
+                              OnKeyUp (k);
+                          };
+
         // TODO: For now handle all other escape codes with ignore
         Parser.UnexpectedResponseHandler = str => { return true; };
     }

UnitTests/ConsoleDrivers/V2/MouseInterpreterTests.cs

@@ -8,20 +8,18 @@ public class MouseInterpreterTests
     public void TestMouseEventSequences_InterpretedOnlyAsFlag (List<MouseEventArgs> events, MouseFlags expected)
     {
         // Arrange: Mock dependencies and set up the interpreter
-        var viewFinder = Mock.Of<IViewFinder> ();
-        var interpreter = new MouseInterpreter (null, viewFinder);
+        var interpreter = new MouseInterpreter (null);
 
         // Act and Assert: Process all but the last event and ensure they yield no results
         for (int i = 0; i < events.Count - 1; i++)
         {
             var intermediateResult = interpreter.Process (events [i]);
-            Assert.Empty (intermediateResult);
+            Assert.Equal (events [i].Flags,intermediateResult.Flags);
         }
 
         // Process the final event and verify the expected result
-        var finalResult = interpreter.Process (events [^1]).ToArray (); // ^1 is the last item in the list
-        var singleResult = Assert.Single (finalResult); // Ensure only one result is produced
-        Assert.Equal (expected, singleResult.Flags);
+        var finalResult = interpreter.Process (events [^1]); // ^1 is the last item in the list
+        Assert.Equal (expected, finalResult.Flags);
     }