Live preview while editing AXAML files

src/Consolonia.Core/Assembly.cs

@@ -2,5 +2,6 @@
 using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("Consolonia.Core.Tests")]
+[assembly: InternalsVisibleTo("Consolonia.Designer")]
 
 [assembly: CLSCompliant(false)] //todo: should we make it compliant?

src/Consolonia.Core/Consolonia.Core.csproj

@@ -3,12 +3,12 @@
 
     <ItemGroup>
         <PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
-        <PackageReference Include="Avalonia.FreeDesktop" Version="$(AvaloniaVersion)" />
+        <PackageReference Include="Avalonia.ReactiveUI" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Skia" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Controls.DataGrid" Version="$(AvaloniaVersion)" />
-        <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.8" />
         <PackageReference Include="Unicode.net" Version="2.0.0" />
         <PackageReference Include="Wcwidth" Version="2.0.0" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     </ItemGroup>
 
 </Project>

src/Consolonia.Core/Drawing/DrawingContextImpl.cs

@@ -34,11 +34,11 @@
         private readonly Matrix _postTransform = Matrix.Identity;
         private Matrix _transform = Matrix.Identity;
 
-        public DrawingContextImpl(ConsoleWindow consoleWindow, PixelBuffer pixelBuffer)
+        public DrawingContextImpl(ConsoleWindow consoleWindow)
         {
             _consoleWindow = consoleWindow;
-            _pixelBuffer = pixelBuffer;
-            _clipStack.Push(pixelBuffer.Size);
+            _pixelBuffer = consoleWindow.PixelBuffer;
+            _clipStack.Push(_pixelBuffer.Size);
         }
 
         private Rect CurrentClip => _clipStack.Peek();
@@ -101,7 +101,7 @@
                     () =>
                     {
                         _pixelBuffer.Set(new PixelBufferCoordinate((ushort)px, (ushort)py),
-                            (existingPixel, _) => existingPixel.Blend(imagePixel), imagePixel.Background.Color);
+                            existingPixel => existingPixel.Blend(imagePixel));
                     });
             }
         }
@@ -175,8 +175,8 @@
                     CurrentClip.ExecuteWithClipping(new Point(px, py), () =>
                     {
                         _pixelBuffer.Set(new PixelBufferCoordinate((ushort)px, (ushort)py),
-                            (pixel, bb) => pixel.Blend(new Pixel(new PixelBackground(bb.Mode, bb.Color))),
-                            backgroundBrush);
+                            pixel => pixel.Blend(new Pixel(new PixelBackground(backgroundBrush.Mode,
+                                backgroundBrush.Color))));
                     });
                 }
             }
@@ -210,7 +210,8 @@
                 return;
             }
 
-            var shapedBuffer = (ShapedBuffer)glyphRunImpl.GlyphInfos;
+            var shapedBuffer = glyphRunImpl.GlyphInfos as ShapedBuffer;
+            ArgumentNullException.ThrowIfNull(shapedBuffer);
             string text = shapedBuffer.Text.ToString();
             DrawStringInternal(foreground, text, glyphRun.GlyphTypeface);
         }
@@ -303,39 +304,29 @@
         {
             if (pen.Thickness == 0) return;
 
-            line = TransformLineInternal(line);
-
-            Point head = line.PStart;
-            if (pen.Brush is MoveConsoleCaretToPositionBrush)
+            if (pen.Thickness == UnderlineThickness || pen.Thickness == StrikethroughThickness)
             {
-                CurrentClip.ExecuteWithClipping(head,
-                    () => { _pixelBuffer.Set((PixelBufferCoordinate)head, pixel => pixel.Blend(new Pixel(true))); });
-                return;
-            }
+                if (line.Vertical)
+                    throw new NotSupportedException("Vertical strikethrough or underline text decorations is not supported.");
 
-            if (line.Vertical == false && pen.Thickness > 1)
-            {
                 // horizontal lines with thickness larger than one are text decorations
-                ApplyTextDecorationLineInternal(ref head, pen, line);
+                ApplyTextDecorationLineInternal(pen, line);
                 return;
             }
 
-            var extractColorCheckPlatformSupported = ExtractColorOrNullWithPlatformCheck(pen, out var lineStyle);
-            if (extractColorCheckPlatformSupported == null)
-                return;
-
-            var color = (Color)extractColorCheckPlatformSupported;
-
-            byte pattern = (byte)(line.Vertical ? 0b1010 : 0b0101);
-            DrawPixelAndMoveHead(ref head, line, lineStyle, pattern, color, line.Length); //line
+            DrawRectangleLineInternal(pen, line);
         }
 
-        private void ApplyTextDecorationLineInternal(ref Point head, IPen pen, Line line)
+        private void ApplyTextDecorationLineInternal(IPen pen, Line line)
         {
-            TextDecorationCollection textDecoration = pen.Thickness switch
+            line = TransformLineInternal(line);
+
+            Point head = line.PStart;
+
+            TextDecorationLocation textDecoration = pen.Thickness switch
             {
-                UnderlineThickness => TextDecorations.Underline,
-                StrikethroughThickness => TextDecorations.Strikethrough,
+                UnderlineThickness => TextDecorationLocation.Underline,
+                StrikethroughThickness => TextDecorationLocation.Strikethrough,
                 _ => throw new ArgumentOutOfRangeException($"Unsupported thickness {pen.Thickness}")
             };
 
@@ -517,7 +508,7 @@
                             CurrentClip.ExecuteWithClipping(newCharacterPoint, () =>
                             {
                                 _pixelBuffer.Set((PixelBufferCoordinate)newCharacterPoint,
-                                    (oldPixel, cp) => oldPixel.Blend(cp), consolePixel);
+                                    oldPixel => oldPixel.Blend(consolePixel));
                             });
                         }
 
@@ -533,17 +524,63 @@
                     default:
                     {
                         var symbol = new SimpleSymbol(glyph);
-                        var consolePixel = new Pixel(symbol, foregroundColor, typeface.Style, typeface.Weight);
+                        // if we are attempting to draw a wide glyph we need to make sure that the clipping point
+                        // is for the last physical char. Aka a double char should be clipped if it's second rendered 
+                        // char would break the boundary of the clip.
+                        // var clippingPoint = new Point(characterPoint.X + symbol.Width - 1, characterPoint.Y);
+                        var newPixel = new Pixel(symbol, foregroundColor, typeface.Style, typeface.Weight);
                         CurrentClip.ExecuteWithClipping(characterPoint, () =>
                         {
                             _pixelBuffer.Set((PixelBufferCoordinate)characterPoint,
-                                (oldPixel, cp) => oldPixel.Blend(cp), consolePixel);
+                                oldPixel =>
+                                {
+                                    if (oldPixel.Width == 0)
+                                    {
+                                        // if the oldPixel was empty, we need to set the previous pixel to space
+                                        double targetX = characterPoint.X - 1;
+                                        if (targetX >= 0)
+                                            _pixelBuffer.Set(
+                                                (PixelBufferCoordinate)new Point(targetX, characterPoint.Y),
+                                                oldPixel2 =>
+                                                    new Pixel(
+                                                        new PixelForeground(new SimpleSymbol(' '), Colors.Transparent),
+                                                        oldPixel2.Background));
+                                    }
+                                    else if (oldPixel.Width > 1)
+                                    {
+                                        // if oldPixel was wide we need to reset overlapped symbols from empty to space
+                                        for (ushort i = 1; i < oldPixel.Width; i++)
+                                        {
+                                            double targetX = characterPoint.X + i;
+                                            if (targetX < _pixelBuffer.Size.Width)
+                                                _pixelBuffer.Set(
+                                                    (PixelBufferCoordinate)new Point(targetX, characterPoint.Y),
+                                                    oldPixel2 =>
+                                                        new Pixel(
+                                                            new PixelForeground(new SimpleSymbol(' '),
+                                                                Colors.Transparent), oldPixel2.Background));
+                                        }
+                                    }
+
+                                    // if the pixel was a wide character, we need to set the overlapped pixels to empty pixels.
+                                    if (newPixel.Width > 1)
+                                        for (int i = 1; i < symbol.Width; i++)
+                                        {
+                                            double targetX = characterPoint.X + i;
+                                            if (targetX < _pixelBuffer.Size.Width)
+                                                _pixelBuffer.Set(
+                                                    (PixelBufferCoordinate)new Point(targetX, characterPoint.Y),
+                                                    oldPixel2 =>
+                                                        new Pixel(
+                                                            new PixelForeground(new SimpleSymbol(), Colors.Transparent),
+                                                            oldPixel2.Background));
+                                        }
+
+                                    return oldPixel.Blend(newPixel);
+                                });
                         });
 
-                        if (symbol.Width > 1)
-                            currentXPosition += symbol.Width;
-                        else
-                            currentXPosition++;
+                        currentXPosition += symbol.Width;
                     }
                         break;
                 }

src/Consolonia.Core/Drawing/PixelBufferImplementation/ColorConverter.cs

@@ -0,0 +1,22 @@
+using System;
+using Avalonia.Media;
+using Newtonsoft.Json;
+
+namespace Consolonia.Core.Drawing.PixelBufferImplementation
+{
+    public class ColorConverter : JsonConverter<Color>
+    {
+        public override Color ReadJson(JsonReader reader, Type objectType, Color existingValue, bool hasExistingValue,
+            JsonSerializer serializer)
+        {
+            if (Color.TryParse(reader.Value!.ToString(), out Color color))
+                return color;
+            return Colors.Transparent;
+        }
+
+        public override void WriteJson(JsonWriter writer, Color value, JsonSerializer serializer)
+        {
+            writer.WriteValue(value!.ToString());
+        }
+    }
+}

src/Consolonia.Core/Drawing/PixelBufferImplementation/DrawingBoxSymbol.cs

@@ -1,29 +1,56 @@
 using System;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Text.Json.Serialization;
 
 namespace Consolonia.Core.Drawing.PixelBufferImplementation
 {
     /// <summary>
     ///     https://en.wikipedia.org/wiki/Box-drawing_character
     /// </summary>
     [DebuggerDisplay("DrawingBox {Text}")]
-    public struct DrawingBoxSymbol : ISymbol, IEquatable<DrawingBoxSymbol>
+    [JsonConverter(typeof(SymbolConverter))]
+    public readonly struct DrawingBoxSymbol : ISymbol, IEquatable<DrawingBoxSymbol>
     {
         // all 0bXXXX_0000 are special values
         private const byte BoldSymbol = 0b0001_0000;
         private const byte EmptySymbol = 0b0;
-        private readonly byte _upRightDownLeft;
 
         public DrawingBoxSymbol(byte upRightDownLeft)
         {
-            _upRightDownLeft = upRightDownLeft;
-            Text = GetBoxSymbol(_upRightDownLeft).ToString();
+            UpRightDownLeft = upRightDownLeft;
+            Text = GetBoxSymbol(UpRightDownLeft).ToString();
         }
 
-        public string Text { get; private init; }
+        public byte UpRightDownLeft { get; init; }
 
-        public ushort Width { get; } = 1;
+        public bool Equals(DrawingBoxSymbol other)
+        {
+            if ((object)other is null) return false;
+            return UpRightDownLeft == other!.UpRightDownLeft;
+        }
+
+        [JsonIgnore] public string Text { get; init; }
+
+        [JsonIgnore] public ushort Width { get; } = 1;
+
+        public bool IsWhiteSpace()
+        {
+            return UpRightDownLeft == EmptySymbol;
+        }
+
+        public ISymbol Blend(ref ISymbol symbolAbove)
+        {
+            if (symbolAbove.IsWhiteSpace()) return this;
+
+            if (symbolAbove is not DrawingBoxSymbol drawingBoxSymbol)
+                return symbolAbove;
+
+            if (drawingBoxSymbol.UpRightDownLeft == BoldSymbol || UpRightDownLeft == BoldSymbol)
+                return new DrawingBoxSymbol(BoldSymbol);
+
+            return new DrawingBoxSymbol((byte)(UpRightDownLeft | drawingBoxSymbol.UpRightDownLeft));
+        }
 
         /// <summary>
         ///     https://en.wikipedia.org/wiki/Code_page_437
@@ -99,24 +126,6 @@
             }
         }
 
-        public bool IsWhiteSpace()
-        {
-            return _upRightDownLeft == EmptySymbol;
-        }
-
-        public ISymbol Blend(ref ISymbol symbolAbove)
-        {
-            if (symbolAbove.IsWhiteSpace()) return this;
-
-            if (symbolAbove is not DrawingBoxSymbol drawingBoxSymbol)
-                return symbolAbove;
-
-            if (drawingBoxSymbol._upRightDownLeft == BoldSymbol || _upRightDownLeft == BoldSymbol)
-                return new DrawingBoxSymbol(BoldSymbol);
-
-            return new DrawingBoxSymbol((byte)(_upRightDownLeft | drawingBoxSymbol._upRightDownLeft));
-        }
-
         public static DrawingBoxSymbol UpRightDownLeftFromPattern(byte pattern, LineStyle lineStyle)
         {
             if (pattern == EmptySymbol) return new DrawingBoxSymbol(EmptySymbol);
@@ -134,19 +143,14 @@
             }
         }
 
-        public bool Equals(DrawingBoxSymbol other)
-        {
-            return _upRightDownLeft == other._upRightDownLeft;
-        }
-
         public override bool Equals([NotNullWhen(true)] object obj)
         {
             return obj is DrawingBoxSymbol other && Equals(other);
         }
 
         public override int GetHashCode()
         {
-            return _upRightDownLeft.GetHashCode();
+            return UpRightDownLeft.GetHashCode();
         }
 
         public static bool operator ==(DrawingBoxSymbol left, DrawingBoxSymbol right)
@@ -156,7 +160,7 @@
 
         public static bool operator !=(DrawingBoxSymbol left, DrawingBoxSymbol right)
         {
-            return !left.Equals(right);
+            return !left!.Equals(right);
         }
     }
 }

src/Consolonia.Core/Drawing/PixelBufferImplementation/ISymbol.cs

@@ -1,5 +1,8 @@
+using Newtonsoft.Json;
+
 namespace Consolonia.Core.Drawing.PixelBufferImplementation
 {
+    [JsonConverter(typeof(SymbolConverter))]
     public interface ISymbol
     {
         /// <summary>