rvc/stylepatternline.h

Go to the documentation of this file.

#ifndef INC_RVC_STYLEPATTERNLINE_H
#define INC_RVC_STYLEPATTERNLINE_H

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

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

namespace RVC {

class STYLEPATTERN_LINE : public STYLEPATTERN_BASE {
   public:

      enum ELEMENT_TYPE {
         ELEMENT_TYPE_Line =        0,
         ELEMENT_TYPE_CrossLine =   1,
         ELEMENT_TYPE_Circle =      2,
         ELEMENT_TYPE_Polyline =    3,
         ELEMENT_TYPE_Polygon =     4,
         ELEMENT_TYPE_Text =        5,
         ELEMENT_TYPE_Symbol =      6,
         ELEMENT_TYPE_COUNT
         };

      class ITERATOR;
      class ELEMENT;

      class ELEMENT_SHARED {
         public:

            MGD::LINECAP GetCapStyle (
               ) const { return ((m_pData->flags & LINEPATTELEM::FLAG_CapRound) ? MGD::LINECAP_Round : MGD::LINECAP_Butt); }

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

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

            INT16 GetInterval (
               ) const { return (m_pData->xspacing); }
               
            MGD::LINEJOIN GetJoinStyle (
               ) const { return ((m_pData->flags & LINEPATTELEM::FLAG_JoinMiter) ? MGD::LINEJOIN_Miter : (m_pData->flags & LINEPATTELEM::FLAG_JoinBevel) ? MGD::LINEJOIN_Bevel : MGD::LINEJOIN_Round); }

            INT16 GetOffsetAlong (
               ) const { return (m_pData->xoffset); }

            INT16 GetOffsetAside (
               ) const { return ((m_pData->type != ELEMENT_TYPE_Line) ? -m_pData->yoffset : m_pData->yoffset); }

            INT16 GetSize (
               ) const { return (m_pData->xsize); }

            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 & LINEPATTELEM::FLAG_Filled) != 0); }
               
         protected:

            struct LINEPATTELEM {
               enum TYPE {
                  TYPE_Line =    0,          
                  TYPE_CrossLine,            
                  TYPE_Circle,               
                  TYPE_PolyLine,             
                  TYPE_Polygon,              
                  TYPE_Last = TYPE_Polygon   
                  };
                  
               enum FLAGS {
                  FLAG_Filled =     0x0001,  
                  FLAG_JoinMiter =  0x0002,  
                  FLAG_JoinBevel =  0x0004,  
                  FLAG_CapRound =   0x0008   
                  };

               INT16 extrabytes;                   
               UINT8 type;                         
               UINT8 colornum;                     
               UINT16 flags;                       
               INT16 xoffset;                      
               INT16 xspacing;                     
               INT16 yoffset;                      
               INT16 xsize;                        
               INT16 thickness;                    
               };


         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            const LINEPATTELEM *m_pData;
            void *m_pExtra;

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

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

            ~ELEMENT_SHARED (
               ) { }

            friend class RVC::STYLEPATTERN_LINE;
            friend class ELEMENT;
            friend class ITERATOR;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class ELEMENT : public ELEMENT_SHARED {
         public:

            ELEMENT (
               ) { memset(&m_MyData,0,sizeof(m_MyData)); m_pData = &m_MyData; }

            ELEMENT (
               const ELEMENT& rhs
               );

            ELEMENT (
               const ELEMENT_SHARED& rhs
               );

            explicit ELEMENT (
               ELEMENT_TYPE type
               );

            ~ELEMENT (
               ) { if (m_pExtra != 0) free(m_pExtra); }

            ELEMENT& operator= (
               const ELEMENT& rhs
               );

            ELEMENT& operator= (
               const ELEMENT_SHARED& rhs
               );

            void SetCapStyle (
               MGD::LINECAP linecap
               ) { if (linecap == MGD::LINECAP_Round) m_MyData.flags |= LINEPATTELEM::FLAG_CapRound; else m_MyData.flags &= ~LINEPATTELEM::FLAG_CapRound; }

            void SetColorIndex (
               UINT8 idx
               ) { m_MyData.colornum = idx; }

            void SetFilled (
               bool filled
               ) { if (filled) m_MyData.flags |= LINEPATTELEM::FLAG_Filled; else m_MyData.flags &= ~LINEPATTELEM::FLAG_Filled; }

            void SetInterval (
               INT16 interval
               ) { m_MyData.xspacing = interval; }

            void SetJoinStyle (
               MGD::LINEJOIN linejoin
               ) {
               m_MyData.flags &= ~(LINEPATTELEM::FLAG_JoinMiter|LINEPATTELEM::FLAG_JoinBevel);
               if (linejoin == MGD::LINEJOIN_Miter) m_MyData.flags |= LINEPATTELEM::FLAG_JoinMiter;
               else if (linejoin == MGD::LINEJOIN_Bevel) m_MyData.flags |= LINEPATTELEM::FLAG_JoinBevel;
               }

            void SetOffsetAlong (
               INT16 offset
               ) { m_MyData.xoffset = offset; }

            void SetOffsetAside (
               INT16 offset
               ) { m_MyData.yoffset = (m_MyData.type != ELEMENT_TYPE_Line) ? -offset : offset; }

            void SetSize (
               INT16 size
               ) { m_MyData.xsize = size; }

            void SetThickness (
               INT16 thickness
               ) { m_MyData.thickness = thickness; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ELEMENT_SHARED::LINEPATTELEM m_MyData;
            #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 RVC::STYLEPATTERN_LINE;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      STYLEPATTERN_LINE (
         ) : STYLEPATTERN_BASE(PATTERNTYPE_Line, sizeof(PATTERNHEADER_LINE)) {}

      STYLEPATTERN_LINE (
         const void* buf,
         INT32 NumBytes
         ) : STYLEPATTERN_BASE(PATTERNTYPE_Line, sizeof(PATTERNHEADER_LINE)) {
         SetPattern(buf, NumBytes, sizeof(PATTERNHEADER_LINE));
         }
      
      STYLEPATTERN_LINE (
         const STYLEPATTERN_LINE& rhs
         ) : STYLEPATTERN_BASE(rhs) {}

      virtual ~STYLEPATTERN_LINE (
         ) { }

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

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

      ERRVALUE DeleteElement (
         unsigned idx
         );

      void DeleteUnusedColors (
         );

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

      ELEMENT GetElement (
         unsigned idx
         ) const;

      INT16 GetExtentLeft (
         ) const { return (reinterpret_cast<PATTERNHEADER_LINE*>(m_PattBuff)->extentsa); }

      INT16 GetExtentRight (
         ) const { return (reinterpret_cast<PATTERNHEADER_LINE*>(m_PattBuff)->extentsb); }

      ERRVALUE InsertElement (
         unsigned idx,
         const ELEMENT& element
         );

      ERRVALUE SetElement (
         unsigned idx,
         const ELEMENT& element
         );

      INT32 GetWidth (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct PATTERNHEADER_LINE : public STYLEPATTERN_BASE::PATTERNHEADER {
         INT16 extentsa;                     
         INT16 extentsb;                     
         };

      ERRVALUE BuildOffsetIndex () const;
      INT32 GetOffset (unsigned idx) const;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     

#endif   

---