rvc/stylepatternsymbol.h

Go to the documentation of this file.

#ifndef INC_RVC_STYLEPATTERNSYMBOL_H
#define INC_RVC_STYLEPATTERNSYMBOL_H

#ifndef INC_RVC_STYLEPATTERNBASE_H
   #include <rvc/stylepatternbase.h>
#endif

#ifndef INC_MI32_MG2ENUMS_H
   #include <mi32/mg2enums.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class MISTRING;
class PLANECONIC;
class POLYLINE;
class POLYLINELIST;
class SUBREGION2D;
struct TEXTSTYLE;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

class STYLEPATTERN_SYMBOL : public STYLEPATTERN_BASE {
   public:

      enum ELEMENT_TYPE {
         ELEMENT_TYPE_Null =        0,
         ELEMENT_TYPE_Circle =      1,
         ELEMENT_TYPE_Arc =         2,
         ELEMENT_TYPE_ArcWedge =    3,
         ELEMENT_TYPE_ArcChord =    4,
         ELEMENT_TYPE_Ellipse =     5,
         ELEMENT_TYPE_EArc =        6,
         ELEMENT_TYPE_EArcWedge =   7,
         ELEMENT_TYPE_EArcChord =   8,
         ELEMENT_TYPE_Line =        9,
         ELEMENT_TYPE_Polygon =     10,
         ELEMENT_TYPE_Point =    11,
         ELEMENT_TYPE_Text =        12,
         ELEMENT_TYPE_Segment =     13,
         ELEMENT_TYPE_Rectangle =   14,
         ELEMENT_TYPE_Polygons =    15,
         ELEMENT_TYPE_Splines  = 16,
         ELEMENT_TYPE_COUNT
         };

      class ITERATOR;
      class ELEMENT;

      class ELEMENT_SHARED {
         public:

            MGD::LINECAP GetCapStyle (
               ) const;

            UINT8 GetColorIndex (
               ) const { return (m_pData->colornum); }

            MGD::LINEJOIN GetJoinStyle (
               ) const;

            INT16 GetThickness (
               ) const { return (m_pData->thickness); }

            ELEMENT_TYPE GetType (
               ) const { return (static_cast<ELEMENT_TYPE>(m_pData->type)); }

            bool IsFilled (
               ) const { return ((m_pData->flags & SYMBOLELEM::FLAG_Filled) != 0); }

            bool GetPoint (
               DPOINT2D& point
               ) const;

            bool GetPoint (
               FPOINT2D& point
               ) const;

            bool GetPoint (
               WPOINT2D& point
               ) const;

            bool GetPoints (
               POLYLINE& points
               ) const;
   
            bool GetLines (
               POLYLINELIST& lines
               ) const;
   
            bool GetLine (
               POLYLINE& polyline
               ) const;
   
            bool GetPlaneConic (
               PLANECONIC& planeconic
               ) const;
   
            bool GetPolygon (
               POLYLINE& polygon
               ) const;

            bool GetSubRegion (
               SUBREGION2D& subregion
               ) const;
   
            bool GetText (
               MISTRING& string
               ) const;
   
            const MIUNICODE* const GetText (
               ) const;

            bool GetTextStyle (
               TEXTSTYLE& style
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            union SYMBOLDATA {
               struct { INT16 x, y, radius; } circle;
               struct { INT16 x, y, radius, sangle, eangle; } arc;
               struct { INT16 x, y, xsize, ysize, rotate; } ellipse;
               struct { INT16 x, y, xsize, ysize, sangle, eangle, rotate; } earc;
               struct { INT16 x, y; } point;
               struct { INT16 x1, y1, x2, y2; UINT16 capstyle; } segment;
               struct { INT16 x, y, xsize, ysize, rotate, shear; UINT16 joinstyle; } rectangle;
               struct { UINT16 numpoints, joinstyle, capstyle; } line;
               struct { UINT16 numpoints, joinstyle; } polygon;
               struct { UINT16 numchars, fontnum, fontstyle, flags;
                        INT16 x, y, height, rotate, shear, textrot, xscale; } text;
               struct { UINT16 numpoints, joinstyle, capstyle; } spline;
               struct { UINT16 numpoints, joinstyle, capstyle; } ttfsymbol;
               struct { UINT16 numpoints, joinstyle, numpolys; } polygons;
               INT16 spare[12];
               };

            struct SYMBOLELEM {
               enum FLAGS {
                  FLAG_None = 0x0000,
                  FLAG_Filled = 0x0001 
                  };
               
               SYMBOLDATA data;                    
               UINT32 numbytes;                    
               INT16 thickness;                    
               UINT16 flags;                       
               UINT8 type;                         
               UINT8 colornum;                     
               UINT8 spare[2];                     
               };

            const SYMBOLELEM *m_pData;
            void *m_pExtra;

            ELEMENT_SHARED (
               ): m_pData(0), m_pExtra(0) { }

            explicit ELEMENT_SHARED (const void *pElemData)
               : m_pData(static_cast<const SYMBOLELEM*>(pElemData)), m_pExtra(static_cast<UINT8*>(const_cast<void*>(pElemData)) + sizeof(SYMBOLELEM))
               { }

            ~ELEMENT_SHARED (
               ) { }

            friend class STYLEPATTERN_SYMBOL;
            friend class ITERATOR;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class ITERATOR {
         public:

            ITERATOR (
               ): m_pEnd(0) { }

            ~ITERATOR (
               ) { }

            const ELEMENT_SHARED& operator* (
               ) const { return (m_element); }

            const ELEMENT_SHARED* operator-> (
               ) const { return (&m_element); }

            ITERATOR& operator++ ();

            bool operator== (
               const ITERATOR& rhs
               ) const { return ((m_pEnd == 0 && rhs.m_pEnd == 0) || m_element.m_pData == rhs.m_element.m_pData); }

            bool operator!= (
               const ITERATOR& rhs
               ) const { return (!(*this == rhs)); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            ELEMENT_SHARED m_element;
            const void *m_pEnd;

            ITERATOR (const void *pData, const void *pEnd)
               : m_element(pData), m_pEnd(pEnd)
               { }

            friend class STYLEPATTERN_SYMBOL;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
         
      STYLEPATTERN_SYMBOL (
         ) : STYLEPATTERN_BASE(PATTERNTYPE_Symbol, sizeof(PATTERNHEADER_SYMBOL)) {}
      
      STYLEPATTERN_SYMBOL (
         const STYLEPATTERN_SYMBOL& rhs
         ) : STYLEPATTERN_BASE(rhs) {}

      STYLEPATTERN_SYMBOL (
         const void* buf,
         INT32 NumBytes
         ) : STYLEPATTERN_BASE(PATTERNTYPE_Symbol, sizeof(PATTERNHEADER_SYMBOL)) {
         SetPattern(buf, NumBytes, sizeof(PATTERNHEADER_SYMBOL));
         }
      
      virtual ~STYLEPATTERN_SYMBOL (
         ) { }

      STYLEPATTERN_SYMBOL& operator= (
         const STYLEPATTERN_SYMBOL& rhs
         ) { if (this != &rhs) { STYLEPATTERN_BASE::operator=(rhs); } return (*this); }

      ITERATOR Begin (
         ) const { return (ITERATOR(GetFirstElemPtr(),GetPattBuffer()+GetSize())); }

      ITERATOR End (
      #ifdef WIN32
         ) const { return (ITERATOR()); }
      #else
         ) const { ITERATOR it; return (it); }
      #endif

      INT16 GetHotSpotX (
         ) const { return (reinterpret_cast<const PATTERNHEADER_SYMBOL*>(m_PattBuff)->xhot); }

      INT16 GetHotSpotY (
         ) const { return (reinterpret_cast<const PATTERNHEADER_SYMBOL*>(m_PattBuff)->yhot); }

      INT16 GetSizeX (
         ) const { return (reinterpret_cast<const PATTERNHEADER_SYMBOL*>(m_PattBuff)->xsize); }

      INT16 GetSizeY (
         ) const { return (reinterpret_cast<const PATTERNHEADER_SYMBOL*>(m_PattBuff)->ysize); }

      bool ComputeSize (
         INT32& xsize,
         INT32& ysize
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct PATTERNHEADER_SYMBOL : public STYLEPATTERN_BASE::PATTERNHEADER {
         enum FLAGS {
            FLAG_None = 0x0000,
            FLAG_OldSymbol = 0x8000
            };
            
         INT16 xsize;                        
         INT16 ysize;                        
         INT16 xhot;                         
         INT16 yhot;                         
         UINT16 flags;                       
         UINT8 spare[2];                     
         };
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

}     

#endif   

---