topical media & game development
lib-of-vs-libs-QTDevWin-CIncludes-CMApplication.h / h
/*
File: CMApplication.h
Contains: Color Matching Interfaces
Version: Technology: ColorSync 3.0
Release: QuickTime 6.0.2
Copyright: (c) 1992-2001 by Apple Computer, Inc., all rights reserved.
Bugs?: For bug reports, consult the following page on
the World Wide Web:
http://developer.apple.com/bugreporter/
*/
ifndef __CMAPPLICATION__
define __CMAPPLICATION__
ifndef __MACTYPES__
include <MacTypes.h>
endif
ifndef __QUICKDRAW__
include <Quickdraw.h>
endif
ifndef __FILES__
include <Files.h>
endif
ifndef __CMICCPROFILE__
include <CMICCProfile.h>
endif
ifndef __DISPLAYS__
include <Displays.h>
endif
ifndef __MACERRORS__
include <MacErrors.h>
endif
if TARGET_API_MAC_OS8
ifndef __PRINTING__
include <Printing.h>
endif
endif /* TARGET_API_MAC_OS8 */
if TARGET_OS_WIN32
include <windows.h>
endif
if PRAGMA_ONCE
#pragma once
endif
ifdef __cplusplus
extern "C" {
endif
if PRAGMA_IMPORT
#pragma import on
endif
if PRAGMA_STRUCT_ALIGN
#pragma options align=mac68k
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
endif
enum {
kDefaultCMMSignature = FOUR_CHAR_CODE('appl')
};
/* Macintosh 68K trap word */
enum {
cmTrap = 0xABEE
};
/* PicComment IDs */
enum {
cmBeginProfile = 220,
cmEndProfile = 221,
cmEnableMatching = 222,
cmDisableMatching = 223,
cmComment = 224
};
/* PicComment selectors for cmComment */
enum {
cmBeginProfileSel = 0,
cmContinueProfileSel = 1,
cmEndProfileSel = 2,
cmProfileIdentifierSel = 3
};
/* Defines for version 1.0 CMProfileSearchRecord.fieldMask */
enum {
cmMatchCMMType = 0x00000001,
cmMatchApplProfileVersion = 0x00000002,
cmMatchDataType = 0x00000004,
cmMatchDeviceType = 0x00000008,
cmMatchDeviceManufacturer = 0x00000010,
cmMatchDeviceModel = 0x00000020,
cmMatchDeviceAttributes = 0x00000040,
cmMatchFlags = 0x00000080,
cmMatchOptions = 0x00000100,
cmMatchWhite = 0x00000200,
cmMatchBlack = 0x00000400
};
/* Defines for version 2.0 CMSearchRecord.searchMask */
enum {
cmMatchAnyProfile = 0x00000000,
cmMatchProfileCMMType = 0x00000001,
cmMatchProfileClass = 0x00000002,
cmMatchDataColorSpace = 0x00000004,
cmMatchProfileConnectionSpace = 0x00000008,
cmMatchManufacturer = 0x00000010,
cmMatchModel = 0x00000020,
cmMatchAttributes = 0x00000040,
cmMatchProfileFlags = 0x00000080
};
/* deviceType values for ColorSync 1.0 Device Profile access */
enum {
cmSystemDevice = FOUR_CHAR_CODE('sys '),
cmGDevice = FOUR_CHAR_CODE('gdev')
};
/* Commands for CMFlattenUPP(...) */
enum {
cmOpenReadSpool = 1,
cmOpenWriteSpool = 2,
cmReadSpool = 3,
cmWriteSpool = 4,
cmCloseSpool = 5
};
/* Flags for PostScript-related functions */
enum {
cmPS7bit = 1,
cmPS8bit = 2
};
/* Flags for profile embedding functions */
enum {
cmEmbedWholeProfile = 0x00000000,
cmEmbedProfileIdentifier = 0x00000001
};
/* Commands for CMAccessUPP(...) */
enum {
cmOpenReadAccess = 1,
cmOpenWriteAccess = 2,
cmReadAccess = 3,
cmWriteAccess = 4,
cmCloseAccess = 5,
cmCreateNewAccess = 6,
cmAbortWriteAccess = 7,
cmBeginAccess = 8,
cmEndAccess = 9
};
/* Abstract data type for memory-based Profile */
typedef struct OpaqueCMProfileRef* CMProfileRef;
/* Abstract data type for Profile search result */
typedef struct OpaqueCMProfileSearchRef* CMProfileSearchRef;
/* Abstract data type for BeginMatching(...) reference */
typedef struct OpaqueCMMatchRef* CMMatchRef;
/* Abstract data type for ColorWorld reference */
typedef struct OpaqueCMWorldRef* CMWorldRef;
/* Caller-supplied flatten function */
typedef CALLBACK_API( OSErr , CMFlattenProcPtr )(long command, long *size, void *data, void *refCon);
/* Caller-supplied progress function for Bitmap & PixMap matching routines */
typedef CALLBACK_API( Boolean , CMBitmapCallBackProcPtr )(long progress, void *refCon);
/* Caller-supplied progress function for NCMMConcatInit & NCMMNewLinkProfile routines */
typedef CALLBACK_API( Boolean , CMConcatCallBackProcPtr )(long progress, void *refCon);
/* Caller-supplied filter function for Profile search */
typedef CALLBACK_API( Boolean , CMProfileFilterProcPtr )(CMProfileRef prof, void *refCon);
/* Caller-supplied function for profile access */
typedef CALLBACK_API( OSErr , CMProfileAccessProcPtr )(long command, long offset, long *size, void *data, void *refCon);
typedef STACK_UPP_TYPE(CMFlattenProcPtr) CMFlattenUPP;
typedef STACK_UPP_TYPE(CMBitmapCallBackProcPtr) CMBitmapCallBackUPP;
typedef STACK_UPP_TYPE(CMConcatCallBackProcPtr) CMConcatCallBackUPP;
typedef STACK_UPP_TYPE(CMProfileFilterProcPtr) CMProfileFilterUPP;
typedef STACK_UPP_TYPE(CMProfileAccessProcPtr) CMProfileAccessUPP;
if OPAQUE_UPP_TYPES
EXTERN_API(CMFlattenUPP)
NewCMFlattenUPP (CMFlattenProcPtr userRoutine);
EXTERN_API(CMBitmapCallBackUPP)
NewCMBitmapCallBackUPP (CMBitmapCallBackProcPtr userRoutine);
EXTERN_API(CMConcatCallBackUPP)
NewCMConcatCallBackUPP (CMConcatCallBackProcPtr userRoutine);
EXTERN_API(CMProfileFilterUPP)
NewCMProfileFilterUPP (CMProfileFilterProcPtr userRoutine);
EXTERN_API(CMProfileAccessUPP)
NewCMProfileAccessUPP (CMProfileAccessProcPtr userRoutine);
EXTERN_API(void)
DisposeCMFlattenUPP (CMFlattenUPP userUPP);
EXTERN_API(void)
DisposeCMBitmapCallBackUPP (CMBitmapCallBackUPP userUPP);
EXTERN_API(void)
DisposeCMConcatCallBackUPP (CMConcatCallBackUPP userUPP);
EXTERN_API(void)
DisposeCMProfileFilterUPP (CMProfileFilterUPP userUPP);
EXTERN_API(void)
DisposeCMProfileAccessUPP (CMProfileAccessUPP userUPP);
EXTERN_API(OSErr)
InvokeCMFlattenUPP (long command,
long * size,
void * data,
void * refCon,
CMFlattenUPP userUPP);
EXTERN_API(Boolean)
InvokeCMBitmapCallBackUPP (long progress,
void * refCon,
CMBitmapCallBackUPP userUPP);
EXTERN_API(Boolean)
InvokeCMConcatCallBackUPP (long progress,
void * refCon,
CMConcatCallBackUPP userUPP);
EXTERN_API(Boolean)
InvokeCMProfileFilterUPP (CMProfileRef prof,
void * refCon,
CMProfileFilterUPP userUPP);
EXTERN_API(OSErr)
InvokeCMProfileAccessUPP (long command,
long offset,
long * size,
void * data,
void * refCon,
CMProfileAccessUPP userUPP);
else
enum { uppCMFlattenProcInfo = 0x00003FE0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes) */
enum { uppCMBitmapCallBackProcInfo = 0x000003D0 }; /* pascal 1_byte Func(4_bytes, 4_bytes) */
enum { uppCMConcatCallBackProcInfo = 0x000003D0 }; /* pascal 1_byte Func(4_bytes, 4_bytes) */
enum { uppCMProfileFilterProcInfo = 0x000003D0 }; /* pascal 1_byte Func(4_bytes, 4_bytes) */
enum { uppCMProfileAccessProcInfo = 0x0000FFE0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#define NewCMFlattenUPP(userRoutine) (CMFlattenUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMFlattenProcInfo, GetCurrentArchitecture())
#define NewCMBitmapCallBackUPP(userRoutine) (CMBitmapCallBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMBitmapCallBackProcInfo, GetCurrentArchitecture())
#define NewCMConcatCallBackUPP(userRoutine) (CMConcatCallBackUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMConcatCallBackProcInfo, GetCurrentArchitecture())
#define NewCMProfileFilterUPP(userRoutine) (CMProfileFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMProfileFilterProcInfo, GetCurrentArchitecture())
#define NewCMProfileAccessUPP(userRoutine) (CMProfileAccessUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMProfileAccessProcInfo, GetCurrentArchitecture())
#define DisposeCMFlattenUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeCMBitmapCallBackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeCMConcatCallBackUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeCMProfileFilterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeCMProfileAccessUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define InvokeCMFlattenUPP(command, size, data, refCon, userUPP) (OSErr)CALL_FOUR_PARAMETER_UPP((userUPP), uppCMFlattenProcInfo, (command), (size), (data), (refCon))
#define InvokeCMBitmapCallBackUPP(progress, refCon, userUPP) (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppCMBitmapCallBackProcInfo, (progress), (refCon))
#define InvokeCMConcatCallBackUPP(progress, refCon, userUPP) (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppCMConcatCallBackProcInfo, (progress), (refCon))
#define InvokeCMProfileFilterUPP(prof, refCon, userUPP) (Boolean)CALL_TWO_PARAMETER_UPP((userUPP), uppCMProfileFilterProcInfo, (prof), (refCon))
#define InvokeCMProfileAccessUPP(command, offset, size, data, refCon, userUPP) (OSErr)CALL_FIVE_PARAMETER_UPP((userUPP), uppCMProfileAccessProcInfo, (command), (offset), (size), (data), (refCon))
endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
define NewCMFlattenProc(userRoutine) NewCMFlattenUPP(userRoutine)
define NewCMBitmapCallBackProc(userRoutine) NewCMBitmapCallBackUPP(userRoutine)
define NewCMConcatCallBackProc(userRoutine) NewCMConcatCallBackUPP(userRoutine)
define NewCMProfileFilterProc(userRoutine) NewCMProfileFilterUPP(userRoutine)
define NewCMProfileAccessProc(userRoutine) NewCMProfileAccessUPP(userRoutine)
define CallCMFlattenProc(userRoutine, command, size, data, refCon) InvokeCMFlattenUPP(command, size, data, refCon, userRoutine)
define CallCMBitmapCallBackProc(userRoutine, progress, refCon) InvokeCMBitmapCallBackUPP(progress, refCon, userRoutine)
define CallCMConcatCallBackProc(userRoutine, progress, refCon) InvokeCMConcatCallBackUPP(progress, refCon, userRoutine)
define CallCMProfileFilterProc(userRoutine, prof, refCon) InvokeCMProfileFilterUPP(prof, refCon, userRoutine)
define CallCMProfileAccessProc(userRoutine, command, offset, size, data, refCon) InvokeCMProfileAccessUPP(command, offset, size, data, refCon, userRoutine)
typedef long CMError;
/* For 1.0 and 2.0 profile header variants */
/* CMAppleProfileHeader */
union CMAppleProfileHeader {
CMHeader cm1;
CM2Header cm2;
};
typedef union CMAppleProfileHeader CMAppleProfileHeader;
/* Param for CWConcatColorWorld(...) */
struct CMConcatProfileSet {
UInt16 keyIndex; /* Zero-based */
UInt16 count; /* Min 1 */
CMProfileRef profileSet[1]; /* Variable. Ordered from Source -> Dest */
};
typedef struct CMConcatProfileSet CMConcatProfileSet;
/* NCMConcatProfileSpec Tags */
enum {
kNoTransform = 0, /* Not used */
kUseAtoB = 1, /* Use 'A2B*' tag from this profile or equivalent */
kUseBtoA = 2, /* Use 'B2A*' tag from this profile or equivalent */
kUseBtoB = 3, /* Use 'pre*' tag from this profile or equivalent */
/* For typical device profiles the following synonyms may be useful */
kDeviceToPCS = kUseAtoB, /* Device Dependent to Device Independent */
kPCSToDevice = kUseBtoA, /* Device Independent to Device Dependent */
kPCSToPCS = kUseBtoB, /* Independent, through device's gamut */
kUseProfileIntent = (long)0xFFFFFFFF /* For renderingIntent in NCMConcatProfileSpec */
};
/* NCMConcatProfileSpec */
struct NCMConcatProfileSpec {
UInt32 renderingIntent; /* renderingIntent override */
UInt32 transformTag; /* transformTag, defined above */
CMProfileRef profile; /* profile */
};
typedef struct NCMConcatProfileSpec NCMConcatProfileSpec;
/* NCMConcatProfileSet */
struct NCMConcatProfileSet {
OSType cmm; /* e.g. 'KCMS', 'appl', ... uniquely ids the cmm, or 0000 */
UInt32 flags; /* specify quality, lookup only, no gamut checking ... */
UInt32 flagsMask; /* which bits of 'flags' to use to override profile */
UInt32 profileCount; /* how many ProfileSpecs in the following set */
NCMConcatProfileSpec profileSpecs[1]; /* Variable. Ordered from Source -> Dest */
};
typedef struct NCMConcatProfileSet NCMConcatProfileSet;
/* ColorSync color data types */
struct CMRGBColor {
UInt16 red; /* 0..65535 */
UInt16 green;
UInt16 blue;
};
typedef struct CMRGBColor CMRGBColor;
struct CMCMYKColor {
UInt16 cyan; /* 0..65535 */
UInt16 magenta;
UInt16 yellow;
UInt16 black;
};
typedef struct CMCMYKColor CMCMYKColor;
struct CMCMYColor {
UInt16 cyan; /* 0..65535 */
UInt16 magenta;
UInt16 yellow;
};
typedef struct CMCMYColor CMCMYColor;
struct CMHLSColor {
UInt16 hue; /* 0..65535. Fraction of circle. Red at 0 */
UInt16 lightness; /* 0..65535 */
UInt16 saturation; /* 0..65535 */
};
typedef struct CMHLSColor CMHLSColor;
struct CMHSVColor {
UInt16 hue; /* 0..65535. Fraction of circle. Red at 0 */
UInt16 saturation; /* 0..65535 */
UInt16 value; /* 0..65535 */
};
typedef struct CMHSVColor CMHSVColor;
struct CMLabColor {
UInt16 L; /* 0..65535 maps to 0..100 */
UInt16 a; /* 0..65535 maps to -128..127.996 */
UInt16 b; /* 0..65535 maps to -128..127.996 */
};
typedef struct CMLabColor CMLabColor;
struct CMLuvColor {
UInt16 L; /* 0..65535 maps to 0..100 */
UInt16 u; /* 0..65535 maps to -128..127.996 */
UInt16 v; /* 0..65535 maps to -128..127.996 */
};
typedef struct CMLuvColor CMLuvColor;
struct CMYxyColor {
UInt16 capY; /* 0..65535 maps to 0..1 */
UInt16 x; /* 0..65535 maps to 0..1 */
UInt16 y; /* 0..65535 maps to 0..1 */
};
typedef struct CMYxyColor CMYxyColor;
struct CMGrayColor {
UInt16 gray; /* 0..65535 */
};
typedef struct CMGrayColor CMGrayColor;
struct CMMultichannel5Color {
UInt8 components[5]; /* 0..255 */
};
typedef struct CMMultichannel5Color CMMultichannel5Color;
struct CMMultichannel6Color {
UInt8 components[6]; /* 0..255 */
};
typedef struct CMMultichannel6Color CMMultichannel6Color;
struct CMMultichannel7Color {
UInt8 components[7]; /* 0..255 */
};
typedef struct CMMultichannel7Color CMMultichannel7Color;
struct CMMultichannel8Color {
UInt8 components[8]; /* 0..255 */
};
typedef struct CMMultichannel8Color CMMultichannel8Color;
struct CMNamedColor {
UInt32 namedColorIndex; /* 0..a lot */
};
typedef struct CMNamedColor CMNamedColor;
union CMColor {
CMRGBColor rgb;
CMHSVColor hsv;
CMHLSColor hls;
CMXYZColor XYZ;
CMLabColor Lab;
CMLuvColor Luv;
CMYxyColor Yxy;
CMCMYKColor cmyk;
CMCMYColor cmy;
CMGrayColor gray;
CMMultichannel5Color mc5;
CMMultichannel6Color mc6;
CMMultichannel7Color mc7;
CMMultichannel8Color mc8;
CMNamedColor namedColor;
};
typedef union CMColor CMColor;
struct CMProfileSearchRecord {
CMHeader header;
UInt32 fieldMask;
UInt32 reserved[2];
};
typedef struct CMProfileSearchRecord CMProfileSearchRecord;
typedef CMProfileSearchRecord * CMProfileSearchRecordPtr;
typedef CMProfileSearchRecordPtr * CMProfileSearchRecordHandle;
/* Search definition for 2.0 */
struct CMSearchRecord {
OSType CMMType;
OSType profileClass;
OSType dataColorSpace;
OSType profileConnectionSpace;
UInt32 deviceManufacturer;
UInt32 deviceModel;
UInt32 deviceAttributes[2];
UInt32 profileFlags;
UInt32 searchMask;
CMProfileFilterUPP filter;
};
typedef struct CMSearchRecord CMSearchRecord;
/* CMMInfo structure */
struct CMMInfo {
UInt32 dataSize; /* Size of this structure - compatibility*/
OSType CMMType; /* Signature, e.g. 'KCMS'*/
OSType CMMMfr; /* Vendor, e.g. 'appl'*/
UInt32 CMMVersion; /* cmm version number*/
unsigned char ASCIIName[32]; /* pascal string - name*/
unsigned char ASCIIDesc[256]; /* pascal string - description or copyright*/
UniCharCount UniCodeNameCount; /* count of UniChars in following array*/
UniChar UniCodeName[32]; /* the name in UniCode chars*/
UniCharCount UniCodeDescCount; /* count of UniChars in following array*/
UniChar UniCodeDesc[256]; /* the description in UniCode chars*/
};
typedef struct CMMInfo CMMInfo;
/* GetCWInfo structures */
struct CMMInfoRecord {
OSType CMMType;
long CMMVersion;
};
typedef struct CMMInfoRecord CMMInfoRecord;
struct CMCWInfoRecord {
UInt32 cmmCount;
CMMInfoRecord cmmInfo[2];
};
typedef struct CMCWInfoRecord CMCWInfoRecord;
/* profile identifier structures */
struct CMProfileIdentifier {
CM2Header profileHeader;
CMDateTime calibrationDate;
UInt32 ASCIIProfileDescriptionLen;
char ASCIIProfileDescription[1]; /* variable length */
};
typedef struct CMProfileIdentifier CMProfileIdentifier;
typedef CMProfileIdentifier * CMProfileIdentifierPtr;
/* packing formats */
enum {
cmNoColorPacking = 0x0000,
cmWord5ColorPacking = 0x0500,
cmWord565ColorPacking = 0x0600,
cmLong8ColorPacking = 0x0800,
cmLong10ColorPacking = 0x0A00,
cmAlphaFirstPacking = 0x1000,
cmOneBitDirectPacking = 0x0B00,
cmAlphaLastPacking = 0x0000,
cm8_8ColorPacking = 0x2800,
cm16_8ColorPacking = 0x2000,
cm24_8ColorPacking = 0x2100,
cm32_8ColorPacking = cmLong8ColorPacking,
cm40_8ColorPacking = 0x2200,
cm48_8ColorPacking = 0x2300,
cm56_8ColorPacking = 0x2400,
cm64_8ColorPacking = 0x2500,
cm32_16ColorPacking = 0x2600,
cm48_16ColorPacking = 0x2900,
cm64_16ColorPacking = 0x2A00,
cm32_32ColorPacking = 0x2700,
cmLittleEndianPacking = 0x4000,
cmReverseChannelPacking = 0x8000
};
/* colorspace masks */
enum {
cmColorSpaceSpaceMask = 0x0000007F,
cmColorSpaceAlphaMask = 0x00000080,
cmColorSpaceSpaceAndAlphaMask = 0x000000FF,
cmColorSpacePackingMask = 0x0000FF00,
cmColorSpaceReservedMask = (long)0xFFFF0000
};
/* general colorspaces */
enum {
cmNoSpace = 0,
cmRGBSpace = 1,
cmCMYKSpace = 2,
cmHSVSpace = 3,
cmHLSSpace = 4,
cmYXYSpace = 5,
cmXYZSpace = 6,
cmLUVSpace = 7,
cmLABSpace = 8,
cmReservedSpace1 = 9,
cmGraySpace = 10,
cmReservedSpace2 = 11,
cmGamutResultSpace = 12,
cmNamedIndexedSpace = 16,
cmMCFiveSpace = 17,
cmMCSixSpace = 18,
cmMCSevenSpace = 19,
cmMCEightSpace = 20,
cmAlphaSpace = 0x80,
cmRGBASpace = cmRGBSpace + cmAlphaSpace,
cmGrayASpace = cmGraySpace + cmAlphaSpace
};
/* supported CMBitmapColorSpaces - Each of the following is a */
/* combination of a general colospace and a packing formats. */
/* Each can also be or'd with cmReverseChannelPacking. */
enum {
cmGray8Space = cmGraySpace + cm8_8ColorPacking,
cmGrayA16Space = cmGrayASpace + cm16_8ColorPacking,
cmGray16Space = cmGraySpace,
cmGrayA32Space = cmGrayASpace,
cmGray16LSpace = cmGraySpace + cmLittleEndianPacking,
cmGrayA32LSpace = cmGrayASpace + cmLittleEndianPacking,
cmRGB16Space = cmRGBSpace + cmWord5ColorPacking,
cmRGB16LSpace = cmRGBSpace + cmWord5ColorPacking + cmLittleEndianPacking,
cmRGB565Space = cmRGBSpace + cmWord565ColorPacking,
cmRGB565LSpace = cmRGBSpace + cmWord565ColorPacking + cmLittleEndianPacking,
cmRGB24Space = cmRGBSpace + cm24_8ColorPacking,
cmRGB32Space = cmRGBSpace + cm32_8ColorPacking,
cmRGB48Space = cmRGBSpace + cm48_16ColorPacking,
cmRGB48LSpace = cmRGBSpace + cm48_16ColorPacking + cmLittleEndianPacking,
cmARGB32Space = cmRGBASpace + cm32_8ColorPacking + cmAlphaFirstPacking,
cmARGB64Space = cmRGBASpace + cm64_16ColorPacking + cmAlphaFirstPacking,
cmARGB64LSpace = cmRGBASpace + cm64_16ColorPacking + cmAlphaFirstPacking + cmLittleEndianPacking,
cmRGBA32Space = cmRGBASpace + cm32_8ColorPacking + cmAlphaLastPacking,
cmRGBA64Space = cmRGBASpace + cm64_16ColorPacking + cmAlphaLastPacking,
cmRGBA64LSpace = cmRGBASpace + cm64_16ColorPacking + cmAlphaLastPacking + cmLittleEndianPacking,
cmCMYK32Space = cmCMYKSpace + cm32_8ColorPacking,
cmCMYK64Space = cmCMYKSpace + cm64_16ColorPacking,
cmCMYK64LSpace = cmCMYKSpace + cm64_16ColorPacking + cmLittleEndianPacking,
cmHSV32Space = cmHSVSpace + cmLong10ColorPacking,
cmHLS32Space = cmHLSSpace + cmLong10ColorPacking,
cmYXY32Space = cmYXYSpace + cmLong10ColorPacking,
cmXYZ24Space = cmXYZSpace + cm24_8ColorPacking,
cmXYZ32Space = cmXYZSpace + cmLong10ColorPacking,
cmXYZ48Space = cmXYZSpace + cm48_16ColorPacking,
cmXYZ48LSpace = cmXYZSpace + cm48_16ColorPacking + cmLittleEndianPacking,
cmLUV32Space = cmLUVSpace + cmLong10ColorPacking,
cmLAB24Space = cmLABSpace + cm24_8ColorPacking,
cmLAB32Space = cmLABSpace + cmLong10ColorPacking,
cmLAB48Space = cmLABSpace + cm48_16ColorPacking,
cmLAB48LSpace = cmLABSpace + cm48_16ColorPacking + cmLittleEndianPacking,
cmGamutResult1Space = cmOneBitDirectPacking + cmGamutResultSpace,
cmNamedIndexed32Space = cm32_32ColorPacking + cmNamedIndexedSpace,
cmNamedIndexed32LSpace = cm32_32ColorPacking + cmNamedIndexedSpace + cmLittleEndianPacking,
cmMCFive8Space = cm40_8ColorPacking + cmMCFiveSpace,
cmMCSix8Space = cm48_8ColorPacking + cmMCSixSpace,
cmMCSeven8Space = cm56_8ColorPacking + cmMCSevenSpace,
cmMCEight8Space = cm64_8ColorPacking + cmMCEightSpace
};
typedef UInt32 CMBitmapColorSpace;
struct CMBitmap {
char * image;
long width;
long height;
long rowBytes;
long pixelSize;
CMBitmapColorSpace space;
long user1;
long user2;
};
typedef struct CMBitmap CMBitmap;
/* Classic Print Manager Stuff */
if TARGET_OS_MAC
enum {
enableColorMatchingOp = 12,
registerProfileOp = 13
};
endif /* TARGET_OS_MAC */
/* Profile Locations */
enum {
CS_MAX_PATH = 256
};
enum {
cmNoProfileBase = 0,
cmFileBasedProfile = 1,
cmHandleBasedProfile = 2,
cmPtrBasedProfile = 3,
cmProcedureBasedProfile = 4,
cmPathBasedProfile = 5,
cmBufferBasedProfile = 6
};
struct CMFileLocation {
FSSpec spec;
};
typedef struct CMFileLocation CMFileLocation;
struct CMHandleLocation {
Handle h;
};
typedef struct CMHandleLocation CMHandleLocation;
struct CMPtrLocation {
Ptr p;
};
typedef struct CMPtrLocation CMPtrLocation;
struct CMProcedureLocation {
CMProfileAccessUPP proc;
void * refCon;
};
typedef struct CMProcedureLocation CMProcedureLocation;
struct CMPathLocation {
char path[256];
};
typedef struct CMPathLocation CMPathLocation;
struct CMBufferLocation {
void * buffer;
UInt32 size;
};
typedef struct CMBufferLocation CMBufferLocation;
union CMProfLoc {
CMFileLocation fileLoc;
CMHandleLocation handleLoc;
CMPtrLocation ptrLoc;
CMProcedureLocation procLoc;
CMPathLocation pathLoc;
CMBufferLocation bufferLoc;
};
typedef union CMProfLoc CMProfLoc;
struct CMProfileLocation {
short locType;
CMProfLoc u;
};
typedef struct CMProfileLocation CMProfileLocation;
if TARGET_OS_MAC
enum {
cmOriginalProfileLocationSize = 72,
cmCurrentProfileLocationSize = 2 + CS_MAX_PATH
};
else
enum {
cmOriginalProfileLocationSize = 2 + CS_MAX_PATH,
cmCurrentProfileLocationSize = 2 + CS_MAX_PATH
};
endif /* TARGET_OS_MAC */
/* Struct and enums used for Profile iteration */
enum {
cmProfileIterateDataVersion1 = 0x00010000,
cmProfileIterateDataVersion2 = 0x00020000
};
struct CMProfileIterateData {
UInt32 dataVersion; /* cmProfileIterateDataVersion2 */
CM2Header header;
ScriptCode code;
Str255 name;
CMProfileLocation location;
UniCharCount uniCodeNameCount;
UniChar * uniCodeName;
unsigned char * asciiName;
CMMakeAndModel * makeAndModel;
};
typedef struct CMProfileIterateData CMProfileIterateData;
/* Caller-supplied callback function for Profile & CMM iteration */
typedef CALLBACK_API( OSErr , CMProfileIterateProcPtr )(CMProfileIterateData *iterateData, void *refCon);
typedef CALLBACK_API( OSErr , CMMIterateProcPtr )(CMMInfo *iterateData, void *refCon);
typedef STACK_UPP_TYPE(CMProfileIterateProcPtr) CMProfileIterateUPP;
typedef STACK_UPP_TYPE(CMMIterateProcPtr) CMMIterateUPP;
if OPAQUE_UPP_TYPES
EXTERN_API(CMProfileIterateUPP)
NewCMProfileIterateUPP (CMProfileIterateProcPtr userRoutine);
EXTERN_API(CMMIterateUPP)
NewCMMIterateUPP (CMMIterateProcPtr userRoutine);
EXTERN_API(void)
DisposeCMProfileIterateUPP (CMProfileIterateUPP userUPP);
EXTERN_API(void)
DisposeCMMIterateUPP (CMMIterateUPP userUPP);
EXTERN_API(OSErr)
InvokeCMProfileIterateUPP (CMProfileIterateData * iterateData,
void * refCon,
CMProfileIterateUPP userUPP);
EXTERN_API(OSErr)
InvokeCMMIterateUPP (CMMInfo * iterateData,
void * refCon,
CMMIterateUPP userUPP);
else
enum { uppCMProfileIterateProcInfo = 0x000003E0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes) */
enum { uppCMMIterateProcInfo = 0x000003E0 }; /* pascal 2_bytes Func(4_bytes, 4_bytes) */
#define NewCMProfileIterateUPP(userRoutine) (CMProfileIterateUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMProfileIterateProcInfo, GetCurrentArchitecture())
#define NewCMMIterateUPP(userRoutine) (CMMIterateUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppCMMIterateProcInfo, GetCurrentArchitecture())
#define DisposeCMProfileIterateUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define DisposeCMMIterateUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#define InvokeCMProfileIterateUPP(iterateData, refCon, userUPP) (OSErr)CALL_TWO_PARAMETER_UPP((userUPP), uppCMProfileIterateProcInfo, (iterateData), (refCon))
#define InvokeCMMIterateUPP(iterateData, refCon, userUPP) (OSErr)CALL_TWO_PARAMETER_UPP((userUPP), uppCMMIterateProcInfo, (iterateData), (refCon))
endif
/* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
define NewCMProfileIterateProc(userRoutine) NewCMProfileIterateUPP(userRoutine)
define NewCMMIterateProc(userRoutine) NewCMMIterateUPP(userRoutine)
define CallCMProfileIterateProc(userRoutine, iterateData, refCon) InvokeCMProfileIterateUPP(iterateData, refCon, userRoutine)
define CallCMMIterateProc(userRoutine, iterateData, refCon) InvokeCMMIterateUPP(iterateData, refCon, userRoutine)
/* Profile file and element access */
EXTERN_API( CMError )
CMNewProfile (CMProfileRef * prof,
const CMProfileLocation * theProfile) FOURWORDINLINE(0x203C, 0x0008, 0x001B, 0xABEE);
EXTERN_API( CMError )
CMOpenProfile (CMProfileRef * prof,
const CMProfileLocation * theProfile) FOURWORDINLINE(0x203C, 0x0008, 0x001C, 0xABEE);
EXTERN_API( CMError )
CMCloseProfile (CMProfileRef prof) FOURWORDINLINE(0x203C, 0x0004, 0x001D, 0xABEE);
EXTERN_API( CMError )
CMUpdateProfile (CMProfileRef prof) FOURWORDINLINE(0x203C, 0x0004, 0x0034, 0xABEE);
EXTERN_API( CMError )
CMCopyProfile (CMProfileRef * targetProf,
const CMProfileLocation * targetLocation,
CMProfileRef srcProf) FOURWORDINLINE(0x203C, 0x000C, 0x0025, 0xABEE);
EXTERN_API( CMError )
CMValidateProfile (CMProfileRef prof,
Boolean * valid,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x000C, 0x0026, 0xABEE);
EXTERN_API( CMError )
CMGetProfileLocation (CMProfileRef prof,
CMProfileLocation * theProfile) FOURWORDINLINE(0x203C, 0x0008, 0x003C, 0xABEE);
EXTERN_API( CMError )
NCMGetProfileLocation (CMProfileRef prof,
CMProfileLocation * theProfile,
UInt32 * locationSize) FOURWORDINLINE(0x203C, 0x000C, 0x0059, 0xABEE);
EXTERN_API( CMError )
CMFlattenProfile (CMProfileRef prof,
UInt32 flags,
CMFlattenUPP proc,
void * refCon,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0014, 0x0031, 0xABEE);
if TARGET_OS_MAC
EXTERN_API( CMError )
CMUnflattenProfile (FSSpec * resultFileSpec,
CMFlattenUPP proc,
void * refCon,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0010, 0x0032, 0xABEE);
endif /* TARGET_OS_MAC */
EXTERN_API( CMError )
CMGetProfileHeader (CMProfileRef prof,
CMAppleProfileHeader * header) FOURWORDINLINE(0x203C, 0x0008, 0x0039, 0xABEE);
EXTERN_API( CMError )
CMSetProfileHeader (CMProfileRef prof,
const CMAppleProfileHeader * header) FOURWORDINLINE(0x203C, 0x0008, 0x003A, 0xABEE);
EXTERN_API( CMError )
CMProfileElementExists (CMProfileRef prof,
OSType tag,
Boolean * found) FOURWORDINLINE(0x203C, 0x000C, 0x001E, 0xABEE);
EXTERN_API( CMError )
CMCountProfileElements (CMProfileRef prof,
UInt32 * elementCount) FOURWORDINLINE(0x203C, 0x0008, 0x001F, 0xABEE);
EXTERN_API( CMError )
CMGetProfileElement (CMProfileRef prof,
OSType tag,
UInt32 * elementSize,
void * elementData) FOURWORDINLINE(0x203C, 0x0010, 0x0020, 0xABEE);
EXTERN_API( CMError )
CMSetProfileElement (CMProfileRef prof,
OSType tag,
UInt32 elementSize,
void * elementData) FOURWORDINLINE(0x203C, 0x0010, 0x0023, 0xABEE);
EXTERN_API( CMError )
CMSetProfileElementSize (CMProfileRef prof,
OSType tag,
UInt32 elementSize) FOURWORDINLINE(0x203C, 0x000C, 0x0038, 0xABEE);
EXTERN_API( CMError )
CMSetProfileElementReference (CMProfileRef prof,
OSType elementTag,
OSType referenceTag) FOURWORDINLINE(0x203C, 0x000C, 0x0035, 0xABEE);
EXTERN_API( CMError )
CMGetPartialProfileElement (CMProfileRef prof,
OSType tag,
UInt32 offset,
UInt32 * byteCount,
void * elementData) FOURWORDINLINE(0x203C, 0x0014, 0x0036, 0xABEE);
EXTERN_API( CMError )
CMSetPartialProfileElement (CMProfileRef prof,
OSType tag,
UInt32 offset,
UInt32 byteCount,
void * elementData) FOURWORDINLINE(0x203C, 0x0014, 0x0037, 0xABEE);
EXTERN_API( CMError )
CMGetIndProfileElementInfo (CMProfileRef prof,
UInt32 index,
OSType * tag,
UInt32 * elementSize,
Boolean * refs) FOURWORDINLINE(0x203C, 0x0014, 0x0021, 0xABEE);
EXTERN_API( CMError )
CMGetIndProfileElement (CMProfileRef prof,
UInt32 index,
UInt32 * elementSize,
void * elementData) FOURWORDINLINE(0x203C, 0x0010, 0x0022, 0xABEE);
EXTERN_API( CMError )
CMRemoveProfileElement (CMProfileRef prof,
OSType tag) FOURWORDINLINE(0x203C, 0x0008, 0x0024, 0xABEE);
EXTERN_API( CMError )
CMGetScriptProfileDescription (CMProfileRef prof,
Str255 name,
ScriptCode * code) FOURWORDINLINE(0x203C, 0x000C, 0x003E, 0xABEE);
EXTERN_API( CMError )
CMGetProfileDescriptions (CMProfileRef prof,
char * aName,
UInt32 * aCount,
Str255 mName,
ScriptCode * mCode,
UniChar * uName,
UniCharCount * uCount) FOURWORDINLINE(0x203C, 0x001A, 0x0067, 0xABEE);
EXTERN_API( CMError )
CMSetProfileDescriptions (CMProfileRef prof,
const char * aName,
UInt32 aCount,
ConstStr255Param mName,
ScriptCode mCode,
const UniChar * uName,
UniCharCount uCount) FOURWORDINLINE(0x203C, 0x001A, 0x0068, 0xABEE);
EXTERN_API( CMError )
CMCloneProfileRef (CMProfileRef prof) FOURWORDINLINE(0x203C, 0x0004, 0x0042, 0xABEE);
EXTERN_API( CMError )
CMGetProfileRefCount (CMProfileRef prof,
long * count) FOURWORDINLINE(0x203C, 0x0008, 0x0043, 0xABEE);
EXTERN_API( CMError )
CMProfileModified (CMProfileRef prof,
Boolean * modified) FOURWORDINLINE(0x203C, 0x0008, 0x0044, 0xABEE);
/* named Color access functions */
EXTERN_API( CMError )
CMGetNamedColorInfo (CMProfileRef prof,
UInt32 * deviceChannels,
OSType * deviceColorSpace,
OSType * PCSColorSpace,
UInt32 * count,
StringPtr prefix,
StringPtr suffix) FOURWORDINLINE(0x203C, 0x001C, 0x0046, 0xABEE);
EXTERN_API( CMError )
CMGetNamedColorValue (CMProfileRef prof,
StringPtr name,
CMColor * deviceColor,
CMColor * PCSColor) FOURWORDINLINE(0x203C, 0x0010, 0x0047, 0xABEE);
EXTERN_API( CMError )
CMGetIndNamedColorValue (CMProfileRef prof,
UInt32 index,
CMColor * deviceColor,
CMColor * PCSColor) FOURWORDINLINE(0x203C, 0x0010, 0x0048, 0xABEE);
EXTERN_API( CMError )
CMGetNamedColorIndex (CMProfileRef prof,
StringPtr name,
UInt32 * index) FOURWORDINLINE(0x203C, 0x000C, 0x0049, 0xABEE);
EXTERN_API( CMError )
CMGetNamedColorName (CMProfileRef prof,
UInt32 index,
StringPtr name) FOURWORDINLINE(0x203C, 0x000C, 0x004A, 0xABEE);
/* General-purpose matching functions */
EXTERN_API( CMError )
NCWNewColorWorld (CMWorldRef * cw,
CMProfileRef src,
CMProfileRef dst) FOURWORDINLINE(0x203C, 0x000C, 0x0014, 0xABEE);
EXTERN_API( CMError )
CWConcatColorWorld (CMWorldRef * cw,
CMConcatProfileSet * profileSet) FOURWORDINLINE(0x203C, 0x0008, 0x0015, 0xABEE);
EXTERN_API( CMError )
CWNewLinkProfile (CMProfileRef * prof,
const CMProfileLocation * targetLocation,
CMConcatProfileSet * profileSet) FOURWORDINLINE(0x203C, 0x000C, 0x0033, 0xABEE);
EXTERN_API( CMError )
NCWConcatColorWorld (CMWorldRef * cw,
NCMConcatProfileSet * profileSet,
CMConcatCallBackUPP proc,
void * refCon) FOURWORDINLINE(0x203C, 0x0008, 0x0061, 0xABEE);
EXTERN_API( CMError )
NCWNewLinkProfile (CMProfileRef * prof,
const CMProfileLocation * targetLocation,
NCMConcatProfileSet * profileSet,
CMConcatCallBackUPP proc,
void * refCon) FOURWORDINLINE(0x203C, 0x000C, 0x0062, 0xABEE);
EXTERN_API( void )
CWDisposeColorWorld (CMWorldRef cw) FOURWORDINLINE(0x203C, 0x0004, 0x0001, 0xABEE);
EXTERN_API( CMError )
CWMatchColors (CMWorldRef cw,
CMColor * myColors,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0002, 0xABEE);
EXTERN_API( CMError )
CWCheckColors (CMWorldRef cw,
CMColor * myColors,
UInt32 count,
UInt32 * result) FOURWORDINLINE(0x203C, 0x0010, 0x0003, 0xABEE);
EXTERN_API( CMError )
CWMatchBitmap (CMWorldRef cw,
CMBitmap * bitmap,
CMBitmapCallBackUPP progressProc,
void * refCon,
CMBitmap * matchedBitmap) FOURWORDINLINE(0x203C, 0x0010, 0x002C, 0xABEE);
EXTERN_API( CMError )
CWCheckBitmap (CMWorldRef cw,
const CMBitmap * bitmap,
CMBitmapCallBackUPP progressProc,
void * refCon,
CMBitmap * resultBitmap) FOURWORDINLINE(0x203C, 0x0014, 0x002D, 0xABEE);
/* Quickdraw-specific matching */
EXTERN_API( CMError )
CWMatchPixMap (CMWorldRef cw,
PixMap * myPixMap,
CMBitmapCallBackUPP progressProc,
void * refCon) FOURWORDINLINE(0x203C, 0x0010, 0x0004, 0xABEE);
EXTERN_API( CMError )
CWCheckPixMap (CMWorldRef cw,
PixMap * myPixMap,
CMBitmapCallBackUPP progressProc,
void * refCon,
BitMap * resultBitMap) FOURWORDINLINE(0x203C, 0x0014, 0x0007, 0xABEE);
if TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON
EXTERN_API( CMError )
NCMBeginMatching (CMProfileRef src,
CMProfileRef dst,
CMMatchRef * myRef) FOURWORDINLINE(0x203C, 0x000C, 0x0016, 0xABEE);
EXTERN_API( void )
CMEndMatching (CMMatchRef myRef) FOURWORDINLINE(0x203C, 0x0004, 0x000B, 0xABEE);
EXTERN_API( void )
NCMDrawMatchedPicture (PicHandle myPicture,
CMProfileRef dst,
Rect * myRect) FOURWORDINLINE(0x203C, 0x000C, 0x0017, 0xABEE);
EXTERN_API( void )
CMEnableMatchingComment (Boolean enableIt) FOURWORDINLINE(0x203C, 0x0002, 0x000D, 0xABEE);
EXTERN_API( CMError )
NCMUseProfileComment (CMProfileRef prof,
UInt32 flags) FOURWORDINLINE(0x203C, 0x0008, 0x003B, 0xABEE);
endif /* TARGET_API_MAC_OS8 || TARGET_API_MAC_CARBON */
if TARGET_OS_WIN32
if CALL_NOT_IN_CARBON
EXTERN_API( CMError )
CWMatchHBITMAP (CMWorldRef cw,
HBITMAP hBitmap,
CMBitmapCallBackUPP progressProc,
void * refCon);
endif /* CALL_NOT_IN_CARBON */
endif /* TARGET_OS_WIN32 */
EXTERN_API( CMError )
CMCreateProfileIdentifier (CMProfileRef prof,
CMProfileIdentifierPtr ident,
UInt32 * size) FOURWORDINLINE(0x203C, 0x000C, 0x0041, 0xABEE);
/* System Profile access */
EXTERN_API( CMError )
CMGetSystemProfile (CMProfileRef * prof) FOURWORDINLINE(0x203C, 0x0004, 0x0018, 0xABEE);
EXTERN_API( CMError )
CMSetSystemProfile (const FSSpec * profileFileSpec) FOURWORDINLINE(0x203C, 0x0004, 0x0019, 0xABEE);
EXTERN_API( CMError )
NCMSetSystemProfile (const CMProfileLocation * profLoc) FOURWORDINLINE(0x203C, 0x0004, 0x0064, 0xABEE);
EXTERN_API( CMError )
CMGetDefaultProfileBySpace (OSType dataColorSpace,
CMProfileRef * prof) FOURWORDINLINE(0x203C, 0x0008, 0x005A, 0xABEE);
EXTERN_API( CMError )
CMSetDefaultProfileBySpace (OSType dataColorSpace,
CMProfileRef prof) FOURWORDINLINE(0x203C, 0x0008, 0x005B, 0xABEE);
if TARGET_OS_MAC
EXTERN_API( CMError )
CMGetProfileByAVID (AVIDType theAVID,
CMProfileRef * prof) FOURWORDINLINE(0x203C, 0x0008, 0x005C, 0xABEE);
EXTERN_API( CMError )
CMSetProfileByAVID (AVIDType theAVID,
CMProfileRef prof) FOURWORDINLINE(0x203C, 0x0008, 0x005D, 0xABEE);
endif /* TARGET_OS_MAC */
/* Profile Use enumerations */
enum {
cmInputUse = FOUR_CHAR_CODE('inpt'),
cmOutputUse = FOUR_CHAR_CODE('outp'),
cmDisplayUse = FOUR_CHAR_CODE('dply'),
cmProofUse = FOUR_CHAR_CODE('pruf')
};
/* Profile access by Use */
EXTERN_API( CMError )
CMGetDefaultProfileByUse (OSType use,
CMProfileRef * prof) FOURWORDINLINE(0x203C, 0x0008, 0x0069, 0xABEE);
EXTERN_API( CMError )
CMSetDefaultProfileByUse (OSType use,
CMProfileRef prof) FOURWORDINLINE(0x203C, 0x0008, 0x0079, 0xABEE);
/* Profile Management */
EXTERN_API( CMError )
CMNewProfileSearch (CMSearchRecord * searchSpec,
void * refCon,
UInt32 * count,
CMProfileSearchRef * searchResult) FOURWORDINLINE(0x203C, 0x0010, 0x0027, 0xABEE);
EXTERN_API( CMError )
CMUpdateProfileSearch (CMProfileSearchRef search,
void * refCon,
UInt32 * count) FOURWORDINLINE(0x203C, 0x000C, 0x0028, 0xABEE);
EXTERN_API( void )
CMDisposeProfileSearch (CMProfileSearchRef search) FOURWORDINLINE(0x203C, 0x0004, 0x0029, 0xABEE);
EXTERN_API( CMError )
CMSearchGetIndProfile (CMProfileSearchRef search,
UInt32 index,
CMProfileRef * prof) FOURWORDINLINE(0x203C, 0x000C, 0x002A, 0xABEE);
EXTERN_API( CMError )
CMSearchGetIndProfileFileSpec (CMProfileSearchRef search,
UInt32 index,
FSSpec * profileFile) FOURWORDINLINE(0x203C, 0x000C, 0x002B, 0xABEE);
EXTERN_API( CMError )
CMProfileIdentifierFolderSearch (CMProfileIdentifierPtr ident,
UInt32 * matchedCount,
CMProfileSearchRef * searchResult) FOURWORDINLINE(0x203C, 0x000C, 0x003F, 0xABEE);
EXTERN_API( CMError )
CMProfileIdentifierListSearch (CMProfileIdentifierPtr ident,
CMProfileRef * profileList,
UInt32 listSize,
UInt32 * matchedCount,
CMProfileRef * matchedList) FOURWORDINLINE(0x203C, 0x0014, 0x0040, 0xABEE);
EXTERN_API( CMError )
CMIterateColorSyncFolder (CMProfileIterateUPP proc,
UInt32 * seed,
UInt32 * count,
void * refCon) FOURWORDINLINE(0x203C, 0x0010, 0x0058, 0xABEE);
EXTERN_API( CMError )
NCMUnflattenProfile (CMProfileLocation * targetLocation,
CMFlattenUPP proc,
void * refCon,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0010, 0x0065, 0xABEE);
/* Utilities */
if TARGET_OS_MAC
EXTERN_API( CMError )
CMGetColorSyncFolderSpec (short vRefNum,
Boolean createFolder,
short * foundVRefNum,
long * foundDirID) FOURWORDINLINE(0x203C, 0x000C, 0x0011, 0xABEE);
endif /* TARGET_OS_MAC */
if TARGET_OS_WIN32 || TARGET_OS_UNIX
if CALL_NOT_IN_CARBON
EXTERN_API( CMError )
CMGetColorSyncFolderPath (Boolean createFolder,
char * lpBuffer,
UInt32 uSize);
endif /* CALL_NOT_IN_CARBON */
endif /* TARGET_OS_WIN32 || TARGET_OS_UNIX */
EXTERN_API( CMError )
CMGetCWInfo (CMWorldRef cw,
CMCWInfoRecord * info) FOURWORDINLINE(0x203C, 0x0008, 0x001A, 0xABEE);
if TARGET_API_MAC_OS8
if CALL_NOT_IN_CARBON
EXTERN_API( CMError )
CMConvertProfile2to1 (CMProfileRef profv2,
CMProfileHandle * profv1) FOURWORDINLINE(0x203C, 0x0008, 0x0045, 0xABEE);
endif /* CALL_NOT_IN_CARBON */
endif /* TARGET_API_MAC_OS8 */
EXTERN_API( CMError )
CMGetPreferredCMM (OSType * cmmType,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0008, 0x005E, 0xABEE);
EXTERN_API( CMError )
CMIterateCMMInfo (CMMIterateUPP proc,
UInt32 * count,
void * refCon) FOURWORDINLINE(0x203C, 0x000C, 0x0063, 0xABEE);
EXTERN_API( CMError )
CMGetColorSyncVersion (UInt32 * version) FOURWORDINLINE(0x203C, 0x0004, 0x0066, 0xABEE);
EXTERN_API( CMError )
CMLaunchControlPanel (UInt32 flags);
/* ColorSpace conversion functions */
EXTERN_API( CMError )
CMConvertXYZToLab (const CMColor * src,
const CMXYZColor * white,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x0010, 0x004B, 0xABEE);
EXTERN_API( CMError )
CMConvertLabToXYZ (const CMColor * src,
const CMXYZColor * white,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x0010, 0x004C, 0xABEE);
EXTERN_API( CMError )
CMConvertXYZToLuv (const CMColor * src,
const CMXYZColor * white,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x0010, 0x004D, 0xABEE);
EXTERN_API( CMError )
CMConvertLuvToXYZ (const CMColor * src,
const CMXYZColor * white,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x0010, 0x004E, 0xABEE);
EXTERN_API( CMError )
CMConvertXYZToYxy (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x004F, 0xABEE);
EXTERN_API( CMError )
CMConvertYxyToXYZ (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0050, 0xABEE);
EXTERN_API( CMError )
CMConvertRGBToHLS (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0051, 0xABEE);
EXTERN_API( CMError )
CMConvertHLSToRGB (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0052, 0xABEE);
EXTERN_API( CMError )
CMConvertRGBToHSV (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0053, 0xABEE);
EXTERN_API( CMError )
CMConvertHSVToRGB (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0054, 0xABEE);
EXTERN_API( CMError )
CMConvertRGBToGray (const CMColor * src,
CMColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0055, 0xABEE);
EXTERN_API( CMError )
CMConvertXYZToFixedXYZ (const CMXYZColor * src,
CMFixedXYZColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0056, 0xABEE);
EXTERN_API( CMError )
CMConvertFixedXYZToXYZ (const CMFixedXYZColor * src,
CMXYZColor * dst,
UInt32 count) FOURWORDINLINE(0x203C, 0x000C, 0x0057, 0xABEE);
/* PS-related */
EXTERN_API( CMError )
CMGetPS2ColorSpace (CMProfileRef srcProf,
UInt32 flags,
CMFlattenUPP proc,
void * refCon,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0014, 0x002E, 0xABEE);
EXTERN_API( CMError )
CMGetPS2ColorRenderingIntent (CMProfileRef srcProf,
UInt32 flags,
CMFlattenUPP proc,
void * refCon,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0014, 0x002F, 0xABEE);
EXTERN_API( CMError )
CMGetPS2ColorRendering (CMProfileRef srcProf,
CMProfileRef dstProf,
UInt32 flags,
CMFlattenUPP proc,
void * refCon,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0018, 0x0030, 0xABEE);
EXTERN_API( CMError )
CMGetPS2ColorRenderingVMSize (CMProfileRef srcProf,
CMProfileRef dstProf,
UInt32 * vmSize,
Boolean * preferredCMMnotfound) FOURWORDINLINE(0x203C, 0x0010, 0x003D, 0xABEE);
/* ColorSync 1.0 functions which have parallel 2.0 counterparts */
if TARGET_API_MAC_OS8
if CALL_NOT_IN_CARBON
EXTERN_API( CMError )
CWNewColorWorld (CMWorldRef * cw,
CMProfileHandle src,
CMProfileHandle dst) FOURWORDINLINE(0x203C, 0x000C, 0x0000, 0xABEE);
EXTERN_API( CMError )
ConcatenateProfiles (CMProfileHandle thru,
CMProfileHandle dst,
CMProfileHandle * newDst) FOURWORDINLINE(0x203C, 0x000C, 0x000C, 0xABEE);
EXTERN_API( CMError )
CMBeginMatching (CMProfileHandle src,
CMProfileHandle dst,
CMMatchRef * myRef) FOURWORDINLINE(0x203C, 0x000C, 0x000A, 0xABEE);
EXTERN_API( void )
CMDrawMatchedPicture (PicHandle myPicture,
CMProfileHandle dst,
Rect * myRect) FOURWORDINLINE(0x203C, 0x000C, 0x0009, 0xABEE);
EXTERN_API( CMError )
CMUseProfileComment (CMProfileHandle profile) FOURWORDINLINE(0x203C, 0x0004, 0x0008, 0xABEE);
EXTERN_API( void )
CMGetProfileName (CMProfileHandle myProfile,
CMIString * IStringResult) FOURWORDINLINE(0x203C, 0x0008, 0x000E, 0xABEE);
EXTERN_API( long )
CMGetProfileAdditionalDataOffset (CMProfileHandle myProfile) FOURWORDINLINE(0x203C, 0x0004, 0x000F, 0xABEE);
/* ProfileResponder functions */
EXTERN_API( CMError )
GetProfile (OSType deviceType,
long refNum,
CMProfileHandle aProfile,
CMProfileHandle * returnedProfile) FOURWORDINLINE(0x203C, 0x0010, 0x0005, 0xABEE);
EXTERN_API( CMError )
SetProfile (OSType deviceType,
long refNum,
CMProfileHandle newProfile) FOURWORDINLINE(0x203C, 0x000C, 0x0006, 0xABEE);
EXTERN_API( CMError )
SetProfileDescription (OSType deviceType,
long refNum,
long deviceData,
CMProfileHandle hProfile) FOURWORDINLINE(0x203C, 0x0010, 0x0010, 0xABEE);
EXTERN_API( CMError )
GetIndexedProfile (OSType deviceType,
long refNum,
CMProfileSearchRecordHandle search,
CMProfileHandle * returnProfile,
long * index) FOURWORDINLINE(0x203C, 0x0014, 0x0012, 0xABEE);
EXTERN_API( CMError )
DeleteDeviceProfile (OSType deviceType,
long refNum,
CMProfileHandle deleteMe) FOURWORDINLINE(0x203C, 0x000C, 0x0013, 0xABEE);
endif /* CALL_NOT_IN_CARBON */
if OLDROUTINENAMES
/* constants */
typedef CMFlattenProcPtr CMFlattenProc;
typedef CMBitmapCallBackProcPtr CMBitmapCallBackProc;
typedef CMProfileFilterProcPtr CMProfileFilterProc;
enum {
CMTrap = cmTrap,
CMBeginProfile = cmBeginProfile,
CMEndProfile = cmEndProfile,
CMEnableMatching = cmEnableMatching,
CMDisableMatching = cmDisableMatching
};
/* 1.0 Error codes, for compatibility with older applications. 1.0 CMM's may return obsolete error codes */
enum {
CMNoError = 0, /* obsolete name, use noErr */
CMProfileError = cmProfileError,
CMMethodError = cmMethodError,
CMMemFullError = -172, /* obsolete, 2.0 uses memFullErr */
CMUnimplementedError = -173, /* obsolete, 2.0 uses unimpErr */
CMParamError = -174, /* obsolete, 2.0 uses paramErr */
CMMethodNotFound = cmMethodNotFound,
CMProfileNotFound = cmProfileNotFound,
CMProfilesIdentical = cmProfilesIdentical,
CMCantConcatenateError = cmCantConcatenateError,
CMCantXYZ = cmCantXYZ,
CMCantDeleteProfile = cmCantDeleteProfile,
CMUnsupportedDataType = cmUnsupportedDataType,
CMNoCurrentProfile = cmNoCurrentProfile
};
enum {
qdSystemDevice = cmSystemDevice,
qdGDevice = cmGDevice
};
enum {
kMatchCMMType = cmMatchCMMType,
kMatchApplProfileVersion = cmMatchApplProfileVersion,
kMatchDataType = cmMatchDataType,
kMatchDeviceType = cmMatchDeviceType,
kMatchDeviceManufacturer = cmMatchDeviceManufacturer,
kMatchDeviceModel = cmMatchDeviceModel,
kMatchDeviceAttributes = cmMatchDeviceAttributes,
kMatchFlags = cmMatchFlags,
kMatchOptions = cmMatchOptions,
kMatchWhite = cmMatchWhite,
kMatchBlack = cmMatchBlack
};
/* types */
typedef CMCMYKColor CMYKColor;
typedef CMWorldRef CWorld;
typedef long * CMGamutResult;
/* functions */
define EndMatching(myRef) CMEndMatching(myRef)
define EnableMatching(enableIt) CMEnableMatchingComment(enableIt)
define GetColorSyncFolderSpec(vRefNum, createFolder, foundVRefNum, foundDirID) CMGetColorSyncFolderSpec(vRefNum, createFolder, foundVRefNum, foundDirID)
define BeginMatching(src, dst, myRef) CMBeginMatching(src, dst, myRef)
define DrawMatchedPicture(myPicture, dst, myRect) CMDrawMatchedPicture(myPicture, dst, myRect)
define UseProfile(profile) CMUseProfileComment(profile)
define GetProfileName(myProfile, IStringResult) CMGetProfileName(myProfile, IStringResult)
define GetProfileAdditionalDataOffset(myProfile) CMGetProfileAdditionalDataOffset(myProfile)
endif /* OLDROUTINENAMES */
/* Deprecated stuff*/
/* PrGeneral parameter blocks */
struct TEnableColorMatchingBlk {
short iOpCode;
short iError;
long lReserved;
THPrint hPrint;
Boolean fEnableIt;
SInt8 filler;
};
typedef struct TEnableColorMatchingBlk TEnableColorMatchingBlk;
struct TRegisterProfileBlk {
short iOpCode;
short iError;
long lReserved;
THPrint hPrint;
Boolean fRegisterIt;
SInt8 filler;
};
typedef struct TRegisterProfileBlk TRegisterProfileBlk;
endif /* TARGET_API_MAC_OS8 */
if PRAGMA_STRUCT_ALIGN
#pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
endif
ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
endif
ifdef __cplusplus
}
endif
endif /* __CMAPPLICATION__ */
(C) Æliens
04/09/2009
You may not copy or print any of this material without explicit permission of the author or the publisher.
In case of other copyright issues, contact the author.
