Quickdraw.h

Go to the documentation of this file.

 
#ifndef __QUICKDRAW__
#define __QUICKDRAW__
 
#ifndef __COMPONENTS__
#include <Components.h>
#endif
 
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
 
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
 
#ifndef __QUICKDRAWTEXT__
#include <QuickdrawText.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
 
  enum
  {
    invalColReq = -1 /*invalid color table request*/
  };
 
  enum
  {
    /* transfer modes */
    srcCopy = 0, /*the 16 transfer modes*/
    srcOr = 1,
    srcXor = 2,
    srcBic = 3,
    notSrcCopy = 4,
    notSrcOr = 5,
    notSrcXor = 6,
    notSrcBic = 7,
    patCopy = 8,
    patOr = 9,
    patXor = 10,
    patBic = 11,
    notPatCopy = 12,
    notPatOr = 13,
    notPatXor = 14,
    notPatBic = 15, /* Special Text Transfer Mode */
    grayishTextOr = 49,
    hilitetransfermode = 50,
    hilite = 50, /* Arithmetic transfer modes */
    blend = 32,
    addPin = 33,
    addOver = 34,
    subPin = 35,
    addMax = 37,
    adMax = 37,
    subOver = 38,
    adMin = 39,
    ditherCopy = 64, /* Transparent mode constant */
    transparent = 36
  };
 
  enum
  {
    italicBit = 1,
    ulineBit = 2,
    outlineBit = 3,
    shadowBit = 4,
    condenseBit = 5,
    extendBit = 6
  };
 
  enum
  {
    /* QuickDraw color separation constants */
    normalBit = 0,  /*normal screen mapping*/
    inverseBit = 1, /*inverse screen mapping*/
    redBit = 4,     /*RGB additive mapping*/
    greenBit = 3,
    blueBit = 2,
    cyanBit = 8, /*CMYBk subtractive mapping*/
    magentaBit = 7,
    yellowBit = 6,
    blackBit = 5
  };
 
  enum
  {
    blackColor = 33, /*colors expressed in these mappings*/
    whiteColor = 30,
    redColor = 205,
    greenColor = 341,
    blueColor = 409,
    cyanColor = 273,
    magentaColor = 137,
    yellowColor = 69
  };
 
  enum
  {
    picLParen = 0, /*standard picture comments*/
    picRParen = 1,
    clutType = 0,   /*0 if lookup table*/
    fixedType = 1,  /*1 if fixed table*/
    directType = 2, /*2 if direct values*/
    gdDevType = 0   /*0 = monochrome 1 = color*/
  };
 
  enum
  {
    interlacedDevice = 2, /* 1 if single pixel lines look bad */
    hwMirroredDevice = 4, /* 1 if device is HW mirrored */
    roundedDevice = 5,    /* 1 if device has been �rounded� into the GrayRgn */
    hasAuxMenuBar = 6,    /* 1 if device has an aux menu bar on it */
    burstDevice = 7,
    ext32Device = 8,
    ramInit = 10,      /*1 if initialized from 'scrn' resource*/
    mainScreen = 11,   /* 1 if main screen */
    allInit = 12,      /* 1 if all devices initialized */
    screenDevice = 13, /*1 if screen device [not used]*/
    noDriver = 14,     /* 1 if no driver for this GDevice */
    screenActive = 15, /*1 if in use*/
    hiliteBit = 7,     /*flag bit in LMGet/SetHiliteMode*/
    pHiliteBit = 0,    /*flag bit in LMGet/SetHiliteMode when used with BitClr*/
    defQDColors = 127, /*resource ID of clut for default QDColors*/
                       /* pixel type */
    RGBDirect = 16,    /* 16 & 32 bits/pixel pixelType value */
                       /* pmVersion values */
    baseAddr32 = 4     /*pixmap base address is 32-bit address*/
  };
 
  enum
  {
    sysPatListID = 0,
    iBeamCursor = 1,
    crossCursor = 2,
    plusCursor = 3,
    watchCursor = 4
  };
 
  enum
  {
    kQDGrafVerbFrame = 0,
    kQDGrafVerbPaint = 1,
    kQDGrafVerbErase = 2,
    kQDGrafVerbInvert = 3,
    kQDGrafVerbFill = 4
  };
 
#if OLDROUTINENAMES
  enum
  {
    frame = kQDGrafVerbFrame,
    paint = kQDGrafVerbPaint,
    erase = kQDGrafVerbErase,
    invert = kQDGrafVerbInvert,
    fill = kQDGrafVerbFill
  };
 
#endif /* OLDROUTINENAMES */
 
  typedef SInt8 GrafVerb;
  enum
  {
    chunky = 0,
    chunkyPlanar = 1,
    planar = 2
  };
 
  typedef SInt8 PixelType;
  typedef short Bits16[16];
 
  /***************   IMPORTANT NOTE REGARDING Pattern
  ************************************** Patterns were originally defined as:
 
          C:          typedef unsigned char Pattern[8];
          Pascal:     Pattern = PACKED ARRAY [0..7] OF 0..255;
 
     The old array definition of Pattern would cause 68000 based CPU's to crash in
  certain circum- stances. The new struct definition is safe, but may require
  source code changes to compile.
 
  *********************************************************************************************/
  struct Pattern
  {
    UInt8 pat[8];
  };
  typedef struct Pattern Pattern;
  typedef const Pattern *ConstPatternParam;
  typedef Pattern *PatPtr;
  typedef PatPtr *PatHandle;
  typedef SignedByte QDByte;
  typedef QDByte *QDPtr;
  typedef QDPtr *QDHandle;
  typedef short QDErr;
  enum
  {
    singleDevicesBit = 0,
    dontMatchSeedsBit = 1,
    allDevicesBit = 2
  };
 
  enum
  {
    singleDevices = 1 << singleDevicesBit,
    dontMatchSeeds = 1 << dontMatchSeedsBit,
    allDevices = 1 << allDevicesBit
  };
 
  typedef unsigned long DeviceLoopFlags;
  typedef SInt32 PrinterStatusOpcode;
  enum
  {
    kPrinterFontStatus = 0,
    kPrinterScalingStatus = 1
  };
 
  struct PrinterFontStatus
  {
    SInt32 oResult;
    SInt16 iFondID;
    Style iStyle;
  };
  typedef struct PrinterFontStatus PrinterFontStatus;
  struct PrinterScalingStatus
  {
    Point oScalingFactors;
  };
  typedef struct PrinterScalingStatus PrinterScalingStatus;
  struct BitMap
  {
    Ptr baseAddr;
    short rowBytes;
    Rect bounds;
  };
  typedef struct BitMap BitMap;
  typedef BitMap *BitMapPtr;
  typedef BitMapPtr *BitMapHandle;
  struct Cursor
  {
    Bits16 data;
    Bits16 mask;
    Point hotSpot;
  };
  typedef struct Cursor Cursor;
  typedef Cursor *CursPtr;
  typedef CursPtr *CursHandle;
  struct PenState
  {
    Point pnLoc;
    Point pnSize;
    short pnMode;
    Pattern pnPat;
  };
  typedef struct PenState PenState;
#if !OPAQUE_TOOLBOX_STRUCTS
  struct MacRegion
  {
    unsigned short rgnSize; /* size in bytes; don't rely on it */
    Rect rgnBBox;           /* enclosing rectangle; in Carbon use GetRegionBounds */
  };
  typedef struct MacRegion MacRegion;
#if TARGET_OS_MAC
  typedef MacRegion Region;
#endif /* TARGET_OS_MAC */
 
  typedef MacRegion *RgnPtr;
  typedef RgnPtr *RgnHandle;
#else
typedef struct OpaqueRgnHandle *RgnHandle;
#endif /* !OPAQUE_TOOLBOX_STRUCTS */
 
  struct Picture
  {
    short picSize;
    Rect picFrame;
  };
  typedef struct Picture Picture;
  typedef Picture *PicPtr;
  typedef PicPtr *PicHandle;
  struct MacPolygon
  {
    short polySize;
    Rect polyBBox;
    Point polyPoints[1];
  };
  typedef struct MacPolygon MacPolygon;
#if TARGET_OS_MAC
  typedef MacPolygon Polygon;
#endif /* TARGET_OS_MAC */
 
  typedef MacPolygon *PolyPtr;
  typedef PolyPtr *PolyHandle;
  typedef CALLBACK_API(void, QDTextProcPtr)(short byteCount, const void *textBuf,
                                            Point numer, Point denom);
  typedef CALLBACK_API(void, QDLineProcPtr)(Point newPt);
  typedef CALLBACK_API(void, QDRectProcPtr)(GrafVerb verb, const Rect *r);
  typedef CALLBACK_API(void, QDRRectProcPtr)(GrafVerb verb, const Rect *r,
                                             short ovalWidth, short ovalHeight);
  typedef CALLBACK_API(void, QDOvalProcPtr)(GrafVerb verb, const Rect *r);
  typedef CALLBACK_API(void, QDArcProcPtr)(GrafVerb verb, const Rect *r,
                                           short startAngle, short arcAngle);
  typedef CALLBACK_API(void, QDPolyProcPtr)(GrafVerb verb, PolyHandle poly);
  typedef CALLBACK_API(void, QDRgnProcPtr)(GrafVerb verb, RgnHandle rgn);
  typedef CALLBACK_API(void, QDBitsProcPtr)(const BitMap *srcBits,
                                            const Rect *srcRect,
                                            const Rect *dstRect, short mode,
                                            RgnHandle maskRgn);
  typedef CALLBACK_API(void, QDCommentProcPtr)(short kind, short dataSize,
                                               Handle dataHandle);
  typedef CALLBACK_API(short, QDTxMeasProcPtr)(short byteCount,
                                               const void *textAddr, Point *numer,
                                               Point *denom, FontInfo *info);
  typedef CALLBACK_API(void, QDGetPicProcPtr)(void *dataPtr, short byteCount);
  typedef CALLBACK_API(void, QDPutPicProcPtr)(const void *dataPtr,
                                              short byteCount);
  typedef CALLBACK_API(void, QDOpcodeProcPtr)(const Rect *fromRect,
                                              const Rect *toRect, UInt16 opcode,
                                              SInt16 version);
  typedef CALLBACK_API_C(OSStatus, QDStdGlyphsProcPtr)(void *dataStream,
                                                       ByteCount size);
  typedef CALLBACK_API(void, QDJShieldCursorProcPtr)(short left, short top,
                                                     short right, short bottom);
  typedef STACK_UPP_TYPE(QDTextProcPtr) QDTextUPP;
  typedef STACK_UPP_TYPE(QDLineProcPtr) QDLineUPP;
  typedef STACK_UPP_TYPE(QDRectProcPtr) QDRectUPP;
  typedef STACK_UPP_TYPE(QDRRectProcPtr) QDRRectUPP;
  typedef STACK_UPP_TYPE(QDOvalProcPtr) QDOvalUPP;
  typedef STACK_UPP_TYPE(QDArcProcPtr) QDArcUPP;
  typedef STACK_UPP_TYPE(QDPolyProcPtr) QDPolyUPP;
  typedef STACK_UPP_TYPE(QDRgnProcPtr) QDRgnUPP;
  typedef STACK_UPP_TYPE(QDBitsProcPtr) QDBitsUPP;
  typedef STACK_UPP_TYPE(QDCommentProcPtr) QDCommentUPP;
  typedef STACK_UPP_TYPE(QDTxMeasProcPtr) QDTxMeasUPP;
  typedef STACK_UPP_TYPE(QDGetPicProcPtr) QDGetPicUPP;
  typedef STACK_UPP_TYPE(QDPutPicProcPtr) QDPutPicUPP;
  typedef STACK_UPP_TYPE(QDOpcodeProcPtr) QDOpcodeUPP;
  typedef STACK_UPP_TYPE(QDStdGlyphsProcPtr) QDStdGlyphsUPP;
  typedef STACK_UPP_TYPE(QDJShieldCursorProcPtr) QDJShieldCursorUPP;
  struct QDProcs
  {
    QDTextUPP textProc;
    QDLineUPP lineProc;
    QDRectUPP rectProc;
    QDRRectUPP rRectProc;
    QDOvalUPP ovalProc;
    QDArcUPP arcProc;
    QDPolyUPP polyProc;
    QDRgnUPP rgnProc;
    QDBitsUPP bitsProc;
    QDCommentUPP commentProc;
    QDTxMeasUPP txMeasProc;
    QDGetPicUPP getPicProc;
    QDPutPicUPP putPicProc;
  };
  typedef struct QDProcs QDProcs;
  typedef QDProcs *QDProcsPtr;
  QDTextUPP
  NewQDTextUPP(QDTextProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDTextProcInfo = 0x00003F80
  }; /* pascal no_return_value Func(2_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline QDTextUPP NewQDTextUPP(QDTextProcPtr userRoutine)
  {
    return (QDTextUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDTextProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDTextUPP(userRoutine)                                             \
  (QDTextUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDTextProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  QDLineUPP
  NewQDLineUPP(QDLineProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDLineProcInfo = 0x000000C0
  }; /* pascal no_return_value Func(4_bytes) */
#ifdef __cplusplus
  inline QDLineUPP NewQDLineUPP(QDLineProcPtr userRoutine)
  {
    return (QDLineUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDLineProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDLineUPP(userRoutine)                                             \
  (QDLineUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDLineProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  QDRectUPP
  NewQDRectUPP(QDRectProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDRectProcInfo = 0x00000340
  }; /* pascal no_return_value Func(1_byte, 4_bytes) */
#ifdef __cplusplus
  inline QDRectUPP NewQDRectUPP(QDRectProcPtr userRoutine)
  {
    return (QDRectUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDRectProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDRectUPP(userRoutine)                                             \
  (QDRectUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDRectProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  QDRRectUPP
  NewQDRRectUPP(QDRRectProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDRRectProcInfo = 0x00002B40
  }; /* pascal no_return_value Func(1_byte, 4_bytes, 2_bytes, 2_bytes) */
#ifdef __cplusplus
  inline QDRRectUPP NewQDRRectUPP(QDRRectProcPtr userRoutine)
  {
    return (QDRRectUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDRRectProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDRRectUPP(userRoutine)   \
  (QDRRectUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppQDRRectProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  QDOvalUPP
  NewQDOvalUPP(QDOvalProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDOvalProcInfo = 0x00000340
  }; /* pascal no_return_value Func(1_byte, 4_bytes) */
#ifdef __cplusplus
  inline QDOvalUPP NewQDOvalUPP(QDOvalProcPtr userRoutine)
  {
    return (QDOvalUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDOvalProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDOvalUPP(userRoutine)                                             \
  (QDOvalUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDOvalProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  QDArcUPP
  NewQDArcUPP(QDArcProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDArcProcInfo = 0x00002B40
  }; /* pascal no_return_value Func(1_byte, 4_bytes, 2_bytes, 2_bytes) */
#ifdef __cplusplus
  inline QDArcUPP NewQDArcUPP(QDArcProcPtr userRoutine)
  {
    return (QDArcUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDArcProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDArcUPP(userRoutine)                                            \
  (QDArcUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDArcProcInfo, \
                                  GetCurrentArchitecture())
#endif
#endif
 
  QDPolyUPP
  NewQDPolyUPP(QDPolyProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDPolyProcInfo = 0x00000340
  }; /* pascal no_return_value Func(1_byte, 4_bytes) */
#ifdef __cplusplus
  inline QDPolyUPP NewQDPolyUPP(QDPolyProcPtr userRoutine)
  {
    return (QDPolyUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDPolyProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDPolyUPP(userRoutine)                                             \
  (QDPolyUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDPolyProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  QDRgnUPP
  NewQDRgnUPP(QDRgnProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDRgnProcInfo = 0x00000340
  }; /* pascal no_return_value Func(1_byte, 4_bytes) */
#ifdef __cplusplus
  inline QDRgnUPP NewQDRgnUPP(QDRgnProcPtr userRoutine)
  {
    return (QDRgnUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDRgnProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDRgnUPP(userRoutine)                                            \
  (QDRgnUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDRgnProcInfo, \
                                  GetCurrentArchitecture())
#endif
#endif
 
  QDBitsUPP
  NewQDBitsUPP(QDBitsProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDBitsProcInfo = 0x0000EFC0
  }; /* pascal no_return_value Func(4_bytes, 4_bytes, 4_bytes, 2_bytes, 4_bytes)
      */
#ifdef __cplusplus
  inline QDBitsUPP NewQDBitsUPP(QDBitsProcPtr userRoutine)
  {
    return (QDBitsUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDBitsProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDBitsUPP(userRoutine)                                             \
  (QDBitsUPP) NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDBitsProcInfo, \
                                   GetCurrentArchitecture())
#endif
#endif
 
  QDCommentUPP
  NewQDCommentUPP(QDCommentProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDCommentProcInfo = 0x00000E80
  }; /* pascal no_return_value Func(2_bytes, 2_bytes, 4_bytes) */
#ifdef __cplusplus
  inline QDCommentUPP NewQDCommentUPP(QDCommentProcPtr userRoutine)
  {
    return (QDCommentUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDCommentProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDCommentUPP(userRoutine)   \
  (QDCommentUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppQDCommentProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  QDTxMeasUPP
  NewQDTxMeasUPP(QDTxMeasProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDTxMeasProcInfo = 0x0000FFA0
  }; /* pascal 2_bytes Func(2_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline QDTxMeasUPP NewQDTxMeasUPP(QDTxMeasProcPtr userRoutine)
  {
    return (QDTxMeasUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDTxMeasProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDTxMeasUPP(userRoutine)   \
  (QDTxMeasUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppQDTxMeasProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  QDGetPicUPP
  NewQDGetPicUPP(QDGetPicProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDGetPicProcInfo = 0x000002C0
  }; /* pascal no_return_value Func(4_bytes, 2_bytes) */
#ifdef __cplusplus
  inline QDGetPicUPP NewQDGetPicUPP(QDGetPicProcPtr userRoutine)
  {
    return (QDGetPicUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDGetPicProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDGetPicUPP(userRoutine)   \
  (QDGetPicUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppQDGetPicProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  QDPutPicUPP
  NewQDPutPicUPP(QDPutPicProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDPutPicProcInfo = 0x000002C0
  }; /* pascal no_return_value Func(4_bytes, 2_bytes) */
#ifdef __cplusplus
  inline QDPutPicUPP NewQDPutPicUPP(QDPutPicProcPtr userRoutine)
  {
    return (QDPutPicUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDPutPicProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDPutPicUPP(userRoutine)   \
  (QDPutPicUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppQDPutPicProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  QDOpcodeUPP
  NewQDOpcodeUPP(QDOpcodeProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDOpcodeProcInfo = 0x00002BC0
  }; /* pascal no_return_value Func(4_bytes, 4_bytes, 2_bytes, 2_bytes) */
#ifdef __cplusplus
  inline QDOpcodeUPP NewQDOpcodeUPP(QDOpcodeProcPtr userRoutine)
  {
    return (QDOpcodeUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDOpcodeProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDOpcodeUPP(userRoutine)   \
  (QDOpcodeUPP) NewRoutineDescriptor( \
      (ProcPtr)(userRoutine), uppQDOpcodeProcInfo, GetCurrentArchitecture())
#endif
#endif
 
  QDStdGlyphsUPP
  NewQDStdGlyphsUPP(QDStdGlyphsProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDStdGlyphsProcInfo = 0x000003F1
  }; /* 4_bytes Func(4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline QDStdGlyphsUPP NewQDStdGlyphsUPP(QDStdGlyphsProcPtr userRoutine)
  {
    return (QDStdGlyphsUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppQDStdGlyphsProcInfo, GetCurrentArchitecture());
  }
#else
#define NewQDStdGlyphsUPP(userRoutine)                                     \
  (QDStdGlyphsUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDStdGlyphsProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  QDJShieldCursorUPP
  NewQDJShieldCursorUPP(QDJShieldCursorProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDJShieldCursorProcInfo = 0x00002A80
  }; /* pascal no_return_value Func(2_bytes, 2_bytes, 2_bytes, 2_bytes) */
#ifdef __cplusplus
  inline QDJShieldCursorUPP
  NewQDJShieldCursorUPP(QDJShieldCursorProcPtr userRoutine)
  {
    return (QDJShieldCursorUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppQDJShieldCursorProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewQDJShieldCursorUPP(userRoutine)                                     \
  (QDJShieldCursorUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDJShieldCursorProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeQDTextUPP(QDTextUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDTextUPP(QDTextUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDTextUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDLineUPP(QDLineUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDLineUPP(QDLineUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDLineUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDRectUPP(QDRectUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDRectUPP(QDRectUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDRectUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDRRectUPP(QDRRectUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDRRectUPP(QDRRectUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDRRectUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDOvalUPP(QDOvalUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDOvalUPP(QDOvalUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDOvalUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDArcUPP(QDArcUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDArcUPP(QDArcUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDArcUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDPolyUPP(QDPolyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDPolyUPP(QDPolyUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDPolyUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDRgnUPP(QDRgnUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDRgnUPP(QDRgnUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDRgnUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDBitsUPP(QDBitsUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDBitsUPP(QDBitsUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDBitsUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDCommentUPP(QDCommentUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDCommentUPP(QDCommentUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDCommentUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDTxMeasUPP(QDTxMeasUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDTxMeasUPP(QDTxMeasUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDTxMeasUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDGetPicUPP(QDGetPicUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDGetPicUPP(QDGetPicUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDGetPicUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDPutPicUPP(QDPutPicUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDPutPicUPP(QDPutPicUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDPutPicUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDOpcodeUPP(QDOpcodeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDOpcodeUPP(QDOpcodeUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDOpcodeUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDStdGlyphsUPP(QDStdGlyphsUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDStdGlyphsUPP(QDStdGlyphsUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDStdGlyphsUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeQDJShieldCursorUPP(QDJShieldCursorUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDJShieldCursorUPP(QDJShieldCursorUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDJShieldCursorUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeQDTextUPP(short byteCount, const void *textBuf, Point numer, Point denom,
                  QDTextUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDTextUPP(short byteCount, const void *textBuf, Point numer,
                              Point denom, QDTextUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppQDTextProcInfo, byteCount, textBuf, numer,
                            denom);
  }
#else
#define InvokeQDTextUPP(byteCount, textBuf, numer, denom, userUPP)   \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppQDTextProcInfo, (byteCount), \
                          (textBuf), (numer), (denom))
#endif
#endif
 
  void
  InvokeQDLineUPP(Point newPt, QDLineUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDLineUPP(Point newPt, QDLineUPP userUPP)
  {
    CALL_ONE_PARAMETER_UPP(userUPP, uppQDLineProcInfo, newPt);
  }
#else
#define InvokeQDLineUPP(newPt, userUPP) \
  CALL_ONE_PARAMETER_UPP((userUPP), uppQDLineProcInfo, (newPt))
#endif
#endif
 
  void
  InvokeQDRectUPP(GrafVerb verb, const Rect *r, QDRectUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDRectUPP(GrafVerb verb, const Rect *r, QDRectUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppQDRectProcInfo, verb, r);
  }
#else
#define InvokeQDRectUPP(verb, r, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppQDRectProcInfo, (verb), (r))
#endif
#endif
 
  void
  InvokeQDRRectUPP(GrafVerb verb, const Rect *r, short ovalWidth,
                   short ovalHeight, QDRRectUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDRRectUPP(GrafVerb verb, const Rect *r, short ovalWidth,
                               short ovalHeight, QDRRectUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppQDRRectProcInfo, verb, r, ovalWidth,
                            ovalHeight);
  }
#else
#define InvokeQDRRectUPP(verb, r, ovalWidth, ovalHeight, userUPP)     \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppQDRRectProcInfo, (verb), (r), \
                          (ovalWidth), (ovalHeight))
#endif
#endif
 
  void
  InvokeQDOvalUPP(GrafVerb verb, const Rect *r, QDOvalUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDOvalUPP(GrafVerb verb, const Rect *r, QDOvalUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppQDOvalProcInfo, verb, r);
  }
#else
#define InvokeQDOvalUPP(verb, r, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppQDOvalProcInfo, (verb), (r))
#endif
#endif
 
  void
  InvokeQDArcUPP(GrafVerb verb, const Rect *r, short startAngle, short arcAngle,
                 QDArcUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDArcUPP(GrafVerb verb, const Rect *r, short startAngle,
                             short arcAngle, QDArcUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppQDArcProcInfo, verb, r, startAngle,
                            arcAngle);
  }
#else
#define InvokeQDArcUPP(verb, r, startAngle, arcAngle, userUPP)      \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppQDArcProcInfo, (verb), (r), \
                          (startAngle), (arcAngle))
#endif
#endif
 
  void
  InvokeQDPolyUPP(GrafVerb verb, PolyHandle poly, QDPolyUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDPolyUPP(GrafVerb verb, PolyHandle poly, QDPolyUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppQDPolyProcInfo, verb, poly);
  }
#else
#define InvokeQDPolyUPP(verb, poly, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppQDPolyProcInfo, (verb), (poly))
#endif
#endif
 
  void
  InvokeQDRgnUPP(GrafVerb verb, RgnHandle rgn, QDRgnUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDRgnUPP(GrafVerb verb, RgnHandle rgn, QDRgnUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppQDRgnProcInfo, verb, rgn);
  }
#else
#define InvokeQDRgnUPP(verb, rgn, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppQDRgnProcInfo, (verb), (rgn))
#endif
#endif
 
  void
  InvokeQDBitsUPP(const BitMap *srcBits, const Rect *srcRect, const Rect *dstRect,
                  short mode, RgnHandle maskRgn, QDBitsUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDBitsUPP(const BitMap *srcBits, const Rect *srcRect,
                              const Rect *dstRect, short mode, RgnHandle maskRgn,
                              QDBitsUPP userUPP)
  {
    CALL_FIVE_PARAMETER_UPP(userUPP, uppQDBitsProcInfo, srcBits, srcRect, dstRect,
                            mode, maskRgn);
  }
#else
#define InvokeQDBitsUPP(srcBits, srcRect, dstRect, mode, maskRgn, userUPP)    \
  CALL_FIVE_PARAMETER_UPP((userUPP), uppQDBitsProcInfo, (srcBits), (srcRect), \
                          (dstRect), (mode), (maskRgn))
#endif
#endif
 
  void
  InvokeQDCommentUPP(short kind, short dataSize, Handle dataHandle,
                     QDCommentUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDCommentUPP(short kind, short dataSize, Handle dataHandle,
                                 QDCommentUPP userUPP)
  {
    CALL_THREE_PARAMETER_UPP(userUPP, uppQDCommentProcInfo, kind, dataSize,
                             dataHandle);
  }
#else
#define InvokeQDCommentUPP(kind, dataSize, dataHandle, userUPP)     \
  CALL_THREE_PARAMETER_UPP((userUPP), uppQDCommentProcInfo, (kind), \
                           (dataSize), (dataHandle))
#endif
#endif
 
  short
  InvokeQDTxMeasUPP(short byteCount, const void *textAddr, Point *numer,
                    Point *denom, FontInfo *info, QDTxMeasUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline short InvokeQDTxMeasUPP(short byteCount, const void *textAddr,
                                 Point *numer, Point *denom, FontInfo *info,
                                 QDTxMeasUPP userUPP)
  {
    return (short)CALL_FIVE_PARAMETER_UPP(userUPP, uppQDTxMeasProcInfo, byteCount,
                                          textAddr, numer, denom, info);
  }
#else
#define InvokeQDTxMeasUPP(byteCount, textAddr, numer, denom, info, userUPP)   \
  (short)CALL_FIVE_PARAMETER_UPP((userUPP), uppQDTxMeasProcInfo, (byteCount), \
                                 (textAddr), (numer), (denom), (info))
#endif
#endif
 
  void
  InvokeQDGetPicUPP(void *dataPtr, short byteCount, QDGetPicUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDGetPicUPP(void *dataPtr, short byteCount,
                                QDGetPicUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppQDGetPicProcInfo, dataPtr, byteCount);
  }
#else
#define InvokeQDGetPicUPP(dataPtr, byteCount, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppQDGetPicProcInfo, (dataPtr), (byteCount))
#endif
#endif
 
  void
  InvokeQDPutPicUPP(const void *dataPtr, short byteCount, QDPutPicUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDPutPicUPP(const void *dataPtr, short byteCount,
                                QDPutPicUPP userUPP)
  {
    CALL_TWO_PARAMETER_UPP(userUPP, uppQDPutPicProcInfo, dataPtr, byteCount);
  }
#else
#define InvokeQDPutPicUPP(dataPtr, byteCount, userUPP) \
  CALL_TWO_PARAMETER_UPP((userUPP), uppQDPutPicProcInfo, (dataPtr), (byteCount))
#endif
#endif
 
  void
  InvokeQDOpcodeUPP(const Rect *fromRect, const Rect *toRect, UInt16 opcode,
                    SInt16 version, QDOpcodeUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDOpcodeUPP(const Rect *fromRect, const Rect *toRect,
                                UInt16 opcode, SInt16 version,
                                QDOpcodeUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppQDOpcodeProcInfo, fromRect, toRect,
                            opcode, version);
  }
#else
#define InvokeQDOpcodeUPP(fromRect, toRect, opcode, version, userUPP) \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppQDOpcodeProcInfo, (fromRect), \
                          (toRect), (opcode), (version))
#endif
#endif
 
  OSStatus
  InvokeQDStdGlyphsUPP(void *dataStream, ByteCount size, QDStdGlyphsUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeQDStdGlyphsUPP(void *dataStream, ByteCount size,
                                       QDStdGlyphsUPP userUPP)
  {
    return (OSStatus)CALL_TWO_PARAMETER_UPP(userUPP, uppQDStdGlyphsProcInfo,
                                            dataStream, size);
  }
#else
#define InvokeQDStdGlyphsUPP(dataStream, size, userUPP)                \
  (OSStatus) CALL_TWO_PARAMETER_UPP((userUPP), uppQDStdGlyphsProcInfo, \
                                    (dataStream), (size))
#endif
#endif
 
  void
  InvokeQDJShieldCursorUPP(short left, short top, short right, short bottom,
                           QDJShieldCursorUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeQDJShieldCursorUPP(short left, short top, short right,
                                       short bottom, QDJShieldCursorUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppQDJShieldCursorProcInfo, left, top, right,
                            bottom);
  }
#else
#define InvokeQDJShieldCursorUPP(left, top, right, bottom, userUPP)      \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppQDJShieldCursorProcInfo, (left), \
                          (top), (right), (bottom))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewQDTextProc(userRoutine) NewQDTextUPP(userRoutine)
#define NewQDLineProc(userRoutine) NewQDLineUPP(userRoutine)
#define NewQDRectProc(userRoutine) NewQDRectUPP(userRoutine)
#define NewQDRRectProc(userRoutine) NewQDRRectUPP(userRoutine)
#define NewQDOvalProc(userRoutine) NewQDOvalUPP(userRoutine)
#define NewQDArcProc(userRoutine) NewQDArcUPP(userRoutine)
#define NewQDPolyProc(userRoutine) NewQDPolyUPP(userRoutine)
#define NewQDRgnProc(userRoutine) NewQDRgnUPP(userRoutine)
#define NewQDBitsProc(userRoutine) NewQDBitsUPP(userRoutine)
#define NewQDCommentProc(userRoutine) NewQDCommentUPP(userRoutine)
#define NewQDTxMeasProc(userRoutine) NewQDTxMeasUPP(userRoutine)
#define NewQDGetPicProc(userRoutine) NewQDGetPicUPP(userRoutine)
#define NewQDPutPicProc(userRoutine) NewQDPutPicUPP(userRoutine)
#define NewQDOpcodeProc(userRoutine) NewQDOpcodeUPP(userRoutine)
#define NewQDStdGlyphsProc(userRoutine) NewQDStdGlyphsUPP(userRoutine)
#define NewQDJShieldCursorProc(userRoutine) NewQDJShieldCursorUPP(userRoutine)
#define CallQDTextProc(userRoutine, byteCount, textBuf, numer, denom) \
  InvokeQDTextUPP(byteCount, textBuf, numer, denom, userRoutine)
#define CallQDLineProc(userRoutine, newPt) InvokeQDLineUPP(newPt, userRoutine)
#define CallQDRectProc(userRoutine, verb, r) \
  InvokeQDRectUPP(verb, r, userRoutine)
#define CallQDRRectProc(userRoutine, verb, r, ovalWidth, ovalHeight) \
  InvokeQDRRectUPP(verb, r, ovalWidth, ovalHeight, userRoutine)
#define CallQDOvalProc(userRoutine, verb, r) \
  InvokeQDOvalUPP(verb, r, userRoutine)
#define CallQDArcProc(userRoutine, verb, r, startAngle, arcAngle) \
  InvokeQDArcUPP(verb, r, startAngle, arcAngle, userRoutine)
#define CallQDPolyProc(userRoutine, verb, poly) \
  InvokeQDPolyUPP(verb, poly, userRoutine)
#define CallQDRgnProc(userRoutine, verb, rgn) \
  InvokeQDRgnUPP(verb, rgn, userRoutine)
#define CallQDBitsProc(userRoutine, srcBits, srcRect, dstRect, mode, maskRgn) \
  InvokeQDBitsUPP(srcBits, srcRect, dstRect, mode, maskRgn, userRoutine)
#define CallQDCommentProc(userRoutine, kind, dataSize, dataHandle) \
  InvokeQDCommentUPP(kind, dataSize, dataHandle, userRoutine)
#define CallQDTxMeasProc(userRoutine, byteCount, textAddr, numer, denom, info) \
  InvokeQDTxMeasUPP(byteCount, textAddr, numer, denom, info, userRoutine)
#define CallQDGetPicProc(userRoutine, dataPtr, byteCount) \
  InvokeQDGetPicUPP(dataPtr, byteCount, userRoutine)
#define CallQDPutPicProc(userRoutine, dataPtr, byteCount) \
  InvokeQDPutPicUPP(dataPtr, byteCount, userRoutine)
#define CallQDOpcodeProc(userRoutine, fromRect, toRect, opcode, version) \
  InvokeQDOpcodeUPP(fromRect, toRect, opcode, version, userRoutine)
#define CallQDStdGlyphsProc(userRoutine, dataStream, size) \
  InvokeQDStdGlyphsUPP(dataStream, size, userRoutine)
#define CallQDJShieldCursorProc(userRoutine, left, top, right, bottom) \
  InvokeQDJShieldCursorUPP(left, top, right, bottom, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
#if !OPAQUE_TOOLBOX_STRUCTS
  struct GrafPort
  {
    short device;      /* not available in Carbon*/
    BitMap portBits;   /* in Carbon use GetPortBitMapForCopyBits or IsPortColor*/
    Rect portRect;     /* in Carbon use Get/SetPortBounds*/
    RgnHandle visRgn;  /* in Carbon use Get/SetPortVisibleRegion*/
    RgnHandle clipRgn; /* in Carbon use Get/SetPortClipRegion*/
    Pattern bkPat;     /* not available in Carbon all GrafPorts are CGrafPorts*/
    Pattern fillPat;   /* not available in Carbon all GrafPorts are CGrafPorts*/
    Point pnLoc;       /* in Carbon use GetPortPenLocation or MoveTo*/
    Point pnSize;      /* in Carbon use Get/SetPortPenSize*/
    short pnMode;      /* in Carbon use Get/SetPortPenMode*/
    Pattern pnPat;     /* not available in Carbon all GrafPorts are CGrafPorts*/
    short pnVis;       /* in Carbon use GetPortPenVisibility or Show/HidePen*/
    short txFont;      /* in Carbon use GetPortTextFont or TextFont*/
    StyleField txFace; /* in Carbon use GetPortTextFace or TextFace*/
    /*StyleField occupies 16-bits, but only first 8-bits are used*/
    short txMode;     /* in Carbon use GetPortTextMode or TextMode*/
    short txSize;     /* in Carbon use GetPortTextSize or TextSize*/
    Fixed spExtra;    /* in Carbon use GetPortSpExtra or SpaceExtra*/
    long fgColor;     /* not available in Carbon */
    long bkColor;     /* not available in Carbon*/
    short colrBit;    /* not available in Carbon*/
    short patStretch; /* not available in Carbon*/
    Handle picSave;   /* in Carbon use IsPortPictureBeingDefined*/
    Handle rgnSave;   /* not available in Carbon*/
    Handle polySave;  /* not available in Carbon*/
    QDProcsPtr
        grafProcs; /* not available in Carbon all GrafPorts are CGrafPorts*/
  };
  typedef struct GrafPort GrafPort;
  typedef GrafPort *GrafPtr;
  typedef GrafPtr WindowPtr;
  typedef WindowPtr DialogPtr;
#else
typedef struct OpaqueWindowPtr *WindowPtr;
typedef struct OpaqueDialogPtr *DialogPtr;
typedef struct OpaqueGrafPtr *GrafPtr;
#endif /* !OPAQUE_TOOLBOX_STRUCTS */
 
  typedef WindowPtr WindowRef;
  /* DragConstraint constants to pass to DragGray,DragTheRgn, or
   * ConstrainedDragRgn*/
  typedef UInt16 DragConstraint;
  enum
  {
    kNoConstraint = 0,
    kVerticalConstraint = 1,
    kHorizontalConstraint = 2
  };
 
  typedef CALLBACK_API(void, DragGrayRgnProcPtr)(void);
  struct RGBColor
  {
    unsigned short red;   /*magnitude of red component*/
    unsigned short green; /*magnitude of green component*/
    unsigned short blue;  /*magnitude of blue component*/
  };
  typedef struct RGBColor RGBColor;
  typedef RGBColor *RGBColorPtr;
  typedef RGBColorPtr *RGBColorHdl;
  typedef CALLBACK_API(Boolean, ColorSearchProcPtr)(RGBColor *rgb,
                                                    long *position);
  typedef CALLBACK_API(Boolean, ColorComplementProcPtr)(RGBColor *rgb);
  typedef STACK_UPP_TYPE(DragGrayRgnProcPtr) DragGrayRgnUPP;
  typedef STACK_UPP_TYPE(ColorSearchProcPtr) ColorSearchUPP;
  typedef STACK_UPP_TYPE(ColorComplementProcPtr) ColorComplementUPP;
  DragGrayRgnUPP
  NewDragGrayRgnUPP(DragGrayRgnProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDragGrayRgnProcInfo = 0x00000000
  }; /* pascal no_return_value Func() */
#ifdef __cplusplus
  inline DragGrayRgnUPP NewDragGrayRgnUPP(DragGrayRgnProcPtr userRoutine)
  {
    return (DragGrayRgnUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDragGrayRgnProcInfo, GetCurrentArchitecture());
  }
#else
#define NewDragGrayRgnUPP(userRoutine)                                     \
  (DragGrayRgnUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppDragGrayRgnProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  ColorSearchUPP
  NewColorSearchUPP(ColorSearchProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppColorSearchProcInfo = 0x000003D0
  }; /* pascal 1_byte Func(4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline ColorSearchUPP NewColorSearchUPP(ColorSearchProcPtr userRoutine)
  {
    return (ColorSearchUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppColorSearchProcInfo, GetCurrentArchitecture());
  }
#else
#define NewColorSearchUPP(userRoutine)                                     \
  (ColorSearchUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppColorSearchProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  ColorComplementUPP
  NewColorComplementUPP(ColorComplementProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppColorComplementProcInfo = 0x000000D0
  }; /* pascal 1_byte Func(4_bytes) */
#ifdef __cplusplus
  inline ColorComplementUPP
  NewColorComplementUPP(ColorComplementProcPtr userRoutine)
  {
    return (ColorComplementUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppColorComplementProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewColorComplementUPP(userRoutine)                                     \
  (ColorComplementUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppColorComplementProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeDragGrayRgnUPP(DragGrayRgnUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDragGrayRgnUPP(DragGrayRgnUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDragGrayRgnUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeColorSearchUPP(ColorSearchUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeColorSearchUPP(ColorSearchUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeColorSearchUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  DisposeColorComplementUPP(ColorComplementUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeColorComplementUPP(ColorComplementUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeColorComplementUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  void
  InvokeDragGrayRgnUPP(DragGrayRgnUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeDragGrayRgnUPP(DragGrayRgnUPP userUPP)
  {
    CALL_ZERO_PARAMETER_UPP(userUPP, uppDragGrayRgnProcInfo);
  }
#else
#define InvokeDragGrayRgnUPP(userUPP) \
  CALL_ZERO_PARAMETER_UPP((userUPP), uppDragGrayRgnProcInfo)
#endif
#endif
 
  Boolean
  InvokeColorSearchUPP(RGBColor *rgb, long *position, ColorSearchUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeColorSearchUPP(RGBColor *rgb, long *position,
                                      ColorSearchUPP userUPP)
  {
    return (Boolean)CALL_TWO_PARAMETER_UPP(userUPP, uppColorSearchProcInfo, rgb,
                                           position);
  }
#else
#define InvokeColorSearchUPP(rgb, position, userUPP)                         \
  (Boolean) CALL_TWO_PARAMETER_UPP((userUPP), uppColorSearchProcInfo, (rgb), \
                                   (position))
#endif
#endif
 
  Boolean
  InvokeColorComplementUPP(RGBColor *rgb, ColorComplementUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline Boolean InvokeColorComplementUPP(RGBColor *rgb,
                                          ColorComplementUPP userUPP)
  {
    return (Boolean)CALL_ONE_PARAMETER_UPP(userUPP, uppColorComplementProcInfo,
                                           rgb);
  }
#else
#define InvokeColorComplementUPP(rgb, userUPP) \
  (Boolean) CALL_ONE_PARAMETER_UPP((userUPP), uppColorComplementProcInfo, (rgb))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewDragGrayRgnProc(userRoutine) NewDragGrayRgnUPP(userRoutine)
#define NewColorSearchProc(userRoutine) NewColorSearchUPP(userRoutine)
#define NewColorComplementProc(userRoutine) NewColorComplementUPP(userRoutine)
#define CallDragGrayRgnProc(userRoutine) InvokeDragGrayRgnUPP(userRoutine)
#define CallColorSearchProc(userRoutine, rgb, position) \
  InvokeColorSearchUPP(rgb, position, userRoutine)
#define CallColorComplementProc(userRoutine, rgb) \
  InvokeColorComplementUPP(rgb, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
  struct ColorSpec
  {
    short value;  /*index or other value*/
    RGBColor rgb; /*true color*/
  };
  typedef struct ColorSpec ColorSpec;
  typedef ColorSpec *ColorSpecPtr;
  typedef ColorSpec CSpecArray[1];
  struct ColorTable
  {
    long ctSeed;        /*unique identifier for table*/
    short ctFlags;      /*high bit: 0 = PixMap; 1 = device*/
    short ctSize;       /*number of entries in CTTable*/
    CSpecArray ctTable; /*array [0..0] of ColorSpec*/
  };
  typedef struct ColorTable ColorTable;
  typedef ColorTable *CTabPtr;
  typedef CTabPtr *CTabHandle;
  struct xColorSpec
  {
    short value;  /*index or other value*/
    RGBColor rgb; /*true color*/
    short xalpha;
  };
  typedef struct xColorSpec xColorSpec;
  typedef xColorSpec *xColorSpecPtr;
  typedef xColorSpec xCSpecArray[1];
  struct MatchRec
  {
    unsigned short red;
    unsigned short green;
    unsigned short blue;
    long matchData;
  };
  typedef struct MatchRec MatchRec;
#ifndef OLDPIXMAPSTRUCT
#if TARGET_OS_MAC && TARGET_API_MAC_OS8
#define OLDPIXMAPSTRUCT 1
#else
#define OLDPIXMAPSTRUCT 0
#endif /* TARGET_OS_MAC && TARGET_API_MAC_OS8 */
 
#endif /* !defined(OLDPIXMAPSTRUCT) */
 
#if OLDPIXMAPSTRUCT
#define GETPIXMAPPIXELFORMAT(pm) ((pm)->pixelSize)
#else
#define GETPIXMAPPIXELFORMAT(pm) \
  (((pm)->pixelFormat != 0) ? (pm)->pixelFormat : (pm)->pixelSize)
#endif
 
#if TARGET_OS_MAC && TARGET_API_MAC_OS8
#define NON_MAC_PIXEL_FORMATS 0
#else
#define NON_MAC_PIXEL_FORMATS 1
#endif
 
  /* pixel formats*/
  enum
  {
    k1MonochromePixelFormat = 0x00000001,  /* 1 bit indexed*/
    k2IndexedPixelFormat = 0x00000002,     /* 2 bit indexed*/
    k4IndexedPixelFormat = 0x00000004,     /* 4 bit indexed*/
    k8IndexedPixelFormat = 0x00000008,     /* 8 bit indexed*/
    k16BE555PixelFormat = 0x00000010,      /* 16 bit BE rgb 555 (Mac)*/
    k24RGBPixelFormat = 0x00000018,        /* 24 bit rgb */
    k32ARGBPixelFormat = 0x00000020,       /* 32 bit argb    (Mac)*/
    k1IndexedGrayPixelFormat = 0x00000021, /* 1 bit indexed gray*/
    k2IndexedGrayPixelFormat = 0x00000022, /* 2 bit indexed gray*/
    k4IndexedGrayPixelFormat = 0x00000024, /* 4 bit indexed gray*/
    k8IndexedGrayPixelFormat = 0x00000028  /* 8 bit indexed gray*/
  };
 
  /* values for PixMap.pixelFormat*/
  enum
  {
    k16LE555PixelFormat = FOUR_CHAR_CODE('L555'),  /* 16 bit LE rgb 555 (PC)*/
    k16LE5551PixelFormat = FOUR_CHAR_CODE('5551'), /* 16 bit LE rgb 5551*/
    k16BE565PixelFormat = FOUR_CHAR_CODE('B565'),  /* 16 bit BE rgb 565*/
    k16LE565PixelFormat = FOUR_CHAR_CODE('L565'),  /* 16 bit LE rgb 565*/
    k24BGRPixelFormat = FOUR_CHAR_CODE('24BG'),    /* 24 bit bgr */
    k32BGRAPixelFormat = FOUR_CHAR_CODE('BGRA'),   /* 32 bit bgra    (Matrox)*/
    k32ABGRPixelFormat = FOUR_CHAR_CODE('ABGR'),   /* 32 bit abgr    */
    k32RGBAPixelFormat = FOUR_CHAR_CODE('RGBA'),   /* 32 bit rgba    */
    kYUVSPixelFormat =
        FOUR_CHAR_CODE('yuvs'), /* YUV 4:2:2 byte ordering 16-unsigned = 'YUY2'*/
    kYUVUPixelFormat =
        FOUR_CHAR_CODE('yuvu'),                   /* YUV 4:2:2 byte ordering 16-signed*/
    kYVU9PixelFormat = FOUR_CHAR_CODE('YVU9'),    /* YVU9 Planar    9*/
    kYUV411PixelFormat = FOUR_CHAR_CODE('Y411'),  /* YUV 4:1:1 Interleaved  16*/
    kYVYU422PixelFormat = FOUR_CHAR_CODE('YVYU'), /* YVYU 4:2:2 byte ordering 16*/
    kUYVY422PixelFormat = FOUR_CHAR_CODE('UYVY'), /* UYVY 4:2:2 byte ordering 16*/
    kYUV211PixelFormat = FOUR_CHAR_CODE('Y211'),  /* YUV 2:1:1 Packed   8*/
    k2vuyPixelFormat = FOUR_CHAR_CODE('2vuy')     /* UYVY 4:2:2 byte ordering   16*/
  };
 
  struct PixMap
  {
    Ptr baseAddr;    /*pointer to pixels*/
    short rowBytes;  /*offset to next line*/
    Rect bounds;     /*encloses bitmap*/
    short pmVersion; /*pixMap version number*/
    short packType;  /*defines packing format*/
    long packSize;   /*length of pixel data*/
    Fixed hRes;      /*horiz. resolution (ppi)*/
    Fixed vRes;      /*vert. resolution (ppi)*/
    short pixelType; /*defines pixel type*/
    short pixelSize; /*# bits in pixel*/
    short cmpCount;  /*# components in pixel*/
    short cmpSize;   /*# bits per component*/
#if OLDPIXMAPSTRUCT
    long planeBytes;    /*offset to next plane*/
    CTabHandle pmTable; /*color map for this pixMap*/
    long pmReserved;
#else
  OSType pixelFormat; /*fourCharCode representation*/
  CTabHandle pmTable; /*color map for this pixMap*/
  void *pmExt;        /*Handle to pixMap extension*/
#endif
  };
  typedef struct PixMap PixMap;
  typedef PixMap *PixMapPtr;
  typedef PixMapPtr *PixMapHandle;
  struct PixPat
  {
    short patType;       /*type of pattern*/
    PixMapHandle patMap; /*the pattern's pixMap*/
    Handle patData;      /*pixmap's data*/
    Handle patXData;     /*expanded Pattern data*/
    short patXValid;     /*flags whether expanded Pattern valid*/
    Handle patXMap;      /*Handle to expanded Pattern data*/
    Pattern pat1Data;    /*old-Style pattern/RGB color*/
  };
  typedef struct PixPat PixPat;
  typedef PixPat *PixPatPtr;
  typedef PixPatPtr *PixPatHandle;
  struct CCrsr
  {
    short crsrType;       /*type of cursor*/
    PixMapHandle crsrMap; /*the cursor's pixmap*/
    Handle crsrData;      /*cursor's data*/
    Handle crsrXData;     /*expanded cursor data*/
    short crsrXValid;     /*depth of expanded data (0 if none)*/
    Handle crsrXHandle;   /*future use*/
    Bits16 crsr1Data;     /*one-bit cursor*/
    Bits16 crsrMask;      /*cursor's mask*/
    Point crsrHotSpot;    /*cursor's hotspot*/
    long crsrXTable;      /*private*/
    long crsrID;          /*private*/
  };
  typedef struct CCrsr CCrsr;
  typedef CCrsr *CCrsrPtr;
  typedef CCrsrPtr *CCrsrHandle;
  struct GammaTbl
  {
    short gVersion;        /*gamma version number*/
    short gType;           /*gamma data type*/
    short gFormulaSize;    /*Formula data size*/
    short gChanCnt;        /*number of channels of data*/
    short gDataCnt;        /*number of values/channel*/
    short gDataWidth;      /*bits/corrected value (data packed to next larger byte
                              size)*/
    short gFormulaData[1]; /*data for formulas followed by gamma values*/
  };
  typedef struct GammaTbl GammaTbl;
  typedef GammaTbl *GammaTblPtr;
  typedef GammaTblPtr *GammaTblHandle;
  struct ITab
  {
    long iTabSeed;   /*copy of CTSeed from source CTable*/
    short iTabRes;   /*bits/channel resolution of iTable*/
    Byte iTTable[1]; /*byte colortable index values*/
  };
  typedef struct ITab ITab;
  typedef ITab *ITabPtr;
  typedef ITabPtr *ITabHandle;
  struct SProcRec
  {
    Handle nxtSrch;          /*SProcHndl Handle to next SProcRec*/
    ColorSearchUPP srchProc; /*search procedure proc ptr*/
  };
  typedef struct SProcRec SProcRec;
  typedef SProcRec *SProcPtr;
  typedef SProcPtr *SProcHndl;
  struct CProcRec
  {
    Handle nxtComp;              /*CProcHndl Handle to next CProcRec*/
    ColorComplementUPP compProc; /*complement procedure proc ptr*/
  };
  typedef struct CProcRec CProcRec;
  typedef CProcRec *CProcPtr;
  typedef CProcPtr *CProcHndl;
#ifndef OLDGDEVICESTRUCT
#if TARGET_OS_MAC && TARGET_API_MAC_OS8
#define OLDGDEVICESTRUCT 1
#else
#define OLDGDEVICESTRUCT 0
#endif /* TARGET_OS_MAC && TARGET_API_MAC_OS8 */
 
#endif /* !defined(OLDGDEVICESTRUCT) */
 
  typedef struct GDevice GDevice;
  typedef GDevice *GDPtr;
  typedef GDPtr *GDHandle;
  struct GDevice
  {
    short gdRefNum;         /*driver's unit number*/
    short gdID;             /*client ID for search procs*/
    short gdType;           /*fixed/CLUT/direct*/
    ITabHandle gdITable;    /*Handle to inverse lookup table*/
    short gdResPref;        /*preferred resolution of GDITable*/
    SProcHndl gdSearchProc; /*search proc list head*/
    CProcHndl gdCompProc;   /*complement proc list*/
    short gdFlags;          /*grafDevice flags word*/
    PixMapHandle gdPMap;    /*describing pixMap*/
    long gdRefCon;          /*reference value*/
    GDHandle gdNextGD;      /*GDHandle Handle of next gDevice*/
    Rect gdRect;            /* device's bounds in global coordinates*/
    long gdMode;            /*device's current mode*/
    short gdCCBytes;        /*depth of expanded cursor data*/
    short gdCCDepth;        /*depth of expanded cursor data*/
    Handle gdCCXData;       /*Handle to cursor's expanded data*/
    Handle gdCCXMask;       /*Handle to cursor's expanded mask*/
#if OLDGDEVICESTRUCT
    long gdReserved; /*future use. MUST BE 0*/
#else
  Handle gdExt; /*QuickTime 3.0 private info*/
#endif
  };
 
  struct GrafVars
  {
    RGBColor rgbOpColor;     /*color for addPin  subPin and average*/
    RGBColor rgbHiliteColor; /*color for hiliting*/
    Handle pmFgColor;        /*palette Handle for foreground color*/
    short pmFgIndex;         /*index value for foreground*/
    Handle pmBkColor;        /*palette Handle for background color*/
    short pmBkIndex;         /*index value for background*/
    short pmFlags;           /*flags for Palette Manager*/
  };
  typedef struct GrafVars GrafVars;
  typedef GrafVars *GVarPtr;
  typedef GVarPtr *GVarHandle;
 
#if !OPAQUE_TOOLBOX_STRUCTS
  typedef struct CGrafPort CGrafPort;
  typedef CGrafPort *CGrafPtr;
#else
typedef GrafPtr CGrafPtr;
#endif /* !OPAQUE_TOOLBOX_STRUCTS */
 
  typedef CALLBACK_API_C(OSStatus,
                         QDPrinterStatusProcPtr)(PrinterStatusOpcode opcode,
                                                 CGrafPtr currentPort,
                                                 void *printerStatus);
  typedef STACK_UPP_TYPE(QDPrinterStatusProcPtr) QDPrinterStatusUPP;
 
  struct CQDProcs
  {
    QDTextUPP textProc;
    QDLineUPP lineProc;
    QDRectUPP rectProc;
    QDRRectUPP rRectProc;
    QDOvalUPP ovalProc;
    QDArcUPP arcProc;
    QDPolyUPP polyProc;
    QDRgnUPP rgnProc;
    QDBitsUPP bitsProc;
    QDCommentUPP commentProc;
    QDTxMeasUPP txMeasProc;
    QDGetPicUPP getPicProc;
    QDPutPicUPP putPicProc;
    QDOpcodeUPP opcodeProc;
    UniversalProcPtr
        newProc1; /* this is the StdPix bottleneck -- see ImageCompression.h */
    QDStdGlyphsUPP
        glyphsProc; /* was newProc2; now used in Unicode text drawing */
    QDPrinterStatusUPP
        printerStatusProc; /* was newProc3;  now used to communicate status
                              between Printing code and System imaging code */
    UniversalProcPtr newProc4;
    UniversalProcPtr newProc5;
    UniversalProcPtr newProc6;
  };
  typedef struct CQDProcs CQDProcs;
  typedef CQDProcs *CQDProcsPtr;
#if !OPAQUE_TOOLBOX_STRUCTS
  struct CGrafPort
  {
    short device;            /* not available in Carbon*/
    PixMapHandle portPixMap; /* in Carbon use GetPortPixMap*/
    short portVersion;       /* in Carbon use IsPortColor*/
    Handle grafVars;         /* not available in Carbon*/
    short chExtra;           /* in Carbon use GetPortChExtra*/
    short pnLocHFrac;        /* in Carbon use Get/SetPortFracHPenLocation*/
    Rect portRect;           /* in Carbon use Get/SetPortBounds*/
    RgnHandle visRgn;        /* in Carbon use Get/SetPortVisibleRegion*/
    RgnHandle clipRgn;       /* in Carbon use Get/SetPortClipRegion*/
    PixPatHandle bkPixPat;   /* in Carbon use GetPortBackPixPat or BackPixPat*/
    RGBColor rgbFgColor;     /* in Carbon use GetPortForeColor or RGBForeColor*/
    RGBColor rgbBkColor;     /* in Carbon use GetPortBackColor or RGBBackColor*/
    Point pnLoc;             /* in Carbon use GetPortPenLocation or MoveTo*/
    Point pnSize;            /* in Carbon use Get/SetPortPenSize*/
    short pnMode;            /* in Carbon use Get/SetPortPenMode*/
    PixPatHandle pnPixPat;   /* in Carbon use Get/SetPortPenPixPat*/
    PixPatHandle fillPixPat; /* in Carbon use GetPortFillPixPat*/
    short pnVis;             /* in Carbon use GetPortPenVisibility or Show/HidePen*/
    short txFont;            /* in Carbon use GetPortTextFont or TextFont*/
    StyleField txFace;       /* in Carbon use GetPortTextFace or TextFace*/
    /*StyleField occupies 16-bits, but only first 8-bits are used*/
    short txMode;          /* in Carbon use GetPortTextMode or TextMode*/
    short txSize;          /* in Carbon use GetPortTextSize or TextSize*/
    Fixed spExtra;         /* in Carbon use GetPortSpExtra or SpaceExtra*/
    long fgColor;          /* not available in Carbon*/
    long bkColor;          /* not available in Carbon*/
    short colrBit;         /* not available in Carbon*/
    short patStretch;      /* not available in Carbon*/
    Handle picSave;        /* in Carbon use IsPortPictureBeingDefined*/
    Handle rgnSave;        /* in Carbon use IsPortRegionBeingDefined*/
    Handle polySave;       /* in Carbon use IsPortPolyBeingDefined*/
    CQDProcsPtr grafProcs; /* in Carbon use Get/SetPortGrafProcs*/
  };
 
#endif /* !OPAQUE_TOOLBOX_STRUCTS */
 
#if OPAQUE_TOOLBOX_STRUCTS
  typedef WindowPtr CWindowPtr;
#else
typedef CGrafPtr CWindowPtr;
#endif /* OPAQUE_TOOLBOX_STRUCTS */
 
  struct ReqListRec
  {
    short reqLSize;    /*request list size*/
    short reqLData[1]; /*request list data*/
  };
  typedef struct ReqListRec ReqListRec;
  struct OpenCPicParams
  {
    Rect srcRect;
    Fixed hRes;
    Fixed vRes;
    short version;
    short reserved1;
    long reserved2;
  };
  typedef struct OpenCPicParams OpenCPicParams;
  enum
  {
    kCursorImageMajorVersion = 0x0001,
    kCursorImageMinorVersion = 0x0000
  };
 
  struct CursorImageRec
  {
    UInt16 majorVersion;
    UInt16 minorVersion;
    PixMapHandle cursorPixMap;
    BitMapHandle cursorBitMask;
  };
  typedef struct CursorImageRec CursorImageRec;
  typedef CursorImageRec *CursorImagePtr;
  typedef CALLBACK_API(void, DeviceLoopDrawingProcPtr)(short depth,
                                                       short deviceFlags,
                                                       GDHandle targetDevice,
                                                       long userData);
  typedef STACK_UPP_TYPE(DeviceLoopDrawingProcPtr) DeviceLoopDrawingUPP;
#if CALL_NOT_IN_CARBON
  QDPrinterStatusUPP
  NewQDPrinterStatusUPP(QDPrinterStatusProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppQDPrinterStatusProcInfo = 0x00000FF1
  }; /* 4_bytes Func(4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline QDPrinterStatusUPP
  NewQDPrinterStatusUPP(QDPrinterStatusProcPtr userRoutine)
  {
    return (QDPrinterStatusUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                    uppQDPrinterStatusProcInfo,
                                                    GetCurrentArchitecture());
  }
#else
#define NewQDPrinterStatusUPP(userRoutine)                                     \
  (QDPrinterStatusUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppQDPrinterStatusProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
#endif /* CALL_NOT_IN_CARBON */
 
  DeviceLoopDrawingUPP
  NewDeviceLoopDrawingUPP(DeviceLoopDrawingProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppDeviceLoopDrawingProcInfo = 0x00003E80
  }; /* pascal no_return_value Func(2_bytes, 2_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline DeviceLoopDrawingUPP
  NewDeviceLoopDrawingUPP(DeviceLoopDrawingProcPtr userRoutine)
  {
    return (DeviceLoopDrawingUPP)NewRoutineDescriptor(
        (ProcPtr)(userRoutine), uppDeviceLoopDrawingProcInfo,
        GetCurrentArchitecture());
  }
#else
#define NewDeviceLoopDrawingUPP(userRoutine)                                \
  (DeviceLoopDrawingUPP) NewRoutineDescriptor((ProcPtr)(userRoutine),       \
                                              uppDeviceLoopDrawingProcInfo, \
                                              GetCurrentArchitecture())
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  void
  DisposeQDPrinterStatusUPP(QDPrinterStatusUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeQDPrinterStatusUPP(QDPrinterStatusUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeQDPrinterStatusUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#endif /* CALL_NOT_IN_CARBON */
 
  void
  DisposeDeviceLoopDrawingUPP(DeviceLoopDrawingUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeDeviceLoopDrawingUPP(DeviceLoopDrawingUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeDeviceLoopDrawingUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
#if CALL_NOT_IN_CARBON
  OSStatus
  InvokeQDPrinterStatusUPP(PrinterStatusOpcode opcode, CGrafPtr currentPort,
                           void *printerStatus, QDPrinterStatusUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeQDPrinterStatusUPP(PrinterStatusOpcode opcode,
                                           CGrafPtr currentPort,
                                           void *printerStatus,
                                           QDPrinterStatusUPP userUPP)
  {
    return (OSStatus)CALL_THREE_PARAMETER_UPP(userUPP, uppQDPrinterStatusProcInfo,
                                              opcode, currentPort, printerStatus);
  }
#else
#define InvokeQDPrinterStatusUPP(opcode, currentPort, printerStatus, userUPP) \
  (OSStatus)                                                                  \
      CALL_THREE_PARAMETER_UPP((userUPP), uppQDPrinterStatusProcInfo,         \
                               (opcode), (currentPort), (printerStatus))
#endif
#endif
 
#endif /* CALL_NOT_IN_CARBON */
 
  void
  InvokeDeviceLoopDrawingUPP(short depth, short deviceFlags,
                             GDHandle targetDevice, long userData,
                             DeviceLoopDrawingUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void InvokeDeviceLoopDrawingUPP(short depth, short deviceFlags,
                                         GDHandle targetDevice, long userData,
                                         DeviceLoopDrawingUPP userUPP)
  {
    CALL_FOUR_PARAMETER_UPP(userUPP, uppDeviceLoopDrawingProcInfo, depth,
                            deviceFlags, targetDevice, userData);
  }
#else
#define InvokeDeviceLoopDrawingUPP(depth, deviceFlags, targetDevice, userData, \
                                   userUPP)                                    \
  CALL_FOUR_PARAMETER_UPP((userUPP), uppDeviceLoopDrawingProcInfo, (depth),    \
                          (deviceFlags), (targetDevice), (userData))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewQDPrinterStatusProc(userRoutine) NewQDPrinterStatusUPP(userRoutine)
#define NewDeviceLoopDrawingProc(userRoutine) \
  NewDeviceLoopDrawingUPP(userRoutine)
#define CallQDPrinterStatusProc(userRoutine, opcode, currentPort, \
                                printerStatus)                    \
  InvokeQDPrinterStatusUPP(opcode, currentPort, printerStatus, userRoutine)
#define CallDeviceLoopDrawingProc(userRoutine, depth, deviceFlags,       \
                                  targetDevice, userData)                \
  InvokeDeviceLoopDrawingUPP(depth, deviceFlags, targetDevice, userData, \
                             userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
#if !OPAQUE_TOOLBOX_STRUCTS || !TARGET_API_MAC_CARBON
  struct QDGlobals
  {
    char privates[76];
    long randSeed;     /* in Carbon use GetQDGlobalsRandomSeed*/
    BitMap screenBits; /* in Carbon use GetQDGlobalsScreenBits*/
    Cursor arrow;      /* in Carbon use GetQDGlobalsArrow*/
    Pattern dkGray;    /* in Carbon use GetQDGlobalsDarkGray*/
    Pattern ltGray;    /* in Carbon use GetQDGlobalsLightGray*/
    Pattern gray;      /* in Carbon use GetQDGlobalsGray*/
    Pattern black;     /* in Carbon use GetQDGlobalsBlack*/
    Pattern white;     /* in Carbon use GetQDGlobalsWhite*/
    GrafPtr thePort;   /* in Carbon use GetQDGlobalsThePort*/
  };
  typedef struct QDGlobals QDGlobals;
  typedef QDGlobals *QDGlobalsPtr;
  typedef QDGlobalsPtr *QDGlobalsHdl;
  extern QDGlobals qd;
 
#endif /* !OPAQUE_TOOLBOX_STRUCTS || !TARGET_API_MAC_CARBON */
 
#if CALL_NOT_IN_CARBON
  void
  InitGraf(void *globalPtr);
 
  void
  OpenPort(GrafPtr port);
 
  void
  InitPort(GrafPtr port);
 
  void
  ClosePort(GrafPtr port);
 
#endif /* CALL_NOT_IN_CARBON */
 
  OSErr
  LockPortBits(GrafPtr port);
 
  OSErr
  UnlockPortBits(GrafPtr port);
 
  /* Break a region up into rectangles.*/
 
  enum
  {
    kQDParseRegionFromTop = (1 << 0),
    kQDParseRegionFromBottom = (1 << 1),
    kQDParseRegionFromLeft = (1 << 2),
    kQDParseRegionFromRight = (1 << 3),
    kQDParseRegionFromTopLeft = kQDParseRegionFromTop | kQDParseRegionFromLeft,
    kQDParseRegionFromBottomRight =
        kQDParseRegionFromBottom | kQDParseRegionFromRight
  };
 
  typedef SInt32 QDRegionParseDirection;
  enum
  {
    kQDRegionToRectsMsgInit = 1,
    kQDRegionToRectsMsgParse = 2,
    kQDRegionToRectsMsgTerminate = 3
  };
 
  typedef CALLBACK_API_C(OSStatus,
                         RegionToRectsProcPtr)(UInt16 message, RgnHandle rgn,
                                               const Rect *rect, void *refCon);
  typedef STACK_UPP_TYPE(RegionToRectsProcPtr) RegionToRectsUPP;
  RegionToRectsUPP
  NewRegionToRectsUPP(RegionToRectsProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
  enum
  {
    uppRegionToRectsProcInfo = 0x00003FB1
  }; /* 4_bytes Func(2_bytes, 4_bytes, 4_bytes, 4_bytes) */
#ifdef __cplusplus
  inline RegionToRectsUPP NewRegionToRectsUPP(RegionToRectsProcPtr userRoutine)
  {
    return (RegionToRectsUPP)NewRoutineDescriptor((ProcPtr)(userRoutine),
                                                  uppRegionToRectsProcInfo,
                                                  GetCurrentArchitecture());
  }
#else
#define NewRegionToRectsUPP(userRoutine)                                     \
  (RegionToRectsUPP)                                                         \
      NewRoutineDescriptor((ProcPtr)(userRoutine), uppRegionToRectsProcInfo, \
                           GetCurrentArchitecture())
#endif
#endif
 
  void
  DisposeRegionToRectsUPP(RegionToRectsUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline void DisposeRegionToRectsUPP(RegionToRectsUPP userUPP)
  {
    DisposeRoutineDescriptor((UniversalProcPtr)userUPP);
  }
#else
#define DisposeRegionToRectsUPP(userUPP) DisposeRoutineDescriptor(userUPP)
#endif
#endif
 
  OSStatus
  InvokeRegionToRectsUPP(UInt16 message, RgnHandle rgn, const Rect *rect,
                         void *refCon, RegionToRectsUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
  inline OSStatus InvokeRegionToRectsUPP(UInt16 message, RgnHandle rgn,
                                         const Rect *rect, void *refCon,
                                         RegionToRectsUPP userUPP)
  {
    return (OSStatus)CALL_FOUR_PARAMETER_UPP(userUPP, uppRegionToRectsProcInfo,
                                             message, rgn, rect, refCon);
  }
#else
#define InvokeRegionToRectsUPP(message, rgn, rect, refCon, userUPP)       \
  (OSStatus) CALL_FOUR_PARAMETER_UPP((userUPP), uppRegionToRectsProcInfo, \
                                     (message), (rgn), (rect), (refCon))
#endif
#endif
 
#if CALL_NOT_IN_CARBON || OLDROUTINENAMES
/* support for pre-Carbon UPP routines: New...Proc and Call...Proc */
#define NewRegionToRectsProc(userRoutine) NewRegionToRectsUPP(userRoutine)
#define CallRegionToRectsProc(userRoutine, message, rgn, rect, refCon) \
  InvokeRegionToRectsUPP(message, rgn, rect, refCon, userRoutine)
#endif /* CALL_NOT_IN_CARBON */
 
  OSStatus
  QDRegionToRects(RgnHandle rgn, QDRegionParseDirection dir,
                  RegionToRectsUPP proc, void *userData);
 
#if !TARGET_OS_MAC
#if CALL_NOT_IN_CARBON
  OSErr
  UpdatePort(GrafPtr port);
 
  void *
  GetPortNativeWindow(GrafPtr macPort);
 
  GrafPtr
  GetNativeWindowPort(void *nativeWindow);
 
  void *
  MacRegionToNativeRegion(RgnHandle macRegion);
 
  RgnHandle
  NativeRegionToMacRegion(void *nativeRegion);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* !TARGET_OS_MAC */
 
#if TARGET_OS_WIN32
#if CALL_NOT_IN_CARBON
  void *
  GetPortHWND(GrafPtr port);
 
  GrafPtr
  GetHWNDPort(void *theHWND);
 
#define GetPortHWND(port) (HWND) GetPortNativeWindow(port)
#define GetHWNDPort(theHWND) GetNativeWindowPort(theHWND)
  void *
  GetPortHDC(GrafPtr port);
 
  void *
  GetPortHBITMAP(GrafPtr port);
 
  void *
  GetPortHPALETTE(GrafPtr port);
 
  void *
  GetPortHFONT(GrafPtr port);
 
  void *
  GetDIBFromPICT(PicHandle hPict);
 
  PicHandle
  GetPICTFromDIB(void *h);
 
#endif /* CALL_NOT_IN_CARBON */
 
#endif /* TARGET_OS_WIN32 */
 
#if TARGET_OS_MAC
#define MacSetPort SetPort
#endif
  void
  MacSetPort(GrafPtr port);
 
  void
  GetPort(GrafPtr *port);
 
  Boolean
  QDSwapPort(CGrafPtr inNewPort, CGrafPtr *outOldPort);
 
  void
  GrafDevice(short device);
 
The third line above correctly adjusts for the required word alignment.
Example
#include < Quickdraw.h >
#include < Memory.h >
OffScreenDraw( short rWide, short rHigh, Rect rDest )
// rWide, rHigh; size of off-screen rectangle
// rDest; on-screen destination */
{
  BitMap saveBits;
  BitMap tempBits;
  short bytesPerRow;
  saveBits = thePort->portBits; /* save current */
  /* now create an off-screen "canvas" */
  bytesPerRow = (((rWide - 1) / 16) + 1) * 2;
  tempBits.baseAddr = (QDPtr)NewPtr(bytesPerRow * rHigh);
  tempBits.rowBytes = bytesPerRow;
  SetRect(&tempBits.bounds, 0, 0, rWide, rHigh);
  </ pre>
              * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                        *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
          *    \carbon_lib in CarbonLib 1.0 and
      later
          *    \mac_os_x in version 10.0 and
      later
              * /
          void
          SetPortBits(const BitMap *bm);
 
  void
  PortSize(short width, short height);
 
  void
  MovePortTo(short leftGlobal, short topGlobal);
 
  void
  SetOrigin(short h, short v);
 
  void
  SetClip(RgnHandle rgn);
 
  void
  GetClip(RgnHandle rgn);
 
  void
  ClipRect(const Rect *r);
 
  void
  BackPat(const Pattern *pat);
 
  void
  InitCursor(void);
 
#if TARGET_OS_MAC
#define MacSetCursor SetCursor
#endif
    void
    MacSetCursor(const Cursor *crsr);
 
    void
    HideCursor(void);
 
#if TARGET_OS_MAC
#define MacShowCursor ShowCursor
#endif
    void
    MacShowCursor(void);
 
    void
    ObscureCursor(void);
 
    void
    HidePen(void);
 
    void
    ShowPen(void);
 
    void
        GetPen(Point * pt);
 
    ShowPen(); /* we want pen to be visible */
    /* ...draw some figure here which may change the state... */
    SetPenState(&savePenState); /* restore the pen's visible state */
  }
  </ pre>
              * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                        *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
          *    \carbon_lib in CarbonLib 1.0 and
      later
          *    \mac_os_x in version 10.0 and
      later
              * /
          void
          GetPenState(PenState *pnState);
 
  void
  SetPenState(const PenState *pnState);
 
  void
  PenSize(short width, short height);
 
  void
  PenMode(short mode);
 
  void
  PenPat(const Pattern *pat);
 
  void
  PenNormal(void);
 
  void
  MoveTo(short h, short v);
 
  void
  Move(short dh, short dv);
 
#if TARGET_OS_MAC
#define MacLineTo LineTo
#endif
  void
  MacLineTo(short h, short v);
 
  void
  Line(short dh, short dv);
 
  void
  ForeColor(long color);
 
  void
  BackColor(long color);
 
  void
  ColorBit(short whichBit);
 
#if TARGET_OS_MAC
#define MacSetRect SetRect
#endif
  void
  MacSetRect(Rect *r, short left, short top, short right, short bottom);
 
#if TARGET_OS_MAC
#define MacOffsetRect OffsetRect
#endif
  void
  MacOffsetRect(Rect *r, short dh, short dv);
 
#if TARGET_OS_MAC
#define MacInsetRect InsetRect
#endif
  void
  MacInsetRect(Rect *r, short dh, short dv);
 
  Boolean
  SectRect(const Rect *src1, const Rect *src2, Rect *dstRect);
 
#if TARGET_OS_MAC
#define MacUnionRect UnionRect
#endif
  void
  MacUnionRect(const Rect *src1, const Rect *src2, Rect *dstRect);
 
#if TARGET_OS_MAC
#define MacEqualRect EqualRect
#endif
  Boolean
  MacEqualRect(const Rect *rect1, const Rect *rect2);
 
  Boolean
  EmptyRect(const Rect *r);
 
#if TARGET_OS_MAC
#define MacFrameRect FrameRect
#endif
  void
  MacFrameRect(const Rect *r);
 
  void
  PaintRect(const Rect *r);
 
  void
  EraseRect(const Rect *r);
 
#if TARGET_OS_MAC
#define MacInvertRect InvertRect
#endif
  void
  MacInvertRect(const Rect *r);
 
#if TARGET_OS_MAC
#define MacFillRect FillRect
#endif
  void
  MacFillRect(const Rect *r, const Pattern *pat);
 
  void
  FrameOval(const Rect *r);
 
  void
  PaintOval(const Rect *r);
 
  void
  EraseOval(const Rect *r);
 
  void
  InvertOval(const Rect *r);
 
  void
  FillOval(const Rect *r, const Pattern *pat);
 
  void
  FrameRoundRect(const Rect *r, short ovalWidth, short ovalHeight);
 
  void
  PaintRoundRect(const Rect *r, short ovalWidth, short ovalHeight);
 
  void
  EraseRoundRect(const Rect *r, short ovalWidth, short ovalHeight);
 
  void
  InvertRoundRect(const Rect *r, short ovalWidth, short ovalHeight);
 
  void
  FillRoundRect(const Rect *r, short ovalWidth, short ovalHeight,
                const Pattern *pat);
 
  void
  FrameArc(const Rect *r, short startAngle, short arcAngle);
 
  void
  PaintArc(const Rect *r, short startAngle, short arcAngle);
 
  void
  EraseArc(const Rect *r, short startAngle, short arcAngle);
 
  void
  InvertArc(const Rect *r, short startAngle, short arcAngle);
 
  void
  FillArc(const Rect *r, short startAngle, short arcAngle, const Pattern *pat);
 
  RgnHandle
  NewRgn(void);
 
  void
  OpenRgn(void);
 
  void
  CloseRgn(RgnHandle dstRgn);
 
  OSErr
  BitMapToRegion(RgnHandle region, const BitMap *bMap);
 
  void
  HandleToRgn(Handle oldRegion, RgnHandle region);
 
  void
  RgnToHandle(RgnHandle region, Handle flattenedRgnDataHdl);
 
  void
  DisposeRgn(RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacCopyRgn CopyRgn
#endif
  void
  MacCopyRgn(RgnHandle srcRgn, RgnHandle dstRgn);
 
  void
  SetEmptyRgn(RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacSetRectRgn SetRectRgn
#endif
  void
  MacSetRectRgn(RgnHandle rgn, short left, short top, short right, short bottom);
 
  void
  RectRgn(RgnHandle rgn, const Rect *r);
 
#if TARGET_OS_MAC
#define MacOffsetRgn OffsetRgn
#endif
  void
  MacOffsetRgn(RgnHandle rgn, short dh, short dv);
 
  void
  InsetRgn(RgnHandle rgn, short dh, short dv);
 
  void
  SectRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
 
#if TARGET_OS_MAC
#define MacUnionRgn UnionRgn
#endif
  void
  MacUnionRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
 
  void
  DiffRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
 
#if TARGET_OS_MAC
#define MacXorRgn XorRgn
#endif
  void
  MacXorRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
 
  Boolean
  RectInRgn(const Rect *r, RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacEqualRgn EqualRgn
#endif
  Boolean
  MacEqualRgn(RgnHandle rgnA, RgnHandle rgnB);
 
  Boolean
  EmptyRgn(RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacFrameRgn FrameRgn
#endif
  void
  MacFrameRgn(RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacPaintRgn PaintRgn
#endif
  void
  MacPaintRgn(RgnHandle rgn);
 
  void
  EraseRgn(RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacInvertRgn InvertRgn
#endif
  void
  MacInvertRgn(RgnHandle rgn);
 
#if TARGET_OS_MAC
#define MacFillRgn FillRgn
#endif
  void
  MacFillRgn(RgnHandle rgn, const Pattern *pat);
 
  void
  ScrollRect(const Rect *r, short dh, short dv, RgnHandle updateRgn);
 
  void
  CopyBits(const BitMap *srcBits, const BitMap *dstBits, const Rect *srcRect,
           const Rect *dstRect, short mode,
           RgnHandle maskRgn) /* can be NULL */;
 
  void
  SeedFill(const void *srcPtr, void *dstPtr, short srcRow, short dstRow,
           short height, short words, short seedH, short seedV);
 
  void
  CalcMask(const void *srcPtr, void *dstPtr, short srcRow, short dstRow,
           short height, short words);
 
  void
  CopyMask(const BitMap *srcBits, const BitMap *maskBits, const BitMap *dstBits,
           const Rect *srcRect, const Rect *maskRect, const Rect *dstRect);
 
  PicHandle
  OpenPicture(const Rect *picFrame);
 
  void
  PicComment(short kind, short dataSize, Handle dataHandle);
 
  void
  ClosePicture(void);
 
  void
  DrawPicture(PicHandle myPicture, const Rect *dstRect);
 
  void
  KillPicture(PicHandle myPicture);
 
  PolyHandle
  OpenPoly(void);
 
  void
  ClosePoly(void);
 
  void
  KillPoly(PolyHandle poly);
 
  void
  OffsetPoly(PolyHandle poly, short dh, short dv);
 
  void
  FramePoly(PolyHandle poly);
 
  void
  PaintPoly(PolyHandle poly);
 
  void
  ErasePoly(PolyHandle poly);
 
  void
  InvertPoly(PolyHandle poly);
 
  void
  FillPoly(PolyHandle poly, const Pattern *pat);
 
  void
  SetPt(Point *pt, short h, short v);
 
  LocalToGlobal(&tmpPt);                 /* convert to global */
  SubPt(localPt, &tmpPt);                /* find difference */
  OffsetPoly(thePoly, tmpPt.h, tmpPt.v); /* move the item */
  </ pre>
              * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                        *    \non_carbon_cfm in InterfaceLib 7.1 and
      later
          *    \carbon_lib in CarbonLib 1.0 and
      later
          *    \mac_os_x in version 10.0 and
      later
              * /
          void
          LocalToGlobal(Point *pt);
 
  ctlCode = FindControl(myEvent.where, myWindow, &myCtl);
  if (ctlCode == inThumb)
  /*. . . etc. . . */
}
This function is also used as an intermediate step in converting between
    coordinates of two different grafPorts(e.g., windows)
        .For instance,
    to
    convert the position of rectangle theRect from the coordinates of windowA
    to the coordinates of windowB : SetPort(windowA);
LocalToGlobal(&topLeft(theRect));
LocalToGlobal(&botRight(theRect));
SetPort(windowB);
GlobalToLocal(&topLeft(theRect));
GlobalToLocal(&botRight(theRect));
To convert between the coordinates of regions and polygons, calculate the</ pre>
                                                                        * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                                                                                  *    \non_carbon_cfm in InterfaceLib 7.1 and
                                                                later
                                                                    *    \carbon_lib in CarbonLib 1.0 and
                                                                later
                                                                    *    \mac_os_x in version 10.0 and
                                                                later
                                                                        * /
                                                                    void
                                                                    GlobalToLocal(Point *pt);
 
theRand = Random(); /* get a random number */
The Quickdraw global variable randSeed can also be used as a seed to start a
        pseudo -
    random sequence.Example
/* example function returns value between min and max */
#include < Quickdraw.h >
    unsigned short
    RangedRdm(unsigned short min, unsigned short max)
/* assume that min is less than max */
{
  unsigned qdRdm; /* treat return value as 0-65536 */
  long range, t;
  qdRdm = Random();
  range = max - min;
  t = (qdRdm * range) / 65536; /* now 0 <= t <= range */
  return (t + min);
}
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        short
        Random(void);
 
void StuffHex(void *thingPtr, ConstStr255Param s);
 
#if TARGET_OS_MAC
#define MacGetPixel GetPixel
#endif
Boolean
MacGetPixel(short h, short v);
 
void ScalePt(Point *pt, const Rect *srcRect, const Rect *dstRect);
 
w1 = r1.right - r1.left;
w2 = r2.right - r2.left;             /* and widths */
thePoint.h = (thePoint.h * w1) / w2; /* apply ratio of sizes */
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        void
        MapPt(Point *pt, const Rect *srcRect, const Rect *dstRect);
 
void MapRect(Rect *r, const Rect *srcRect, const Rect *dstRect);
 
void MapRgn(RgnHandle rgn, const Rect *srcRect, const Rect *dstRect);
 
void MapPoly(PolyHandle poly, const Rect *srcRect, const Rect *dstRect);
 
pascal short myCommentProc(void);             /* declare the function */
SetStdProcs(&myQDProcs);                      /* initialize with defaults */
myQDProcs.commentProc = (QDPtr)myCommentProc; /* change one proc */
thePort->grafProcs = &myQDProcs;              /* install the change */
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        void
        SetStdProcs(QDProcs *procs);
 
void StdRect(GrafVerb verb, const Rect *r);
 
void StdRRect(GrafVerb verb, const Rect *r, short ovalWidth, short ovalHeight);
 
void StdOval(GrafVerb verb, const Rect *r);
 
void StdArc(GrafVerb verb, const Rect *r, short startAngle, short arcAngle);
 
void StdPoly(GrafVerb verb, PolyHandle poly);
 
void StdRgn(GrafVerb verb, RgnHandle rgn);
 
void StdBits(const BitMap *srcBits, const Rect *srcRect, const Rect *dstRect,
             short mode, RgnHandle maskRgn);
 
void StdComment(short kind, short dataSize, Handle dataHandle);
 
void StdGetPic(void *dataPtr, short byteCount);
 
void StdPutPic(const void *dataPtr, short byteCount);
 
void StdOpcode(const Rect *fromRect, const Rect *toRect, UInt16 opcode,
               SInt16 version);
 
void AddPt(Point src, Point *dst);
 
... they are equal...
}
or the more efficient : if (*(long *)&pt1 == *(long *)&pt2){/* compare longs once */
                                                            ... they are equal...} < / pre >
                        * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                                  *    \non_carbon_cfm in InterfaceLib 7.1 and
        later *    \carbon_lib in CarbonLib 1.0 and later *    \mac_os_x in version 10.0 and later * / Boolean EqualPt(Point pt1, Point pt2);
 
#if TARGET_OS_MAC
#define MacPtInRect PtInRect
#endif
Boolean
MacPtInRect(Point pt, const Rect *r);
 
void Pt2Rect(Point pt1, Point pt2, Rect *dstRect);
 
void PtToAngle(const Rect *r, Point pt, short *angle);
 
void SubPt(Point src, Point *dst);
 
...
}
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        Boolean
        PtInRgn(Point pt, RgnHandle rgn);
 
void StdLine(Point newPt);
 
#if CALL_NOT_IN_CARBON
void OpenCPort(CGrafPtr port);
 
void InitCPort(CGrafPtr port);
 
void CloseCPort(CGrafPtr port);
 
#endif /* CALL_NOT_IN_CARBON */
 
PixMapHandle
NewPixMap(void);
 
void DisposePixMap(PixMapHandle pm);
 
void CopyPixMap(PixMapHandle srcPM, PixMapHandle dstPM);
 
PixPatHandle
NewPixPat(void);
 
void DisposePixPat(PixPatHandle pp);
 
void CopyPixPat(PixPatHandle srcPP, PixPatHandle dstPP);
 
void PenPixPat(PixPatHandle pp);
 
void BackPixPat(PixPatHandle pp);
 
PixPatHandle
GetPixPat(short patID);
 
void MakeRGBPat(PixPatHandle pp, const RGBColor *myColor);
 
void FillCRect(const Rect *r, PixPatHandle pp);
 
void FillCOval(const Rect *r, PixPatHandle pp);
 
void FillCRoundRect(const Rect *r, short ovalWidth, short ovalHeight,
                    PixPatHandle pp);
 
void FillCArc(const Rect *r, short startAngle, short arcAngle, PixPatHandle pp);
 
void FillCRgn(RgnHandle rgn, PixPatHandle pp);
 
void FillCPoly(PolyHandle poly, PixPatHandle pp);
 
void RGBForeColor(const RGBColor *color);
 
void RGBBackColor(const RGBColor *color);
 
void SetCPixel(short h, short v, const RGBColor *cPix);
 
void SetPortPix(PixMapHandle pm);
 
void GetCPixel(short h, short v, RGBColor *cPix);
 
void GetForeColor(RGBColor *color);
 
void GetBackColor(RGBColor *color);
 
void SeedCFill(const BitMap *srcBits, const BitMap *dstBits, const Rect *srcRect,
               const Rect *dstRect, short seedH, short seedV,
               ColorSearchUPP matchProc, long matchData);
 
void CalcCMask(const BitMap *srcBits, const BitMap *dstBits, const Rect *srcRect,
               const Rect *dstRect, const RGBColor *seedRGB,
               ColorSearchUPP matchProc, long matchData);
 
PicHandle
OpenCPicture(const OpenCPicParams *newHeader);
 
void OpColor(const RGBColor *color);
 
void HiliteColor(const RGBColor *color);
 
void DisposeCTable(CTabHandle cTable);
 
CTabHandle
GetCTable(short ctID);
 
CCrsrHandle
GetCCursor(short crsrID);
 
void SetCCursor(CCrsrHandle cCrsr);
 
void AllocCursor(void);
 
void DisposeCCursor(CCrsrHandle cCrsr);
 
/* GetCIcon(), PlotCIcon(), and DisposeCIcon() moved to Icons.h*/
 
void SetStdCProcs(CQDProcs *procs);
 
GDHandle
GetMaxDevice(const Rect *globalRect);
 
long GetCTSeed(void);
 
GDHandle
GetDeviceList(void);
 
GDHandle
GetMainDevice(void);
 
GDHandle
GetNextDevice(GDHandle curDevice);
 
Boolean
TestDeviceAttribute(GDHandle gdh, short attribute);
 
void SetDeviceAttribute(GDHandle gdh, short attribute, Boolean value);
 
void InitGDevice(short qdRefNum, long mode, GDHandle gdh);
 
GDHandle
NewGDevice(short refNum, long mode);
 
void DisposeGDevice(GDHandle gdh);
 
void SetGDevice(GDHandle gd);
 
GDHandle
GetGDevice(void);
 
long Color2Index(const RGBColor *myColor);
 
void Index2Color(long index, RGBColor *aColor);
 
void InvertColor(RGBColor *myColor);
 
Boolean
RealColor(const RGBColor *color);
 
void GetSubTable(CTabHandle myColors, short iTabRes, CTabHandle targetTbl);
 
void MakeITable(CTabHandle cTabH, ITabHandle iTabH, short res);
 
void AddSearch(ColorSearchUPP searchProc);
 
void AddComp(ColorComplementUPP compProc);
 
void DelSearch(ColorSearchUPP searchProc);
 
void DelComp(ColorComplementUPP compProc);
 
void SetClientID(short id);
 
void ProtectEntry(short index, Boolean protect);
 
void ReserveEntry(short index, Boolean reserve);
 
void SetEntries(short start, short count, CSpecArray aTable);
 
void SaveEntries(CTabHandle srcTable, CTabHandle resultTable, ReqListRec *selection);
 
void RestoreEntries(CTabHandle srcTable, CTabHandle dstTable, ReqListRec *selection);
 
short QDError(void);
 
void CopyDeepMask(const BitMap *srcBits, const BitMap *maskBits,
                  const BitMap *dstBits, const Rect *srcRect, const Rect *maskRect,
                  const Rect *dstRect, short mode,
                  RgnHandle maskRgn) /* can be NULL */;
 
void DeviceLoop(RgnHandle drawingRgn, DeviceLoopDrawingUPP drawingProc,
                long userData, DeviceLoopFlags flags);
 
#if TARGET_OS_MAC && TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#pragma parameter __A0 GetMaskTable
#endif
Ptr GetMaskTable(void);
 
PatHandle
GetPattern(short patternID);
 
#if TARGET_OS_MAC
#define MacGetCursor GetCursor
#endif
CursHandle
MacGetCursor(short cursorID);
 
PicHandle
GetPicture(short pictureID);
 
long DeltaPoint(Point ptA, Point ptB);
 
An alternative method is to convert shieldRect to global coordinates(via
                                                                         LocalToGlobal) before the call,
    and pass(0, 0) as offsetPt.</ pre>
                * \copyright THINK Reference © 1991 -
            1992 Symantec Corporation
 
                *    \non_carbon_cfm in InterfaceLib 7.1 and
        later
            *    \carbon_lib in CarbonLib 1.0 and
        later
            *    \mac_os_x in version 10.0 and
        later
                * /
            void ShieldCursor(const Rect *shieldRect, Point offsetPt);
 
void ScreenRes(short *scrnHRes, short *scrnVRes);
 
void GetIndPattern(Pattern *thePat, short patternListID, short index);
 
#if CALL_NOT_IN_CARBON
Boolean
ptinrect(const Point *pt, const Rect *r);
 
void pt2rect(const Point *pt1, const Point *pt2, Rect *destRect);
 
void pttoangle(const Rect *r, const Point *pt, short *angle);
 
Boolean
ptinrgn(const Point *pt, RgnHandle rgn);
 
void addpt(const Point *src, Point *dst);
 
void subpt(const Point *src, Point *dst);
 
Boolean
equalpt(const Point *pt1, const Point *pt2);
 
void stuffhex(void *thingPtr, const char *s);
 
void stdline(const Point *newPt);
 
void shieldcursor(const Rect *shieldRect, Point *offsetPt);
 
#endif /* CALL_NOT_IN_CARBON */
 
long deltapoint(Point *ptA, Point *ptB);
 
#if OLDROUTINENAMES
#define DisposPixMap(pm) DisposePixMap(pm)
#define DisposPixPat(pp) DisposePixPat(pp)
#define DisposCTable(cTable) DisposeCTable(cTable)
#define DisposCCursor(cCrsr) DisposeCCursor(cCrsr)
#define DisposGDevice(gdh) DisposeGDevice(gdh)
#endif /* OLDROUTINENAMES */
 
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        void
        PackBits(Ptr *srcPtr, Ptr *dstPtr, short srcBytes);
 
void UnpackBits(Ptr *srcPtr, Ptr *dstPtr, short dstBytes);
 
/* -------- calculate dv and dh; the vertical and horizontal distance */
dv = startPt.v - endPt.v; /* vertical is easy */
dh = FixRound(FixMul(INT2FIX(dv), theSlope));
MoveTo(startPt.h, startPt.v); /* move to start point */
Line(dh, dv);                 /* draw calculated distance */
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        Fixed
        SlopeFromAngle(short angle);
 
Fixed theSlope;
Point startPt, endPt;
short theAngle, dh, dv;
dh = startPt.h - endPt.h; /* calculate the deltas */
dv = startPt.v - endPt.v;
theSlope = FixRatio(INT2FIX(dh), INT2FIX(dv)); /* slope=dh/dv */
theAngle = AngleFromSlope(theSlope);
</ pre>
            * \copyright THINK Reference © 1991 - 1992 Symantec Corporation
 
                                                      *    \non_carbon_cfm in InterfaceLib 7.1 and
    later
        *    \carbon_lib in CarbonLib 1.0 and
    later
        *    \mac_os_x in version 10.0 and
    later
            * /
        short
        AngleFromSlope(Fixed slope);
 
/* New transfer modes */
enum
{
  colorXorXFer = 52,
  noiseXFer = 53,
  customXFer = 54
};
 
/* Custom XFer flags */
enum
{
  kXFer1PixelAtATime = 0x00000001, /* 1 pixel passed to custom XFer proc*/
  kXFerConvertPixelToRGB32 =
      0x00000002 /* All color depths converted to 32 bit RGB*/
};
 
struct CustomXFerRec
{
  UInt32 version;
  void *srcPixels;
  void *destPixels;
  void *resultPixels;
  UInt32 refCon;
  UInt32 pixelSize;
  UInt32 pixelCount;
  Point firstPixelHV;
  Rect destBounds;
};
typedef struct CustomXFerRec CustomXFerRec;
typedef CustomXFerRec *CustomXFerRecPtr;
typedef CALLBACK_API(void, CustomXFerProcPtr)(CustomXFerRecPtr info);
OSErr GetPortCustomXFerProc(CGrafPtr port, CustomXFerProcPtr *proc, UInt32 *flags,
                            UInt32 *refCon);
 
OSErr SetPortCustomXFerProc(CGrafPtr port, CustomXFerProcPtr proc, UInt32 flags,
                            UInt32 refCon);
 
enum
{
  kCursorComponentsVersion = 0x00010001
};
 
enum
{
  kCursorComponentType = FOUR_CHAR_CODE('curs')
};
 
/* Cursor Component capabilities flags */
enum
{
  cursorDoesAnimate = 1L << 0,
  cursorDoesHardware = 1L << 1,
  cursorDoesUnreadableScreenBits = 1L << 2
};
 
/* Cursor Component output mode flags */
enum
{
  kRenderCursorInHardware = 1L << 0,
  kRenderCursorInSoftware = 1L << 1
};
 
/* Cursor Component Info */
struct CursorInfo
{
  long version; /* use kCursorComponentsVersion */
  long capabilities;
  long animateDuration; /* approximate time between animate tickles */
  Rect bounds;
  Point hotspot;
  long reserved; /* must set to zero */
};
typedef struct CursorInfo CursorInfo;
/* Cursor Component Selectors */
enum
{
  kCursorComponentInit = 0x0001,
  kCursorComponentGetInfo = 0x0002,
  kCursorComponentSetOutputMode = 0x0003,
  kCursorComponentSetData = 0x0004,
  kCursorComponentReconfigure = 0x0005,
  kCursorComponentDraw = 0x0006,
  kCursorComponentErase = 0x0007,
  kCursorComponentMove = 0x0008,
  kCursorComponentAnimate = 0x0009,
  kCursorComponentLastReserved = 0x0050
};
 
OSErr OpenCursorComponent(Component c, ComponentInstance *ci);
 
OSErr CloseCursorComponent(ComponentInstance ci);
 
OSErr SetCursorComponent(ComponentInstance ci);
 
OSErr CursorComponentChanged(ComponentInstance ci);
 
OSErr CursorComponentSetData(ComponentInstance ci, long data);
 
/* Quickdraw-specific ColorSync matching */
/* Available in CarbonLib... */
Boolean
IsValidPort(CGrafPtr port);
 
#if ACCESSOR_CALLS_ARE_FUNCTIONS
/* GrafPort */
/* Getters */
PixMapHandle
GetPortPixMap(CGrafPtr port);
 
const BitMap *
GetPortBitMapForCopyBits(CGrafPtr port);
 
Rect *
GetPortBounds(CGrafPtr port, Rect *rect);
 
RGBColor *
GetPortForeColor(CGrafPtr port, RGBColor *foreColor);
 
RGBColor *
GetPortBackColor(CGrafPtr port, RGBColor *backColor);
 
RGBColor *
GetPortOpColor(CGrafPtr port, RGBColor *opColor);
 
RGBColor *
GetPortHiliteColor(CGrafPtr port, RGBColor *hiliteColor);
 
CQDProcsPtr
GetPortGrafProcs(CGrafPtr port);
 
short GetPortTextFont(CGrafPtr port);
 
Style GetPortTextFace(CGrafPtr port);
 
short GetPortTextMode(CGrafPtr port);
 
short GetPortTextSize(CGrafPtr port);
 
short GetPortChExtra(CGrafPtr port);
 
short GetPortFracHPenLocation(CGrafPtr port);
 
Fixed GetPortSpExtra(CGrafPtr port);
 
short GetPortPenVisibility(CGrafPtr port);
 
RgnHandle
GetPortVisibleRegion(CGrafPtr port, RgnHandle visRgn);
 
RgnHandle
GetPortClipRegion(CGrafPtr port, RgnHandle clipRgn);
 
PixPatHandle
GetPortBackPixPat(CGrafPtr port, PixPatHandle backPattern);
 
PixPatHandle
GetPortPenPixPat(CGrafPtr port, PixPatHandle penPattern);
 
PixPatHandle
GetPortFillPixPat(CGrafPtr port, PixPatHandle fillPattern);
 
Point *
GetPortPenSize(CGrafPtr port, Point *penSize);
 
SInt32
GetPortPenMode(CGrafPtr port);
 
Point *
GetPortPenLocation(CGrafPtr port, Point *penLocation);
 
Boolean
IsPortRegionBeingDefined(CGrafPtr port);
 
Boolean
IsPortPictureBeingDefined(CGrafPtr port);
 
Boolean
IsPortPolyBeingDefined(CGrafPtr port);
 
Boolean
IsPortOffscreen(CGrafPtr port);
 
Boolean
IsPortColor(CGrafPtr port);
 
Boolean
IsPortVisibleRegionEmpty(CGrafPtr port);
 
Boolean
IsPortClipRegionEmpty(CGrafPtr port);
 
void SectRegionWithPortClipRegion(CGrafPtr port, RgnHandle ioRegion);
 
void SectRegionWithPortVisibleRegion(CGrafPtr port, RgnHandle ioRegion);
 
/* Swappers */
Handle
SwapPortPicSaveHandle(CGrafPtr port, Handle inPicSaveHdl);
 
/* Setters */
void SetPortBounds(CGrafPtr port, const Rect *rect);
 
void SetPortOpColor(CGrafPtr port, const RGBColor *opColor);
 
void SetPortGrafProcs(CGrafPtr port, CQDProcsPtr procs);
 
void SetPortTextFont(CGrafPtr port, short txFont);
 
void SetPortTextSize(CGrafPtr port, short txSize);
 
void SetPortTextFace(CGrafPtr port, StyleParameter face);
 
void SetPortTextMode(CGrafPtr port, short mode);
 
void SetPortVisibleRegion(CGrafPtr port, RgnHandle visRgn);
 
void SetPortClipRegion(CGrafPtr port, RgnHandle clipRgn);
 
void SetPortPenPixPat(CGrafPtr port, PixPatHandle penPattern);
 
void SetPortFillPixPat(CGrafPtr port, PixPatHandle penPattern);
 
void SetPortBackPixPat(CGrafPtr port, PixPatHandle backPattern);
 
void SetPortPenSize(CGrafPtr port, Point penSize);
 
void SetPortPenMode(CGrafPtr port, SInt32 penMode);
 
void SetPortFracHPenLocation(CGrafPtr port, short pnLocHFrac);
 
/* PixMap */
Rect *
GetPixBounds(PixMapHandle pixMap, Rect *bounds);
 
short GetPixDepth(PixMapHandle pixMap);
 
/* QDGlobals */
/* Getters */
long GetQDGlobalsRandomSeed(void);
 
BitMap *
GetQDGlobalsScreenBits(BitMap *screenBits);
 
Cursor *
GetQDGlobalsArrow(Cursor *arrow);
 
Pattern *
GetQDGlobalsDarkGray(Pattern *dkGray);
 
Pattern *
GetQDGlobalsLightGray(Pattern *ltGray);
 
Pattern *
GetQDGlobalsGray(Pattern *gray);
 
Pattern *
GetQDGlobalsBlack(Pattern *black);
 
Pattern *
GetQDGlobalsWhite(Pattern *white);
 
CGrafPtr
GetQDGlobalsThePort(void);
 
/* Setters */
void SetQDGlobalsRandomSeed(long randomSeed);
 
void SetQDGlobalsArrow(const Cursor *arrow);
 
/* Regions */
Rect *
GetRegionBounds(RgnHandle region, Rect *bounds);
 
Boolean
IsRegionRectangular(RgnHandle region);
 
/* Utilities */
/* To prevent upward dependencies, GetWindowFromPort() is defined in Window
 * Manager interface: */
/*      pascal WindowRef        GetWindowFromPort(CGrafPtr port); */
/* NewPtr/OpenCPort doesn't work with opaque structures */
CGrafPtr
CreateNewPort(void);
 
void DisposePort(CGrafPtr port);
 
void SetQDError(OSErr err);
 
#endif /* ACCESSOR_CALLS_ARE_FUNCTIONS */
 
Boolean
QDIsPortBuffered(CGrafPtr port);
 
Boolean
QDIsPortBufferDirty(CGrafPtr port);
 
void QDFlushPortBuffer(CGrafPtr port, RgnHandle region); /* can be NULL */
 
OSStatus
QDGetDirtyRegion(CGrafPtr port, RgnHandle rgn);
 
OSStatus
QDSetDirtyRegion(CGrafPtr port, RgnHandle rgn);
 
OSStatus
QDAddRectToDirtyRegion(CGrafPtr inPort, const Rect *inBounds);
 
OSStatus
QDAddRegionToDirtyRegion(CGrafPtr inPort, RgnHandle inRegion);
 
OSStatus
CreateCGContextForPort(CGrafPtr inPort, CGContextRef *outContext);
 
OSStatus
ClipCGContextToRegion(CGContextRef gc, const Rect *portRect, RgnHandle region);
 
OSStatus
SyncCGContextOriginWithPort(CGContextRef inContext, CGrafPtr port);
 
OSStatus
QDBeginCGContext(CGrafPtr inPort, CGContextRef *outContext);
 
OSStatus
QDEndCGContext(CGrafPtr inPort, CGContextRef *inoutContext);
 
typedef struct OpaqueQDRegionBitsRef *QDRegionBitsRef;
QDRegionBitsRef
QDSaveRegionBits(RgnHandle region);
 
OSStatus
QDRestoreRegionBits(RgnHandle region, QDRegionBitsRef regionBits);
 
OSStatus
QDDisposeRegionBits(QDRegionBitsRef regionBits);
 
CGrafPtr
CreateNewPortForCGDisplayID(UInt32 inCGDisplayID);
 
void QDDisplayWaitCursor(Boolean forceWaitCursor);
 
void QDSetPatternOrigin(Point origin);
 
void QDGetPatternOrigin(Point *origin);
 
SInt16
LMGetScrVRes(void);
 
void LMSetScrVRes(SInt16 value);
 
SInt16
LMGetScrHRes(void);
 
void LMSetScrHRes(SInt16 value);
 
GDHandle
LMGetMainDevice(void);
 
void LMSetMainDevice(GDHandle value);
 
GDHandle
LMGetDeviceList(void);
 
void LMSetDeviceList(GDHandle value);
 
Handle
LMGetQDColors(void);
 
void LMSetQDColors(Handle value);
 
Handle
LMGetWidthListHand(void);
 
void LMSetWidthListHand(Handle value);
 
UInt8 LMGetHiliteMode(void);
 
void LMSetHiliteMode(UInt8 value);
 
Ptr LMGetWidthPtr(void);
 
void LMSetWidthPtr(Ptr value);
 
Handle
LMGetWidthTabHandle(void);
 
void LMSetWidthTabHandle(Handle value);
 
SInt32
LMGetLastSPExtra(void);
 
void LMSetLastSPExtra(SInt32 value);
 
Handle
LMGetLastFOND(void);
 
void LMSetLastFOND(Handle value);
 
UInt8 LMGetFractEnable(void);
 
void LMSetFractEnable(UInt8 value);
 
GDHandle
LMGetTheGDevice(void);
 
void LMSetTheGDevice(GDHandle value);
 
#if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#define LMGetHiliteRGB(hiliteRGBValue) (*(hiliteRGBValue) = *(RGBColor *)0x0DA0)
#define LMSetHiliteRGB(hiliteRGBValue) \
  ((*(RGBColor *)0x0DA0) = *(hiliteRGBValue))
#else
void LMGetHiliteRGB(RGBColor *hiliteRGBValue);
 
void LMSetHiliteRGB(const RGBColor *hiliteRGBValue);
 
#endif /* TARGET_CPU_68K && !TARGET_RT_MAC_CFM */
 
Boolean
LMGetCursorNew(void);
 
void LMSetCursorNew(Boolean value);
 
#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 /* __QUICKDRAW__ */
in CarbonLib 1.0 and later *    \mac_os_x in version 10.0 and later * / UInt8 LMGetHiliteMode(void);
 
void LMSetHiliteMode(UInt8 value);
 
Ptr LMGetWidthPtr(void);
 
void LMSetWidthPtr(Ptr value);
 
Handle
LMGetWidthTabHandle(void);
 
void LMSetWidthTabHandle(Handle value);
 
SInt32
LMGetLastSPExtra(void);
 
void LMSetLastSPExtra(SInt32 value);
 
Handle
LMGetLastFOND(void);
 
void LMSetLastFOND(Handle value);
 
UInt8 LMGetFractEnable(void);
 
void LMSetFractEnable(UInt8 value);
 
GDHandle
LMGetTheGDevice(void);
 
void LMSetTheGDevice(GDHandle value);
 
#if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
#define LMGetHiliteRGB(hiliteRGBValue) (*(hiliteRGBValue) = *(RGBColor *)0x0DA0)
#define LMSetHiliteRGB(hiliteRGBValue) \
  ((*(RGBColor *)0x0DA0) = *(hiliteRGBValue))
#else
void LMGetHiliteRGB(RGBColor *hiliteRGBValue);
 
void LMSetHiliteRGB(const RGBColor *hiliteRGBValue);
 
#endif /* TARGET_CPU_68K && !TARGET_RT_MAC_CFM */
 
Boolean
LMGetCursorNew(void);
 
void LMSetCursorNew(Boolean value);
 
#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 /* __QUICKDRAW__ */