rvc/cadelement.h

Go to the documentation of this file.

#ifndef INC_RVC_CADELEMENT_H
#define INC_RVC_CADELEMENT_H

#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_STYLETYPE_H
   #include <rvc/styletype.h>
#endif

#include <utility>

#ifndef GENERATING_DOXYGEN_OUTPUT   
// Forward Declarations
class LABELFRAMEPARMS;
struct LINESTYLE;
class PLANECONIC;
struct POINTSTYLE;
struct POLYSTYLE;
class SUBREGION2D;
struct TEXTSTYLE;
class TRANS2D_AFFINE;
namespace RVC {
   class STYLE;
   }
#endif

namespace RVC {

class CADELEMENT {
   public:
   
      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

      CADELEMENT (
         );

      CADELEMENT (
         const CADELEMENT& rhs
         );

      ~CADELEMENT (
         );
         
      CADELEMENT& operator= (
         const CADELEMENT& rhs
         );

      void Clear (
         );
         
      double ComputeDistanceFrom (
         const DPOINT2D& point
         ) const;

      bool ComputeExtents (
         DRECT3D& Extents,
         const RVC::STYLE* StyleObj = 0
         ) const;

      bool ComputeInsertBorder (
         const CAD& CadObj,
         POLYLINE& Border
         ) const;

      bool ComputeInsertExtents (
         const CAD& CadObj,
         DRECT3D& Extents
         ) const;

      void ConvertForward (
         const TRANS2D_AFFINE& taf
         );
      
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );

      ERRVALUE ConvertForwardDense (
         const TRANS2D_MAPGEN& tmg
         );

      void ConvertForward (
         const TRANS3D& t3d
         );
      
      void ConvertInverse (
         const TRANS2D_AFFINE& taf
         );
      
      ERRVALUE ConvertInverse (
         const TRANS2D_MAPGEN& tmg
         );

      ERRVALUE ConvertInverseDense (
         const TRANS2D_MAPGEN& tmg
         );

      void ConvertInverse (
         const TRANS3D& t3d
         );

      ERRVALUE DrawElement (
         DRAW& Draw,
         const TRANS2D_AFFINE& BlockToCAD,      
         double MinChordDist = 0.0,             
         DIMENSION dim = DIMENSION_2D
         );

      ELEMTYPE GetApproximateElementType (
         ) const;
         
      bool GetBox (
         BOX& Box
         ) const;
         
      INT32 GetDatabaseIndex (
         ) const;
      
      TYPE GetElementType (
         ) const;
      
      static TEXTID GetElementTypeTextID (
         TYPE CadType
         );

      bool GetElementStyle (
         TEXTSTYLE& textstyle
         ) const;
   
      bool GetElementStyle (
         POINTSTYLE& pointstyle
         ) const;
   
      bool GetElementStyle (
         LINESTYLE& linestyle
         ) const;
   
      bool GetElementStyle (
         POLYSTYLE& polystyle
         ) const;
         
      bool GetGMLElement (
         MISTRING& GMLElement,
         const MILIST<std::pair<MISTRING, MISTRING> >& AttribList       
         );
         
      bool GetInsert (
         INSERT& Insert
         ) const;
      
      bool GetLabelFrameParms (
         LABELFRAMEPARMS& FrameParms
         ) const;
         
      bool GetLines (
         POLYLINELIST& PolyLineList
         ) const;
         
      bool GetMesh (
         MESH& Mesh
         ) const;
      
      bool GetPlaneConic (
         PLANECONIC& Conic
         ) const;
         
      bool GetPoints (
         POLYLINE& PointArray
         ) const;
         
      bool GetRegion (
         REGION2D& Region,
         bool Validate = false
         ) const;
         
      bool GetSubRegion (
         SUBREGION2D& SubRegion,
         bool Validate = false
         ) const;
         
      bool GetTextElement (
         POLYLINELIST& PolyLineList,      
         MISTRING& text,
         TEXTSTYLE& style,
         LABELFRAMEPARMS* FrameParms = 0
         ) const;
         
      SCREENUNIT GetWidthUnits (
         ) const;

      double GetZValue (
         ) const;
         
      bool IsBaselineFit ( 
         ) const;

      bool IsBaselineSplineFit ( 
         ) const;
   
      bool IsClipUnderSet (
         ) const;
         
      bool IsInsertion (
         ) const;
   
      bool IsLine (
         ) const;
   
      bool IsPlaneConic (
         ) const;
   
      bool IsPoint (
         ) const;

      bool IsPointInside (
         const DPOINT2D& pt
         ) const;
   
      bool IsPolygon (
         ) const;
   
      bool IsText (
         ) const;

      bool IsValid (
         ) const;
   
      void SetBox (
         const BOX& Box
         );
      
      void SetBaselineFit (
         bool value
         );
         
      void SetBaselineSplineFit (
         bool value
         );
         
      void SetClipUnder (
         bool value
         );
         
      void SetDatabaseIndex (
         INT32 index
         );

      bool SetElementFromGML (
         const MISTRING& GMLElement,
         MILIST<std::pair<MISTRING, MISTRING> >& AttribList       
         );
      
      void SetElementStyle (
         const TEXTSTYLE& textstyle
         );
   
      void SetElementStyle (
         const POINTSTYLE& pointstyle
         );
   
      void SetElementStyle (
         const LINESTYLE& linestyle
         );
   
      void SetElementStyle (
         const POLYSTYLE& polystyle
         );
   
      void SetInsert (
         const INSERT& Insert
         );
      
      void SetLines (
         const POLYLINELIST& PolyLineList,
         DIMENSION dim = DIMENSION_2D
         );
         
      void SetMesh (
         const MESH& Mesh
         );
      
      void SetPlaneConic (
         const PLANECONIC& Conic
         );
   
      void SetPoint (
         const DPOINT3D& point,
         DIMENSION dim = DIMENSION_2D
         );
         
      void SetPoints (
         const POLYLINE& PointArray,
         DIMENSION dim = DIMENSION_2D
         );
         
      void SetPolyLine (
         const POLYLINE& PolyLine,
         DIMENSION dim = DIMENSION_2D
         );
         
      void SetRegion (
         const REGION2D& Region,
         DIMENSION dim = DIMENSION_2D
         );
         
      void SetSubRegion (
         const SUBREGION2D& SubRegion,
         DIMENSION dim = DIMENSION_2D
         );
         
      void SetTextElement (
         const POLYLINELIST& PolyLineList,         
         const MISTRING& text,
         const TEXTSTYLE& style,
         const LABELFRAMEPARMS* FrameParms = 0,
         DIMENSION dim = DIMENSION_2D
         );

      void SetWidthUnits (
         SCREENUNIT WidthUnits
         );
         
      void SetZValue (
         double zvalue
         );
         
      bool TestElement (
         const REGION2D& Region,
         TESTCRITERIA TestMode
         ) const;
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT   
      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 RVC::STYLE* StyleObj = 0) const;
      void GeneratePointsFromBox (POLYLINE& PolyLine) const;
      void GetPolyLineList (POLYLINELIST& PolyLineList) const;
      void SetPolyLineList (const POLYLINELIST& PolyLineList);
      void TranslatePatterns (const SIMPLE_ARRAY<INT32> PattTrans[RVC::PATTERNTYPE_NumTypes]);

      class GMLSAX;     
      friend class GMLSAX;
      friend class CAD;
      #endif
   };
   
#ifndef GENERATING_DOXYGEN_OUTPUT   
DEFINE_ENUM_OP_INCREMENT(CADELEMENT::TYPE)
#endif


class CADELEMENT::BOX {
   public:
      BOX () : m_Rotation(0.0) {}

      BOX (const BOX& rhs) : m_rect(rhs.m_rect), m_Rotation(rhs.m_Rotation) {}

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

      void Clear (
         ) {
         m_rect.SetInvalid();
         m_Rotation = 0.0;
         return;
         }

      // Generate a POLYLINE describing the box       
      void GeneratePoints (
         POLYLINE& PolyLine,
         DIMENSION dim
         ) const;
      
      const DRECT3D& GetBoxExtents (
         ) const { return (m_rect); }
   
      double GetRotation (
         ) const { return (m_Rotation); }
   
      void SetBoxExtents (
         const DRECT3D& rect
         ) { m_rect = rect; }
   
      void SetRotation (
         double Rotation
         ) { m_Rotation = Rotation; }
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT   
      DRECT3D m_rect;
      double m_Rotation;
      #endif
   };


class CADELEMENT::DRAW {
   public:
      DRAW () {}
      virtual ~DRAW () {}

      int DrawElement (
         const CADELEMENT& Element,       
         const TRANS2D_AFFINE& BtoC          
         ) { return (v_DrawElement(Element, BtoC)); }

      ERRVALUE DrawLines (
         const CADELEMENT& Element,       
         const POLYLINELIST& LineList        
         ) { return (v_DrawLines(Element, LineList)); }

      ERRVALUE DrawPoints (
         const CADELEMENT& Element,       
         const POLYLINE& Points              
         ) { return (v_DrawPoints(Element, Points)); }

      ERRVALUE DrawText (
         const CADELEMENT& Element,       
         const MISTRING& string,             
         const POLYLINELIST& LineList        
         ) { return (v_DrawText(Element, string, LineList)); }

      ERRVALUE DrawSubRegion (
         const CADELEMENT& Element,       
         const SUBREGION2D& SubRegion        
         ) { return (v_DrawSubRegion(Element, SubRegion)); }
         
   private:

   #ifdef WIN32
      #pragma warning (push)
      #pragma warning (disable:4100)   // Unreferenced formal parameter
   #endif
      virtual int v_DrawElement (const CADELEMENT& Element, const TRANS2D_AFFINE& BtoC) { return (0); }
      virtual ERRVALUE v_DrawLines (const CADELEMENT& Element, const POLYLINELIST& LineList) { return (0); }
      virtual ERRVALUE v_DrawPoints (const CADELEMENT& Element, const POLYLINE& Points) { return (0); }
      virtual ERRVALUE v_DrawText (const CADELEMENT& Element, const MISTRING& string, const POLYLINELIST& LineList) { return (0); }
      virtual ERRVALUE v_DrawSubRegion (const CADELEMENT& Element, const SUBREGION2D& SubRegion) { return (0); }
   #ifdef WIN32
      #pragma warning (pop)
   #endif
   };



class CADELEMENT::INSERT {
   public:
      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)
         {}
         
      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;
         }
         
      INT32 GetBlockNum (
         ) const { return (m_BlockNum); }
         
      double GetColumnSpace (
         ) const { return (m_colspace); }

      const DPOINT3D& GetInsertPoint (
         ) const { return (m_InsertPt); }

      double GetLineSpace (
         ) const { return (m_linspace); }

      INT32 GetNumColumns (
         ) const { return (m_numcols); }
         
      INT32 GetNumLines (
         ) const { return (m_numlins); }
         
      double GetRotation (
         ) const { return (m_rotate); }

      double GetXScale (
         ) const { return (m_xscale); }

      double GetYScale (
         ) const { return (m_yscale); }

      double GetZScale (
         ) const { return (m_zscale); }

      void SetBlockNum (
         INT32 BlockNum
         ) { m_BlockNum = BlockNum; }
         
      void SetColumnSpace (
         double ColumnSpace
         ) { m_colspace = ColumnSpace; }

      void SetInsertPoint (
         const DPOINT3D& InsertPt
         ) { m_InsertPt = InsertPt; }

      void SetLineSpace (
         double LineSpace
         ) { m_linspace = LineSpace; }

      void SetNumColumns (
         INT32 NumColumns
         ) { m_numcols = static_cast<UINT16>(NumColumns); if (m_numcols == 0) m_numcols = 1; }
         
      void SetNumLines (
         INT32 NumLines
         ) { m_numlins = static_cast<UINT16>(NumLines); if (m_numlins == 0) m_numlins = 1; }
         
      void SetRotation (
         double rotate
         ) { m_rotate = rotate; }

      void SetXScale (
         double xscale
         ) { m_xscale = xscale; if (m_xscale == 0.0) m_xscale = 1.0; }

      void SetYScale (
         double yscale
         ) { m_yscale = yscale; if (m_yscale == 0.0) m_yscale = 1.0; }

      void SetZScale (
         double zscale
         ) { m_zscale = zscale; if (m_zscale == 0.0) m_zscale = 1.0; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT   
      DPOINT3D m_InsertPt;             
      INT32 m_BlockNum;                
      double m_rotate;                 
      double m_xscale;                 
      double m_yscale;                 
      double m_zscale;                 
      UINT16 m_numlins;                
      UINT16 m_numcols;                
      double m_linspace;               
      double m_colspace;               
      #endif
   };


class CADELEMENT::MESH {
   public:
      MESH (
         ) : 
         m_NumLineVertices(0),
         m_NumColumnVertices(0),
         m_TopBottomClosed(false),
         m_LeftRightClosed(false)
         {}
         
      void Clear (
         ) {
         m_MeshPoints.Clear();         
         m_NumLineVertices = m_NumColumnVertices = 0;
         m_TopBottomClosed = m_LeftRightClosed = false;
         return;
         }
            
      const POLYLINE& GetMeshPoints (
         ) const { return (m_MeshPoints); }
      
      UINT32 GetNumColumnVertices (
         ) const { return (m_NumColumnVertices); }
         
      UINT32 GetNumLineVertices (
         ) const { return (m_NumLineVertices); }
         
      bool IsLeftRightClosed (
         ) const { return (m_LeftRightClosed); }
   
      bool IsTopBottomClosed (
         ) const { return (m_TopBottomClosed); }

      void SetLeftRightClosed (
         bool LeftRightClosed
         ) { m_LeftRightClosed = LeftRightClosed; }
         
      void SetMeshPoints (
         const POLYLINE& MeshPoints
         ) { m_MeshPoints = MeshPoints; }
   
      void SetNumColumnVertices (
         UINT32 NumColumnVertices
         ) { m_NumColumnVertices = NumColumnVertices; }
         
      void SetNumLineVertices (
         UINT32 NumLineVertices
         ) { m_NumLineVertices = NumLineVertices; }
         
      void SetTopBottomClosed (
         bool TopBottomClosed
         ) { m_TopBottomClosed = TopBottomClosed; }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT   
      UINT32 m_NumLineVertices;                 
      UINT32 m_NumColumnVertices;               
      bool m_TopBottomClosed;
      bool m_LeftRightClosed;
      POLYLINE m_MeshPoints;
      #endif
   };

}     // End of RVC namespace

#endif   // INC_RVC_CADELEMENT_H

---