mg2cms.h

Go to the documentation of this file.

/**
 * \file mi32/mg2cms.h
 * \brief MGD classes for ICM
 *
 * vim: ts=3 sw=3
 *
 * \if NODOC
 * $Log: mg2cms.h_v $
 * Revision 1.17  2003/10/01 22:16:27  dwilliss
 * Doxygen
 *
 * Revision 1.16  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.15  2003/07/31 20:36:07  dwilliss
 * Added operator== and operator!= for MGD::PROFILE
 *
 * Revision 1.14  2003/07/03 22:17:08  dwilliss
 * *** empty log message ***
 *
 * Revision 1.13  2003/07/03 17:52:10  dwilliss
 * *** empty log message ***
 *
 * Revision 1.12  2003/06/27 19:12:14  dwilliss
 * *** empty log message ***
 *
 * Revision 1.11  2003/06/16 22:56:43  dwilliss
 * *** empty log message ***
 *
 * Revision 1.10  2003/06/13 20:28:12  dwilliss
 * Added PROFILEPARMS base class, changed PROFILEPARMS_RGB to derive from it
 * and added PROFILEPARMS_PRINTER
 *
 * Revision 1.9  2003/06/12 17:40:52  dwilliss
 * Fixed a const problem
 *
 * Revision 1.8  2003/06/12 15:05:54  dwilliss
 * include colorspc.h
 *
 * Revision 1.7  2003/06/11 17:11:43  dwilliss
 * Virtual methods all renamed to start with v_ and made private (where
 * Changed a bunch of stuff
 * AAARG!)
 * possible) or protected.
 *
 * Revision 1.6  2003/06/06 22:34:29  dwilliss
 * Still implementing
 *
 * Revision 1.5  2003/05/28 15:13:46  dwilliss
 * Still working on implementation
 *
 * Revision 1.4  2003/05/22 15:43:35  dwilliss
 * Cleaned up so that the implementation module will compile without having
 * to cast stuff all over the place
 *
 * Revision 1.3  2003/05/22 14:17:24  dwilliss
 * Don't include contrib include file here.
 *
 * Revision 1.2  2003/05/21 22:30:37  dwilliss
 * *** empty log message ***
 *
 * Revision 1.1  2003/05/16 16:01:07  dwilliss
 * Initial revision
 *
 *
 * \endif
 **/

#ifndef INC_MI32_MG2CMS_H
#define INC_MI32_MG2CMS_H

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

#ifndef INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

#ifndef INC_MI32_MILIST_H
#include <mi32/milist.h>
#endif

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

#ifndef INC_MI32_MCB_H
#include <mi32/mcb.h>
#endif

#ifndef INC_MI32_SERIALIZ_H
#include <mi32/serializ.h>
#endif

struct COLOR;
class MISTRING;
class XMLNODE;

namespace MGUI {
class XMLFORM_DATA;
}


//! Forward decl of things defined in lcms/lcms.h, which we can't include here.
typedef void* cmsHPROFILE;
typedef void* cmsHTRANSFORM;

#ifndef GENERATING_DOXYGEN_OUTPUT
//! Warning! This is evil!
//! Several methods need to take a COLORXYZ or COLORxyY, which consists of three
//! doubles and won't fit in our COLOR structure.  I'd like to just pass the
//! cmsCIEXYZ and cmsCIExyY structures, but they're defined in an include file
//! that our rules say I can't include here. 
//! I can define my own versions of them, but then I'd have to cast them a lot
//! inside the implementation module.  The solution is to define them as being
//! derived from the real cms classes if lcms/lcms.h has been included and 
//! define the same thing myself if not.
#ifdef __cms_H
#define COLORXYZ_BASE   cmsCIEXYZ
#define COLORxyY_BASE   cmsCIExyY
#else
namespace { 
   struct CIECOLORXYZ { double X, Y, Z; }; 
   struct CIECOLORxyY { double x, y, Y; }; 
}
#define COLORXYZ_BASE   CIECOLORXYZ
#define COLORxyY_BASE   CIECOLORxyY
#endif
#endif // GENERATING_DOXYGEN_OUTPUT


//! A color in XYZ space, represented using doubles instead of INT16.
//! The class members are public, but not shown here due to the way
//! the class is defined. They're named X, Y, and Z
//! If you have included <lcms/lcms.h> before this include file, then
//! COLORXYZ is defined as being derived from cmsCIEXYZ so that you can
//! pass one to functions in the lcms library.  But only the mg2cms.c
//! module needs to do that.
class COLORXYZ : public COLORXYZ_BASE {
   public:
      COLORXYZ();
      COLORXYZ(double X, double Y, double Z);
      COLORXYZ(const COLORXYZ&);
      explicit COLORXYZ(const COLOR&);
      COLORXYZ& operator=(const COLORXYZ& rhs);
      COLORXYZ& operator=(const COLOR& rhs);

      //! Get the ITEMDEF array for serializing this class
      static const SERIALIZER::ITEMDEF* GetSerialItemDef();

      //! Converts the color to sRGB and returns in our COLOR structure
      //! Returns false if out of gammut
      bool GetColor_sRGB(COLOR&) const;
   };


//! A color in xyY space, represented using doubles instead of INT16.
//! The class members are public, but not shown here due to the way
//! the class is defined. They're named x, y, and Y
//! If you have included <lcms/lcms.h> before this include file, then
//! COLORxyY is defined as being derived from cmsCIExyY so that you can
//! pass one to functions in the lcms library.  But only the mg2cms.c
//! module needs to do that.
class COLORxyY : public COLORxyY_BASE {
   public:
      COLORxyY();
      COLORxyY(double x, double y, double Y);
      COLORxyY(const COLORxyY&);
      COLORxyY(const COLOR&);
      COLORxyY& operator=(const COLORxyY& rhs);
      COLORxyY& operator=(const COLOR& rhs);

      //! Get the ITEMDEF array for serializing this class
      static const SERIALIZER::ITEMDEF* GetSerialItemDef();

      //! Set a color as a WhitePoint in degrees Kelvin
      bool SetTemperature (
         int DegreesKelvin
         );

      //! Converts the color to sRGB and returns in our COLOR structure
      //! Returns false if out of gammut
      bool GetColor_sRGB(COLOR&) const;

   //! Actual data is inherited from the base class, defined by lcms.h
   };

namespace MGD {

   class TRANSFORM;
   class DEVICE;
   class PROFILEPARMS_RGB;
   class PROFILEPARMS_PRINTER;

   class GAMMA {
      public:
         GAMMA (
            int entries,
            double gamma
            );

         ~GAMMA();

         //! Smooths the gamma table.
         //! "Smooth" curves work better and are more pleasant to the eyes.
         //! Documentation doesn't say what lambda values should be.
         bool Smooth (
            double lambda
            );

         #ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef __cms_H
         //! Returns the GAMMATABLE as expected by the lcms library functions
         GAMMATABLE* GetTable (
            ) const {
            return m_table;
            }
#endif
         #endif // GENERATING_DOXYGEN_OUTPUT

         //! Could define += and + operators which would call
         //!   cmsJoinGamma
         //!
      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef __cms_H
         //! Only defined inside the implementation module.  We can't forward
         //! declare it because it's defined in a contributed include file as
         //! an nunamed struct with a typedef.
         GAMMATABLE* m_table;
#else
         void* m_table; 
#endif
         #endif // GENERATING_DOXYGEN_OUTPUT

      };

   //! In-memory representataion of an ICM profile
   class PROFILE {
      public:
         //! Profiles which can be hard-coded without the need for a file
         enum BUILTIN_PROFILE {
            PROFILE_NONE      = -1,    //!< so we can initialize to "not set" 
            PROFILE_sRGB      = 0,
            PROFILE_XYZ,
            PROFILE_LAB,
            PROFILE_AdobeRGB_1998,
            PROFILE_AppleRGB
            };

         //! Rendering Intent
         enum INTENT {
            INTENT_Perceptual             = 0,     //!< The default
            INTENT_RelativeColorimetric   = 1,
            INTENT_Saturation             = 2,
            INTENT_AbsoluteColorimetric   = 3
            };

         //! Profile usage.  Used as a parameter to SupportsIntent()
         enum USAGE {
            USAGE_Input    = 0,
            USAGE_Output   = 1,
            USAGE_Proof    = 2
            };

         //! ICM Profile tags.
         //! These are only used to see if a profile has a given tag, and 
         //! eventually to retrieve data for specific tags
         enum TAG {
            TAG_AToB0                       = 0x41324230L,  //!<  'A2B0' 
            TAG_AToB1                       = 0x41324231L,  //!<  'A2B1' 
            TAG_AToB2                       = 0x41324232L,  //!<  'A2B2' 
            TAG_BlueColorant                = 0x6258595AL,  //!<  'bXYZ' 
            TAG_BlueTRC                     = 0x62545243L,  //!<  'bTRC' 
            TAG_BToA0                       = 0x42324130L,  //!<  'B2A0' 
            TAG_BToA1                       = 0x42324131L,  //!<  'B2A1' 
            TAG_BToA2                       = 0x42324132L,  //!<  'B2A2' 
            TAG_CalibrationDateTime         = 0x63616C74L,  //!<  'calt' 
            TAG_CharTarget                  = 0x74617267L,  //!<  'targ' 
            TAG_Copyright                   = 0x63707274L,  //!<  'cprt' 
            TAG_CrdInfo                     = 0x63726469L,  //!<  'crdi' 
            TAG_DeviceMfgDesc               = 0x646D6E64L,  //!<  'dmnd' 
            TAG_DeviceModelDesc             = 0x646D6464L,  //!<  'dmdd' 
            TAG_Gamut                       = 0x67616D74L,  //!<  'gamt ' 
            TAG_GrayTRC                     = 0x6b545243L,  //!<  'kTRC' 
            TAG_GreenColorant               = 0x6758595AL,  //!<  'gXYZ' 
            TAG_GreenTRC                    = 0x67545243L,  //!<  'gTRC' 
            TAG_Luminance                   = 0x6C756d69L,  //!<  'lumi' 
            TAG_Measurement                 = 0x6D656173L,  //!<  'meas' 
            TAG_MediaBlackPoint             = 0x626B7074L,  //!<  'bkpt' 
            TAG_MediaWhitePoint             = 0x77747074L,  //!<  'wtpt' 
            TAG_NamedColor                  = 0x6E636f6CL,  /* 'ncol' 
                                                                  * OBSOLETE, use ncl2 */
            TAG_NamedColor2                 = 0x6E636C32L,  //!<  'ncl2' 
            TAG_Preview0                    = 0x70726530L,  //!<  'pre0' 
            TAG_Preview1                    = 0x70726531L,  //!<  'pre1' 
            TAG_Preview2                    = 0x70726532L,  //!<  'pre2' 
            TAG_ProfileDescription          = 0x64657363L,  //!<  'desc' 
            TAG_ProfileSequenceDesc         = 0x70736571L,  //!<  'pseq' 
            TAG_Ps2CRD0                     = 0x70736430L,  //!<  'psd0' 
            TAG_Ps2CRD1                     = 0x70736431L,  //!<  'psd1' 
            TAG_Ps2CRD2                     = 0x70736432L,  //!<  'psd2' 
            TAG_Ps2CRD3                     = 0x70736433L,  //!<  'psd3' 
            TAG_Ps2CSA                      = 0x70733273L,  //!<  'ps2s' 
            TAG_RenderingIntent             = 0x70733269L,  //!<  'ps2i' 
            TAG_RedColorant                 = 0x7258595AL,  //!<  'rXYZ' 
            TAG_RedTRC                      = 0x72545243L,  //!<  'rTRC' 
            TAG_ScreeningDesc               = 0x73637264L,  //!<  'scrd' 
            TAG_Screening                   = 0x7363726EL,  //!<  'scrn' 
            TAG_Technology                  = 0x74656368L,  //!<  'tech' 
            TAG_UcrBg                       = 0x62666420L,  //!<  'bfd ' 
            TAG_ViewingCondDesc             = 0x76756564L,  //!<  'vued' 
            TAG_ViewingConditions           = 0x76696577L  //!<  'view' 
         };

         /* 
          * Color Space Signatures
          * Note that only icSigXYZData and icSigLabData are valid
          * Profile Connection Spaces (PCSs)
          *
          * These are NOT the same as our COLORSPACE enum, which really should
          * have been called FORMAT or something.
          */ 
         enum ICMCOLORSPACE {
            ICMCOLORSPACE_XYZ                 = 0x58595A20L,  //!<  'XYZ ' 
            ICMCOLORSPACE_Lab                 = 0x4C616220L,  //!<  'Lab ' 
            ICMCOLORSPACE_Luv                 = 0x4C757620L,  //!<  'Luv ' 
            ICMCOLORSPACE_YCbCr               = 0x59436272L,  //!<  'YCbr' 
            ICMCOLORSPACE_Yxy                 = 0x59787920L,  //!<  'Yxy ' 
            ICMCOLORSPACE_RGB                 = 0x52474220L,  //!<  'RGB ' 
            ICMCOLORSPACE_Gray                = 0x47524159L,  //!<  'GRAY' 
            ICMCOLORSPACE_HSV                 = 0x48535620L,  //!<  'HSV ' 
            ICMCOLORSPACE_HLS                 = 0x484C5320L,  //!<  'HLS ' 
            ICMCOLORSPACE_CMYK                = 0x434D594BL,  //!<  'CMYK' 
            ICMCOLORSPACE_CMY                 = 0x434D5920L,  //!<  'CMY ' 
            ICMCOLORSPACE_2Color              = 0x32434C52L,  //!<  '2CLR' 
            ICMCOLORSPACE_3Color              = 0x33434C52L,  //!<  '3CLR' 
            ICMCOLORSPACE_4Color              = 0x34434C52L,  //!<  '4CLR' 
            ICMCOLORSPACE_5Color              = 0x35434C52L,  //!<  '5CLR' 
            ICMCOLORSPACE_6Color              = 0x36434C52L,  //!<  '6CLR' 
            ICMCOLORSPACE_7Color              = 0x37434C52L,  //!<  '7CLR' 
            ICMCOLORSPACE_8Color              = 0x38434C52L   //!<  '8CLR' 
            };

         //! Profile class
         enum CLASS {
            CLASS_Unspecified               = 0,
            CLASS_Input                     = 0x73636E72L,  //!<  'scnr' 
            CLASS_Display                   = 0x6D6E7472L,  //!<  'mntr' 
            CLASS_Output                    = 0x70727472L,  //!<  'prtr' 
            CLASS_Link                      = 0x6C696E6BL,  //!<  'link' 
            CLASS_Abstract                  = 0x61627374L,  //!<  'abst' 
            CLASS_ColorSpace                = 0x73706163L,  //!<  'spac' 
            CLASS_NamedColor                = 0x6e6d636cL   //!<  'nmcl' 
            };

         //! Predefined primaries for custom RGB profiles.  
         //! Call EnumeratePrimaries() to retrieve a list of pre-defined primaries
         struct PRIMARIES {
            int id;              //!< A unique identifier for comboboxes
            const char* name;    //!< will be translated through tntxres.txt, though most are acronyms (NTCS, PAL, etc)
            COLORxyY red;
            COLORxyY green;
            COLORxyY blue;
         
            //! Get the ITEMDEF array for serializing this class
            static const SERIALIZER::ITEMDEF* GetSerialItemDef();
            };

         //! Standard Whitepoints
         //! Call EnumerateWhitePoints() to retrieve a list of pre-defined white points
         struct WHITEPOINT {
            int id;              //!< A unique identifier for comboboxes
            const char* name;    //!< will be translated through tntxres.txt, though most are like "6500\\xB0K (D65)"  ('\\xB0' is the degree symbol)
            COLORxyY color;
            };

         class LISTENTRY;

         //! Default constructor
         //! Empty profile until Open or something els/PRIM is called
         PROFILE (
            ) :
            m_priv(0)
            {
            }

         //! Construct a built-in profile
         //!   - PROFILE::PROFILE_sRGB
         //!   - PROFILE::PROFILE_XYZ
         //!   - PROFILE::PROFILE_LAB
         PROFILE (
            BUILTIN_PROFILE builtin
            ) :
            m_priv(0)
            {
               CreateBuiltInProfile(builtin);
            }
         
         //! Copy constructor
         //! Copy is "cheap" as the actual data is refcounted
         PROFILE (
            const PROFILE& rhs
            );

         //! Destructor 
         //! (note: not virtual.  No derived classes)
         ~PROFILE (
            );

         //! Assignment operator.
         //! Assignment is "cheap" as the actual data is refcounted
         PROFILE& operator= (
            const PROFILE& rhs
            );

         //! Comparison operator
         bool operator== (
            const PROFILE& rhs
            ) const;

         bool operator!= (
            const PROFILE& rhs
            ) const {
            return (!(*this == rhs));
            }

         //! Return a list of profiles for a given device class
         static ERRVALUE EnumerateProfiles (
            CLASS ProfileClass,
            MILIST<LISTENTRY>& List
            );

         //! Return a list of RGB primaries for custom RGB spaces.
         //! The order of entries in this list may change.  Do not depend on
         //! position within the list.  The COLORxyY values may change if
         //! more accurate values are found.  
         //! The names and numeric IDs will not change for a given entry and 
         //! may be safely written to a file to record which entry was selected.
         //! The numeric ID is also useful for populating ComboBoxes
         static ERRVALUE EnumeratePrimaries (
            MILIST<PRIMARIES>& List
            );

         //! Return the list of standard White points.
         //! The order of entries in this list may change.  Do not depend on
         //! position within the list.  The COLORxyY values may change if
         //! more accurate values are found.  
         //! The names and numeric IDs will not change for a given entry and 
         //! may be safely written to a file to record which entry was selected.
         //!
         //! For WhitePoints which are temperatures in degrees Kelvin, the
         //! numeric ID is actually the temperature. For the others, 
         //! (Illuminant A, etc), they're just arbitrary numbers.
         static ERRVALUE EnumerateWhitePoints (
            MILIST<WHITEPOINT>& List
            );

         //! Convert a tempature to a CIExyY color.
         //! Returns true if the whitepoint could be computed, or false if the
         //! tempeture is not valid.
         static bool WhitePointFromTemp (
            int tempK,              //!< Temperature in degrees Kelvin
            COLORxyY& WhitePoint //!< Color returned
            );

         //! Get the CIEXYZ values of R,G,and B
         bool GetColorants (
            COLORXYZ& red,
            COLORXYZ& green,
            COLORXYZ& blue
            ) const;

         //! Get the Iluminant
         bool GetIluminant (
            COLORXYZ& illuminant 
            ) const;

         //! Get the media Black Point
         bool GetMediaBlackPoint (
            COLORXYZ& blackpoint
            ) const;

         //! Get the media White Point
         bool GetMediaWhitePoint (
            COLORXYZ& whitepoint 
            ) const;

         //! Return the name of the profile
         void GetName (
            MISTRING&
            ) const;

         //! Return the description of the profile
         void GetDesc (
            MISTRING&
            ) const;

         //! Return the default rendering intent
         INTENT GetRenderingIntent (
            ) const;

         //! Get the PCS color space
         //! XXX (What is the PCS color space and how is it different from
         //! cmsGetColorSpace()?
         ICMCOLORSPACE GetPCS (
            ) const;

         ICMCOLORSPACE GetColorSpace (
            ) const;
         //! cmsGetColorSpace

         //! Return the device class (input, output, whatever)
         CLASS GetDeviceClass (
            ) const;

         //! returns true if the profile supports the given intent.
         bool SupportsIntent (
            INTENT intent,    
            USAGE use         
            ) const;

         void Free (
            );

         //! Return true if the profile contains the specified ICM tag
         bool HasTag (
            TAG sig
            ) const;

         bool IsEmpty (
            ) const {
            return (m_priv == 0);
            }

         //! Open an ICM profile file
         ERRVALUE Read (
            const FILEPATH& path
            );
         //! Actual implementation will call cmsOpenProfileFromFile(filaname, "r");
         ERRVALUE ReadFromMemory (
            const void* buf,  //!< XXX Actual cmsOpenProfileFromMem takes non-const but makes a copy
            int size
            );

         ERRVALUE Create (
            const PROFILEPARMS_RGB& parms
            );

         ERRVALUE Create (
            const PROFILEPARMS_PRINTER& parms
            );

         //! Create a profile which combines all the profiles in a transform
         //! into a single profile.  
         ERRVALUE CreateDeviceLinkProfile (
            TRANSFORM& transform,
            UINT32 flags   //!< XXX Define enum for whatever flags it wants
            );
         //! cmsTransfor2DeviceLink(transform, dwFlags)
         //!  flags: cmsFLAGS_HIGHRESPRECALC
         //!        cmsFLAGS_LOWRESPRECALD

         //! Create an ink-limiting device link profile.
         ERRVALUE CreateInkLimitingProfile (
            double limit,     //!< Ink limit (0 to 400%)
            COLORSPACE ColorSpace  //!< XXX default to CMYK
            );

         //! Create an sRGB or LAB profile, which can be hard-coded.
         ERRVALUE CreateBuiltInProfile (
            BUILTIN_PROFILE profile
            );

         //! Create an RGB profile from a whitepoint, 3 primaries
         //! and 3 gamma tables.  
         //! Some common primaries can be found using the function
         //! EnumeratePrimaries()
         ERRVALUE CreateRGBProfile (
            const COLORxyY& WhitePoint,
            const PRIMARIES& Primaries,
            const GAMMA& TransferFunctionRed,
            const GAMMA& TransferFunctionGreen,
            const GAMMA& TransferFunctionBlue
            );

         ERRVALUE CreateGrayProfile (
            const COLORxyY& WhitePoint,
            const GAMMA& TransferFunction 
            );

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         friend class TRANSFORM;

         class PRIVDATA;

         PRIVDATA* m_priv;
         cmsHPROFILE GetProfile() const;

         ERRVALUE CreateSimpleRGBProfile (
            int WhitePoint,
            double gamma,
            double rx,
            double ry,
            double gx,
            double gy,
            double bx,
            double by
            );
         #endif //!< GENERATING_DOXYGEN_OUTPUT
      };

   class PROFILEPARMS {
      public:
         enum MODE {
            MODE_None = 0,
            MODE_sRGB = 1,
            MODE_ICMFile = 2,
            MODE_UserDefined = 3
            };

         PROFILEPARMS();
         virtual ~PROFILEPARMS() {}

         //! Get the ITEMDEF array for serializing this class
         static const SERIALIZER::ITEMDEF* GetSerialItemDef();

         ERRVALUE IniRead(const char*inikey = 0, INIHANDLE handle = 0);
         ERRVALUE IniWrite(const char*inikey = 0, INIHANDLE handle = 0) const;
         void XMLRead (const MGUI::XMLFORM_DATA&);
         void XMLWrite (MGUI::XMLFORM_DATA&) const;

         MODE m_mode;
         PROFILE::INTENT m_intent;
         PROFILE::BUILTIN_PROFILE m_BuiltInProfile;
         FILEPATH m_filepath;
         int m_WhitePoint;    //!< Degrees Kelvin
         double m_wx, m_wy;   //!< Actual whitepoint color (xyY with Y=1.0) (if m_WhitePoint == -1)

      private:
         virtual const char* v_GetDefaultINIKey() const = 0;
         //! Derived class only needs to read and write its own members.
         //! The base class already took care of reading and writing its
         //! members.  
         virtual ERRVALUE v_IniRead(const char*inikey, INIHANDLE handle = 0) = 0;
         virtual ERRVALUE v_IniWrite(const char*inikey, INIHANDLE handle = 0)  const = 0;
         virtual void v_XMLRead(const MGUI::XMLFORM_DATA&) = 0;
         virtual void v_XMLWrite(MGUI::XMLFORM_DATA&) const = 0;

         virtual void v_NotifyObservers() const {}
      };

   class PROFILEPARMS_RGB : public PROFILEPARMS {
      public:
         PROFILEPARMS_RGB ();
         ~PROFILEPARMS_RGB() {};

         //! Get the ITEMDEF array for serializing this class
         static const SERIALIZER::ITEMDEF* GetSerialItemDef();

         double m_RedGamma, m_GreenGamma, m_BlueGamma;
         PROFILE::PRIMARIES m_primary;

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         virtual const char* v_GetDefaultINIKey() const { return "ICMScreen"; }
         virtual ERRVALUE v_IniRead(const char*inikey, INIHANDLE handle = 0);
         virtual ERRVALUE v_IniWrite(const char*inikey, INIHANDLE handle = 0) const;
         virtual void v_XMLRead(const MGUI::XMLFORM_DATA&);
         virtual void v_XMLWrite(MGUI::XMLFORM_DATA&) const;
         #endif // GENERATING_DOXYGEN_OUTPUT
      };

   //! Same as PROFILEPARMS_RGB, except when IniWrite is called on this one,
   //! it will call the callbacks of the things that want to know when it 
   //! changes.
   class PROFILEPARMS_SCREEN : public PROFILEPARMS_RGB {
      public:
         PROFILEPARMS_SCREEN ();
         ~PROFILEPARMS_SCREEN() {}
         static void AddChangeCallback (
            McbCallbackFunc func,
            void* cbdata
            );
         static void RemoveChangeCallback (
            McbCallbackFunc func,
            void* cbdata
            );
      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         virtual void v_NotifyObservers() const ;
         #endif // GENERATING_DOXYGEN_OUTPUT
      };
         
   class PROFILEPARMS_PRINTER : public PROFILEPARMS {
      public:
         PROFILEPARMS_PRINTER ();
         ~PROFILEPARMS_PRINTER() {};

         //! Get the ITEMDEF array for serializing this class
         static const SERIALIZER::ITEMDEF* GetSerialItemDef();

         bool m_bProofToScreen;
         bool m_bOutOfGamutAlarm;
         COLOR m_AlarmColor;
         bool m_bUseProfileForProofingOnly;
         double m_InkLimit;
         double m_BlackInkLimit;
      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         virtual const char* v_GetDefaultINIKey() const { return "PrinterICM"; }
         virtual ERRVALUE v_IniRead(const char*inikey, INIHANDLE handle = 0);
         virtual ERRVALUE v_IniWrite(const char*inikey, INIHANDLE handle = 0) const;
         virtual void v_XMLRead(const MGUI::XMLFORM_DATA&);
         virtual void v_XMLWrite(MGUI::XMLFORM_DATA&) const;
         #endif // GENERATING_DOXYGEN_OUTPUT

      };

   
   //! PROFILE::LISTENTRY used to retrieve a list of PROFILES available on the
   //! current system.  Use PROFILE::EnumerateProfiles() to get a list 
   class PROFILE::LISTENTRY {
      public:
         LISTENTRY () { }

         //! Copy constructor
         LISTENTRY (
            const LISTENTRY& rhs
            ) :
            m_filepath(rhs.m_filepath),
            m_desc(rhs.m_desc),
            m_bIsBuiltIn(rhs.m_bIsBuiltIn),
            m_BuiltInID(rhs.m_BuiltInID)
            {}


         ~LISTENTRY () {}
         
         //! Assignment operator.
         LISTENTRY& operator= (
            const LISTENTRY& rhs
            ) {
            if (&rhs != this) {
               m_filepath = rhs.m_filepath;
               m_desc = rhs.m_desc;
               m_bIsBuiltIn = rhs.m_bIsBuiltIn;
               m_BuiltInID = rhs.m_BuiltInID;
               }
            return (*this);
            }

         const MISTRING& GetDescription (
            ) const {
            return (m_desc);
            }

         const FILEPATH& GetFilePath (
            ) const {
            return (m_filepath);
            }

         bool IsBuiltIn (
            ) const {
            return (m_bIsBuiltIn);
            }

         BUILTIN_PROFILE GetBuiltInID (
            ) const {
            return (m_BuiltInID);
            }

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         FILEPATH m_filepath;
         MISTRING m_desc;
         bool m_bIsBuiltIn;
         BUILTIN_PROFILE m_BuiltInID;

         //! Private constructor
         LISTENTRY (
            const FILEPATH& fp, 
            const MISTRING& desc
            ) :
            m_desc(desc),
            m_filepath(fp),
            m_bIsBuiltIn(false),
            m_BuiltInID(PROFILE::PROFILE_NONE)
            {
            }

         LISTENTRY (
            PROFILE::BUILTIN_PROFILE id,
            const MISTRING& desc
            ) :
            m_desc(desc),
            m_bIsBuiltIn(true),
            m_BuiltInID(id)
            {
            }

         friend class PROFILE;   // PROFILE can use private constructor
         #endif // GENERATING_DOXYGEN_OUTPUT
      };


   //! In-memory representataion of an ICM profile
   class TRANSFORM {
      public:

         //! Default constructor
         //! Empty transform until Open or something else is called
         TRANSFORM (
            ) :
            m_priv(0)
            {
            }

         //! Shortcut construct simple transform
         TRANSFORM (
            const PROFILE& InputProfile,
            COLORSPACE InputColorSpace,
            const PROFILE& OutputProfile,
            COLORSPACE OutputColorSpace,  
            PROFILE::INTENT RenderingIntent = PROFILE::INTENT_Perceptual, 
            UINT32 flags = 0  // XXX Define an enum
            );

         //! cmsCreateProofingTransform (
         //!   input, inputformat,
         //!   output, outputformat
         //!   proofprofile,
         //!   intent,
         //!   proofingintent = INTENT_ABSOLUTE_COLORIMETRIC
         //!   dwFlags = cmsFLAGS_SOFTPROOFING
         //!      cmsFLAGS_GAMUTCHECK
         //!      cmsFLAGS_SOFTPROOFING


         //! cmsCreateMultiprofileTransform (
         //!   profile_array,
         //!   num_profiles,
         //!   inputformat, outputformat, intent, flags
         //!   )

         //! Copy constructor
         //! Copy is "cheap" as the actual data is refcounted
         TRANSFORM (
            const TRANSFORM& rhs
            );

         //! Destructor 
         //! (note: not virtual.  No derived classes)
         ~TRANSFORM (
            );

         //! Assignment operator.
         //! Assignment is "cheap" as the actual data is refcounted
         TRANSFORM& operator= (
            const TRANSFORM& rhs
            );

         //! Set the color to use if OutOfGamutAlarm is enabled.
         //! Due to the way it's implemented in the lcms library, this is a
         //! global setting, not per-transform.
         static void SetOutOfGamutAlarmColor (
            const COLOR& color
            );

         ERRVALUE Create (
            const PROFILE& InputProfile,
            COLORSPACE InputColorSpace,
            const PROFILE& OutputProfile,
            COLORSPACE OutputColorSpace,  
            PROFILE::INTENT RenderingIntent = PROFILE::INTENT_Perceptual, 
            UINT32 flags = 0  // XXX Define an enum
            );

         ERRVALUE Create (
            const PROFILE& InputProfile,
            COLORSPACE InputColorSpace,
            const PROFILEPARMS_PRINTER& ProofParms,
            const PROFILE& OutputProfile,
            COLORSPACE OutputColorSpace,  
            PROFILE::INTENT RenderingIntent = PROFILE::INTENT_Perceptual, 
            UINT32 flags = 0  // XXX Define an enum
            );

         COLORSPACE GetOutputColorSpace (
            ) const {
            return (m_DestColorSpace);
            }

         //! Returns a const reference to the input profile used to create
         //! this transform. 
         const PROFILE& GetInputProfile (
            ) const;

         //! Returns a const reference to the output profile used to create
         //! this transform
         const PROFILE& GetOutputProfile (
            ) const;

         //! Returns true if the transform does nothing.
         //! NOTE:  An empty transform will _really_ do nothing.  DoTransform
         //! won't even copy the source to the destination because it doesn't
         //! know how many bytes per pixel there are
         bool IsEmpty (
            ) const {
            return (m_priv == 0);
            }

         //! Transform an input buffer to an output buffer.
         //! The buffers are expected to match InputFormat and OutputFormat
         //! passed to CreateTransform() or CreateProofingTransform()
         //! It is safe for src to == dest as long as they're both the same
         //! number of bytes per pixel.
         void DoTransform (
            const void* src,
            void* dest,
            int size       //!< Size in pixels
            ) const;

         void DoTransform (
            const COLOR& src,
            COLOR& dest
            ) const;

         void Free();

      private:
         #ifndef GENERATING_DOXYGEN_OUTPUT
         class PRIVDATA;

         PRIVDATA* m_priv;
         COLORSPACE m_SrcColorSpace;
         COLORSPACE m_DestColorSpace;

         cmsHTRANSFORM GetTrans() const;
         #endif // GENERATING_DOXYGEN_OUTPUT

      }; //! End of TRANSFORM
   }     //! End of MGD namespace

#endif // INC_MI32_MG2CMS_H

---