dxfexport.cs

导出dxf的原码类库,根据国外一个反编译的

                this.AddFloat(50, aData.rotation);
            }
        }

        public float MM(float Value)
        {
            if (!use01MM)
            {
                return Value;
            }
            return (Value / 100f);
        }

        protected bool ParseRects(DXFRectangle aRect, DXFFigure aFigure, ArrayList NewElems)
        {
            Line line = new Line();
            Rect rect = new Rect();
            ArrayList list = new ArrayList();
            DXFLine line2 = new DXFLine();
            bool flag = false;
            DXFData aData = new DXFData();
            rect.X1 = (int)Math.Round((double)aRect.LeftTop.X);
            rect.Y1 = (int)Math.Round((double)aRect.LeftTop.Y);
            rect.X2 = (int)Math.Round((double)aRect.RightBottom.X);
            rect.Y2 = (int)Math.Round((double)aRect.RightBottom.Y);
            if (rect.X2 < rect.X1)
            {
                int num3 = rect.X2;
                rect.X2 = rect.X1;
                rect.X1 = num3;
            }
            if (rect.Y2 < rect.Y1)
            {
                int num4 = rect.Y2;
                rect.Y2 = rect.Y1;
                rect.Y1 = num4;
            }
            if (aFigure is DXFMText)
            {
                if (((DXFMText)aFigure).IntersecRect(rect))
                {
                    ((DXFMText)aFigure).ParseToTexts(rect, NewElems);
                    return true;
                }
                NewElems.Add(aFigure);
                return flag;
            }
            if (((aFigure is DXFEllipse) || (aFigure is DXFArc)) || ((aFigure is DXFRectangle) || (aFigure is DXFPolyline)))
            {
                if (((DXFRectangle)aFigure).IntersecRect(rect))
                {
                    ((DXFRectangle)aFigure).ParseToLines(NewElems);
                    for (int j = NewElems.Count - 1; j > 0; j--)
                    {
                        this.ParseRects(aRect, (DXFFigure)NewElems[j], NewElems);
                    }
                    NewElems.Clear();
                    return true;
                }
                NewElems.Add(aFigure);
                return flag;
            }
            if (!(aFigure is DXFLine))
            {
                NewElems.Add(aFigure);
                return flag;
            }
            line2 = (DXFLine)aFigure;
            line.x1 = (int)Math.Round((double)line2.StartPoint.X);
            line.y1 = (int)Math.Round((double)line2.StartPoint.Y);
            line.x2 = (int)Math.Round((double)line2.EndPoint.X);
            line.y2 = (int)Math.Round((double)line2.EndPoint.Y);
            for (int i = 0; i < list.Count; i++)
            {
                aData = line2.data;
                Line line3 = (Line)list[i];
                aData.point.X = line3.x1;
                line3 = (Line)list[i];
                aData.point.Y = line3.y1;
                line3 = (Line)list[i];
                aData.point1.X = line3.x2;
                line3 = (Line)list[i];
                aData.point1.Y = line3.y2;
                line2 = new DXFLine(aData);
                line2.Layer = aFigure.Layer;
                NewElems.Add(line2);
            }
            list.Clear();
            return true;
        }

        public static void PtToDXF(Point P, DXFPoint DXF)
        {
            DXF.X = P.X + offsetX;
            DXF.Y = -(P.Y + offsetY);
        }

        public bool SaveToFile(string fileName)
        {
            StreamWriter aS = File.CreateText(fileName);
            try
            {
                this.SaveToStream(aS);
                aS.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }

        public void SaveToStream(StreamWriter aS)
        {
            ArrayList list = new ArrayList();
            ArrayList list2 = new ArrayList();
            ArrayList newElems = new ArrayList();
            DXFRectangle aRect = new DXFRectangle();
            DXFFigure figure = new DXFFigure();
            int num = 0;
            while (num < this.figuresList.Count)
            {
                if ((isParseWhite && (this.figuresList[num] is DXFHatch)) && ((((DXFHatch)this.figuresList[num]).Style == HatchStyle.hsSolid) && (((DXFHatch)this.figuresList[num]).Color == 0xff)))
                {
                    if ((((DXFHatch)this.figuresList[num]).BndAmount != 1) || (((DXFHatch)this.figuresList[num]).GetPointsNumber(0) != 4))
                    {
                        num++;
                        continue;
                    }
                    figure = new DXFRectangle(((DXFHatch)this.figuresList[num]).data);
                    figure.data.point = ((DXFHatch)this.figuresList[num]).GetPoint(0, 0);
                    figure.data.point1 = ((DXFHatch)this.figuresList[num]).GetPoint(0, 2);
                    this.figuresList[num] = figure;
                    list2.Add(this.figuresList[num]);
                    aRect = (DXFRectangle)this.figuresList[num];
                    for (int i = num - 1; i > 0; i--)
                    {
                        if (this.ParseRects(aRect, (DXFFigure)this.figuresList[i], newElems))
                        {
                            this.figuresList.RemoveAt(i);
                            for (int j = 0; j < newElems.Count; j++)
                            {
                                this.figuresList.Insert(i, newElems[j]);
                            }
                        }
                    }
                    newElems.Clear();
                    this.figuresList.Remove(figure);
                }
                num++;
            }
            for (num = 0; num < this.figuresList.Count; num++)
            {
                figure = (DXFFigure)this.figuresList[num];
                this.nameCurrentLayer = figure.Layer;
                if (figure != null)
                {
                    figure.ExportAsDXF(this);
                }
            }
            ArrayList current = new ArrayList();
            current = this.current;
            this.current = list;
            this.AddS(DXFTables.SHeader);
            this.AddString(9, "$ACADVER");
            this.AddString(1, this.GetStrAutoCADVer());
            this.AddString(9, "$HANDSEED");
            string str = string.Format("{0:X}", ((this.handle + this.layers.Count) + this.blocks.Count) + 1);
            this.AddString(5, str);
            this.AddString(9, "$LIMMIN");
            this.AddPoint(10, this.limMin);
            this.AddString(9, "$LIMMAX");
            this.AddPoint(10, this.limMax);
            this.AddS(DXFTables.STablesLTYPE);
            this.current.Add(this.lTypes);
            this.AddS(DXFTables.STablesLAYER);
            for (num = 0; num < this.layers.Count; num++)
            {
                ((DXFLayer)this.layers[num]).ExportAsDXF(this);
            }
            this.AddS(DXFTables.STablesSTYLE);
            this.AddS(DXFTables.STablesDIMSTYLE);
            if (autoCADVer == AutoCADVersion.R2000)
            {
                this.AddS(DXFTables.STablesDIMSTYLE_R2000);
            }
            this.AddS(DXFTables.STablesBLOCK_RECORD);
            this.current.Add(this.blkRecs);
            this.AddS(DXFTables.SBlocks);
            for (num = 0; num < this.blocks.Count; num++)
            {
                this.current.Add((ArrayList)this.blocks[num]);
                this.AddName("ENDBLK", "AcDbBlockEnd");
            }
            this.AddS(new string[] { "  0", "ENDSEC", "  0", "SECTION", "  2", "ENTITIES" });
            //DXFData data = new DXFData();
            //data.height = 50f;
            //data.rotation = 0f;
            //data.point.X = 57f;
            //data.point.Y = 0f;
            //data.color = 1;
            //data.text = "Trial version";
            //this.AddText(data);
            this.current.Add(this.entities);
            if (autoCADVer == AutoCADVersion.R2000)
            {
                this.AddS(DXFTables.SObjects_R2000);
            }
            else
            {
                this.AddS(DXFTables.SObjects_R14);
            }
            this.AddS(DXFTables.SEndOfDXF);
            this.SaveToStream(aS, this.current);
            this.current = current;
           // MessageBox.Show("DXF Export trial version");
        }

        private void SaveToStream(StreamWriter aS, ArrayList aDt)
        {
            for (int i = 0; i < aDt.Count; i++)
            {
                if (aDt[i] is string)
                {
                    aS.WriteLine(aDt[i]);
                }
                if (aDt[i] is string[])
                {
                    for (int j = 0; j < ((string[])aDt[i]).Length; j++)
                    {
                        aS.WriteLine(((string[])aDt[i])[j]);
                    }
                }
                if (aDt[i] is ArrayList)
                {
                    this.SaveToStream(aS, (ArrayList)aDt[i]);
                }
            }
        }

        private void SetCurrentLayer(DXFLayer Value)
        {
            this.currentLayer = Value;
            this.nameCurrentLayer = this.currentLayer.Name;
            if (this.layers.IndexOf(Value) == -1)
            {
                this.layers.Add(this.currentLayer);
            }
        }

        public void SetLayerByString(string aName)
        {
            for (int i = 0; i < this.layers.Count; i++)
            {
                if (((DXFLayer)this.layers[i]).Name == aName)
                {
                    this.currentLayer = (DXFLayer)this.layers[i];
                }
            }
        }

        private string SpecialFormat(int aDt)
        {
            string str = "";
            if (aDt < 100)
            {
                if (aDt < 10)
                {
                    str = "  ";
                }
                else
                {
                    str = " ";
                }
            }
            return (str + aDt);
        }

        // Properties
        public string Block
        {
            get
            {
                return this.block;
            }
            set
            {
                this.BeginBlock(value);
            }
        }

        public DXFLayer CurrentLayer
        {
            get
            {
                return this.currentLayer;
            }
            set
            {
                this.currentLayer = (DXFLayer)value.Clone();
                this.nameCurrentLayer = this.currentLayer.Name;
                if (this.layers.IndexOf(value) == -1)
                {
                    this.layers.Add(this.currentLayer);
                }
            }
        }

        public float PenWidthRatio
        {
            get
            {
                return this.penWidthRatio;
            }
            set
            {
                this.penWidthRatio = value;
            }
        }

    }
}