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

Terminal.Gui/Application/Application.Run.cs

@@ -1,7 +1,6 @@
 #nullable enable
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
-using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace Terminal.Gui;
 
@@ -522,7 +521,7 @@ public static void LayoutAndDraw (bool forceDraw = false)
 
     /// <summary>The <see cref="MainLoop"/> driver for the application</summary>
     /// <value>The main loop.</value>
-    internal static MainLoop? MainLoop { get; private set; }
+    public static MainLoop? MainLoop { get; private set; }
 
     /// <summary>
     ///     Set to true to cause <see cref="End"/> to be called after the first iteration. Set to false (the default) to

Terminal.Gui/Application/MainLoop.cs

@@ -10,7 +10,7 @@
 namespace Terminal.Gui;
 
 /// <summary>Interface to create a platform specific <see cref="MainLoop"/> driver.</summary>
-internal interface IMainLoopDriver
+public interface IMainLoopDriver
 {
     /// <summary>Must report whether there are any events pending, or even block waiting for events.</summary>
     /// <returns><c>true</c>, if there were pending events, <c>false</c> otherwise.</returns>
@@ -29,14 +29,24 @@ internal interface IMainLoopDriver
 
     /// <summary>Wakes up the <see cref="MainLoop"/> that might be waiting on input, must be thread safe.</summary>
     void Wakeup ();
+
+    /// <summary>
+    ///     Flag <see cref="WaitForInput"/> to force reading input instead of call <see cref="ManualResetEventSlim.Wait ()"/>.
+    /// </summary>
+    bool ForceRead { get; set; }
+
+    /// <summary>
+    ///     Switch for waiting for input or signaled to resume.
+    /// </summary>
+    ManualResetEventSlim WaitForInput { get; set; }
 }
 
 /// <summary>The MainLoop monitors timers and idle handlers.</summary>
 /// <remarks>
 ///     Monitoring of file descriptors is only available on Unix, there does not seem to be a way of supporting this
 ///     on Windows.
 /// </remarks>
-internal class MainLoop : IDisposable
+public class MainLoop : IDisposable
 {
     internal List<Func<bool>> _idleHandlers = new ();
     internal SortedList<long, Timeout> _timeouts = new ();
@@ -72,7 +82,7 @@ internal ReadOnlyCollection<Func<bool>> IdleHandlers
 
     /// <summary>The current <see cref="IMainLoopDriver"/> in use.</summary>
     /// <value>The main loop driver.</value>
-    internal IMainLoopDriver MainLoopDriver { get; private set; }
+    public IMainLoopDriver MainLoopDriver { get; private set; }
 
     /// <summary>Used for unit tests.</summary>
     internal bool Running { get; set; }
@@ -130,10 +140,7 @@ internal Func<bool> AddIdle (Func<bool> idleHandler)
     /// </remarks>
     internal object AddTimeout (TimeSpan time, Func<bool> callback)
     {
-        if (callback is null)
-        {
-            throw new ArgumentNullException (nameof (callback));
-        }
+        ArgumentNullException.ThrowIfNull (callback);
 
         var timeout = new Timeout { Span = time, Callback = callback };
         AddTimeout (time, timeout);
@@ -156,7 +163,7 @@ internal bool CheckTimersAndIdleHandlers (out int waitTimeout)
 
         waitTimeout = 0;
 
-        lock (_timeouts)
+        lock (_timeoutsLockToken)
         {
             if (_timeouts.Count > 0)
             {
@@ -262,7 +269,7 @@ internal void Run ()
     /// </remarks>
     internal void RunIteration ()
     {
-        lock (_timeouts)
+        lock (_timeoutsLockToken)
         {
             if (_timeouts.Count > 0)
             {
@@ -272,7 +279,7 @@ internal void RunIteration ()
 
         MainLoopDriver.Iteration ();
 
-        var runIdle = false;
+        bool runIdle;
 
         lock (_idleHandlersLock)
         {

Terminal.Gui/ConsoleDrivers/AnsiEscapeSequence/AnsiEscapeSequenceRequest.cs

@@ -0,0 +1,126 @@
+#nullable enable
+namespace Terminal.Gui;
+
+/// <summary>
+///     Describes an ongoing ANSI request sent to the console.
+///     Send a request using <see cref="ConsoleDriver.TryWriteAnsiRequest"/> which will return the response.
+/// </summary>
+public class AnsiEscapeSequenceRequest
+{
+    internal readonly object _responseLock = new (); // Per-instance lock
+
+    /// <summary>
+    ///     Gets the response received from the request.
+    /// </summary>
+    public AnsiEscapeSequenceResponse? AnsiEscapeSequenceResponse { get; internal set; }
+
+    /// <summary>
+    ///     The value expected in the response after the CSI e.g.
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_ReportTerminalSizeInChars.Value</cref>
+    ///     </see>
+    ///     should result in a response of the form <c>ESC [ 8 ; height ; width t</c>. In this case,
+    ///     <see cref="ExpectedResponseValue"/>
+    ///     will be <c>"8"</c>.
+    /// </summary>
+    public string? ExpectedResponseValue { get; init; }
+
+    /// <summary>
+    ///     Gets the request string to send e.g. see
+    ///     <see>
+    ///         <cref>EscSeqUtils.CSI_SendDeviceAttributes.Request</cref>
+    ///     </see>
+    /// </summary>
+    public required string Request { get; init; }
+
+    /// <summary>
+    ///     <para>
+    ///         Gets the terminator that uniquely identifies the response received from
+    ///         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; }
+
+    internal void RaiseResponseFromInput (string? response, AnsiEscapeSequenceRequest? request)
+    {
+        ProcessResponse (response, request);
+
+        ResponseFromInput?.Invoke (this, AnsiEscapeSequenceResponse);
+    }
+
+    /// <summary>
+    ///     Raised with the response object and validation.
+    /// </summary>
+    internal event EventHandler<AnsiEscapeSequenceResponse?>? ResponseFromInput;
+
+    /// <summary>
+    ///     Process the <see cref="AnsiEscapeSequenceResponse"/> of an ANSI escape sequence request.
+    /// </summary>
+    /// <param name="response">The response.</param>
+    private void ProcessResponse (string? response, AnsiEscapeSequenceRequest? request)
+    {
+        var error = new StringBuilder ();
+        var values = new string? [] { null };
+
+        try
+        {
+            if (!string.IsNullOrEmpty (response) && !response.StartsWith (AnsiEscapeSequenceRequestUtils.KeyEsc))
+            {
+                throw new InvalidOperationException ($"Invalid Response: {response}");
+            }
+
+            if (string.IsNullOrEmpty (Terminator))
+            {
+                throw new InvalidOperationException ("Terminator request is empty.");
+            }
+
+            if (string.IsNullOrEmpty (response))
+            {
+                throw new InvalidOperationException ("Response request is null.");
+            }
+
+            if (!string.IsNullOrEmpty (response) && !response.EndsWith (Terminator [^1]))
+            {
+                string resp = string.IsNullOrEmpty (response) ? "" : response.Last ().ToString ();
+
+                throw new InvalidOperationException ($"Terminator ends with '{resp}'\nand doesn't end with: '{Terminator [^1]}'");
+            }
+        }
+        catch (Exception ex)
+        {
+            error.AppendLine ($"Error executing ANSI request:\n{ex.Message}");
+        }
+        finally
+        {
+            if (string.IsNullOrEmpty (error.ToString ()))
+            {
+                (string? _, string? _, values, string? _) = AnsiEscapeSequenceRequestUtils.GetEscapeResult (response?.ToCharArray ());
+            }
+
+            if (request is { } && !string.IsNullOrEmpty (request.ExpectedResponseValue) && request.ExpectedResponseValue != values [0])
+            {
+                error.AppendLine ($"Error executing ANSI request:\nValue ends with '{values [0]}'\nand doesn't end with: '{ExpectedResponseValue! [^1]}'");
+            }
+        }
+
+        AnsiEscapeSequenceResponse = new ()
+        {
+            Response = response, Error = error.ToString (),
+            Terminator = string.IsNullOrEmpty (response) ? "" : response [^1].ToString (),
+            ExpectedResponseValue = values [0],
+            Valid = string.IsNullOrWhiteSpace (error.ToString ()) && !string.IsNullOrWhiteSpace (response)
+        };
+    }
+}

Terminal.Gui/ConsoleDrivers/AnsiEscapeSequence/AnsiEscapeSequenceRequestStatus.cs

@@ -0,0 +1,17 @@
+#nullable enable
+namespace Terminal.Gui;
+
+/// <summary>
+///     Represents the status of an ANSI escape sequence request made to the terminal using
+///     <see cref="AnsiEscapeSequenceRequests"/>.
+/// </summary>
+/// <remarks></remarks>
+public class AnsiEscapeSequenceRequestStatus
+{
+    /// <summary>Creates a new state of escape sequence request.</summary>
+    /// <param name="ansiRequest">The <see cref="AnsiEscapeSequenceRequest"/> object.</param>
+    public AnsiEscapeSequenceRequestStatus (AnsiEscapeSequenceRequest ansiRequest) { AnsiRequest = ansiRequest; }
+
+    /// <summary>Gets the Escape Sequence Terminator (e.g. ESC[8t ... t is the terminator).</summary>
+    public AnsiEscapeSequenceRequest AnsiRequest { get; }
+}