Icons.h

Go to the documentation of this file.

 
#ifndef __ICONS__
#define __ICONS__
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __QUICKDRAW__
#include <Quickdraw.h>
#endif
 
#ifndef __FILES__
#include <Files.h>
#endif
 
#ifndef __CODEFRAGMENTS__
#include <CodeFragments.h>
#endif
 
#ifndef __CGCONTEXT__
#include <CGContext.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
 
  /* The following are icons for which there are both icon suites and SICNs. */
  /* Avoid using icon resources if possible. Use IconServices instead. */
  enum
  {
    kGenericDocumentIconResource = -4000,
    kGenericStationeryIconResource = -3985,
    kGenericEditionFileIconResource = -3989,
    kGenericApplicationIconResource = -3996,
    kGenericDeskAccessoryIconResource = -3991,
    kGenericFolderIconResource = -3999,
    kPrivateFolderIconResource = -3994,
    kFloppyIconResource = -3998,
    kTrashIconResource = -3993,
    kGenericRAMDiskIconResource = -3988,
    kGenericCDROMIconResource = -3987
  };
 
  /* The following are icons for which there are SICNs only. */
  /* Avoid using icon resources if possible. Use IconServices instead. */
  enum
  {
    kDesktopIconResource = -3992,
    kOpenFolderIconResource = -3997,
    kGenericHardDiskIconResource = -3995,
    kGenericFileServerIconResource = -3972,
    kGenericSuitcaseIconResource = -3970,
    kGenericMoverObjectIconResource = -3969
  };
 
  /* The following are icons for which there are icon suites only. */
  /* Avoid using icon resources if possible. Use IconServices instead. */
  enum
  {
    kGenericPreferencesIconResource = -3971,
    kGenericQueryDocumentIconResource = -16506,
    kGenericExtensionIconResource = -16415,
    kSystemFolderIconResource = -3983,
    kHelpIconResource = -20271,
    kAppleMenuFolderIconResource = -3982
  };
 
  /* Obsolete. Use named constants defined above. */
  enum
  {
    genericDocumentIconResource = kGenericDocumentIconResource,
    genericStationeryIconResource = kGenericStationeryIconResource,
    genericEditionFileIconResource = kGenericEditionFileIconResource,
    genericApplicationIconResource = kGenericApplicationIconResource,
    genericDeskAccessoryIconResource = kGenericDeskAccessoryIconResource,
    genericFolderIconResource = kGenericFolderIconResource,
    privateFolderIconResource = kPrivateFolderIconResource,
    floppyIconResource = kFloppyIconResource,
    trashIconResource = kTrashIconResource,
    genericRAMDiskIconResource = kGenericRAMDiskIconResource,
    genericCDROMIconResource = kGenericCDROMIconResource,
    desktopIconResource = kDesktopIconResource,
    openFolderIconResource = kOpenFolderIconResource,
    genericHardDiskIconResource = kGenericHardDiskIconResource,
    genericFileServerIconResource = kGenericFileServerIconResource,
    genericSuitcaseIconResource = kGenericSuitcaseIconResource,
    genericMoverObjectIconResource = kGenericMoverObjectIconResource,
    genericPreferencesIconResource = kGenericPreferencesIconResource,
    genericQueryDocumentIconResource = kGenericQueryDocumentIconResource,
    genericExtensionIconResource = kGenericExtensionIconResource,
    systemFolderIconResource = kSystemFolderIconResource,
    appleMenuFolderIconResource = kAppleMenuFolderIconResource
  };
 
  /* Avoid using icon resources if possible. Use IconServices instead. */
  enum
  {
    kStartupFolderIconResource = -3981,
    kOwnedFolderIconResource = -3980,
    kDropFolderIconResource = -3979,
    kSharedFolderIconResource = -3978,
    kMountedFolderIconResource = -3977,
    kControlPanelFolderIconResource = -3976,
    kPrintMonitorFolderIconResource = -3975,
    kPreferencesFolderIconResource = -3974,
    kExtensionsFolderIconResource = -3973,
    kFontsFolderIconResource = -3968,
    kFullTrashIconResource = -3984
  };
 
  /* Obsolete. Use named constants defined above. */
  enum
  {
    startupFolderIconResource = kStartupFolderIconResource,
    ownedFolderIconResource = kOwnedFolderIconResource,
    dropFolderIconResource = kDropFolderIconResource,
    sharedFolderIconResource = kSharedFolderIconResource,
    mountedFolderIconResource = kMountedFolderIconResource,
    controlPanelFolderIconResource = kControlPanelFolderIconResource,
    printMonitorFolderIconResource = kPrintMonitorFolderIconResource,
    preferencesFolderIconResource = kPreferencesFolderIconResource,
    extensionsFolderIconResource = kExtensionsFolderIconResource,
    fontsFolderIconResource = kFontsFolderIconResource,
    fullTrashIconResource = kFullTrashIconResource
  };
 
  /* The following icon types can only be used as an icon element */
  /* inside a 'icns' icon family */
  enum
  {
    kThumbnail32BitData = FOUR_CHAR_CODE('it32'),
    kThumbnail8BitMask = FOUR_CHAR_CODE('t8mk')
  };
 
  enum
  {
    kHuge1BitMask = FOUR_CHAR_CODE('ich#'),
    kHuge4BitData = FOUR_CHAR_CODE('ich4'),
    kHuge8BitData = FOUR_CHAR_CODE('ich8'),
    kHuge32BitData = FOUR_CHAR_CODE('ih32'),
    kHuge8BitMask = FOUR_CHAR_CODE('h8mk')
  };
 
  /* The following icon types can be used as a resource type */
  /* or as an icon element type inside a 'icns' icon family */
  enum
  {
    kLarge1BitMask = FOUR_CHAR_CODE('ICN#'),
    kLarge4BitData = FOUR_CHAR_CODE('icl4'),
    kLarge8BitData = FOUR_CHAR_CODE('icl8'),
    kLarge32BitData = FOUR_CHAR_CODE('il32'),
    kLarge8BitMask = FOUR_CHAR_CODE('l8mk'),
    kSmall1BitMask = FOUR_CHAR_CODE('ics#'),
    kSmall4BitData = FOUR_CHAR_CODE('ics4'),
    kSmall8BitData = FOUR_CHAR_CODE('ics8'),
    kSmall32BitData = FOUR_CHAR_CODE('is32'),
    kSmall8BitMask = FOUR_CHAR_CODE('s8mk'),
    kMini1BitMask = FOUR_CHAR_CODE('icm#'),
    kMini4BitData = FOUR_CHAR_CODE('icm4'),
    kMini8BitData = FOUR_CHAR_CODE('icm8')
  };
 
  /*  Icon Variants */
  /* These can be used as an element of an 'icns' icon family */
  /* or as a parameter to GetIconRefVariant */
  enum
  {
    kTileIconVariant = FOUR_CHAR_CODE('tile'),
    kRolloverIconVariant = FOUR_CHAR_CODE('over'),
    kDropIconVariant = FOUR_CHAR_CODE('drop'),
    kOpenIconVariant = FOUR_CHAR_CODE('open'),
    kOpenDropIconVariant = FOUR_CHAR_CODE('odrp')
  };
 
  /* Obsolete. Use names defined above. */
  enum
  {
    large1BitMask = kLarge1BitMask,
    large4BitData = kLarge4BitData,
    large8BitData = kLarge8BitData,
    small1BitMask = kSmall1BitMask,
    small4BitData = kSmall4BitData,
    small8BitData = kSmall8BitData,
    mini1BitMask = kMini1BitMask,
    mini4BitData = kMini4BitData,
    mini8BitData = kMini8BitData
  };
 
  /* Alignment type values. */
  enum
  {
    kAlignNone = 0x00,
    kAlignVerticalCenter = 0x01,
    kAlignTop = 0x02,
    kAlignBottom = 0x03,
    kAlignHorizontalCenter = 0x04,
    kAlignAbsoluteCenter = kAlignVerticalCenter | kAlignHorizontalCenter,
    kAlignCenterTop = kAlignTop | kAlignHorizontalCenter,
    kAlignCenterBottom = kAlignBottom | kAlignHorizontalCenter,
    kAlignLeft = 0x08,
    kAlignCenterLeft = kAlignVerticalCenter | kAlignLeft,
    kAlignTopLeft = kAlignTop | kAlignLeft,
    kAlignBottomLeft = kAlignBottom | kAlignLeft,
    kAlignRight = 0x0C,
    kAlignCenterRight = kAlignVerticalCenter | kAlignRight,
    kAlignTopRight = kAlignTop | kAlignRight,
    kAlignBottomRight = kAlignBottom | kAlignRight
  };
 
  /* Obsolete. Use names defined above. */
  enum
  {
    atNone = kAlignNone,
    atVerticalCenter = kAlignVerticalCenter,
    atTop = kAlignTop,
    atBottom = kAlignBottom,
    atHorizontalCenter = kAlignHorizontalCenter,
    atAbsoluteCenter = kAlignAbsoluteCenter,
    atCenterTop = kAlignCenterTop,
    atCenterBottom = kAlignCenterBottom,
    atLeft = kAlignLeft,
    atCenterLeft = kAlignCenterLeft,
    atTopLeft = kAlignTopLeft,
    atBottomLeft = kAlignBottomLeft,
    atRight = kAlignRight,
    atCenterRight = kAlignCenterRight,
    atTopRight = kAlignTopRight,
    atBottomRight = kAlignBottomRight
  };
 
  typedef SInt16 IconAlignmentType;
  /* Transform type values. */
  enum
  {
    kTransformNone = 0x00,
    kTransformDisabled = 0x01,
    kTransformOffline = 0x02,
    kTransformOpen = 0x03,
    kTransformLabel1 = 0x0100,
    kTransformLabel2 = 0x0200,
    kTransformLabel3 = 0x0300,
    kTransformLabel4 = 0x0400,
    kTransformLabel5 = 0x0500,
    kTransformLabel6 = 0x0600,
    kTransformLabel7 = 0x0700,
    kTransformSelected = 0x4000,
    kTransformSelectedDisabled = kTransformSelected | kTransformDisabled,
    kTransformSelectedOffline = kTransformSelected | kTransformOffline,
    kTransformSelectedOpen = kTransformSelected | kTransformOpen
  };
 
  /* Obsolete. Use names defined above. */
  enum
  {
    ttNone = kTransformNone,
    ttDisabled = kTransformDisabled,
    ttOffline = kTransformOffline,
    ttOpen = kTransformOpen,
    ttLabel1 = kTransformLabel1,
    ttLabel2 = kTransformLabel2,
    ttLabel3 = kTransformLabel3,
    ttLabel4 = kTransformLabel4,
    ttLabel5 = kTransformLabel5,
    ttLabel6 = kTransformLabel6,
    ttLabel7 = kTransformLabel7,
    ttSelected = kTransformSelected,
    ttSelectedDisabled = kTransformSelectedDisabled,
    ttSelectedOffline = kTransformSelectedOffline,
    ttSelectedOpen = kTransformSelectedOpen
  };
 
  typedef SInt16 IconTransformType;
  /* Selector mask values. */
  enum
  {
    kSelectorLarge1Bit = 0x00000001,
    kSelectorLarge4Bit = 0x00000002,
    kSelectorLarge8Bit = 0x00000004,
    kSelectorLarge32Bit = 0x00000008,
    kSelectorLarge8BitMask = 0x00000010,
    kSelectorSmall1Bit = 0x00000100,
    kSelectorSmall4Bit = 0x00000200,
    kSelectorSmall8Bit = 0x00000400,
    kSelectorSmall32Bit = 0x00000800,
    kSelectorSmall8BitMask = 0x00001000,
    kSelectorMini1Bit = 0x00010000,
    kSelectorMini4Bit = 0x00020000,
    kSelectorMini8Bit = 0x00040000,
    kSelectorHuge1Bit = 0x01000000,
    kSelectorHuge4Bit = 0x02000000,
    kSelectorHuge8Bit = 0x04000000,
    kSelectorHuge32Bit = 0x08000000,
    kSelectorHuge8BitMask = 0x10000000,
    kSelectorAllLargeData = 0x000000FF,
    kSelectorAllSmallData = 0x0000FF00,
    kSelectorAllMiniData = 0x00FF0000,
    kSelectorAllHugeData = (long)0xFF000000,
    kSelectorAll1BitData = kSelectorLarge1Bit | kSelectorSmall1Bit |
                           kSelectorMini1Bit | kSelectorHuge1Bit,
    kSelectorAll4BitData = kSelectorLarge4Bit | kSelectorSmall4Bit |
                           kSelectorMini4Bit | kSelectorHuge4Bit,
    kSelectorAll8BitData = kSelectorLarge8Bit | kSelectorSmall8Bit |
                           kSelectorMini8Bit | kSelectorHuge8Bit,
    kSelectorAll32BitData =
        kSelectorLarge32Bit | kSelectorSmall32Bit | kSelectorHuge32Bit,
    kSelectorAllAvailableData = (long)0xFFFFFFFF
  };
 
  /* Obsolete. Use names defined above. */
  enum
  {
    svLarge1Bit = kSelectorLarge1Bit,
    svLarge4Bit = kSelectorLarge4Bit,
    svLarge8Bit = kSelectorLarge8Bit,
    svSmall1Bit = kSelectorSmall1Bit,
    svSmall4Bit = kSelectorSmall4Bit,
    svSmall8Bit = kSelectorSmall8Bit,
    svMini1Bit = kSelectorMini1Bit,
    svMini4Bit = kSelectorMini4Bit,
    svMini8Bit = kSelectorMini8Bit,
    svAllLargeData = kSelectorAllLargeData,
    svAllSmallData = kSelectorAllSmallData,
    svAllMiniData = kSelectorAllMiniData,
    svAll1BitData = kSelectorAll1BitData,
    svAll4BitData = kSelectorAll4BitData,
    svAll8BitData = kSelectorAll8BitData,
    svAllAvailableData = kSelectorAllAvailableData
  };
 
  typedef UInt32 IconSelectorValue;
  typedef CALLBACK_API(OSErr, IconActionProcPtr)(ResType theType, Handle *theIcon,
                                                 void *yourDataPtr);
  typedef CALLBACK_API(Handle, IconGetterProcPtr)(ResType theType,
                                                  void *yourDataPtr);
  typedef STACK_UPP_TYPE(IconActionProcPtr) IconActionUPP;
  typedef STACK_UPP_TYPE(IconGetterProcPtr) IconGetterUPP;
  IconActionUPP
  NewIconActionUPP(IconActionProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppIconActionProcInfo = 0x00000FE0
  }; /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline IconActionUPP NewIconActionUPP(IconActionProcPtr userRoutine)
  {
    return (IconActionUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppIconActionProcInfo, GetCurrentArchitecture());
  }
#else
#define NewIconActionUPP(userRoutine)   \
  (IconActionUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppIconActionProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  IconGetterUPP
  NewIconGetterUPP(IconGetterProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppIconGetterProcInfo = 0x000003F0
  }; /* pascal 4_bytes Func(4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline IconGetterUPP NewIconGetterUPP(IconGetterProcPtr userRoutine)
  {
    return (IconGetterUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppIconGetterProcInfo, GetCurrentArchitecture());
  }
#else
#define NewIconGetterUPP(userRoutine)   \
  (IconGetterUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppIconGetterProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeIconActionUPP(IconActionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeIconActionUPP(IconActionUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeIconActionUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeIconGetterUPP(IconGetterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeIconGetterUPP(IconGetterUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeIconGetterUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSErr
  InvokeIconActionUPP(ResType theType, Handle *theIcon, void *yourDataPtr,
                      IconActionUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSErr InvokeIconActionUPP(ResType theType, Handle *theIcon,
                                   void *yourDataPtr, IconActionUPP userUPP)
  {
    return (OSErr)CALL_THREE_PARAMETER_UPP(userUPP, uppIconActionProcInfo,
                                           theType, theIcon, yourDataPtr);
  }
#else
#define InvokeIconActionUPP(theType, theIcon, yourDataPtr, userUPP)  \
  (OSErr) CALL_THREE_PARAMETER_UPP((userUPP), uppIconActionProcInfo, \
                                   (theType), (theIcon), (yourDataPtr))
#endif
#endif
 
  Handle
  InvokeIconGetterUPP(ResType theType, void *yourDataPtr, IconGetterUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Handle InvokeIconGetterUPP(ResType theType, void *yourDataPtr,
                                    IconGetterUPP userUPP)
  {
    return (Handle)CALL_TWO_PARAMETER_UPP(userUPP, uppIconGetterProcInfo, theType,
                                          yourDataPtr);
  }
#else
#define InvokeIconGetterUPP(theType, yourDataPtr, userUPP)                     \
  (Handle) CALL_TWO_PARAMETER_UPP((userUPP), uppIconGetterProcInfo, (theType), \
                                  (yourDataPtr))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewIconActionProc(userRoutine) NewIconActionUPP(userRoutine)
#define NewIconGetterProc(userRoutine) NewIconGetterUPP(userRoutine)
#define CallIconActionProc(userRoutine, theType, theIcon, yourDataPtr) \
  InvokeIconActionUPP(theType, theIcon, yourDataPtr, userRoutine)
#define CallIconGetterProc(userRoutine, theType, yourDataPtr) \
  InvokeIconGetterUPP(theType, yourDataPtr, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
  typedef IconGetterProcPtr IconGetter;
  typedef IconActionProcPtr IconAction;
  /* CIconHandle, GetCIcon(), PlotCIcon(), and DisposeCIcon() moved here from
   * Quickdraw.h*/
  struct CIcon
  {
    PixMap iconPMap;        /*the icon's pixMap*/
    BitMap iconMask;        /*the icon's mask*/
    BitMap iconBMap;        /*the icon's bitMap*/
    Handle iconData;        /*the icon's data*/
    SInt16 iconMaskData[1]; /*icon's mask and BitMap data*/
  };
  typedef struct CIcon CIcon;
  typedef CIcon *CIconPtr;
  typedef CIconPtr *CIconHandle;
  CIconHandle
  GetCIcon(SInt16 iconID);
 
  void
  PlotCIcon(const Rect *theRect, CIconHandle theIcon);
 
  void
  DisposeCIcon(CIconHandle theIcon);
 
  /* GetIcon and PlotIcon moved here from ToolUtils*/
  Handle
  GetIcon(SInt16 iconID);
 
  void
  PlotIcon(const Rect *theRect, Handle theIcon);
 
  typedef Handle IconSuiteRef;
  typedef Handle IconCacheRef;
  /* IconRefs are 32-bit values identifying cached icon data. IconRef 0 is
   * invalid.*/
  typedef struct OpaqueIconRef *IconRef;
  OSErr
  PlotIconID(const Rect *theRect, IconAlignmentType align,
             IconTransformType transform, SInt16 theResID);
 
  OSErr
  NewIconSuite(IconSuiteRef *theIconSuite);
 
  OSErr
  AddIconToSuite(Handle theIconData, IconSuiteRef theSuite, ResType theType);
 
  OSErr
  GetIconFromSuite(Handle *theIconData, IconSuiteRef theSuite, ResType theType);
 
  OSErr
  ForEachIconDo(IconSuiteRef theSuite, IconSelectorValue selector,
                IconActionUPP action, void *yourDataPtr);
 
  OSErr
  GetIconSuite(IconSuiteRef *theIconSuite, SInt16 theResID,
               IconSelectorValue selector);
 
  OSErr
  DisposeIconSuite(IconSuiteRef theIconSuite, Boolean disposeData);
 
  OSErr
  PlotIconSuite(const Rect *theRect, IconAlignmentType align,
                IconTransformType transform, IconSuiteRef theIconSuite);
 
  OSErr
  MakeIconCache(IconCacheRef *theCache, IconGetterUPP makeIcon, void *yourDataPtr);
 
  OSErr
  LoadIconCache(const Rect *theRect, IconAlignmentType align,
                IconTransformType transform, IconCacheRef theIconCache);
 
  OSErr
  PlotIconMethod(const Rect *theRect, IconAlignmentType align,
                 IconTransformType transform, IconGetterUPP theMethod,
                 void *yourDataPtr);
 
  OSErr
  GetLabel(SInt16 labelNumber, RGBColor *labelColor, Str255 labelString);
 
  Boolean
  PtInIconID(Point testPt, const Rect *iconRect, IconAlignmentType align,
             SInt16 iconID);
 
  Boolean
  PtInIconSuite(Point testPt, const Rect *iconRect, IconAlignmentType align,
                IconSuiteRef theIconSuite);
 
  Boolean
  PtInIconMethod(Point testPt, const Rect *iconRect, IconAlignmentType align,
                 IconGetterUPP theMethod, void *yourDataPtr);
 
  Boolean
  RectInIconID(const Rect *testRect, const Rect *iconRect,
               IconAlignmentType align, SInt16 iconID);
 
  Boolean
  RectInIconSuite(const Rect *testRect, const Rect *iconRect,
                  IconAlignmentType align, IconSuiteRef theIconSuite);
 
  Boolean
  RectInIconMethod(const Rect *testRect, const Rect *iconRect,
                   IconAlignmentType align, IconGetterUPP theMethod,
                   void *yourDataPtr);
 
  OSErr
  IconIDToRgn(RgnHandle theRgn, const Rect *iconRect, IconAlignmentType align,
              SInt16 iconID);
 
  OSErr
  IconSuiteToRgn(RgnHandle theRgn, const Rect *iconRect, IconAlignmentType align,
                 IconSuiteRef theIconSuite);
 
  OSErr
  IconMethodToRgn(RgnHandle theRgn, const Rect *iconRect, IconAlignmentType align,
                  IconGetterUPP theMethod, void *yourDataPtr);
 
  OSErr
  SetSuiteLabel(IconSuiteRef theSuite, SInt16 theLabel);
 
  SInt16
  GetSuiteLabel(IconSuiteRef theSuite);
 
  OSErr
  GetIconCacheData(IconCacheRef theCache, void **theData);
 
  OSErr
  SetIconCacheData(IconCacheRef theCache, void *theData);
 
  OSErr
  GetIconCacheProc(IconCacheRef theCache, IconGetterUPP *theProc);
 
  OSErr
  SetIconCacheProc(IconCacheRef theCache, IconGetterUPP theProc);
 
  OSErr
  PlotIconHandle(const Rect *theRect, IconAlignmentType align,
                 IconTransformType transform, Handle theIcon);
 
  OSErr
  PlotSICNHandle(const Rect *theRect, IconAlignmentType align,
                 IconTransformType transform, Handle theSICN);
 
  OSErr
  PlotCIconHandle(const Rect *theRect, IconAlignmentType align,
                  IconTransformType transform, CIconHandle theCIcon);
 
  enum
  {
    kSystemIconsCreator = FOUR_CHAR_CODE('macs')
  };
 
  /* Generic Finder icons */
  enum
  {
    kClipboardIcon = FOUR_CHAR_CODE('CLIP'),
    kClippingUnknownTypeIcon = FOUR_CHAR_CODE('clpu'),
    kClippingPictureTypeIcon = FOUR_CHAR_CODE('clpp'),
    kClippingTextTypeIcon = FOUR_CHAR_CODE('clpt'),
    kClippingSoundTypeIcon = FOUR_CHAR_CODE('clps'),
    kDesktopIcon = FOUR_CHAR_CODE('desk'),
    kFinderIcon = FOUR_CHAR_CODE('FNDR'),
    kFontSuitcaseIcon = FOUR_CHAR_CODE('FFIL'),
    kFullTrashIcon = FOUR_CHAR_CODE('ftrh'),
    kGenericApplicationIcon = FOUR_CHAR_CODE('APPL'),
    kGenericCDROMIcon = FOUR_CHAR_CODE('cddr'),
    kGenericControlPanelIcon = FOUR_CHAR_CODE('APPC'),
    kGenericControlStripModuleIcon = FOUR_CHAR_CODE('sdev'),
    kGenericComponentIcon = FOUR_CHAR_CODE('thng'),
    kGenericDeskAccessoryIcon = FOUR_CHAR_CODE('APPD'),
    kGenericDocumentIcon = FOUR_CHAR_CODE('docu'),
    kGenericEditionFileIcon = FOUR_CHAR_CODE('edtf'),
    kGenericExtensionIcon = FOUR_CHAR_CODE('INIT'),
    kGenericFileServerIcon = FOUR_CHAR_CODE('srvr'),
    kGenericFontIcon = FOUR_CHAR_CODE('ffil'),
    kGenericFontScalerIcon = FOUR_CHAR_CODE('sclr'),
    kGenericFloppyIcon = FOUR_CHAR_CODE('flpy'),
    kGenericHardDiskIcon = FOUR_CHAR_CODE('hdsk'),
    kGenericIDiskIcon = FOUR_CHAR_CODE('idsk'),
    kGenericRemovableMediaIcon = FOUR_CHAR_CODE('rmov'),
    kGenericMoverObjectIcon = FOUR_CHAR_CODE('movr'),
    kGenericPCCardIcon = FOUR_CHAR_CODE('pcmc'),
    kGenericPreferencesIcon = FOUR_CHAR_CODE('pref'),
    kGenericQueryDocumentIcon = FOUR_CHAR_CODE('qery'),
    kGenericRAMDiskIcon = FOUR_CHAR_CODE('ramd'),
    kGenericSharedLibaryIcon = FOUR_CHAR_CODE('shlb'),
    kGenericStationeryIcon = FOUR_CHAR_CODE('sdoc'),
    kGenericSuitcaseIcon = FOUR_CHAR_CODE('suit'),
    kGenericURLIcon = FOUR_CHAR_CODE('gurl'),
    kGenericWORMIcon = FOUR_CHAR_CODE('worm'),
    kInternationalResourcesIcon = FOUR_CHAR_CODE('ifil'),
    kKeyboardLayoutIcon = FOUR_CHAR_CODE('kfil'),
    kSoundFileIcon = FOUR_CHAR_CODE('sfil'),
    kSystemSuitcaseIcon = FOUR_CHAR_CODE('zsys'),
    kTrashIcon = FOUR_CHAR_CODE('trsh'),
    kTrueTypeFontIcon = FOUR_CHAR_CODE('tfil'),
    kTrueTypeFlatFontIcon = FOUR_CHAR_CODE('sfnt'),
    kTrueTypeMultiFlatFontIcon = FOUR_CHAR_CODE('ttcf'),
    kUserIDiskIcon = FOUR_CHAR_CODE('udsk'),
    kInternationResourcesIcon = kInternationalResourcesIcon /* old misspelling*/
  };
 
  /* Internet locations */
  enum
  {
    kInternetLocationHTTPIcon = FOUR_CHAR_CODE('ilht'),
    kInternetLocationFTPIcon = FOUR_CHAR_CODE('ilft'),
    kInternetLocationAppleShareIcon = FOUR_CHAR_CODE('ilaf'),
    kInternetLocationAppleTalkZoneIcon = FOUR_CHAR_CODE('ilat'),
    kInternetLocationFileIcon = FOUR_CHAR_CODE('ilfi'),
    kInternetLocationMailIcon = FOUR_CHAR_CODE('ilma'),
    kInternetLocationNewsIcon = FOUR_CHAR_CODE('ilnw'),
    kInternetLocationNSLNeighborhoodIcon = FOUR_CHAR_CODE('ilns'),
    kInternetLocationGenericIcon = FOUR_CHAR_CODE('ilge')
  };
 
  /* Folders */
  enum
  {
    kGenericFolderIcon = FOUR_CHAR_CODE('fldr'),
    kDropFolderIcon = FOUR_CHAR_CODE('dbox'),
    kMountedFolderIcon = FOUR_CHAR_CODE('mntd'),
    kOpenFolderIcon = FOUR_CHAR_CODE('ofld'),
    kOwnedFolderIcon = FOUR_CHAR_CODE('ownd'),
    kPrivateFolderIcon = FOUR_CHAR_CODE('prvf'),
    kSharedFolderIcon = FOUR_CHAR_CODE('shfl')
  };
 
  /* Sharing Privileges icons */
  enum
  {
    kSharingPrivsNotApplicableIcon = FOUR_CHAR_CODE('shna'),
    kSharingPrivsReadOnlyIcon = FOUR_CHAR_CODE('shro'),
    kSharingPrivsReadWriteIcon = FOUR_CHAR_CODE('shrw'),
    kSharingPrivsUnknownIcon = FOUR_CHAR_CODE('shuk'),
    kSharingPrivsWritableIcon = FOUR_CHAR_CODE('writ')
  };
 
  /* Users and Groups icons */
  enum
  {
    kUserFolderIcon = FOUR_CHAR_CODE('ufld'),
    kWorkgroupFolderIcon = FOUR_CHAR_CODE('wfld'),
    kGuestUserIcon = FOUR_CHAR_CODE('gusr'),
    kUserIcon = FOUR_CHAR_CODE('user'),
    kOwnerIcon = FOUR_CHAR_CODE('susr'),
    kGroupIcon = FOUR_CHAR_CODE('grup')
  };
 
  /* Special folders */
  enum
  {
    kAppearanceFolderIcon = FOUR_CHAR_CODE('appr'),
    kAppleExtrasFolderIcon = FOUR_CHAR_CODE('aex�'),
    kAppleMenuFolderIcon = FOUR_CHAR_CODE('amnu'),
    kApplicationsFolderIcon = FOUR_CHAR_CODE('apps'),
    kApplicationSupportFolderIcon = FOUR_CHAR_CODE('asup'),
    kAssistantsFolderIcon = FOUR_CHAR_CODE('ast�'),
    kColorSyncFolderIcon = FOUR_CHAR_CODE('prof'),
    kContextualMenuItemsFolderIcon = FOUR_CHAR_CODE('cmnu'),
    kControlPanelDisabledFolderIcon = FOUR_CHAR_CODE('ctrD'),
    kControlPanelFolderIcon = FOUR_CHAR_CODE('ctrl'),
    kControlStripModulesFolderIcon = FOUR_CHAR_CODE('sdv�'),
    kDocumentsFolderIcon = FOUR_CHAR_CODE('docs'),
    kExtensionsDisabledFolderIcon = FOUR_CHAR_CODE('extD'),
    kExtensionsFolderIcon = FOUR_CHAR_CODE('extn'),
    kFavoritesFolderIcon = FOUR_CHAR_CODE('favs'),
    kFontsFolderIcon = FOUR_CHAR_CODE('font'),
    kHelpFolderIcon = FOUR_CHAR_CODE('�hlp'),
    kInternetFolderIcon = FOUR_CHAR_CODE('int�'),
    kInternetPlugInFolderIcon = FOUR_CHAR_CODE('�net'),
    kInternetSearchSitesFolderIcon = FOUR_CHAR_CODE('issf'),
    kLocalesFolderIcon = FOUR_CHAR_CODE('�loc'),
    kMacOSReadMeFolderIcon = FOUR_CHAR_CODE('mor�'),
    kPublicFolderIcon = FOUR_CHAR_CODE('pubf'),
    kPreferencesFolderIcon = FOUR_CHAR_CODE('prf�'),
    kPrinterDescriptionFolderIcon = FOUR_CHAR_CODE('ppdf'),
    kPrinterDriverFolderIcon = FOUR_CHAR_CODE('�prd'),
    kPrintMonitorFolderIcon = FOUR_CHAR_CODE('prnt'),
    kRecentApplicationsFolderIcon = FOUR_CHAR_CODE('rapp'),
    kRecentDocumentsFolderIcon = FOUR_CHAR_CODE('rdoc'),
    kRecentServersFolderIcon = FOUR_CHAR_CODE('rsrv'),
    kScriptingAdditionsFolderIcon = FOUR_CHAR_CODE('�scr'),
    kSharedLibrariesFolderIcon = FOUR_CHAR_CODE('�lib'),
    kScriptsFolderIcon = FOUR_CHAR_CODE('scr�'),
    kShutdownItemsDisabledFolderIcon = FOUR_CHAR_CODE('shdD'),
    kShutdownItemsFolderIcon = FOUR_CHAR_CODE('shdf'),
    kSpeakableItemsFolder = FOUR_CHAR_CODE('spki'),
    kStartupItemsDisabledFolderIcon = FOUR_CHAR_CODE('strD'),
    kStartupItemsFolderIcon = FOUR_CHAR_CODE('strt'),
    kSystemExtensionDisabledFolderIcon = FOUR_CHAR_CODE('macD'),
    kSystemFolderIcon = FOUR_CHAR_CODE('macs'),
    kTextEncodingsFolderIcon = FOUR_CHAR_CODE('�tex'),
    kUsersFolderIcon = FOUR_CHAR_CODE('usr�'),
    kUtilitiesFolderIcon = FOUR_CHAR_CODE('uti�'),
    kVoicesFolderIcon = FOUR_CHAR_CODE('fvoc')
  };
 
  /* Badges */
  enum
  {
    kAppleScriptBadgeIcon = FOUR_CHAR_CODE('scrp'),
    kLockedBadgeIcon = FOUR_CHAR_CODE('lbdg'),
    kMountedBadgeIcon = FOUR_CHAR_CODE('mbdg'),
    kSharedBadgeIcon = FOUR_CHAR_CODE('sbdg'),
    kAliasBadgeIcon = FOUR_CHAR_CODE('abdg'),
    kAlertCautionBadgeIcon = FOUR_CHAR_CODE('cbdg')
  };
 
  /* Alert icons */
  enum
  {
    kAlertNoteIcon = FOUR_CHAR_CODE('note'),
    kAlertCautionIcon = FOUR_CHAR_CODE('caut'),
    kAlertStopIcon = FOUR_CHAR_CODE('stop')
  };
 
  /* Networking icons */
  enum
  {
    kAppleTalkIcon = FOUR_CHAR_CODE('atlk'),
    kAppleTalkZoneIcon = FOUR_CHAR_CODE('atzn'),
    kAFPServerIcon = FOUR_CHAR_CODE('afps'),
    kFTPServerIcon = FOUR_CHAR_CODE('ftps'),
    kHTTPServerIcon = FOUR_CHAR_CODE('htps'),
    kGenericNetworkIcon = FOUR_CHAR_CODE('gnet'),
    kIPFileServerIcon = FOUR_CHAR_CODE('isrv')
  };
 
  /* Toolbar icons */
  enum
  {
    kToolbarCustomizeIcon = FOUR_CHAR_CODE('tcus'),
    kToolbarDeleteIcon = FOUR_CHAR_CODE('tdel'),
    kToolbarFavoritesIcon = FOUR_CHAR_CODE('tfav'),
    kToolbarHomeIcon = FOUR_CHAR_CODE('thom')
  };
 
  /* Other icons */
  enum
  {
    kAppleLogoIcon = FOUR_CHAR_CODE('capl'),
    kAppleMenuIcon = FOUR_CHAR_CODE('sapl'),
    kBackwardArrowIcon = FOUR_CHAR_CODE('baro'),
    kFavoriteItemsIcon = FOUR_CHAR_CODE('favr'),
    kForwardArrowIcon = FOUR_CHAR_CODE('faro'),
    kGridIcon = FOUR_CHAR_CODE('grid'),
    kHelpIcon = FOUR_CHAR_CODE('help'),
    kKeepArrangedIcon = FOUR_CHAR_CODE('arng'),
    kLockedIcon = FOUR_CHAR_CODE('lock'),
    kNoFilesIcon = FOUR_CHAR_CODE('nfil'),
    kNoFolderIcon = FOUR_CHAR_CODE('nfld'),
    kNoWriteIcon = FOUR_CHAR_CODE('nwrt'),
    kProtectedApplicationFolderIcon = FOUR_CHAR_CODE('papp'),
    kProtectedSystemFolderIcon = FOUR_CHAR_CODE('psys'),
    kRecentItemsIcon = FOUR_CHAR_CODE('rcnt'),
    kShortcutIcon = FOUR_CHAR_CODE('shrt'),
    kSortAscendingIcon = FOUR_CHAR_CODE('asnd'),
    kSortDescendingIcon = FOUR_CHAR_CODE('dsnd'),
    kUnlockedIcon = FOUR_CHAR_CODE('ulck'),
    kConnectToIcon = FOUR_CHAR_CODE('cnct'),
    kGenericWindowIcon = FOUR_CHAR_CODE('gwin'),
    kQuestionMarkIcon = FOUR_CHAR_CODE('ques'),
    kDeleteAliasIcon = FOUR_CHAR_CODE('dali'),
    kEjectMediaIcon = FOUR_CHAR_CODE('ejec'),
    kBurningIcon = FOUR_CHAR_CODE('burn'),
    kRightContainerArrowIcon = FOUR_CHAR_CODE('rcar')
  };
 
  //  IconServicesUsageFlags
  typedef UInt32 IconServicesUsageFlags;
  enum
  {
    kIconServicesNormalUsageFlag = 0
  };
 
  enum
  {
    kIconServicesCatalogInfoMask =
        (kFSCatInfoNodeID | kFSCatInfoParentDirID | kFSCatInfoVolume |
         kFSCatInfoNodeFlags | kFSCatInfoFinderInfo | kFSCatInfoFinderXInfo |
         kFSCatInfoUserAccess)
  };
 
  typedef UInt32 PlotIconRefFlags;
  enum
  {
 
    kPlotIconRefNormalFlags = 0L,
 
    kPlotIconRefNoImage = (1 << 1),
 
    kPlotIconRefNoMask = (1 << 2)
  };
 
  enum
  {
    kIconFamilyType = FOUR_CHAR_CODE('icns')
  };
 
  struct IconFamilyElement
  {
    OSType elementType; /* 'ICN#', 'icl8', etc...*/
    Size elementSize;   /* Size of this element*/
    unsigned char elementData[1];
  };
  typedef struct IconFamilyElement IconFamilyElement;
  struct IconFamilyResource
  {
    OSType resourceType; /* Always 'icns'*/
    Size resourceSize;   /* Total size of this resource*/
    IconFamilyElement elements[1];
  };
  typedef struct IconFamilyResource IconFamilyResource;
  typedef IconFamilyResource *IconFamilyPtr;
  typedef IconFamilyPtr *IconFamilyHandle;
#if CALL_NOT_IN_CARBON
  OSErr
  IconServicesInit(CFragInitBlockPtr initBlockPtr);
 
  void
  IconServicesTerminate(void);
 
#endif /* CALL_NOT_IN_CARBON */
 
  OSErr
  IconRefToIconFamily(IconRef theIconRef, IconSelectorValue whichIcons,
                      IconFamilyHandle *iconFamily);
 
  OSErr
  IconFamilyToIconSuite(IconFamilyHandle iconFamily, IconSelectorValue whichIcons,
                        IconSuiteRef *iconSuite);
 
  OSErr
  IconSuiteToIconFamily(IconSuiteRef iconSuite, IconSelectorValue whichIcons,
                        IconFamilyHandle *iconFamily);
 
  OSErr
  SetIconFamilyData(IconFamilyHandle iconFamily, OSType iconType, Handle h);
 
  OSErr
  GetIconFamilyData(IconFamilyHandle iconFamily, OSType iconType, Handle h);
 
  OSErr
  GetIconRefOwners(IconRef theIconRef, UInt16 *owners);
 
  OSErr
  AcquireIconRef(IconRef theIconRef);
 
  OSErr
  ReleaseIconRef(IconRef theIconRef);
 
  OSErr
  GetIconRefFromFile(const FSSpec *theFile, IconRef *theIconRef, SInt16 *theLabel);
 
  OSErr
  GetIconRef(SInt16 vRefNum, OSType creator, OSType iconType, IconRef *theIconRef);
 
  OSErr
  GetIconRefFromFolder(SInt16 vRefNum, SInt32 parentFolderID, SInt32 folderID,
                       SInt8 attributes, SInt8 accessPrivileges,
                       IconRef *theIconRef);
 
  /* GetIconRefFromFileInfo*/
  OSStatus
  GetIconRefFromFileInfo(const FSRef *inRef, UniCharCount inFileNameLength,
                         const UniChar *inFileName, /* can be NULL */
                         FSCatalogInfoBitmap inWhichInfo,
                         const FSCatalogInfo *inCatalogInfo, /* can be NULL */
                         IconServicesUsageFlags inUsageFlags, IconRef *outIconRef,
                         SInt16 *outLabel);
 
  OSErr
  RegisterIconRefFromIconFamily(OSType creator, OSType iconType,
                                IconFamilyHandle iconFamily, IconRef *theIconRef);
 
  OSErr
  RegisterIconRefFromResource(OSType creator, OSType iconType,
                              const FSSpec *resourceFile, SInt16 resourceID,
                              IconRef *theIconRef);
 
  /* RegisterIconRefFromFSRef*/
  OSStatus
  RegisterIconRefFromFSRef(OSType creator, OSType iconType, const FSRef *iconFile,
                           IconRef *theIconRef);
 
  OSErr
  UnregisterIconRef(OSType creator, OSType iconType);
 
  OSErr
  UpdateIconRef(IconRef theIconRef);
 
  OSErr
  OverrideIconRefFromResource(IconRef theIconRef, const FSSpec *resourceFile,
                              SInt16 resourceID);
 
  OSErr
  OverrideIconRef(IconRef oldIconRef, IconRef newIconRef);
 
  OSErr
  RemoveIconRefOverride(IconRef theIconRef);
 
  OSErr
  CompositeIconRef(IconRef backgroundIconRef, IconRef foregroundIconRef,
                   IconRef *compositeIconRef);
 
  OSErr
  IsIconRefComposite(IconRef compositeIconRef, IconRef *backgroundIconRef,
                     IconRef *foregroundIconRef);
 
  Boolean
  IsValidIconRef(IconRef theIconRef);
 
  OSErr
  PlotIconRef(const Rect *theRect, IconAlignmentType align,
              IconTransformType transform,
              IconServicesUsageFlags theIconServicesUsageFlags,
              IconRef theIconRef);
 
  /* PlotIconRefInContext*/
  OSStatus
  PlotIconRefInContext(CGContextRef inContext, const CGRect *inRect,
                       IconAlignmentType inAlign, IconTransformType inTransform,
                       const RGBColor *inLabelColor, PlotIconRefFlags inFlags,
                       IconRef inIconRef);
 
  Boolean
  PtInIconRef(const Point *testPt, const Rect *iconRect, IconAlignmentType align,
              IconServicesUsageFlags theIconServicesUsageFlags,
              IconRef theIconRef);
 
  Boolean
  RectInIconRef(const Rect *testRect, const Rect *iconRect,
                IconAlignmentType align,
                IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef);
 
  OSErr
  IconRefToRgn(RgnHandle theRgn, const Rect *iconRect, IconAlignmentType align,
               IconServicesUsageFlags iconServicesUsageFlags, IconRef theIconRef);
 
  OSErr
  GetIconSizesFromIconRef(IconSelectorValue iconSelectorInput,
                          IconSelectorValue *iconSelectorOutputPtr,
                          IconServicesUsageFlags iconServicesUsageFlags,
                          IconRef theIconRef);
 
  OSErr
  FlushIconRefs(OSType creator, OSType iconType);
 
  OSErr
  FlushIconRefsByVolume(SInt16 vRefNum);
 
  OSErr
  SetCustomIconsEnabled(SInt16 vRefNum, Boolean enableCustomIcons);
 
  OSErr
  GetCustomIconsEnabled(SInt16 vRefNum, Boolean *customIconsEnabled);
 
  Boolean
  IsIconRefMaskEmpty(IconRef iconRef);
 
  IconRef
  GetIconRefVariant(IconRef inIconRef, OSType inVariant,
                    IconTransformType *outTransform);
 
  OSErr
  RegisterIconRefFromIconFile(OSType creator, OSType iconType,
                              const FSSpec *iconFile, IconRef *theIconRef);
 
  OSErr
  ReadIconFile(const FSSpec *iconFile, IconFamilyHandle *iconFamily);
 
  /* ReadIconFromFSRef*/
  OSStatus
  ReadIconFromFSRef(const FSRef *ref, IconFamilyHandle *iconFamily);
 
  OSErr
  WriteIconFile(IconFamilyHandle iconFamily, const FSSpec *iconFile);
 
#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 /* __ICONS__ */
* / or disposing the iconFamily
               * /
 
           OSErr
           ReadIconFile(const FSSpec *iconFile, IconFamilyHandle *iconFamily);
 
/* ReadIconFromFSRef*/
OSStatus
ReadIconFromFSRef(const FSRef *ref, IconFamilyHandle *iconFamily);
 
OSErr WriteIconFile(IconFamilyHandle iconFamily, const FSSpec *iconFile);
 
#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 /* __ICONS__ */
* /*/*/ * /*/*/ * /*/*/ * /*/*/ */*/