mirror of
https://github.com/elliotnunn/mac-rom.git
synced 2024-06-01 07:41:58 +00:00
4325cdcc78
Resource forks are included only for .rsrc files. These are DeRezzed into their data fork. 'ckid' resources, from the Projector VCS, are not included. The Tools directory, containing mostly junk, is also excluded.
991 lines
28 KiB
OpenEdge ABL
991 lines
28 KiB
OpenEdge ABL
|
|
{
|
|
Created: Saturday, July 27, 1991 at 10:42 PM
|
|
Quickdraw.p
|
|
Pascal Interface to the Macintosh Libraries
|
|
|
|
Copyright Apple Computer, Inc. 1985-1991
|
|
All rights reserved
|
|
|
|
Change History (most recent first):
|
|
|
|
<19> 7/6/92 KON No longer need bits 5 and 6 in gdFlags. Move bit 4 to bit 6.
|
|
<18> 6/30/92 KON Add three new gdFlags: Bit 4 hasAuxMenuBar, Bit 5
|
|
pixelsAreSlewSlow, and Bit 6 whiteIsOff.
|
|
<17> 5/29/92 DCL Moved StdText from QuickDraw to QuickDrawText.
|
|
<16> 5/5/92 DCL For New Inside Mac: removing 'sc' prefixes from some calls,
|
|
moving some calls from script to TextUtils, and moving some from
|
|
TextUtils & QuickDraw to QuickdrawText. Weeeeeeee!
|
|
<15> 4/15/92 DCL For New Inside Mac: Moved many definitions from Script to
|
|
TextUtils and QuickDraw. And added new synonyms. #1025005
|
|
<14> 7/31/91 JL Updated Copyright. Restored Comments.
|
|
<13> 2/4/91 JL Added burstDevice and ext32Device.
|
|
<12> 1/28/91 LN Checked in Database Generated File from DSG. Added Dispose
|
|
synonym for Dispos calls.
|
|
<11> 12/14/90 KON Change name of PICT2Header to OpenCPicParams.[smc]
|
|
<10> 10/3/90 JAL Added Inline for GetMaskTable, Added BitMapToRegionGlue call
|
|
for pre Mac II machines, changed QDProcsPtr to a CQDProcsPtr
|
|
in CGrafPort, added RGBDirect, baseAddr32, rgnOverflowErr,
|
|
and insufficientStackErr
|
|
<9> 9/15/90 KON Added CopyDeepMask, OpenCPicture, and PICT2Header record.
|
|
<8> 9/14/90 csd Added interfaces for the DeviceLoop call.
|
|
<7> 9/4/90 kaz Adding grayishTextOr text mode.
|
|
<6> 6/19/90 DVB Add "ColorSpecPtr" type
|
|
|
|
To Do:
|
|
}
|
|
|
|
|
|
{$IFC UNDEFINED UsingIncludes}
|
|
{$SETC UsingIncludes := 0}
|
|
{$ENDC}
|
|
|
|
{$IFC NOT UsingIncludes}
|
|
UNIT Quickdraw;
|
|
INTERFACE
|
|
{$ENDC}
|
|
|
|
{$IFC UNDEFINED UsingQuickdraw}
|
|
{$SETC UsingQuickdraw := 1}
|
|
|
|
{$I+}
|
|
{$SETC QuickdrawIncludes := UsingIncludes}
|
|
{$SETC UsingIncludes := 1}
|
|
{$IFC UNDEFINED UsingTypes}
|
|
{$I $$Shell(PInterfaces)Types.p}
|
|
{$ENDC}
|
|
{$IFC UNDEFINED UsingQuickdrawText}
|
|
{$I $$Shell(PInterfaces)QuickdrawText.p}
|
|
{$ENDC}
|
|
{$SETC UsingIncludes := QuickdrawIncludes}
|
|
|
|
CONST
|
|
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;
|
|
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;
|
|
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}
|
|
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 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 }
|
|
|
|
|
|
|
|
TYPE
|
|
GrafVerb = (frame,paint,erase,invert,fill);
|
|
|
|
PixelType = (chunky,chunkyPlanar,planar);
|
|
|
|
|
|
|
|
PatPtr = ^Pattern;
|
|
PatHandle = ^PatPtr;
|
|
|
|
Pattern = PACKED ARRAY [0..7] OF 0..255;
|
|
|
|
QDByte = SignedByte;
|
|
|
|
QDPtr = Ptr; { blind pointer }
|
|
|
|
QDHandle = Handle; { blind handle }
|
|
|
|
|
|
|
|
QDErr = INTEGER;
|
|
|
|
Bits16 = ARRAY [0..15] OF INTEGER;
|
|
|
|
|
|
|
|
DeviceLoopFlags = SET OF (singleDevices,dontMatchSeeds,allDevices,DeviceLoopFlags3,
|
|
DeviceLoopFlags4,DeviceLoopFlags5,DeviceLoopFlags6,DeviceLoopFlags7,DeviceLoopFlags8,
|
|
DeviceLoopFlags9,DeviceLoopFlags10,DeviceLoopFlags11,DeviceLoopFlags12,
|
|
DeviceLoopFlags13,DeviceLoopFlags14,DeviceLoopFlags15,DeviceLoopFlags16,
|
|
DeviceLoopFlags17,DeviceLoopFlags18,DeviceLoopFlags19,DeviceLoopFlags20,
|
|
DeviceLoopFlags21,DeviceLoopFlags22,DeviceLoopFlags23,DeviceLoopFlags24,
|
|
DeviceLoopFlags25,DeviceLoopFlags26,DeviceLoopFlags27,DeviceLoopFlags28,
|
|
DeviceLoopFlags29,DeviceLoopFlags30,DeviceLoopFlags31);
|
|
|
|
|
|
BitMapPtr = ^BitMap;
|
|
BitMapHandle = ^BitMapPtr;
|
|
BitMap = RECORD
|
|
baseAddr: Ptr;
|
|
rowBytes: INTEGER;
|
|
bounds: Rect;
|
|
END;
|
|
|
|
CursPtr = ^Cursor;
|
|
CursHandle = ^CursPtr;
|
|
Cursor = RECORD
|
|
data: Bits16;
|
|
mask: Bits16;
|
|
hotSpot: Point;
|
|
END;
|
|
|
|
PenState = RECORD
|
|
pnLoc: Point;
|
|
pnSize: Point;
|
|
pnMode: INTEGER;
|
|
pnPat: Pattern;
|
|
END;
|
|
|
|
RgnPtr = ^Region;
|
|
RgnHandle = ^RgnPtr;
|
|
Region = RECORD
|
|
rgnSize: INTEGER; {size in bytes}
|
|
rgnBBox: Rect; {enclosing rectangle}
|
|
END;
|
|
|
|
PicPtr = ^Picture;
|
|
PicHandle = ^PicPtr;
|
|
Picture = RECORD
|
|
picSize: INTEGER;
|
|
picFrame: Rect;
|
|
END;
|
|
|
|
PolyPtr = ^Polygon;
|
|
PolyHandle = ^PolyPtr;
|
|
Polygon = RECORD
|
|
polySize: INTEGER;
|
|
polyBBox: Rect;
|
|
polyPoints: ARRAY [0..0] OF Point;
|
|
END;
|
|
|
|
QDProcsPtr = ^QDProcs;
|
|
QDProcs = RECORD
|
|
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;
|
|
END;
|
|
|
|
GrafPtr = ^GrafPort;
|
|
GrafPort = RECORD
|
|
device: INTEGER;
|
|
portBits: BitMap;
|
|
portRect: Rect;
|
|
visRgn: RgnHandle;
|
|
clipRgn: RgnHandle;
|
|
bkPat: Pattern;
|
|
fillPat: Pattern;
|
|
pnLoc: Point;
|
|
pnSize: Point;
|
|
pnMode: INTEGER;
|
|
pnPat: Pattern;
|
|
pnVis: INTEGER;
|
|
txFont: INTEGER;
|
|
txFace: Style; {txFace is unpacked byte but push as short}
|
|
txMode: INTEGER;
|
|
txSize: INTEGER;
|
|
spExtra: Fixed;
|
|
fgColor: LONGINT;
|
|
bkColor: LONGINT;
|
|
colrBit: INTEGER;
|
|
patStretch: INTEGER;
|
|
picSave: Handle;
|
|
rgnSave: Handle;
|
|
polySave: Handle;
|
|
grafProcs: QDProcsPtr;
|
|
END;
|
|
|
|
|
|
WindowPtr = GrafPtr;
|
|
|
|
{typedef pascal Boolean (*ColorSearchProcPtr)(RGBColor *rgb, long *position);
|
|
typedef pascal Boolean (*ColorComplementProcPtr)(RGBColor *rgb);}
|
|
|
|
RGBColor = RECORD
|
|
red: INTEGER; {magnitude of red component}
|
|
green: INTEGER; {magnitude of green component}
|
|
blue: INTEGER; {magnitude of blue component}
|
|
END;
|
|
|
|
ColorSpecPtr = ^ColorSpec;
|
|
ColorSpec = RECORD
|
|
value: INTEGER; {index or other value}
|
|
rgb: RGBColor; {true color}
|
|
END;
|
|
|
|
|
|
CSpecArray = ARRAY [0..0] OF ColorSpec;
|
|
|
|
CTabPtr = ^ColorTable;
|
|
CTabHandle = ^CTabPtr;
|
|
ColorTable = RECORD
|
|
ctSeed: LONGINT; {unique identifier for table}
|
|
ctFlags: INTEGER; {high bit: 0 = PixMap; 1 = device}
|
|
ctSize: INTEGER; {number of entries in CTTable}
|
|
ctTable: CSpecArray; {array [0..0] of ColorSpec}
|
|
END;
|
|
|
|
MatchRec = RECORD
|
|
red: INTEGER;
|
|
green: INTEGER;
|
|
blue: INTEGER;
|
|
matchData: LONGINT;
|
|
END;
|
|
|
|
PixMapPtr = ^PixMap;
|
|
PixMapHandle = ^PixMapPtr;
|
|
PixMap = RECORD
|
|
baseAddr: Ptr; {pointer to pixels}
|
|
rowBytes: INTEGER; {offset to next line}
|
|
bounds: Rect; {encloses bitmap}
|
|
pmVersion: INTEGER; {pixMap version number}
|
|
packType: INTEGER; {defines packing format}
|
|
packSize: LONGINT; {length of pixel data}
|
|
hRes: Fixed; {horiz. resolution (ppi)}
|
|
vRes: Fixed; {vert. resolution (ppi)}
|
|
pixelType: INTEGER; {defines pixel type}
|
|
pixelSize: INTEGER; {# bits in pixel}
|
|
cmpCount: INTEGER; {# components in pixel}
|
|
cmpSize: INTEGER; {# bits per component}
|
|
planeBytes: LONGINT; {offset to next plane}
|
|
pmTable: CTabHandle; {color map for this pixMap}
|
|
pmReserved: LONGINT; {for future use. MUST BE 0}
|
|
END;
|
|
|
|
PixPatPtr = ^PixPat;
|
|
PixPatHandle = ^PixPatPtr;
|
|
PixPat = RECORD
|
|
patType: INTEGER; {type of pattern}
|
|
patMap: PixMapHandle; {the pattern's pixMap}
|
|
patData: Handle; {pixmap's data}
|
|
patXData: Handle; {expanded Pattern data}
|
|
patXValid: INTEGER; {flags whether expanded Pattern valid}
|
|
patXMap: Handle; {Handle to expanded Pattern data}
|
|
pat1Data: Pattern; {old-Style pattern/RGB color}
|
|
END;
|
|
|
|
CCrsrPtr = ^CCrsr;
|
|
CCrsrHandle = ^CCrsrPtr;
|
|
CCrsr = RECORD
|
|
crsrType: INTEGER; {type of cursor}
|
|
crsrMap: PixMapHandle; {the cursor's pixmap}
|
|
crsrData: Handle; {cursor's data}
|
|
crsrXData: Handle; {expanded cursor data}
|
|
crsrXValid: INTEGER; {depth of expanded data (0 if none)}
|
|
crsrXHandle: Handle; {future use}
|
|
crsr1Data: Bits16; {one-bit cursor}
|
|
crsrMask: Bits16; {cursor's mask}
|
|
crsrHotSpot: Point; {cursor's hotspot}
|
|
crsrXTable: LONGINT; {private}
|
|
crsrID: LONGINT; {private}
|
|
END;
|
|
|
|
CIconPtr = ^CIcon;
|
|
CIconHandle = ^CIconPtr;
|
|
CIcon = RECORD
|
|
iconPMap: PixMap; {the icon's pixMap}
|
|
iconMask: BitMap; {the icon's mask}
|
|
iconBMap: BitMap; {the icon's bitMap}
|
|
iconData: Handle; {the icon's data}
|
|
iconMaskData: ARRAY [0..0] OF INTEGER; {icon's mask and BitMap data}
|
|
END;
|
|
|
|
GammaTblPtr = ^GammaTbl;
|
|
GammaTblHandle = ^GammaTblPtr;
|
|
GammaTbl = RECORD
|
|
gVersion: INTEGER; {gamma version number}
|
|
gType: INTEGER; {gamma data type}
|
|
gFormulaSize: INTEGER; {Formula data size}
|
|
gChanCnt: INTEGER; {number of channels of data}
|
|
gDataCnt: INTEGER; {number of values/channel}
|
|
gDataWidth: INTEGER; {bits/corrected value (data packed to next larger byte size)}
|
|
gFormulaData: ARRAY [0..0] OF INTEGER; {data for formulas followed by gamma values}
|
|
END;
|
|
|
|
ITabPtr = ^ITab;
|
|
ITabHandle = ^ITabPtr;
|
|
ITab = RECORD
|
|
iTabSeed: LONGINT; {copy of CTSeed from source CTable}
|
|
iTabRes: INTEGER; {bits/channel resolution of iTable}
|
|
iTTable: ARRAY [0..0] OF SignedByte; {byte colortable index values}
|
|
END;
|
|
|
|
SProcPtr = ^SProcRec;
|
|
SProcHndl = ^SProcPtr;
|
|
SProcRec = RECORD
|
|
nxtSrch: Handle; {SProcHndl Handle to next SProcRec}
|
|
srchProc: ProcPtr; {pointer to search procedure}
|
|
END;
|
|
|
|
CProcPtr = ^CProcRec;
|
|
CProcHndl = ^CProcPtr;
|
|
CProcRec = RECORD
|
|
nxtComp: CProcHndl; {CProcHndl Handle to next CProcRec}
|
|
compProc: ProcPtr; {pointer to complement procedure}
|
|
END;
|
|
|
|
GDPtr = ^GDevice;
|
|
GDHandle = ^GDPtr;
|
|
GDevice = RECORD
|
|
gdRefNum: INTEGER; {driver's unit number}
|
|
gdID: INTEGER; {client ID for search procs}
|
|
gdType: INTEGER; {fixed/CLUT/direct}
|
|
gdITable: ITabHandle; {Handle to inverse lookup table}
|
|
gdResPref: INTEGER; {preferred resolution of GDITable}
|
|
gdSearchProc: SProcHndl; {search proc list head}
|
|
gdCompProc: CProcHndl; {complement proc list}
|
|
gdFlags: INTEGER; {grafDevice flags word}
|
|
gdPMap: PixMapHandle; {describing pixMap}
|
|
gdRefCon: LONGINT; {reference value}
|
|
gdNextGD: GDHandle; {GDHandle Handle of next gDevice}
|
|
gdRect: Rect; { device's bounds in global coordinates}
|
|
gdMode: LONGINT; {device's current mode}
|
|
gdCCBytes: INTEGER; {depth of expanded cursor data}
|
|
gdCCDepth: INTEGER; {depth of expanded cursor data}
|
|
gdCCXData: Handle; {Handle to cursor's expanded data}
|
|
gdCCXMask: Handle; {Handle to cursor's expanded mask}
|
|
gdReserved: LONGINT; {future use. MUST BE 0}
|
|
END;
|
|
|
|
GVarPtr = ^GrafVars;
|
|
GVarHandle = ^GVarPtr;
|
|
GrafVars = RECORD
|
|
rgbOpColor: RGBColor; {color for addPin subPin and average}
|
|
rgbHiliteColor: RGBColor; {color for hiliting}
|
|
pmFgColor: Handle; {palette Handle for foreground color}
|
|
pmFgIndex: INTEGER; {index value for foreground}
|
|
pmBkColor: Handle; {palette Handle for background color}
|
|
pmBkIndex: INTEGER; {index value for background}
|
|
pmFlags: INTEGER; {flags for Palette Manager}
|
|
END;
|
|
|
|
CQDProcsPtr = ^CQDProcs;
|
|
CQDProcs = RECORD
|
|
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: Ptr; {fields added to QDProcs}
|
|
newProc1: Ptr;
|
|
newProc2: Ptr;
|
|
newProc3: Ptr;
|
|
newProc4: Ptr;
|
|
newProc5: Ptr;
|
|
newProc6: Ptr;
|
|
END;
|
|
|
|
CGrafPtr = ^CGrafPort;
|
|
CGrafPort = RECORD
|
|
device: INTEGER;
|
|
portPixMap: PixMapHandle; {port's pixel map}
|
|
portVersion: INTEGER; {high 2 bits always set}
|
|
grafVars: Handle; {Handle to more fields}
|
|
chExtra: INTEGER; {character extra}
|
|
pnLocHFrac: INTEGER; {pen fraction}
|
|
portRect: Rect;
|
|
visRgn: RgnHandle;
|
|
clipRgn: RgnHandle;
|
|
bkPixPat: PixPatHandle; {background pattern}
|
|
rgbFgColor: RGBColor; {RGB components of fg}
|
|
rgbBkColor: RGBColor; {RGB components of bk}
|
|
pnLoc: Point;
|
|
pnSize: Point;
|
|
pnMode: INTEGER;
|
|
pnPixPat: PixPatHandle; {pen's pattern}
|
|
fillPixPat: PixPatHandle; {fill pattern}
|
|
pnVis: INTEGER;
|
|
txFont: INTEGER;
|
|
txFace: Style; {txFace is unpacked byte push as short}
|
|
txMode: INTEGER;
|
|
txSize: INTEGER;
|
|
spExtra: Fixed;
|
|
fgColor: LONGINT;
|
|
bkColor: LONGINT;
|
|
colrBit: INTEGER;
|
|
patStretch: INTEGER;
|
|
picSave: Handle;
|
|
rgnSave: Handle;
|
|
polySave: Handle;
|
|
grafProcs: CQDProcsPtr;
|
|
END;
|
|
|
|
|
|
CWindowPtr = CGrafPtr;
|
|
|
|
ReqListRec = RECORD
|
|
reqLSize: INTEGER; {request list size}
|
|
reqLData: ARRAY [0..0] OF INTEGER; {request list data}
|
|
END;
|
|
|
|
OpenCPicParams = RECORD
|
|
srcRect: Rect;
|
|
hRes: Fixed;
|
|
vRes: Fixed;
|
|
version: INTEGER;
|
|
reserved1: INTEGER;
|
|
reserved2: LONGINT;
|
|
END;
|
|
|
|
|
|
DeviceLoopDrawingProcPtr = ProcPtr;
|
|
|
|
|
|
VAR
|
|
{$PUSH}
|
|
{$J+}
|
|
thePort: GrafPtr;
|
|
white: Pattern;
|
|
black: Pattern;
|
|
gray: Pattern;
|
|
ltGray: Pattern;
|
|
dkGray: Pattern;
|
|
arrow: Cursor;
|
|
screenBits: BitMap;
|
|
randSeed: LONGINT;
|
|
{$POP}
|
|
|
|
|
|
|
|
PROCEDURE InitGraf(globalPtr: Ptr);
|
|
INLINE $A86E;
|
|
PROCEDURE OpenPort(port: GrafPtr);
|
|
INLINE $A86F;
|
|
PROCEDURE InitPort(port: GrafPtr);
|
|
INLINE $A86D;
|
|
PROCEDURE ClosePort(port: GrafPtr);
|
|
INLINE $A87D;
|
|
PROCEDURE SetPort(port: GrafPtr);
|
|
INLINE $A873;
|
|
PROCEDURE GetPort(VAR port: GrafPtr);
|
|
INLINE $A874;
|
|
PROCEDURE GrafDevice(device: INTEGER);
|
|
INLINE $A872;
|
|
PROCEDURE SetPortBits(bm: BitMap);
|
|
INLINE $A875;
|
|
PROCEDURE PortSize(width: INTEGER;height: INTEGER);
|
|
INLINE $A876;
|
|
PROCEDURE MovePortTo(leftGlobal: INTEGER;topGlobal: INTEGER);
|
|
INLINE $A877;
|
|
PROCEDURE SetOrigin(h: INTEGER;v: INTEGER);
|
|
INLINE $A878;
|
|
PROCEDURE SetClip(rgn: RgnHandle);
|
|
INLINE $A879;
|
|
PROCEDURE GetClip(rgn: RgnHandle);
|
|
INLINE $A87A;
|
|
PROCEDURE ClipRect(r: Rect);
|
|
INLINE $A87B;
|
|
PROCEDURE BackPat(pat: Pattern);
|
|
INLINE $A87C;
|
|
PROCEDURE InitCursor;
|
|
INLINE $A850;
|
|
PROCEDURE SetCursor(crsr: Cursor);
|
|
INLINE $A851;
|
|
PROCEDURE HideCursor;
|
|
INLINE $A852;
|
|
PROCEDURE ShowCursor;
|
|
INLINE $A853;
|
|
PROCEDURE ObscureCursor;
|
|
INLINE $A856;
|
|
PROCEDURE HidePen;
|
|
INLINE $A896;
|
|
PROCEDURE ShowPen;
|
|
INLINE $A897;
|
|
PROCEDURE GetPen(VAR pt: Point);
|
|
INLINE $A89A;
|
|
PROCEDURE GetPenState(VAR pnState: PenState);
|
|
INLINE $A898;
|
|
PROCEDURE SetPenState(pnState: PenState);
|
|
INLINE $A899;
|
|
PROCEDURE PenSize(width: INTEGER;height: INTEGER);
|
|
INLINE $A89B;
|
|
PROCEDURE PenMode(mode: INTEGER);
|
|
INLINE $A89C;
|
|
PROCEDURE PenPat(pat: Pattern);
|
|
INLINE $A89D;
|
|
PROCEDURE PenNormal;
|
|
INLINE $A89E;
|
|
PROCEDURE MoveTo(h: INTEGER;v: INTEGER);
|
|
INLINE $A893;
|
|
PROCEDURE Move(dh: INTEGER;dv: INTEGER);
|
|
INLINE $A894;
|
|
PROCEDURE LineTo(h: INTEGER;v: INTEGER);
|
|
INLINE $A891;
|
|
PROCEDURE Line(dh: INTEGER;dv: INTEGER);
|
|
INLINE $A892;
|
|
PROCEDURE ForeColor(color: LONGINT);
|
|
INLINE $A862;
|
|
PROCEDURE BackColor(color: LONGINT);
|
|
INLINE $A863;
|
|
PROCEDURE ColorBit(whichBit: INTEGER);
|
|
INLINE $A864;
|
|
PROCEDURE SetRect(VAR r: Rect;left: INTEGER;top: INTEGER;right: INTEGER;
|
|
bottom: INTEGER);
|
|
INLINE $A8A7;
|
|
PROCEDURE OffsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
|
|
INLINE $A8A8;
|
|
PROCEDURE InsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
|
|
INLINE $A8A9;
|
|
FUNCTION SectRect(src1: Rect;src2: Rect;VAR dstRect: Rect): BOOLEAN;
|
|
INLINE $A8AA;
|
|
PROCEDURE UnionRect(src1: Rect;src2: Rect;VAR dstRect: Rect);
|
|
INLINE $A8AB;
|
|
FUNCTION EqualRect(rect1: Rect;rect2: Rect): BOOLEAN;
|
|
INLINE $A8A6;
|
|
FUNCTION EmptyRect(r: Rect): BOOLEAN;
|
|
INLINE $A8AE;
|
|
PROCEDURE FrameRect(r: Rect);
|
|
INLINE $A8A1;
|
|
PROCEDURE PaintRect(r: Rect);
|
|
INLINE $A8A2;
|
|
PROCEDURE EraseRect(r: Rect);
|
|
INLINE $A8A3;
|
|
PROCEDURE InvertRect(r: Rect);
|
|
INLINE $A8A4;
|
|
PROCEDURE FillRect(r: Rect;pat: Pattern);
|
|
INLINE $A8A5;
|
|
PROCEDURE FrameOval(r: Rect);
|
|
INLINE $A8B7;
|
|
PROCEDURE PaintOval(r: Rect);
|
|
INLINE $A8B8;
|
|
PROCEDURE EraseOval(r: Rect);
|
|
INLINE $A8B9;
|
|
PROCEDURE InvertOval(r: Rect);
|
|
INLINE $A8BA;
|
|
PROCEDURE FillOval(r: Rect;pat: Pattern);
|
|
INLINE $A8BB;
|
|
PROCEDURE FrameRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
|
|
INLINE $A8B0;
|
|
PROCEDURE PaintRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
|
|
INLINE $A8B1;
|
|
PROCEDURE EraseRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
|
|
INLINE $A8B2;
|
|
PROCEDURE InvertRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
|
|
INLINE $A8B3;
|
|
PROCEDURE FillRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
|
|
pat: Pattern);
|
|
INLINE $A8B4;
|
|
PROCEDURE FrameArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
|
|
INLINE $A8BE;
|
|
PROCEDURE PaintArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
|
|
INLINE $A8BF;
|
|
PROCEDURE EraseArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
|
|
INLINE $A8C0;
|
|
PROCEDURE InvertArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
|
|
INLINE $A8C1;
|
|
PROCEDURE FillArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pat: Pattern);
|
|
INLINE $A8C2;
|
|
FUNCTION NewRgn: RgnHandle;
|
|
INLINE $A8D8;
|
|
PROCEDURE OpenRgn;
|
|
INLINE $A8DA;
|
|
PROCEDURE CloseRgn(dstRgn: RgnHandle);
|
|
INLINE $A8DB;
|
|
FUNCTION BitMapToRegionGlue(region: RgnHandle;bMap: BitMap): OSErr;
|
|
FUNCTION BitMapToRegion(region: RgnHandle;bMap: BitMap): OSErr;
|
|
INLINE $A8D7;
|
|
PROCEDURE DisposeRgn(rgn: RgnHandle);
|
|
INLINE $A8D9;
|
|
PROCEDURE CopyRgn(srcRgn: RgnHandle;dstRgn: RgnHandle);
|
|
INLINE $A8DC;
|
|
PROCEDURE SetEmptyRgn(rgn: RgnHandle);
|
|
INLINE $A8DD;
|
|
PROCEDURE SetRectRgn(rgn: RgnHandle;left: INTEGER;top: INTEGER;right: INTEGER;
|
|
bottom: INTEGER);
|
|
INLINE $A8DE;
|
|
PROCEDURE RectRgn(rgn: RgnHandle;r: Rect);
|
|
INLINE $A8DF;
|
|
PROCEDURE OffsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
|
|
INLINE $A8E0;
|
|
PROCEDURE InsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
|
|
INLINE $A8E1;
|
|
PROCEDURE SectRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
|
|
INLINE $A8E4;
|
|
PROCEDURE UnionRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
|
|
INLINE $A8E5;
|
|
PROCEDURE DiffRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
|
|
INLINE $A8E6;
|
|
PROCEDURE XorRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
|
|
INLINE $A8E7;
|
|
FUNCTION RectInRgn(r: Rect;rgn: RgnHandle): BOOLEAN;
|
|
INLINE $A8E9;
|
|
FUNCTION EqualRgn(rgnA: RgnHandle;rgnB: RgnHandle): BOOLEAN;
|
|
INLINE $A8E3;
|
|
FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
|
|
INLINE $A8E2;
|
|
PROCEDURE FrameRgn(rgn: RgnHandle);
|
|
INLINE $A8D2;
|
|
PROCEDURE PaintRgn(rgn: RgnHandle);
|
|
INLINE $A8D3;
|
|
PROCEDURE EraseRgn(rgn: RgnHandle);
|
|
INLINE $A8D4;
|
|
PROCEDURE InvertRgn(rgn: RgnHandle);
|
|
INLINE $A8D5;
|
|
PROCEDURE FillRgn(rgn: RgnHandle;pat: Pattern);
|
|
INLINE $A8D6;
|
|
PROCEDURE ScrollRect(r: Rect;dh: INTEGER;dv: INTEGER;updateRgn: RgnHandle);
|
|
INLINE $A8EF;
|
|
PROCEDURE CopyBits(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
|
|
mode: INTEGER;maskRgn: RgnHandle);
|
|
INLINE $A8EC;
|
|
PROCEDURE SeedFill(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
|
|
height: INTEGER;words: INTEGER;seedH: INTEGER;seedV: INTEGER);
|
|
INLINE $A839;
|
|
PROCEDURE CalcMask(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
|
|
height: INTEGER;words: INTEGER);
|
|
INLINE $A838;
|
|
PROCEDURE CopyMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;srcRect: Rect;
|
|
maskRect: Rect;dstRect: Rect);
|
|
INLINE $A817;
|
|
FUNCTION OpenPicture(picFrame: Rect): PicHandle;
|
|
INLINE $A8F3;
|
|
PROCEDURE PicComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
|
|
INLINE $A8F2;
|
|
PROCEDURE ClosePicture;
|
|
INLINE $A8F4;
|
|
PROCEDURE DrawPicture(myPicture: PicHandle;dstRect: Rect);
|
|
INLINE $A8F6;
|
|
PROCEDURE KillPicture(myPicture: PicHandle);
|
|
INLINE $A8F5;
|
|
FUNCTION OpenPoly: PolyHandle;
|
|
INLINE $A8CB;
|
|
PROCEDURE ClosePoly;
|
|
INLINE $A8CC;
|
|
PROCEDURE KillPoly(poly: PolyHandle);
|
|
INLINE $A8CD;
|
|
PROCEDURE OffsetPoly(poly: PolyHandle;dh: INTEGER;dv: INTEGER);
|
|
INLINE $A8CE;
|
|
PROCEDURE FramePoly(poly: PolyHandle);
|
|
INLINE $A8C6;
|
|
PROCEDURE PaintPoly(poly: PolyHandle);
|
|
INLINE $A8C7;
|
|
PROCEDURE ErasePoly(poly: PolyHandle);
|
|
INLINE $A8C8;
|
|
PROCEDURE InvertPoly(poly: PolyHandle);
|
|
INLINE $A8C9;
|
|
PROCEDURE FillPoly(poly: PolyHandle;pat: Pattern);
|
|
INLINE $A8CA;
|
|
PROCEDURE SetPt(VAR pt: Point;h: INTEGER;v: INTEGER);
|
|
INLINE $A880;
|
|
PROCEDURE LocalToGlobal(VAR pt: Point);
|
|
INLINE $A870;
|
|
PROCEDURE GlobalToLocal(VAR pt: Point);
|
|
INLINE $A871;
|
|
FUNCTION Random: INTEGER;
|
|
INLINE $A861;
|
|
PROCEDURE StuffHex(thingPtr: Ptr;s: Str255);
|
|
INLINE $A866;
|
|
FUNCTION GetPixel(h: INTEGER;v: INTEGER): BOOLEAN;
|
|
INLINE $A865;
|
|
PROCEDURE ScalePt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
|
|
INLINE $A8F8;
|
|
PROCEDURE MapPt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
|
|
INLINE $A8F9;
|
|
PROCEDURE MapRect(VAR r: Rect;srcRect: Rect;dstRect: Rect);
|
|
INLINE $A8FA;
|
|
PROCEDURE MapRgn(rgn: RgnHandle;srcRect: Rect;dstRect: Rect);
|
|
INLINE $A8FB;
|
|
PROCEDURE MapPoly(poly: PolyHandle;srcRect: Rect;dstRect: Rect);
|
|
INLINE $A8FC;
|
|
PROCEDURE SetStdProcs(VAR procs: QDProcs);
|
|
INLINE $A8EA;
|
|
PROCEDURE StdRect(verb: GrafVerb;r: Rect);
|
|
INLINE $A8A0;
|
|
PROCEDURE StdRRect(verb: GrafVerb;r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
|
|
INLINE $A8AF;
|
|
PROCEDURE StdOval(verb: GrafVerb;r: Rect);
|
|
INLINE $A8B6;
|
|
PROCEDURE StdArc(verb: GrafVerb;r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
|
|
INLINE $A8BD;
|
|
PROCEDURE StdPoly(verb: GrafVerb;poly: PolyHandle);
|
|
INLINE $A8C5;
|
|
PROCEDURE StdRgn(verb: GrafVerb;rgn: RgnHandle);
|
|
INLINE $A8D1;
|
|
PROCEDURE StdBits(VAR srcBits: BitMap;VAR srcRect: Rect;dstRect: Rect;mode: INTEGER;
|
|
maskRgn: RgnHandle);
|
|
INLINE $A8EB;
|
|
PROCEDURE StdComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
|
|
INLINE $A8F1;
|
|
PROCEDURE StdGetPic(dataPtr: Ptr;byteCount: INTEGER);
|
|
INLINE $A8EE;
|
|
PROCEDURE StdPutPic(dataPtr: Ptr;byteCount: INTEGER);
|
|
INLINE $A8F0;
|
|
PROCEDURE AddPt(src: Point;VAR dst: Point);
|
|
INLINE $A87E;
|
|
FUNCTION EqualPt(pt1: Point;pt2: Point): BOOLEAN;
|
|
INLINE $A881;
|
|
FUNCTION PtInRect(pt: Point;r: Rect): BOOLEAN;
|
|
INLINE $A8AD;
|
|
PROCEDURE Pt2Rect(pt1: Point;pt2: Point;VAR dstRect: Rect);
|
|
INLINE $A8AC;
|
|
PROCEDURE PtToAngle(r: Rect;pt: Point;VAR angle: INTEGER);
|
|
INLINE $A8C3;
|
|
FUNCTION PtInRgn(pt: Point;rgn: RgnHandle): BOOLEAN;
|
|
INLINE $A8E8;
|
|
PROCEDURE StdLine(newPt: Point);
|
|
INLINE $A890;
|
|
PROCEDURE OpenCPort(port: CGrafPtr);
|
|
INLINE $AA00;
|
|
PROCEDURE InitCPort(port: CGrafPtr);
|
|
INLINE $AA01;
|
|
PROCEDURE CloseCPort(port: CGrafPtr);
|
|
INLINE $A87D;
|
|
FUNCTION NewPixMap: PixMapHandle;
|
|
INLINE $AA03;
|
|
PROCEDURE DisposPixMap(pm: PixMapHandle);
|
|
INLINE $AA04;
|
|
PROCEDURE DisposePixMap(pm: PixMapHandle);
|
|
INLINE $AA04;
|
|
PROCEDURE CopyPixMap(srcPM: PixMapHandle;dstPM: PixMapHandle);
|
|
INLINE $AA05;
|
|
FUNCTION NewPixPat: PixPatHandle;
|
|
INLINE $AA07;
|
|
PROCEDURE DisposPixPat(pp: PixPatHandle);
|
|
INLINE $AA08;
|
|
PROCEDURE DisposePixPat(pp: PixPatHandle);
|
|
INLINE $AA08;
|
|
PROCEDURE CopyPixPat(srcPP: PixPatHandle;dstPP: PixPatHandle);
|
|
INLINE $AA09;
|
|
PROCEDURE PenPixPat(pp: PixPatHandle);
|
|
INLINE $AA0A;
|
|
PROCEDURE BackPixPat(pp: PixPatHandle);
|
|
INLINE $AA0B;
|
|
FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
|
|
INLINE $AA0C;
|
|
PROCEDURE MakeRGBPat(pp: PixPatHandle;myColor: RGBColor);
|
|
INLINE $AA0D;
|
|
PROCEDURE FillCRect(r: Rect;pp: PixPatHandle);
|
|
INLINE $AA0E;
|
|
PROCEDURE FillCOval(r: Rect;pp: PixPatHandle);
|
|
INLINE $AA0F;
|
|
PROCEDURE FillCRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
|
|
pp: PixPatHandle);
|
|
INLINE $AA10;
|
|
PROCEDURE FillCArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pp: PixPatHandle);
|
|
INLINE $AA11;
|
|
PROCEDURE FillCRgn(rgn: RgnHandle;pp: PixPatHandle);
|
|
INLINE $AA12;
|
|
PROCEDURE FillCPoly(poly: PolyHandle;pp: PixPatHandle);
|
|
INLINE $AA13;
|
|
PROCEDURE RGBForeColor(color: RGBColor);
|
|
INLINE $AA14;
|
|
PROCEDURE RGBBackColor(color: RGBColor);
|
|
INLINE $AA15;
|
|
PROCEDURE SetCPixel(h: INTEGER;v: INTEGER;cPix: RGBColor);
|
|
INLINE $AA16;
|
|
PROCEDURE SetPortPix(pm: PixMapHandle);
|
|
INLINE $AA06;
|
|
PROCEDURE GetCPixel(h: INTEGER;v: INTEGER;VAR cPix: RGBColor);
|
|
INLINE $AA17;
|
|
PROCEDURE GetForeColor(VAR color: RGBColor);
|
|
INLINE $AA19;
|
|
PROCEDURE GetBackColor(VAR color: RGBColor);
|
|
INLINE $AA1A;
|
|
PROCEDURE SeedCFill(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
|
|
seedH: INTEGER;seedV: INTEGER;matchProc: ProcPtr;matchData: LONGINT);
|
|
INLINE $AA50;
|
|
PROCEDURE CalcCMask(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
|
|
seedRGB: RGBColor;matchProc: ProcPtr;matchData: LONGINT);
|
|
INLINE $AA4F;
|
|
FUNCTION OpenCPicture(newHeader: OpenCPicParams): PicHandle;
|
|
INLINE $AA20;
|
|
PROCEDURE OpColor(color: RGBColor);
|
|
INLINE $AA21;
|
|
PROCEDURE HiliteColor(color: RGBColor);
|
|
INLINE $AA22;
|
|
PROCEDURE DisposCTable(cTable: CTabHandle);
|
|
INLINE $AA24;
|
|
PROCEDURE DisposeCTable(cTable: CTabHandle);
|
|
INLINE $AA24;
|
|
FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
|
|
INLINE $AA18;
|
|
FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
|
|
INLINE $AA1B;
|
|
PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
|
|
INLINE $AA1C;
|
|
PROCEDURE AllocCursor;
|
|
INLINE $AA1D;
|
|
PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
|
|
INLINE $AA26;
|
|
PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
|
|
INLINE $AA26;
|
|
FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
|
|
INLINE $AA1E;
|
|
PROCEDURE PlotCIcon(theRect: Rect;theIcon: CIconHandle);
|
|
INLINE $AA1F;
|
|
PROCEDURE DisposCIcon(theIcon: CIconHandle);
|
|
INLINE $AA25;
|
|
PROCEDURE DisposeCIcon(theIcon: CIconHandle);
|
|
INLINE $AA25;
|
|
PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
|
|
INLINE $AA4E;
|
|
FUNCTION GetMaxDevice(globalRect: Rect): GDHandle;
|
|
INLINE $AA27;
|
|
FUNCTION GetCTSeed: LONGINT;
|
|
INLINE $AA28;
|
|
FUNCTION GetDeviceList: GDHandle;
|
|
INLINE $AA29;
|
|
FUNCTION GetMainDevice: GDHandle;
|
|
INLINE $AA2A;
|
|
FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
|
|
INLINE $AA2B;
|
|
FUNCTION TestDeviceAttribute(gdh: GDHandle;attribute: INTEGER): BOOLEAN;
|
|
INLINE $AA2C;
|
|
PROCEDURE SetDeviceAttribute(gdh: GDHandle;attribute: INTEGER;value: BOOLEAN);
|
|
INLINE $AA2D;
|
|
PROCEDURE InitGDevice(qdRefNum: INTEGER;mode: LONGINT;gdh: GDHandle);
|
|
INLINE $AA2E;
|
|
FUNCTION NewGDevice(refNum: INTEGER;mode: LONGINT): GDHandle;
|
|
INLINE $AA2F;
|
|
PROCEDURE DisposGDevice(gdh: GDHandle);
|
|
INLINE $AA30;
|
|
PROCEDURE DisposeGDevice(gdh: GDHandle);
|
|
INLINE $AA30;
|
|
PROCEDURE SetGDevice(gd: GDHandle);
|
|
INLINE $AA31;
|
|
FUNCTION GetGDevice: GDHandle;
|
|
INLINE $AA32;
|
|
FUNCTION Color2Index(myColor: RGBColor): LONGINT;
|
|
INLINE $AA33;
|
|
PROCEDURE Index2Color(index: LONGINT;VAR aColor: RGBColor);
|
|
INLINE $AA34;
|
|
PROCEDURE InvertColor(VAR myColor: RGBColor);
|
|
INLINE $AA35;
|
|
FUNCTION RealColor(color: RGBColor): BOOLEAN;
|
|
INLINE $AA36;
|
|
PROCEDURE GetSubTable(myColors: CTabHandle;iTabRes: INTEGER;targetTbl: CTabHandle);
|
|
INLINE $AA37;
|
|
PROCEDURE MakeITable(cTabH: CTabHandle;iTabH: ITabHandle;res: INTEGER);
|
|
INLINE $AA39;
|
|
PROCEDURE AddSearch(searchProc: ProcPtr);
|
|
INLINE $AA3A;
|
|
PROCEDURE AddComp(compProc: ProcPtr);
|
|
INLINE $AA3B;
|
|
PROCEDURE DelSearch(searchProc: ProcPtr);
|
|
INLINE $AA4C;
|
|
PROCEDURE DelComp(compProc: ProcPtr);
|
|
INLINE $AA4D;
|
|
PROCEDURE SubPt(src: Point;VAR dst: Point);
|
|
INLINE $A87F;
|
|
PROCEDURE SetClientID(id: INTEGER);
|
|
INLINE $AA3C;
|
|
PROCEDURE ProtectEntry(index: INTEGER;protect: BOOLEAN);
|
|
INLINE $AA3D;
|
|
PROCEDURE ReserveEntry(index: INTEGER;reserve: BOOLEAN);
|
|
INLINE $AA3E;
|
|
PROCEDURE SetEntries(start: INTEGER;count: INTEGER;aTable: CSpecArray);
|
|
INLINE $AA3F;
|
|
PROCEDURE SaveEntries(srcTable: CTabHandle;resultTable: CTabHandle;VAR selection: ReqListRec);
|
|
INLINE $AA49;
|
|
PROCEDURE RestoreEntries(srcTable: CTabHandle;dstTable: CTabHandle;VAR selection: ReqListRec);
|
|
INLINE $AA4A;
|
|
FUNCTION QDError: INTEGER;
|
|
INLINE $AA40;
|
|
PROCEDURE CopyDeepMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;
|
|
srcRect: Rect;maskRect: Rect;dstRect: Rect;mode: INTEGER;maskRgn: RgnHandle);
|
|
INLINE $AA51;
|
|
PROCEDURE DeviceLoop(drawingRgn: RgnHandle;drawingProc: DeviceLoopDrawingProcPtr;
|
|
userData: LONGINT;flags: DeviceLoopFlags);
|
|
INLINE $ABCA;
|
|
FUNCTION GetMaskTable: Ptr;
|
|
INLINE $A836,$2E88;
|
|
|
|
|
|
{$ENDC} { UsingQuickdraw }
|
|
|
|
{$IFC NOT UsingIncludes}
|
|
END.
|
|
{$ENDC}
|
|
|