SvgView.cs

using System;
using System.IO;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.Maui.Controls;
using Microsoft.Maui.Storage;
using NeuroAccessMaui.Extensions;
using NeuroAccessMaui.Services;
using SkiaSharp;
using SkiaSharp.Views.Maui;
using SkiaSharp.Views.Maui.Controls;
using SkiaSharp.Views.Maui.Handlers;
using Svg.Skia;
 
namespace NeuroAccessMaui.UI.Controls
{
    public class AutoHeightSKCanvasView : SKCanvasView
    {
        public virtual Size CustomMeasuredSize(double widthConstraint, double heightConstraint)
        {
            return Size.Zero;
        }
    }
    internal class AutoHeightSKCanvasViewHandler : SKCanvasViewHandler
    {
        public override Size GetDesiredSize(double widthConstraint, double heightConstraint)
        {
            AutoHeightSKCanvasView? AutoHeightSKCanvasView = this.VirtualView as AutoHeightSKCanvasView;
            if (AutoHeightSKCanvasView is not null)
            {
                Size Custom = AutoHeightSKCanvasView.Measure(widthConstraint, heightConstraint);
                if (Custom == Size.Zero)
                    return base.GetDesiredSize(widthConstraint, heightConstraint);
                else
                    return Custom;
            }
            return base.GetDesiredSize(widthConstraint, heightConstraint);
        }
    }
    public class SvgView : AutoHeightSKCanvasView, IDisposable
    {
        public static readonly BindableProperty SourceProperty =
            BindableProperty.Create(
                nameof(Source),
                typeof(string),
                typeof(SvgView),
                default(string),
                propertyChanged: OnSourceChanged);
 
        public static readonly BindableProperty AspectProperty =
            BindableProperty.Create(
                nameof(Aspect),
                typeof(Aspect),
                typeof(SvgView),
                Aspect.AspectFit,
                propertyChanged: OnAspectChanged);
 
        public static readonly BindableProperty TintColorProperty =
            BindableProperty.Create(
                nameof(TintColor),
                typeof(Color),
                typeof(SvgView),
                null,
                propertyChanged: OnTintColorChanged);
 
        public string Source
        {
            get => (string)this.GetValue(SourceProperty);
            set => this.SetValue(SourceProperty, value);
        }
 
        public Aspect Aspect
        {
            get => (Aspect)this.GetValue(AspectProperty);
            set => this.SetValue(AspectProperty, value);
        }
 
        public Color? TintColor
        {
            get => (Color?)this.GetValue(TintColorProperty);
            set => this.SetValue(TintColorProperty, value);
        }
 
        private SKSvg? svg;
 
        private bool disposedValue;
 
        public SvgView()
        {
            // Disable touch events if not needed.
            this.EnableTouchEvents = false;
            PaintSurface += this.OnPaintSurface;
        }
 
        private static void OnSourceChanged(BindableObject bindable, object oldValue, object newValue)
        {
            SvgView SvgView = (SvgView)bindable;
            SvgView.LoadSvg();
        }
 
        private static void OnAspectChanged(BindableObject bindable, object oldValue, object newValue)
        {
            SvgView SvgView = (SvgView)bindable;
            SvgView.InvalidateSurface();
        }
 
        private static void OnTintColorChanged(BindableObject bindable, object oldValue, object newValue)
        {
            SvgView SvgView = (SvgView)bindable;
            SvgView.InvalidateSurface();
        }
 
        private async void LoadSvg()
        {
            if (string.IsNullOrEmpty(this.Source))
                return;
 
            // Dispose of any previous instance.
            this.svg?.Dispose();
            this.svg = null;
 
            try
            {
                using Stream Stream = await FileSystem.OpenAppPackageFileAsync(this.Source);
                this.svg = new SKSvg();
                this.svg.Load(Stream);
            }
            catch (Exception Ex)
            {
                ServiceRef.LogService.LogWarning($"Error loading SVG asset '{this.Source}': {Ex}", this.GetClassAndMethod(MethodBase.GetCurrentMethod()));
                this.svg = null;
            }
            finally
            {
                // Request a redraw regardless of success or failure.
                this.InvalidateSurface();
 
                this.InvalidateMeasure();
 
                
 
            }
        }
 
        private void OnPaintSurface(object? sender, SKPaintSurfaceEventArgs e)
        {
            SKCanvas Canvas = e.Surface.Canvas;
            Canvas.Clear();
 
            if (this.svg?.Picture is null)
                return;
 
            SKImageInfo Info = e.Info;
            SKRect SvgRect = this.svg.Picture.CullRect;
 
            // Calculate scaling factors.
            float ScaleX = Info.Width / SvgRect.Width;
            float ScaleY = Info.Height / SvgRect.Height;
            float Scale;
            float TranslateX = 0;
            float TranslateY = 0;
 
            switch (this.Aspect)
            {
                case Aspect.Fill:
                    // Non-uniform scaling to completely fill the view (might distort the image).
                    Canvas.Scale(ScaleX, ScaleY);
                    this.DrawPictureWithOptionalTint(Canvas, this.svg.Picture);
                    return;
 
                case Aspect.AspectFill:
                    // Uniform scaling that covers the view (parts may be clipped).
                    Scale = Math.Max(ScaleX, ScaleY);
                    break;
 
                case Aspect.AspectFit:
                default:
                    // Uniform scaling to fit entirely within the view.
                    Scale = Math.Min(ScaleX, ScaleY);
                    break;
            }
 
            // Calculate dimensions after scaling.
            float ScaledWidth = SvgRect.Width * Scale;
            float ScaledHeight = SvgRect.Height * Scale;
 
            // Center the SVG.
            TranslateX = (Info.Width - ScaledWidth) / 2;
            TranslateY = (Info.Height - ScaledHeight) / 2;
 
            Canvas.Translate(TranslateX, TranslateY);
            Canvas.Scale(Scale);
 
            this.DrawPictureWithOptionalTint(Canvas, this.svg.Picture);
        }
 
        private void DrawPictureWithOptionalTint(SKCanvas canvas, SKPicture picture)
        {
            if (this.TintColor is null)
            {
                canvas.DrawPicture(picture);
            }
            else
            {
                // Apply tint using an SKPaint with a color filter.
                using SKPaint Paint = new()
                {
                    ColorFilter = SKColorFilter.CreateBlendMode(this.TintColor.ToSKColor(), SKBlendMode.SrcIn)
                };
                canvas.DrawPicture(picture, Paint);
            }
        }
 
 
        protected override SizeRequest OnMeasure(double widthConstraint, double heightConstraint)
        {
            // If the SVG is not loaded yet, fall back to the default measurement.
            if (this.svg?.Picture is null)
            {
                return base.OnMeasure(widthConstraint, heightConstraint);
            }
 
            // Retrieve the intrinsic dimensions of the SVG.
            SKRect svgBounds = this.svg.Picture.CullRect;
            double intrinsicWidth = svgBounds.Width;
            double intrinsicHeight = svgBounds.Height;
 
            // Check if constraints are unbounded.
            bool unboundedWidth = double.IsInfinity(widthConstraint);
            bool unboundedHeight = double.IsInfinity(heightConstraint);
 
            // If both dimensions are unbounded, return the intrinsic size.
            if (unboundedWidth && unboundedHeight)
            {
                return new SizeRequest(new Size(intrinsicWidth, intrinsicHeight));
            }
            // If only one dimension is unbounded, calculate it from the other dimension
            // while preserving the aspect ratio of the SVG.
            else if (unboundedWidth)
            {
                double scale = heightConstraint / intrinsicHeight;
                return new SizeRequest(new Size(intrinsicWidth * scale, heightConstraint));
            }
            else if (unboundedHeight)
            {
                double scale = widthConstraint / intrinsicWidth;
                return new SizeRequest(new Size(widthConstraint, intrinsicHeight * scale));
            }
            else
            {
                // If both dimensions are constrained, you can decide whether to honor the constraints
                // (for example, scaling the intrinsic size) or simply return the constraints.
                // Here we preserve the intrinsic aspect ratio.
                double constraintAspect = widthConstraint / heightConstraint;
                double intrinsicAspect = intrinsicWidth / intrinsicHeight;
 
                if (intrinsicAspect > constraintAspect)
                {
                    // Constrained by width.
                    double scaledHeight = widthConstraint / intrinsicAspect;
                    return new SizeRequest(new Size(widthConstraint, scaledHeight));
                }
                else
                {
                    // Constrained by height.
                    double scaledWidth = heightConstraint * intrinsicAspect;
                    return new SizeRequest(new Size(scaledWidth, heightConstraint));
                }
            }
        }
 
        #region IDisposable Implementation
 
        public void Dispose()
        {
            this.Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
 
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposedValue)
            {
                if (disposing)
                {
                    // Unsubscribe from events and dispose managed objects.
                    PaintSurface -= this.OnPaintSurface;
                    this.svg?.Dispose();
                    this.svg = null;
                }
                // Free unmanaged resources, if any.
                this.disposedValue = true;
            }
        }
 
        ~SvgView()
        {
            this.Dispose(disposing: false);
        }
 
        #endregion
    }
}