/************************************************************

Created: Saturday, July 27, 1991 at 5:34 PM
 Quickdraw.h
 C Interface to the Macintosh Libraries


  Copyright Apple Computer, Inc. 1985-1991
  All rights reserved


	Change History (most recent first):

		 <6>	 11/5/93	IH		Sync with Excelsior.
		<SM2>	11/16/92	CSS		Update from Reality:
									<27> 11/13/92 JDR	Updated QuickDraw.h to not use the dangerous pattern type.
		<SM1>	10/19/92	CSS		Directly call the traps for quickdraw.
		<26>	  7/6/92	KON		No longer need bits 5 and 6 in gdFlags. Move bit 4 to bit 6.
		<25>	 6/30/92	KON		Add three new gdFlags: Bit 4 hasAuxMenuBar, Bit 5
									pixelsAreSlewSlow, and Bit 6 whiteIsOff.
		<24>	 5/29/92	DCL		Moved StdText from QuickDraw to QuickDrawText.
		<23>	  5/5/92	DCL		For New Inside Mac: moved text-related calls from TextUtils &
									QuickDraw to QuickdrawText. Weeeeeeee!
		<22>	 4/15/92	DCL		For New Inside Mac: Moved many definitions from Script to
									TextUtils and QuickDraw. And added new synonyms. #1025005
		<21>	 2/18/92	MH		The new, and alternative old definition of Pattern which were
									developed for ETO 6 are added.  The new def prevents certain
									crashes on 68000 machines running code compiled with it.  In
									order to keep the BBS builds working, I have added a tempory
									#define of dangerousPattern, which causes the old def to be
									chosen.  The old def poses no danger to our system code.  The
									#define should be removed when producing interface files for
									external consumption.  Ideally, it should be removed from this
									file and added to {COptions} in the build script.
		<20>	11/11/91	MH		Add comment about the dangers of placing a Pattern at an odd
									alignment in a struct.
		<19>	 11/8/91	JL		Changed PatPtr from a pointer to the Pattern struct to a pointer
									to the same type as the Pattern struct. Pattern is an array and
									therefore a pointer to it would be a pointer to a pointer.
		<18>	 7/31/91	JL		Updated Copyright. Restored Comments.
		<17>	 6/14/91	JL		Moved gdDevType and burstDevice up to previous enum to match the
									DSG database.  Adjusted comments as well. Temporarily lost
									comments for ext32Device and burstDevice; will be restored
									later.  Also lost updated copyright date; will restore later.
		<16>	  2/5/91	stb		gs: add burstDevice and ext32Device
		<15>	 1/28/91	LN		Checked in Database Generated File from DSG. changed
									constPatternParameter to ConstPatternParam.
		<13>	12/14/90	KON		Change name of PICT2Header to OpenCPicParams.[smc]
		<12>	11/27/90	JL		Put formal parameter names back.
		<11>	 11/7/90	JL		Changed all #defines to anonymous enums
		<10>	 11/4/90	dba		created constPatternParameter since Pattern is an array in C;
									got rid of some extraneous parameter names; made some parameters
									void* instead of Ptr; added more use of const in parameters;
									added DisposePixMap, DisposePixPat, DisposeCTable,
									DisposeCCursor, DisposeCIcon, DisposeGDevice
		 <9>	10/21/90	gbm		(with dba) Made compatible with 3.2 C compiler (and incompatible
									with previous compilers).
		 <9>	10/10/90	JAL		New style #Pragma Parameters for MPW 3.2 C
		 <8>	 9/15/90	JSM		Add typedef struct PICT2Header PICT2Header.
		 <7>	 9/15/90	KON		Added equates for OpenCPicture, CopyDeepMask, and the
									CPictureHeader record.
		 <6>	 9/14/90	csd		Added interfaces for the DeviceLoop call.
		 <5>	  9/4/90	kaz		Adding grayishTextOr text mode
	<4>	03/09/90	JAL	Added dithercopy.
	<3>	03/02/90	JAL	Added adMax which is correct spelling.
************************************************************/


#ifndef __QUICKDRAW__
#define __QUICKDRAW__

#ifndef __TYPES__
#include <Types.h>
#endif

#ifndef __QUICKDRAWTEXT__
#include <QuickdrawText.h>  
#endif

#ifndef __ROMFastTrapsIncluded__
#include "ROMFastTraps.h"
#endif


enum {

 invalColReq = -1,					/*invalid color table request*/

/* 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,

/* Arithmetic transfer modes */
 blend = 32,
 addPin = 33
};
enum {
 addOver = 34,
 subPin = 35,
 addMax = 37,
 adMax = 37,
 subOver = 38,
 adMin = 39,
 ditherCopy = 64,

/* Transparent mode constant */
 transparent = 36,

/* 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,
 blackColor = 33,					/*colors expressed in these mappings*/
 whiteColor = 30,
 redColor = 205
};
enum {
 greenColor = 341,
 blueColor = 409,
 cyanColor = 273,
 magentaColor = 137,
 yellowColor = 69,

 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*/
 burstDevice = 7
};
enum {
 roundedDevice = 5,					/* 1 if device has been “rounded” into the GrayRgn */
 hasAuxMenuBar = 6,					/* 1 if device has an aux menu bar on it */
 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 HiliteMode (lowMem flag)*/
 pHiliteBit = 0,					/*flag bit in HiliteMode used with BitClr procedure*/

 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*/

 rgnOverflowErr = -147,				/* Region accumulation failed. Resulting region may be currupt */
 insufficientStackErr = -149		/* QuickDraw could not complete the operation */
};




enum {frame,paint,erase,invert,fill};
typedef unsigned char GrafVerb;

enum {chunky,chunkyPlanar,planar};
typedef unsigned char PixelType;


typedef short Bits16[16];

/***************   IMPORTANT NOTE REGARDING PATTERN  **************************************
   The old array defintion 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.
   Read the details in Appendix J of:
   		"MPW E.T.O. #6 Latest Libraries/Interfaces"
	If you decide that you are safe, and happier with the old definition, you may add
   "-d dangerousPattern" to your C command line to avoid compilation errors without changing
   your source code.
*********************************************************************************************/

#ifdef dangerousPattern
typedef unsigned char Pattern[8];
typedef const unsigned char *ConstPatternParam;
#else
struct Pattern{
   unsigned char pat[8];
};
typedef struct Pattern Pattern;
typedef const Pattern *ConstPatternParam;
#endif
typedef Pattern *PatPtr;
typedef PatPtr *PatHandle;

typedef char QDByte, *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;


struct BitMap {
 Ptr baseAddr;
 short rowBytes;
 Rect bounds;
};

typedef struct BitMap BitMap;
typedef BitMap *BitMapPtr, **BitMapHandle;

struct Cursor {
 Bits16 data;
 Bits16 mask;
 Point hotSpot;
};

typedef struct Cursor Cursor;
typedef Cursor *CursPtr, **CursHandle;

struct PenState {
 Point pnLoc;
 Point pnSize;
 short pnMode;
 Pattern pnPat;
};

typedef struct PenState PenState;

struct Region {
 short rgnSize;						/*size in bytes*/
 Rect rgnBBox;						/*enclosing rectangle*/
};

typedef struct Region Region;
typedef Region *RgnPtr, **RgnHandle;

struct Picture {
 short picSize;
 Rect picFrame;
};

typedef struct Picture Picture;
typedef Picture *PicPtr, **PicHandle;

struct Polygon {
 short polySize;
 Rect polyBBox;
 Point polyPoints[1];
};

typedef struct Polygon Polygon;
typedef Polygon *PolyPtr, **PolyHandle;

struct QDProcs {
 Ptr textProc;
 Ptr lineProc;
 Ptr rectProc;
 Ptr rRectProc;
 Ptr ovalProc;
 Ptr arcProc;
 Ptr polyProc;
 Ptr rgnProc;
 Ptr bitsProc;
 Ptr commentProc;
 Ptr txMeasProc;
 Ptr getPicProc;
 Ptr putPicProc;
};

typedef struct QDProcs QDProcs;
typedef QDProcs *QDProcsPtr;

struct GrafPort {
 short device;
 BitMap portBits;
 Rect portRect;
 RgnHandle visRgn;
 RgnHandle clipRgn;
 Pattern bkPat;
 Pattern fillPat;
 Point pnLoc;
 Point pnSize;
 short pnMode;
 Pattern pnPat;
 short pnVis;
 short txFont;
 Style txFace;						/*txFace is unpacked byte but push as short*/
 char filler;
 short txMode;
 short txSize;
 Fixed spExtra;
 long fgColor;
 long bkColor;
 short colrBit;
 short patStretch;
 Handle picSave;
 Handle rgnSave;
 Handle polySave;
 QDProcsPtr grafProcs;
};

typedef struct GrafPort GrafPort;
typedef GrafPort *GrafPtr;


typedef GrafPtr WindowPtr;

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 pascal Boolean (*ColorSearchProcPtr)(RGBColor *rgb, long *position);
typedef pascal Boolean (*ColorComplementProcPtr)(RGBColor *rgb);

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, **CTabHandle;

struct MatchRec {
 unsigned short red;
 unsigned short green;
 unsigned short blue;
 long matchData;
};

typedef struct MatchRec MatchRec;

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*/
 long planeBytes;					/*offset to next plane*/
 CTabHandle pmTable;				/*color map for this pixMap*/
 long pmReserved;					/*for future use. MUST BE 0*/
};

typedef struct PixMap PixMap;
typedef PixMap *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, **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, **CCrsrHandle;

struct CIcon {
 PixMap iconPMap;					/*the icon's pixMap*/
 BitMap iconMask;					/*the icon's mask*/
 BitMap iconBMap;					/*the icon's bitMap*/
 Handle iconData;					/*the icon's data*/
 short iconMaskData[1];				/*icon's mask and BitMap data*/
};

typedef struct CIcon CIcon;
typedef CIcon *CIconPtr, **CIconHandle;

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, **GammaTblHandle;

struct ITab {
 long iTabSeed;						/*copy of CTSeed from source CTable*/
 short iTabRes;						/*bits/channel resolution of iTable*/
 unsigned char iTTable[1];			/*byte colortable index values*/
};

typedef struct ITab ITab;
typedef ITab *ITabPtr, **ITabHandle;

struct SProcRec {
 Handle nxtSrch;					/*SProcHndl Handle to next SProcRec*/
 ColorSearchProcPtr srchProc;		/*pointer to search procedure*/
};

typedef struct SProcRec SProcRec;
typedef SProcRec *SProcPtr, **SProcHndl;

struct CProcRec {
 Handle nxtComp;					/*CProcHndl Handle to next CProcRec*/
 ColorComplementProcPtr compProc;	/*pointer to complement procedure*/
};

typedef struct CProcRec CProcRec;
typedef CProcRec *CProcPtr, **CProcHndl;

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*/
 Handle 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*/
 long gdReserved;					/*future use. MUST BE 0*/
};

typedef struct GDevice GDevice;
typedef GDevice *GDPtr, **GDHandle;

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, **GVarHandle;

struct CQDProcs {
 Ptr textProc;
 Ptr lineProc;
 Ptr rectProc;
 Ptr rRectProc;
 Ptr ovalProc;
 Ptr arcProc;
 Ptr polyProc;
 Ptr rgnProc;
 Ptr bitsProc;
 Ptr commentProc;
 Ptr txMeasProc;
 Ptr getPicProc;
 Ptr putPicProc;
 Ptr opcodeProc;					/*fields added to QDProcs*/
 Ptr newProc1;
 Ptr newProc2;
 Ptr newProc3;
 Ptr newProc4;
 Ptr newProc5;
 Ptr newProc6;
};

typedef struct CQDProcs CQDProcs;
typedef CQDProcs *CQDProcsPtr;

struct CGrafPort {
 short device;
 PixMapHandle portPixMap;			/*port's pixel map*/
 short portVersion;					/*high 2 bits always set*/
 Handle grafVars;					/*Handle to more fields*/
 short chExtra;						/*character extra*/
 short pnLocHFrac;					/*pen fraction*/
 Rect portRect;
 RgnHandle visRgn;
 RgnHandle clipRgn;
 PixPatHandle bkPixPat;				/*background pattern*/
 RGBColor rgbFgColor;				/*RGB components of fg*/
 RGBColor rgbBkColor;				/*RGB components of bk*/
 Point pnLoc;
 Point pnSize;
 short pnMode;
 PixPatHandle pnPixPat;				/*pen's pattern*/
 PixPatHandle fillPixPat;			/*fill pattern*/
 short pnVis;
 short txFont;
 Style txFace;						/*txFace is unpacked byte  push as short*/
 char filler;
 short txMode;
 short txSize;
 Fixed spExtra;
 long fgColor;
 long bkColor;
 short colrBit;
 short patStretch;
 Handle picSave;
 Handle rgnSave;
 Handle polySave;
 CQDProcsPtr grafProcs;
};

typedef struct CGrafPort CGrafPort;
typedef CGrafPort *CGrafPtr;


typedef CGrafPtr CWindowPtr;

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;


typedef pascal void (*DeviceLoopDrawingProcPtr)(short depth, short deviceFlags, GDHandle targetDevice,  long userData);




extern struct  {
char privates[76];
long randSeed;
BitMap screenBits;
Cursor arrow;
Pattern dkGray;
Pattern ltGray;
Pattern gray;
Pattern black;
Pattern white;
GrafPtr thePort;
}qd;


#ifdef __cplusplus
extern "C" {
#endif

pascal void InitGraf(void *globalPtr)
 = {__GenToolboxTrapCode(0xA86E)}; 
pascal void OpenPort(GrafPtr port)
 = {__GenToolboxTrapCode(0xA86F)}; 
pascal void InitPort(GrafPtr port)
 = {__GenToolboxTrapCode(0xA86D)}; 
pascal void ClosePort(GrafPtr port)
 = {__GenToolboxTrapCode(0xA87D)}; 
pascal void SetPort(GrafPtr port)
 = {__GenToolboxTrapCode(0xA873)}; 
pascal void GetPort(GrafPtr *port)
 = {__GenToolboxTrapCode(0xA874)}; 
pascal void GrafDevice(short device)
 = {__GenToolboxTrapCode(0xA872)}; 
pascal void SetPortBits(const BitMap *bm)
 = {__GenToolboxTrapCode(0xA875)}; 
pascal void PortSize(short width,short height)
 = {__GenToolboxTrapCode(0xA876)}; 
pascal void MovePortTo(short leftGlobal,short topGlobal)
 = {__GenToolboxTrapCode(0xA877)}; 
pascal void SetOrigin(short h,short v)
 = {__GenToolboxTrapCode(0xA878)}; 
pascal void SetClip(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA879)}; 
pascal void GetClip(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA87A)}; 
pascal void ClipRect(const Rect *r)
 = {__GenToolboxTrapCode(0xA87B)}; 
pascal void BackPat(ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA87C)}; 
pascal void InitCursor(void)
 = {__GenToolboxTrapCode(0xA850)}; 
pascal void SetCursor(const Cursor *crsr)
 = {__GenToolboxTrapCode(0xA851)}; 
pascal void HideCursor(void)
 = {__GenToolboxTrapCode(0xA852)}; 
pascal void ShowCursor(void)
 = {__GenToolboxTrapCode(0xA853)}; 
pascal void ObscureCursor(void)
 = {__GenToolboxTrapCode(0xA856)}; 
pascal void HidePen(void)
 = {__GenToolboxTrapCode(0xA896)}; 
pascal void ShowPen(void)
 = {__GenToolboxTrapCode(0xA897)}; 
pascal void GetPen(Point *pt)
 = {__GenToolboxTrapCode(0xA89A)}; 
pascal void GetPenState(PenState *pnState)
 = {__GenToolboxTrapCode(0xA898)}; 
pascal void SetPenState(const PenState *pnState)
 = {__GenToolboxTrapCode(0xA899)}; 
pascal void PenSize(short width,short height)
 = {__GenToolboxTrapCode(0xA89B)}; 
pascal void PenMode(short mode)
 = {__GenToolboxTrapCode(0xA89C)}; 
pascal void PenPat(ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA89D)}; 
pascal void PenNormal(void)
 = {__GenToolboxTrapCode(0xA89E)}; 
pascal void MoveTo(short h,short v)
 = {__GenToolboxTrapCode(0xA893)}; 
pascal void Move(short dh,short dv)
 = {__GenToolboxTrapCode(0xA894)}; 
pascal void LineTo(short h,short v)
 = {__GenToolboxTrapCode(0xA891)}; 
pascal void Line(short dh,short dv)
 = {__GenToolboxTrapCode(0xA892)}; 
pascal void ForeColor(long color)
 = {__GenToolboxTrapCode(0xA862)}; 
pascal void BackColor(long color)
 = {__GenToolboxTrapCode(0xA863)}; 
pascal void ColorBit(short whichBit)
 = {__GenToolboxTrapCode(0xA864)}; 
pascal void SetRect(Rect *r,short left,short top,short right,short bottom)
 = {__GenToolboxTrapCode(0xA8A7)}; 
pascal void OffsetRect(Rect *r,short dh,short dv)
 = {__GenToolboxTrapCode(0xA8A8)}; 
pascal void InsetRect(Rect *r,short dh,short dv)
 = {__GenToolboxTrapCode(0xA8A9)}; 
pascal Boolean SectRect(const Rect *src1,const Rect *src2,Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8AA)}; 
pascal void UnionRect(const Rect *src1,const Rect *src2,Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8AB)}; 
pascal Boolean EqualRect(const Rect *rect1,const Rect *rect2)
 = {__GenToolboxTrapCode(0xA8A6)}; 
pascal Boolean EmptyRect(const Rect *r)
 = {__GenToolboxTrapCode(0xA8AE)}; 
pascal void FrameRect(const Rect *r)
 = {__GenToolboxTrapCode(0xA8A1)}; 
pascal void PaintRect(const Rect *r)
 = {__GenToolboxTrapCode(0xA8A2)}; 
pascal void EraseRect(const Rect *r)
 = {__GenToolboxTrapCode(0xA8A3)}; 
pascal void InvertRect(const Rect *r)
 = {__GenToolboxTrapCode(0xA8A4)}; 
pascal void FillRect(const Rect *r,ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA8A5)}; 
pascal void FrameOval(const Rect *r)
 = {__GenToolboxTrapCode(0xA8B7)}; 
pascal void PaintOval(const Rect *r)
 = {__GenToolboxTrapCode(0xA8B8)}; 
pascal void EraseOval(const Rect *r)
 = {__GenToolboxTrapCode(0xA8B9)}; 
pascal void InvertOval(const Rect *r)
 = {__GenToolboxTrapCode(0xA8BA)}; 
pascal void FillOval(const Rect *r,ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA8BB)}; 
pascal void FrameRoundRect(const Rect *r,short ovalWidth,short ovalHeight)
 = {__GenToolboxTrapCode(0xA8B0)}; 
pascal void PaintRoundRect(const Rect *r,short ovalWidth,short ovalHeight)
 = {__GenToolboxTrapCode(0xA8B1)}; 
pascal void EraseRoundRect(const Rect *r,short ovalWidth,short ovalHeight)
 = {__GenToolboxTrapCode(0xA8B2)}; 
pascal void InvertRoundRect(const Rect *r,short ovalWidth,short ovalHeight)
 = {__GenToolboxTrapCode(0xA8B3)}; 
pascal void FillRoundRect(const Rect *r,short ovalWidth,short ovalHeight,
 ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA8B4)}; 
pascal void FrameArc(const Rect *r,short startAngle,short arcAngle)
 = {__GenToolboxTrapCode(0xA8BE)}; 
pascal void PaintArc(const Rect *r,short startAngle,short arcAngle)
 = {__GenToolboxTrapCode(0xA8BF)}; 
pascal void EraseArc(const Rect *r,short startAngle,short arcAngle)
 = {__GenToolboxTrapCode(0xA8C0)}; 
pascal void InvertArc(const Rect *r,short startAngle,short arcAngle)
 = {__GenToolboxTrapCode(0xA8C1)}; 
pascal void FillArc(const Rect *r,short startAngle,short arcAngle,ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA8C2)}; 
pascal RgnHandle NewRgn(void)
 = {__GenToolboxTrapCode(0xA8D8)}; 
pascal void OpenRgn(void)
 = {__GenToolboxTrapCode(0xA8DA)}; 
pascal void CloseRgn(RgnHandle dstRgn)
 = {__GenToolboxTrapCode(0xA8DB)}; 
pascal OSErr BitMapToRegionGlue(RgnHandle region,const BitMap *bMap); 
pascal OSErr BitMapToRegion(RgnHandle region,const BitMap *bMap)
 = {__GenToolboxTrapCode(0xA8D7)}; 
pascal void DisposeRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8D9)}; 
pascal void CopyRgn(RgnHandle srcRgn,RgnHandle dstRgn)
 = {__GenToolboxTrapCode(0xA8DC)}; 
pascal void SetEmptyRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8DD)}; 
pascal void SetRectRgn(RgnHandle rgn,short left,short top,short right,short bottom)
 = {__GenToolboxTrapCode(0xA8DE)}; 
pascal void RectRgn(RgnHandle rgn,const Rect *r)
 = {__GenToolboxTrapCode(0xA8DF)}; 
pascal void OffsetRgn(RgnHandle rgn,short dh,short dv)
 = {__GenToolboxTrapCode(0xA8E0)}; 
pascal void InsetRgn(RgnHandle rgn,short dh,short dv)
 = {__GenToolboxTrapCode(0xA8E1)}; 
pascal void SectRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn)
 = {__GenToolboxTrapCode(0xA8E4)}; 
pascal void UnionRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn)
 = {__GenToolboxTrapCode(0xA8E5)}; 
pascal void DiffRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn)
 = {__GenToolboxTrapCode(0xA8E6)}; 
pascal void XorRgn(RgnHandle srcRgnA,RgnHandle srcRgnB,RgnHandle dstRgn)
 = {__GenToolboxTrapCode(0xA8E7)}; 
pascal Boolean RectInRgn(const Rect *r,RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8E9)}; 
pascal Boolean EqualRgn(RgnHandle rgnA,RgnHandle rgnB)
 = {__GenToolboxTrapCode(0xA8E3)}; 
pascal Boolean EmptyRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8E2)}; 
pascal void FrameRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8D2)}; 
pascal void PaintRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8D3)}; 
pascal void EraseRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8D4)}; 
pascal void InvertRgn(RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8D5)}; 
pascal void FillRgn(RgnHandle rgn,ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA8D6)}; 
pascal void ScrollRect(const Rect *r,short dh,short dv,RgnHandle updateRgn)
 = {__GenToolboxTrapCode(0xA8EF)}; 
pascal void CopyBits(const BitMap *srcBits,const BitMap *dstBits,const Rect *srcRect,
 const Rect *dstRect,short mode,RgnHandle maskRgn)
 = {__GenToolboxTrapCode(0xA8EC)}; 
pascal void SeedFill(const void *srcPtr,void *dstPtr,short srcRow,short dstRow,
 short height,short words,short seedH,short seedV)
 = {__GenToolboxTrapCode(0xA839)}; 
pascal void CalcMask(const void *srcPtr,void *dstPtr,short srcRow,short dstRow,
 short height,short words)
 = {__GenToolboxTrapCode(0xA838)}; 
pascal void CopyMask(const BitMap *srcBits,const BitMap *maskBits,const BitMap *dstBits,
 const Rect *srcRect,const Rect *maskRect,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA817)}; 
pascal PicHandle OpenPicture(const Rect *picFrame)
 = {__GenToolboxTrapCode(0xA8F3)}; 
pascal void PicComment(short kind,short dataSize,Handle dataHandle)
 = {__GenToolboxTrapCode(0xA8F2)}; 
pascal void ClosePicture(void)
 = {__GenToolboxTrapCode(0xA8F4)}; 
pascal void DrawPicture(PicHandle myPicture,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8F6)}; 
pascal void KillPicture(PicHandle myPicture)
 = {__GenToolboxTrapCode(0xA8F5)}; 
pascal PolyHandle OpenPoly(void)
 = {__GenToolboxTrapCode(0xA8CB)}; 
pascal void ClosePoly(void)
 = {__GenToolboxTrapCode(0xA8CC)}; 
pascal void KillPoly(PolyHandle poly)
 = {__GenToolboxTrapCode(0xA8CD)}; 
pascal void OffsetPoly(PolyHandle poly,short dh,short dv)
 = {__GenToolboxTrapCode(0xA8CE)}; 
pascal void FramePoly(PolyHandle poly)
 = {__GenToolboxTrapCode(0xA8C6)}; 
pascal void PaintPoly(PolyHandle poly)
 = {__GenToolboxTrapCode(0xA8C7)}; 
pascal void ErasePoly(PolyHandle poly)
 = {__GenToolboxTrapCode(0xA8C8)}; 
pascal void InvertPoly(PolyHandle poly)
 = {__GenToolboxTrapCode(0xA8C9)}; 
pascal void FillPoly(PolyHandle poly,ConstPatternParam pat)
 = {__GenToolboxTrapCode(0xA8CA)}; 
pascal void SetPt(Point *pt,short h,short v)
 = {__GenToolboxTrapCode(0xA880)}; 
pascal void LocalToGlobal(Point *pt)
 = {__GenToolboxTrapCode(0xA870)}; 
pascal void GlobalToLocal(Point *pt)
 = {__GenToolboxTrapCode(0xA871)}; 
pascal short Random(void)
 = {__GenToolboxTrapCode(0xA861)}; 
pascal void StuffHex(void *thingPtr,ConstStr255Param s)
 = {__GenToolboxTrapCode(0xA866)}; 
pascal Boolean GetPixel(short h,short v)
 = {__GenToolboxTrapCode(0xA865)}; 
pascal void ScalePt(Point *pt,const Rect *srcRect,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8F8)}; 
pascal void MapPt(Point *pt,const Rect *srcRect,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8F9)}; 
pascal void MapRect(Rect *r,const Rect *srcRect,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8FA)}; 
pascal void MapRgn(RgnHandle rgn,const Rect *srcRect,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8FB)}; 
pascal void MapPoly(PolyHandle poly,const Rect *srcRect,const Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8FC)}; 
pascal void SetStdProcs(QDProcs *procs)
 = {__GenToolboxTrapCode(0xA8EA)}; 
pascal void StdRect(GrafVerb verb,const Rect *r)
 = {__GenToolboxTrapCode(0xA8A0)}; 
pascal void StdRRect(GrafVerb verb,const Rect *r,short ovalWidth,short ovalHeight)
 = {__GenToolboxTrapCode(0xA8AF)}; 
pascal void StdOval(GrafVerb verb,const Rect *r)
 = {__GenToolboxTrapCode(0xA8B6)}; 
pascal void StdArc(GrafVerb verb,const Rect *r,short startAngle,short arcAngle)
 = {__GenToolboxTrapCode(0xA8BD)}; 
pascal void StdPoly(GrafVerb verb,PolyHandle poly)
 = {__GenToolboxTrapCode(0xA8C5)}; 
pascal void StdRgn(GrafVerb verb,RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8D1)}; 
pascal void StdBits(const BitMap *srcBits,const Rect *srcRect,const Rect *dstRect,
 short mode,RgnHandle maskRgn)
 = {__GenToolboxTrapCode(0xA8EB)}; 
pascal void StdComment(short kind,short dataSize,Handle dataHandle)
 = {__GenToolboxTrapCode(0xA8F1)}; 
pascal void StdGetPic(void *dataPtr,short byteCount)
 = {__GenToolboxTrapCode(0xA8EE)}; 
pascal void StdPutPic(const void *dataPtr,short byteCount)
 = {__GenToolboxTrapCode(0xA8F0)}; 
pascal void AddPt(Point src,Point *dst)
 = {__GenToolboxTrapCode(0xA87E)}; 
void subpt(Point *src,Point *dst); 
pascal Boolean EqualPt(Point pt1,Point pt2)
 = {__GenToolboxTrapCode(0xA881)}; 
pascal Boolean PtInRect(Point pt,const Rect *r)
 = {__GenToolboxTrapCode(0xA8AD)}; 
pascal void Pt2Rect(Point pt1,Point pt2,Rect *dstRect)
 = {__GenToolboxTrapCode(0xA8AC)}; 
pascal void PtToAngle(const Rect *r,Point pt,short *angle)
 = {__GenToolboxTrapCode(0xA8C3)}; 
pascal Boolean PtInRgn(Point pt,RgnHandle rgn)
 = {__GenToolboxTrapCode(0xA8E8)}; 
pascal void StdLine(Point newPt)
 = {__GenToolboxTrapCode(0xA890)}; 
pascal void OpenCPort(CGrafPtr port)
 = {__GenToolboxTrapCode(0xAA00)}; 
pascal void InitCPort(CGrafPtr port)
 = {__GenToolboxTrapCode(0xAA01)}; 
pascal void CloseCPort(CGrafPtr port)
 = {__GenToolboxTrapCode(0xA87D)}; 
pascal PixMapHandle NewPixMap(void)
 = {__GenToolboxTrapCode(0xAA03)}; 
pascal void DisposPixMap(PixMapHandle pm)
 = {__GenToolboxTrapCode(0xAA04)}; 
pascal void DisposePixMap(PixMapHandle pm)
 = {__GenToolboxTrapCode(0xAA04)}; 
pascal void CopyPixMap(PixMapHandle srcPM,PixMapHandle dstPM)
 = {__GenToolboxTrapCode(0xAA05)}; 
pascal PixPatHandle NewPixPat(void)
 = {__GenToolboxTrapCode(0xAA07)}; 
pascal void DisposPixPat(PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA08)}; 
pascal void DisposePixPat(PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA08)}; 
pascal void CopyPixPat(PixPatHandle srcPP,PixPatHandle dstPP)
 = {__GenToolboxTrapCode(0xAA09)}; 
pascal void PenPixPat(PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA0A)}; 
pascal void BackPixPat(PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA0B)}; 
pascal PixPatHandle GetPixPat(short patID)
 = {__GenToolboxTrapCode(0xAA0C)}; 
pascal void MakeRGBPat(PixPatHandle pp,const RGBColor *myColor)
 = {__GenToolboxTrapCode(0xAA0D)}; 
pascal void FillCRect(const Rect *r,PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA0E)}; 
pascal void FillCOval(const Rect *r,PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA0F)}; 
pascal void FillCRoundRect(const Rect *r,short ovalWidth,short ovalHeight,
 PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA10)}; 
pascal void FillCArc(const Rect *r,short startAngle,short arcAngle,PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA11)}; 
pascal void FillCRgn(RgnHandle rgn,PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA12)}; 
pascal void FillCPoly(PolyHandle poly,PixPatHandle pp)
 = {__GenToolboxTrapCode(0xAA13)}; 
pascal void RGBForeColor(const RGBColor *color)
 = {__GenToolboxTrapCode(0xAA14)}; 
pascal void RGBBackColor(const RGBColor *color)
 = {__GenToolboxTrapCode(0xAA15)}; 
pascal void SetCPixel(short h,short v,const RGBColor *cPix)
 = {__GenToolboxTrapCode(0xAA16)}; 
pascal void SetPortPix(PixMapHandle pm)
 = {__GenToolboxTrapCode(0xAA06)}; 
pascal void GetCPixel(short h,short v,RGBColor *cPix)
 = {__GenToolboxTrapCode(0xAA17)}; 
pascal void GetForeColor(RGBColor *color)
 = {__GenToolboxTrapCode(0xAA19)}; 
pascal void GetBackColor(RGBColor *color)
 = {__GenToolboxTrapCode(0xAA1A)}; 
pascal void SeedCFill(const BitMap *srcBits,const BitMap *dstBits,const Rect *srcRect,
 const Rect *dstRect,short seedH,short seedV,ColorSearchProcPtr matchProc,
 long matchData)
 = {__GenToolboxTrapCode(0xAA50)}; 
pascal void CalcCMask(const BitMap *srcBits,const BitMap *dstBits,const Rect *srcRect,
 const Rect *dstRect,const RGBColor *seedRGB,ColorSearchProcPtr matchProc,
 long matchData)
 = {__GenToolboxTrapCode(0xAA4F)}; 
pascal PicHandle OpenCPicture(const OpenCPicParams *newHeader)
 = {__GenToolboxTrapCode(0xAA20)}; 
pascal void OpColor(const RGBColor *color)
 = {__GenToolboxTrapCode(0xAA21)}; 
pascal void HiliteColor(const RGBColor *color)
 = {__GenToolboxTrapCode(0xAA22)}; 
pascal void DisposCTable(CTabHandle cTable)
 = {__GenToolboxTrapCode(0xAA24)}; 
pascal void DisposeCTable(CTabHandle cTable)
 = {__GenToolboxTrapCode(0xAA24)}; 
pascal CTabHandle GetCTable(short ctID)
 = {__GenToolboxTrapCode(0xAA18)}; 
pascal CCrsrHandle GetCCursor(short crsrID)
 = {__GenToolboxTrapCode(0xAA1B)}; 
pascal void SetCCursor(CCrsrHandle cCrsr)
 = {__GenToolboxTrapCode(0xAA1C)}; 
pascal void AllocCursor(void)
 = {__GenToolboxTrapCode(0xAA1D)}; 
pascal void DisposCCursor(CCrsrHandle cCrsr)
 = {__GenToolboxTrapCode(0xAA26)}; 
pascal void DisposeCCursor(CCrsrHandle cCrsr)
 = {__GenToolboxTrapCode(0xAA26)}; 
pascal CIconHandle GetCIcon(short iconID)
 = {__GenToolboxTrapCode(0xAA1E)}; 
pascal void PlotCIcon(const Rect *theRect,CIconHandle theIcon)
 = {__GenToolboxTrapCode(0xAA1F)}; 
pascal void DisposCIcon(CIconHandle theIcon)
 = {__GenToolboxTrapCode(0xAA25)}; 
pascal void DisposeCIcon(CIconHandle theIcon)
 = {__GenToolboxTrapCode(0xAA25)}; 
pascal void SetStdCProcs(CQDProcs *procs)
 = {__GenToolboxTrapCode(0xAA4E)}; 
pascal GDHandle GetMaxDevice(const Rect *globalRect)
 = {__GenToolboxTrapCode(0xAA27)}; 
pascal long GetCTSeed(void)
 = {__GenToolboxTrapCode(0xAA28)}; 
pascal GDHandle GetDeviceList(void)
 = {__GenToolboxTrapCode(0xAA29)}; 
pascal GDHandle GetMainDevice(void)
 = {__GenToolboxTrapCode(0xAA2A)}; 
pascal GDHandle GetNextDevice(GDHandle curDevice)
 = {__GenToolboxTrapCode(0xAA2B)}; 
pascal Boolean TestDeviceAttribute(GDHandle gdh,short attribute)
 = {__GenToolboxTrapCode(0xAA2C)}; 
pascal void SetDeviceAttribute(GDHandle gdh,short attribute,Boolean value)
 = {__GenToolboxTrapCode(0xAA2D)}; 
pascal void InitGDevice(short qdRefNum,long mode,GDHandle gdh)
 = {__GenToolboxTrapCode(0xAA2E)}; 
pascal GDHandle NewGDevice(short refNum,long mode)
 = {__GenToolboxTrapCode(0xAA2F)}; 
pascal void DisposGDevice(GDHandle gdh)
 = {__GenToolboxTrapCode(0xAA30)}; 
pascal void DisposeGDevice(GDHandle gdh)
 = {__GenToolboxTrapCode(0xAA30)}; 
pascal void SetGDevice(GDHandle gd)
 = {__GenToolboxTrapCode(0xAA31)}; 
pascal GDHandle GetGDevice(void)
 = {__GenToolboxTrapCode(0xAA32)}; 
pascal long Color2Index(const RGBColor *myColor)
 = {__GenToolboxTrapCode(0xAA33)}; 
pascal void Index2Color(long index,RGBColor *aColor)
 = {__GenToolboxTrapCode(0xAA34)}; 
pascal void InvertColor(RGBColor *myColor)
 = {__GenToolboxTrapCode(0xAA35)}; 
pascal Boolean RealColor(const RGBColor *color)
 = {__GenToolboxTrapCode(0xAA36)}; 
pascal void GetSubTable(CTabHandle myColors,short iTabRes,CTabHandle targetTbl)
 = {__GenToolboxTrapCode(0xAA37)}; 
pascal void MakeITable(CTabHandle cTabH,ITabHandle iTabH,short res)
 = {__GenToolboxTrapCode(0xAA39)}; 
pascal void AddSearch(ColorSearchProcPtr searchProc)
 = {__GenToolboxTrapCode(0xAA3A)}; 
pascal void AddComp(ColorComplementProcPtr compProc)
 = {__GenToolboxTrapCode(0xAA3B)}; 
pascal void DelSearch(ColorSearchProcPtr searchProc)
 = {__GenToolboxTrapCode(0xAA4C)}; 
pascal void DelComp(ColorComplementProcPtr compProc)
 = {__GenToolboxTrapCode(0xAA4D)}; 
pascal void SubPt(Point src,Point *dst)
 = {__GenToolboxTrapCode(0xA87F)}; 
pascal void SetClientID(short id)
 = {__GenToolboxTrapCode(0xAA3C)}; 
pascal void ProtectEntry(short index,Boolean protect)
 = {__GenToolboxTrapCode(0xAA3D)}; 
Boolean equalpt(Point *pt1,Point *pt2); 
pascal void ReserveEntry(short index,Boolean reserve)
 = {__GenToolboxTrapCode(0xAA3E)}; 
pascal void SetEntries(short start,short count,CSpecArray aTable)
 = {__GenToolboxTrapCode(0xAA3F)}; 
Boolean ptinrect(Point *pt,const Rect *r); 
pascal void SaveEntries(CTabHandle srcTable,CTabHandle resultTable,ReqListRec *selection)
 = {__GenToolboxTrapCode(0xAA49)}; 
pascal void RestoreEntries(CTabHandle srcTable,CTabHandle dstTable,ReqListRec *selection)
 = {__GenToolboxTrapCode(0xAA4A)}; 
void pt2rect(Point *pt1,Point *pt2,const Rect *destRect); 
pascal short QDError(void)
 = {__GenToolboxTrapCode(0xAA40)}; 
pascal void CopyDeepMask(const BitMap *srcBits,const BitMap *maskBits,const BitMap *dstBits,
 const Rect *srcRect,const Rect *maskRect,const Rect *dstRect,short mode,
 RgnHandle maskRgn)
 = {__GenToolboxTrapCode(0xAA51)}; 
pascal void DeviceLoop(RgnHandle drawingRgn,DeviceLoopDrawingProcPtr drawingProc,
 long userData,DeviceLoopFlags flags)
 = {__GenToolboxTrapCode(0xABCA)}; 
#pragma parameter __A0 GetMaskTable
pascal Ptr GetMaskTable(void)
 = {__GenToolboxTrapCode(0xA836)}; 
void pttoangle(const Rect *r,Point *pt,short *angle); 
Boolean ptinrgn(Point *pt,RgnHandle rgn); 
void stdline(Point *newPt); 
void drawstring(char *s); 
void addpt(Point *src,Point *dst); 
void stuffhex(Ptr thingPtr,char *s); 
short stringwidth(char *s);


#ifdef __cplusplus
}
#endif

#endif