HYTOS

    }

          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, Program.xml.DocumentElement);

          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)));

          }

          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);

          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);

          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]);

            }

          }

          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());

            }

          }

          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);

          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, Program.xml.DocumentElement);

          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, Program.xml.DocumentElement);

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

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

          {

          }

          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, Program.xml.DocumentElement);

            foreach(var obj in objColl)

          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, Program.xml.DocumentElement);

          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, Program.xml.DocumentElement);

          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, Program.xml.DocumentElement);

    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");

      }

    }