color.h

Go to the documentation of this file.

/**
 * \file color.h <mi32/color.h>
 * \brief Definitions for COLOR structure and functions
 *
 * \if NODOC
 * $Id: color.h_v 1.56 2004/11/09 18:04:50 dwilliss Exp $
 *
 * $Log: color.h_v $
 * Revision 1.56  2004/11/09 18:04:50  dwilliss
 * Fix the dark colors
 *
 * Revision 1.55  2004/09/14 16:31:32  dwilliss
 * Define some new color names (darker versions)
 *
 * Revision 1.54  2004/07/09 21:52:52  vdronov
 * *** empty log message ***
 *
 * Revision 1.53  2004/03/03 15:56:38  mju
 * Use specified range in setcmyk when eventually set RGB.
 *
 * Revision 1.52  2004/03/02 22:48:18  scowan
 * Made most methods inline.
 *
 * Revision 1.51  2004/02/10 18:45:10  mju
 * Add GetRGB.
 *
 * Revision 1.50  2003/09/25 21:29:07  dwilliss
 * Don't capitalize enum any more. Genitor needed it, doxygen doesn't like it.
 *
 * Revision 1.49  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.48  2003/05/22 22:58:38  scowan
 * Moved to misystem.
 *
 * Revision 1.47  2003/05/22 21:36:10  scowan
 * Removed assignment operator from name string.
 *
 * Revision 1.46  2003/05/22 21:19:38  mju
 * Remove ctor taking char* name.
 *
 * Revision 1.45  2003/05/22 15:49:54  dwilliss
 * GetRed/GetGreen/GetBlue no longer inlines that just return members
 * They now depend on what colorspace the color is in
 *
 * Revision 1.44  2003/05/21 22:39:44  dwilliss
 * Added support for non-rgb colorspace storage
 *
 * Revision 1.43  2003/02/28 18:57:42  msmith
 * Fixed ORANGE color - it was backwards.
 *
 * Revision 1.42  2003/02/07 14:30:47  mju
 * Remove ; to fix mac warning.
 *
 * Revision 1.41  2003/01/23 16:17:10  dwilliss
 * Changed comments on Blend to indicate correct range for alpha.
 *
 * Revision 1.40  2003/01/23 15:17:31  dwilliss
 * Changed Blend to use UINT8 alpha value and avoid floating-point
 *
 * Revision 1.39  2003/01/22 23:04:03  dwilliss
 * Added a Blend method
 *
 * Revision 1.38  2002/11/22 15:26:35  mju
 * Add IsEqualNoTransp.
 *
 * Revision 1.37  2002/11/19 22:58:12  mju
 * Add COLORMODEL enum.
 *
 * Revision 1.36  2002/11/19 22:48:20  mju
 * Add SetCMYK.
 *
 * Revision 1.35  2002/11/18 15:57:50  mju
 * Add Get/SetByColorSpace.
 *
 * Revision 1.34  2002/11/14 23:02:23  mju
 * Change SetRGB from COLOR to use Get methods so will do colorspace conversione when implemented.
 *
 * Revision 1.33  2002/11/14 22:58:13  mju
 * Make GetRed/Green/Blue have separate implemention for non-range for efficiency.
 * Add STATUS_NonRGB for non-RGB colorspace storage.
 *
 * Revision 1.32  2002/11/11 15:58:54  mju
 * Deperecate stringtocolor.
 *
 * Revision 1.30  2002/11/07 14:03:13  mju
 * Init flags in ctor by name string.
 *
 * Revision 1.29  2002/10/25 14:56:17  mju
 * Add Validate method.
 *
 * Revision 1.28  2002/10/23 17:48:39  mju
 * Add IsReserved/SetReserved methods.
 * Deprecate old flags, add private enum for flags etc.
 *
 * Revision 1.27  2002/10/22 17:44:33  mju
 * Return value from op=.
 *
 * Revision 1.26  2002/10/22 14:57:15  mju
 * Remove setInvisible, use SetTransparency(255) instead.
 *
 * Revision 1.25  2002/10/22 14:26:37  mju
 * Change HasValue to check if any member set except certain flags.
 *
 * Revision 1.24  2002/10/21 20:55:48  mju
 * Deprecate NextColor fns.
 *
 * Revision 1.23  2002/10/21 20:49:55  dwilliss
 * Was missing a ";" after PREVENT_MEMCMP()
 *
 * Revision 1.22  2002/10/21 20:46:16  mju
 * Add Clear() and HasValue() methods.
 * Check appropriate flags in IsEqualTo method.
 *
 * Revision 1.21  2002/10/21 20:24:44  mju
 * Add SetByName and use in ctor/op=.
 * Make SetRGB non-inline with range.
 * Add PREVENT_MEMCMP.
 *
 * Revision 1.20  2002/10/21 16:53:35  mju
 * Deprecate access to COLOR data members.
 * Add various Get methods for accessing data members.
 * Add SetRGB method using range.
 *
 * Revision 1.19  2002/09/09 13:27:06  mju
 * Remove deprecated inline.
 *
 * Revision 1.18  2001/12/11 15:54:02  scowan
 * Added include for membuf for swap bytes.
 *
 * Revision 1.17  2001/12/11 15:50:07  scowan
 * Added swap bytes function to swap color structures correctly.
 *
 * Revision 1.16  2001/11/14 22:07:03  msmith
 * GetTransparency returns flags >> 8 now, not flags > 8
 *
 * Revision 1.15  2001/11/05 16:49:10  mju
 * Add ctor from colorref.
 *
 * Revision 1.14  2001/08/17 17:08:52  mju
 * Add SetRGB using color reference.
 *
 * Revision 1.13  2001/08/16 21:08:58  mju
 * Add SetColorRef() method.
 *
 * Revision 1.12  2001/02/19 15:21:07  mju
 * Add color::GetColorRef().
 *
 * Revision 1.11  2000/05/04 16:26:56  mju
 * Add SetTransparency method.
 * Add Genitor docs.
 *
 * Revision 1.1  1999/04/28  14:08:58  mju
 * Initial revision
 * \endif
**/

#ifndef  INC_MI32_COLOR_H
#define  INC_MI32_COLOR_H

#ifndef  INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

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

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

//----------------------------------------------------------------------------
//!      Constants
//----------------------------------------------------------------------------

#define  STD64STEP      21845    //!< Step value for creating 64 "standard" colors (65535 / 3)
#define  NUMSTDCOLORS   80       //!< 64 color + 16 gray

//===================================================================================================================
//! Color "model" enumeration.
// 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,    //!< Red-Green-Blue
   COLORMODEL_CMY =           1,    //!< Cyan-Magenta-Yellow
   COLORMODEL_CMYK =          2,    //!< Cyan-Magenta-Yellow-Black
   COLORMODEL_HIS =           3,    //!< Hue-Intensity-Saturation single hexcone
   COLORMODEL_HBS =           4,    //!< Hue-Brightness-Saturation double hexcone
   COLORMODEL_MunsellHSV =    5,    //!< Munsell Hue-Saturation-Value
   COLORMODEL_XYZ =           6,    //!< CIE XYZ (fixed point)
   COLORMODEL_Lab =           7,    //!< CIE Lab (fixed point)
   COLORMODEL_Pantone =       8,    //!< Pantone named colors (16 bit color number) 
   COLORMODEL_COUNT
   };

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

//===================================================================================================================
//! Structure to contain single color specification with possible transparency.
//!
//! This structure is stored in files and will never change in size.
struct CLASSLIBEXPORT COLOR {
   public:

      //! Enumerated color names.
      // 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 =        0x00A52A2A,
         PURPLE =       0x00A020F0,
         DARKRED =      0x00000080,
         DARKGREEN =    0x00008000,
         DARKBLUE =     0x00800000,
         DARKCYAN =     0x00808000,
         DARKMAGENTA =  0x00A000A0,
         DARKYELLOW =   0x00008080,
         FORESTGREEN =  0x00228B22,
         WHITE =        0x00FFFFFF
         };

      enum FLAGS {
         STATUS_ValueSet =       0x0001,
//    LEGACY_Writable =       0x0002,
         STATUS_Reserved =       0x0004,
         STATUS_Invisible =      0x0008,
//    LEGACY_Stored =         0x0010,
         STATUS_ICMCorrected =   0x0020,  //!< ICM correction already done. Note, NonRGB imlies ICM's already been done too
         STATUS_NonRGB =         0x0080,  //!< If set, other flags are usurped to hold COLORMODEL
         MASK_Compare =          0xFFE9,
         MASK_CompareNoTransp =  0x00E5,
         MASK_Transparency =     0xFF00,
         LEGACY_Invalid =        0xFFFF
         };

      //! Default constructor.
      COLOR (
         ) : 
         m_Red(0), 
         m_Green(0), 
         m_Blue(0), 
         m_flags(0)
         {}

      //! Construct with specified red, green, blue values.
      COLOR (
         UINT16 red,
         UINT16 green,
         UINT16 blue
         ) : 
         m_Red(red), 
         m_Green(green), 
         m_Blue(blue), 
         m_flags(STATUS_ValueSet)
         {}

      //! Construct by color reference.
      explicit COLOR (
         UINT32 ColorRef
         ) :
         m_Red(static_cast<UINT16>((ColorRef << 8) & 0xFF00)),
         m_Green(static_cast<UINT16>(ColorRef & 0xFF00)),
         m_Blue(static_cast<UINT16>((ColorRef >> 8) & 0xFF00)),
         m_flags(STATUS_ValueSet)
         {}

      //! Construct by enumerated name.
      COLOR (
         NAME name
         ) :
         m_Red(static_cast<UINT16>((name << 8) & 0xFF00)),
         m_Green(static_cast<UINT16>(name & 0xFF00)),
         m_Blue(static_cast<UINT16>((name >> 8) & 0xFF00)),
         m_flags(STATUS_ValueSet)
         {}

      //! Assign by enumerated name.
      //! Original flag and transparency values are retained.
      COLOR& operator= (
         COLOR::NAME name
         ) {
         m_Red = static_cast<UINT16>((name << 8) & 0xFF00);
         m_Green = static_cast<UINT16>(name & 0xFF00);
         m_Blue = static_cast<UINT16>((name >> 8) & 0xFF00);
         m_flags |= STATUS_ValueSet;
         return (*this);
         }

      //! Blend this color with another color.
      //! The range of values for alpha is 0-255.  
      void Blend (
         const COLOR& other,
         UINT8 alpha = 128    //!< 0 == all "this", 255 = all "other"
         ) {
         // Note: technically, alpha _should_ be 0-256, but for consistancy
         // it's a UINT8. Since we divide by shifting, the best we can get is
         // alpha == 255/256, which doesn't quite allow 1.0.  But if you really
         // wanted all the "other" color, you could just do an assignment.
         UINT32 inv = 256 - alpha;
         SetRGB ( 
            (UINT16)((GetRed() * inv + other.GetRed() * (UINT32)alpha) >> 8),
            (UINT16)((GetGreen() * inv + other.GetGreen() * (UINT32)alpha) >> 8),
            (UINT16)((GetBlue() * inv + other.GetBlue() * (UINT32)alpha) >> 8)
            );
         return;
         }
      
      //! Clear current color setting.
      void Clear (
         ) { 
         m_Red = m_Green = m_Blue = m_flags = 0;
         return;
         }

      //! Get Blue as UINT16 (0-65535).
      UINT16 GetBlue (
         ) const {
         return (m_Blue);
         }

      //! Get Blue in range specified.
      UINT16 GetBlue (
         UINT16 range                     //!< Range 1-65535
         ) const { 
         return (static_cast<UINT16>((static_cast<UINT32>(GetBlue()) * range + 32767) / 65535));
         }

      //! Get Blue as byte (0-255).
      UINT8 GetBlueByte (
         ) const { 
         return (static_cast<UINT8>(GetBlue() >> 8));
         }

      COLORMODEL GetColorModel (
         ) const {
         if (m_flags & STATUS_NonRGB) {
            return (static_cast<COLORMODEL>(m_flags & 0x7F));
            }
         return (COLORMODEL_RGB);
         }

      //! Get values in specified COLORSPACE.
      //! For colorspaces containing an "alpha" component, "alpha" is considered to be "opacity".
      //! Binary, grayscale and indexed colorspaces are not supported and an error will be returned for such.
      ERRVALUE GetByColorSpace (
         COLORSPACE colorspace,           //!< Color space
         void *values                     //!< Buffer to hold returned values, size depends on colorspace
         ) const;

      //! Get WIN32 color reference (0x00BBGGRR).
      UINT32 GetColorRef (
         ) const { 
         return ((m_Red >> 8) | (m_Green & 0xFF00) | (((INT32)(m_Blue & 0xFF00)) << 8));
         }

      //! Get Green as UINT16 (0-65535).
      UINT16 GetGreen (
         ) const {
         return (m_Green);
         }

      //! Get Green in range specified.
      UINT16 GetGreen (
         UINT16 range                     //!< Range 1-65535
         ) const { 
         return (static_cast<UINT16>((static_cast<UINT32>(GetGreen()) * range + 32767) / 65535));
         }

      //! Get Green as byte (0-255).
      UINT8 GetGreenByte (
         ) const { 
         return (static_cast<UINT8>(GetGreen() >> 8));
         }

      //! Get opacity value (0-255).
      UINT8 GetOpacity (
         ) const { 
         // STATUS_Invisible may be set if color was read in from old data
         if (!(m_flags & STATUS_NonRGB) && (m_flags & STATUS_Invisible)) {
            return (0);
            }
         return (static_cast<UINT8>(255 - (m_flags >> 8))); 
         }

      //! Get Red as UINT16 (0-65535).
      UINT16 GetRed (
         ) const {
         return (m_Red);
         }

      //! Get Red in range specified.
      UINT16 GetRed (
         UINT16 range                     //!< Range 1-65535
         ) const { 
         return (static_cast<UINT16>((static_cast<UINT32>(GetRed()) * range + 32767) / 65535)); 
         }

      //! Get Red as byte (0-255).
      UINT8 GetRedByte (
         ) const { 
         return (static_cast<UINT8>(GetRed() >> 8)); 
         }

      //! Get Red, Green, Blue values in single call for efficiency.
      void GetRGB (
         UINT16& red,
         UINT16& green,
         UINT16& blue
         ) const {
         red = m_Red;
         green = m_Green;
         blue = m_Blue;
         return;
         }

      //! Retrieve transparency value.
      //! @return Transparency (0 - 255), 0 = opaque, 255 = 100% transparent.
      UINT8 GetTransparency (
         ) const { 
         // STATUS_Invisible may be set if COLOR comes from old data
         if (!(m_flags & STATUS_NonRGB) && (m_flags & STATUS_Invisible)) {
            return (255);
            }
         return (static_cast<UINT8>(m_flags >> 8)); 
         }

      //! Determine if has any transparency value (including invisible).
      bool HasTransparency (
         ) const { 
         // STATUS_Invisible may be set if COLOR comes from old data
         if ((m_flags & MASK_Transparency) != 0) return (true);
         return (!(m_flags & STATUS_NonRGB) && (m_flags & STATUS_Invisible));
         }

      //! Determine if a color value has been set.
      bool HasValue (
         ) const { 
         return ((m_flags & MASK_Compare) != 0 || m_Red != 0 || m_Green != 0 || m_Blue != 0); 
         }

      //! Compare colors for equality, excluding transparency settings.
      bool IsEqualNoTransp (
         const COLOR& rhs     
         ) const { 
         if (((rhs.m_flags | m_flags) & STATUS_NonRGB) != 0) {
            // one or both are non-rgb. Compare all flags except transparency byte
            return (m_Red == rhs.m_Red && m_Green == rhs.m_Green && m_Blue == rhs.m_Blue && (m_flags & 0x00FF) == (rhs.m_flags & 0x00FF)); 
            }
         // Old data may also have the STATUS_Invisible flag set.
         return (m_Red == rhs.m_Red && m_Green == rhs.m_Green && m_Blue == rhs.m_Blue && (m_flags & MASK_CompareNoTransp) == (rhs.m_flags & MASK_CompareNoTransp)); 
         }

      //! Compare colors for equality, including transparency, etc.
      bool IsEqualTo (
         const COLOR& rhs     
         ) const { 
         if (((rhs.m_flags | m_flags) & STATUS_NonRGB) != 0) {
            // one or both are non-rgb. Compare all flags 
            return (m_Red == rhs.m_Red && m_Green == rhs.m_Green && m_Blue == rhs.m_Blue && m_flags == rhs.m_flags); 
            }
         // Legacy data may have some bits set that we want to ignore.
         return (m_Red == rhs.m_Red && m_Green == rhs.m_Green && m_Blue == rhs.m_Blue && (m_flags & MASK_Compare) == (rhs.m_flags & MASK_Compare)); 
         }

      //! Determine if the color has been run through an ICM transformation.
      //! This is used to insure that the same color isn't translated more
      //! than once.
      bool IsICMCorrected (
         ) const {
         if (m_flags & STATUS_NonRGB) return (true);
         return ((m_flags & STATUS_ICMCorrected) != 0);
         }

      //! Determine if color is 'invisible' (100% transparent).
      bool IsInvisible (
         ) const { 
         if (m_flags & STATUS_NonRGB) {
            return ((m_flags & 0xFF00) == 0xFF00);
            }
         // Legacy data may have STATUS_Invisible set
         return ((m_flags & STATUS_Invisible) != 0 || (m_flags & 0xFF00) == 0xFF00);
         }

      //! Determine if color is 'reserved' for application-specific use.
      //! In color search and allocation operations 'reserved' colors are not used or changed.
      bool IsReserved (
         ) const { 
         if (m_flags & STATUS_NonRGB) return (false); // NonRGB can't be reserved
         return ((m_flags & STATUS_Reserved) != 0); 
         }

      //! Get as string for serializer writing.
      void SerialGetString (
         char *string                     //!< String to contain values, should be at least 32 bytes
         ) const;

      //! Set from string for serializer reading.
      void SerialSetString (
         const char *string               //!< String to set from
         );

      //! Set values using specified COLORSPACE.
      //! For colorspaces containing an "alpha" component, "alpha" is considered to be "opacity".
      //! Binary, grayscale and indexed colorspaces are not supported and an error will be returned for such.
      ERRVALUE SetByColorSpace (
         COLORSPACE colorspace,           //!< Color space
         const void *values               //!< Buffer holding values to set, size depends on colorspace
         );

      //! Set color by name string.
      //! @return 'true' if name found, 'false' if not.
      //! Also supports strings in forms "redpct greenpct bluepct" and "redpct,greenpct,bluepct".
      bool SetByName (
         const char *string               //!< Color name, case-insensitive
         );

      //! Set from Cyan, Magenta, Yellow in specified range.
      void SetCMY (
         int cyan,
         int magenta,
         int yellow,
         int range                        //!< Range, 1-65535
         ) {
         SetRGB(range-cyan,range-magenta,range-yellow,range);
         return;
         }

      //! Set from Cyan, Magenta, Yellow, Black in specified range.
      void SetCMYK (
         int cyan,
         int magenta,
         int yellow,
         int black,
         int range                        //!< Range, 1-65535
         ) {
         int r = range - cyan - black;
         int g = range - magenta - black;
         int b = range - yellow - black;
         SetRGB(MAX(0,r),MAX(0,g),MAX(0,b),range);
         return;
         }

      //! Set red, green, blue values from WIN32 color reference (0x00BBGGRR).
      //! Original flag and transparency values are retained.
      void SetColorRef (
         UINT32 ColorRef
         ) {
         m_Red = static_cast<UINT16>((ColorRef << 8) & 0xFF00);
         m_Green = static_cast<UINT16>(ColorRef & 0xFF00);
         m_Blue = static_cast<UINT16>((ColorRef >> 8) & 0xFF00);
         if (m_flags & STATUS_NonRGB) m_flags &= ~0x00FF;
         m_flags |= STATUS_ValueSet;
         return;
         }

      //! Specify whether the color has been run through an ICM transformation.
      //! This is used to insure that the same color isn't translated more
      //! than once.
      //! Of course there's no way to specify which target profile it's been
      //! corrected to.  ICM-corrected colors should never be stored in files
      //! unless the whole file is corrected to some target device profile.
      void SetIsICMCorrected (
         bool bCorrected
         ) {
         if (m_flags & STATUS_NonRGB) return;   // It's implied for non RGB
         if (bCorrected) {
            m_flags |= STATUS_ICMCorrected;
            }
         else {
            m_flags &= ~STATUS_ICMCorrected;
            }
         return;
         }

      //! Set opacity value.
      void SetOpacity (
         UINT8 opacity                    //!< Value to set, 0 = invisible, 255 = 100% opaque
         ) {
         m_flags &= ~MASK_Transparency;
         m_flags |= static_cast<UINT16>(255-opacity) << 8;
         return;
         }

      //! Set whether color is 'reserved' or not.
      void SetReserved (
         bool reserved = true             //!< 'true' to make reserved, 'false' to not
         ) { 
         if (m_flags & STATUS_NonRGB) return;   // non-rgb can't be "reserved"
         if (reserved) {
            m_flags |= STATUS_Reserved; 
            }
         else {
            m_flags &= ~STATUS_Reserved;
            }
         return;
         }

      //! Set red, green, blue values in range 0-65535.
      //! Original flag and transparency values are retained.
      void SetRGB (
         UINT16 red,
         UINT16 green,
         UINT16 blue
         ) { 
         if (m_flags & STATUS_NonRGB) m_flags &= 0xFF00;
         m_Red = red; 
         m_Green = green; 
         m_Blue = blue; 
         m_flags |= STATUS_ValueSet; 
         return;
         }

      //! Set red, green, blue values from COLOR.
      //! Original flag and transparency values are retained.
      void SetRGB (
         const COLOR& color
         ) { 
         SetRGB(color.GetRed(),color.GetGreen(),color.GetBlue());
         return;
         }

      //! Set from Red, Green, Blue in specified range.
      //! Values outside the range will be limited to the range specified.
      void SetRGB (
         int red,                      //!< Red in range specified
         int green,                    //!< Green in range specified
         int blue,                     //!< Blue in range specified
         int range                     //!< Range, 1-65535
         ) {
         if (range < 1 || range > 65535) return;
         m_Red = static_cast<UINT16>((static_cast<UINT32>(bound(red,0,range)) * 65535 + range/2) / range);
         m_Green = static_cast<UINT16>((static_cast<UINT32>(bound(green,0,range)) * 65535 + range/2) / range);
         m_Blue = static_cast<UINT16>((static_cast<UINT32>(bound(blue,0,range)) * 65535 + range/2) / range);
         m_flags |= STATUS_ValueSet;
         m_flags &= ~STATUS_NonRGB;
         return;
         }

      //! Set transparency value.
      void SetTransparency (
         UINT8 transparency               //!< Value to set, 0 = opaque, 255 = 100% transparent
         ) {
         m_flags &= ~MASK_Transparency;
         m_flags |= static_cast<UINT16>(transparency) << 8;
         if (transparency < 255) m_flags &= ~STATUS_Invisible;
         return;
         }

      //! Validate status for some legacy stored color instances.
      void Validate (
         ) { 
         if (m_flags == LEGACY_Invalid) m_flags = STATUS_ValueSet;
         return;
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      UINT16 m_Red;
      UINT16 m_Green;
      UINT16 m_Blue;
      UINT16 m_flags;

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

PREVENT_MEMCMP(COLOR)
#undef   CLASSLIBEXPORT


//! Compare COLORs for equality.
inline bool operator== (
   const COLOR& lhs,
   const COLOR& rhs
   ) {
   return (lhs.IsEqualTo(rhs));
   }


//! Compare COLORs for inequality.
inline bool operator!= (
   const COLOR& lhs,
   const COLOR& rhs
   ) {
   return (!lhs.IsEqualTo(rhs));
   }


inline void SwapBytes (
   COLOR& color
   ) {
   SwapBytes(reinterpret_cast<UINT16*>(&color), 4);
   return;
   }

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

#endif   //!< INC_MI32_COLOR_H

---