rvc/stylepatternbase.h

Go to the documentation of this file.

#ifndef INC_RVC_STYLEPATTERNBASE_H
#define INC_RVC_STYLEPATTERNBASE_H

#ifndef INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef INC_MI32_COLOR_H
   #include <mi32/color.h>
#endif

#ifndef INC_RVC_OBJECTNAME_H
   #include <rvc/objectname.h>
#endif

#ifndef INC_RVC_STYLETYPE_H
   #include <rvc/styletype.h>
#endif

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class STYLE;
#endif // GENERATING_DOXYGEN_OUTPUT

class STYLEPATTERN_BASE {
   public:
   
      enum SPECIALCOLOR {
         SPECIALCOLOR_Transparent = 255,
         SPECIALCOLOR_Variable =    254
         };

      STYLEPATTERN_BASE (
         ) : 
         m_PattBuff(0), 
         m_PattHdrSize(sizeof(PATTERNHEADER)), 
         m_PattBuffSize(sizeof(PATTERNHEADER)), 
         m_BuffSizeAlloc(sizeof(PATTERNHEADER))
         { 
         MmAllocCExc((void**)&m_PattBuff, m_PattBuffSize); 
         }
         
      virtual ~STYLEPATTERN_BASE (
         ) { MmFree(m_PattBuff); }

      ERRVALUE AppendColor (
         const COLOR& color
         );

      void Clear (
         ) { m_PattBuffSize = m_PattHdrSize; memset(m_PattBuff,0,m_PattHdrSize); }

      const RVC::OBJECTNAME& GetName (
         ) const { return (*reinterpret_cast<const OBJECTNAME*>(m_PattBuff)); }

      const COLOR& GetColor (
         UINT8 idx
         ) const { return (GetColors()[idx]); }

      const COLOR* GetColors (
         ) const { return (reinterpret_cast<COLOR*>(m_PattBuff + m_PattHdrSize)); }
         
      INT32 GetNumColors (
         ) const { return (reinterpret_cast<const PATTERNHEADER*>(m_PattBuff)->numcolors); }

      INT32 GetNumElements (
         ) const { return (reinterpret_cast<const PATTERNHEADER*>(m_PattBuff)->numelements); }

      PATTERNTYPE GetPatternType (
         ) const { return (m_PattType); }

      // XXX make protected when possible.
      INT32 GetSize (
         ) const { return (m_PattBuffSize); }

      bool IsEmpty (
         ) const { return (v_IsEmpty()); }

      bool IsEqualDef (
         const STYLEPATTERN_BASE& rhs
         ) const {
         if (m_PattBuffSize != rhs.m_PattBuffSize) return (false);
         return (memcmp(m_PattBuff+sizeof(OBJECTNAME),rhs.m_PattBuff+sizeof(OBJECTNAME),m_PattBuffSize-sizeof(OBJECTNAME))==0);
         }

      void SetColor (
         UINT8 idx,
         const COLOR& color
         ) { if (idx < GetNumColors()) reinterpret_cast<COLOR*>(m_PattBuff + m_PattHdrSize)[idx] = color; }

      void SetName (
         const OBJECTNAME& name
         ) { *reinterpret_cast<OBJECTNAME*>(m_PattBuff) = name; }

      ERRVALUE SetPattern (
         const void* SrcPattBuff,
         INT32 PattBuffSize,
         INT32 PattHdrSize
         );

      // XXX delete when drawing code updated.
      operator const void* (
         ) const { return (m_PattBuff); }

         
   protected:

      struct PATTERNHEADER {
         RVC::OBJECTNAME name;               
         INT16 numelements;                  
         INT16 numcolors;                    
         };

      STYLEPATTERN_BASE (
         PATTERNTYPE PattType,
         int PattHdrSize
         ) : 
         m_PattBuff(0), 
         m_PattHdrSize(PattHdrSize), 
         m_PattBuffSize(PattHdrSize), 
         m_BuffSizeAlloc(PattHdrSize),
         m_PattType(PattType)
         { 
         MmAllocCExc((void**)&m_PattBuff, m_PattBuffSize); 
         }
         
      STYLEPATTERN_BASE (const STYLEPATTERN_BASE& rhs);

      STYLEPATTERN_BASE& operator= (const STYLEPATTERN_BASE& rhs);
      
      void DeleteColorSet (
         const UINT8 *set              
         );

      void DeleteFromBuffer (
         INT32 offset,
         INT32 numbytes
         );

      const UINT8* GetPattBuffer (
         ) const { return (m_PattBuff); }

      UINT8* GetPattBuffer (
         ) { return (m_PattBuff); }

      const UINT8* GetFirstElemPtr (
         ) const { return (m_PattBuff+m_PattHdrSize+((GetNumColors()>0)?GetNumColors():0)*sizeof(COLOR)); }

      UINT8* GetFirstElemPtr (
         ) { return (m_PattBuff+m_PattHdrSize+((GetNumColors()>0)?GetNumColors():0)*sizeof(COLOR)); }

      ERRVALUE InsertIntoBuffer (
         INT32 offset,
         INT32 numbytes,
         const void *data = 0
         );
         
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT8* m_PattBuff;
      INT32 m_PattHdrSize;
      INT32 m_PattBuffSize;
      mutable SIMPLE_ARRAY<UINT32> m_OffsetArray;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      INT32 m_BuffSizeAlloc;
      PATTERNTYPE m_PattType;

      virtual bool v_IsEmpty (
         ) const { return (GetNumElements() == 0); }
         
      friend class STYLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif   // INC_RVC_STYLEPATTERNBASE_H

---