rvc/stylepatternhatch.h

Go to the documentation of this file.

#ifndef INC_RVC_STYLEPATTERNHATCH_H
#define INC_RVC_STYLEPATTERNHATCH_H

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

#ifndef INC_MI32_POINT_H
   #include <mi32/point.h>
#endif


namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class STYLEPATTERN_LINE;
#endif // GENERATING_DOXYGEN_OUTPUT

class STYLEPATTERN_HATCH : public STYLEPATTERN_BASE {
   public:

      enum ELEMENT_TYPE {
         ELEMENT_TYPE_Simple      = 0,
         ELEMENT_TYPE_LinePattern = 1,
         ELEMENT_TYPE_SolidFill   = 2,
         ELEMENT_TYPE_COUNT       = 3
         };

      class ITERATOR;
      class ELEMENT;

      class ELEMENT_SHARED {
         public:

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

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

            void GetLinePattern (
               STYLEPATTERN_LINE& pattern
               ) const;

            UINT32 GetFlags (
               ) const { return (0); };

            void GetOriginOffset (
               DPOINT2D& offset
               ) const { offset.x = m_pData->xoffset; offset.y = m_pData->yoffset; return; }

            double GetSpacing (
               ) const { return (m_pData->spacing); }

            double GetAngle (
               ) const { return (m_pData->angle); }

            double GetThickness (
               ) const { return (m_pData->thickness); }
               
            bool IsVisible (
               ) const { return (m_pData->isvisible != 0); }

         protected:

            struct HATCHPATTELEM {
               enum TYPE {
                  TYPE_Simple =        0, 
                  TYPE_LinePattern =   1, 
                  TYPE_SolidFill =     2, 
                  TYPE_Last =          2  
                  };
                  
               UINT8 type;                         
               UINT8 colornum;                     
               UINT8 isvisible;                    
               UINT8 space;                        
               UINT32 linedatasize;                
               UINT32 flags;                       
               UINT8 spare[4];                     
               DOUBLE xoffset;                     
               DOUBLE yoffset;                     
               DOUBLE spacing;                     
               DOUBLE angle;                       
               DOUBLE thickness;                   
               };
   
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            const HATCHPATTELEM *m_pData;
            void *m_pExtra;

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

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

            ~ELEMENT_SHARED (
               ) { }

            friend class STYLEPATTERN_HATCH;
            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 SetColorIndex (
               UINT8 ColorNum
               ) { m_MyData.colornum = ColorNum; }

            void SetLinePattern (
               const STYLEPATTERN_LINE& pattern
               );

            void SetOriginOffset (
               const DPOINT2D& offset
               ) { m_MyData.xoffset = offset.x; m_MyData.yoffset = offset.y; }

            void SetSpacing (
               double spacing
               ) { m_MyData.spacing = spacing; }

            void SetAngle (
               double angle
               ) { m_MyData.angle = angle; }

            void SetThickness (
               double thickness
               ) { m_MyData.thickness = thickness; }
               
            void SetVisible (
               bool visible
               ) { m_MyData.isvisible = visible; }
               
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            ELEMENT_SHARED::HATCHPATTELEM 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 STYLEPATTERN_HATCH;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      STYLEPATTERN_HATCH (
         ) : STYLEPATTERN_BASE(PATTERNTYPE_Hatch, sizeof(PATTERNHEADER_HATCH)) {}
      
      STYLEPATTERN_HATCH (
         const void* buf,
         INT32 NumBytes
         ) : STYLEPATTERN_BASE(PATTERNTYPE_Hatch, sizeof(PATTERNHEADER_HATCH)) {
         SetPattern(buf, NumBytes, sizeof(PATTERNHEADER_HATCH));
         }
      
      STYLEPATTERN_HATCH (
         const STYLEPATTERN_HATCH& rhs
         ) : STYLEPATTERN_BASE(rhs) {}

      virtual ~STYLEPATTERN_HATCH (
         ) { }

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

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

      ERRVALUE DeleteElement (
         unsigned idx
         );
         
      ITERATOR End (
      #ifdef WIN32
         ) const { return (ITERATOR()); }
      #else
         ) const { ITERATOR it; return (it); }
      #endif

      ELEMENT GetElement (
         unsigned idx
         ) const;

      void LowerElement (
         UINT32 Element
         );

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

      void RaiseElement (
         UINT32 Element
         );

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

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      struct PATTERNHEADER_HATCH : public STYLEPATTERN_BASE::PATTERNHEADER {
         UINT8 spare[4];                     
         };

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


}     

#endif   

---