Fixes #3767. Allowing any driver to request ANSI escape sequence with immediate response.

Terminal.Gui/Application/Application.Run.cs

@@ -493,6 +493,7 @@ public static void Refresh ()
         {
             if (tl.LayoutNeeded)
             {
+                tl.SetRelativeLayout (new (Driver!.Cols, Driver.Rows));
                 tl.LayoutSubviews ();
             }
 

Terminal.Gui/ConsoleDrivers/AnsiEscapeSequence/AnsiEscapeSequenceRequest.cs

@@ -0,0 +1,129 @@
+#nullable enable
+namespace Terminal.Gui;
+
+/// <summary>
+///     Describes an ongoing ANSI request sent to the console.
+///     Use <see cref="ResponseReceived"/> to handle the response
+///     when console answers the request.
+/// </summary>
+public class AnsiEscapeSequenceRequest
+{
+    internal readonly object _responseLock = new (); // Per-instance lock
+
+    /// <summary>
+    ///     Request to send e.g. see
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_SendDeviceAttributes.Request</cref>
+    ///     </see>
+    /// </summary>
+    public required string Request { get; init; }
+
+    /// <summary>
+    ///     Response received from the request.
+    /// </summary>
+    public string Response { get; internal set; } = string.Empty;
+
+    /// <summary>
+    ///     Invoked when the console responds with an ANSI response code that matches the
+    ///     <see cref="Terminator"/>
+    /// </summary>
+    public event EventHandler<AnsiEscapeSequenceResponse>? ResponseReceived;
+
+    /// <summary>
+    ///     <para>
+    ///         The terminator that uniquely identifies the type of response as responded
+    ///         by the console. e.g. for
+    ///         <see>
+    ///             <cref>EscSeqUtils.CSI_SendDeviceAttributes.Request</cref>
+    ///         </see>
+    ///         the terminator is
+    ///         <see>
+    ///             <cref>EscSeqUtils.CSI_SendDeviceAttributes.Terminator</cref>
+    ///         </see>
+    ///         .
+    ///     </para>
+    ///     <para>
+    ///         After sending a request, the first response with matching terminator will be matched
+    ///         to the oldest outstanding request.
+    ///     </para>
+    /// </summary>
+    public required string Terminator { get; init; }
+
+    /// <summary>
+    ///     Execute an ANSI escape sequence escape which may return a response or error.
+    /// </summary>
+    /// <param name="ansiRequest">The ANSI escape sequence to request.</param>
+    /// <param name="result">
+    ///     When this method returns <see langword="true"/>, an object containing the response with an empty
+    ///     error.
+    /// </param>
+    /// <returns>A <see cref="AnsiEscapeSequenceResponse"/> with the response, error, terminator and value.</returns>
+    public static bool TryExecuteAnsiRequest (AnsiEscapeSequenceRequest ansiRequest, out AnsiEscapeSequenceResponse result)
+    {
+        var error = new StringBuilder ();
+        var values = new string? [] { null };
+
+        try
+        {
+            ConsoleDriver? driver = Application.Driver;
+
+            // Send the ANSI escape sequence
+            ansiRequest.Response = driver?.WriteAnsiRequest (ansiRequest)!;
+
+            if (!string.IsNullOrEmpty (ansiRequest.Response) && !ansiRequest.Response.StartsWith (EscSeqUtils.KeyEsc))
+            {
+                throw new InvalidOperationException ("Invalid escape character!");
+            }
+
+            if (string.IsNullOrEmpty (ansiRequest.Terminator))
+            {
+                throw new InvalidOperationException ("Terminator request is empty.");
+            }
+
+            if (!ansiRequest.Response.EndsWith (ansiRequest.Terminator [^1]))
+            {
+                string resp = string.IsNullOrEmpty (ansiRequest.Response) ? "" : ansiRequest.Response.Last ().ToString ();
+
+                throw new InvalidOperationException ($"Terminator ends with '{resp}'\nand doesn't end with: '{ansiRequest.Terminator [^1]}'");
+            }
+        }
+        catch (Exception ex)
+        {
+            error.AppendLine ($"Error executing ANSI request:\n{ex.Message}");
+        }
+        finally
+        {
+            if (string.IsNullOrEmpty (error.ToString ()))
+            {
+                (string? _, string? _, values, string? _) = EscSeqUtils.GetEscapeResult (ansiRequest.Response.ToCharArray ());
+            }
+        }
+
+        AnsiEscapeSequenceResponse ansiResponse = new ()
+        {
+            Response = ansiRequest.Response, Error = error.ToString (),
+            Terminator = string.IsNullOrEmpty (ansiRequest.Response) ? "" : ansiRequest.Response [^1].ToString (), Value = values [0]
+        };
+
+        // Invoke the event if it's subscribed
+        ansiRequest.ResponseReceived?.Invoke (ansiRequest, ansiResponse);
+
+        result = ansiResponse;
+
+        return string.IsNullOrWhiteSpace (result.Error) && !string.IsNullOrWhiteSpace (result.Response);
+    }
+
+    /// <summary>
+    ///     The value expected in the response e.g.
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_ReportTerminalSizeInChars.Value</cref>
+    ///     </see>
+    ///     which will have a 't' as terminator but also other different request may return the same terminator with a
+    ///     different value.
+    /// </summary>
+    public string? Value { get; init; }
+
+    internal void RaiseResponseFromInput (AnsiEscapeSequenceRequest ansiRequest, string response) { ResponseFromInput?.Invoke (ansiRequest, response); }
+
+    internal event EventHandler<string>? ResponseFromInput;
+}

Terminal.Gui/ConsoleDrivers/AnsiEscapeSequence/AnsiEscapeSequenceResponse.cs

@@ -0,0 +1,53 @@
+#nullable enable
+namespace Terminal.Gui;
+
+/// <summary>
+///     Describes a finished ANSI received from the console.
+/// </summary>
+public class AnsiEscapeSequenceResponse
+{
+    /// <summary>
+    ///     Error received from e.g. see
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_SendDeviceAttributes.Request</cref>
+    ///     </see>
+    /// </summary>
+    public required string Error { get; init; }
+
+    /// <summary>
+    ///     Response received from e.g. see
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_SendDeviceAttributes.Request</cref>
+    ///     </see>
+    ///     .
+    /// </summary>
+    public required string Response { get; init; }
+
+    /// <summary>
+    ///     <para>
+    ///         The terminator that uniquely identifies the type of response as responded
+    ///         by the console. e.g. for
+    ///         <see>
+    ///             <cref>EscSeqUtils.CSI_SendDeviceAttributes.Request</cref>
+    ///         </see>
+    ///         the terminator is
+    ///         <see>
+    ///             <cref>EscSeqUtils.CSI_SendDeviceAttributes.Terminator</cref>
+    ///         </see>
+    ///     </para>
+    ///     <para>
+    ///         The received terminator must match to the terminator sent by the request.
+    ///     </para>
+    /// </summary>
+    public required string Terminator { get; init; }
+
+    /// <summary>
+    ///     The value expected in the response e.g.
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_ReportTerminalSizeInChars.Value</cref>
+    ///     </see>
+    ///     which will have a 't' as terminator but also other different request may return the same terminator with a
+    ///     different value.
+    /// </summary>
+    public string? Value { get; init; }
+}

Terminal.Gui/ConsoleDrivers/ConsoleDriver.cs

@@ -144,7 +144,7 @@ public void AddRune (Rune rune)
                     // are correctly combined with the base char, but are ALSO treated as 1 column
                     // width codepoints E.g. `echo "[e`u{0301}`u{0301}]"` will output `[é  ]`.
                     // 
-                    // Until this is addressed (see Issue #), we do our best by 
+                    // Until this is addressed (see Issue #), we do our best by
                     // a) Attempting to normalize any CM with the base char to it's left
                     // b) Ignoring any CMs that don't normalize
                     if (Col > 0)
@@ -167,7 +167,7 @@ public void AddRune (Rune rune)
                             if (normalized.Length == 1)
                             {
                                 // It normalized! We can just set the Cell to the left with the
-                                // normalized codepoint 
+                                // normalized codepoint
                                 Contents [Row, Col - 1].Rune = (Rune)normalized [0];
 
                                 // Ignore. Don't move to next column because we're already there
@@ -377,7 +377,7 @@ public void FillRect (Rectangle rect, Rune rune = default)
                 {
                     Contents [r, c] = new Cell
                     {
-                        Rune = (rune != default ? rune : (Rune)' '),
+                        Rune = rune != default ? rune : (Rune)' ',
                         Attribute = CurrentAttribute, IsDirty = true
                     };
                     _dirtyLines! [r] = true;
@@ -608,6 +608,19 @@ 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);
 
+    /// <summary>
+    ///     Provide handling for the terminal write ANSI escape sequence request.
+    /// </summary>
+    /// <param name="ansiRequest">The <see cref="AnsiEscapeSequenceRequest"/> object.</param>
+    /// <returns>The request response.</returns>
+    public abstract string WriteAnsiRequest (AnsiEscapeSequenceRequest ansiRequest);
+
+    /// <summary>
+    ///     Provide proper writing to send escape sequence recognized by the <see cref="ConsoleDriver"/>.
+    /// </summary>
+    /// <param name="ansi"></param>
+    public abstract void WriteRaw (string ansi);
+
     #endregion
 }
 

Terminal.Gui/ConsoleDrivers/ConsoleKeyMapping.cs

@@ -249,7 +249,7 @@ public static ConsoleModifiers MapToConsoleModifiers (KeyCode key)
     {
         var modifiers = new ConsoleModifiers ();
 
-        if (key.HasFlag (KeyCode.ShiftMask))
+        if (key.HasFlag (KeyCode.ShiftMask) || char.IsUpper ((char)key))
         {
             modifiers |= ConsoleModifiers.Shift;
         }
@@ -590,7 +590,8 @@ internal static uint GetKeyCharFromUnicodeChar (
 
                 if (uc != UnicodeCategory.NonSpacingMark && uc != UnicodeCategory.OtherLetter)
                 {
-                    consoleKey = char.ToUpper (stFormD [i]);
+                    char ck = char.ToUpper (stFormD [i]);
+                    consoleKey = (uint)(ck > 0 && ck <= 255 ? char.ToUpper (stFormD [i]) : 0);
                     scode = GetScanCode ("VirtualKey", char.ToUpper (stFormD [i]), 0);
 
                     if (scode is { })
@@ -704,6 +705,32 @@ internal static uint MapKeyCodeToConsoleKey (KeyCode keyValue, out bool isConsol
                 return (uint)ConsoleKey.F24;
             case KeyCode.Tab | KeyCode.ShiftMask:
                 return (uint)ConsoleKey.Tab;
+            case KeyCode.Space:
+                return (uint)ConsoleKey.Spacebar;
+            default:
+                uint c = (char)keyValue;
+
+                if (c is >= (char)ConsoleKey.A and <= (char)ConsoleKey.Z)
+                {
+                    return c;
+                }
+
+                if ((c - 32) is >= (char)ConsoleKey.A and <= (char)ConsoleKey.Z)
+                {
+                    return (c - 32);
+                }
+
+                if (Enum.IsDefined (typeof (ConsoleKey), keyValue.ToString ()))
+                {
+                    return (uint)keyValue;
+                }
+
+                // DEL
+                if ((uint)keyValue == 127)
+                {
+                    return (uint)ConsoleKey.Backspace;
+                }
+                break;
         }
 
         isConsoleKey = false;
@@ -867,6 +894,14 @@ public static KeyCode MapConsoleKeyInfoToKeyCode (ConsoleKeyInfo consoleKeyInfo)
             case ConsoleKey.Tab:
                 keyCode = KeyCode.Tab;
 
+                break;
+            case ConsoleKey.Spacebar:
+                keyCode = KeyCode.Space;
+
+                break;
+            case ConsoleKey.Backspace:
+                keyCode = KeyCode.Backspace;
+
                 break;
             default:
                 if ((int)consoleKeyInfo.KeyChar is >= 1 and <= 26)