DrawingState.cs

using SkiaSharp;
using System;
using System.Collections.Generic;
using Waher.Layout.Layout2D.Model.Fonts;
using Waher.Script;
 
namespace Waher.Layout.Layout2D.Model
{
    public delegate string ElementToString(ILayoutElement Element);
 
    public class DrawingState : IDisposable
    {
        private Dictionary<ILayoutElement, bool> relativeElements = null;
        private readonly Variables session;
        private readonly SKPaint textPenRoot;
        private readonly SKFont fontRoot;
        private readonly SKPaint defaultPen;
        private SKCanvas canvas;
        private SKPaint shapePen;
        private SKPaint shapeFill;
        private SKFont font;
        private SKPaint textPen;
        private float? width_0;
        private float? height_x;
        private SKSize areaSize;
        private SKSize viewportSize;
        private readonly float pixelsPerInch;
        private bool logRelativeElements = false;
 
        public DrawingState(SKCanvas Canvas, RenderSettings Settings, Variables Session)
        {
            this.canvas = Canvas;
            this.session = Session;
            this.pixelsPerInch = Settings.PixelsPerInch;
            this.areaSize = this.viewportSize = new SKSize(Settings.Width, Settings.Height);
 
            this.font = this.fontRoot = new SKFont()
            {
                Edging = SKFontEdging.SubpixelAntialias,
                Hinting = SKFontHinting.Full,
                Subpixel = true,
                Size = (float)(Settings.FontSize * this.pixelsPerInch / 72),
                Typeface = SKTypeface.FromFamilyName(Settings.FontName, SKFontStyle.Normal) 
                    ?? SKTypeface.Default
            };
 
            this.textPen = this.textPenRoot = new SKPaint()
            {
                IsAntialias = true,
                Style = SKPaintStyle.Fill,
                Color = Settings.TextColor
            };
 
            this.defaultPen = new SKPaint()
            {
                IsAntialias = true,
                Style = SKPaintStyle.Stroke,
                Color = Settings.PenColor
            };
        }
 
        public void Dispose()
        {
            this.textPen?.Dispose();
            this.textPenRoot?.Dispose();
            this.font?.Dispose();
            this.fontRoot?.Dispose();
            this.defaultPen?.Dispose();
        }
 
        public Variables Session => this.session;
 
        public float PixelsPerInch => this.pixelsPerInch;
 
        public SKCanvas Canvas
        {
            get => this.canvas;
            internal set => this.canvas = value;
        }
 
        public SKPaint TextPen
        {
            get => this.textPen;
            set => this.textPen = value;
        }
 
        public SKFont Font
        {
            get => this.font;
            set => this.font = value;
        }
 
        public SKPaint DefaultPen => this.defaultPen;
 
        public SKPaint ShapePen
        {
            get => this.shapePen;
            set => this.shapePen = value;
        }
 
        public SKPaint ShapeFill
        {
            get => this.shapeFill;
            set => this.shapeFill = value;
        }
 
        public float AreaWidth => this.areaSize.Width;
 
        public float AreaHeight => this.areaSize.Height;
 
        public void CalcDrawingSize(Length L, ref float Size, bool Horizontal, ILayoutElement Element)
        {
            switch (L.Unit)
            {
                // pixels (1px = 1/96th of 1in) (absolute)
                case LengthUnit.Px:
                    Size = L.Value * this.pixelsPerInch / 96;
                    break;
 
                // points (1pt = 1/72 of 1in) (absolute)
                case LengthUnit.Pt:
                    Size = L.Value * this.pixelsPerInch / 72;
                    break;
 
                // picas (1pc = 12 pt) (absolute)
                case LengthUnit.Pc:
                    Size = L.Value * this.pixelsPerInch / 12;
                    break;
 
                // centimeters (absolute)
                case LengthUnit.Cm:
                    Size = L.Value * this.pixelsPerInch / 2.54f;
                    break;
 
                // inches (1in = 96px = 2.54cm)
                case LengthUnit.In:
                    Size = L.Value * this.pixelsPerInch;
                    break;
 
                // millimeters (absolute)
                case LengthUnit.Mm:
                    Size = L.Value * this.pixelsPerInch / 25.4f;
                    break;
 
                // Relative to the font-size of the element (2em means 2 times the size of the current font)
                case LengthUnit.Em:
                    float Size2 = L.Value * this.font.Size;
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to the x-height of the current font (rarely used)
                case LengthUnit.Ex:
                    if (!this.height_x.HasValue)
                    {
                        this.font.MeasureText("x", out SKRect Bounds, this.textPen);
                        this.height_x = Bounds.Height;
                    }
 
                    Size2 = L.Value * this.height_x.Value;
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to the width of the "0" (zero)
                case LengthUnit.Ch:
                    if (!this.width_0.HasValue)
                        this.width_0 = this.font.MeasureText("0", this.textPen);
 
                    Size2 = L.Value * this.width_0.Value;
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to font-size of the root element
                case LengthUnit.Rem:
                    Size2 = L.Value * this.fontRoot.Size;
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to 1% of the width of the viewport
                case LengthUnit.Vw:
                    Size2 = L.Value * this.viewportSize.Width / 100;
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to 1% of the height of the viewport
                case LengthUnit.Vh:
                    Size2 = L.Value * this.viewportSize.Height / 100;
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to 1% of viewport's* smaller dimension
                case LengthUnit.Vmin:
                    if (this.viewportSize.Width < this.viewportSize.Height)
                        Size2 = L.Value * this.viewportSize.Width / 100;
                    else
                        Size2 = L.Value * this.viewportSize.Height / 100;
 
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to 1% of viewport's* larger dimension
                case LengthUnit.Vmax:
                    if (this.viewportSize.Width > this.viewportSize.Height)
                        Size2 = L.Value * this.viewportSize.Width / 100;
                    else
                        Size2 = L.Value * this.viewportSize.Height / 100;
 
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                // Relative to the parent element
                case LengthUnit.Percent:
                    if (Horizontal)
                        Size2 = L.Value * this.areaSize.Width / 100;
                    else
                        Size2 = L.Value * this.areaSize.Height / 100;
 
                    if (Size != Size2)
                    {
                        this.ReportMeasureRelative(Element);
                        Size = Size2;
                    }
                    break;
 
                default:
                    Size = L.Value;
                    break;
            }
        }
 
        public SKSize SetAreaSize(SKSize AreaSize)
        {
            SKSize Prev = this.areaSize;
            this.areaSize = AreaSize;
            return Prev;
        }
 
        public FontState Push(Font Font)
        {
            if (Font is null)
                return null;
            else
                return new FontState(Font.TextPen, Font.FontDef);
        }
 
        public void Restore(FontState FontState)
        {
            if (!(FontState is null))
            {
                this.textPen = FontState.Pen;
                this.font = FontState.Font;
            }
        }
 
        public bool MeasureRelative
        {
            get;
            private set;
        }
 
        public IEnumerable<ILayoutElement> RelativeElements => this.relativeElements.Keys;
 
        public void ReportMeasureRelative(ILayoutElement Element)
        {
            this.MeasureRelative = true;
            if (this.logRelativeElements)
                this.relativeElements[Element] = true;
        }
 
        public void ClearRelativeMeasurement(bool LogRelativeElements)
        {
            this.MeasureRelative = false;
            this.logRelativeElements = LogRelativeElements;
            if (this.logRelativeElements)
            {
                if (this.relativeElements is null)
                    this.relativeElements = new Dictionary<ILayoutElement, bool>();
                else
                    this.relativeElements.Clear();
            }
        }
 
        public string GetShortestRelativeMeasurement(ElementToString Map)
        {
            string Best = string.Empty;
            int BestLen = int.MaxValue;
 
            foreach (ILayoutElement Element in this.relativeElements.Keys)
            {
                string Item = Map(Element);
                int Len = Item.Length;
 
                if (Len < BestLen)
                {
                    Best = Item;
                    BestLen = Len;
                }
            }
 
            return Best;
        }
 
        public string GetShortestRelativeMeasurementXml()
        {
            return this.GetShortestRelativeMeasurement((E) => E.ToXml());
        }
 
        public string GetShortestRelativeMeasurementStateXml()
        {
            return this.GetShortestRelativeMeasurement((E) => E.ExportState());
        }
    }
}