cad.h

Go to the documentation of this file.

/**
 * \file rvc/cad.h
 * \brief interface for the RVCCAD class.
 *
 * \if NODOC
 * $Id: cad.h_v 1.58 2004/12/01 18:39:31 dfriberg Exp $
 *
 * $Log: cad.h_v $
 * Revision 1.58  2004/12/01 18:39:31  dfriberg
 * LINKTYPE_DGN = 5 (as defined in RVC::CADHANDLE::LINKTYPE)
 *
 * Revision 1.57  2004/11/30 16:18:22  ldyas
 * restore default.
 *
 * Revision 1.56  2004/11/24 23:17:42  ldyas
 * changed default validate in getregion.
 *
 * Revision 1.55  2004/11/09 00:14:32  dfriberg
 * Add DGN to LINKTYPE.
 *
 * Revision 1.54  2004/09/02 14:13:52  scowan
 * Fixed prototype for add element.
 *
 * Revision 1.53  2004/09/01 22:53:39  scowan
 * Changed to use cad handle paradigm.
 *
 * Revision 1.51  2004/07/28 16:12:41  scowan
 * Moved polyline generation from a box to the box class.
 *
 * Revision 1.50  2004/07/15 17:00:09  scowan
 * Added new private element method.
 *
 * Revision 1.49  2004/07/15 15:47:05  scowan
 * Fixed memory leak.
 *
 * Revision 1.48  2004/07/12 23:21:20  scowan
 * Removed use of geo region.
 *
 * Revision 1.47  2004/06/14 20:09:40  scowan
 * Added method to get the text frame parms.
 *
 * Revision 1.46  2004/06/14 16:20:55  scowan
 * Added methods to set and get baseline flags.
 *
 * Revision 1.45  2004/06/11 16:17:32  scowan
 * Addow increment of cad element type enums.
 *
 * Revision 1.44  2004/06/10 16:53:54  scowan
 * Added delete last element method.
 *
 * Revision 1.43  2004/06/07 15:32:06  scowan
 * Added method to update element.
 *
 * Revision 1.42  2004/06/04 19:25:27  scowan
 * Added methods to help in cad merge.
 *
 * Revision 1.41  2004/05/28 20:35:28  scowan
 * Added new mehtods and virtual method overrides.
 *
 * Revision 1.40  2004/05/28 15:56:57  scowan
 * Changed to have element iterator use new element class.
 *
 * Revision 1.39  2004/05/27 19:59:00  scowan
 * Added make parm ctor.
 *
 * Revision 1.38  2004/05/27 16:11:39  scowan
 * Added methods to access certain fields in cad element.
 *
 * Revision 1.37  2004/05/20 22:05:30  scowan
 * Added database index methods.
 *
 * Revision 1.36  2004/05/20 19:40:03  scowan
 * Added cad element class and other sub-classes.
 *
 * Revision 1.35  2003/11/21 22:17:02  scowan
 * Support new Capabilities system.
 *
 * Revision 1.34  2003/10/13 16:46:37  scowan
 * Added cad type to text id method.
 *
 * Revision 1.33  2003/10/07 17:35:45  scowan
 * Object virtual method changes.
 *
 * Revision 1.32  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.31  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.30  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.29  2003/08/27 21:28:13  scowan
 * Removed unused linkked file virtual methods.
 *
 * Revision 1.28  2003/06/19 17:46:34  scowan
 * Added virtual method.
 *
 * Revision 1.27  2003/06/04 23:35:06  scowan
 * Added find element draw set.
 *
 * Revision 1.26  2003/05/12 23:33:11  scowan
 * Changes to virtual methods.
 *
 * Revision 1.25  2003/05/07 22:20:36  scowan
 * Changed virtual method format.
 *
 * Revision 1.24  2002/09/30 23:22:18  scowan
 * Made element search code const.
 *
 * Revision 1.23  2002/09/17 22:49:14  scowan
 * More virtual method adjustment.
 *
 * Revision 1.22  2002/09/03 22:18:32  scowan
 * More virtual method moves.
 *
 * Revision 1.21  2002/08/29 22:13:22  scowan
 * Virtual method adjustment.
 *
 * Revision 1.20  2002/06/27 17:57:14  scowan
 * nc.
 *
 * Revision 1.19  2002/06/19 22:24:10  scowan
 * More method changes.
 *
 * Revision 1.18  2002/06/18 22:15:22  scowan
 * Added extract interface.
 *
 * Revision 1.17  2002/04/30 17:33:50  scowan
 * Change base make parm class name.
 *
 * Revision 1.16  2002/04/30 14:40:24  scowan
 * Removed namespace from inheritance.
 *
 * Revision 1.15  2002/04/30 14:03:13  scowan
 * More const.
 *
 * Revision 1.14  2002/04/26 22:44:13  scowan
 * Added more virtual methods.
 *
 * Revision 1.13  2002/03/01 16:19:28  scowan
 * Added virtual methods.
 *
 * Revision 1.12  2002/03/01 15:34:35  scowan
 * Added set element ID method.
 *
 * Revision 1.11  2002/02/27 23:24:46  scowan
 * Added get element extents methods.
 *
 * Revision 1.10  2001/10/18 15:29:32  scowan
 * Added update method.
 *
 * Revision 1.9  2001/10/17 22:49:39  scowan
 * Added multiple stuff.
 *
 * Revision 1.8  2001/10/08 20:50:00  scowan
 * Added element region method.
 *
 * Revision 1.7  2001/09/28 15:29:11  scowan
 * Added extents to the make parms.
 *
 * Revision 1.6  2001/07/31 16:40:38  scowan
 * Added new interface methods.
 *
 * Revision 1.5  2001/07/12 20:14:55  scowan
 * Added encoding for linked objects.
 *
 * Revision 1.4  2001/06/14 16:06:14  scowan
 * Changed source type.
 *
 * Revision 1.3  2001/06/14 15:12:40  scowan
 * Added to RVC namespace.
 *
 * Revision 1.2  2001/06/13 15:51:16  scowan
 * Changed objtype enum.
 * Added make mehtod.
 *
 * Revision 1.1  2001/05/29 21:12:27  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::CAD rvc/cad.h
//!   \brief Manages RVC::OBJTYPE_CAD RVC objects.  
//!
//!   The interface currently wraps the MfCAD functions.
//!   
//!   RVC Object Types that this class supports: RVC::OBJTYPE_CAD.
//!
//!   Default RVC Object Type for this class: RVC::OBJTYPE_CAD.
//!
//!   Valid parents for this class:
//!      - RVC::OBJTYPE_File
//!      - RVC::OBJTYPE_Folder

#ifndef INC_RVC_CAD_H
#define INC_RVC_CAD_H

#ifndef INC_RVC_GEOMETRC_H
   #include <rvc/geometrc.h>
#endif

#ifndef INC_MI32_RVCCAD_H
   #include <mi32/rvccad.h>
#endif

#ifndef INC_MI32_POLYLINE_H
   #include <mi32/polyline.h>
#endif

#ifndef INC_MI32_SCRNUNIT_H
   #include <mi32/scrnunit.h>
#endif

#ifndef INC_RVC_STYLE_H
   #include <rvc/style.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT   
// Forward Declarations
class BITSET_UNOWNED;
struct CADBLOCK;
class LABELFRAMEPARMS;
struct LINESTYLE;
class PLANECONIC;
struct POINTSTYLE;
struct POLYSTYLE;
class SUBREGION2D;
struct TEXTSTYLE;
class TRANS2D_AFFINE;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT   
// Forward Declarations
class CADHANDLE;
class QSEARCHTREE;
#endif // GENERATING_DOXYGEN_OUTPUT

class CAD : public GEOMETRIC {
   public:

      typedef INT32 CADBLOCKNUM;    //!< Typedef for CAD block number type

      enum LINKTYPE {
         LINKTYPE_Internal = 0,
         LINKTYPE_MapInfo = 1,      //!<  Mapinfo .MIF format 
         LINKTYPE_AtlasGIS = 2,     //!<  Atlas GIS 3.0 internal format 
         LINKTYPE_Shapefile = 3,    //!<  Arc/Info Shapefile format 
         LINKTYPE_DGN = 5,          //!<  MicroStation DGN format
         LINKTYPE_Edit = 1000
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT   
      class CONST_ELEMITERATOR;
      friend class CONST_ELEMITERATOR;
      class DRAW;
      class ELEMENT;
      class LINKPARMS;
      class MAKEPARMS;
      #endif // GENERATING_DOXYGEN_OUTPUT

      //! Default constructor
      CAD (
         );

      //! Copy constructor
      CAD (
         const RVC::CAD& obj
         );

      //! Destructor
      virtual ~CAD (
         );

      //! Assignment, will close and re-open object if possible
      RVC::CAD& operator= (
         const RVC::CAD& rhs
         );

      //! Add an element to the CAD object   
      INT32 AddElement (
         const ELEMENT& Element
         );

      //! Copy a block inside a CAD object
      ERRVALUE CopyBlock (
         CADBLOCKNUM DestBlockNum,
         CADBLOCKNUM SrcBlockNum
         );

      //! Delete the element specified.  Only works if the GEOMETRIC::CAPABILITY_CanDeleteAnyElement is available
      ERRVALUE DeleteElement (
         INT32 ElemNum
         );
         
      ERRVALUE DeleteLastElement (
         );
         
      //! Draws the block by calling the virtual draw routines.
      //! @return The number of elements drawn. 
      INT32 DrawBlock (
         DRAW& Draw,
         INT32 BlockNum = 0,
         double MinChordDist = 0.0              //!< Default is to use %5 of the Radius length
         ) const;

      //! Draws an element.
      //! Returns > 0 if drawn, 0 if not, > 0 error. 
      int DrawElement (                   
         DRAW& Draw,
         INT32 BlockNum,
         INT32 ElemNum,                         //!< Element to draw
         double MinChordDist = 0.0              //!< Default is to use %5 of the Radius length
         ) const;

      //! Obtain a constant iterator to the first CAD element in the current block
      //! @return Constant iterator to first CAD element in the current block
      CONST_ELEMITERATOR ElementBegin (
         ) const;

      //! Obtain an iterator to the last+1 CAD element in the current block
      //! @return Constant iterator to last+1 CAD element in the current block
      CONST_ELEMITERATOR ElementEnd (
         ) const;

      //! Erase all elements from a block
      ERRVALUE EraseBlock (
         CADBLOCKNUM BlockNum
         );

      //! Get the current block number
      //! @return Current block number
      CADBLOCKNUM GetCurrentBlock (
         ) const;

      //! Obtain the link type
      //! @return RVCCAD::LINKTYPE
      LINKTYPE GetLinkType (
         ) const;

      //! Get MAKEPARM values from current CAD object instance       
      ERRVALUE GetMakeParms (
         RVC::CAD::MAKEPARMS& MakeParms
         ) const;
         
      //! Obtain next available element ID for element ID table
      //! @return Next available Element ID
      INT32 GetNextElemID (
         ) const;

      //! Obtain the number of blocks in this CAD object
      //! @return Number of blocks
      INT32 GetNumBlocks (
         ) const;

      //! Link CAD object to external file
      ERRVALUE Link (                        //! Create a raster object
         const RVC::OBJECT& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         const LINKPARMS& LinkParms,
         const char* Source = 0
         );

      //! Create a new CAD object
      ERRVALUE Make (                        //! Create a raster object
         const RVC::OBJECT& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         const MAKEPARMS& MakeParms,
         const char* Source = 0
         );

      //! Create a new CAD object
      ERRVALUE Make (                        //! Create a raster object
         const RVC::OBJITEM& ObjItem,
         const MAKEPARMS& MakeParms,
         const char* Source = 0
         );

      //! Read the block information
      ERRVALUE ReadBlock (
         CADBLOCKNUM BlockNum,
         CADBLOCK& block,
         bool MakeCurrent = true             //!< Make current block
         ) const;

      //! Read next CAD element in the sequence in the current block
      ERRVALUE ReadElement (
         ELEMENT& Element,
         DIMENSION dim = DIMENSION_2D
         ) const;

      //! Read specific CAD element in the current block
      ERRVALUE ReadElement (
         INT32 ElemNum,
         ELEMENT& Element,
         DIMENSION dim = DIMENSION_2D
         ) const;

      //! Rewind CAD object block reading to the begining
      ERRVALUE Rewind (
         );
         
      ERRVALUE SetEditBlock (
         INT32 BlockNum
         );

      //! Set next available element ID for element ID table
      ERRVALUE SetNextElemID (
         INT32 NextElemID
         );

      //! Set CAD object point coordinate type
      ERRVALUE SetPointType (
         POINTTYPE PointType
         );

      //! Change the drawing order of an element in the CAD object         
      ERRVALUE SortElement (
         INT32 ElemNum,
         bool SortToFront
         );
         
      //! Change the drawing order of the set of elements in the CAD object         
      ERRVALUE SortElements (
         const BITSET_UNOWNED& SortSet,
         bool SortToFront
         );
         
      //! Write the block information
      ERRVALUE WriteBlock (
         CADBLOCKNUM BlockNum,
         CADBLOCK& block,
         bool MakeCurrent = true             //!< Make current block
         );

      //! Write element information, only valid if linktype == LINKTYPE_Edit
      ERRVALUE WriteElement (
         INT32 ElemNum,
         const ELEMENT& Element
         );
         
      //! Update element information (in CADELEMOPT section)
      ERRVALUE UpdateElement (
         INT32 ElemNum,
         const ELEMENT& Element
         );
         
      ERRVALUE UpdateExtentsFromInsertElements (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      ERRVALUE CreateAndPopulateSearchTree (INT32 InitialNumElements, const DRECT2D& InitialExtents, QSEARCHTREE& SearchTree) const;
      INT32 DrawBlock (DRAW& Draw, INT32 BlockNum, const TRANS2D_AFFINE& BlockToCAD, INT32 InsertLevel, double MinChordDist) const;
      int DrawElement (DRAW& Draw, INT32 BlockNum, INT32 ElemNum, const TRANS2D_AFFINE& BlockToCAD, INT32 InsertLevel, double MinChordDist) const;
      ERRVALUE DrawInsert (DRAW& Draw, INT32 BlockNum, const ELEMENT& Element, const TRANS2D_AFFINE& BlockToCAD, INT32 InsertLevel, double MinChordDist) const;
      
      ERRVALUE ExtractToCAD (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags, const SIMPLE_ARRAY<INT32>& FontTrans, const SIMPLE_ARRAY<INT32> PattTrans[RVC::STYLE::PATTERN_NumTypes]) const;
      ERRVALUE ExtractToRegion (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToVector (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      
      INT64 GetCurrentPosition () const;
      void SetCurrentPosition (INT64 Position) const;
      
      int SetupBlockTransList(ELEMTRANSLIST& TransList) const;
      int SetupDBRecordTransList(ELEMTRANSLIST& TransList) const;
      int SetupElementTransList(const ELEMSELECTPARMS& SelectParms, ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;

      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();              //! Close the open object
      virtual RVC::OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent);

      //! Implementation of RVC::GEOSPATIAL virtual methods
      virtual void v_GetExtents (DRECT3D &extents) const;
      virtual void v_GetScale (double& xscale, double& yscale) const;
      virtual double v_GetZScale () const;
      virtual double v_GetZOffset () const;
      virtual bool v_HasCapability (int Capability) const;
      virtual void v_SetScale (double xscale, double yscale);
      virtual void v_SetZOffset (double zoffset);
      virtual void v_SetZScale (double zscale);
      
      //! Implementation of RVC::GEOMETRIC virtual methods
      virtual ERRVALUE v_AddSearchTreeElement (INT32 elemnum, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_BuildSearchTree (INT32 InitialNumElements, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_ClearSearchTree (INT32 InitialNumElements, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_CopySearchTreeElement (INT32 SourceElement, INT32 DestElement, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_DeleteSearchTreeElement (INT32 elemnum, ELEMTYPE ElemType);
      virtual ERRVALUE v_ExtractTo (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      virtual INT32 v_FindClosestElementLow (ELEMTYPE ElemType, const DPOINT2D& SearchPt, SEARCHFILTER* SearchFilter, double SearchDist, double* DistFromElem) const;
      virtual ERRVALUE v_FindClosestElementsLow (const DPOINT2D& SearchPt, double SearchDist, SEARCHFILTER* SearchFilter, SIMPLE_ARRAY<RVC::ELEMENT>& ElementList) const;
      virtual ERRVALUE v_FindElementDrawSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, SEARCHRESULT& SearchResult) const;
      virtual ERRVALUE v_FindElementSearchSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, SEARCHRESULT& SearchResult) const;
      virtual INT32 v_GetAttachmentIndex (const RVC::ELEMENT& Element) const;
      virtual ERRVALUE v_GetElementExtents (ELEMTYPE ElemType, INT32 ElemNum, DRECT3D& Extents) const;
      virtual INT32 v_GetNextElementID (ELEMTYPE ElemType) const;
      virtual INT32 v_GetNumElements (ELEMTYPE ElemType) const;
      virtual POINTTYPE v_GetPointType () const;
      virtual INT32 v_GetPointSize () const;
      virtual double v_GetTotalLineLength () const;
      virtual bool v_IsElementDeleted (const RVC::ELEMENT& Element) const;
      virtual bool v_IsEmpty () const;
      virtual ERRVALUE v_SaveSearchTrees ();
      virtual ERRVALUE v_SetExtents (const DRECT3D &extents);
      virtual ERRVALUE v_SetNextElementID (ELEMTYPE ElemType, INT32 NextElementID);
      virtual bool v_SetSearchTree (ELEMTYPE ElemType, RVC::QSEARCHTREE* SearchTree, bool ReplaceExisting);
      virtual ERRVALUE v_SetTotalLineLength (double length);
      virtual int v_SetupElemTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      virtual bool v_TestElementAgainstRegion (const RVC::ELEMENT& Element, const REGION2D& region, TESTCRITERIA TestMode) const;
      virtual ERRVALUE v_UpdateExtents (const DRECT3D& extents);
         
      CADHANDLE* m_CadHandle;
      LINKTYPE m_LinkType;       //!< 2   Type of link (DXF, MIF, ...) 
      mutable QSEARCHTREE *m_CADQTree;
      class OPTIMIZE;
      mutable OPTIMIZE* m_Optimize;
      mutable bool m_SetInstanceData;     //!< This object set the instance data if true, it needs to remove it on closing
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


//! CAD Element Definition
//! This class is used to define and use a CAD object element
class CAD::ELEMENT {
   public:
   
      //! Enumeration of the different CAD element types in use
      enum TYPE {
         TYPE_Insert = 0,
         TYPE_Point = 1,
         TYPE_Circle = 2,
         TYPE_Arc = 3,
         TYPE_ArcChord = 4,
         TYPE_Text = 5,
         TYPE_Line = 7,
         TYPE_RotationBox = 8,
         TYPE_Polygon = 9,
         TYPE_Mesh = 10,
         TYPE_Ellipse = 11,
         TYPE_EllipticalArc = 12,
         TYPE_ArcWedge = 14,
         TYPE_EllipticalArcWedge = 15,
         TYPE_EllipticalArcChord = 16,
         TYPE_MultiLine = 17,
         TYPE_MultiPoint = 18,
         TYPE_MultiPolygon = 19,
         TYPE_LAST
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT   
      class BOX;
      class DRAW;
      class INSERT;
      class MESH;
      #endif

      //! Default Constructor    
      ELEMENT (
         );

      //! Copy Constructor    
      ELEMENT (
         const ELEMENT& rhs
         );

      //! Destructor    
      ~ELEMENT (
         );
         
      //! Assignment Operator
      ELEMENT& operator= (
         const ELEMENT& rhs
         );

      //! Clear the element
      void Clear (
         );
         
      //! Compute the closest distance from an element to the point given
      //! NOTE: Does not compute distance from a TYPE_Insert element
      double ComputeDistanceFrom (
         const DPOINT2D& point
         ) const;

      //! Compute the extents of this element         
      //! NOTE: Does not compute extents from a TYPE_Insert element, use ComputeInsertExtents()
      //! @return 'True' if the extents can be calculated, 'false' if not
      bool ComputeExtents (
         DRECT3D& Extents
         ) const;

      //! Compute the border polygon (rotated box) of the inserted CAD block defined by this element
      //! @return 'True' if the element is a TYPE_Insert, 'false' if not
      bool ComputeInsertBorder (
         const CAD& CadObj,
         POLYLINE& Border
         ) const;

      //! Compute the extents of the inserted CAD block defined by this element
      //! @return 'True' if the element is a TYPE_Insert, 'false' if not
      bool ComputeInsertExtents (
         const CAD& CadObj,
         DRECT3D& Extents
         ) const;

      //! Convert point coordinates using affine transformation      
      void ConvertForward (
         const TRANS2D_AFFINE& taf
         );
      
      //! Convert point coordinates using generic transformation     
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using generic transformation with densification
      ERRVALUE ConvertForwardDense (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using 3D perspective transformation    
      void ConvertForward (
         const TRANS3D& t3d
         );
      
      //! Convert point coordinates using affine transformation      
      void ConvertInverse (
         const TRANS2D_AFFINE& taf
         );
      
      //! Convert point coordinates using generic transformation     
      ERRVALUE ConvertInverse (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using generic transformation with densification
      ERRVALUE ConvertInverseDense (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using 3D perspective transformation    
      void ConvertInverse (
         const TRANS3D& t3d
         );

      //! 'Draw' the element using the "DRAW" interface class passed in
      //! This method takes the individual elements and does a transformation to a well known construct to simplify
      //! handling of multiple data types.  See RVC::CAD::ELEMENT::DRAW class for the primitives that the ELEMENT class 
      //! is transformed to.
      //! NOTE: Does not 'draw' from an TYPE_Insert element
      ERRVALUE DrawElement (
         DRAW& Draw,
         const TRANS2D_AFFINE& BlockToCAD,      //!< Affine transformation from inserted block to CAD object coordinates
         double MinChordDist = 0.0              //!< Default is to use %5 of the Radius length
         );

      //! Get the approximate element type
      //! @return ELEMTYPE_Point, ELEMTYPE_Line, ELEMTYPE_Polygon, ELEMTYPE_Label, or ELEMTYPE_Empty if cannot be represented
      ELEMTYPE GetAppoxElementType (
         ) const;
         
      //! Get the TYPE_RotationBox from this
      //! @return 'True' if the element is a TYPE_RotationBox, 'false' if not
      bool GetBox (
         BOX& Box
         ) const;
         
      //! Get the database index for this element
      //! @return '-1' if no database element index exists for this element, >=0 for valid database element index
      INT32 GetDatabaseIndex (
         ) const;
      
      //! Get the ELEMENT::TYPE designation for this
      //! @return ELEMENT::TYPE
      TYPE GetElementType (
         ) const;
      
      //! Get the TEXTID for the CAD::ELEMENT::TYPE specified.
      static TEXTID GetElementTypeTextID (
         TYPE CadType
         );

      //! Get the TEXTSTYLE for this type
      //! @return 'true' if the method is able to set the element style based on its element type, 'false' if not
      bool GetElementStyle (
         TEXTSTYLE& textstyle
         ) const;
   
      //! Get the POINTSTYLE for this type
      //! @return 'true' if the method is able to set the element style based on its element type, 'false' if not
      bool GetElementStyle (
         POINTSTYLE& pointstyle
         ) const;
   
      //! Get the LINESTYLE for this type
      //! @return 'true' if the method is able to set the element style based on its element type, 'false' if not
      bool GetElementStyle (
         LINESTYLE& linestyle
         ) const;
   
      //! Get the POLYSTYLE for this type
      //! @return 'true' if the method is able to set the element style based on its element type, 'false' if not
      bool GetElementStyle (
         POLYSTYLE& polystyle
         ) const;
         
      //! Get the TYPE_Insert from this
      //! @return 'True' if the element is a TYPE_Insert, 'false' if not
      bool GetInsert (
         INSERT& Insert
         ) const;
      
      //! Get the Text Label frame parms information from this
      //! @return 'True' if the element is a TYPE_Text type, 'false' if not
      bool GetLabelFrameParms (
         LABELFRAMEPARMS& FrameParms
         ) const;
         
      //! Get the line primitives from this
      //! @return 'True' if the element is made up of a list of POLYLINE's, 'false' if not
      bool GetLines (
         POLYLINELIST& PolyLineList
         ) const;
         
      //! Get the TYPE_Mesh from this
      //! @return 'True' if the element is a TYPE_Mesh, 'false' if not
      bool GetMesh (
         MESH& Mesh
         ) const;
      
      //! Get the PLANECONIC representation from this
      //! @return 'True' if the element is a PLANECONIC type, 'false' if not
      bool GetPlaneConic (
         PLANECONIC& Conic
         ) const;
         
      //! Get the point primitives from this
      //! @return 'True' if the element is made up of one or more points, 'false' if not
      bool GetPoints (
         POLYLINE& PointArray
         ) const;
         
      //! Get the REGION2D representation from this
      //! @return 'True' if the element is a REGION2D type, 'false' if not
      bool GetRegion (
         REGION2D& Region,
         bool Validate = false
         ) const;
         
      //! Get the SUBREGION2D representation from this
      //! @return 'True' if the element is a SUBREGION2D type, 'false' if not
      bool GetSubRegion (
         SUBREGION2D& SubRegion,
         bool Validate = false
         ) const;
         
      //! Get the Text element information from this
      //! @return 'True' if the element is a TYPE_Text type, 'false' if not
      bool GetTextElement (
         POLYLINELIST& PolyLineList,      //!< First line is the baseline, the rest are leader lines
         MISTRING& text,
         TEXTSTYLE& style,
         LABELFRAMEPARMS* FrameParms = 0
         ) const;
         
      //! Get the units of width 
      SCREENUNIT GetWidthUnits (
         ) const;

      //! Get the Z value assiociated with this element
      double GetZValue (
         ) const;
         
      //! Does the label follow the baseline?
      //! @return 'True' if label follows baseline
      bool IsBaselineFit ( 
         ) const;

      //! Does the label follow the splined baseline?
      //! @return 'True' if label follows the splined baseline
      bool IsBaselineSplineFit ( 
         ) const;
   
      //! Clip vector features under the label when rendering
      //! @return 'True' if features under the label needs to be clipped
      bool IsClipUnderSet (
         ) const;
         
      //! Is the element an insertion element?
      //! @return 'True' if the element is a TYPE_Insert, 'false' if not
      bool IsInsertion (
         ) const;
   
      //! Can the element be represented by open lines?
      //! @return 'True' if the element can be represented by open lines, 'false' if not
      bool IsLine (
         ) const;
   
      //! Can the element be represented by a PLANECONIC
      //! @return 'True' if the element can be represented by a PLANECONIC, 'false' if not
      bool IsPlaneConic (
         ) const;
   
      //! Can the element be represented by one or more points?
      //! @return 'True' if the element can be represented by one or more points, 'false' if not
      bool IsPoint (
         ) const;

      //! Is the point inside the element?   
      //! @return 'True' if the element is a polygon (IsPolygon() == true) and the point is inside it, 'false' if not
      bool IsPointInside (
         const DPOINT2D& pt
         ) const;
   
      //! Can the element be represented by closed lines?
      //! @return 'True' if the element can be represented by closed lines, 'false' if not
      bool IsPolygon (
         ) const;
   
      //! Is the element a text element?
      //! @return 'True' if the element is a TYPE_Text, 'false' if not
      bool IsText (
         ) const;
   
      //! Set the TYPE_RotationBox from 'Box'
      void SetBox (
         const BOX& Box
         );
      
      //! Set the label to follow the baseline
      void SetBaselineFit (
         bool value
         );
         
      //! Set the label to follow the splined baseline
      void SetBaselineSplineFit (
         bool value
         );
         
      //! Set the label clip under flag
      void SetClipUnder (
         bool value
         );
         
      //! Set the database index for this element: '-1' if no database element index exists for this element, >=0 for valid database element index
      void SetDatabaseIndex (
         INT32 index
         );
      
      //! Set the TEXTSTYLE for this type
      void SetElementStyle (
         const TEXTSTYLE& textstyle
         );
   
      //! Set the POINTSTYLE for this type
      void SetElementStyle (
         const POINTSTYLE& pointstyle
         );
   
      //! Set the LINESTYLE for this type
      void SetElementStyle (
         const LINESTYLE& linestyle
         );
   
      //! Set the POLYSTYLE for this type
      void SetElementStyle (
         const POLYSTYLE& polystyle
         );
   
      //! Set the TYPE_Insert from 'Insert'
      void SetInsert (
         const INSERT& Insert
         );
      
      //! Set the element type and the data based on 'PolyLineList'
      void SetLines (
         const POLYLINELIST& PolyLineList
         );
         
      //! Set the TYPE_Mesh from 'Mesh'
      void SetMesh (
         const MESH& Mesh
         );
      
      //! Set the element type and data based on 'Conic'
      void SetPlaneConic (
         const PLANECONIC& Conic
         );
   
      //! Set the element type and data based on 'point'
      void SetPoint (
         const DPOINT3D& point
         );
         
      //! Set the element type and data based on 'PointArray'
      void SetPoints (
         const POLYLINE& PointArray
         );
         
      //! Set the element type and data based on 'PolyLine'
      void SetPolyLine (
         const POLYLINE& PolyLine
         );
         
      //! Set the element type and data based on 'Region'
      void SetRegion (
         const REGION2D& Region
         );
         
      //! Set the element type and data based on 'SubRegion'
      void SetSubRegion (
         const SUBREGION2D& SubRegion
         );
         
      //! Set the TYPE_Text from the information passed in
      void SetTextElement (
         const POLYLINELIST& PolyLineList,         //!< First line is the baseline, the rest are leader lines
         const MISTRING& text,
         const TEXTSTYLE& style,
         const LABELFRAMEPARMS* FrameParms = 0
         );

      //! Set the units of width 
      void SetWidthUnits (
         SCREENUNIT WidthUnits
         );
         
      //! Set the Z value assiociated with this element
      void SetZValue (
         double zvalue
         );
         
      //! Test this to see if it passes the TEXTCRITERIA given using the REGION2D passed in
      //! NOTE: Cannot test a TYPE_Insert element
      //! @return 'True' if the element met the criteria, 'false' if not
      bool TestElement (
         const REGION2D& Region,
         TESTCRITERIA TestMode
         ) const;
   
   private:
      CADELEMHDR m_ElemHdr;
      CADELEMOPT m_ElemOpt;
      CADELEMDATA m_ElemData;
      POLYLINE m_Points;
      MISTRING m_String;
      SIMPLE_ARRAY<INT32> m_IsleList;
      SIMPLE_ARRAY<CADSUBPOLY> m_SubPolyList;

      void ClearGeometric ();
      void ComputeStringExtents (DRECT3D& Extents) const;
      void GeneratePointsFromBox (POLYLINE& PolyLine) const;
      void GetPolyLineList (POLYLINELIST& PolyLineList) const;
      void SetPolyLineList (const POLYLINELIST& PolyLineList);
      void TranslatePatterns (const SIMPLE_ARRAY<INT32> PattTrans[RVC::STYLE::PATTERN_NumTypes]);
      
      friend class CAD;
   };
   
DEFINE_ENUM_OP_INCREMENT(CAD::ELEMENT::TYPE)

//! CAD element TYPE_RotationBox class implementation
class CAD::ELEMENT::BOX {
   public:
      //! Default Constructor    
      BOX () : m_Rotation(0.0) {}

      //! Copy Constructor    
      BOX (const BOX& rhs) : m_rect(rhs.m_rect), m_Rotation(rhs.m_Rotation) {}

      //! Assignment Operator
      BOX& operator= (
         const BOX& rhs
         ) { 
         if (this != &rhs) {
            m_rect = rhs.m_rect; 
            m_Rotation = rhs.m_Rotation;
            } 
         return (*this); 
         }

      //! Clear the box
      void Clear (
         ) {
         m_rect.SetInvalid();
         m_Rotation = 0.0;
         return;
         }

      // Generate a POLYLINE describing the box       
      void GeneratePoints (
         POLYLINE& PolyLine
         ) const;
      
      //! Get the box rectangle, unrotated
      //! @return The box rectangle
      const DRECT3D& GetBoxExtents (
         ) const { return (m_rect); }
   
      //! Get the box rotation value in radians
      //! @return The box rotation value in radians
      double GetRotation (
         ) const { return (m_Rotation); }
   
      //! Set the box rectangle, unrotated
      void SetBoxExtents (
         const DRECT3D& rect
         ) { m_rect = rect; }
   
      //! Set the box rotation value in radians
      void SetRotation (
         double Rotation
         ) { m_Rotation = Rotation; }
   
   private:
      DRECT3D m_rect;
      double m_Rotation;
   };


//! CAD::ELEMENT Interface class to render and/or transform CAD Elements into common types
class CAD::ELEMENT::DRAW {
   public:
      DRAW () {}
      virtual ~DRAW () {}

      //! First chance to render an element without any transformations to one of methods below.
      //! @return >0 if this method used the element and do not call methods below, ==0 if call the methods below, <0 error
      int DrawElement (
         const CAD::ELEMENT& Element,        //!< Original CAD::ELEMENT
         const TRANS2D_AFFINE& BtoC          //!< Block to CAD transformation, methods below will do the transform before sending the converted element
         ) { return (v_DrawElement(Element, BtoC)); }

      //! Transform CAD element to a set of one or more lines, only if the element can be represented as lines and not polygons
      ERRVALUE DrawLines (
         const CAD::ELEMENT& Element,        //!< Original CAD::ELEMENT
         const POLYLINELIST& LineList        //!< CAD::ELEMENT transformed to lines
         ) { return (v_DrawLines(Element, LineList)); }

      //! Transform CAD element to a set of one or more singular points, only if the element can be represented as singular points
      ERRVALUE DrawPoints (
         const CAD::ELEMENT& Element,        //!< Original CAD::ELEMENT
         const POLYLINE& Points              //!< CAD::ELEMENT transformed to a POLYLINE of points
         ) { return (v_DrawPoints(Element, Points)); }

      //! Called if the CAD element is a text label element
      ERRVALUE DrawText (
         const CAD::ELEMENT& Element,        //!< Original CAD::ELEMENT
         const MISTRING& string,             //!< Text string
         const POLYLINELIST& LineList        //!< First line is the baseline, all others after that are leader lines
         ) { return (v_DrawText(Element, string, LineList)); }

      //! Transform CAD element to a SUBREGION2D, only if the element can be represented as a SUBREGION2D
      //! Multiple calls to this method will be done if one SUBREGION2D is not enough (CAD::ELEMENT::TYPE_MultiPolygon)
      ERRVALUE DrawSubRegion (
         const CAD::ELEMENT& Element,        //!< Original CAD::ELEMENT
         const SUBREGION2D& SubRegion        //!< SubRegion to fill
         ) { return (v_DrawSubRegion(Element, SubRegion)); }
         
   private:

      virtual int v_DrawElement (const CAD::ELEMENT& Element, const TRANS2D_AFFINE& BtoC) { return (0); }
      virtual ERRVALUE v_DrawLines (const CAD::ELEMENT& Element, const POLYLINELIST& LineList) { return (0); }
      virtual ERRVALUE v_DrawPoints (const CAD::ELEMENT& Element, const POLYLINE& Points) { return (0); }
      virtual ERRVALUE v_DrawText (const CAD::ELEMENT& Element, const MISTRING& string, const POLYLINELIST& LineList) { return (0); }
      virtual ERRVALUE v_DrawSubRegion (const CAD::ELEMENT& Element, const SUBREGION2D& SubRegion) { return (0); }
   };


//! CAD Interface class to filter CAD elements before drawing
//! Inherits from CAD::ELEMENT::DRAW
class CAD::DRAW : public CAD::ELEMENT::DRAW {
   public:
      DRAW () {}
      virtual ~DRAW () {}
   
      //! Filter CAD elements before they are rendered.  Specific place to modify certain attributes of the element and update element status
      //! @return >0 if the element is to be rendered, ==0 if not, <0 error
      int FilterElement (
         CAD::ELEMENT& Element,              //!< Original CAD::ELEMENT, can change specific items in the element in the filter call
         const TRANS2D_AFFINE& BtoC,         //!< Block to CAD transformation
         INT32 InsertLevel,                  //!< How deep the block insertion stack is, 0 for main block
         INT32 ElemNum,                      //!< Element number in the current drawing block
         const DRECT3D& Extents              //!< Element extents, maybe invalid
         ) { return (v_FilterElement(Element, BtoC, InsertLevel, ElemNum, Extents)); }
         
   private:
      virtual int v_FilterElement (CAD::ELEMENT& Element, const TRANS2D_AFFINE& BtoC, INT32 InsertLevel, INT32 ElemNum, const DRECT3D& Extents) { return (1); }
   };
   

//! CAD element TYPE_Insert class implementation
class CAD::ELEMENT::INSERT {
   public:
      //! Default Constructor    
      INSERT (
         ) :
         m_InsertPt(0.0,0.0,0.0),
         m_BlockNum(-1),
         m_rotate(0.0),
         m_xscale(1.0),
         m_yscale(1.0),
         m_zscale(1.0),
         m_numlins(1),
         m_numcols(1),
         m_linspace(0.0),
         m_colspace(0.0)
         {}
         
      //! Set the INSERT class back to its ctor'd state
      void Clear (
         ) {
         m_InsertPt.x = m_InsertPt.y = m_InsertPt.z = m_linspace = m_colspace = m_rotate = 0.0;
         m_BlockNum = -1;
         m_xscale = m_yscale = m_zscale = 1.0;
         m_numlins = m_numcols = 1;
         return;
         }
         
      //! Get the CAD block number to insert
      //! @return The CAD block number to insert      
      INT32 GetBlockNum (
         ) const { return (m_BlockNum); }
         
      //! Get the column spacing between block array insertions
      //! only useful if GetNumColumns() > 1
      //! @return Column spacing between block array insertions
      double GetColumnSpace (
         ) const { return (m_colspace); }

      //! Get the block insertion point location
      //! @return Block insertion point
      const DPOINT3D& GetInsertPoint (
         ) const { return (m_InsertPt); }

      //! Get the line spacing between block array insertions
      //! only useful if GetNumLines() > 1
      //! @return Line spacing between block array insertions
      double GetLineSpace (
         ) const { return (m_linspace); }

      //! Get the number of columns in a multi-block array insert
      //! @return Number of columns in a multi-block array insert
      INT32 GetNumColumns (
         ) const { return (m_numcols); }
         
      //! Get the number of lines in a multi-block array insert
      //! @return Number of lines in a multi-block array insert
      INT32 GetNumLines (
         ) const { return (m_numlins); }
         
      //! Get the rotation angle (in radians) that the block is rotated around the insertion point
      //! @return Insertion rotation angle in radians
      double GetRotation (
         ) const { return (m_rotate); }

      //! Get the x scale factor that the block is scaled around the insertion point
      //! @return Insertion X scale factor
      double GetXScale (
         ) const { return (m_xscale); }

      //! Get the y scale factor that the block is scaled around the insertion point
      //! @return Insertion Y scale factor
      double GetYScale (
         ) const { return (m_yscale); }

      //! Get the z scale factor that the block is scaled around the insertion point
      //! @return Insertion Z scale factor
      double GetZScale (
         ) const { return (m_zscale); }

      //! Set the CAD block number to insert
      void SetBlockNum (
         INT32 BlockNum
         ) { m_BlockNum = BlockNum; }
         
      //! Set the column spacing between block array insertions
      //! only useful if GetNumColumns() > 1
      void SetColumnSpace (
         double ColumnSpace
         ) { m_colspace = ColumnSpace; }

      //! Set the block insertion point location
      void SetInsertPoint (
         const DPOINT3D& InsertPt
         ) { m_InsertPt = InsertPt; }

      //! Set the line spacing between block array insertions
      //! only useful if GetNumLines() > 1
      void SetLineSpace (
         double LineSpace
         ) { m_linspace = LineSpace; }

      //! Set the number of columns in a multi-block array insert
      void SetNumColumns (
         INT32 NumColumns
         ) { m_numcols = static_cast<UINT16>(NumColumns); if (m_numcols == 0) m_numcols = 1; }
         
      //! Set the number of lines in a multi-block array insert
      void SetNumLines (
         INT32 NumLines
         ) { m_numlins = static_cast<UINT16>(NumLines); if (m_numlins == 0) m_numlins = 1; }
         
      //! Set the rotation angle (in radians) that the block is rotated around the insertion point
      void SetRotation (
         double rotate
         ) { m_rotate = rotate; }

      //! Set the x scale factor that the block is scaled around the insertion point
      void SetXScale (
         double xscale
         ) { m_xscale = xscale; if (m_xscale == 0.0) m_xscale = 1.0; }

      //! Set the y scale factor that the block is scaled around the insertion point
      void SetYScale (
         double yscale
         ) { m_yscale = yscale; if (m_yscale == 0.0) m_yscale = 1.0; }

      //! Set the z scale factor that the block is scaled around the insertion point
      void SetZScale (
         double zscale
         ) { m_zscale = zscale; if (m_zscale == 0.0) m_zscale = 1.0; }

   private:
   
      DPOINT3D m_InsertPt;             //!<  Point where to insert the block 
      INT32 m_BlockNum;                //!<  Index of block to insert 
      double m_rotate;                 //!<  Rotation angle 
      double m_xscale;                 //!<  X Scale factor
      double m_yscale;                 //!<  Y Scale factor
      double m_zscale;                 //!<  Z Scale factor
      UINT16 m_numlins;                //!<  Number of lines
      UINT16 m_numcols;                //!<  Number of columns
      double m_linspace;               //!<  Spacing between lines 
      double m_colspace;               //!<  Spacing between columns 

   };


//! CAD element TYPE_Mesh class implementation
class CAD::ELEMENT::MESH {
   public:
      //! Default Constructor    
      MESH (
         ) : 
         m_NumLineVertices(0),
         m_NumColumnVertices(0),
         m_TopBottomClosed(false),
         m_LeftRightClosed(false)
         {}
         
      //! Set the MESH class back to its ctor'd state
      void Clear (
         ) {
         m_MeshPoints.Clear();         
         m_NumLineVertices = m_NumColumnVertices = 0;
         m_TopBottomClosed = m_LeftRightClosed = false;
         return;
         }
            
      //! Get the mesh point array.  
      //! The number of points is equal to GetNumColumnVertices() * GetNumLineVertices()
      //! @return A POLYLINE containing the mesh points
      const POLYLINE& GetMeshPoints (
         ) const { return (m_MeshPoints); }
      
      //! Get the number of columns in the mesh
      //! @return Number of columns in the mesh
      UINT32 GetNumColumnVertices (
         ) const { return (m_NumColumnVertices); }
         
      //! Get the number of lines in the mesh
      //! @return Number of lines in the mesh
      UINT32 GetNumLineVertices (
         ) const { return (m_NumLineVertices); }
         
      //! Determine if the left and right sides of the mesh are to be closed
      //! @return 'True' if the left and right sides are to be closed, 'false' if not
      bool IsLeftRightClosed (
         ) const { return (m_LeftRightClosed); }
   
      //! Determine if the top and bottom sides of the mesh are to be closed
      //! @return 'True' if the top and bottom sides are to be closed, 'false' if not
      bool IsTopBottomClosed (
         ) const { return (m_TopBottomClosed); }

      //! Set flag to state that the left and right sides of the mesh are to be closed
      void SetLeftRightClosed (
         bool LeftRightClosed
         ) { m_LeftRightClosed = LeftRightClosed; }
         
      //! Set the mesh point array.  
      //! The number of points is equal to GetNumColumnVertices() * GetNumLineVertices()
      void SetMeshPoints (
         const POLYLINE& MeshPoints
         ) { m_MeshPoints = MeshPoints; }
   
      //! Set the number of columns in the mesh
      void SetNumColumnVertices (
         UINT32 NumColumnVertices
         ) { m_NumColumnVertices = NumColumnVertices; }
         
      //! Set the number of lines in the mesh
      void SetNumLineVertices (
         UINT32 NumLineVertices
         ) { m_NumLineVertices = NumLineVertices; }
         
      //! Set flag to state that the top and bottom sides of the mesh are to be closed
      void SetTopBottomClosed (
         bool TopBottomClosed
         ) { m_TopBottomClosed = TopBottomClosed; }
         
   private:
      UINT32 m_NumLineVertices;                 //!<  Number of X vertices for mesh 
      UINT32 m_NumColumnVertices;               //!<  Number of Y vertices for mesh 
      bool m_TopBottomClosed;
      bool m_LeftRightClosed;
      POLYLINE m_MeshPoints;
   };


//! Constant element iterator class
//!
//! This class is used to iterate through a CAD object's elements.  See methods ElementBegin() and ElementEnd() for obtaining a 
//! CAD object element iterator
class CAD::CONST_ELEMITERATOR {
   public:
      //! Default constructor
      CONST_ELEMITERATOR (
         ) : 
         m_CADObj(0),
         m_Element(0),
         m_ReachedEnd(false)
         {}

      //! Copy constructor
      CONST_ELEMITERATOR (
         const CONST_ELEMITERATOR& rhs
         ) : 
         m_Element(0),
         m_CADObj(rhs.m_CADObj),
         m_ReachedEnd(rhs.m_ReachedEnd)
         {
         if (rhs.m_Element != 0) m_Element = new ELEMENT(*rhs.m_Element);
         }

      #ifndef GENERATING_DOXYGEN_OUTPUT
      //! Internal constructor used by ElementEnd() methods
      CONST_ELEMITERATOR (
         const RVC::CAD* CADObj,
         INT32 LastElemNum
         ) : 
         m_Element(0),
         m_CADObj(CADObj),
         m_ReachedEnd(true)
         {}

      //! Internal constructor used by ElementBegin() methods
      CONST_ELEMITERATOR (
         const RVC::CAD* CADObj
         ) :
         m_Element(0),
         m_CADObj(CADObj),
         m_ReachedEnd(false)
         {
         ERRORPOSNDISABLE disable;
         const_cast<CAD*>(CADObj)->Rewind();
         m_Element = new ELEMENT;
         m_ReachedEnd = (CADObj->ReadElement(*m_Element) == R_BadCADElemNum);
         }
            
      #endif // GENERATING_DOXYGEN_OUTPUT

      //! Destructor
      virtual ~CONST_ELEMITERATOR (
         ) {
         delete m_Element;
         }

      //! Assignment
      CONST_ELEMITERATOR& operator= (
         const CONST_ELEMITERATOR& rhs
         ) {
         if (this != &rhs) {
            delete m_Element;
            m_Element = 0;
            if (rhs.m_Element != 0) m_Element = new ELEMENT(*rhs.m_Element);
            m_CADObj = rhs.m_CADObj;
            m_ReachedEnd = rhs.m_ReachedEnd;
            }
         return (*this);
         }

      //! Dereference
      const ELEMENT& operator* (
         ) const { return (*m_Element); }

      //! Dereference arrow
      const ELEMENT* operator-> (
         ) const { return (&**this); }

      //! Pre-increment
      CONST_ELEMITERATOR& operator++ (
         ) {
         ERRORPOSNDISABLE disable;
         m_ReachedEnd = (m_CADObj->ReadElement(*m_Element) == R_BadCADElemNum);
         return (*this);
         }

      //! Comparison for equality
      bool operator== (
         const CONST_ELEMITERATOR& rhs
         ) const { return (m_CADObj == rhs.m_CADObj && m_ReachedEnd == rhs.m_ReachedEnd); }

      //! Comparison for inequality
      bool operator!= (
         const CONST_ELEMITERATOR& rhs
         ) const { return (!(*this == rhs)); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ELEMENT* m_Element;
      const CAD* m_CADObj;
      bool m_ReachedEnd;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CAD::LINKPARMS {
   public:

      //! Default constructor, initialize to 2D Polygonal topology by default
      LINKPARMS (
         const FILEPATH& filename,
         LINKTYPE LinkType,
         CHAR_ENCODING encoding = CHAR_ENCODING_ASCII
         ) :
         m_filename(filename),
         m_LinkType(LinkType),
         m_encoding(encoding)
         {}

      //! Obtain CAD object link character encoding
      //! @return CHAR_ENCODING of linked object
      CHAR_ENCODING GetEncoding (
         ) const {return (m_encoding);}

      //! Obtain CAD object link filepath
      //! @return FILEPATH of linked object
      const FILEPATH& GetLinkFilePath (
         ) const {return (m_filename);}

      //! Obtain CAD object link type
      //! @return RVCCAD::LINKTYPE
      LINKTYPE GetLinkType (
         ) const {return (m_LinkType);}
         
      //! Set CAD object link character encoding
      void SetEncoding (
         CHAR_ENCODING encoding
         ) {m_encoding = encoding;}

      //! Set CAD object link file path
      void