开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
CMApplication.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：72k
源码类别：

多媒体编程

开发平台：

Visual C++

CMApplication.h：源码内容
  1. /*
  2.      File:       CMApplication.h
  3.  
  4.      Contains:   Color Matching Interfaces
  5.  
  6.      Version:    Technology: ColorSync 3.0
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 1992-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __CMAPPLICATION__
  18. #define __CMAPPLICATION__
  20. #ifndef __MACTYPES__
  21. #include "MacTypes.h"
  22. #endif
  24. #ifndef __QUICKDRAW__
  25. #include "Quickdraw.h"
  26. #endif
  28. #ifndef __FILES__
  29. #include "Files.h"
  30. #endif
  32. #ifndef __CMICCPROFILE__
  33. #include "CMICCProfile.h"
  34. #endif
  36. #ifndef __DISPLAYS__
  37. #include "Displays.h"
  38. #endif
  40. #ifndef __MACERRORS__
  41. #include "MacErrors.h"
  42. #endif
  44. #if TARGET_API_MAC_OS8
  45. #ifndef __PRINTING__
  46. #include "Printing.h"
  47. #endif
  49. #endif  /* TARGET_API_MAC_OS8 */
  52. #if TARGET_OS_WIN32
  53. #include "windows.h"
  54. #endif
  58. #if PRAGMA_ONCE
  59. #pragma once
  60. #endif
  62. #ifdef __cplusplus
  63. extern "C" {
  64. #endif
  66. #if PRAGMA_IMPORT
  67. #pragma import on
  68. #endif
  70. #if PRAGMA_STRUCT_ALIGN
  71.     #pragma options align=mac68k
  72. #elif PRAGMA_STRUCT_PACKPUSH
  73.     #pragma pack(push, 2)
  74. #elif PRAGMA_STRUCT_PACK
  75.     #pragma pack(2)
  76. #endif
  78. enum {
  79.     kDefaultCMMSignature        = FOUR_CHAR_CODE('appl')
  80. };
  82. /* Macintosh 68K trap word */
  83. enum {
  84.     cmTrap                      = 0xABEE
  85. };
  88. /* PicComment IDs */
  89. enum {
  90.     cmBeginProfile              = 220,
  91.     cmEndProfile                = 221,
  92.     cmEnableMatching            = 222,
  93.     cmDisableMatching           = 223,
  94.     cmComment                   = 224
  95. };
  97. /* PicComment selectors for cmComment */
  98. enum {
  99.     cmBeginProfileSel           = 0,
  100.     cmContinueProfileSel        = 1,
  101.     cmEndProfileSel             = 2,
  102.     cmProfileIdentifierSel      = 3
  103. };
  106. /* Defines for version 1.0 CMProfileSearchRecord.fieldMask */
  107. enum {
  108.     cmMatchCMMType              = 0x00000001,
  109.     cmMatchApplProfileVersion   = 0x00000002,
  110.     cmMatchDataType             = 0x00000004,
  111.     cmMatchDeviceType           = 0x00000008,
  112.     cmMatchDeviceManufacturer   = 0x00000010,
  113.     cmMatchDeviceModel          = 0x00000020,
  114.     cmMatchDeviceAttributes     = 0x00000040,
  115.     cmMatchFlags                = 0x00000080,
  116.     cmMatchOptions              = 0x00000100,
  117.     cmMatchWhite                = 0x00000200,
  118.     cmMatchBlack                = 0x00000400
  119. };
  121. /* Defines for version 2.0 CMSearchRecord.searchMask */
  122. enum {
  123.     cmMatchAnyProfile           = 0x00000000,
  124.     cmMatchProfileCMMType       = 0x00000001,
  125.     cmMatchProfileClass         = 0x00000002,
  126.     cmMatchDataColorSpace       = 0x00000004,
  127.     cmMatchProfileConnectionSpace = 0x00000008,
  128.     cmMatchManufacturer         = 0x00000010,
  129.     cmMatchModel                = 0x00000020,
  130.     cmMatchAttributes           = 0x00000040,
  131.     cmMatchProfileFlags         = 0x00000080
  132. };
  135. /* deviceType values for ColorSync 1.0 Device Profile access */
  136. enum {
  137.     cmSystemDevice              = FOUR_CHAR_CODE('sys '),
  138.     cmGDevice                   = FOUR_CHAR_CODE('gdev')
  139. };
  141. /* Commands for CMFlattenUPP(...) */
  142. enum {
  143.     cmOpenReadSpool             = 1,
  144.     cmOpenWriteSpool            = 2,
  145.     cmReadSpool                 = 3,
  146.     cmWriteSpool                = 4,
  147.     cmCloseSpool                = 5
  148. };
  150. /* Flags for PostScript-related functions */
  151. enum {
  152.     cmPS7bit                    = 1,
  153.     cmPS8bit                    = 2
  154. };
  156. /* Flags for profile embedding functions */
  157. enum {
  158.     cmEmbedWholeProfile         = 0x00000000,
  159.     cmEmbedProfileIdentifier    = 0x00000001
  160. };
  162. /* Commands for CMAccessUPP(...) */
  163. enum {
  164.     cmOpenReadAccess            = 1,
  165.     cmOpenWriteAccess           = 2,
  166.     cmReadAccess                = 3,
  167.     cmWriteAccess               = 4,
  168.     cmCloseAccess               = 5,
  169.     cmCreateNewAccess           = 6,
  170.     cmAbortWriteAccess          = 7,
  171.     cmBeginAccess               = 8,
  172.     cmEndAccess                 = 9
  173. };
  176. /* Abstract data type for memory-based Profile */
  177. typedef struct OpaqueCMProfileRef*      CMProfileRef;
  178. /* Abstract data type for Profile search result */
  179. typedef struct OpaqueCMProfileSearchRef*  CMProfileSearchRef;
  180. /* Abstract data type for BeginMatching(...) reference */
  181. typedef struct OpaqueCMMatchRef*        CMMatchRef;
  182. /* Abstract data type for ColorWorld reference */
  183. typedef struct OpaqueCMWorldRef*        CMWorldRef;
  184. /* Caller-supplied flatten function */
  185. typedef CALLBACK_API( OSErr , CMFlattenProcPtr )(long command, long *size, void *data, void *refCon);
  186. /* Caller-supplied progress function for Bitmap & PixMap matching routines */
  187. typedef CALLBACK_API( Boolean , CMBitmapCallBackProcPtr )(long progress, void *refCon);
  188. /* Caller-supplied progress function for NCMMConcatInit & NCMMNewLinkProfile routines */
  189. typedef CALLBACK_API( Boolean , CMConcatCallBackProcPtr )(long progress, void *refCon);
  190. /* Caller-supplied filter function for Profile search */
  191. typedef CALLBACK_API( Boolean , CMProfileFilterProcPtr )(CMProfileRef prof, void *refCon);
  192. /* Caller-supplied function for profile access */
  193. typedef CALLBACK_API( OSErr , CMProfileAccessProcPtr )(long command, long offset, long *size, void *data, void *refCon);
  194. typedef STACK_UPP_TYPE(CMFlattenProcPtr)                        CMFlattenUPP;
  195. typedef STACK_UPP_TYPE(CMBitmapCallBackProcPtr)                 CMBitmapCallBackUPP;
  196. typedef STACK_UPP_TYPE(CMConcatCallBackProcPtr)                 CMConcatCallBackUPP;
  197. typedef STACK_UPP_TYPE(CMProfileFilterProcPtr)                  CMProfileFilterUPP;
  198. typedef STACK_UPP_TYPE(CMProfileAccessProcPtr)                  CMProfileAccessUPP;
  199. #if OPAQUE_UPP_TYPES
  200.     EXTERN_API(CMFlattenUPP)
  201.     NewCMFlattenUPP                (CMFlattenProcPtr        userRoutine);
  203.     EXTERN_API(CMBitmapCallBackUPP)
  204.     NewCMBitmapCallBackUPP         (CMBitmapCallBackProcPtr userRoutine);
  206.     EXTERN_API(CMConcatCallBackUPP)
  207.     NewCMConcatCallBackUPP         (CMConcatCallBackProcPtr userRoutine);
  209.     EXTERN_API(CMProfileFilterUPP)
  210.     NewCMProfileFilterUPP          (CMProfileFilterProcPtr  userRoutine);
  212.     EXTERN_API(CMProfileAccessUPP)
  213.     NewCMProfileAccessUPP          (CMProfileAccessProcPtr  userRoutine);
  215.     EXTERN_API(void)
  216.     DisposeCMFlattenUPP            (CMFlattenUPP            userUPP);
  218.     EXTERN_API(void)
  219.     DisposeCMBitmapCallBackUPP     (CMBitmapCallBackUPP     userUPP);
  221.     EXTERN_API(void)
  222.     DisposeCMConcatCallBackUPP     (CMConcatCallBackUPP     userUPP);
  224.     EXTERN_API(void)
  225.     DisposeCMProfileFilterUPP      (CMProfileFilterUPP      userUPP);
  227.     EXTERN_API(void)
  228.     DisposeCMProfileAccessUPP      (CMProfileAccessUPP      userUPP);
  230.     EXTERN_API(OSErr)
  231.     InvokeCMFlattenUPP             (long                    command,
  232.                                     long *                  size,
  233.                                     void *                  data,
  234.                                     void *                  refCon,
  235.                                     CMFlattenUPP            userUPP);
  237.     EXTERN_API(Boolean)
  238.     InvokeCMBitmapCallBackUPP      (long                    progress,
  239.                                     void *                  refCon,
  240.                                     CMBitmapCallBackUPP     userUPP);
  242.     EXTERN_API(Boolean)
  243.     InvokeCMConcatCallBackUPP      (long                    progress,
  244.                                     void *                  refCon,
  245.                                     CMConcatCallBackUPP     userUPP);
  247.     EXTERN_API(Boolean)
  248.     InvokeCMProfileFilterUPP       (CMProfileRef            prof,
  249.                                     void *                  refCon,
  250.                                     CMProfileFilterUPP      userUPP);
  252.     EXTERN_API(OSErr)
  253.     InvokeCMProfileAccessUPP       (long                    command,
  254.                                     long                    offset,
  255.                                     long *                  size,
  256.                                     void *                  data,
  257.                                     void *                  refCon,
  258.                                     CMProfileAccessUPP      userUPP);
  260. #else
  261.     enum { uppCMFlattenProcInfo = 0x00003FE0 };                     /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
  262.     enum { uppCMBitmapCallBackProcInfo = 0x000003D0 };              /* pascal 1_byte Func(4_bytes, 4_bytes) */
  263.     enum { uppCMConcatCallBackProcInfo = 0x000003D0 };              /* pascal 1_byte Func(4_bytes, 4_bytes) */
  264.     enum { uppCMProfileFilterProcInfo = 0x000003D0 };               /* pascal 1_byte Func(4_bytes, 4_bytes) */
  265.     enum { uppCMProfileAccessProcInfo = 0x0000FFE0 };               /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
  266.     #define NewCMFlattenUPP(userRoutine)                            (CMFlattenUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMFlattenProcInfo, GetCurrentArchitecture())
  267.     #define NewCMBitmapCallBackUPP(userRoutine)                     (CMBitmapCallBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMBitmapCallBackProcInfo, GetCurrentArchitecture())
  268.     #define NewCMConcatCallBackUPP(userRoutine)                     (CMConcatCallBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMConcatCallBackProcInfo, GetCurrentArchitecture())
  269.     #define NewCMProfileFilterUPP(userRoutine)                      (CMProfileFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMProfileFilterProcInfo, GetCurrentArchitecture())
  270.     #define NewCMProfileAccessUPP(userRoutine)                      (CMProfileAccessUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMProfileAccessProcInfo, GetCurrentArchitecture())
  271.     #define DisposeCMFlattenUPP(userUPP)                            DisposeRoutineDescriptor(userUPP)
  272.     #define DisposeCMBitmapCallBackUPP(userUPP)                     DisposeRoutineDescriptor(userUPP)
  273.     #define DisposeCMConcatCallBackUPP(userUPP)                     DisposeRoutineDescriptor(userUPP)
  274.     #define DisposeCMProfileFilterUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
  275.     #define DisposeCMProfileAccessUPP(userUPP)                      DisposeRoutineDescriptor(userUPP)
  276.     #define InvokeCMFlattenUPP(command, size, data, refCon, userUPP)  (OSErr)CALL_FOUR_PARAMETER_UPP((userUPP), uppCMFlattenProcInfo, (command), (size), (data), (refCon))
  277.     #define InvokeCMBitmapCallBackUPP(progress, refCon, userUPP)    (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppCMBitmapCallBackProcInfo, (progress), (refCon))
  278.     #define InvokeCMConcatCallBackUPP(progress, refCon, userUPP)    (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppCMConcatCallBackProcInfo, (progress), (refCon))
  279.     #define InvokeCMProfileFilterUPP(prof, refCon, userUPP)         (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppCMProfileFilterProcInfo, (prof), (refCon))
  280.     #define InvokeCMProfileAccessUPP(command, offset, size, data, refCon, userUPP)  (OSErr)CALL_FIVE_PARAMETER_UPP((userUPP), uppCMProfileAccessProcInfo, (command), (offset), (size), (data), (refCon))
  281. #endif
  282. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  283. #define NewCMFlattenProc(userRoutine)                           NewCMFlattenUPP(userRoutine)
  284. #define NewCMBitmapCallBackProc(userRoutine)                    NewCMBitmapCallBackUPP(userRoutine)
  285. #define NewCMConcatCallBackProc(userRoutine)                    NewCMConcatCallBackUPP(userRoutine)
  286. #define NewCMProfileFilterProc(userRoutine)                     NewCMProfileFilterUPP(userRoutine)
  287. #define NewCMProfileAccessProc(userRoutine)                     NewCMProfileAccessUPP(userRoutine)
  288. #define CallCMFlattenProc(userRoutine, command, size, data, refCon) InvokeCMFlattenUPP(command, size, data, refCon, userRoutine)
  289. #define CallCMBitmapCallBackProc(userRoutine, progress, refCon) InvokeCMBitmapCallBackUPP(progress, refCon, userRoutine)
  290. #define CallCMConcatCallBackProc(userRoutine, progress, refCon) InvokeCMConcatCallBackUPP(progress, refCon, userRoutine)
  291. #define CallCMProfileFilterProc(userRoutine, prof, refCon)      InvokeCMProfileFilterUPP(prof, refCon, userRoutine)
  292. #define CallCMProfileAccessProc(userRoutine, command, offset, size, data, refCon) InvokeCMProfileAccessUPP(command, offset, size, data, refCon, userRoutine)
  293. typedef long                            CMError;
  294. /* For 1.0 and 2.0 profile header variants */
  295. /* CMAppleProfileHeader */
  297. union CMAppleProfileHeader {
  298.     CMHeader                        cm1;
  299.     CM2Header                       cm2;
  300. };
  301. typedef union CMAppleProfileHeader      CMAppleProfileHeader;
  302. /* Param for CWConcatColorWorld(...) */
  304. struct CMConcatProfileSet {
  305.     UInt16                          keyIndex;                   /* Zero-based */
  306.     UInt16                          count;                      /* Min 1 */
  307.     CMProfileRef                    profileSet[1];              /* Variable. Ordered from Source -> Dest */
  308. };
  309. typedef struct CMConcatProfileSet       CMConcatProfileSet;
  311. /* NCMConcatProfileSpec Tags */
  312. enum {
  313.     kNoTransform                = 0,                            /* Not used */
  314.     kUseAtoB                    = 1,                            /* Use 'A2B*' tag from this profile or equivalent */
  315.     kUseBtoA                    = 2,                            /* Use 'B2A*' tag from this profile or equivalent */
  316.     kUseBtoB                    = 3,                            /* Use 'pre*' tag from this profile or equivalent */
  317.                                                                 /* For typical device profiles the following synonyms may be useful */
  318.     kDeviceToPCS                = kUseAtoB,                     /* Device Dependent to Device Independent */
  319.     kPCSToDevice                = kUseBtoA,                     /* Device Independent to Device Dependent */
  320.     kPCSToPCS                   = kUseBtoB,                     /* Independent, through device's gamut */
  321.     kUseProfileIntent           = (long)0xFFFFFFFF              /* For renderingIntent in NCMConcatProfileSpec    */
  322. };
  324. /* NCMConcatProfileSpec */
  326. struct NCMConcatProfileSpec {
  327.     UInt32                          renderingIntent;            /* renderingIntent override     */
  328.     UInt32                          transformTag;               /* transformTag, defined above    */
  329.     CMProfileRef                    profile;                    /* profile */
  330. };
  331. typedef struct NCMConcatProfileSpec     NCMConcatProfileSpec;
  332. /* NCMConcatProfileSet */
  334. struct NCMConcatProfileSet {
  335.     OSType                          cmm;                        /* e.g. 'KCMS', 'appl', ...  uniquely ids the cmm, or 0000 */
  336.     UInt32                          flags;                      /* specify quality, lookup only, no gamut checking ... */
  337.     UInt32                          flagsMask;                  /* which bits of 'flags' to use to override profile */
  338.     UInt32                          profileCount;               /* how many ProfileSpecs in the following set */
  339.     NCMConcatProfileSpec            profileSpecs[1];            /* Variable. Ordered from Source -> Dest */
  340. };
  341. typedef struct NCMConcatProfileSet      NCMConcatProfileSet;
  342. /* ColorSync color data types */
  344. struct CMRGBColor {
  345.     UInt16                          red;                        /* 0..65535 */
  346.     UInt16                          green;
  347.     UInt16                          blue;
  348. };
  349. typedef struct CMRGBColor               CMRGBColor;
  351. struct CMCMYKColor {
  352.     UInt16                          cyan;                       /* 0..65535 */
  353.     UInt16                          magenta;
  354.     UInt16                          yellow;
  355.     UInt16                          black;
  356. };
  357. typedef struct CMCMYKColor              CMCMYKColor;
  359. struct CMCMYColor {
  360.     UInt16                          cyan;                       /* 0..65535 */
  361.     UInt16                          magenta;
  362.     UInt16                          yellow;
  363. };
  364. typedef struct CMCMYColor               CMCMYColor;
  366. struct CMHLSColor {
  367.     UInt16                          hue;                        /* 0..65535. Fraction of circle. Red at 0 */
  368.     UInt16                          lightness;                  /* 0..65535 */
  369.     UInt16                          saturation;                 /* 0..65535 */
  370. };
  371. typedef struct CMHLSColor               CMHLSColor;
  373. struct CMHSVColor {
  374.     UInt16                          hue;                        /* 0..65535. Fraction of circle. Red at 0 */
  375.     UInt16                          saturation;                 /* 0..65535 */
  376.     UInt16                          value;                      /* 0..65535 */
  377. };
  378. typedef struct CMHSVColor               CMHSVColor;
  380. struct CMLabColor {
  381.     UInt16                          L;                          /* 0..65535 maps to 0..100 */
  382.     UInt16                          a;                          /* 0..65535 maps to -128..127.996 */
  383.     UInt16                          b;                          /* 0..65535 maps to -128..127.996 */
  384. };
  385. typedef struct CMLabColor               CMLabColor;
  387. struct CMLuvColor {
  388.     UInt16                          L;                          /* 0..65535 maps to 0..100 */
  389.     UInt16                          u;                          /* 0..65535 maps to -128..127.996 */
  390.     UInt16                          v;                          /* 0..65535 maps to -128..127.996 */
  391. };
  392. typedef struct CMLuvColor               CMLuvColor;
  394. struct CMYxyColor {
  395.     UInt16                          capY;                       /* 0..65535 maps to 0..1 */
  396.     UInt16                          x;                          /* 0..65535 maps to 0..1 */
  397.     UInt16                          y;                          /* 0..65535 maps to 0..1 */
  398. };
  399. typedef struct CMYxyColor               CMYxyColor;
  401. struct CMGrayColor {
  402.     UInt16                          gray;                       /* 0..65535 */
  403. };
  404. typedef struct CMGrayColor              CMGrayColor;
  406. struct CMMultichannel5Color {
  407.     UInt8                           components[5];              /* 0..255 */
  408. };
  409. typedef struct CMMultichannel5Color     CMMultichannel5Color;
  411. struct CMMultichannel6Color {
  412.     UInt8                           components[6];              /* 0..255 */
  413. };
  414. typedef struct CMMultichannel6Color     CMMultichannel6Color;
  416. struct CMMultichannel7Color {
  417.     UInt8                           components[7];              /* 0..255 */
  418. };
  419. typedef struct CMMultichannel7Color     CMMultichannel7Color;
  421. struct CMMultichannel8Color {
  422.     UInt8                           components[8];              /* 0..255 */
  423. };
  424. typedef struct CMMultichannel8Color     CMMultichannel8Color;
  426. struct CMNamedColor {
  427.     UInt32                          namedColorIndex;            /* 0..a lot */
  428. };
  429. typedef struct CMNamedColor             CMNamedColor;
  431. union CMColor {
  432.     CMRGBColor                      rgb;
  433.     CMHSVColor                      hsv;
  434.     CMHLSColor                      hls;
  435.     CMXYZColor                      XYZ;
  436.     CMLabColor                      Lab;
  437.     CMLuvColor                      Luv;
  438.     CMYxyColor                      Yxy;
  439.     CMCMYKColor                     cmyk;
  440.     CMCMYColor                      cmy;
  441.     CMGrayColor                     gray;
  442.     CMMultichannel5Color            mc5;
  443.     CMMultichannel6Color            mc6;
  444.     CMMultichannel7Color            mc7;
  445.     CMMultichannel8Color            mc8;
  446.     CMNamedColor                    namedColor;
  447. };
  448. typedef union CMColor                   CMColor;
  450. struct CMProfileSearchRecord {
  451.     CMHeader                        header;
  452.     UInt32                          fieldMask;
  453.     UInt32                          reserved[2];
  454. };
  455. typedef struct CMProfileSearchRecord    CMProfileSearchRecord;
  456. typedef CMProfileSearchRecord *         CMProfileSearchRecordPtr;
  457. typedef CMProfileSearchRecordPtr *      CMProfileSearchRecordHandle;
  458. /* Search definition for 2.0 */
  460. struct CMSearchRecord {
  461.     OSType                          CMMType;
  462.     OSType                          profileClass;
  463.     OSType                          dataColorSpace;
  464.     OSType                          profileConnectionSpace;
  465.     UInt32                          deviceManufacturer;
  466.     UInt32                          deviceModel;
  467.     UInt32                          deviceAttributes[2];
  468.     UInt32                          profileFlags;
  469.     UInt32                          searchMask;
  470.     CMProfileFilterUPP              filter;
  471. };
  472. typedef struct CMSearchRecord           CMSearchRecord;
  473. /* CMMInfo structure */
  475. struct CMMInfo {
  476.     UInt32                          dataSize;                   /* Size of this structure - compatibility*/
  477.     OSType                          CMMType;                    /* Signature, e.g. 'KCMS'*/
  478.     OSType                          CMMMfr;                     /* Vendor, e.g. 'appl'*/
  479.     UInt32                          CMMVersion;                 /* cmm version number*/
  480.     unsigned char                   ASCIIName[32];              /* pascal string - name*/
  481.     unsigned char                   ASCIIDesc[256];             /* pascal string - description or copyright*/
  482.     UniCharCount                    UniCodeNameCount;           /* count of UniChars in following array*/
  483.     UniChar                         UniCodeName[32];            /* the name in UniCode chars*/
  484.     UniCharCount                    UniCodeDescCount;           /* count of UniChars in following array*/
  485.     UniChar                         UniCodeDesc[256];           /* the description in UniCode chars*/
  486. };
  487. typedef struct CMMInfo                  CMMInfo;
  488. /* GetCWInfo structures */
  490. struct CMMInfoRecord {
  491.     OSType                          CMMType;
  492.     long                            CMMVersion;
  493. };
  494. typedef struct CMMInfoRecord            CMMInfoRecord;
  496. struct CMCWInfoRecord {
  497.     UInt32                          cmmCount;
  498.     CMMInfoRecord                   cmmInfo[2];
  499. };
  500. typedef struct CMCWInfoRecord           CMCWInfoRecord;
  501. /* profile identifier structures */
  503. struct CMProfileIdentifier {
  504.     CM2Header                       profileHeader;
  505.     CMDateTime                      calibrationDate;
  506.     UInt32                          ASCIIProfileDescriptionLen;
  507.     char                            ASCIIProfileDescription[1]; /* variable length */
  508. };
  509. typedef struct CMProfileIdentifier      CMProfileIdentifier;
  510. typedef CMProfileIdentifier *           CMProfileIdentifierPtr;
  511. /* packing formats */
  512. enum {
  513.     cmNoColorPacking            = 0x0000,
  514.     cmWord5ColorPacking         = 0x0500,
  515.     cmWord565ColorPacking       = 0x0600,
  516.     cmLong8ColorPacking         = 0x0800,
  517.     cmLong10ColorPacking        = 0x0A00,
  518.     cmAlphaFirstPacking         = 0x1000,
  519.     cmOneBitDirectPacking       = 0x0B00,
  520.     cmAlphaLastPacking          = 0x0000,
  521.     cm8_8ColorPacking           = 0x2800,
  522.     cm16_8ColorPacking          = 0x2000,
  523.     cm24_8ColorPacking          = 0x2100,
  524.     cm32_8ColorPacking          = cmLong8ColorPacking,
  525.     cm40_8ColorPacking          = 0x2200,
  526.     cm48_8ColorPacking          = 0x2300,
  527.     cm56_8ColorPacking          = 0x2400,
  528.     cm64_8ColorPacking          = 0x2500,
  529.     cm32_16ColorPacking         = 0x2600,
  530.     cm48_16ColorPacking         = 0x2900,
  531.     cm64_16ColorPacking         = 0x2A00,
  532.     cm32_32ColorPacking         = 0x2700,
  533.     cmLittleEndianPacking       = 0x4000,
  534.     cmReverseChannelPacking     = 0x8000
  535. };
  537. /* colorspace masks */
  538. enum {
  539.     cmColorSpaceSpaceMask       = 0x0000007F,
  540.     cmColorSpaceAlphaMask       = 0x00000080,
  541.     cmColorSpaceSpaceAndAlphaMask = 0x000000FF,
  542.     cmColorSpacePackingMask     = 0x0000FF00,
  543.     cmColorSpaceReservedMask    = (long)0xFFFF0000
  544. };
  546. /* general colorspaces */
  547. enum {
  548.     cmNoSpace                   = 0,
  549.     cmRGBSpace                  = 1,
  550.     cmCMYKSpace                 = 2,
  551.     cmHSVSpace                  = 3,
  552.     cmHLSSpace                  = 4,
  553.     cmYXYSpace                  = 5,
  554.     cmXYZSpace                  = 6,
  555.     cmLUVSpace                  = 7,
  556.     cmLABSpace                  = 8,
  557.     cmReservedSpace1            = 9,
  558.     cmGraySpace                 = 10,
  559.     cmReservedSpace2            = 11,
  560.     cmGamutResultSpace          = 12,
  561.     cmNamedIndexedSpace         = 16,
  562.     cmMCFiveSpace               = 17,
  563.     cmMCSixSpace                = 18,
  564.     cmMCSevenSpace              = 19,
  565.     cmMCEightSpace              = 20,
  566.     cmAlphaSpace                = 0x80,
  567.     cmRGBASpace                 = cmRGBSpace + cmAlphaSpace,
  568.     cmGrayASpace                = cmGraySpace + cmAlphaSpace
  569. };
  571. /* supported CMBitmapColorSpaces - Each of the following is a */
  572. /* combination of a general colospace and a packing formats. */
  573. /* Each can also be or'd with cmReverseChannelPacking. */
  574. enum {
  575.     cmGray8Space                = cmGraySpace + cm8_8ColorPacking,
  576.     cmGrayA16Space              = cmGrayASpace + cm16_8ColorPacking,
  577.     cmGray16Space               = cmGraySpace,
  578.     cmGrayA32Space              = cmGrayASpace,
  579.     cmGray16LSpace              = cmGraySpace + cmLittleEndianPacking,
  580.     cmGrayA32LSpace             = cmGrayASpace + cmLittleEndianPacking,
  581.     cmRGB16Space                = cmRGBSpace + cmWord5ColorPacking,
  582.     cmRGB16LSpace               = cmRGBSpace + cmWord5ColorPacking + cmLittleEndianPacking,
  583.     cmRGB565Space               = cmRGBSpace + cmWord565ColorPacking,
  584.     cmRGB565LSpace              = cmRGBSpace + cmWord565ColorPacking + cmLittleEndianPacking,
  585.     cmRGB24Space                = cmRGBSpace + cm24_8ColorPacking,
  586.     cmRGB32Space                = cmRGBSpace + cm32_8ColorPacking,
  587.     cmRGB48Space                = cmRGBSpace + cm48_16ColorPacking,
  588.     cmRGB48LSpace               = cmRGBSpace + cm48_16ColorPacking + cmLittleEndianPacking,
  589.     cmARGB32Space               = cmRGBASpace + cm32_8ColorPacking + cmAlphaFirstPacking,
  590.     cmARGB64Space               = cmRGBASpace + cm64_16ColorPacking + cmAlphaFirstPacking,
  591.     cmARGB64LSpace              = cmRGBASpace + cm64_16ColorPacking + cmAlphaFirstPacking + cmLittleEndianPacking,
  592.     cmRGBA32Space               = cmRGBASpace + cm32_8ColorPacking + cmAlphaLastPacking,
  593.     cmRGBA64Space               = cmRGBASpace + cm64_16ColorPacking + cmAlphaLastPacking,
  594.     cmRGBA64LSpace              = cmRGBASpace + cm64_16ColorPacking + cmAlphaLastPacking + cmLittleEndianPacking,
  595.     cmCMYK32Space               = cmCMYKSpace + cm32_8ColorPacking,
  596.     cmCMYK64Space               = cmCMYKSpace + cm64_16ColorPacking,
  597.     cmCMYK64LSpace              = cmCMYKSpace + cm64_16ColorPacking + cmLittleEndianPacking,
  598.     cmHSV32Space                = cmHSVSpace + cmLong10ColorPacking,
  599.     cmHLS32Space                = cmHLSSpace + cmLong10ColorPacking,
  600.     cmYXY32Space                = cmYXYSpace + cmLong10ColorPacking,
  601.     cmXYZ24Space                = cmXYZSpace + cm24_8ColorPacking,
  602.     cmXYZ32Space                = cmXYZSpace + cmLong10ColorPacking,
  603.     cmXYZ48Space                = cmXYZSpace + cm48_16ColorPacking,
  604.     cmXYZ48LSpace               = cmXYZSpace + cm48_16ColorPacking + cmLittleEndianPacking,
  605.     cmLUV32Space                = cmLUVSpace + cmLong10ColorPacking,
  606.     cmLAB24Space                = cmLABSpace + cm24_8ColorPacking,
  607.     cmLAB32Space                = cmLABSpace + cmLong10ColorPacking,
  608.     cmLAB48Space                = cmLABSpace + cm48_16ColorPacking,
  609.     cmLAB48LSpace               = cmLABSpace + cm48_16ColorPacking + cmLittleEndianPacking,
  610.     cmGamutResult1Space         = cmOneBitDirectPacking + cmGamutResultSpace,
  611.     cmNamedIndexed32Space       = cm32_32ColorPacking + cmNamedIndexedSpace,
  612.     cmNamedIndexed32LSpace      = cm32_32ColorPacking + cmNamedIndexedSpace + cmLittleEndianPacking,
  613.     cmMCFive8Space              = cm40_8ColorPacking + cmMCFiveSpace,
  614.     cmMCSix8Space               = cm48_8ColorPacking + cmMCSixSpace,
  615.     cmMCSeven8Space             = cm56_8ColorPacking + cmMCSevenSpace,
  616.     cmMCEight8Space             = cm64_8ColorPacking + cmMCEightSpace
  617. };
  621. typedef UInt32                          CMBitmapColorSpace;
  623. struct CMBitmap {
  624.     char *                          image;
  625.     long                            width;
  626.     long                            height;
  627.     long                            rowBytes;
  628.     long                            pixelSize;
  629.     CMBitmapColorSpace              space;
  630.     long                            user1;
  631.     long                            user2;
  632. };
  633. typedef struct CMBitmap                 CMBitmap;
  635. /* Classic Print Manager Stuff */
  636. #if TARGET_OS_MAC
  637. enum {
  638.     enableColorMatchingOp       = 12,
  639.     registerProfileOp           = 13
  640. };
  642. #endif  /* TARGET_OS_MAC */
  644. /* Profile Locations */
  645. enum {
  646.     CS_MAX_PATH                 = 256
  647. };
  649. enum {
  650.     cmNoProfileBase             = 0,
  651.     cmFileBasedProfile          = 1,
  652.     cmHandleBasedProfile        = 2,
  653.     cmPtrBasedProfile           = 3,
  654.     cmProcedureBasedProfile     = 4,
  655.     cmPathBasedProfile          = 5,
  656.     cmBufferBasedProfile        = 6
  657. };
  660. struct CMFileLocation {
  661.     FSSpec                          spec;
  662. };
  663. typedef struct CMFileLocation           CMFileLocation;
  665. struct CMHandleLocation {
  666.     Handle                          h;
  667. };
  668. typedef struct CMHandleLocation         CMHandleLocation;
  670. struct CMPtrLocation {
  671.     Ptr                             p;
  672. };
  673. typedef struct CMPtrLocation            CMPtrLocation;
  675. struct CMProcedureLocation {
  676.     CMProfileAccessUPP              proc;
  677.     void *                          refCon;
  678. };
  679. typedef struct CMProcedureLocation      CMProcedureLocation;
  681. struct CMPathLocation {
  682.     char                            path[256];
  683. };
  684. typedef struct CMPathLocation           CMPathLocation;
  686. struct CMBufferLocation {
  687.     void *                          buffer;
  688.     UInt32                          size;
  689. };
  690. typedef struct CMBufferLocation         CMBufferLocation;
  692. union CMProfLoc {
  693.     CMFileLocation                  fileLoc;
  694.     CMHandleLocation                handleLoc;
  695.     CMPtrLocation                   ptrLoc;
  696.     CMProcedureLocation             procLoc;
  697.     CMPathLocation                  pathLoc;
  698.     CMBufferLocation                bufferLoc;
  699. };
  700. typedef union CMProfLoc                 CMProfLoc;
  702. struct CMProfileLocation {
  703.     short                           locType;
  704.     CMProfLoc                       u;
  705. };
  706. typedef struct CMProfileLocation        CMProfileLocation;
  707. #if TARGET_OS_MAC
  708. enum {
  709.     cmOriginalProfileLocationSize = 72,
  710.     cmCurrentProfileLocationSize = 2 + CS_MAX_PATH
  711. };
  713. #else
  714. enum {
  715.     cmOriginalProfileLocationSize = 2 + CS_MAX_PATH,
  716.     cmCurrentProfileLocationSize = 2 + CS_MAX_PATH
  717. };
  719. #endif  /* TARGET_OS_MAC */
  721. /* Struct and enums used for Profile iteration */
  722. enum {
  723.     cmProfileIterateDataVersion1 = 0x00010000,
  724.     cmProfileIterateDataVersion2 = 0x00020000
  725. };
  728. struct CMProfileIterateData {
  729.     UInt32                          dataVersion;                /* cmProfileIterateDataVersion2 */
  730.     CM2Header                       header;
  731.     ScriptCode                      code;
  732.     Str255                          name;
  733.     CMProfileLocation               location;
  734.     UniCharCount                    uniCodeNameCount;
  735.     UniChar *                       uniCodeName;
  736.     unsigned char *                 asciiName;
  737.     CMMakeAndModel *                makeAndModel;
  738. };
  739. typedef struct CMProfileIterateData     CMProfileIterateData;
  740. /* Caller-supplied callback function for Profile & CMM iteration */
  741. typedef CALLBACK_API( OSErr , CMProfileIterateProcPtr )(CMProfileIterateData *iterateData, void *refCon);
  742. typedef CALLBACK_API( OSErr , CMMIterateProcPtr )(CMMInfo *iterateData, void *refCon);
  743. typedef STACK_UPP_TYPE(CMProfileIterateProcPtr)                 CMProfileIterateUPP;
  744. typedef STACK_UPP_TYPE(CMMIterateProcPtr)                       CMMIterateUPP;
  745. #if OPAQUE_UPP_TYPES
  746.     EXTERN_API(CMProfileIterateUPP)
  747.     NewCMProfileIterateUPP         (CMProfileIterateProcPtr userRoutine);
  749.     EXTERN_API(CMMIterateUPP)
  750.     NewCMMIterateUPP               (CMMIterateProcPtr       userRoutine);
  752.     EXTERN_API(void)
  753.     DisposeCMProfileIterateUPP     (CMProfileIterateUPP     userUPP);
  755.     EXTERN_API(void)
  756.     DisposeCMMIterateUPP           (CMMIterateUPP           userUPP);
  758.     EXTERN_API(OSErr)
  759.     InvokeCMProfileIterateUPP      (CMProfileIterateData *  iterateData,
  760.                                     void *                  refCon,
  761.                                     CMProfileIterateUPP     userUPP);
  763.     EXTERN_API(OSErr)
  764.     InvokeCMMIterateUPP            (CMMInfo *               iterateData,
  765.                                     void *                  refCon,
  766.                                     CMMIterateUPP           userUPP);
  768. #else
  769.     enum { uppCMProfileIterateProcInfo = 0x000003E0 };              /* pascal 2_bytes Func(4_bytes, 4_bytes) */
  770.     enum { uppCMMIterateProcInfo = 0x000003E0 };                    /* pascal 2_bytes Func(4_bytes, 4_bytes) */
  771.     #define NewCMProfileIterateUPP(userRoutine)                     (CMProfileIterateUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMProfileIterateProcInfo, GetCurrentArchitecture())
  772.     #define NewCMMIterateUPP(userRoutine)                           (CMMIterateUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMMIterateProcInfo, GetCurrentArchitecture())
  773.     #define DisposeCMProfileIterateUPP(userUPP)                     DisposeRoutineDescriptor(userUPP)
  774.     #define DisposeCMMIterateUPP(userUPP)                           DisposeRoutineDescriptor(userUPP)
  775.     #define InvokeCMProfileIterateUPP(iterateData, refCon, userUPP)  (OSErr)CALL_TWO_PARAMETER_UPP((userUPP), uppCMProfileIterateProcInfo, (iterateData), (refCon))
  776.     #define InvokeCMMIterateUPP(iterateData, refCon, userUPP)       (OSErr)CALL_TWO_PARAMETER_UPP((userUPP), uppCMMIterateProcInfo, (iterateData), (refCon))
  777. #endif
  778. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  779. #define NewCMProfileIterateProc(userRoutine)                    NewCMProfileIterateUPP(userRoutine)
  780. #define NewCMMIterateProc(userRoutine)                          NewCMMIterateUPP(userRoutine)
  781. #define CallCMProfileIterateProc(userRoutine, iterateData, refCon) InvokeCMProfileIterateUPP(iterateData, refCon, userRoutine)
  782. #define CallCMMIterateProc(userRoutine, iterateData, refCon)    InvokeCMMIterateUPP(iterateData, refCon, userRoutine)
  783. /* Profile file and element access */
  784. EXTERN_API( CMError )
  785. CMNewProfile                    (CMProfileRef *         prof,
  786.                                  const CMProfileLocation * theProfile)                      FOURWORDINLINE(0x203C, 0x0008, 0x001B, 0xABEE);
  788. EXTERN_API( CMError )
  789. CMOpenProfile                   (CMProfileRef *         prof,
  790.                                  const CMProfileLocation * theProfile)                      FOURWORDINLINE(0x203C, 0x0008, 0x001C, 0xABEE);
  792. EXTERN_API( CMError )
  793. CMCloseProfile                  (CMProfileRef           prof)                               FOURWORDINLINE(0x203C, 0x0004, 0x001D, 0xABEE);
  795. EXTERN_API( CMError )
  796. CMUpdateProfile                 (CMProfileRef           prof)                               FOURWORDINLINE(0x203C, 0x0004, 0x0034, 0xABEE);
  798. EXTERN_API( CMError )
  799. CMCopyProfile                   (CMProfileRef *         targetProf,
  800.                                  const CMProfileLocation * targetLocation,
  801.                                  CMProfileRef           srcProf)                            FOURWORDINLINE(0x203C, 0x000C, 0x0025, 0xABEE);
  803. EXTERN_API( CMError )
  804. CMValidateProfile               (CMProfileRef           prof,
  805.                                  Boolean *              valid,
  806.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x000C, 0x0026, 0xABEE);
  808. EXTERN_API( CMError )
  809. CMGetProfileLocation            (CMProfileRef           prof,
  810.                                  CMProfileLocation *    theProfile)                         FOURWORDINLINE(0x203C, 0x0008, 0x003C, 0xABEE);
  812. EXTERN_API( CMError )
  813. NCMGetProfileLocation           (CMProfileRef           prof,
  814.                                  CMProfileLocation *    theProfile,
  815.                                  UInt32 *               locationSize)                       FOURWORDINLINE(0x203C, 0x000C, 0x0059, 0xABEE);
  817. EXTERN_API( CMError )
  818. CMFlattenProfile                (CMProfileRef           prof,
  819.                                  UInt32                 flags,
  820.                                  CMFlattenUPP           proc,
  821.                                  void *                 refCon,
  822.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0014, 0x0031, 0xABEE);
  824. #if TARGET_OS_MAC
  825. EXTERN_API( CMError )
  826. CMUnflattenProfile              (FSSpec *               resultFileSpec,
  827.                                  CMFlattenUPP           proc,
  828.                                  void *                 refCon,
  829.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0010, 0x0032, 0xABEE);
  831. #endif  /* TARGET_OS_MAC */
  833. EXTERN_API( CMError )
  834. CMGetProfileHeader              (CMProfileRef           prof,
  835.                                  CMAppleProfileHeader * header)                             FOURWORDINLINE(0x203C, 0x0008, 0x0039, 0xABEE);
  837. EXTERN_API( CMError )
  838. CMSetProfileHeader              (CMProfileRef           prof,
  839.                                  const CMAppleProfileHeader * header)                       FOURWORDINLINE(0x203C, 0x0008, 0x003A, 0xABEE);
  841. EXTERN_API( CMError )
  842. CMProfileElementExists          (CMProfileRef           prof,
  843.                                  OSType                 tag,
  844.                                  Boolean *              found)                              FOURWORDINLINE(0x203C, 0x000C, 0x001E, 0xABEE);
  846. EXTERN_API( CMError )
  847. CMCountProfileElements          (CMProfileRef           prof,
  848.                                  UInt32 *               elementCount)                       FOURWORDINLINE(0x203C, 0x0008, 0x001F, 0xABEE);
  850. EXTERN_API( CMError )
  851. CMGetProfileElement             (CMProfileRef           prof,
  852.                                  OSType                 tag,
  853.                                  UInt32 *               elementSize,
  854.                                  void *                 elementData)                        FOURWORDINLINE(0x203C, 0x0010, 0x0020, 0xABEE);
  856. EXTERN_API( CMError )
  857. CMSetProfileElement             (CMProfileRef           prof,
  858.                                  OSType                 tag,
  859.                                  UInt32                 elementSize,
  860.                                  void *                 elementData)                        FOURWORDINLINE(0x203C, 0x0010, 0x0023, 0xABEE);
  862. EXTERN_API( CMError )
  863. CMSetProfileElementSize         (CMProfileRef           prof,
  864.                                  OSType                 tag,
  865.                                  UInt32                 elementSize)                        FOURWORDINLINE(0x203C, 0x000C, 0x0038, 0xABEE);
  867. EXTERN_API( CMError )
  868. CMSetProfileElementReference    (CMProfileRef           prof,
  869.                                  OSType                 elementTag,
  870.                                  OSType                 referenceTag)                       FOURWORDINLINE(0x203C, 0x000C, 0x0035, 0xABEE);
  872. EXTERN_API( CMError )
  873. CMGetPartialProfileElement      (CMProfileRef           prof,
  874.                                  OSType                 tag,
  875.                                  UInt32                 offset,
  876.                                  UInt32 *               byteCount,
  877.                                  void *                 elementData)                        FOURWORDINLINE(0x203C, 0x0014, 0x0036, 0xABEE);
  879. EXTERN_API( CMError )
  880. CMSetPartialProfileElement      (CMProfileRef           prof,
  881.                                  OSType                 tag,
  882.                                  UInt32                 offset,
  883.                                  UInt32                 byteCount,
  884.                                  void *                 elementData)                        FOURWORDINLINE(0x203C, 0x0014, 0x0037, 0xABEE);
  886. EXTERN_API( CMError )
  887. CMGetIndProfileElementInfo      (CMProfileRef           prof,
  888.                                  UInt32                 index,
  889.                                  OSType *               tag,
  890.                                  UInt32 *               elementSize,
  891.                                  Boolean *              refs)                               FOURWORDINLINE(0x203C, 0x0014, 0x0021, 0xABEE);
  893. EXTERN_API( CMError )
  894. CMGetIndProfileElement          (CMProfileRef           prof,
  895.                                  UInt32                 index,
  896.                                  UInt32 *               elementSize,
  897.                                  void *                 elementData)                        FOURWORDINLINE(0x203C, 0x0010, 0x0022, 0xABEE);
  899. EXTERN_API( CMError )
  900. CMRemoveProfileElement          (CMProfileRef           prof,
  901.                                  OSType                 tag)                                FOURWORDINLINE(0x203C, 0x0008, 0x0024, 0xABEE);
  903. EXTERN_API( CMError )
  904. CMGetScriptProfileDescription   (CMProfileRef           prof,
  905.                                  Str255                 name,
  906.                                  ScriptCode *           code)                               FOURWORDINLINE(0x203C, 0x000C, 0x003E, 0xABEE);
  908. EXTERN_API( CMError )
  909. CMGetProfileDescriptions        (CMProfileRef           prof,
  910.                                  char *                 aName,
  911.                                  UInt32 *               aCount,
  912.                                  Str255                 mName,
  913.                                  ScriptCode *           mCode,
  914.                                  UniChar *              uName,
  915.                                  UniCharCount *         uCount)                             FOURWORDINLINE(0x203C, 0x001A, 0x0067, 0xABEE);
  917. EXTERN_API( CMError )
  918. CMSetProfileDescriptions        (CMProfileRef           prof,
  919.                                  const char *           aName,
  920.                                  UInt32                 aCount,
  921.                                  ConstStr255Param       mName,
  922.                                  ScriptCode             mCode,
  923.                                  const UniChar *        uName,
  924.                                  UniCharCount           uCount)                             FOURWORDINLINE(0x203C, 0x001A, 0x0068, 0xABEE);
  926. EXTERN_API( CMError )
  927. CMCloneProfileRef               (CMProfileRef           prof)                               FOURWORDINLINE(0x203C, 0x0004, 0x0042, 0xABEE);
  929. EXTERN_API( CMError )
  930. CMGetProfileRefCount            (CMProfileRef           prof,
  931.                                  long *                 count)                              FOURWORDINLINE(0x203C, 0x0008, 0x0043, 0xABEE);
  933. EXTERN_API( CMError )
  934. CMProfileModified               (CMProfileRef           prof,
  935.                                  Boolean *              modified)                           FOURWORDINLINE(0x203C, 0x0008, 0x0044, 0xABEE);
  938. /* named Color access functions */
  939. EXTERN_API( CMError )
  940. CMGetNamedColorInfo             (CMProfileRef           prof,
  941.                                  UInt32 *               deviceChannels,
  942.                                  OSType *               deviceColorSpace,
  943.                                  OSType *               PCSColorSpace,
  944.                                  UInt32 *               count,
  945.                                  StringPtr              prefix,
  946.                                  StringPtr              suffix)                             FOURWORDINLINE(0x203C, 0x001C, 0x0046, 0xABEE);
  948. EXTERN_API( CMError )
  949. CMGetNamedColorValue            (CMProfileRef           prof,
  950.                                  StringPtr              name,
  951.                                  CMColor *              deviceColor,
  952.                                  CMColor *              PCSColor)                           FOURWORDINLINE(0x203C, 0x0010, 0x0047, 0xABEE);
  954. EXTERN_API( CMError )
  955. CMGetIndNamedColorValue         (CMProfileRef           prof,
  956.                                  UInt32                 index,
  957.                                  CMColor *              deviceColor,
  958.                                  CMColor *              PCSColor)                           FOURWORDINLINE(0x203C, 0x0010, 0x0048, 0xABEE);
  960. EXTERN_API( CMError )
  961. CMGetNamedColorIndex            (CMProfileRef           prof,
  962.                                  StringPtr              name,
  963.                                  UInt32 *               index)                              FOURWORDINLINE(0x203C, 0x000C, 0x0049, 0xABEE);
  965. EXTERN_API( CMError )
  966. CMGetNamedColorName             (CMProfileRef           prof,
  967.                                  UInt32                 index,
  968.                                  StringPtr              name)                               FOURWORDINLINE(0x203C, 0x000C, 0x004A, 0xABEE);
  971. /* General-purpose matching functions */
  972. EXTERN_API( CMError )
  973. NCWNewColorWorld                (CMWorldRef *           cw,
  974.                                  CMProfileRef           src,
  975.                                  CMProfileRef           dst)                                FOURWORDINLINE(0x203C, 0x000C, 0x0014, 0xABEE);
  977. EXTERN_API( CMError )
  978. CWConcatColorWorld              (CMWorldRef *           cw,
  979.                                  CMConcatProfileSet *   profileSet)                         FOURWORDINLINE(0x203C, 0x0008, 0x0015, 0xABEE);
  981. EXTERN_API( CMError )
  982. CWNewLinkProfile                (CMProfileRef *         prof,
  983.                                  const CMProfileLocation * targetLocation,
  984.                                  CMConcatProfileSet *   profileSet)                         FOURWORDINLINE(0x203C, 0x000C, 0x0033, 0xABEE);
  986. EXTERN_API( CMError )
  987. NCWConcatColorWorld             (CMWorldRef *           cw,
  988.                                  NCMConcatProfileSet *  profileSet,
  989.                                  CMConcatCallBackUPP    proc,
  990.                                  void *                 refCon)                             FOURWORDINLINE(0x203C, 0x0008, 0x0061, 0xABEE);
  992. EXTERN_API( CMError )
  993. NCWNewLinkProfile               (CMProfileRef *         prof,
  994.                                  const CMProfileLocation * targetLocation,
  995.                                  NCMConcatProfileSet *  profileSet,
  996.                                  CMConcatCallBackUPP    proc,
  997.                                  void *                 refCon)                             FOURWORDINLINE(0x203C, 0x000C, 0x0062, 0xABEE);
  999. EXTERN_API( void )
  1000. CWDisposeColorWorld             (CMWorldRef             cw)                                 FOURWORDINLINE(0x203C, 0x0004, 0x0001, 0xABEE);
  1002. EXTERN_API( CMError )
  1003. CWMatchColors                   (CMWorldRef             cw,
  1004.                                  CMColor *              myColors,
  1005.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0002, 0xABEE);
  1007. EXTERN_API( CMError )
  1008. CWCheckColors                   (CMWorldRef             cw,
  1009.                                  CMColor *              myColors,
  1010.                                  UInt32                 count,
  1011.                                  UInt32 *               result)                             FOURWORDINLINE(0x203C, 0x0010, 0x0003, 0xABEE);
  1013. EXTERN_API( CMError )
  1014. CWMatchBitmap                   (CMWorldRef             cw,
  1015.                                  CMBitmap *             bitmap,
  1016.                                  CMBitmapCallBackUPP    progressProc,
  1017.                                  void *                 refCon,
  1018.                                  CMBitmap *             matchedBitmap)                      FOURWORDINLINE(0x203C, 0x0010, 0x002C, 0xABEE);
  1020. EXTERN_API( CMError )
  1021. CWCheckBitmap                   (CMWorldRef             cw,
  1022.                                  const CMBitmap *       bitmap,
  1023.                                  CMBitmapCallBackUPP    progressProc,
  1024.                                  void *                 refCon,
  1025.                                  CMBitmap *             resultBitmap)                       FOURWORDINLINE(0x203C, 0x0014, 0x002D, 0xABEE);
  1028. /* Quickdraw-specific matching */
  1029. EXTERN_API( CMError )
  1030. CWMatchPixMap                   (CMWorldRef             cw,
  1031.                                  PixMap *               myPixMap,
  1032.                                  CMBitmapCallBackUPP    progressProc,
  1033.                                  void *                 refCon)                             FOURWORDINLINE(0x203C, 0x0010, 0x0004, 0xABEE);
  1035. EXTERN_API( CMError )
  1036. CWCheckPixMap                   (CMWorldRef             cw,
  1037.                                  PixMap *               myPixMap,
  1038.                                  CMBitmapCallBackUPP    progressProc,
  1039.                                  void *                 refCon,
  1040.                                  BitMap *               resultBitMap)                       FOURWORDINLINE(0x203C, 0x0014, 0x0007, 0xABEE);
  1042. #if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
  1043. EXTERN_API( CMError )
  1044. NCMBeginMatching                (CMProfileRef           src,
  1045.                                  CMProfileRef           dst,
  1046.                                  CMMatchRef *           myRef)                              FOURWORDINLINE(0x203C, 0x000C, 0x0016, 0xABEE);
  1048. EXTERN_API( void )
  1049. CMEndMatching                   (CMMatchRef             myRef)                              FOURWORDINLINE(0x203C, 0x0004, 0x000B, 0xABEE);
  1051. EXTERN_API( void )
  1052. NCMDrawMatchedPicture           (PicHandle              myPicture,
  1053.                                  CMProfileRef           dst,
  1054.                                  Rect *                 myRect)                             FOURWORDINLINE(0x203C, 0x000C, 0x0017, 0xABEE);
  1056. EXTERN_API( void )
  1057. CMEnableMatchingComment         (Boolean                enableIt)                           FOURWORDINLINE(0x203C, 0x0002, 0x000D, 0xABEE);
  1059. EXTERN_API( CMError )
  1060. NCMUseProfileComment            (CMProfileRef           prof,
  1061.                                  UInt32                 flags)                              FOURWORDINLINE(0x203C, 0x0008, 0x003B, 0xABEE);
  1063. #endif  /* TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON */
  1065. #if TARGET_OS_WIN32
  1066. #if CALL_NOT_IN_CARBON
  1067. EXTERN_API( CMError )
  1068. CWMatchHBITMAP                  (CMWorldRef             cw,
  1069.                                  HBITMAP                hBitmap,
  1070.                                  CMBitmapCallBackUPP    progressProc,
  1071.                                  void *                 refCon);
  1073. #endif  /* CALL_NOT_IN_CARBON */
  1075. #endif  /* TARGET_OS_WIN32 */
  1077. EXTERN_API( CMError )
  1078. CMCreateProfileIdentifier       (CMProfileRef           prof,
  1079.                                  CMProfileIdentifierPtr  ident,
  1080.                                  UInt32 *               size)                               FOURWORDINLINE(0x203C, 0x000C, 0x0041, 0xABEE);
  1083. /* System Profile access */
  1084. EXTERN_API( CMError )
  1085. CMGetSystemProfile              (CMProfileRef *         prof)                               FOURWORDINLINE(0x203C, 0x0004, 0x0018, 0xABEE);
  1087. EXTERN_API( CMError )
  1088. CMSetSystemProfile              (const FSSpec *         profileFileSpec)                    FOURWORDINLINE(0x203C, 0x0004, 0x0019, 0xABEE);
  1090. EXTERN_API( CMError )
  1091. NCMSetSystemProfile             (const CMProfileLocation * profLoc)                         FOURWORDINLINE(0x203C, 0x0004, 0x0064, 0xABEE);
  1093. EXTERN_API( CMError )
  1094. CMGetDefaultProfileBySpace      (OSType                 dataColorSpace,
  1095.                                  CMProfileRef *         prof)                               FOURWORDINLINE(0x203C, 0x0008, 0x005A, 0xABEE);
  1097. EXTERN_API( CMError )
  1098. CMSetDefaultProfileBySpace      (OSType                 dataColorSpace,
  1099.                                  CMProfileRef           prof)                               FOURWORDINLINE(0x203C, 0x0008, 0x005B, 0xABEE);
  1101. #if TARGET_OS_MAC
  1102. EXTERN_API( CMError )
  1103. CMGetProfileByAVID              (AVIDType               theAVID,
  1104.                                  CMProfileRef *         prof)                               FOURWORDINLINE(0x203C, 0x0008, 0x005C, 0xABEE);
  1106. EXTERN_API( CMError )
  1107. CMSetProfileByAVID              (AVIDType               theAVID,
  1108.                                  CMProfileRef           prof)                               FOURWORDINLINE(0x203C, 0x0008, 0x005D, 0xABEE);
  1110. #endif  /* TARGET_OS_MAC */
  1112. /* Profile Use enumerations */
  1113. enum {
  1114.     cmInputUse                  = FOUR_CHAR_CODE('inpt'),
  1115.     cmOutputUse                 = FOUR_CHAR_CODE('outp'),
  1116.     cmDisplayUse                = FOUR_CHAR_CODE('dply'),
  1117.     cmProofUse                  = FOUR_CHAR_CODE('pruf')
  1118. };
  1120. /* Profile access by Use */
  1121. EXTERN_API( CMError )
  1122. CMGetDefaultProfileByUse        (OSType                 use,
  1123.                                  CMProfileRef *         prof)                               FOURWORDINLINE(0x203C, 0x0008, 0x0069, 0xABEE);
  1125. EXTERN_API( CMError )
  1126. CMSetDefaultProfileByUse        (OSType                 use,
  1127.                                  CMProfileRef           prof)                               FOURWORDINLINE(0x203C, 0x0008, 0x0079, 0xABEE);
  1129. /* Profile Management */
  1130. EXTERN_API( CMError )
  1131. CMNewProfileSearch              (CMSearchRecord *       searchSpec,
  1132.                                  void *                 refCon,
  1133.                                  UInt32 *               count,
  1134.                                  CMProfileSearchRef *   searchResult)                       FOURWORDINLINE(0x203C, 0x0010, 0x0027, 0xABEE);
  1136. EXTERN_API( CMError )
  1137. CMUpdateProfileSearch           (CMProfileSearchRef     search,
  1138.                                  void *                 refCon,
  1139.                                  UInt32 *               count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0028, 0xABEE);
  1141. EXTERN_API( void )
  1142. CMDisposeProfileSearch          (CMProfileSearchRef     search)                             FOURWORDINLINE(0x203C, 0x0004, 0x0029, 0xABEE);
  1144. EXTERN_API( CMError )
  1145. CMSearchGetIndProfile           (CMProfileSearchRef     search,
  1146.                                  UInt32                 index,
  1147.                                  CMProfileRef *         prof)                               FOURWORDINLINE(0x203C, 0x000C, 0x002A, 0xABEE);
  1149. EXTERN_API( CMError )
  1150. CMSearchGetIndProfileFileSpec   (CMProfileSearchRef     search,
  1151.                                  UInt32                 index,
  1152.                                  FSSpec *               profileFile)                        FOURWORDINLINE(0x203C, 0x000C, 0x002B, 0xABEE);
  1154. EXTERN_API( CMError )
  1155. CMProfileIdentifierFolderSearch (CMProfileIdentifierPtr  ident,
  1156.                                  UInt32 *               matchedCount,
  1157.                                  CMProfileSearchRef *   searchResult)                       FOURWORDINLINE(0x203C, 0x000C, 0x003F, 0xABEE);
  1159. EXTERN_API( CMError )
  1160. CMProfileIdentifierListSearch   (CMProfileIdentifierPtr  ident,
  1161.                                  CMProfileRef *         profileList,
  1162.                                  UInt32                 listSize,
  1163.                                  UInt32 *               matchedCount,
  1164.                                  CMProfileRef *         matchedList)                        FOURWORDINLINE(0x203C, 0x0014, 0x0040, 0xABEE);
  1166. EXTERN_API( CMError )
  1167. CMIterateColorSyncFolder        (CMProfileIterateUPP    proc,
  1168.                                  UInt32 *               seed,
  1169.                                  UInt32 *               count,
  1170.                                  void *                 refCon)                             FOURWORDINLINE(0x203C, 0x0010, 0x0058, 0xABEE);
  1172. EXTERN_API( CMError )
  1173. NCMUnflattenProfile             (CMProfileLocation *    targetLocation,
  1174.                                  CMFlattenUPP           proc,
  1175.                                  void *                 refCon,
  1176.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0010, 0x0065, 0xABEE);
  1178. /* Utilities */
  1179. #if TARGET_OS_MAC
  1180. EXTERN_API( CMError )
  1181. CMGetColorSyncFolderSpec        (short                  vRefNum,
  1182.                                  Boolean                createFolder,
  1183.                                  short *                foundVRefNum,
  1184.                                  long *                 foundDirID)                         FOURWORDINLINE(0x203C, 0x000C, 0x0011, 0xABEE);
  1186. #endif  /* TARGET_OS_MAC */
  1188. #if TARGET_OS_WIN32 || TARGET_OS_UNIX
  1189. #if CALL_NOT_IN_CARBON
  1190. EXTERN_API( CMError )
  1191. CMGetColorSyncFolderPath        (Boolean                createFolder,
  1192.                                  char *                 lpBuffer,
  1193.                                  UInt32                 uSize);
  1195. #endif  /* CALL_NOT_IN_CARBON */
  1197. #endif  /* TARGET_OS_WIN32 || TARGET_OS_UNIX */
  1199. EXTERN_API( CMError )
  1200. CMGetCWInfo                     (CMWorldRef             cw,
  1201.                                  CMCWInfoRecord *       info)                               FOURWORDINLINE(0x203C, 0x0008, 0x001A, 0xABEE);
  1203. #if TARGET_API_MAC_OS8
  1204. #if CALL_NOT_IN_CARBON
  1205. EXTERN_API( CMError )
  1206. CMConvertProfile2to1            (CMProfileRef           profv2,
  1207.                                  CMProfileHandle *      profv1)                             FOURWORDINLINE(0x203C, 0x0008, 0x0045, 0xABEE);
  1209. #endif  /* CALL_NOT_IN_CARBON */
  1211. #endif  /* TARGET_API_MAC_OS8 */
  1213. EXTERN_API( CMError )
  1214. CMGetPreferredCMM               (OSType *               cmmType,
  1215.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0008, 0x005E, 0xABEE);
  1217. EXTERN_API( CMError )
  1218. CMIterateCMMInfo                (CMMIterateUPP          proc,
  1219.                                  UInt32 *               count,
  1220.                                  void *                 refCon)                             FOURWORDINLINE(0x203C, 0x000C, 0x0063, 0xABEE);
  1222. EXTERN_API( CMError )
  1223. CMGetColorSyncVersion           (UInt32 *               version)                            FOURWORDINLINE(0x203C, 0x0004, 0x0066, 0xABEE);
  1225. EXTERN_API( CMError )
  1226. CMLaunchControlPanel            (UInt32                 flags);
  1228. /* ColorSpace conversion functions */
  1229. EXTERN_API( CMError )
  1230. CMConvertXYZToLab               (const CMColor *        src,
  1231.                                  const CMXYZColor *     white,
  1232.                                  CMColor *              dst,
  1233.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x0010, 0x004B, 0xABEE);
  1235. EXTERN_API( CMError )
  1236. CMConvertLabToXYZ               (const CMColor *        src,
  1237.                                  const CMXYZColor *     white,
  1238.                                  CMColor *              dst,
  1239.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x0010, 0x004C, 0xABEE);
  1241. EXTERN_API( CMError )
  1242. CMConvertXYZToLuv               (const CMColor *        src,
  1243.                                  const CMXYZColor *     white,
  1244.                                  CMColor *              dst,
  1245.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x0010, 0x004D, 0xABEE);
  1247. EXTERN_API( CMError )
  1248. CMConvertLuvToXYZ               (const CMColor *        src,
  1249.                                  const CMXYZColor *     white,
  1250.                                  CMColor *              dst,
  1251.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x0010, 0x004E, 0xABEE);
  1253. EXTERN_API( CMError )
  1254. CMConvertXYZToYxy               (const CMColor *        src,
  1255.                                  CMColor *              dst,
  1256.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x004F, 0xABEE);
  1258. EXTERN_API( CMError )
  1259. CMConvertYxyToXYZ               (const CMColor *        src,
  1260.                                  CMColor *              dst,
  1261.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0050, 0xABEE);
  1263. EXTERN_API( CMError )
  1264. CMConvertRGBToHLS               (const CMColor *        src,
  1265.                                  CMColor *              dst,
  1266.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0051, 0xABEE);
  1268. EXTERN_API( CMError )
  1269. CMConvertHLSToRGB               (const CMColor *        src,
  1270.                                  CMColor *              dst,
  1271.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0052, 0xABEE);
  1273. EXTERN_API( CMError )
  1274. CMConvertRGBToHSV               (const CMColor *        src,
  1275.                                  CMColor *              dst,
  1276.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0053, 0xABEE);
  1278. EXTERN_API( CMError )
  1279. CMConvertHSVToRGB               (const CMColor *        src,
  1280.                                  CMColor *              dst,
  1281.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0054, 0xABEE);
  1283. EXTERN_API( CMError )
  1284. CMConvertRGBToGray              (const CMColor *        src,
  1285.                                  CMColor *              dst,
  1286.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0055, 0xABEE);
  1288. EXTERN_API( CMError )
  1289. CMConvertXYZToFixedXYZ          (const CMXYZColor *     src,
  1290.                                  CMFixedXYZColor *      dst,
  1291.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0056, 0xABEE);
  1293. EXTERN_API( CMError )
  1294. CMConvertFixedXYZToXYZ          (const CMFixedXYZColor * src,
  1295.                                  CMXYZColor *           dst,
  1296.                                  UInt32                 count)                              FOURWORDINLINE(0x203C, 0x000C, 0x0057, 0xABEE);
  1299. /* PS-related */
  1300. EXTERN_API( CMError )
  1301. CMGetPS2ColorSpace              (CMProfileRef           srcProf,
  1302.                                  UInt32                 flags,
  1303.                                  CMFlattenUPP           proc,
  1304.                                  void *                 refCon,
  1305.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0014, 0x002E, 0xABEE);
  1307. EXTERN_API( CMError )
  1308. CMGetPS2ColorRenderingIntent    (CMProfileRef           srcProf,
  1309.                                  UInt32                 flags,
  1310.                                  CMFlattenUPP           proc,
  1311.                                  void *                 refCon,
  1312.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0014, 0x002F, 0xABEE);
  1314. EXTERN_API( CMError )
  1315. CMGetPS2ColorRendering          (CMProfileRef           srcProf,
  1316.                                  CMProfileRef           dstProf,
  1317.                                  UInt32                 flags,
  1318.                                  CMFlattenUPP           proc,
  1319.                                  void *                 refCon,
  1320.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0018, 0x0030, 0xABEE);
  1322. EXTERN_API( CMError )
  1323. CMGetPS2ColorRenderingVMSize    (CMProfileRef           srcProf,
  1324.                                  CMProfileRef           dstProf,
  1325.                                  UInt32 *               vmSize,
  1326.                                  Boolean *              preferredCMMnotfound)               FOURWORDINLINE(0x203C, 0x0010, 0x003D, 0xABEE);
  1329. /* ColorSync 1.0 functions which have parallel 2.0 counterparts */
  1330. #if TARGET_API_MAC_OS8
  1331. #if CALL_NOT_IN_CARBON
  1332. EXTERN_API( CMError )
  1333. CWNewColorWorld                 (CMWorldRef *           cw,
  1334.                                  CMProfileHandle        src,
  1335.                                  CMProfileHandle        dst)                                FOURWORDINLINE(0x203C, 0x000C, 0x0000, 0xABEE);
  1337. EXTERN_API( CMError )
  1338. ConcatenateProfiles             (CMProfileHandle        thru,
  1339.                                  CMProfileHandle        dst,
  1340.                                  CMProfileHandle *      newDst)                             FOURWORDINLINE(0x203C, 0x000C, 0x000C, 0xABEE);
  1342. EXTERN_API( CMError )
  1343. CMBeginMatching                 (CMProfileHandle        src,
  1344.                                  CMProfileHandle        dst,
  1345.                                  CMMatchRef *           myRef)                              FOURWORDINLINE(0x203C, 0x000C, 0x000A, 0xABEE);
  1347. EXTERN_API( void )
  1348. CMDrawMatchedPicture            (PicHandle              myPicture,
  1349.                                  CMProfileHandle        dst,
  1350.                                  Rect *                 myRect)                             FOURWORDINLINE(0x203C, 0x000C, 0x0009, 0xABEE);
  1352. EXTERN_API( CMError )
  1353. CMUseProfileComment             (CMProfileHandle        profile)                            FOURWORDINLINE(0x203C, 0x0004, 0x0008, 0xABEE);
  1355. EXTERN_API( void )
  1356. CMGetProfileName                (CMProfileHandle        myProfile,
  1357.                                  CMIString *            IStringResult)                      FOURWORDINLINE(0x203C, 0x0008, 0x000E, 0xABEE);
  1359. EXTERN_API( long )
  1360. CMGetProfileAdditionalDataOffset (CMProfileHandle       myProfile)                          FOURWORDINLINE(0x203C, 0x0004, 0x000F, 0xABEE);
  1363. /* ProfileResponder functions */
  1364. EXTERN_API( CMError )
  1365. GetProfile                      (OSType                 deviceType,
  1366.                                  long                   refNum,
  1367.                                  CMProfileHandle        aProfile,
  1368.                                  CMProfileHandle *      returnedProfile)                    FOURWORDINLINE(0x203C, 0x0010, 0x0005, 0xABEE);
  1370. EXTERN_API( CMError )
  1371. SetProfile                      (OSType                 deviceType,
  1372.                                  long                   refNum,
  1373.                                  CMProfileHandle        newProfile)                         FOURWORDINLINE(0x203C, 0x000C, 0x0006, 0xABEE);
  1375. EXTERN_API( CMError )
  1376. SetProfileDescription           (OSType                 deviceType,
  1377.                                  long                   refNum,
  1378.                                  long                   deviceData,
  1379.                                  CMProfileHandle        hProfile)                           FOURWORDINLINE(0x203C, 0x0010, 0x0010, 0xABEE);
  1381. EXTERN_API( CMError )
  1382. GetIndexedProfile               (OSType                 deviceType,
  1383.                                  long                   refNum,
  1384.                                  CMProfileSearchRecordHandle  search,
  1385.                                  CMProfileHandle *      returnProfile,
  1386.                                  long *                 index)                              FOURWORDINLINE(0x203C, 0x0014, 0x0012, 0xABEE);
  1388. EXTERN_API( CMError )
  1389. DeleteDeviceProfile             (OSType                 deviceType,
  1390.                                  long                   refNum,
  1391.                                  CMProfileHandle        deleteMe)                           FOURWORDINLINE(0x203C, 0x000C, 0x0013, 0xABEE);
  1394. #endif  /* CALL_NOT_IN_CARBON */
  1396. #if OLDROUTINENAMES
  1397. /* constants */
  1399. typedef CMFlattenProcPtr                CMFlattenProc;
  1400. typedef CMBitmapCallBackProcPtr         CMBitmapCallBackProc;
  1401. typedef CMProfileFilterProcPtr          CMProfileFilterProc;
  1402. enum {
  1403.     CMTrap                      = cmTrap,
  1404.     CMBeginProfile              = cmBeginProfile,
  1405.     CMEndProfile                = cmEndProfile,
  1406.     CMEnableMatching            = cmEnableMatching,
  1407.     CMDisableMatching           = cmDisableMatching
  1408. };
  1410. /* 1.0 Error codes, for compatibility with older applications. 1.0 CMM's may return obsolete error codes */
  1411. enum {
  1412.     CMNoError                   = 0,                            /*    obsolete name, use noErr */
  1413.     CMProfileError              = cmProfileError,
  1414.     CMMethodError               = cmMethodError,
  1415.     CMMemFullError              = -172,                         /*    obsolete, 2.0 uses memFullErr */
  1416.     CMUnimplementedError        = -173,                         /*    obsolete, 2.0 uses unimpErr */
  1417.     CMParamError                = -174,                         /*    obsolete, 2.0 uses paramErr */
  1418.     CMMethodNotFound            = cmMethodNotFound,
  1419.     CMProfileNotFound           = cmProfileNotFound,
  1420.     CMProfilesIdentical         = cmProfilesIdentical,
  1421.     CMCantConcatenateError      = cmCantConcatenateError,
  1422.     CMCantXYZ                   = cmCantXYZ,
  1423.     CMCantDeleteProfile         = cmCantDeleteProfile,
  1424.     CMUnsupportedDataType       = cmUnsupportedDataType,
  1425.     CMNoCurrentProfile          = cmNoCurrentProfile
  1426. };
  1428. enum {
  1429.     qdSystemDevice              = cmSystemDevice,
  1430.     qdGDevice                   = cmGDevice
  1431. };
  1434. enum {
  1435.     kMatchCMMType               = cmMatchCMMType,
  1436.     kMatchApplProfileVersion    = cmMatchApplProfileVersion,
  1437.     kMatchDataType              = cmMatchDataType,
  1438.     kMatchDeviceType            = cmMatchDeviceType,
  1439.     kMatchDeviceManufacturer    = cmMatchDeviceManufacturer,
  1440.     kMatchDeviceModel           = cmMatchDeviceModel,
  1441.     kMatchDeviceAttributes      = cmMatchDeviceAttributes,
  1442.     kMatchFlags                 = cmMatchFlags,
  1443.     kMatchOptions               = cmMatchOptions,
  1444.     kMatchWhite                 = cmMatchWhite,
  1445.     kMatchBlack                 = cmMatchBlack
  1446. };
  1448. /* types */
  1449. typedef CMCMYKColor                     CMYKColor;
  1450. typedef CMWorldRef                      CWorld;
  1451. typedef long *                          CMGamutResult;
  1452. /* functions */
  1453. #define EndMatching(myRef)                                                      CMEndMatching(myRef)
  1454. #define EnableMatching(enableIt)                                                CMEnableMatchingComment(enableIt)
  1455. #define GetColorSyncFolderSpec(vRefNum, createFolder, foundVRefNum, foundDirID) CMGetColorSyncFolderSpec(vRefNum, createFolder, foundVRefNum, foundDirID)
  1456. #define BeginMatching(src, dst, myRef)                                          CMBeginMatching(src, dst, myRef)
  1457. #define DrawMatchedPicture(myPicture, dst, myRect)                              CMDrawMatchedPicture(myPicture, dst, myRect)
  1458. #define UseProfile(profile)                                                     CMUseProfileComment(profile)
  1459. #define GetProfileName(myProfile, IStringResult)                                CMGetProfileName(myProfile, IStringResult)
  1460. #define GetProfileAdditionalDataOffset(myProfile)                               CMGetProfileAdditionalDataOffset(myProfile)
  1461. #endif  /* OLDROUTINENAMES */
  1463. /* Deprecated stuff*/
  1465. /* PrGeneral parameter blocks */
  1467. struct TEnableColorMatchingBlk {
  1468.     short                           iOpCode;
  1469.     short                           iError;
  1470.     long                            lReserved;
  1471.     THPrint                         hPrint;
  1472.     Boolean                         fEnableIt;
  1473.     SInt8                           filler;
  1474. };
  1475. typedef struct TEnableColorMatchingBlk  TEnableColorMatchingBlk;
  1477. struct TRegisterProfileBlk {
  1478.     short                           iOpCode;
  1479.     short                           iError;
  1480.     long                            lReserved;
  1481.     THPrint                         hPrint;
  1482.     Boolean                         fRegisterIt;
  1483.     SInt8                           filler;
  1484. };
  1485. typedef struct TRegisterProfileBlk      TRegisterProfileBlk;
  1486. #endif  /* TARGET_API_MAC_OS8 */
  1489. #if PRAGMA_STRUCT_ALIGN
  1490.     #pragma options align=reset
  1491. #elif PRAGMA_STRUCT_PACKPUSH
  1492.     #pragma pack(pop)
  1493. #elif PRAGMA_STRUCT_PACK
  1494.     #pragma pack()
  1495. #endif
  1497. #ifdef PRAGMA_IMPORT_OFF
  1498. #pragma import off
  1499. #elif PRAGMA_IMPORT
  1500. #pragma import reset
  1501. #endif
  1503. #ifdef __cplusplus
  1504. }
  1505. #endif
  1507. #endif /* __CMAPPLICATION__ */