rvc/cad.h

Go to the documentation of this file.

#ifndef INC_RVC_CAD_H
#define INC_RVC_CAD_H

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

#ifndef INC_RVC_CADELEMENT_H
   #include <rvc/cadelement.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class BITSET_UNOWNED;
struct CADBLOCK;
class POLYLINE;
class POLYLINELIST;
namespace RVC {
   class CADHANDLE;
   class DESCRIPTOR;
   class QSEARCHTREE;
   }
#endif


namespace RVC {

class CAD : public GEOMETRIC {
   public:

      typedef INT32 CADBLOCKNUM;          
      typedef RVC::CADELEMENT ELEMENT;    

      enum LINKTYPE {
         LINKTYPE_Internal = 0,
         LINKTYPE_MapInfo = 1,      
         LINKTYPE_Shapefile = 3,    
         LINKTYPE_DGN = 5,          
         LINKTYPE_DWG = 6,          
         LINKTYPE_Edit = 1000
         };

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

      CAD (
         );

      CAD (
         const RVC::CAD& obj
         );

      virtual ~CAD (
         );

      RVC::CAD& operator= (
         const RVC::CAD& rhs
         );

      INT32 AddElement (
         const ELEMENT& Element
         );

      ERRVALUE CopyBlock (
         CADBLOCKNUM DestBlockNum,
         CADBLOCKNUM SrcBlockNum
         );

      ERRVALUE DeleteElement (
         INT32 ElemNum
         );
         
      ERRVALUE DeleteLastElement (
         );
         
      INT32 DrawBlock (
         DRAW& Draw,
         INT32 BlockNum = 0,
         double MinChordDist = 0.0,             
         DIMENSION dim = DIMENSION_2D
         ) const;

      int DrawElement (                   
         DRAW& Draw,
         INT32 BlockNum,
         INT32 ElemNum,                         
         double MinChordDist = 0.0,             
         DIMENSION dim = DIMENSION_2D
         ) const;

      CONST_ELEMITERATOR ElementBegin (
         ) const;

      CONST_ELEMITERATOR ElementEnd (
         ) const;

      ERRVALUE EraseBlock (
         CADBLOCKNUM BlockNum
         );

      ERRVALUE GetBlockDescriptor (
         INT32 BlockNum,
         DESCRIPTOR& Descriptor
         );
         
      CADBLOCKNUM GetCurrentBlock (
         ) const;

      LINKTYPE GetLinkType (
         ) const;

      ERRVALUE GetMakeParms (
         RVC::CAD::MAKEPARMS& MakeParms
         ) const;
         
      INT32 GetNextElemID (
         ) const;

      INT32 GetNumBlocks (
         ) const;

      ERRVALUE Link (                        
         const RVC::OBJECT& parent,
         const RVC::DESCRIPTOR& Descriptor,
         const LINKPARMS& LinkParms,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE Make (                        
         const RVC::OBJECT& parent,
         const RVC::DESCRIPTOR& Descriptor,
         const MAKEPARMS& MakeParms,
         const CREDENTIALS* Credentials RVC_DEFAULT_CREDENTIALS            
         );

      ERRVALUE Make (
         RVC::OBJITEM& ObjItem,                       
         const MAKEPARMS& MakeParms,
#ifdef RVC_CREDENTIALS_MANDATORY
         const char* Source,
         const CREDENTIALS* Credentials
#else
         const char* Source = 0,
         const CREDENTIALS* Credentials = 0           
#endif
         );

      ERRVALUE ReadBlock (
         CADBLOCKNUM BlockNum,
         CADBLOCK& block,
         bool MakeCurrent = true             
         ) const;

      ERRVALUE ReadElement (
         ELEMENT& Element,
         DIMENSION dim = DIMENSION_2D
         ) const;

      ERRVALUE ReadElement (
         INT32 ElemNum,
         ELEMENT& Element,
         DIMENSION dim = DIMENSION_2D
         ) const;

      ERRVALUE Rewind (
         );

      ERRVALUE SetBlockDescriptor (
         INT32 BlockNum,
         const DESCRIPTOR& Descriptor
         );
         
      ERRVALUE SetEditBlock (
         INT32 BlockNum
         );

      ERRVALUE SetNextElemID (
         INT32 NextElemID
         );

      ERRVALUE SetPointType (
         POINTTYPE PointType
         );

      ERRVALUE SortElement (
         INT32 ElemNum,
         bool SortToFront
         );
         
      ERRVALUE SortElements (
         const BITSET_UNOWNED& SortSet,
         bool SortToFront
         );
         
      ERRVALUE WriteBlock (
         CADBLOCKNUM BlockNum,
         CADBLOCK& block,
         bool MakeCurrent = true             
         );

      ERRVALUE WriteElement (
         INT32 ElemNum,
         const ELEMENT& Element
         );
         
      ERRVALUE UpdateElement (
         INT32 ElemNum,
         const ELEMENT& Element
         );
         
      ERRVALUE UpdateExtentsFromInsertElements (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      INT32 DrawBlock (DRAW& Draw, INT32 BlockNum, const TRANS2D_AFFINE& BlockToCAD, INT32 InsertLevel, double MinChordDist, DIMENSION dim) const;
      int DrawElement (DRAW& Draw, INT32 BlockNum, INT32 ElemNum, const TRANS2D_AFFINE& BlockToCAD, INT32 InsertLevel, double MinChordDist, DIMENSION dim) const;
      ERRVALUE DrawInsert (DRAW& Draw, INT32 BlockNum, const ELEMENT& Element, const TRANS2D_AFFINE& BlockToCAD, INT32 InsertLevel, double MinChordDist, DIMENSION dim) 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::PATTERNTYPE_NumTypes]) const;
      ERRVALUE ExtractToRegion (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToShape (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;

      virtual ERRVALUE v_CloseObject ();              
      virtual RVC::OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenMode, MDLGPARENT parent, const CREDENTIALS* Credentials);

      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);
      
      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_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 QSEARCHTREE* v_GetSearchTree (ELEMTYPE ElemType) const;
      virtual double v_GetTotalLineLength () const;
      virtual bool v_IsElementDeleted (const RVC::ELEMENT& Element) const;
      virtual bool v_IsEmpty () const;
      virtual ERRVALUE v_SetExtents (const DRECT3D &extents);
      virtual ERRVALUE v_SetNextElementID (ELEMTYPE ElemType, INT32 NextElementID);
      virtual void v_SetSearchTree (ELEMTYPE ElemType, QSEARCHTREE* SearchTree) const;
      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);
         
      virtual ERRVALUE v_FindClosestElementsLow (const DPOINT2D& SearchPt, double SearchDist, SEARCHFILTER* SearchFilter, SIMPLE_ARRAY<RVC::ELEMENT>& ElementList, COMPONENT Component) const;
      virtual INT32 v_GetAttachmentIndex (const RVC::ELEMENT& Element) const;
      virtual ERRVALUE v_ReadElement (INT32 ElemNum, POLYLINELIST& LineList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadElement (INT32 ElemNum, POLYLINE& PointList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadElement (INT32 ElemNum, REGION2D& Region, DIMENSION dim) const;
      virtual ERRVALUE v_ReadNextLabel (RVC::ELEMENT& Element, MILIST<LABEL>& Label, DIMENSION dim, STYLE* StyleObj) const;
      virtual ERRVALUE v_ReadNextLine (RVC::ELEMENT& Element, POLYLINELIST& LineList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadNextPoint (RVC::ELEMENT& Element, POLYLINE& PointList, DIMENSION dim) const;
      virtual ERRVALUE v_ReadNextRegion (RVC::ELEMENT& Element, REGION2D& Region, DIMENSION dim) const;
      virtual ERRVALUE v_ReadRegion (const BITSET_UNOWNED& ElemSet, REGION2D& Region, DIMENSION dim, bool NoIslands) const;
      
      CADHANDLE* m_CadHandle;
      LINKTYPE m_LinkType;       
      mutable QSEARCHTREE *m_CADQTree;
      class OPTIMIZE;
      mutable OPTIMIZE* m_Optimize;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


class CAD::DRAW : public CADELEMENT::DRAW {
   public:
      DRAW () {}
      virtual ~DRAW () {}
   
      int FilterElement (
         CADELEMENT& Element,             
         const TRANS2D_AFFINE& BtoC,         
         INT32 InsertLevel,                  
         INT32 ElemNum,                      
         const DRECT3D& Extents              
         ) { return (v_FilterElement(Element, BtoC, InsertLevel, ElemNum, Extents)); }
         
   private:
   #ifdef WIN32
      #pragma warning (push)
      #pragma warning (disable:4100)   // Unreferenced formal parameter
   #endif
      virtual int v_FilterElement (CADELEMENT& Element, const TRANS2D_AFFINE& BtoC, INT32 InsertLevel, INT32 ElemNum, const DRECT3D& Extents) { return (1); }
   #ifdef WIN32
      #pragma warning (pop)
   #endif
   };
   

class CAD::CONST_ELEMITERATOR {
   public:
      CONST_ELEMITERATOR (
         ) : 
         m_CADObj(0),
         m_Element(0),
         m_ReachedEnd(false)
         {}

      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
      CONST_ELEMITERATOR (
         const RVC::CAD* CADObj,
         INT32 // LastElemNum (not used, just here to differentiate from ctor for ElementBegin.
         ) : 
         m_Element(0),
         m_CADObj(CADObj),
         m_ReachedEnd(true)
         {}

      CONST_ELEMITERATOR (
         const RVC::CAD* CADObj
         );
            
      #endif // GENERATING_DOXYGEN_OUTPUT

      virtual ~CONST_ELEMITERATOR (
         ) {
         delete m_Element;
         }

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

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

      const ELEMENT* operator-> (
         ) const { return (&**this); }

      CONST_ELEMITERATOR& operator++ (
         );

      bool operator== (
         const CONST_ELEMITERATOR& rhs
         ) const { return (m_CADObj == rhs.m_CADObj && m_ReachedEnd == rhs.m_ReachedEnd); }

      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:

      LINKPARMS (
         const FILEPATH& filename,
         LINKTYPE LinkType,
         CHAR_ENCODING encoding = CHAR_ENCODING_ASCII
         ) :
         m_filename(filename),
         m_LinkType(LinkType),
         m_encoding(encoding)
         {}

      CHAR_ENCODING GetEncoding (
         ) const {return (m_encoding);}

      const FILEPATH& GetLinkFilePath (
         ) const {return (m_filename);}

      LINKTYPE GetLinkType (
         ) const {return (m_LinkType);}
         
      void SetEncoding (
         CHAR_ENCODING encoding
         ) {m_encoding = encoding;}

      void SetLinkFilePath (
         const FILEPATH& FilePath
         ) {m_filename = FilePath;}

      void SetLinkType (
         LINKTYPE LinkType
         ) {m_LinkType = LinkType;}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FILEPATH m_filename;
      LINKTYPE m_LinkType;
      CHAR_ENCODING m_encoding;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class CAD::MAKEPARMS : public RVC::GEOMETRIC::MAKEPARMSBASE {
   public:

      MAKEPARMS (
         POINTTYPE PointType = POINTTYPE_2DXY
         ) :
         GEOMETRIC::MAKEPARMSBASE(PointType),
         m_NextElemID(1),
         m_EditBlockNum(-1)
         {}

      MAKEPARMS (
         const RVC::CAD& Template
         );

      MAKEPARMS (
         const RVC::OBJITEMLIST& GeoObjItemList    
         );

      INT32 GetEditBlockNum (
         ) const { return (m_EditBlockNum); }
         
      INT32 GetNextElemID (
         ) const {return (m_NextElemID);}

      void SetEditBlockNum (
         INT32 BlockNum
         ) { m_EditBlockNum = BlockNum; }
         
      void SetNextElemID (
         INT32 NextElemID
         ) {m_NextElemID = NextElemID;}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      INT32 m_NextElemID;
      INT32 m_EditBlockNum;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif   // INC_RVC_CAD_H

---