UICatalog scenario to open another scenario process and return some result

Author: BDisp

Examples/UICatalog/Scenarios/OpenProcess/OpenChildInAnotherProcess.cs

@@ -0,0 +1,74 @@
+#nullable enable
+
+using System.Diagnostics;
+using System.IO.Pipes;
+using System.Text.Json;
+
+namespace UICatalog.Scenarios;
+
+[ScenarioMetadata ("OpenChildInAnotherProcess", "Open Child In Another Process")]
+[ScenarioCategory ("Application")]
+public sealed class OpenChildInAnotherProcess : Scenario
+{
+    public override void Main ()
+    {
+        IApplication app = Application.Create ();
+
+        app.Init ();
+
+        // Setup - Create a top-level application window and configure it.
+        Window appWindow = new ()
+        {
+            Title = GetQuitKeyAndName (),
+            BorderStyle = LineStyle.None
+        };
+
+        var label = new Label { X = Pos.Center (), Y = 3 };
+
+        var button = new Button ()
+        {
+            X = Pos.Center (),
+            Y = 1,
+            Title = "_Open Child In Another Process",
+        };
+
+        button.Accepting += async (_, e) =>
+                            {
+                                // When Accepting is handled, set e.Handled to true to prevent further processing.
+                                button.Enabled = false;
+                                e.Handled = true;
+                                label.Text = await OpenNewTerminalWindowAsync<string> ("EditName");
+                                button.Enabled = true;
+                            };
+
+        appWindow.Add (button, label);
+
+        app.Run (appWindow);
+        appWindow.Dispose ();
+
+        app.Shutdown ();
+    }
+
+    public async Task<T> OpenNewTerminalWindowAsync<T> (string action)
+    {
+        string pipeName = "RunChildProcess";
+
+        // Start named pipe server before launching child
+        var server = new NamedPipeServerStream (pipeName, PipeDirection.In);
+
+        // Launch external console process running UICatalog app again
+        var p = new Process ();
+        p.StartInfo.FileName = Environment.ProcessPath!;
+        p.StartInfo.Arguments = $"{pipeName} --child --action \"{action}\"";
+        p.StartInfo.UseShellExecute = true;     // Needed so it opens a new terminal window
+        p.Start ();
+
+        // Wait for connection from child
+        await server.WaitForConnectionAsync ();
+
+        using var reader = new StreamReader (server);
+        string json = await reader.ReadToEndAsync ();
+
+        return JsonSerializer.Deserialize<T> (json)!;
+    }
+}

Examples/UICatalog/Scenarios/OpenProcess/RunChildProcess.cs

@@ -0,0 +1,74 @@
+#nullable enable
+
+using System.IO.Pipes;
+using System.Text.Json;
+
+namespace UICatalog.Scenarios;
+
+[ScenarioMetadata ("RunChildProcess", "Run Child Process from Open Child In Another Process")]
+[ScenarioCategory ("Application")]
+public sealed class RunChildProcess : Scenario
+{
+    public static async Task RunChildAsync (string pipeName, string action)
+    {
+        // Run your Terminal.Gui UI
+        object result = await RunMyDialogAsync (action);
+
+        // Send result back
+        await using var client = new NamedPipeClientStream (".", pipeName, PipeDirection.Out);
+        await client.ConnectAsync ();
+
+        string json = JsonSerializer.Serialize (result);
+        await using var writer = new StreamWriter (client);
+        await writer.WriteAsync (json);
+        await writer.FlushAsync ();
+    }
+
+    public static Task<string> RunMyDialogAsync (string action)
+    {
+        TaskCompletionSource<string> tcs = new ();
+        string? result = null;
+
+        IApplication app = Application.Create ();
+
+        app.Init ();
+
+        var win = new Window ()
+        {
+            Width = Dim.Fill (),
+            Height = Dim.Fill (),
+            Title = $"Child Window: {action}"
+        };
+
+        var input = new TextField
+        {
+            X = 1,
+            Y = 1,
+            Width = 30
+        };
+
+        var ok = new Button
+        {
+            X = 1,
+            Y = 3,
+            Text = "Ok",
+            IsDefault = true
+        };
+        ok.Accepting += (_, e) =>
+                      {
+                          result = input.Text;
+                          app.RequestStop ();
+                          e.Handled = true;
+                      };
+
+        win.Add (input, ok);
+
+        app.Run (win);
+        win.Dispose ();
+        app.Shutdown ();
+
+        tcs.SetResult (result ?? string.Empty);
+
+        return tcs.Task;
+    }
+}

Examples/UICatalog/UICatalog.cs

@@ -25,6 +25,7 @@
 using Serilog;
 using Serilog.Core;
 using Serilog.Events;
+using UICatalog.Scenarios;
 using Command = Terminal.Gui.Input.Command;
 using ILogger = Microsoft.Extensions.Logging.ILogger;
 
@@ -141,9 +142,18 @@ private static int Main (string [] args)
                                                                                           .ToArray ()
                                                                              );
 
+        Option<bool> childOption = new ("--child", "Run in child mode");
+
+        Option<string> actionOption = new (
+                                            name: "--action",
+                                            description: "Optional action for child window",
+                                            getDefaultValue: () => string.Empty
+                                           );
+
         var rootCommand = new RootCommand ("A comprehensive sample library and test app for Terminal.Gui")
         {
-            scenarioArgument, debugLogLevel, benchmarkFlag, benchmarkTimeout, resultsFile, driverOption, disableConfigManagement
+            scenarioArgument, debugLogLevel, benchmarkFlag, benchmarkTimeout, resultsFile, driverOption, disableConfigManagement,
+            childOption, actionOption
         };
 
         rootCommand.SetHandler (
@@ -157,7 +167,9 @@ private static int Main (string [] args)
                                         Benchmark = context.ParseResult.GetValueForOption (benchmarkFlag),
                                         BenchmarkTimeout = context.ParseResult.GetValueForOption (benchmarkTimeout),
                                         ResultsFile = context.ParseResult.GetValueForOption (resultsFile) ?? string.Empty,
-                                        DebugLogLevel = context.ParseResult.GetValueForOption (debugLogLevel) ?? "Warning"
+                                        DebugLogLevel = context.ParseResult.GetValueForOption (debugLogLevel) ?? "Warning",
+                                        IsChild = context.ParseResult.GetValueForOption (childOption),
+                                        Action = context.ParseResult.GetValueForOption (actionOption) ?? string.Empty
                                         /* etc. */
                                     };
 
@@ -380,6 +392,13 @@ private static void UICatalogMain (UICatalogCommandLineOptions options)
                                                                   )!);
             UICatalogTop.CachedSelectedScenario = (Scenario)Activator.CreateInstance (UICatalogTop.CachedScenarios [item].GetType ())!;
 
+            if (options.IsChild)
+            {
+                Task.Run (async () => await RunChildProcess.RunChildAsync (UICatalogTop.CachedSelectedScenario.GetName (), options.Action)).Wait ();
+
+                return;
+            }
+
             BenchmarkResults? results = RunScenario (UICatalogTop.CachedSelectedScenario, options.Benchmark);
 
             if (results is { })

Examples/UICatalog/UICatalogCommandLineOptions.cs

@@ -16,5 +16,9 @@ public struct UICatalogCommandLineOptions
     public string ResultsFile { get; set; }
 
     public string DebugLogLevel { get; set; }
+
+    public bool IsChild { get; set; }
+
+    public string Action { get; set; }
     /* etc. */
 }