inabox/inabox.dxf/Objects.cs

using InABox.Core;
using netDxf;
using netDxf.Entities;
using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace InABox.Dxf;

internal interface IDxfObject
{
    void Draw(DrawData data);
}

internal class DxfLine : IDxfObject
{
    public Line Line { get; set; }

    public void Draw(DrawData data)
    {
        if (!Line.IsVisible || !data.Data.HasLayer(Line.Layer)) return;
        data.Graphics.DrawLine(new Pen(Color.Black, data.ConvertThickness((float)Line.Thickness)), DrawData.ConvertPoint(Line.StartPoint), DrawData.ConvertPoint(Line.EndPoint));
    }
}

internal class DxfInsert : IDxfObject
{
    public Insert Insert { get; set; }

    public List<IDxfObject> Objects { get; set; }

    public DxfInsert(Insert insert)
    {
        Insert = insert;
        Objects = insert.Block.Entities.Select(DxfUtils.ConvertEl).NotNull().ToList();
    }

    public void Draw(DrawData data)
    {
        if (!Insert.IsVisible || !data.Data.HasLayer(Insert.Layer)) return;

        var transformation = Insert.GetTransformation();
        var translation = Insert.Position - transformation * Insert.Block.Origin;

        foreach(var entity in Insert.Block.Entities)
        {
            entity.TransformBy(transformation, translation);
            DxfUtils.ConvertEl(entity)?.Draw(data);
        }

        // foreach(var obj in Insert.Explode())
        // {
        //     DxfUtils.ConvertEl(obj)?.Draw(data);
        // }
    }
}

internal class DxfEllipse : IDxfObject
{
    public Ellipse Ellipse { get; set; }

    public DxfEllipse(Ellipse ellipse)
    {
        Ellipse = ellipse;
    }

    public void Draw(DrawData data)
    {
        if (!Ellipse.IsVisible || !data.Data.HasLayer(Ellipse.Layer)) return;

        foreach(var obj in Ellipse.ToPolyline2D(100).Explode())
        {
            DxfUtils.ConvertEl(obj)?.Draw(data);
        }
        // var center = DrawData.ConvertPoint(Ellipse.Center);
        // var size = new SizeF((float)Ellipse.MajorAxis, (float)Ellipse.MinorAxis);

        // var startAngle = (float)(Ellipse.StartAngle);
        // var endAngle = (float)(Ellipse.EndAngle);

        // data.Graphics.DrawArc(new Pen(Color.Black, data.ConvertThickness((float)Ellipse.Thickness)), center.X - size.Width / 2, center.Y - size.Height / 2, size.Width, size.Height, startAngle, Utils.Mod(endAngle - startAngle, 360));
    }
}

internal class DxfSolid : IDxfObject
{
    public Solid Solid { get; set; }

    public DxfSolid(Solid solid)
    {
        Solid = solid;
    }

    public void Draw(DrawData data)
    {
        if (!Solid.IsVisible || !data.Data.HasLayer(Solid.Layer)) return;

        var vertices = new Vector2[]
        {
            Solid.FirstVertex,
            Solid.SecondVertex,
            Solid.FourthVertex, // Apparently the third and fourth are the wrong way round, so I've mirrored that here.
            Solid.ThirdVertex
        };
        data.Graphics.FillPolygon(new SolidBrush(Color.Black), vertices.ToArray(x => DrawData.ConvertPoint(x)));
    }
}

internal class DxfPolyline2D : IDxfObject
{
    public Polyline2D Polyline { get; set; }

    public DxfPolyline2D(Polyline2D polyline)
    {
        Polyline = polyline;
    }

    public void Draw(DrawData data)
    {
        if (!Polyline.IsVisible || !data.Data.HasLayer(Polyline.Layer)) return;

        var entities = Polyline.Explode();
        foreach(var entity in entities)
        {
            DxfUtils.ConvertEl(entity)?.Draw(data);
        }

        // if(Polyline.SmoothType == PolylineSmoothType.NoSmooth)
        // {
        //     var vertices = Polyline.Vertexes.ToArray(x => new PointF((float)x.Position.X, (float)x.Position.Y));
        //     if (Polyline.IsClosed)
        //     {
        //         data.Graphics.DrawPolygon(
        //             new Pen(Color.Black, data.ConvertThickness((float)Polyline.Thickness)),
        //             vertices);
        //     }
        //     else
        //     {
        //         data.Graphics.DrawLines(
        //             new Pen(Color.Black, data.ConvertThickness((float)Polyline.Thickness)),
        //             vertices);
        //     }
        // }
        // else
        // {

        // }
    }
}

internal class DxfMText : IDxfObject
{
    public MText MText { get; set; }

    public DxfMText(MText text)
    {
        MText = text;
    }

    public void Draw(DrawData data)
    {
        if (!MText.IsVisible || !data.Data.HasLayer(MText.Layer)) return;

        Font font;
        if (MText.Style.FontFamilyName.IsNullOrWhiteSpace())
        {
            font = SystemFonts.DefaultFont;
        }
        else
        {
            var fontFamily = new FontFamily(MText.Style.FontFamilyName);
            font = new Font(fontFamily, (float)MText.Height, MText.Style.FontStyle switch
            {
                netDxf.Tables.FontStyle.Bold => FontStyle.Bold,
                netDxf.Tables.FontStyle.Italic => FontStyle.Italic,
                netDxf.Tables.FontStyle.Regular or _ => FontStyle.Regular,
            });
        }

        var text = MText.PlainText().Replace("^M", "");

        data.PushTransform();
        data.Translate(new PointF((float)MText.Position.X, (float)MText.Position.Y));
        data.Rotate((float)MText.Rotation);
        data.Scale(1, -1);

        var size = data.Graphics.MeasureString(text, font, new PointF(), StringFormat.GenericTypographic);
        switch (MText.AttachmentPoint)
        {
            case MTextAttachmentPoint.MiddleLeft:
            case MTextAttachmentPoint.MiddleCenter:
            case MTextAttachmentPoint.MiddleRight:
                data.Translate(new PointF(0, -size.Height / 2));
                break;
            case MTextAttachmentPoint.BottomLeft:
            case MTextAttachmentPoint.BottomCenter:
            case MTextAttachmentPoint.BottomRight:
                data.Translate(new PointF(0, -size.Height));
                break;
            default:
                var ascent = font.FontFamily.GetCellAscent(font.Style);
                var lineSpace = font.FontFamily.GetLineSpacing(font.Style);
                var baseline = ascent * font.Height / font.FontFamily.GetEmHeight(font.Style);
                var ratio = font.GetHeight(data.Graphics) / lineSpace;
                data.Translate(new PointF(0, -baseline + ascent * ratio));
                break;
        }

        switch (MText.AttachmentPoint)
        {
            case MTextAttachmentPoint.TopLeft:
            case MTextAttachmentPoint.MiddleLeft:
            case MTextAttachmentPoint.BottomLeft:
                break;
            case MTextAttachmentPoint.TopCenter:
            case MTextAttachmentPoint.MiddleCenter:
            case MTextAttachmentPoint.BottomCenter:
                data.Translate(new PointF(-(float)size.Width / 2, 0));
                break;
            case MTextAttachmentPoint.TopRight:
            case MTextAttachmentPoint.MiddleRight:
            case MTextAttachmentPoint.BottomRight:
                data.Translate(new PointF(-(float)size.Width, 0));
                break;
        }

        data.Graphics.DrawString(text, font, new SolidBrush(Color.Black), new PointF(0, 0), StringFormat.GenericTypographic);
        data.PopTransform();
    }
}

internal class DxfDimension : IDxfObject
{
    public Dimension Dimension { get; set; }

    public DxfDimension(Dimension dimension)
    {
        Dimension = dimension;
    }

    public void Draw(DrawData data)
    {
        if (!Dimension.IsVisible || !data.Data.HasLayer(Dimension.Layer)) return;

        if(Dimension.Block is null)
        {
            return;
        }

        var entities = Dimension.Block.Entities;
        foreach(var entity in entities)
        {
            DxfUtils.ConvertEl(entity)?.Draw(data);
        }
    }
}