dxfhatch.cs

来自「导出dxf的原码类库,根据国外一个反编译的」· CS 代码 · 共 320 行

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace DXFFile
{
    public class DXFHatch:DXFFigure
    {
        // Fields
        protected int bndAmount;
        protected ArrayList boundaries;
        protected HatchBoundaryType boundaryType;
        protected string patternName;
        private HatchStyle style;

        // Methods
        public DXFHatch()
        {
            this.boundaries = new ArrayList();
            this.patternName = "";
        }

        public DXFHatch(DXFData aData)
            : base(aData)
        {
            this.boundaries = new ArrayList();
            this.patternName = "";
            this.boundaryType = (HatchBoundaryType)aData.selfType;
            DXFPoint point = new DXFPoint();
            base.Layer = "0";
            this.SetStyle(aData);
            this.boundaries.Clear();
            switch (this.boundaryType)
            {
                case HatchBoundaryType.hbtPolyPolyline:
                    if (aData.count <= 0)
                    {
                        break;
                    }
                    for (int i = 0; i < aData.points.Count; i++)
                    {
                        if (((ArrayList)aData.points[i]).Count >= 3)
                        {
                            int num2;
                            this.boundaries.Add(new ArrayList());
                            for (num2 = 0; num2 < ((ArrayList)aData.points[i]).Count; num2++)
                            {
                                point = (DXFPoint)((ArrayList)aData.points[i])[num2];
                                if (((num2 >= 2) && (point.X == ((DXFPoint)((ArrayList)aData.points[i])[num2 - 2]).X)) && (point.Y == ((DXFPoint)((ArrayList)aData.points[i])[num2 - 2]).Y))
                                {
                                    point = null;
                                }
                                else
                                {
                                    ((ArrayList)this.boundaries[this.boundaries.Count - 1]).Add(point.Clone());
                                }
                            }
                            if (((ArrayList)this.boundaries[this.boundaries.Count - 1]).Count < 3)
                            {
                                for (num2 = 0; num2 < (((ArrayList)this.boundaries[this.boundaries.Count - 1]).Count - 1); num2++)
                                {
                                    ((ArrayList)this.boundaries[this.boundaries.Count - 1])[num2] = null;
                                }
                                this.boundaries.Remove((ArrayList)this.boundaries[this.boundaries.Count - 1]);
                            }
                        }
                    }
                    return;

                case HatchBoundaryType.hbtCircle:
                    this.bndAmount = 1;
                    return;

                case HatchBoundaryType.hbtEllipse:
                    this.bndAmount = 1;
                    return;

                default:
                    this.bndAmount = 0;
                    break;
            }
        }

        private void AddBoundaryPathData(DXFExport ADXFExport)
        {
            int num2;
            switch (this.boundaryType)
            {
                case HatchBoundaryType.hbtPolyPolyline:
                    ADXFExport.AddInt(0x5b, this.boundaries.Count);
                    num2 = 0;
                    break;

                case HatchBoundaryType.hbtCircle:
                    ADXFExport.AddInt(0x5b, 1);
                    ADXFExport.AddInt(0x5c, 1);
                    ADXFExport.AddInt(0x5d, 1);
                    ADXFExport.AddInt(0x48, 2);
                    ADXFExport.Add3DPoint(10, base.data.point);
                    ADXFExport.AddFloat(40, ADXFExport.MM(base.data.radius));
                    ADXFExport.AddFloat(50, base.data.startAngle);
                    ADXFExport.AddFloat(0x33, base.data.endAngle);
                    ADXFExport.AddInt(0x49, 1);
                    ADXFExport.AddInt(0x61, 0);
                    return;

                case HatchBoundaryType.hbtEllipse:
                    ADXFExport.AddInt(0x5b, 1);
                    ADXFExport.AddInt(0x5c, 1);
                    ADXFExport.AddInt(0x5d, 1);
                    ADXFExport.AddInt(0x48, 3);
                    ADXFExport.Add3DPoint(10, base.data.point);
                    ADXFExport.Add3DPoint(11, base.data.point1);
                    ADXFExport.AddFloat(40, base.data.radius);
                    ADXFExport.AddFloat(50, base.data.startAngle);
                    ADXFExport.AddFloat(0x33, base.data.endAngle);
                    ADXFExport.AddInt(0x49, 1);
                    ADXFExport.AddInt(0x61, 0);
                    return;

                default:
                    return;
            }
            while (num2 < this.boundaries.Count)
            {
                ADXFExport.AddInt(0x5c, 1);
                ADXFExport.AddInt(0x5d, ((ArrayList)this.boundaries[num2]).Count);
                for (int i = 1; i < ((ArrayList)this.boundaries[num2]).Count; i++)
                {
                    ADXFExport.AddInt(0x48, 1);
                    ADXFExport.Add3DPoint(10, (DXFPoint)((ArrayList)this.boundaries[num2])[i - 1]);
                    ADXFExport.Add3DPoint(11, (DXFPoint)((ArrayList)this.boundaries[num2])[i]);
                }
                ADXFExport.AddInt(0x48, 1);
                ADXFExport.Add3DPoint(10, (DXFPoint)((ArrayList)this.boundaries[num2])[((ArrayList)this.boundaries[num2]).Count - 1]);
                ADXFExport.Add3DPoint(11, (DXFPoint)((ArrayList)this.boundaries[num2])[0]);
                ADXFExport.AddInt(0x61, 0);
                num2++;
            }
        }

        private void AddPatternData(float offset, DXFExport aDXFExport)
        {
            DXFHatchPatternData[] dataArray = new DXFHatchPatternData[2];
            int num2 = 1;
            dataArray[0].basePointX = 0f;
            dataArray[0].basePointY = 0f;
            dataArray[0].offsetX = -offset;
            dataArray[0].offsetY = offset;
            dataArray[1].basePointX = 0f;
            dataArray[1].basePointY = 0f;
            dataArray[1].offsetX = -offset;
            dataArray[1].offsetY = offset;
            switch (this.Style)
            {
                case HatchStyle.hsHorizontal:
                    dataArray[0].angle = 0f;
                    dataArray[0].offsetX = 0f;
                    break;

                case HatchStyle.hsVertical:
                    dataArray[0].angle = 90f;
                    dataArray[0].offsetY = 0f;
                    break;

                case HatchStyle.hsFDiagonal:
                    dataArray[0].angle = 135f;
                    dataArray[0].offsetY = -dataArray[0].offsetY;
                    break;

                case HatchStyle.hsBDiagonal:
                    dataArray[0].angle = 45f;
                    break;

                case HatchStyle.hsCross:
                    num2 = 2;
                    dataArray[0].angle = 0f;
                    dataArray[0].offsetX = 0f;
                    dataArray[1].angle = 90f;
                    break;

                case HatchStyle.hsDiagCross:
                    num2 = 2;
                    dataArray[0].angle = 45f;
                    dataArray[1].angle = 135f;
                    dataArray[1].offsetY = -dataArray[0].offsetY;
                    break;
            }
            aDXFExport.AddFloat(0x34, 0f);
            aDXFExport.AddFloat(0x29, 1f);
            aDXFExport.AddInt(0x4d, 0);
            aDXFExport.AddInt(0x4e, num2);
            for (int i = 0; i < num2; i++)
            {
                aDXFExport.AddFloat(0x35, dataArray[i].angle);
                aDXFExport.AddFloat(0x2b, dataArray[i].basePointX);
                aDXFExport.AddFloat(0x2c, dataArray[i].basePointY);
                aDXFExport.AddFloat(0x2d, dataArray[i].offsetX);
                aDXFExport.AddFloat(0x2e, dataArray[i].offsetY);
                aDXFExport.AddInt(0x4f, 0);
            }
        }

        public override void ExportAsDXF(DXFExport ADXFExport)
        {
            DXFPoint p = new DXFPoint();
            if (((this.boundaries != null) || (this.boundaryType != HatchBoundaryType.hbtPolyPolyline)) && ((this.boundaries.Count != 0) || (this.boundaryType != HatchBoundaryType.hbtPolyPolyline)))
            {
                p.X = 0f;
                p.Y = 0f;
                float offset = 0.05f;
                if (!DXFExport.use01MM)
                {
                    offset *= ADXFExport.fOffset;
                }
                ADXFExport.AddName(DXFTables.sHatchEntity, "AcDbHatch");
                ADXFExport.AddColor(base.data);
                ADXFExport.Add3DPoint(10, p);
                ADXFExport.AddFloat(30, 0f);
                ADXFExport.AddFloat(210, 0f);
                ADXFExport.AddFloat(220, 0f);
                ADXFExport.AddFloat(230, 1f);
                ADXFExport.AddString(2, this.patternName);
                ADXFExport.AddInt(70, base.data.flags);
                ADXFExport.AddInt(0x47, 0);
                this.AddBoundaryPathData(ADXFExport);
                ADXFExport.AddInt(0x4b, 0);
                ADXFExport.AddInt(0x4c, 1);
                if (base.data.flags == 0)
                {
                    this.AddPatternData(offset, ADXFExport);
                }
                ADXFExport.AddInt(0x62, 1);
                ADXFExport.AddPoint(10, p);
            }
        }

        public DXFPoint GetPoint(int bndIndex, int aIndex)
        {
            return new DXFPoint(((DXFPoint)((ArrayList)this.boundaries[bndIndex])[aIndex]).X, ((DXFPoint)((ArrayList)this.boundaries[bndIndex])[aIndex]).Y, ((DXFPoint)((ArrayList)this.boundaries[bndIndex])[aIndex]).Z);
        }

        public int GetPointsNumber(int bndIndex)
        {
            return ((ArrayList)this.boundaries[bndIndex]).Count;
        }

        protected void SetStyle(DXFData Data)
        {
            this.style = (HatchStyle)base.data.style;
            this.patternName = DXFTables.sPatternSOLID;
            base.data.flags = 1;
            if (this.style != HatchStyle.hsSolid)
            {
                base.data.flags = 0;
                switch (this.style)
                {
                    case HatchStyle.hsHorizontal:
                        this.PatternName = DXFTables.sPatternLINE;
                        return;

                    case HatchStyle.hsVertical:
                        this.PatternName = DXFTables.sPatternLINE;
                        return;

                    case HatchStyle.hsFDiagonal:
                        this.PatternName = DXFTables.sPatternANSI31;
                        return;

                    case HatchStyle.hsBDiagonal:
                        this.PatternName = DXFTables.sPatternANSI31;
                        return;

                    case HatchStyle.hsCross:
                        this.PatternName = DXFTables.sPatternNET;
                        return;

                    case HatchStyle.hsDiagCross:
                        this.PatternName = DXFTables.sPatternANSI37;
                        return;

                    default:
                        return;
                }
            }
        }

        // Properties
        public int BndAmount
        {
            get
            {
                return this.boundaries.Count;
            }
        }

        public string PatternName
        {
            get
            {
                return this.PatternName;
            }
            set
            {
                this.patternName = value;
            }
        }

        public HatchStyle Style
        {
            get
            {
                return this.style;
            }
        }
    }
}