Bitmap support

src/Consolonia.Core/Consolonia.Core.csproj

@@ -4,9 +4,11 @@
     <ItemGroup>
         <PackageReference Include="Avalonia" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.FreeDesktop" Version="$(AvaloniaVersion)" />
+        <PackageReference Include="Avalonia.Skia" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Avalonia.Controls.DataGrid" Version="$(AvaloniaVersion)" />
         <PackageReference Include="Crayon" Version="2.0.69" />
         <PackageReference Include="NullLib.ConsoleEx" Version="1.0.4.4" />
+        <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.8" />
     </ItemGroup>
 
 </Project>

src/Consolonia.Core/Drawing/BitmapImpl.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Globalization;
+using System.IO;
+using Avalonia;
+using Avalonia.Media.Imaging;
+using Avalonia.Platform;
+using Avalonia.Skia;
+using SkiaSharp;
+
+namespace Consolonia.Core.Drawing
+{
+    internal class BitmapImpl : IWriteableBitmapImpl
+    {
+        public BitmapImpl(int width, int height, PixelFormat format, AlphaFormat? alphaFormat = null)
+        {
+            Bitmap = new SKBitmap(new SKImageInfo(width, height, format.ToSkColorType(),
+                alphaFormat?.ToSkAlphaType() ?? SKAlphaType.Unknown));
+        }
+
+        public BitmapImpl(SKBitmap bitmap)
+        {
+            Bitmap = bitmap;
+        }
+
+        public BitmapImpl(Stream stream)
+        {
+            using var skStream = new SKManagedStream(stream);
+            Bitmap = SKBitmap.Decode(skStream);
+        }
+
+        public BitmapImpl(string fileName)
+        {
+            Bitmap = SKBitmap.Decode(fileName);
+        }
+
+        public SKBitmap Bitmap { get; }
+
+        Vector IBitmapImpl.Dpi => new(96f, 96f);
+
+        public PixelSize PixelSize => new(Bitmap.Width, (int)(Bitmap.Height * .55));
+
+        public int Version => 1;
+
+        public AlphaFormat? AlphaFormat => Bitmap.Info.AlphaType.ToAlphaFormat();
+
+        public PixelFormat? Format => Bitmap.Info.ColorType.ToAvalonia();
+
+        public void Dispose()
+        {
+            Bitmap.Dispose();
+        }
+
+        public void Save(string fileName, int? quality = 100)
+        {
+            SKEncodedImageFormat format = GetFormatFromFileName(fileName);
+            using SKImage image = SKImage.FromBitmap(Bitmap);
+            using SKData data = image.Encode(format, quality ?? 100);
+            using FileStream stream = File.OpenWrite(fileName);
+            data.SaveTo(stream);
+        }
+
+        public void Save(Stream stream, int? quality = 100)
+        {
+            var format = SKEncodedImageFormat.Jpeg;
+            using SKImage image = SKImage.FromBitmap(Bitmap);
+            using SKData data = image.Encode(format, quality ?? 100);
+            data.SaveTo(stream);
+        }
+
+        public ILockedFramebuffer Lock()
+        {
+            throw new NotImplementedException();
+        }
+
+        public IBitmapImpl Resize(PixelSize pixelSize, BitmapInterpolationMode interpolationMode)
+        {
+            var resized = new SKBitmap(pixelSize.Width, pixelSize.Height);
+            using var canvas = new SKCanvas(resized);
+            canvas.DrawBitmap(Bitmap, new SKRect(0, 0, pixelSize.Width, pixelSize.Height),
+                new SKPaint { FilterQuality = interpolationMode.ToSKFilterQuality() });
+            return new BitmapImpl(resized);
+        }
+
+        private static SKEncodedImageFormat GetFormatFromFileName(string fileName)
+        {
+            return Path.GetExtension(fileName).ToUpperInvariant() switch
+            {
+                ".PNG" => SKEncodedImageFormat.Png,
+                ".JPEG" => SKEncodedImageFormat.Jpeg,
+                ".JPG" => SKEncodedImageFormat.Jpeg,
+                ".GIF" => SKEncodedImageFormat.Gif,
+                ".BMP" => SKEncodedImageFormat.Bmp,
+                ".WBMP" => SKEncodedImageFormat.Wbmp,
+                ".WEBP" => SKEncodedImageFormat.Webp,
+                ".ICO" => SKEncodedImageFormat.Ico,
+                _ => throw new ArgumentException($"Unsupported file extension: {fileName}")
+            };
+        }
+    }
+}

src/Consolonia.Core/Drawing/ConsoleBrush.cs

@@ -94,15 +94,15 @@
                 throw new ArgumentOutOfRangeException(nameof(x), "x is out bounds");
             if (y < 0 || y > height)
                 throw new ArgumentOutOfRangeException(nameof(y), "y is out bounds");
-            if (width <= 0)
-                throw new ArgumentOutOfRangeException(nameof(width), "Width must be positive");
-            if (height <= 0)
-                throw new ArgumentOutOfRangeException(nameof(height), "Height must be positive");
 
             switch (brush)
             {
                 case ILinearGradientBrush gradientBrush:
                 {
+                    if (width <= 0)
+                        width = 1;
+                    if (height <= 0)
+                        height = 1;
                     // Calculate the relative position within the gradient
                     double horizontalRelativePosition = (double)x / width;
                     double verticalRelativePosition = (double)y / height;
@@ -138,6 +138,10 @@
                 }
                 case IConicGradientBrush conicBrush:
                 {
+                    if (width <= 0)
+                        width = 1;
+                    if (height <= 0)
+                        height = 1;
                     // Calculate the relative position within the gradient
                     double horizontalRelativePosition = (double)x / width;
                     double verticalRelativePosition = (double)y / height;
@@ -179,7 +183,7 @@
                     break;
                 }
 
             if (before == null && after == null)
                 throw new ArgumentException("no gradientstops defined");
 
             if (before == null) return after.Color;

src/Consolonia.Core/Drawing/ConsoloniaRenderInterface.cs

@@ -7,6 +7,7 @@
 using Avalonia.Media.TextFormatting;
 using Avalonia.Platform;
 using Consolonia.Core.Text;
+using SkiaSharp;
 
 namespace Consolonia.Core.Drawing
 {
@@ -50,75 +51,112 @@
         public IRenderTargetBitmapImpl CreateRenderTargetBitmap(PixelSize size, Vector dpi)
         {
             throw new NotImplementedException();
+            // return new ConsoleRenderTargetBitmapImpl(size, dpi);
         }
 
         public IWriteableBitmapImpl CreateWriteableBitmap(PixelSize size, Vector dpi, PixelFormat format,
             AlphaFormat alphaFormat)
         {
-            throw new NotImplementedException();
+            return new BitmapImpl(size.Width, size.Height, format, alphaFormat);
         }
 
         public IBitmapImpl LoadBitmap(string fileName)
         {
-            throw new NotImplementedException();
+            using (FileStream stream = File.OpenRead(fileName))
+            {
+                return new BitmapImpl(stream);
+            }
         }
 
         public IBitmapImpl LoadBitmap(Stream stream)
         {
-            throw new NotImplementedException();
+            return new BitmapImpl(stream);
         }
 
-        IWriteableBitmapImpl IPlatformRenderInterface.LoadWriteableBitmapToHeight(Stream stream, int height,
+        public IWriteableBitmapImpl LoadWriteableBitmapToHeight(Stream stream, int height,
             BitmapInterpolationMode interpolationMode)
         {
-            throw new NotImplementedException();
+            using (var skStream = new SKManagedStream(stream))
+            {
+                SKBitmap originalBitmap = SKBitmap.Decode(skStream);
+                int width = (int)(height * ((double)originalBitmap.Width / originalBitmap.Height));
+                SKBitmap resizedBitmap =
+                    originalBitmap.Resize(new SKImageInfo(width, height), (SKFilterQuality)interpolationMode);
+                return new BitmapImpl(resizedBitmap);
+            }
         }
 
         public IWriteableBitmapImpl LoadWriteableBitmapToWidth(Stream stream, int width,
             BitmapInterpolationMode interpolationMode = BitmapInterpolationMode.HighQuality)
         {
-            throw new NotImplementedException();
+            using (var skStream = new SKManagedStream(stream))
+            {
+                SKBitmap originalBitmap = SKBitmap.Decode(skStream);
+                int height = (int)(width * ((double)originalBitmap.Height / originalBitmap.Width));
+                SKBitmap resizedBitmap =
+                    originalBitmap.Resize(new SKImageInfo(width, height), (SKFilterQuality)interpolationMode);
+                return new BitmapImpl(resizedBitmap);
+            }
         }
 
         public IWriteableBitmapImpl LoadWriteableBitmap(string fileName)
         {
-            throw new NotImplementedException();
+            using (FileStream stream = File.OpenRead(fileName))
+            {
+                return LoadWriteableBitmap(stream);
+            }
         }
 
         public IWriteableBitmapImpl LoadWriteableBitmap(Stream stream)
         {
-            throw new NotImplementedException();
+            using (var skStream = new SKManagedStream(stream))
+            {
+                SKBitmap originalBitmap = SKBitmap.Decode(skStream);
+                return new BitmapImpl(originalBitmap);
+            }
         }
 
-        IBitmapImpl IPlatformRenderInterface.LoadBitmapToWidth(Stream stream, int width,
-            BitmapInterpolationMode interpolationMode)
+        public IBitmapImpl LoadBitmapToWidth(Stream stream, int width, BitmapInterpolationMode interpolationMode)
         {
-            throw new NotImplementedException();
+            using (var skStream = new SKManagedStream(stream))
+            {
+                SKBitmap originalBitmap = SKBitmap.Decode(skStream);
+                int height = (int)(width * ((double)originalBitmap.Height / originalBitmap.Width));
+                SKBitmap resizedBitmap =
+                    originalBitmap.Resize(new SKImageInfo(width, height), (SKFilterQuality)interpolationMode);
+                return new BitmapImpl(resizedBitmap);
+            }
         }
 
-        IBitmapImpl IPlatformRenderInterface.LoadBitmapToHeight(Stream stream, int height,
-            BitmapInterpolationMode interpolationMode)
+        public IBitmapImpl LoadBitmapToHeight(Stream stream, int height, BitmapInterpolationMode interpolationMode)
         {
-            throw new NotImplementedException();
+            using (var skStream = new SKManagedStream(stream))
+            {
+                SKBitmap originalBitmap = SKBitmap.Decode(skStream);
+                int width = (int)(height * ((double)originalBitmap.Width / originalBitmap.Height));
+                SKBitmap resizedBitmap =
+                    originalBitmap.Resize(new SKImageInfo(width, height), (SKFilterQuality)interpolationMode);
+                return new BitmapImpl(resizedBitmap);
+            }
         }
 
-        IBitmapImpl IPlatformRenderInterface.ResizeBitmap(IBitmapImpl bitmapImpl, PixelSize destinationSize,
+        public IBitmapImpl ResizeBitmap(IBitmapImpl bitmapImpl, PixelSize destinationSize,
             BitmapInterpolationMode interpolationMode)
         {
-            throw new NotImplementedException();
+            var consoleBitmap = (BitmapImpl)bitmapImpl;
+            return consoleBitmap.Resize(destinationSize, interpolationMode);
         }
 
-        public IBitmapImpl LoadBitmap(
-            PixelFormat format,
-            AlphaFormat alphaFormat,
-            IntPtr data,
-            PixelSize size,
-            Vector dpi,
-            int stride)
+        public IBitmapImpl LoadBitmap(PixelFormat format, AlphaFormat alphaFormat, IntPtr data, PixelSize size,
+            Vector dpi, int stride)
         {
-            throw new NotImplementedException();
+            var info = new SKImageInfo(size.Width, size.Height, SKColorType.Rgb888x, SKAlphaType.Opaque);
+            var bitmap = new SKBitmap();
+            bitmap.InstallPixels(info, data, stride);
+            return new BitmapImpl(bitmap);
         }
 
+
         public IGlyphRunImpl CreateGlyphRun(IGlyphTypeface glyphTypeface, double fontRenderingEmSize,
             IReadOnlyList<GlyphInfo> glyphInfos,
             Point baselineOrigin)

src/Consolonia.Core/Drawing/DrawingContextImpl.cs

@@ -9,6 +9,7 @@
 using Consolonia.Core.Infrastructure;
 using Consolonia.Core.InternalHelpers;
 using Consolonia.Core.Text;
+using SkiaSharp;
 
 namespace Consolonia.Core.Drawing
 {
@@ -47,27 +48,33 @@
 
         public void DrawBitmap(IBitmapImpl source, double opacity, Rect sourceRect, Rect destRect)
         {
-            throw new NotImplementedException();
-            /*
-           //  prototype
-            Rect clip = _currentClip.Intersect(destRect);
-           for (int x = 0; x < sourceRect.Width; x++)
-           for (int y = 0; y < sourceRect.Height; y++)
-           {
-               var myRenderTarget = (RenderTarget)source.Item;
-
-               int left = (int)(x + destRect.Left);
-               int top = (int)(y + destRect.Top);
-               clip.ExecuteWithClipping(new Point(left, top), () =>
-               {
-                   _pixelBuffer.Set(new PixelBufferCoordinate((ushort)left, (ushort)top), destPixel =>
-                   {
-                       return destPixel.Blend(
-                           myRenderTarget._bufferBuffer[new PixelBufferCoordinate((ushort)(x + sourceRect.Left),
-                               (ushort)(y + sourceRect.Top))]);
-                   });
-               });
-           }*/
+            // resize bitmap to destination rect size
+            var targetRect = new Rect(Transform.Transform(new Point(destRect.TopLeft.X, destRect.TopLeft.Y)),
+                Transform.Transform(new Point(destRect.BottomRight.X, destRect.BottomRight.Y)));
+            var bmp = (BitmapImpl)source;
+            using var bitmap = new SKBitmap((int)targetRect.Width, (int)targetRect.Height);
+            using var canvas = new SKCanvas(bitmap);
+            canvas.DrawBitmap(bmp.Bitmap, new SKRect(0, 0, (float)targetRect.Width, (float)targetRect.Height),
+                new SKPaint { FilterQuality = SKFilterQuality.Medium });
+
+            // Rect clip = CurrentClip.Intersect(destRect);
+            int width = bitmap.Info.Width;
+            int height = bitmap.Info.Height;
+            for (int x = 0; x < width; x++)
+            for (int y = 0; y < height; y++)
+            {
+                int px = (int)targetRect.TopLeft.X + x;
+                int py = (int)targetRect.TopLeft.Y + y;
+                SKColor skColor = bitmap.GetPixel(x, y);
+                Color color = Color.FromRgb(skColor.Red, skColor.Green, skColor.Blue);
+                var imagePixel = new Pixel('█', color);
+                CurrentClip.ExecuteWithClipping(new Point(px, py),
+                    () =>
+                    {
+                        _pixelBuffer.Set(new PixelBufferCoordinate((ushort)px, (ushort)py),
+                            (existingPixel, _) => existingPixel.Blend(imagePixel), imagePixel.Background.Color);
+                    });
+            }
         }
 
         public void DrawBitmap(IBitmapImpl source, IBrush opacityMask, Rect opacityMaskRect, Rect destRect)
@@ -139,7 +146,7 @@
                     CurrentClip.ExecuteWithClipping(new Point(px, py), () =>
                     {
                         _pixelBuffer.Set(new PixelBufferCoordinate((ushort)px, (ushort)py),
                             (pixel, bb) => { return pixel.Blend(new Pixel(new PixelBackground(bb.Mode, bb.Color))); },
                             backgroundBrush);
                     });
                 }
@@ -357,7 +364,7 @@
                 return;
             }
 
-            if (!Transform.IsTranslateOnly()) ConsoloniaPlatform.RaiseNotSupported(15);
+            //if (!Transform.IsTranslateOnly()) ConsoloniaPlatform.RaiseNotSupported(15);
 
             Point whereToDraw = origin.Transform(Transform);
             int currentXPosition = 0;
@@ -403,11 +410,10 @@
                     {
                         var consolePixel = new Pixel(c, foregroundColor, typeface.Style, typeface.Weight);
                         CurrentClip.ExecuteWithClipping(characterPoint, () =>
-                            {
-                                _pixelBuffer.Set((PixelBufferCoordinate)characterPoint,
-                                    (oldPixel, cp) => oldPixel.Blend(cp), consolePixel);
-                            }
-                        );
+                        {
+                            _pixelBuffer.Set((PixelBufferCoordinate)characterPoint,
+                                (oldPixel, cp) => oldPixel.Blend(cp), consolePixel);
+                        });
                     }
                         break;
                 }

src/Consolonia.Core/Text/GlyphRunImpl.cs

@@ -27,6 +27,7 @@ public void Dispose()
 
         public IReadOnlyList<float> GetIntersections(float lowerLimit, float upperLimit)
         {
+            // empty intersections defaults to entire span.
             return new List<float>();
         }
 

src/Consolonia.Gallery/Consolonia.Gallery.csproj

@@ -5,6 +5,11 @@
         <IsPackable>False</IsPackable>
     </PropertyGroup>
 
+
+    <ItemGroup>
+      <AvaloniaResource Include="Resources\*" />
+    </ItemGroup>
+
     <ItemGroup>
       <ProjectReference Include="..\Consolonia.Core\Consolonia.Core.csproj" />
       <ProjectReference Include="..\Consolonia.PlatformSupport\Consolonia.PlatformSupport.csproj" />