Alternative IAnsiConsole implementations

[NeilMacMullen]

I have an application that exists in both a "pure" CLI form and a more capable UI version that contains an "embedded" console which is actually just a WPF TextBox. In the future I might want to also create a Blazor version where the "console" is some kind of web control.

I currently solve this by creating a simple abstraction layer around System.Console. This is fine for basic text I/O with some coloring but since one of the main functions of the app is to output tabular data it would be really nice to use the Spectre rendering system.

So what I'm wondering is whether it's practical to create an IAnsiConsole implementation that sits on top of a WPF TextBox or similar control. I took a quick look at the interface and it seems to depend on a number of fairly complex types so it's a bit unclear what the minimum possible implementation would be and whether I'd have to provide (for example) some mapping system between VT100-style escape sequences and color-control commands for my target or whether these can be intercepted at some higher logical layer.

Anyway, would be interested to hear from anyone who's tried this or managed some kind of implementation... :-)

[FrankRay78]

Interesting question.... I started looking into IAnsiConsole and quickly came across the complexity you describe.

However, I see there are three implementations of it, namely:

Each are interesting, but the Recorder and TestConsole look to me like very good examples of the extensibility you are seeking.

TestConsole effectively shows how to instantiate your own internal console, see:

        _console = AnsiConsole.Create(new AnsiConsoleSettings
        {
            Ansi = AnsiSupport.Yes,
            ColorSystem = (ColorSystemSupport)ColorSystem.TrueColor,
            Out = new AnsiConsoleOutput(_writer),
            Interactive = InteractionSupport.No,
            ExclusivityMode = new NoopExclusivityMode(),
            Enrichment = new ProfileEnrichment
            {
                UseDefaultEnrichers = false,
            },
        });

which is used to fulfill many of the IAnsiConsole required interface members, and Recorder shows how to override the Write method:

    public void Write(IRenderable renderable)
    {
        if (renderable is null)
        {
            throw new ArgumentNullException(nameof(renderable));
        }

        _recorded.Add(renderable);

        _console.Write(renderable);
    }

Perhaps you could use these patterns to redirect the Write() call to your intended 'console', eg:

    public void Write(IRenderable renderable)
    {
        //_console.Write(renderable);  //nb. _console instantiated above in the call to AnsiConsole.Create()
        //or
        //WPFConsole.Write(renderable);
        //or
        //BlazorWPFConsole.Write(renderable);
    }

I'd be interested in seeing how you might get on with this.

[NeilMacMullen]

Thanks @FrankRay78 - that's great info. It looks the key bit after that is understanding IRenderable. It looks like the thing to do is use the IRenderable.Render method to emit a set of Segments. Segments get you Style+Text so I can see how this could work for basic rendering. May see if I can knock up a quick prototype later and post back here.

[FrankRay78]

We've been discussing opening up a community namespace, something like 'spectre.Console.Community'. So in the fullness of time, the idea of community maintained 'IAnsiConsole' implementations is a worthy idea.

[NeilMacMullen]

Basic proof of concept - doesn't implement IAnsiConsole since that has quite a bit of "hair" but allows IRenderables to be displayed

//Declare we can support 24 bit color and unicode but nothing else
public class BasicCapabilities : IReadOnlyCapabilities
{
    public ColorSystem ColorSystem => ColorSystem.TrueColor;
    public bool Unicode => true;
    public bool Ansi => false;
    public bool Links => false;
    public bool Legacy => false;
    public bool IsTerminal => false;
    public bool Interactive => false;
}
//simple renderer for WPF richtextbox (fixed size, no decorations)
public class WpfRenderer
{
    private readonly RenderOptions _options;
    private readonly RichTextBox _textBox;

    public WpfRenderer(RichTextBox textBox)
    {
        _textBox = textBox;
        var consoleSize = new Size(80, 40); //HACK: hardcoded size for now
        _options = new RenderOptions(new BasicCapabilities(), consoleSize);
    }

    public void Clear(bool home)
    {
        _textBox.Document.Blocks.Clear();
    }


    public void Write(IRenderable element)
    {
        _textBox.Document.LineHeight = 1;
        foreach (var segment in element.Render(_options, _options.ConsoleSize.Width))
        {
            var style = segment.Style;
            AppendText(_textBox, segment.Text,
                BrushFromSpectreColor(style.Foreground, _textBox.Foreground),
                BrushFromSpectreColor(style.Background, _textBox.Background)
                //TODO - could take account of text styling here
            );
        }
    }

    private static Brush BrushFromSpectreColor(Spectre.Console.Color col, Brush fallback)
        => col == Spectre.Console.Color.Default ? fallback : new SolidColorBrush(Color.FromRgb(col.R, col.G, col.B));

    private static void AppendText(RichTextBox box, string text, Brush foreground, Brush background)
    {
        var tr = new TextRange(box.Document.ContentEnd, box.Document.ContentEnd)
        {
            Text = text
        };

        tr.ApplyPropertyValue(TextElement.ForegroundProperty, foreground);
        tr.ApplyPropertyValue(TextElement.BackgroundProperty, background);
    }
}

Usage.:

  private void TestButtonClicked(object sender, RoutedEventArgs e)
  {
      var c = new WpfRenderer(theRichTextBox);
      c.Clear(true);

      c.Write(new Markup("[green]Here's some basic text\r\n[/]"));
      c.Write(new Markup("Here's some styled text\r\n",
          new Style(Spectre.Console.Color.White  , Spectre.Console.Color.Blue)));
      var table = new Table();
      table.AddColumn("First");
      table.AddColumn("Second");
      table.Rows.Add([new Markup("[green]good data[/]"), new Markup("[red]bad data[/]")]);
      c.Write(table);
  }

Display:

[FrankRay78]

That's frigging awesome.

[NeilMacMullen]

I did get an IAnsiConsole implementation working which has the advantage that all the nice .WriteLine ,.MarkupInterpolated etc extensions then work. However, I had to create a lot of "NoOp" classes to cover the required properties in the IAnsiConsole interface. I may be misunderstanding things but most of these properties seem to be there to support the advanced 'live' rendering that involves moving the cursor around. Would it make sense to introduce an IRenderTarget (or similar) interface to allow for different targets in the case of "static" rendering? I'm thinking something like...

interface IRenderTarget {
  RenderOptions Options {get;}
  void Clear(bool home);
  void Write(Segment segment);
  void Write(IRenderable renderable) {foreach (var segment in renderable) Write(segment);}
}

IAnsiConsole could then even inherit from this. The "basic" IAnsiConsole extensions could then be retargeted to this interface?

Anyway, as I say quite possibly I'm missing something but exposing this layer would make it easier to implement different target surfaces.

[patriksvensson]

Sorry, I don't really understand what that interface would do that IAnsiConsole isn't already doing.
Interactivity (moving the cursor around) is performed if the console is marked as interactive and supports ANSI sequences. Are you looking for a simpler interface to implement?

[NeilMacMullen]

Are you looking for a simpler interface to implement?

Yes, that's exactly it. At the moment implementing IAnsiConsole for something that is just a simple render target requires also creating empty NoOp implementations for IAnsiConsoleCursor, IExclusivityMode, IAnsiConsoleInput, and a couple of other things (IIRC) required to satisfy those interfaces. Since there's no interface "below" IAnsiConsole I have to use it in order to get the nice "Markup and "Write" extension methods. Clearly it's possible, just seems like lower-level interface would make it easier to substitute alternative render surfaces.

Edit Also, passing IAnsiConsole around inside my application feels a bit misleading since it suggests the implementation might support some of the advanced features whereas a more restricted interface makes it clear that this is only a way of rendering simple output.

[patriksvensson]

Yeah, I'm sorry, but we won't support your scenario out of the box. We've added the extensibility points if the community wants to create something niche, but it's not one of our goals to provide implementations for them outside this project's scope.

Anyway, below is an implementation that you can use if you want something simpler.
Just inherit from SimpleConsole, and you should be good to go.

public abstract class SimpleConsole : IAnsiConsole
{
    public Profile Profile { get; }
    public IAnsiConsoleCursor Cursor { get; }
    public IAnsiConsoleInput Input { get; }
    public IExclusivityMode ExclusivityMode { get; }
    public RenderPipeline Pipeline { get; }

    public int Width { get; set; } = 80;
    public int Height { get; set; } = 25;

    public SimpleConsole()
    {
        var writer = new NoopWriter();
        var output = new SimpleOutput(writer, () => Width, () => Height);

        Profile = new Profile(output, Encoding.Unicode)
        {
            Capabilities =
            {
                ColorSystem = ColorSystem.TrueColor,
                Unicode = true,
                Ansi = false,
                Links = false,
                Legacy = false,
                Interactive = false,
                AlternateBuffer = false
            },
        };

        Cursor = new NoopConsoleCursor();
        Input = new NoopConsoleInput();
        ExclusivityMode = new ExclusivityMode();
        Pipeline = new RenderPipeline();
    }

    public abstract void Clear(bool home);
    public abstract void Write(IRenderable renderable);
}

public sealed class NoopWriter : TextWriter
{
    public override Encoding Encoding { get; } = Encoding.Unicode;
}

public sealed class SimpleOutput : IAnsiConsoleOutput
{
    private readonly Func<int> _width;
    private readonly Func<int> _height;
    
    public TextWriter Writer { get; }
    public bool IsTerminal { get; } = true;
    public int Width => _width();
    public int Height => _height();

    public SimpleOutput(NoopWriter writer, Func<int> width, Func<int> height)
    {
        _width = width ?? throw new ArgumentNullException(nameof(width));
        _height = height ?? throw new ArgumentNullException(nameof(height));

        Writer = writer;
    }
    
    public void SetEncoding(Encoding encoding)
    {
    }
}

internal sealed class NoopConsoleCursor : IAnsiConsoleCursor
{
    public void Show(bool show)
    {
    }

    public void SetPosition(int column, int line)
    {
    }

    public void Move(CursorDirection direction, int steps)
    {
    }
}

internal sealed class NoopConsoleInput : IAnsiConsoleInput
{
    public bool IsKeyAvailable()
    {
        return false;
    }

    public ConsoleKeyInfo? ReadKey(bool intercept)
    {
        return null;
    }

    public Task<ConsoleKeyInfo?> ReadKeyAsync(bool intercept, CancellationToken cancellationToken)
    {
        return Task.FromResult<ConsoleKeyInfo?>(null);
    }
}

internal sealed class ExclusivityMode : IExclusivityMode
{
    public T Run<T>(Func<T> func)
    {
        return func();
    }

    public Task<T> RunAsync<T>(Func<Task<T>> func)
    {
        return func();
    }
}

[NeilMacMullen]

Thanks. Yes this is pretty much where I got to yesterday so good to know I didn't miss a trick :-)