mi32/color.h

Go to the documentation of this file.

#ifndef  INC_MI32_COLOR_H
#define  INC_MI32_COLOR_H

#ifndef  INC_MI32_INIBASE_H
#include <mi32/inibase.h>
#endif

#ifndef  INC_MI32_COLORSPC_H
#include <mi32/colorspc.h>
#endif

#ifndef  INC_MI32_MEMBUF_H
#include <mi32/membuf.h>
#endif

#ifndef  GENERATING_DOXYGEN_OUTPUT
class COLOR_ARRAY;
#endif

//----------------------------------------------------------------------------
//    Constants
//----------------------------------------------------------------------------

#define  STD64STEP      21845    
#define  NUMSTDCOLORS   80       

//===================================================================================================================
// Values are passed to DLLs and stored in files and cannot be changed.
// Values must be assigned contiguously and may not exceed 127
enum COLORMODEL {
   COLORMODEL_RGB =           0,    
   COLORMODEL_CMY =           1,    
   COLORMODEL_CMYK =          2,    
   COLORMODEL_COUNT
   };

#ifdef MISYSTEMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

//===================================================================================================================

struct CLASSLIBEXPORT COLOR {
   public:

      // Note, names are equal to COLORREF values to simplify assignment.
      enum NAME {
         //                     xxBBGGRR
         BLACK =              0x00000000,
         RED =                0x000000FF,
         GREEN =              0x0000FF00,
         BLUE =               0x00FF0000,
         CYAN =               0x00FFFF00,
         MAGENTA =            0x00FF00FF,
         YELLOW =             0x0000FFFF,
         GRAY25 =             0x003F3F3F,
         GRAY50 =             0x007F7F7F,
         GRAY75 =             0x00BFBFBF,
         GRAY =               GRAY50,
         ORANGE =             0x0000A5FF,
         BROWN =              0x002A2AA5,
         PURPLE =             0x00A020F0,
         DARKRED =            0x00000080,
         DARKGREEN =          0x00008000,
         DARKBLUE =           0x00800000,
         DARKCYAN =           0x00808000,
         DARKMAGENTA =        0x00A000A0,
         DARKYELLOW =         0x00008080,
         FORESTGREEN =        0x00228B22,
         WHITE =              0x00FFFFFF,
         INTERFACE_RED =      0x009C9CFF,
         INTERFACE_YELLOW =   0x009CFFFF,
         INTERFACE_GREEN =    0x009CFF9C,
         INTERFACE_CYAN =     0x00FFFF9C
         };

      // Values are stored in files and cannot be changed.
      // Values must be assigned contiguously and may not exceed 127
      enum MODEL {
         MODEL_RGB =          0,    
         MODEL_CMY =          1,    
         MODEL_CMYK =         2,    
         MODEL_COUNT
         };

      enum CAPABILITY {
         CAPABILITY_NoTransparency =      0,    
         CAPABILITY_AllowTransparent =    1,    
         CAPABILITY_AllowTransparency =   2,    
         CAPABILITY_AsPrevious =          3     
         };

      COLOR (
         ) : 
         m_u64(0)
         { }

      COLOR (
         UINT16 r16,
         UINT16 g16,
         UINT16 b16
         ):
         m_u64(0)
         { SetRGB(r16,g16,b16); }

      explicit COLOR (
         UINT32 ColorRef
         ):
         m_u64(0)
         { SetColorRef(ColorRef); }

      COLOR (
         NAME name
         ) :
         m_u64(0)
         { SetColorXBGR32(name); }

      COLOR& operator= (
         COLOR::NAME name
         ) { SetColorXBGR32(name); return (*this); }

      void Blend (
         const COLOR& other,
         UINT8 alpha = 128    
         );
      
      void Clear (
         ) { m_u64 = 0; }

      ERRVALUE GetByColorSpace (
         COLORSPACE colorspace,           
         void *values                     
         ) const;

      void GetCMY (
         UINT8& c8,        
         UINT8& m8,        
         UINT8& y8         
         ) const;

      void GetCMY (
         UINT16& c16,      
         UINT16& m16,      
         UINT16& y16       
         ) const;

      void GetCMYK (
         UINT8& c8,        
         UINT8& m8,        
         UINT8& y8,        
         UINT8& k8         
         ) const;

      void GetCMYK (
         UINT16& c16,      
         UINT16& m16,      
         UINT16& y16,      
         UINT16& k16       
         ) const;

      UINT32 GetColor0BGR32 (
         ) const;

      UINT32 GetColor0RGB32 (
         ) const;

      UINT32 GetColorABGR32 (
         ) const;

      UINT32 GetColorARGB32 (
         ) const;

      DEPRECATED COLORMODEL GetColorModel (
         ) const;

      UINT32 GetColorRef (
         ) const { return (GetColor0BGR32()); }

      void GetIniValues (
         UINT16 values[4]
         ) const;

      MODEL GetModel (
         ) const;

      UINT8 GetOpacity (
         ) const { return (UINT8_MAX - GetTransparency()); }

      void GetRGB (
         UINT8& r8,
         UINT8& g8,
         UINT8& b8
         ) const;

      void GetRGB (
         UINT8 *rgb     //<! Red/Green/Blue values returned
         ) const { GetRGB(rgb[0],rgb[1],rgb[2]); }

      void GetRGB (
         UINT16& r16,
         UINT16& g16,
         UINT16& b16
         ) const;

      void GetRGB (
         UINT16 *rgb    //<! Red/Green/Blue values returned
         ) const { GetRGB(rgb[0],rgb[1],rgb[2]); }

      void GetRGBA (
         float& r,      
         float& g,      
         float& b,      
         float& a       
         ) const;

      UINT8 GetTransparency (
         ) const { return (m_u8[I_transparency]); }

      bool HasTransparency (
         ) const { return (m_u8[I_transparency] != 0); }

      bool HasValue (
         ) const { return (m_u64 != 0); }

      bool IniRead (
         INIHANDLE hdl,
         const char *group,
         const char *field
         );

      void IniWrite (
         INIHANDLE hdl,
         const char *group,
         const char *field
         ) const;

      bool IsEqualNoTransp (
         const COLOR& rhs     
         ) const;

      bool IsEqualTo (
         const COLOR& rhs     
         ) const { return (m_u64 == rhs.m_u64); }

      bool IsICMCorrected (
         ) const {
         return ((m_u8[I_status] & (STATUS_NonRGB | STATUS_ICMCorrected)) != 0);
         }

      bool IsInvisible (
         ) const {
         return (m_u8[I_transparency] == UINT8_MAX);
         }

      bool IsReserved (
         ) const { 
         return ((m_u8[I_status] & STATUS_Reserved) && !(m_u8[I_status] & STATUS_NonRGB));
         }

      void SerialGetString (
         char *string                     
         ) const;

      void SerialSetString (
         const char *string               
         );

      ERRVALUE SetByColorSpace (
         COLORSPACE colorspace,           
         const void *values               
         );

      bool SetByName (
         const char *string               
         );

      void SetCMY (
         int cyan,
         int magenta,
         int yellow,
         int range                        
         );

      void SetCMY8 (
         UINT8 c8,                        
         UINT8 m8,                        
         UINT8 y8                         
         );

      void SetCMYK (
         int cyan,
         int magenta,
         int yellow,
         int black,
         int range                        
         );

      void SetCMYK8 (
         UINT8 c8,                        
         UINT8 m8,                        
         UINT8 y8,                        
         UINT8 k8                         
         );

      void SetColor (
         const COLOR& color               
         );

      void SetColorABGR32 (
         UINT32 abgr32                    
         );

      void SetColorARGB32 (
         UINT32 argb32                    
         );

      void SetColorXBGR32 (
         UINT32 xbgr32                    
         );

      void SetColorXRGB32 (
         UINT32 xrgb32                    
         );

      void SetColorRef (
         UINT32 ColorRef
         ) { SetColorXBGR32(ColorRef); }

      void SetIniValues (
         const UINT16 values[4]
         );

      void SetIsICMCorrected (
         bool bCorrected
         );

      void SetOpacity (
         UINT8 opacity                    
         );

      void SetReserved (
         bool reserved = true             
         );

      void SetRGB (
         UINT16 red,
         UINT16 green,
         UINT16 blue
         );

      DEPRECATED_MSG("Deprecated, use SetColor method instead.") void SetRGB (
         const COLOR& color
         );

      void SetRGB (
         int red,                      
         int green,                    
         int blue,                     
         int range                     
         );

      void SetRGB8 (
         UINT8 r8,
         UINT8 g8,
         UINT8 b8
         );

      void SetTransparency (
         UINT8 transparency               
         );

      void SwapBytes ()
         { ::SwapBytes(m_u16, 4); }

      void Validate (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Index into u8 array overlapped onto u16 array.
      enum I_U8 {
   #ifdef BYTEORDER_LoHi
         I_Lo0 =           0,
         I_Hi0 =           1,
         I_Lo1 =           2,
         I_Hi1 =           3,
         I_Lo2 =           4,
         I_Hi2 =           5,
         I_status =        6,
         I_transparency =  7,
   #else
         I_Hi0 =           0,
         I_Lo0 =           1,
         I_Hi1 =           2,
         I_Lo1 =           3,
         I_Hi2 =           4,
         I_Lo2 =           5,
         I_transparency =  6,
         I_status =        7,
   #endif
         // RGB16 color model
         RGB16_R8 = I_Hi0,
         RGB16_G8 = I_Hi1,
         RGB16_B8 = I_Hi2,
         RGB16_R8L = I_Lo0,
         RGB16_G8L = I_Lo1,
         RGB16_B8L = I_Lo2,
         // CMY16 color model
         CMY16_C8 = I_Hi0,
         CMY16_M8 = I_Hi1,
         CMY16_Y8 = I_Hi2,
         CMY16_C8L = I_Lo0,
         CMY16_M8L = I_Lo1,
         CMY16_Y8L = I_Lo2,
         // CMYK12 color model
         CMYK12_C8 = I_Lo0,
         CMYK12_M8 = I_Hi0,
         CMYK12_Y8 = I_Lo1,
         CMYK12_K8 = I_Hi1,
         CMYK12_CM4L = I_Lo2,
         CMYK12_YK4L = I_Hi2,
         };

      // Index values for m_u16 array.
      enum I_U16 {
         RGB16_R = 0,
         RGB16_G = 1,
         RGB16_B = 2,
         CMY16_C = 0,
         CMY16_M = 1,
         CMY16_Y = 2,
         };

      enum STATUS {
         STATUS_ValueSet =       0x01,
         LEGACY_Writable =       0x02,
         STATUS_Reserved =       0x04,
         LEGACY_Invisible =      0x08,
         LEGACY_Stored =         0x10,
         STATUS_ICMCorrected =   0x20, // ICM correction already done. Note, NonRGB implies ICM's already been done too
         STATUS_NonRGB =         0x80  // If set, all other bits are used to hold MODEL
         };

      union {
         UINT64 m_u64;
         UINT16 m_u16[4];
         UINT8 m_u8[8];
         };

      CHECKSIZE(8);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


inline bool operator== (
   const COLOR& lhs,
   const COLOR& rhs
   ) {
   return (lhs.IsEqualTo(rhs));
   }


inline bool operator!= (
   const COLOR& lhs,
   const COLOR& rhs
   ) {
   return (!lhs.IsEqualTo(rhs));
   }


inline int IniRead (INIHANDLE hdl, const char *group, const char *field, COLOR& value) { return (_iniRead(hdl,group,field,INITYPE_COLOR,&value,1)); }

inline int IniRead (INIHANDLE hdl, const char *group, const char *field, COLOR& value, const COLOR& dft) { value = dft; return (IniRead(hdl,group,field,value)); }

inline int IniWrite (INIHANDLE hdl, const char *group, const char *field, const COLOR& value) { return (_iniWrite(hdl,group,field,INITYPE_COLOR,&value,1)); }

inline void SwapBytes (
   COLOR& color
   ) {
   color.SwapBytes();
   }

//===================================================================================================================

#undef   CLASSLIBEXPORT

#endif   // INC_MI32_COLOR_H

---