HYTOS

/////////////////////////////////////////////////////////////////////////////// 

// Copyright (C) 2002-2019, Open Design Alliance (the "Alliance"). 

// All rights reserved. 

// 

// This software and its documentation and related materials are owned by 

// the Alliance. The software may only be incorporated into application 

// programs owned by members of the Alliance, subject to a signed 

// Membership Agreement and Supplemental Software License Agreement with the

// Alliance. The structure and organization of this software are the valuable  

// trade secrets of the Alliance and its suppliers. The software is also 

// protected by copyright law and international treaty provisions. Application  

// programs incorporating this software must include the following statement 

// with their copyright notices:

//   

//   This application incorporates Open Design Alliance software pursuant to a license 

//   agreement with Open Design Alliance.

//   Open Design Alliance Copyright (C) 2002-2019 by Open Design Alliance. 

//   All rights reserved.

//

// By use of this software, its documentation or related materials, you 

// acknowledge and accept the above terms.

///////////////////////////////////////////////////////////////////////////////

using System;

using System.Collections.Generic;

using System.Text;

using System.IO;

using System.Xml;

using Teigha.DatabaseServices;

using Teigha.Geometry;

using Teigha.GraphicsInterface;

using Teigha.Colors;

using Teigha;

// note that GetObject doesn't work in Acad 2009, so we use "obsolete" Open instead

#pragma warning disable 618

namespace OdReadExMgd

{

  class DbDumper

  {

    public DbDumper() { }

    static string toDegreeString(double val)

    {

      return (val * 180.0 / Math.PI) + "d";

    }

    static string toHexString(int val)

    {

      return string.Format("0{0:X}", val);

    }

    static string toArcSymbolTypeString(int val)

    {

      switch (val)

      {

        case 0: return "Precedes text";

        case 1: return "Above text";

        case 2: return "None";

      }

      return "???";

    }

    /************************************************************************/

    /* Shorten a path with ellipses.                                        */

    /************************************************************************/

    static string shortenPath(string Inpath, int maxPath)

    {

      string path = Inpath;

      /**********************************************************************/

      /* If the path fits, just return it                                   */

      /**********************************************************************/

      if (path.Length <= maxPath)

      {

        return path;

      }

      /**********************************************************************/

      /* If there's no backslash, just truncate the path                    */

      /**********************************************************************/

      int lastBackslash = path.LastIndexOf('\\');

      if (lastBackslash < 0)

      {

        return path.Substring(0, maxPath - 3) + "...";

      }

      /**********************************************************************/

      /* Shorten the front of the path                                      */

      /**********************************************************************/

      int fromLeft = (lastBackslash - 3) - (path.Length - maxPath);

      // (12 - 3) - (19 - 10) = 9 - 9 = 0 

      if ((lastBackslash <= 3) || (fromLeft < 1))

      {

        path = "..." + path.Substring(lastBackslash);

      }

      else

      {

        path = path.Substring(0, fromLeft) + "..." + path.Substring(lastBackslash);

      }

      /**********************************************************************/

      /* Truncate the path                                                  */

      /**********************************************************************/

      if (path.Length > maxPath)

      {

        path = path.Substring(0, maxPath - 3) + "...";

      }

      return path;

    }

    static string shortenPath(string Inpath)

    {

      return shortenPath(Inpath, 40);

    }

    /************************************************************************/

    /* Output a string in the form                                          */

    /*   leftString:. . . . . . . . . . . .rightString                      */

    /************************************************************************/

    static void writeLine(int indent, object leftString, object rightString, int colWidth)

    {

      string spaces = "                                                            ";

      string leader = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ";

      const int tabSize = 2;

      /**********************************************************************/

      /* Indent leftString with spaces characters                           */

      /**********************************************************************/

      string newleftString = spaces.Substring(0, tabSize * indent) + leftString.ToString();

      /**********************************************************************/

      /* If rightString is not specified, just output the indented          */

      /* leftString. Otherwise, fill the space between leftString and       */

      /* rightString with leader characters.                                */

      /**********************************************************************/

      if (rightString == null || ((rightString is string) && ((string)rightString) == ""))

      {

        Console.WriteLine(newleftString);

      }

      else

      {

        int leaders = colWidth - newleftString.Length;

        if (leaders > 0)

        {

          Console.WriteLine(newleftString + leader.Substring(newleftString.Length, leaders) + rightString.ToString());

        }

        else

        {

          Console.WriteLine(newleftString + ' ' + rightString.ToString());

        }

      }

    }

    static void writeLine(int indent, object leftString, object rightString)

    {

      writeLine(indent, leftString, rightString, 38);

    }

    static void writeLine(int indent, object leftString)

    {

      writeLine(indent, leftString, null, 38);

    }

    static void writeLine()

    {

      Console.WriteLine();

    }

    static void dumpEntityData(Entity pEnt, int indent)

    {

      try

      {

        Extents3d ext = pEnt.GeometricExtents;

        writeLine(indent, "Min Extents", ext.MinPoint);

        writeLine(indent, "Max Extents", ext.MaxPoint);

      }

      catch (System.Exception)

      {

      }

      writeLine(indent, "Layer", pEnt.Layer);

      writeLine(indent, "Color Index", pEnt.ColorIndex);

      writeLine(indent, "Color", pEnt.Color);

      writeLine(indent, "Linetype", pEnt.Linetype);

      writeLine(indent, "LTscale", pEnt.LinetypeScale);

      writeLine(indent, "Lineweight", pEnt.LineWeight);

      writeLine(indent, "Plot Style", pEnt.PlotStyleName);

      writeLine(indent, "Transparency Method", pEnt.Transparency);

      writeLine(indent, "Visibility", pEnt.Visible);

      writeLine(indent, "Planar", pEnt.IsPlanar);

      if (pEnt.IsPlanar)

      {

        try

        {

          CoordinateSystem3d cs = (CoordinateSystem3d)pEnt.GetPlane().GetCoordinateSystem();

          writeLine(indent + 1, "Origin", cs.Origin);

          writeLine(indent + 1, "u-Axis", cs.Xaxis);

          writeLine(indent + 1, "v-Axis", cs.Yaxis);

        }

        catch (System.Exception ex)

        {

          writeLine(indent + 1, "pEnt.GetPlane().GetCoordinateSystem() failed", ex.Message);

        }

      }

    }

    /************************************************************************/

    /* Dump Text data                                                       */

    /************************************************************************/

    static void dumpTextData(DBText pText, int indent)

    {

      writeLine(indent, "Text String", pText.TextString);

      writeLine(indent, "Text Position", pText.Position);

      writeLine(indent, "Default Alignment", pText.IsDefaultAlignment);

      writeLine(indent, "Alignment Point", pText.AlignmentPoint);

      writeLine(indent, "Height", pText.Height);

      writeLine(indent, "Rotation", toDegreeString(pText.Rotation));

      writeLine(indent, "Horizontal Mode", pText.HorizontalMode);

      writeLine(indent, "Vertical Mode", pText.VerticalMode);

      writeLine(indent, "Mirrored in X", pText.IsMirroredInX);

      writeLine(indent, "Mirrored in Y", pText.IsMirroredInY);

      writeLine(indent, "Oblique", toDegreeString(pText.Oblique));

      writeLine(indent, "Text Style", pText.TextStyleName);

      writeLine(indent, "Width Factor", pText.WidthFactor);

      writeLine(indent, "Normal", pText.Normal);

      writeLine(indent, "Thickness", pText.Thickness);

      dumpEntityData(pText, indent);

            /// write text information to xml file

        if(Program.xml != null)

        {

            XmlNode text = Program.xml.CreateElement("Text");

                XmlNode loc = Program.xml.CreateElement("Location");

                loc.InnerText = string.Format("{0},{1}", pText.Position.X * Program.Scale + Program.OffsetX, pText.Position.Y * Program.Scale + Program.OffsetY + pText.Height * Program.Scale);

                text.AppendChild(loc);

                XmlNode value = Program.xml.CreateElement("Value");

                value.InnerText = pText.TextString.Replace("%%U", "");

                text.AppendChild(value);

                XmlNode angle = Program.xml.CreateElement("Angle");

                angle.InnerText = pText.Rotation.ToString();

                text.AppendChild(angle);

                XmlNode width = Program.xml.CreateElement("Width");

                width.InnerText = String.Format("{0}", pText.WidthFactor * pText.Height * pText.TextString.Length * Program.Scale);

                text.AppendChild(width);

                XmlNode height = Program.xml.CreateElement("Height");

                height.InnerText = (pText.Height * Program.Scale).ToString();

                text.AppendChild(height);

            Program.xml.DocumentElement.AppendChild(text);

        }

    }

    /************************************************************************/

    /* Dump Attribute data                                                  */

    /************************************************************************/

    static void dumpAttributeData(int indent, AttributeReference pAttr, int i)

    {

      writeLine(indent++, pAttr.GetRXClass().Name, i);

      writeLine(indent, "Handle", pAttr.Handle);

      writeLine(indent, "Tag", pAttr.Tag);

      writeLine(indent, "Field Length", pAttr.FieldLength);

      writeLine(indent, "Invisible", pAttr.Invisible);

      writeLine(indent, "Preset", pAttr.IsPreset);

      writeLine(indent, "Verifiable", pAttr.IsVerifiable);

      writeLine(indent, "Locked in Position", pAttr.LockPositionInBlock);

      writeLine(indent, "Constant", pAttr.IsConstant);

      dumpTextData(pAttr, indent);

    }

    /************************************************************************/

    /* Dump Block Reference Data                                             */

    /************************************************************************/

    static void dumpBlockRefData(BlockReference pBlkRef, int indent)

    {

      writeLine(indent, "Position", pBlkRef.Position);

      writeLine(indent, "Rotation", toDegreeString(pBlkRef.Rotation));

      writeLine(indent, "Scale Factors", pBlkRef.ScaleFactors);

      writeLine(indent, "Normal", pBlkRef.Normal);

      writeLine(indent, "Name", pBlkRef.Name);

      Matrix3d blockTransform = pBlkRef.BlockTransform;

      CoordinateSystem3d cs = blockTransform.CoordinateSystem3d;

      writeLine(indent + 1, "Origin", cs.Origin);

      writeLine(indent + 1, "u-Axis", cs.Xaxis);

      writeLine(indent + 1, "v-Axis", cs.Yaxis);

      writeLine(indent + 1, "z-Axis", cs.Zaxis);

      dumpEntityData(pBlkRef, indent);

      /**********************************************************************/

      /* Dump the attributes                                                */

      /**********************************************************************/

      int i = 0;

      AttributeCollection attCol = pBlkRef.AttributeCollection;

      foreach (ObjectId id in attCol)

      {

        try

        {

          using (AttributeReference pAttr = (AttributeReference)id.Open(OpenMode.ForRead))

            dumpAttributeData(indent, pAttr, i++);

        }

        catch (System.Exception)

        {

        }

      }

    }

    /************************************************************************/

    /* Dump data common to all OdDbCurves                                   */

    /************************************************************************/

    static void dumpCurveData(Entity pEnt, int indent)

    {

      Curve pEntity = (Curve)pEnt;

      try

      {

        writeLine(indent, "Start Point", pEntity.StartPoint);

        writeLine(indent, "End Point", pEntity.EndPoint);

      }

      catch (System.Exception)

      {

      }

      writeLine(indent, "Closed", pEntity.Closed);

      writeLine(indent, "Periodic", pEntity.IsPeriodic);

      try

      {

        writeLine(indent, "Area", pEntity.Area);

      }

      catch (System.Exception)

      {

      }

      dumpEntityData(pEntity, indent);

    }

    /************************************************************************/

    /* Dump Dimension data                                                  */

    /************************************************************************/

    static void dumpDimData(Dimension pDim, int indent)

    {

      writeLine(indent, "Measurement", pDim.CurrentMeasurement);

      writeLine(indent, "Dimension Text", pDim.DimensionText);

      if (pDim.CurrentMeasurement >= 0.0)

      {

        writeLine(indent, "Formatted Measurement", pDim.FormatMeasurement(pDim.CurrentMeasurement, pDim.DimensionText));

      }

      if (pDim.DimBlockId.IsNull)

      {

        writeLine(indent, "Dimension Block NULL");

      }

      else

      {

        using (BlockTableRecord btr = (BlockTableRecord)pDim.DimBlockId.Open(OpenMode.ForRead))

          writeLine(indent, "Dimension Block Name", btr.Name);

      }

      writeLine(indent + 1, "Position", pDim.DimBlockPosition);

      writeLine(indent, "Text Position", pDim.TextPosition);

      writeLine(indent, "Text Rotation", toDegreeString(pDim.TextRotation));

      writeLine(indent, "Dimension Style", pDim.DimensionStyleName);

      writeLine(indent, "Background Text Color", pDim.Dimtfillclr);

      writeLine(indent, "BackgroundText Flags", pDim.Dimtfill);

      writeLine(indent, "Extension Line 1 Linetype", pDim.Dimltex1);

      writeLine(indent, "Extension Line 2 Linetype", pDim.Dimltex2);

      writeLine(indent, "Dimension Line Linetype", pDim.Dimltype);

      writeLine(indent, "Horizontal Rotation", toDegreeString(pDim.HorizontalRotation));

      writeLine(indent, "Elevation", pDim.Elevation);

      writeLine(indent, "Normal", pDim.Normal);

      dumpEntityData(pDim, indent);

    }

    /************************************************************************/

    /* 2 Line Angular Dimension Dumper                                      */

    /************************************************************************/

    static void dump(LineAngularDimension2 pDim, int indent)

    {

      writeLine(indent++, pDim.GetRXClass().Name, pDim.Handle);

      writeLine(indent, "Arc Point", pDim.ArcPoint);

      writeLine(indent, "Extension Line 1 Start", pDim.XLine1Start);

      writeLine(indent, "Extension Line 1 End", pDim.XLine1End);

      writeLine(indent, "Extension Line 2 Start", pDim.XLine2Start);

      writeLine(indent, "Extension Line 2 End", pDim.XLine2End);

      dumpDimData(pDim, indent);

    }

    /************************************************************************/

    /* Dump 2D Vertex data                                                  */

    /************************************************************************/

    static void dump2dVertex(int indent, Vertex2d pVertex, int i)

    {

      writeLine(indent++, pVertex.GetRXClass().Name, i);

      writeLine(indent, "Handle", pVertex.Handle);

      writeLine(indent, "Vertex Type", pVertex.VertexType);

      writeLine(indent, "Position", pVertex.Position);

      writeLine(indent, "Start Width", pVertex.StartWidth);

      writeLine(indent, "End Width", pVertex.EndWidth);

      writeLine(indent, "Bulge", pVertex.Bulge);

      if (pVertex.Bulge != 0)

      {

        writeLine(indent, "Bulge Angle", toDegreeString(4 * Math.Atan(pVertex.Bulge)));

      }

      writeLine(indent, "Tangent Used", pVertex.TangentUsed);

      if (pVertex.TangentUsed)

      {

        writeLine(indent, "Tangent", pVertex.Tangent);

      }

    }

    /************************************************************************/

    /* 2D Polyline Dumper                                                   */

    /************************************************************************/

    static void dump(Polyline2d pPolyline, int indent)

    {

      writeLine(indent++, pPolyline.GetRXClass().Name, pPolyline.Handle);

      writeLine(indent, "Elevation", pPolyline.Elevation);

      writeLine(indent, "Normal", pPolyline.Normal);

      writeLine(indent, "Thickness", pPolyline.Thickness);

      /********************************************************************/

      /* Dump the vertices                                                */

      /********************************************************************/

      int i = 0;

      foreach (ObjectId obj in pPolyline)

      {

        using (DBObject dbObj = (DBObject)obj.GetObject(OpenMode.ForRead))

        {

          if (dbObj is Vertex2d)

          {

            dump2dVertex(indent, (Vertex2d)dbObj, i++);

          }

        }

      }

      dumpCurveData(pPolyline, indent);

    }

    /************************************************************************/

    /* Dump 3D Polyline Vertex data                                         */

    /************************************************************************/

    void dump3dPolylineVertex(int indent, PolylineVertex3d pVertex, int i)

    {

      writeLine(indent++, pVertex.GetRXClass().Name, i);

      writeLine(indent, "Handle", pVertex.Handle);

      writeLine(indent, "Type", pVertex.VertexType);

      writeLine(indent, "Position", pVertex.Position);

    }

    /************************************************************************/

    /* 3D Polyline Dumper                                                   */

    /************************************************************************/

    void dump(Polyline3d pPolyline, int indent)

    {

      writeLine(indent++, pPolyline.GetRXClass().Name, pPolyline.Handle);

      /********************************************************************/

      /* Dump the vertices                                                */

      /********************************************************************/

      int i = 0;

      foreach (ObjectId obj in pPolyline)

      {

        using (DBObject dbObj = (DBObject)obj.GetObject(OpenMode.ForRead))

        {

          if (dbObj is PolylineVertex3d)

          {

            dump3dPolylineVertex(indent, (PolylineVertex3d)dbObj, i++);

          }

        }

      }

      dumpCurveData(pPolyline, indent);

    }

    /************************************************************************/

    /* 3DSolid Dumper                                                       */

    /************************************************************************/

    void dump(Solid3d pSolid, int indent)

    {

      writeLine(indent++, pSolid.GetRXClass().Name, pSolid.Handle);

      dumpEntityData(pSolid, indent);

    }

    /************************************************************************/

    /* 3 Point Angular Dimension Dumper                                     */

    /************************************************************************/

    void dump(Point3AngularDimension pDim, int indent)

    {

      writeLine(indent++, pDim.GetRXClass().Name, pDim.Handle);

      writeLine(indent, "Arc Point", pDim.ArcPoint);

      writeLine(indent, "Center Point", pDim.CenterPoint);

      writeLine(indent, "Extension Line 1 Point", pDim.XLine1Point);

      writeLine(indent, "Extension Line 2 Point", pDim.XLine2Point);

      dumpDimData(pDim, indent);

    }

    /************************************************************************/

    /* Aligned Dimension Dumper                                             */

    /************************************************************************/

    void dump(AlignedDimension pDim, int indent)

    {

      writeLine(indent++, pDim.GetRXClass().Name, pDim.Handle);

      writeLine(indent, "Dimension line Point", pDim.DimLinePoint);

      writeLine(indent, "Oblique", toDegreeString(pDim.Oblique));

      writeLine(indent, "Extension Line 1 Point", pDim.XLine1Point);

      writeLine(indent, "Extension Line 2 Point", pDim.XLine2Point);

      dumpDimData(pDim, indent);

    }

    /************************************************************************/

    /* Arc Dumper                                                           */

    /************************************************************************/

    void dump(Arc pArc, int indent)

    {

      writeLine(indent++, pArc.GetRXClass().Name, pArc.Handle);

      writeLine(indent, "Center", pArc.Center);

      writeLine(indent, "Radius", pArc.Radius);

      writeLine(indent, "Start Angle", toDegreeString(pArc.StartAngle));

      writeLine(indent, "End Angle", toDegreeString(pArc.EndAngle));

      writeLine(indent, "Normal", pArc.Normal);

      writeLine(indent, "Thickness", pArc.Thickness);

      dumpCurveData(pArc, indent);

    }

    /************************************************************************/

    /* Arc Dimension Dumper                                                 */

    /************************************************************************/

    void dump(ArcDimension pDim, int indent)

    {

      writeLine(indent++, pDim.GetRXClass().Name, pDim.Handle);

      writeLine(indent, "Arc Point", pDim.ArcPoint);

      writeLine(indent, "Center Point", pDim.CenterPoint);

      writeLine(indent, "Arc symbol", toArcSymbolTypeString(pDim.ArcSymbolType));

      writeLine(indent, "Partial", pDim.IsPartial);

      writeLine(indent, "Has leader", pDim.HasLeader);

      if (pDim.HasLeader)

      {

        writeLine(indent, "Leader 1 Point", pDim.Leader1Point);

        writeLine(indent, "Leader 2 Point", pDim.Leader2Point);

      }

      writeLine(indent, "Extension Line 1 Point", pDim.XLine1Point);

      writeLine(indent, "Extension Line 2 Point", pDim.XLine2Point);

      dumpDimData(pDim, indent);

    }

    /************************************************************************/

    /* Block Reference Dumper                                                */

    /************************************************************************/

    void dump(BlockReference pBlkRef, int indent)

    {

      writeLine(indent++, pBlkRef.GetRXClass().Name, pBlkRef.Handle);

      using (BlockTableRecord pRecord = (BlockTableRecord)pBlkRef.BlockTableRecord.Open(OpenMode.ForRead))

      {

        writeLine(indent, "Name", pRecord.Name);

        dumpBlockRefData(pBlkRef, indent);

        /********************************************************************/

        /* Dump the Spatial Filter  (Xref Clip)                             */

        /********************************************************************/

        // TODO:

        /*

        Filters.SpatialFilter pFilt = 

        {

          writeLine(indent++, pFilt.GetRXClass().Name,   pFilt.Handle);

          writeLine(indent, "Normal",                    pFilt.Definition.Normal);

          writeLine(indent, "Elevation",                 pFilt.Definition.Elevation);

          writeLine(indent, "Front Clip Distance",       pFilt.Definition.FrontClip);

          writeLine(indent, "Back Clip Distance",        pFilt.Definition.BackClip);

          writeLine(indent, "Enabled",                   pFilt.Definition.Enabled);

          foreach (Point2d p in pFilt.Definition.GetPoints())

          {

            writeLine(indent, string.Format("Clip point %d",i), p);

          }

        }

         */

      }

    }

    /************************************************************************/

    /* Body Dumper                                                          */

    /************************************************************************/

    void dump(Body pBody, int indent)

    {

      writeLine(indent++, pBody.GetRXClass().Name, pBody.Handle);

      dumpEntityData(pBody, indent);

    }

    /************************************************************************/

    /* Circle Dumper                                                        */

    /************************************************************************/

    void dump(Circle pCircle, int indent)

    {

      writeLine(indent++, pCircle.GetRXClass().Name, pCircle.Handle);

      writeLine(indent, "Center", pCircle.Center);

      writeLine(indent, "Radius", pCircle.Radius);

      writeLine(indent, "Normal", pCircle.Normal);

      writeLine(indent, "Thickness", pCircle.Thickness);

      dumpCurveData(pCircle, indent);

    }

    /************************************************************************/

    /* Diametric Dimension Dumper                                           */

    /************************************************************************/

    void dump(DiametricDimension pDim, int indent)

    {

      writeLine(indent++, pDim.GetRXClass().Name, pDim.Handle);

      writeLine(indent, "Chord Point", pDim.ChordPoint);

      writeLine(indent, "Far chord Point", pDim.FarChordPoint);

      writeLine(indent, "Leader Length", pDim.LeaderLength);

      dumpDimData(pDim, indent);

    }

    /************************************************************************/

    /* Ellipse Dumper                                                       */

    /************************************************************************/

    void dump(Ellipse pEllipse, int indent)

    {

      writeLine(indent++, pEllipse.GetRXClass().Name, pEllipse.Handle);

      writeLine(indent, "Center", pEllipse.Center);

      writeLine(indent, "Major Axis", pEllipse.MajorAxis);

      writeLine(indent, "Minor Axis", pEllipse.MinorAxis);

      writeLine(indent, "Major Radius", pEllipse.MajorAxis.Length);

      writeLine(indent, "Minor Radius", pEllipse.MinorAxis.Length);

      writeLine(indent, "Radius Ratio", pEllipse.RadiusRatio);

      writeLine(indent, "Start Angle", toDegreeString(pEllipse.StartAngle));

      writeLine(indent, "End Angle", toDegreeString(pEllipse.EndAngle));

      writeLine(indent, "Normal", pEllipse.Normal);

      dumpCurveData(pEllipse, indent);

    }

    /************************************************************************/

    /* Face Dumper                                                       */

    /************************************************************************/

    void dump(Face pFace, int indent)

    {

      writeLine(indent++, pFace.GetRXClass().Name, pFace.Handle);

      for (short i = 0; i < 4; i++)

      {

        writeLine(indent, string.Format("Vertex {0} ", i), pFace.GetVertexAt(i));

      }

      for (short i = 0; i < 4; i++)

      {

        writeLine(indent, string.Format("Edge {0} visible", i), pFace.IsEdgeVisibleAt(i));

      }

      dumpEntityData(pFace, indent);

    }

    /************************************************************************/

    /* FCF Dumper                                                           */

    /************************************************************************/

    void dump(FeatureControlFrame pFcf, int indent)

    {

      writeLine(indent++, pFcf.GetRXClass().Name, pFcf.Handle);

      writeLine(indent, "Location", pFcf.Location);

      writeLine(indent, "Text", pFcf.Text);

      writeLine(indent, "Dimension Style", pFcf.DimensionStyleName);

      writeLine(indent, "Dimension Gap", pFcf.Dimgap);

      writeLine(indent, "Dimension Scale", pFcf.Dimscale);

      writeLine(indent, "Text Height", pFcf.Dimtxt);

      writeLine(indent, "Frame Color", pFcf.Dimclrd);

      writeLine(indent, "Text Style", pFcf.TextStyleName);

      writeLine(indent, "Text Color", pFcf.Dimclrd);

      writeLine(indent, "X-Direction", pFcf.Direction);

      writeLine(indent, "Normal", pFcf.Normal);

      dumpEntityData(pFcf, indent);

    }

    /************************************************************************/

    /* Hatch Dumper                                                         */

    /************************************************************************/

    /***********************************************************************/

    /* Dump Polyline Loop                                                  */

    /***********************************************************************/

    static void dumpPolylineType(int loopIndex, Hatch pHatch, int indent)

    {

      HatchLoop hl = pHatch.GetLoopAt(loopIndex);

      for (int i = 0; i < hl.Polyline.Count; i++)

      {

        BulgeVertex bv = hl.Polyline[i];

        writeLine(indent, "Vertex " + i.ToString(), bv.Vertex.ToString());

        writeLine(indent + 1, "Bulge " + i.ToString(), bv.Bulge);

        writeLine(indent + 1, "Bulge angle " + i.ToString(), toDegreeString(4 * Math.Atan(bv.Bulge)));

      }

    }

    /**********************************************************************/

    /* Dump Circular Arc Edge                                             */

    /**********************************************************************/

    static void dumpCircularArcEdge(int indent, CircularArc2d pCircArc)

    {

      writeLine(indent, "Center", pCircArc.Center);

      writeLine(indent, "Radius", pCircArc.Radius);

      writeLine(indent, "Start Angle", toDegreeString(pCircArc.StartAngle));

      writeLine(indent, "End Angle", toDegreeString(pCircArc.EndAngle));

      writeLine(indent, "Clockwise", pCircArc.IsClockWise);

    }

    /**********************************************************************/

    /* Dump Elliptical Arc Edge                                           */

    /**********************************************************************/

    static void dumpEllipticalArcEdge(int indent, EllipticalArc2d pEllipArc)

    {

      writeLine(indent, "Center", pEllipArc.Center);

      writeLine(indent, "Major Radius", pEllipArc.MajorRadius);

      writeLine(indent, "Minor Radius", pEllipArc.MinorRadius);

      writeLine(indent, "Major Axis", pEllipArc.MajorAxis);

      writeLine(indent, "Minor Axis", pEllipArc.MinorAxis);

      writeLine(indent, "Start Angle", toDegreeString(pEllipArc.StartAngle));

      writeLine(indent, "End Angle", toDegreeString(pEllipArc.EndAngle));

      writeLine(indent, "Clockwise", pEllipArc.IsClockWise);

    }

    /**********************************************************************/

    /* Dump NurbCurve Edge                                           */

    /**********************************************************************/

    static void dumpNurbCurveEdge(int indent, NurbCurve2d pNurbCurve)

    {

      NurbCurve2dData d = pNurbCurve.DefinitionData;

      writeLine(indent, "Degree", d.Degree);

      writeLine(indent, "Rational", d.Rational);

      writeLine(indent, "Periodic", d.Periodic);

      writeLine(indent, "Number of Control Points", d.ControlPoints.Count);

      for (int i = 0; i < d.ControlPoints.Count; i++)

      {

        writeLine(indent, "Control Point " + i.ToString(), d.ControlPoints[i]);

      }

      writeLine(indent, "Number of Knots", d.Knots.Count);

      for (int i = 0; i < d.Knots.Count; i++)

      {

        writeLine(indent, "Knot " + i.ToString(), d.Knots[i]);

      }

      if (d.Rational)

      {

        writeLine(indent, "Number of Weights", d.Weights.Count);

        for (int i = 0; i < d.Weights.Count; i++)

        {

          writeLine(indent, "Weight " + i.ToString(), d.Weights[i]);

        }

      }

    }

    /***********************************************************************/

    /* Dump Edge Loop                                                      */

    /***********************************************************************/

    static void dumpEdgesType(int loopIndex, Hatch pHatch, int indent)

    {

      Curve2dCollection edges = pHatch.GetLoopAt(loopIndex).Curves;

      for (int i = 0; i < (int)edges.Count; i++)

      {

        using (Curve2d pEdge = edges[i])

        {

          writeLine(indent, string.Format("Edge {0}", i), pEdge.GetType().Name);

          switch (pEdge.GetType().Name)

          {

            case "LineSegment2d":

              break;

            case "CircularArc2d":

              dumpCircularArcEdge(indent + 1, (CircularArc2d)pEdge);

              break;

            case "EllipticalArc2d":

              dumpEllipticalArcEdge(indent + 1, (EllipticalArc2d)pEdge);

              break;

            case "NurbCurve2d":

              dumpNurbCurveEdge(indent + 1, (NurbCurve2d)pEdge);

              break;

          }

          /******************************************************************/

          /* Common Edge Properties                                         */

          /******************************************************************/

          Interval interval = pEdge.GetInterval();

          writeLine(indent + 1, "Start Point", pEdge.EvaluatePoint(interval.LowerBound));

          writeLine(indent + 1, "End Point", pEdge.EvaluatePoint(interval.UpperBound));

          writeLine(indent + 1, "Closed", pEdge.IsClosed());

        }

      }

    }

    /************************************************************************/

    /* Convert the specified value to a LoopType string                     */

    /************************************************************************/

    string toLooptypeString(HatchLoopTypes loopType)

    {

      string retVal = "";

      if ((loopType & HatchLoopTypes.External) != 0)

        retVal = retVal + " | kExternal";

      if ((loopType & HatchLoopTypes.Polyline) != 0)

        retVal = retVal + " | kPolyline";

      if ((loopType & HatchLoopTypes.Derived) != 0)

        retVal = retVal + " | kDerived";

      if ((loopType & HatchLoopTypes.Textbox) != 0)

        retVal = retVal + " | kTextbox";

      if ((loopType & HatchLoopTypes.Outermost) != 0)

        retVal = retVal + " | kOutermost";

      if ((loopType & HatchLoopTypes.NotClosed) != 0)

        retVal = retVal + " | kNotClosed";

      if ((loopType & HatchLoopTypes.SelfIntersecting) != 0)

        retVal = retVal + " | kSelfIntersecting";

      if ((loopType & HatchLoopTypes.TextIsland) != 0)

        retVal = retVal + " | kTextIsland";

      if ((loopType & HatchLoopTypes.Duplicate) != 0)

        retVal = retVal + " | kDuplicate";

      return retVal == "" ? "kDefault" : retVal.Substring(3);

    }

    void dump(Hatch pHatch, int indent)

    {

      writeLine(indent++, pHatch.GetRXClass().Name, pHatch.Handle);

      writeLine(indent, "Hatch Style", pHatch.HatchStyle);

      writeLine(indent, "Hatch Object Type", pHatch.HatchObjectType);

      writeLine(indent, "Is Hatch", pHatch.IsHatch);

      writeLine(indent, "Is Gradient", !pHatch.IsGradient);

      if (pHatch.IsHatch)

      {

        /******************************************************************/

        /* Dump Hatch Parameters                                          */

        /******************************************************************/

        writeLine(indent, "Pattern Type", pHatch.PatternType);

        switch (pHatch.PatternType)

        {

          case HatchPatternType.PreDefined:

          case HatchPatternType.CustomDefined:

            writeLine(indent, "Pattern Name", pHatch.PatternName);

            writeLine(indent, "Solid Fill", pHatch.IsSolidFill);

            if (!pHatch.IsSolidFill)

            {

              writeLine(indent, "Pattern Angle", toDegreeString(pHatch.PatternAngle));

              writeLine(indent, "Pattern Scale", pHatch.PatternScale);

            }

            break;

          case HatchPatternType.UserDefined:

            writeLine(indent, "Pattern Angle", toDegreeString(pHatch.PatternAngle));

            writeLine(indent, "Pattern Double", pHatch.PatternDouble);

            writeLine(indent, "Pattern Space", pHatch.PatternSpace);

            break;

        }

        DBObjectCollection entitySet = new DBObjectCollection();

        Handle hhh = pHatch.Handle;

        if (hhh.Value == 1692) //69C)

        {

          pHatch.Explode(entitySet);

          return;

        }

        if (hhh.Value == 1693) //69D)

        {

          try

          {

            pHatch.Explode(entitySet);

          }

          catch (System.Exception e)

          {

            if (e.Message == "eCannotExplodeEntity")

            {

              writeLine(indent, "Hatch " + e.Message + ": ", pHatch.Handle);

              return;

            }

          }

        }

      }

      if (pHatch.IsGradient)

      {

        /******************************************************************/

        /* Dump Gradient Parameters                                       */

        /******************************************************************/

        writeLine(indent, "Gradient Type", pHatch.GradientType);

        writeLine(indent, "Gradient Name", pHatch.GradientName);

        writeLine(indent, "Gradient Angle", toDegreeString(pHatch.GradientAngle));

        writeLine(indent, "Gradient Shift", pHatch.GradientShift);

        writeLine(indent, "Gradient One-Color Mode", pHatch.GradientOneColorMode);

        if (pHatch.GradientOneColorMode)

        {

          writeLine(indent, "ShadeTintValue", pHatch.ShadeTintValue);

        }

        GradientColor[] colors = pHatch.GetGradientColors();

        for (int i = 0; i < colors.Length; i++)

        {

          writeLine(indent, string.Format("Color         {0}", i), colors[i].get_Color());

          writeLine(indent, string.Format("Interpolation {0}", i), colors[i].get_Value());

        }

      }

      /********************************************************************/

      /* Dump Associated Objects                                          */

      /********************************************************************/

      writeLine(indent, "Associated objects", pHatch.Associative);

      foreach (ObjectId id in pHatch.GetAssociatedObjectIds())

      {

        writeLine(indent + 1, id.ObjectClass.Name, id.Handle);

      }

      /********************************************************************/

      /* Dump Loops                                                       */

      /********************************************************************/

      writeLine(indent, "Loops", pHatch.NumberOfLoops);

      for (int i = 0; i < pHatch.NumberOfLoops; i++)

      {

        writeLine(indent + 1, "Loop " + i.ToString(), toLooptypeString(pHatch.LoopTypeAt(i)));

        /******************************************************************/

        /* Dump Loop                                                      */

        /******************************************************************/

        if ((pHatch.LoopTypeAt(i) & HatchLoopTypes.Polyline) != 0)

        {

          dumpPolylineType(i, pHatch, indent + 2);

        }

        else

        {

          dumpEdgesType(i, pHatch, indent + 2);

        }

        /******************************************************************/

        /* Dump Associated Objects                                        */

        /******************************************************************/

        if (pHatch.Associative)

        {

          writeLine(indent + 2, "Associated objects");

          foreach (ObjectId id in pHatch.GetAssociatedObjectIdsAt(i))

          {

            writeLine(indent + 3, id.ObjectClass.Name, id.Handle);

          }

        }

      }

      writeLine(indent, "Elevation", pHatch.Elevation);

      writeLine(indent, "Normal", pHatch.Normal);

      dumpEntityData(pHatch, indent);

    }

    /************************************************************************/

    /* Leader Dumper                                                          */

    /************************************************************************/

    void dump(Leader pLeader, int indent)

    {

      writeLine(indent++, pLeader.GetRXClass().Name, pLeader.Handle);

      writeLine(indent, "Dimension Style", pLeader.DimensionStyleName);

      writeLine(indent, "Annotation");

      if (!pLeader.Annotation.IsNull)

      {

        writeLine(indent++, pLeader.Annotation.ObjectClass.Name, pLeader.Annotation.Handle);

      }

      writeLine(indent + 1, "Type", pLeader.AnnoType);

      writeLine(indent + 1, "Height", pLeader.AnnoHeight);

      writeLine(indent + 1, "Width", pLeader.AnnoWidth);

      writeLine(indent + 1, "Offset", pLeader.AnnotationOffset);

      writeLine(indent, "Has Arrowhead", pLeader.HasArrowHead);

      writeLine(indent, "Has Hook Line", pLeader.HasHookLine);

      writeLine(indent, "Splined", pLeader.IsSplined);

      for (int i = 0; i < pLeader.NumVertices; i++)

      {

        writeLine(indent, string.Format("Vertex {0}", i), pLeader.VertexAt(i));

      }

      writeLine(indent, "Normal", pLeader.Normal);

      dumpCurveData(pLeader, indent);

    }

    /************************************************************************/

    /* Line Dumper                                                          */

    /************************************************************************/

    void dump(Line pLine, int indent)

    {

      writeLine(indent++, pLine.GetRXClass().Name, pLine.Handle);

      writeLine(indent, "Normal", pLine.Normal);

      writeLine(indent, "Thickness", pLine.Thickness);

      dumpEntityData(pLine, indent);

    }

    /************************************************************************/

    /* MInsertBlock Dumper                                                  */

    /************************************************************************/

    void dump(MInsertBlock pMInsert, int indent)

    {

      writeLine(indent++, pMInsert.GetRXClass().Name, pMInsert.Handle);

      using (BlockTableRecord pRecord = (BlockTableRecord)pMInsert.BlockTableRecord.Open(OpenMode.ForRead))

      {

        writeLine(indent, "Name", pRecord.Name);

        writeLine(indent, "Rows", pMInsert.Rows);

        writeLine(indent, "Columns", pMInsert.Columns);

        writeLine(indent, "Row Spacing", pMInsert.RowSpacing);

        writeLine(indent, "Column Spacing", pMInsert.ColumnSpacing);

        dumpBlockRefData(pMInsert, indent);

      }

    }

    /************************************************************************/

    /* Mline Dumper                                                         */

    /************************************************************************/

    void dump(Mline pMline, int indent)

    {

      writeLine(indent++, pMline.GetRXClass().Name, pMline.Handle);

      writeLine(indent, "Style", pMline.Style);

      writeLine(indent, "Closed", pMline.IsClosed);

      writeLine(indent, "Scale", pMline.Scale);

      writeLine(indent, "Suppress Start Caps", pMline.SupressStartCaps);

      writeLine(indent, "Suppress End Caps", pMline.SupressEndCaps);

      writeLine(indent, "Normal", pMline.Normal);

      /********************************************************************/

      /* Dump the segment data                                            */

      /********************************************************************/

      for (int i = 0; i < pMline.NumberOfVertices; i++)

      {

        writeLine(indent, "Segment", i);

        writeLine(indent + 1, "Vertex", pMline.VertexAt(i));

      }

      dumpEntityData(pMline, indent);

    }

    /************************************************************************/

    /* MText Dumper                                                         */

    /************************************************************************/

    void dump(MText pMText, int indent)

    {

      writeLine(indent++, pMText.GetRXClass().Name, pMText.Handle);

      writeLine(indent, "Contents", pMText.Contents);

      writeLine(indent, "Location", pMText.Location);

      writeLine(indent, "Height", pMText.TextHeight);

      writeLine(indent, "Rotation", toDegreeString(pMText.Rotation));

      writeLine(indent, "Text Style Id", pMText.TextStyleId);

      writeLine(indent, "Attachment", pMText.Attachment);

      writeLine(indent, "Background Fill On", pMText.BackgroundFill);

      writeLine(indent, "Background Fill Color", pMText.BackgroundFillColor);

      writeLine(indent, "Background Scale Factor", pMText.BackgroundScaleFactor);

      writeLine(indent, "Background Transparency Method", pMText.BackgroundTransparency);

      writeLine(indent, "X-Direction", pMText.Direction);

      writeLine(indent, "Flow Direction", pMText.FlowDirection);

      writeLine(indent, "Width", pMText.Width);

      writeLine(indent, "Actual Height", pMText.ActualHeight);

      writeLine(indent, "Actual Width", pMText.ActualWidth);

      Point3dCollection points = pMText.GetBoundingPoints();

      writeLine(indent, "TL Bounding Point", points[0]);

      writeLine(indent, "TR Bounding Point", points[1]);

      writeLine(indent, "BL Bounding Point", points[2]);

      writeLine(indent, "BR Bounding Point", points[3]);

      writeLine(indent, "Normal", pMText.Normal);

      dumpEntityData(pMText, indent);

    }

    /************************************************************************/

    /* Ordinate Dimension Dumper                                            */

    /************************************************************************/

    void dump(OrdinateDimension pDim, int indent)

    {

      writeLine(indent++, pDim.GetRXClass().Name, pDim.Handle);

      writeLine(indent, "Defining Point", pDim.DefiningPoint);

      writeLine(indent, "Using x-Axis", pDim.UsingXAxis);

      writeLine(indent, "Using y-Axis", pDim.UsingYAxis);

      writeLine(indent, "Leader End Point", pDim.LeaderEndPoint);

      writeLine(indent, "Origin", pDim.Origin);

      dumpDimData(pDim, indent);

    }

    /************************************************************************/

    /* PolyFaceMesh Dumper                                                  */

    /************************************************************************/

    void dump(PolyFaceMesh pPoly, int indent)

    {

      writeLine(indent++, pPoly.GetRXClass().Name, pPoly.Handle);

      writeLine(indent, "Number of Vertices", pPoly.NumVertices);

      writeLine(indent, "Number of Faces", pPoly.NumFaces);

      /********************************************************************/

      /* dump vertices and faces                                          */

      /********************************************************************/

      int vertexCount = 0;

      int faceCount = 0;

      foreach (ObjectId objId in pPoly)

      {

        using (Entity ent = (Entity)objId.GetObject(OpenMode.ForRead))

        {

          if (ent is PolyFaceMeshVertex)

          {

            PolyFaceMeshVertex pVertex = (PolyFaceMeshVertex)ent;

            writeLine(indent, pVertex.GetRXClass().Name, ++vertexCount);

            writeLine(indent + 1, "Handle", pVertex.Handle);

            writeLine(indent + 1, "Position", pVertex.Position);

            dumpEntityData(pVertex, indent + 1);

          }

          else if (ent is FaceRecord)

          {

            FaceRecord pFace = (FaceRecord)ent;

            string face = "{";

            for (short i = 0; i < 4; i++)

            {

              if (i > 0)

              {

                face = face + " ";

              }

              face = face + pFace.GetVertexAt(i).ToString();

            }

            face += "}";

            writeLine(indent, pFace.GetRXClass().Name, ++faceCount);

            writeLine(indent + 1, "Handle", pFace.Handle);

            writeLine(indent + 1, "Vertices", face);

            dumpEntityData(pFace, indent + 1);

          }

          else

          { // Unknown entity type

            writeLine(indent, "Unexpected Entity");

          }

        }

      }

      dumpEntityData(pPoly, indent);

    }

    /************************************************************************/

    /* Ole2Frame                                                            */

    /************************************************************************/

    void dump(Ole2Frame pOle, int indent)

    {

      writeLine(indent++, pOle.GetRXClass().Name, pOle.Handle);

      Rectangle3d pos = (Rectangle3d)pOle.Position3d;

      writeLine(indent, "Lower Left", pos.LowerLeft);

      writeLine(indent, "Lower Right", pos.LowerRight);

      writeLine(indent, "Upper Left", pos.UpperLeft);

      writeLine(indent, "Upper Right", pos.UpperRight);

      writeLine(indent, "Type", pOle.Type);

      writeLine(indent, "User Type", pOle.UserType);

      if (pOle.Type == Ole2Frame.ItemType.Link)

      {

        writeLine(indent, "Link Name", pOle.LinkName);

        writeLine(indent, "Link Path", pOle.LinkPath);

      }

      writeLine(indent, "Output Quality", pOle.OutputQuality);

      dumpEntityData(pOle, indent);

    }

    /************************************************************************/

    /* Point Dumper                                                         */

    /************************************************************************/

    void dump(DBPoint pPoint, int indent)

    {

      writeLine(indent++, pPoint.GetRXClass().Name, pPoint.Handle);

      writeLine(indent, "Position", pPoint.Position);

      writeLine(indent, "ECS Rotation", toDegreeString(pPoint.EcsRotation));

      writeLine(indent, "Normal", pPoint.Normal);

      writeLine(indent, "Thickness", pPoint.Thickness);

      dumpEntityData(pPoint, indent);

    }

    /************************************************************************/

    /* Polygon Mesh Dumper                                                  */

    /************************************************************************/

    void dump(PolygonMesh pPoly, int indent)

    {

      writeLine(indent++, pPoly.GetRXClass().Name, pPoly.Handle);

      writeLine(indent, "m Size", pPoly.MSize);

      writeLine(indent, "m-Closed", pPoly.IsMClosed);

      writeLine(indent, "m Surface Density", pPoly.MSurfaceDensity);

      writeLine(indent, "n Size", pPoly.NSize);

      writeLine(indent, "n-Closed", pPoly.IsNClosed);

      writeLine(indent, "n Surface Density", pPoly.NSurfaceDensity);

      /********************************************************************/

      /* dump vertices                                                    */

      /********************************************************************/

      int vertexCount = 0;

      foreach (object o in pPoly)

      {

        PolygonMeshVertex pVertex = o as PolygonMeshVertex;

        if (pVertex != null)

        {

          writeLine(indent, pVertex.GetRXClass().Name, vertexCount++);

          writeLine(indent + 1, "Handle", pVertex.Handle);

          writeLine(indent + 1, "Position", pVertex.Position);

          writeLine(indent + 1, "Type", pVertex.VertexType);

        }

      }

      dumpEntityData(pPoly, indent);

    }

    /************************************************************************/

    /* Polyline Dumper                                                      */

    /************************************************************************/

    void dump(Teigha.DatabaseServices.Polyline pPoly, int indent)

    {

      writeLine(indent++, pPoly.GetRXClass().Name, pPoly.Handle);

      writeLine(indent, "Has Width", pPoly.HasWidth);

      if (!pPoly.HasWidth)

      {

        writeLine(indent, "Constant Width", pPoly.ConstantWidth);

      }

      writeLine(indent, "Has Bulges", pPoly.HasBulges);

      writeLine(indent, "Elevation", pPoly.Elevation);

      writeLine(indent, "Normal", pPoly.Normal);

      writeLine(indent, "Thickness", pPoly.Thickness);

      /********************************************************************/

      /* dump vertices                                                    */

      /********************************************************************/

      for (int i = 0; i < pPoly.NumberOfVertices; i++)

      {

        writeLine(indent, string.Format("Vertex {0}", i));

        writeLine(indent + 1, "Segment Type", pPoly.GetSegmentType(i));

        writeLine(indent + 1, "Point", pPoly.GetPoint3dAt(i));

        if (pPoly.HasWidth)

        {

          writeLine(indent, "Start Width", pPoly.GetStartWidthAt(i));

          writeLine(indent, "End Width", pPoly.GetEndWidthAt(i));

        }

        if (pPoly.HasBulges)

        {

          writeLine(indent, "Bulge", pPoly.GetBulgeAt(i));

          if (pPoly.GetSegmentType(i) == SegmentType.Arc)

          {

            writeLine(indent, "Bulge Angle", toDegreeString(4 * Math.Atan(pPoly.GetBulgeAt(i))));

          }

        }

      }

      dumpEntityData(pPoly, indent);

    }

    class DrawContextDumper : Context

    {

      Database _db;

      public DrawContextDumper(Database db)

      {

        _db = db;

      }

      public override Database Database

      {

        get { return _db; }

      }

      public override bool IsBoundaryClipping

      {

        get { return false; }

      }

      public override bool IsPlotGeneration

      {

        get { return false; }

      }

      public override bool IsPostScriptOut

      {

        get { return false; }

      }

    }

    class SubEntityTraitsDumper : SubEntityTraits

    {

      short _color;

      int _drawFlags;

      FillType _ft;

      ObjectId _layer;

      ObjectId _linetype;

      LineWeight _lineWeight;

      Mapper _mapper;

      double _lineTypeScale;

      ObjectId _material;

      PlotStyleDescriptor _plotStyleDescriptor;

      bool _sectionable;

      bool _selectionOnlyGeometry;

      ShadowFlags _shadowFlags;

      double _thickness;

      EntityColor _trueColor;

      Transparency _transparency;

      ObjectId _visualStyle;

      public SubEntityTraitsDumper(Database db)

      {

        _drawFlags = 0; // kNoDrawFlags 

        _color = 0;

        _ft = FillType.FillAlways;

        _layer = db.Clayer;

        _linetype = db.Celtype;

        _lineWeight = db.Celweight;

        _lineTypeScale = db.Celtscale;

        _material = db.Cmaterial;

        _shadowFlags = ShadowFlags.ShadowsIgnore;

        _thickness = 0;

        _trueColor = new EntityColor(ColorMethod.None);

        _transparency = new Transparency();

      }

      protected override void SetLayerFlags(LayerFlags flags)

      {

        writeLine(0, string.Format("SubEntityTraitsDumper.SetLayerFlags(flags = {0})", flags));

      }

      public override void AddLight(ObjectId lightId)

      {

        writeLine(0, string.Format("SubEntityTraitsDumper.AddLight(lightId = {0})", lightId.ToString()));

      }

      public override void SetupForEntity(Entity entity)

      {

        writeLine(0, string.Format("SubEntityTraitsDumper.SetupForEntity(entity = {0})", entity.ToString()));

      }

      public override short Color

      {

        get { return _color; }

        set { _color = value; }

      }

      public override int DrawFlags

      {

        get { return _drawFlags; }

        set { _drawFlags = value; }

      }

      public override FillType FillType

      {

        get { return _ft; }

        set { _ft = value; }

      }

      public override ObjectId Layer

      {

        get { return _layer; }

        set { _layer = value; }

      }

      public override ObjectId LineType

      {

        get { return _linetype; }

        set { _linetype = value; }

      }

      public override double LineTypeScale

      {

        get { return _lineTypeScale; }

        set { _lineTypeScale = value; }

      }

      public override LineWeight LineWeight

      {

        get { return _lineWeight; }

        set { _lineWeight = value; }

      }

      public override Mapper Mapper

      {

        get { return _mapper; }

        set { _mapper = value; }

      }

      public override ObjectId Material

      {

        get { return _material; }

        set { _material = value; }

      }

      public override PlotStyleDescriptor PlotStyleDescriptor

      {

        get { return _plotStyleDescriptor; }

        set { _plotStyleDescriptor = value; }

      }

      public override bool Sectionable

      {

        get { return _sectionable; }

        set { _sectionable = value; }

      }

      public override bool SelectionOnlyGeometry

      {

        get { return _selectionOnlyGeometry; }

        set { _selectionOnlyGeometry = value; }

      }

      public override ShadowFlags ShadowFlags

      {

        get { return _shadowFlags; }

        set { _shadowFlags = value; }

      }

      public override double Thickness

      {

        get { return _thickness; }

        set { _thickness = value; }

      }

      public override EntityColor TrueColor

      {

        get { return _trueColor; }

        set { _trueColor = value; }

      }

      public override Transparency Transparency

      {

        get { return _transparency; }

        set { _transparency = value; }

      }

      public override ObjectId VisualStyle

      {

        get { return _visualStyle; }

        set { _visualStyle = value; }

      }

      public override void SetSelectionMarker(IntPtr sm)

      {

      }

    }

    class WorldGeometryDumper : WorldGeometry

    {

      Stack<Matrix3d> modelMatrix;

      Stack<ClipBoundary> clips;

      int indent;

      public WorldGeometryDumper(int indent)

        : base()

      {

        this.indent = indent;

        modelMatrix = new Stack<Matrix3d>();

        clips = new Stack<ClipBoundary>();

        modelMatrix.Push(Matrix3d.Identity);

      }

      public override Matrix3d ModelToWorldTransform

      {

        get { return modelMatrix.Peek(); }

      }

      public override Matrix3d WorldToModelTransform

      {

        get { return modelMatrix.Peek().Inverse(); }

      }

      public override Matrix3d PushOrientationTransform(OrientationBehavior behavior)

      {

        writeLine(indent, string.Format("WorldGeometry.PushOrientationTransform(behavior = {0})", behavior));

        return new Matrix3d();

      }

      public override Matrix3d PushPositionTransform(PositionBehavior behavior, Point2d offset)

      {

        writeLine(indent, string.Format("WorldGeometry.PushPositionTransform(behavior = {0}, offset = {1})", behavior, offset));

        return new Matrix3d();

      }

      public override Matrix3d PushPositionTransform(PositionBehavior behavior, Point3d offset)

      {

        writeLine(indent, string.Format("WorldGeometry.PushPositionTransform(behavior = {0}, offset = {1})", behavior, offset));

        return new Matrix3d();

      }

      public override bool OwnerDraw(GdiDrawObject gdiDrawObject, Point3d position, Vector3d u, Vector3d v)

      {

        writeLine(indent, string.Format("WorldGeometry.OwnerDraw(gdiDrawObject = {0}, position = {1}, u = {2}, v = {3})", gdiDrawObject, position, u, v));

        return false;

      }

      public override bool Polyline(Teigha.GraphicsInterface.Polyline polylineObj)

      {

        writeLine(indent, string.Format("WorldGeometry.Polyline(value = {0}", polylineObj));

        return false;

      }

      public override bool Polypoint(Point3dCollection points, Vector3dCollection normals, IntPtrCollection subentityMarkers)

      {

        writeLine(indent, string.Format("WorldGeometry.Polypoint(points = {0}, normals = {1}, subentityMarkers = {2}", points, normals, subentityMarkers));

        return false;

      }

      public override bool Polypoint(Point3dCollection points, EntityColorCollection colors, Vector3dCollection normals, IntPtrCollection subentityMarkers)

      {

        writeLine(indent, string.Format("WorldGeometry.Polypoint(points = {0}, colors = {1}, normals = {2}, subentityMarkers = {3}", points, colors, normals, subentityMarkers));

        return false;

      }

      public override bool Polypoint(Point3dCollection points, EntityColorCollection colors, TransparencyCollection transparency, Vector3dCollection normals, IntPtrCollection subentityMarkers, int pointSize)

      {

        writeLine(indent, string.Format("WorldGeometry.Polypoint(points = {0}, colors = {1}, transparency = {2}, normals = {3}, subentityMarkers = {4}, pointSize = {5}", points, colors, transparency, normals, subentityMarkers, pointSize));

        return false;

      }

      public override bool PolyPolyline(Teigha.GraphicsInterface.PolylineCollection polylineCollection)

      {

        writeLine(indent, string.Format("WorldGeometry.PolyPolyline(polylineCollection = {0}", polylineCollection));

        return false;

      }

      public override bool PolyPolygon(UInt32Collection numPolygonPositions, Point3dCollection polygonPositions, UInt32Collection numPolygonPoints, Point3dCollection polygonPoints, EntityColorCollection outlineColors, LinetypeCollection outlineTypes, EntityColorCollection fillColors, Teigha.Colors.TransparencyCollection fillOpacities)

      {

        writeLine(indent, string.Format("WorldGeometry.PolyPolygon(numPolygonPositions = {0}, polygonPositions = {1}, numPolygonPoints = {2}, polygonPoints = {3}, outlineColors = {4}, outlineTypes = {5}, fillColors = {6}, fillOpacities = {7})", numPolygonPositions, polygonPositions, numPolygonPoints, polygonPoints, outlineColors, outlineTypes, fillColors, fillOpacities));

        return false;

      }

      public override Matrix3d PushScaleTransform(ScaleBehavior behavior, Point2d extents)

      {

        writeLine(indent, string.Format("WorldGeometry.PushScaleTransform(behavior = {0}, extents = {1})", behavior, extents));

        return new Matrix3d();

      }

      public override Matrix3d PushScaleTransform(ScaleBehavior behavior, Point3d extents)

      {

        writeLine(indent, string.Format("WorldGeometry.PushScaleTransform(behavior = {0}, extents = {1})", behavior, extents));

        return new Matrix3d();

      }

      public override bool EllipticalArc(Point3d center, Vector3d normal, double majorAxisLength, double minorAxisLength, double startDegreeInRads, double endDegreeInRads, double tiltDegreeInRads, ArcType arType)

      {

        writeLine(indent, string.Format("WorldGeometry.EllipticalArc(center = {0}, normal = {1}, majorAxisLength = {2}, minorAxisLength = {3}, startDegreeInRads = {4}, endDegreeInRads = {5}, tiltDegreeInRads = {6}, arType = {7}", center, normal, majorAxisLength, minorAxisLength, startDegreeInRads, endDegreeInRads, tiltDegreeInRads, arType));

        return false;

      }

      public override bool Circle(Point3d center, double radius, Vector3d normal)

      {

        writeLine(indent, string.Format("WorldGeometry.Circle(center = {0}, radius = {1}, normal = {2})", center, radius, normal));

        return false;

      }

      public override bool Circle(Point3d firstPoint, Point3d secondPoint, Point3d thirdPoint)

      {

        writeLine(indent, string.Format("WorldGeometry.Circle(firstPoint = {0}, secondPoint = {1}, thirdPoint = {2})", firstPoint, secondPoint, thirdPoint));

        return false;

      }

      public override bool CircularArc(Point3d start, Point3d point, Point3d endingPoint, ArcType arcType)

      {

        writeLine(indent, string.Format("WorldGeometry.CircularArc(start = {0}, point = {1}, endingPoint = {2}, arcType = {3})", start, point, endingPoint, arcType));

        return false;

      }

      public override bool CircularArc(Point3d center, double radius, Vector3d normal, Vector3d startVector, double sweepAngle, ArcType arcType)

      {

        writeLine(indent, string.Format("WorldGeometry.CircularArc(center = {0}, radius = {1}, normal = {2}, startVector = {3}, sweepAngle = {4}, arcType = {5}", center, radius, normal, startVector, sweepAngle, arcType));

        return false;

      }

      public override bool Draw(Drawable value)

      {

        writeLine(indent, string.Format("WorldGeometry.Draw(value = {0}", value));

        return false;

      }

      public override bool Image(ImageBGRA32 imageSource, Point3d position, Vector3d u, Vector3d v)

      {

        writeLine(indent, string.Format("WorldGeometry.Image(imageSource = , position = {1}, Vector3d = {2}, Vector3d = {3}", position, u, v));

        return false;

      }

      public override bool Image(ImageBGRA32 imageSource, Point3d position, Vector3d u, Vector3d v, TransparencyMode transparencyMode)

      {

        writeLine(indent, string.Format("WorldGeometry.Image(imageSource = , position = {1}, Vector3d = {2}, Vector3d = {3}, transparencyMode = {4}", position, u, v, transparencyMode));

        return false;

      }

      public override bool Mesh(int rows, int columns, Point3dCollection points, EdgeData edgeData, FaceData faceData, VertexData vertexData, bool bAutoGenerateNormals)

      {

        writeLine(indent, string.Format("WorldGeometry.Mesh(rows = {0}, columns = {1}, points = {2}, edgeData = {3}, faceData = {4}, vertexData = {5}, bAutoGenerateNormals = {6})", rows, columns, points, edgeData, faceData, vertexData, bAutoGenerateNormals));

        return false;

      }

      public override bool Polygon(Point3dCollection points)

      {

        writeLine(indent, string.Format("WorldGeometry.Polygon(points = {0})", points));

        return false;

      }

      public override bool Polyline(Teigha.DatabaseServices.Polyline value, int fromIndex, int segments)

      {

        writeLine(indent, string.Format("WorldGeometry.Polyline(value = {0}, fromIndex = {1}, segments = {2})", value, fromIndex, segments));

        return false;

      }

      public override bool Polyline(Point3dCollection points, Vector3d normal, IntPtr subEntityMarker)

      {

        writeLine(indent, string.Format("WorldGeometry.Polyline(points = {0}, normal = {1}, subEntityMarker = {2})", points, normal, subEntityMarker));

        return false;

      }

      public override void PopClipBoundary()

      {

        writeLine(indent, string.Format("WorldGeometry.PopClipBoundary"));

        clips.Pop();

      }

      public override bool PopModelTransform()

      {

        return true;

      }

      public override bool PushClipBoundary(ClipBoundary boundary)

      {

        writeLine(indent, string.Format("WorldGeometry.PushClipBoundary"));

        clips.Push(boundary);

        return true;

      }

      public override bool PushModelTransform(Matrix3d matrix)

      {

        writeLine(indent, "WorldGeometry.PushModelTransform(Matrix3d)");

        Matrix3d m = modelMatrix.Peek();

        modelMatrix.Push(m * matrix);

        return true;

      }

      public override bool PushModelTransform(Vector3d normal)

      {

        writeLine(indent, "WorldGeometry.PushModelTransform(Vector3d)");

        PushModelTransform(Matrix3d.PlaneToWorld(normal));

        return true;

      }

      public override bool RowOfDots(int count, Point3d start, Vector3d step)

      {

        writeLine(indent, string.Format("ViewportGeometry.RowOfDots(count = {0}, start = {1}, step = {1})", count, start, step));

        return false;

      }

      public override bool Ray(Point3d point1, Point3d point2)

      {

        writeLine(indent, string.Format("WorldGeometry.Ray(point1 = {0}, point2 = {1})", point1, point2));

        return false;

      }

      public override bool Shell(Point3dCollection points, IntegerCollection faces, EdgeData edgeData, FaceData faceData, VertexData vertexData, bool bAutoGenerateNormals)

      {

        writeLine(indent, string.Format("WorldGeometry.Shell(points = {0}, faces = {1}, edgeData = {2}, faceData = {3}, vertexData = {4}, bAutoGenerateNormals = {5})", points, faces, edgeData, faceData, vertexData, bAutoGenerateNormals));

        return false;

      }

      public override bool Text(Point3d position, Vector3d normal, Vector3d direction, string message, bool raw, TextStyle textStyle)

      {

        writeLine(indent, string.Format("WorldGeometry.Text(position = {0}, normal = {1}, direction = {2}, message = {3}, raw = {4}, textStyle = {5})", position, normal, direction, message, raw, textStyle));

        return false;

      }

      public override bool Text(Point3d position, Vector3d normal, Vector3d direction, double height, double width, double oblique, string message)

      {

        writeLine(indent, string.Format("WorldGeometry.Text(position = {0}, normal = {1}, direction = {2}, height = {3}, width = {4}, oblique = {5}, message = {6})", position, normal, direction, height, width, oblique, message));

        return false;

      }

      public override bool WorldLine(Point3d startPoint, Point3d endPoint)

      {

        writeLine(indent, string.Format("WorldGeometry.WorldLine(startPoint = {0}, endPoint = {1})", startPoint, endPoint));

        return false;

      }

      public override bool Xline(Point3d point1, Point3d point2)

      {

        writeLine(indent, string.Format("WorldGeometry.Xline(point1 = {0}, point2 = {1})", point1, point2));

        return false;

      }

      public override void SetExtents(Extents3d extents)

      {

        writeLine(indent, "WorldGeometry.SetExtents({0}) ", extents);

      }

      public override void StartAttributesSegment()

      {

        writeLine(indent, "WorldGeometry.StartAttributesSegment called");