oster@dewey.soe.berkeley.edu (David Phillip Oster) (12/20/88)
/* MacProtos.h */
/*
These ANSI C prototypes for the Macintosh toolbox functions are based
on Tech note 45, with additions for the 128K ROMs from Inside Mac V4.
They have been checked fairly carefully, uncovering a few misspellings
and other bugs in that tech note.
Note: I have made a few small changes and additions to MacTypes.
In particular, I think that ProcPtr should be a pointer to a
procedure, i.e., a function returning void. I also defined the
type FilterProc to be a function returning a Boolean.
Changes from the definitions in Inside Mac: The functions NewWindow
and GetNewWindow take a pointer to a window record, or NIL to allocate
in the heap. Inside Mac declares these as Ptr. I made them WindowPeeks.
Likewise NewDialog and GetNewDialog ought to take DialogPeeks. Finally,
UnloadSeg is documented as taking a Ptr. I made it a ProcPtr.
I think that's it. Please send any corrections to me:
Stew Rubenstein
stew@lhasa.harvard.edu
seismo!harvardlhasa!stew
David Oster:
I've made a few calls take (void *) i.e, a pointer to anything
where it is appropriate BlockMove, FSRead, FSWrite...
I've taken out Stew's filterproc definition because it doesn't force the
necessary use of the "pascal" keyword.
*/
typedef ProcPtr FilterProc;
/* AppleTalk Manager [AM] */
#ifndef _MacProtos_
#define _MacProtos_
#ifndef _MacTypes_
#include <MacTypes.h>
#endif
#ifdef _AppleTalk_
pascal OSErr ATPAddRsp(ABRecHandle);
pascal OSErr ATPCloseSocket(int atpSocket);
pascal OSErr ATPGetRequest(ABRecHandle, Boolean);
pascal OSErr ATPLoad(void);
pascal OSErr ATPOpenSocket(AddrBlock addrRcvd, Byte *atpSocket);
pascal OSErr ATPReqCancel(ABRecHandle, Boolean);
pascal OSErr ATPRequest(ABRecHandle, Boolean);
pascal OSErr ATPResponse(ABRecHandle, Boolean);
pascal OSErr ATPRspCancel(ABRecHandle, Boolean);
pascal OSErr ATPSndRequest(ABRecHandle, Boolean);
pascal OSErr ATPSndRsp(ABRecHandle, Boolean);
pascal OSErr ATPUnload(void);
pascal OSErr DDPCloseSocket(int theSocket);
pascal OSErr DDPOpenSocket(Byte *theSocket, Ptr sktListener);
pascal OSErr DDPRdCancel(ABRecHandle);
pascal OSErr DDPRead(ABRecHandle, Boolean retCksumErrs, Boolean);
pascal OSErr DDPWrite(ABRecHandle, Boolean doChecksum, Boolean);
pascal OSErr GetNodeAddress(int *myNode, int *myNet);
pascal Boolean IsATPOpen(void);
pascal Boolean IsMPPOpen(void);
pascal OSErr LAPCloseProtocol(ABByte theLAPType);
pascal OSErr LAPOpenProtocol(ABByte theLAPType, Ptr protoPtr);
pascal OSErr LAPRdCancel(ABRecHandle);
pascal OSErr LAPRead(ABRecHandle, Boolean);
pascal OSErr LAPWrite(ABRecHandle, Boolean);
pascal OSErr MPPClose(void);
pascal OSErr MPPOpen(void);
pascal OSErr NBPConfirm(ABRecHandle, Boolean);
pascal OSErr NBPExtract(Ptr theBuffer, int numInBuf, int whichOne, EntityName *abEntity, AddrBlock *address);
pascal OSErr NBPLoad(void);
pascal OSErr NBPLookup(ABRecHandle, Boolean);
pascal OSErr NBPRegister(ABRecHandle, Boolean);
pascal OSErr NBPRemove(EntityPtr abEntity);
pascal OSErr NBPUnload(void);
#endif
/* Control Manager [CM] */
#ifdef _ControlMgr_
pascal void DisposeControl(ControlHandle);
pascal void DragControl(ControlHandle, Point start, Rect *limit, Rect *slop, int axis);
pascal void Draw1Control(ControlHandle);
pascal void DrawControls(WindowPtr);
pascal int FindControl(Point where, WindowPtr, ControlHandle *ch);
pascal long GetCRefCon(ControlHandle);
pascal void GetCTitle(ControlHandle, StringPtr title);
pascal ProcPtr GetCtlAction(ControlHandle);
pascal int GetCtlMin(ControlHandle);
pascal int GetCtlMax(ControlHandle);
pascal int GetCtlValue(ControlHandle);
pascal ControlHandle GetNewControl(int ID, WindowPtr wnd);
pascal void HideControl(ControlHandle);
pascal void HiliteControl(ControlHandle, int hiliteState);
pascal void KillControls(WindowPtr);
pascal void MoveControl(ControlHandle, int h, int v);
pascal ControlHandle NewControl(WindowPtr, Rect *bounds, StringPtr title, Boolean vis, int val, int min, int max, int procID, long refCon);
pascal void SetCRefCon(ControlHandle, long data);
pascal void SetCTitle(ControlHandle, StringPtr title);
pascal void SetCtlAction(ControlHandle, ProcPtr actionProc);
pascal void SetCtlMax(ControlHandle, int);
pascal void SetCtlMin(ControlHandle, int);
pascal void SetCtlValue(ControlHandle, int);
pascal void ShowControl(ControlHandle);
pascal void SizeControl(ControlHandle, int w, int h);
pascal int TestControl(ControlHandle, Point);
pascal int TrackControl(ControlHandle, Point start, ProcPtr actionProc);
pascal void UpdtControl(WindowPtr, RgnHandle);
#endif
/* Desk Manager [DS] */
#ifdef _DeskMgr_
pascal void CloseDeskAcc(int refnum);
pascal int OpenDeskAcc(StringPtr theAcc);
pascal void SystemClick(EventRecord *theEvent, WindowPtr);
pascal Boolean SystemEdit(int editCmd);
pascal Boolean SystemEvent(EventRecord *theEvent);
pascal void SystemMenu(long menuResult);
pascal void SystemTask(void);
#endif
/* Dialog Manager [DL] */
#ifdef _DialogMgr_
pascal int Alert(int alertID, FilterProc filterProc);
pascal int CautionAlert(int alertID, FilterProc filterProc);
pascal void CloseDialog(DialogPtr);
pascal void CouldAlert(int alertID);
pascal void CouldDialog(int dialogID);
#ifdef _EventMgr_
pascal Boolean DialogSelect(EventRecord *theEvent, DialogPtr *theDialog, int *itemHit);
#endif
pascal void DisposDialog(DialogPtr);
pascal void DlgCut(DialogPtr);
pascal void DlgCopy(DialogPtr);
pascal void DlgDelete(DialogPtr);
pascal void DlgPaste(DialogPtr);
pascal void DrawDialog(DialogPtr);
pascal void ErrorSound(ProcPtr soundProc);
pascal int FindDItem(DialogPtr, Point);
pascal void FreeAlert(int alertID);
pascal void FreeDialog(int dialogID);
pascal int GetAlrtStage(void);
pascal void GetDItem(DialogPtr, int itemNo, int *itemType, Handle *item, Rect *box);
pascal void GetIText(Handle item, StringPtr text);
pascal DialogPtr GetNewDialog(int dlogID, DialogPeek dStorage, WindowPtr behind);
pascal void HideDItem(DialogPtr, int itemNo);
pascal void InitDialogs(ProcPtr resumeProc);
#ifdef _EventMgr_
pascal Boolean IsDialogEvent(EventRecord *theEvent);
#endif
pascal void ModalDialog(FilterProc filterProc, int *itemHit);
pascal DialogPtr NewDialog(DialogPeek dStorage, Rect *bounds, StringPtr title, Boolean vis, int procID, WindowPtr behind, Boolean goAway, long refCon, Handle items);
pascal int NoteAlert(int alertID, FilterProc filterProc);
pascal void ParamText(StringPtr pm0, StringPtr pm1, StringPtr pm2, StringPtr pm3);
pascal void ResetAlrtStage(void);
pascal void SelIText(DialogPtr, int itemNo, int strtSel, int endSel);
pascal void SetDAFont(int fontNum);
pascal void SetDItem(DialogPtr, int itemNo, int itemType, Handle item, Rect *box);
pascal void SetIText(Handle item, StringPtr text);
pascal void ShowDItem(DialogPtr, int itemNo);
pascal int StopAlert(int alertID, FilterProc filterProc);
pascal void UpdtDialog(DialogPtr, RgnHandle updateRgn);
#endif
/* Disk Driver [DD] */
#ifdef _DiskDvr_
pascal OSErr DiskEject(int drvNum);
pascal OSErr SetTagBuffer(Ptr buffPtr);
pascal OSErr DriveStatus(int drvNum, DrvSts *stat);
#endif
/* Event Manager/OS [OE] */
#ifdef _EventMgr_
pascal void FlushEvents(int evtMask, int stopMask);
#ifdef _OSUtil_
pascal QHdrPtr GetEvQHdr(void);
#endif
pascal Boolean GetOSEvent(int evtMask, EventRecord *Evt);
pascal Boolean OSEventAvail(int evtMask, EventRecord *Evt);
pascal OSErr PostEvent(int evtCode, long evtMsg);
pascal OSErr PPostEvent(int evtCode, long evtMsg, EvQEl *qEl);
pascal void SetEventMask(int theMask);
/* Event Manager/Toolbox [EM] */
pascal Boolean Button(void);
pascal Boolean EventAvail(int evtMask, EventRecord *Evt);
pascal long GetCaretTime(void);
pascal long GetDblTime(void);
pascal void GetKeys(KeyMap *theKeys);
pascal void GetMouse(Point *mouseLoc);
pascal Boolean GetNextEvent(int evtMask, EventRecord *Evt);
pascal Boolean StillDown(void);
pascal long TickCount(void);
pascal Boolean WaitMouseUp(void);
#endif
/* File/Device Manager [FL/DV] */
#ifdef _FileMgr_
pascal OSErr Allocate(int refnum, long *count);
pascal OSErr CloseDriver(int refNum);
pascal OSErr Control(int refNum, int csCode, Ptr csParamPtr);
pascal OSErr Create(StringPtr fileName, int vRef, OSType creator, OSType fileType);
pascal OSErr Eject(StringPtr volName, int vRef);
pascal OSErr FlushVol(StringPtr volName, int vRef);
pascal OSErr FSClose(int ref);
pascal OSErr FSDelete(StringPtr fileName, int vRef);
pascal OSErr FSOpen(StringPtr fileName, int vRef, int *ref);
pascal OSErr FSRead(int refnum, long *count, void *buffPtr);
pascal OSErr FSWrite(int refnum, long *count, void *buffPtr);
#ifdef _DeviceMgr_
pascal DCtlHandle GetDCtlEntry(int refNum);
#endif
pascal OSErr GetEOF(int refnum, long *logEOF);
pascal OSErr GetFInfo(StringPtr fileName, int vRef, FInfo *fndInfo);
pascal OSErr GetFPos(int refnum, long *filePos);
#ifdef _OSUtil_
pascal QHdrPtr GetDrvHdr(void);
pascal QHdrPtr GetFSQHdr(void);
pascal QHdrPtr GetVCBQHdr(void);
#endif
pascal OSErr GetVInfo(int drvNum, StringPtr volName, int *vRef, long *freeBytes);
pascal OSErr GetVol(StringPtr volName, int *vRef);
pascal OSErr GetVRefNum(int pathRef, int *vRef);
pascal OSErr KillIO(int refNum);
pascal OSErr OpenDriver(StringPtr name, int *refNum);
pascal OSErr OpenRF(StringPtr fileName, int vRef, int *ref);
pascal OSErr Rename(StringPtr oldName, int vRef, StringPtr newName);
pascal OSErr RstFLock(StringPtr fileName, int vRef);
pascal OSErr SetEOF(int refnum, long logEOF);
pascal OSErr SetFInfo(StringPtr fileName, int vRef, FInfo *fndInfo);
pascal OSErr SetFLock(StringPtr fileName, int vRef);
pascal OSErr SetFPos(int refnum, int posMode, long posOff);
pascal OSErr SetVol(StringPtr volName, int vRef);
pascal OSErr Status(int refNum, int csCode, Ptr csParamPtr);
pascal OSErr UnMountVol(StringPtr volName, int vRef);
pascal void FInitQueue(void);
pascal OSErr PBAllocate(ParmBlkPtr, Boolean);
pascal OSErr PBAllocContig(ParmBlkPtr, Boolean);
pascal OSErr PBClose(ParmBlkPtr, Boolean);
pascal OSErr PBControl( ParmBlkPtr, Boolean);
pascal OSErr PBCreate(ParmBlkPtr, Boolean);
pascal OSErr PBDelete(ParmBlkPtr, Boolean);
pascal OSErr PBEject(ParmBlkPtr);
pascal OSErr PBFlushFile(ParmBlkPtr, Boolean);
pascal OSErr PBFlushVol(ParmBlkPtr, Boolean);
pascal OSErr PBGetEOF(ParmBlkPtr, Boolean);
pascal OSErr PBGetVInfo(ParmBlkPtr, Boolean);
pascal OSErr PBGetFInfo(ParmBlkPtr, Boolean);
pascal OSErr PBGetFPos(ParmBlkPtr, Boolean);
pascal OSErr PBGetVol(ParmBlkPtr, Boolean);
pascal OSErr PBKillIO(ParmBlkPtr, Boolean);
pascal OSErr PBMountVol(ParmBlkPtr);
pascal OSErr PBOffLine(ParmBlkPtr);
pascal OSErr PBOpen(ParmBlkPtr, Boolean);
pascal OSErr PBOpenRF(ParmBlkPtr, Boolean);
pascal OSErr PBRead(ParmBlkPtr, Boolean);
pascal OSErr PBRename(ParmBlkPtr, Boolean);
pascal OSErr PBRstFLock(ParmBlkPtr, Boolean);
pascal OSErr PBSetEOF(ParmBlkPtr, Boolean);
pascal OSErr PBSetFInfo(ParmBlkPtr, Boolean);
pascal OSErr PBSetFLock(ParmBlkPtr, Boolean);
pascal OSErr PBSetFPos(ParmBlkPtr, Boolean);
pascal OSErr PBSetFVers(ParmBlkPtr, Boolean);
pascal OSErr PBSetVol(ParmBlkPtr, Boolean);
pascal OSErr PBStatus(ParmBlkPtr, Boolean);
pascal OSErr PBUnMountVol(ParmBlkPtr);
pascal OSErr PBWrite(ParmBlkPtr, Boolean);
pascal OSErr PBLockRange(ParmBlkPtr, Boolean);
pascal OSErr PBUnlockRange(ParmBlkPtr, Boolean);
#endif
#ifdef _HFS_
pascal OSErr PBHGetVInfo(HParmBlkPtr, Boolean);
pascal OSErr PBHGetVol(WDPBPtr, Boolean);
pascal OSErr PBHSetVol(WDPBPtr, Boolean);
pascal OSErr PBHOpen(HParmBlkPtr, Boolean);
pascal OSErr PBHOpenRF(HParmBlkPtr, Boolean);
pascal OSErr PBHCreate(HParmBlkPtr, Boolean);
pascal OSErr PBDirCreate(HParmBlkPtr, Boolean);
pascal OSErr PBHDelete(HParmBlkPtr, Boolean);
pascal OSErr PBHGetFInfo(HParmBlkPtr, Boolean);
pascal OSErr PBHSetFInfo(HParmBlkPtr, Boolean);
pascal OSErr PBHRstFLock(HParmBlkPtr, Boolean);
pascal OSErr PBHSetFLock(HParmBlkPtr, Boolean);
pascal OSErr PBHRename(HParmBlkPtr, Boolean);
pascal OSErr PBGetCatInfo(CInfoPBPtr, Boolean);
pascal OSErr PBSetCatInfo(CInfoPBPtr, Boolean);
pascal OSErr PBCatMove(CMovePBPtr, Boolean);
pascal OSErr PBOpenWD(WDPBPtr, Boolean);
pascal OSErr PBCloseWD(WDPBPtr, Boolean);
pascal OSErr PBGetWDInfo(WDPBPtr, Boolean);
pascal OSErr PBGetFCBInfo(FCBPBPtr, Boolean);
#endif
/* Font Manager [FM] */
#ifdef _FontMgr_
pascal FMOutPtr FMSwapFont(FMInput *inRec);
pascal void GetFNum(StringPtr fontName, int *theNum);
pascal void GetFontName(int fontNum, StringPtr theName);
pascal void InitFonts(void);
pascal Boolean RealFont(int fontNum, int size);
pascal void SetFontLock(Boolean lockFlag);
pascal void FontMetrics(FMetricRec *theMetrics);
pascal void SetFScaleDisable(Boolean);
pascal void SetFractEnable(Boolean);
#endif
/* List Manager [LM] */
#ifdef _ListMgr_
pascal ListHandle LNew(Rect *rView, Rect *dataBounds, Point cSize, int theProc, WindowPtr theWindow, Boolean drawIt, Boolean hasGrow, Boolean scrollHoriz, Boolean scrollVert);
pascal void LDispose(ListHandle);
pascal int LAddColumn(int count, int colNum, ListHandle);
pascal int LAddRow(int count, int rowNum, ListHandle);
pascal void LDelColumn(int count, int colNum, ListHandle);
pascal void LDelRow(int count, int rowNum, ListHandle);
pascal void LAddToCell(Ptr data, int dataLen, Cell, ListHandle);
pascal void LClrCell(Cell, ListHandle);
pascal void LGetCell(Ptr data, int *dataLen, Cell, ListHandle);
pascal void LSetCell(Ptr data, int dataLen, Cell, ListHandle);
pascal void LCellSize(Point, ListHandle);
pascal Boolean LGetSelect(Boolean next, Cell *, ListHandle);
pascal void LSetSelect(Boolean setIt, Cell, ListHandle);
pascal Boolean LClick(Point, int modifiers, ListHandle);
pascal long LLastClick(ListHandle); /* really returns a Cell */
pascal void LFind(int *offset, int *len, Cell, ListHandle);
pascal Boolean LNextCell(Boolean hNext, Boolean vNext, Cell *, ListHandle);
pascal void LRect(Rect *, Cell, ListHandle);
pascal Boolean LSearch(Ptr dataPtr, int dataLen, ProcPtr searchProc, Cell *, ListHandle);
pascal void LSize(int listWidth, int listHeight, ListHandle);
pascal void LDraw(Cell, ListHandle);
pascal void LDoDraw(Boolean drawIt, ListHandle);
pascal void LScroll(int dCols, int dRows, ListHandle);
pascal void LAutoScroll(ListHandle);
pascal void LUpdate(RgnHandle, ListHandle);
pascal void LActivate(Boolean, ListHandle);
#endif
/* Memory Manager [MM] */
#ifdef _MemoryMgr_
pascal THz ApplicZone(void);
pascal void BlockMove(void *sourcePtr, void *destPtr, Size byteCount);
pascal Size CompactMem(Size cbNeeded);
pascal void DisposHandle(Handle);
pascal void DisposPtr(void *);
pascal void EmptyHandle(Handle);
pascal long FreeMem(void);
pascal Ptr GetApplLimit(void);
pascal Size GetHandleSize(Handle);
pascal Size GetPtrSize(Ptr);
pascal THz GetZone(void);
pascal Handle GZSaveHnd(void);
pascal THz HandleZone(Handle);
pascal void HClrRBit(Handle);
pascal SignedByte HGetState(Handle);
pascal void HLock(Handle);
pascal void HNoPurge(Handle);
pascal void HPurge(Handle);
pascal void HSetRBit(Handle);
pascal void HSetState(Handle, SignedByte flags);
pascal void HUnlock(Handle);
pascal void InitApplZone(void);
pascal void InitZone(ProcPtr, int cMoreMstrs, Ptr limitPtr, Ptr startPtr);
pascal void MaxApplZone(void);
pascal long MaxBlock(void);
pascal Size MaxMem(Size *grow);
pascal OSErr MemError(void);
pascal void MoreMasters(void);
pascal void MoveHHi(Handle);
pascal Handle NewEmptyHandle(void);
pascal Handle NewHandle(Size logicalSize);
pascal Ptr NewPtr(Size logicalSize);
pascal THz PtrZone(Ptr);
pascal void PurgeMem(Size cbNeeded);
pascal void PurgeSpace(long *total, long *contig);
pascal void ReallocHandle(Handle, Size logicalSize);
pascal Handle RecoverHandle(Ptr);
pascal void ResrvMem(Size cbNeeded);
pascal void SetApplBase(Ptr startPtr);
pascal void SetApplLimit(Ptr zoneLimit);
pascal void SetGrowZone(ProcPtr);
pascal void SetHandleSize(Handle, Size newSize);
pascal void SetPtrSize(Ptr, Size newSize);
pascal void SetZone(THz);
pascal long StackSpace(void);
pascal THz SystemZone(void);
pascal Ptr TopMem(void);
#endif
/* Menu Manager [MN] */
#ifdef _MenuMgr_
pascal void AddResMenu(MenuHandle, ResType);
pascal void AppendMenu(MenuHandle, StringPtr data);
pascal void CalcMenuSize(MenuHandle);
pascal void CheckItem(MenuHandle, int item, Boolean checked);
pascal void ClearMenuBar(void);
pascal int CountMItems(MenuHandle);
pascal void DeleteMenu(int menuID);
pascal void DelMenuItem(MenuHandle, int item);
pascal void DisableItem(MenuHandle, int item);
pascal void DisposeMenu(MenuHandle);
pascal void DrawMenuBar(void);
pascal void EnableItem(MenuHandle, int item);
pascal void FlashMenuBar(int menuID);
pascal void GetItem(MenuHandle, int item, StringPtr itemString);
pascal void GetItemIcon(MenuHandle, int item, int *icon);
pascal void GetItemMark(MenuHandle, int item, int *markChar);
pascal void GetItemStyle(MenuHandle, int item, int *chStyle);
pascal MenuHandle GetMenu(int resourceID);
pascal Handle GetMenuBar(void);
pascal MenuHandle GetMHandle(int menuID);
pascal Handle GetNewMBar(int menuBarID);
pascal void HiliteMenu(int menuID);
pascal void InitMenus(void);
pascal void InsertMenu(MenuHandle, int beforeID);
pascal void InsertResMenu(MenuHandle, ResType, int afterItem);
pascal void InsMenuItem(MenuHandle, StringPtr, int afterItem);
pascal long MenuKey(int);
pascal long MenuSelect(Point startPt);
pascal MenuHandle NewMenu(int menuID, StringPtr title);
pascal void SetItem(MenuHandle, int item, StringPtr itemString);
pascal void SetItemIcon(MenuHandle, int item, int icon);
pascal void SetItemStyle(MenuHandle, int item, int chStyle);
pascal void SetItemMark(MenuHandle, int item, int markChar);
pascal void SetMenuBar(Handle menuList);
pascal void SetMenuFlash(int count);
#endif
/* OS Utilities [OU] */
#ifdef _OSUtil_
pascal void Date2Secs(DateTimeRec *date, long *secs);
pascal void Delay(long numTicks, long *finalTicks);
pascal OSErr DeQueue(QElemPtr qEntry, QHdrPtr theQueue);
pascal void Enqueue(QElemPtr qEntry, QHdrPtr theQueue);
pascal void Environs(int *rom, int *machine);
pascal Boolean EqualString(StringPtr aStr, StringPtr bStr, Boolean caseSens, Boolean diacSens);
pascal void GetDateTime(long *secs);
pascal SysPPtr GetSysPPtr(void);
pascal void GetTime(DateTimeRec *date);
pascal long GetTrapAddress(int trapNum);
pascal OSErr HandAndHand(Handle aHandle, Handle bHandle);
pascal OSErr HandToHand(Handle *h);
pascal OSErr InitUtil(void);
/****** TrapType is undefined !!!!
pascal long NGetTrapAddress(int trapNum, TrapType);
pascal void NSetTrapAddress(long trapAddr, int trapNum, TrapType);
***** TrapType is undefined !!!! */
pascal OSErr PtrAndHand(void *, Handle, long size);
pascal OSErr PtrToHand(void *srcPtr, Handle *dstHandle, long size);
pascal OSErr PtrToXHand(void *srcPtr, Handle dstHandle, long size);
pascal OSErr ReadDateTime(long *secs);
pascal int RelString(StringPtr aStr, StringPtr bStr, Boolean caseSens, Boolean diacSens);
pascal void Restart(void);
pascal void Secs2Date(long secs, DateTimeRec *date);
pascal OSErr SetDateTime(long secs);
pascal void SetTime(DateTimeRec *date);
pascal void SetTrapAddress(long trapAddr, int trapNum);
pascal void SysBeep(int duration);
pascal void UprString(StringPtr, Boolean diacSens);
pascal OSErr WriteParam(void);
#endif
/* Package Manager [PK] */
pascal int DIBadMount(Point where, long evtMessage);
pascal OSErr DIFormat(int drvNum);
pascal void DILoad(void);
pascal void DIUnload(void);
pascal OSErr DIVerify(int drvNum);
pascal OSErr DIZero(int drvNum, StringPtr volName);
pascal void InitAllPacks(void);
pascal void NumToString(long, StringPtr s);
pascal void StringToNum(StringPtr, long *n);
#ifdef _PackageMgr_
pascal void InitPack(int packID);
#endif
#ifdef _IntlPkg_
pascal int IUCompString(StringPtr aStr, StringPtr bStr);
pascal void IUDateString(long dateTime, DateForm form, StringPtr result);
pascal void IUDatePString(long dateTime, DateForm form, StringPtr result, Handle intlParam);
pascal int IUEqualString(StringPtr aStr, StringPtr bStr);
pascal Handle IUGetIntl(int theID);
pascal int IUMagString(Ptr aPtr, Ptr bPtr, int aLen, int bLen);
pascal int IUMagIDString(Ptr aPtr, Ptr bPtr, int aLen, int bLen);
pascal Boolean IUMetric(void);
pascal void IUSetIntl(int refNum, int theID, Handle intlParam);
pascal void IUTimeString(long dateTime, Boolean wantSeconds, StringPtr result);
pascal void IUTimePString(long dateTime, Boolean wantSeconds, StringPtr result, Handle intlParam);
#endif
#ifdef _StdFilePkg_
pascal void SFGetFile(Point where, StringPtr prompt, FilterProc fileFilter, int numTypes, SFTypeList *typeList, ProcPtr dlgHook, SFReply *reply);
pascal void SFPutFile(Point where, StringPtr prompt, StringPtr origName, ProcPtr dlgHook, SFReply *reply);
pascal void SFPGetFile(Point where, StringPtr prompt, FilterProc fileFilter, int numTypes, SFTypeList *typeList, ProcPtr dlgHook, SFReply *reply, int dlgID, FilterProc filterProc);
pascal void SFPPutFile(Point where, StringPtr prompt, StringPtr origName, ProcPtr dlgHook, SFReply *reply, int dlgID, FilterProc filterProc);
#endif
/* Print Manager [PR] */
#ifdef _PrintMgr_
pascal void PrClose(void);
pascal void PrintDefault(THPrint);
pascal void PrCloseDoc(TPPrPort);
pascal void PrClosePage(TPPrPort);
pascal void PrCtlCall(int iWhichCtl, long lparm1, long lparm2, long lparm3);
pascal void PrDrvrClose(void);
pascal Handle PrDrvrDCE(void);
pascal void PrDrvrOpen(void);
pascal int PrDrvrVers(void);
pascal int PrError(void);
pascal Boolean PrJobDialog(THPrint);
pascal void PrJobMerge(THPrint hPrintSrc, THPrint hPrintDst);
pascal void PrOpen(void);
pascal TPPrPort PrOpenDoc(THPrint, TPPrPort, Ptr pIOBuf);
pascal void PrOpenPage(TPPrPort, TPRect pPageFrame);
pascal void PrPicFile(THPrint, TPPrPort, Ptr pIOBuf, Ptr pDevBuf, TPrStatus *prStatus);
pascal void PrSetError(int iErr);
pascal Boolean PrStlDialog(THPrint);
pascal Boolean PrValidate(THPrint);
#endif
/* QuickDraw [QD] */
#ifdef _Quickdraw_
pascal void AddPt(Point srcPt, Point *dstPt);
pascal void BackColor(long color);
pascal void BackPat(Pattern *pat);
pascal int CharWidth(int ch);
pascal void ClipRect(Rect *r);
pascal void ClosePicture(void);
pascal void ClosePoly(void);
pascal void ClosePort(GrafPtr);
pascal void CloseRgn(RgnHandle);
pascal void ColorBit(int whichBit);
pascal void CopyBits(BitMap *srcBits, BitMap *dstBits, Rect *srcRect, Rect *dstRect, int mode, RgnHandle maskRgn);
pascal void CopyRgn(RgnHandle srcRgn, RgnHandle dstRgn);
pascal void DiffRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
pascal void DisposeRgn(RgnHandle);
pascal void DrawChar(int ch);
pascal void DrawPicture(PicHandle, Rect *dstRect);
pascal void DrawString(StringPtr);
pascal void DrawText(Ptr textBuf, int firstByte, int byteCount);
pascal Boolean EmptyRect(Rect *r);
pascal Boolean EmptyRgn(RgnHandle);
pascal Boolean EqualPt(Point pt1, Point pt2);
pascal Boolean EqualRect(Rect *Rect1, Rect *Rect2);
pascal Boolean EqualRgn(RgnHandle rgnA, RgnHandle rgnB);
pascal void EraseArc(Rect *r, int startAngle, int arcAngle);
pascal void EraseOval(Rect *r);
pascal void ErasePoly(PolyHandle);
pascal void EraseRect(Rect *r);
pascal void EraseRgn(RgnHandle);
pascal void EraseRoundRect(Rect *r, int ovalWidth, int ovalHeight);
pascal void FillArc(Rect *r, int startAngle, int arcAngle, Pattern *pat);
pascal void FillOval(Rect *r, Pattern *pat);
pascal void FillPoly(PolyHandle, Pattern *pat);
pascal void FillRect(Rect *r, Pattern *pat);
pascal void FillRgn(RgnHandle, Pattern *pat);
pascal void FillRoundRect(Rect *r, int ovalWidth, int ovalHeight, Pattern *pat);
pascal void ForeColor(long color);
pascal void FrameArc(Rect *r, int startAngle, int arcAngle);
pascal void FrameOval(Rect *r);
pascal void FramePoly(PolyHandle);
pascal void FrameRect(Rect *r);
pascal void FrameRgn(RgnHandle);
pascal void FrameRoundRect(Rect *r, int ovalWidth, int ovalHeight);
pascal void GetClip(RgnHandle);
pascal void GetFontInfo(FontInfo *info);
pascal void GetPen(Point *p);
pascal void GetPenState(PenState *pnState);
pascal Boolean GetPixel(int h, int v);
pascal void GetPort(GrafPtr *port);
pascal void GlobalToLocal(Point *p);
pascal void GrafDevice(int device);
pascal void HideCursor(void);
pascal void HidePen(void);
pascal void InitCursor(void);
pascal void InitGraf(Ptr GlobalPtr);
pascal void InitPort(GrafPtr);
pascal void InsetRect(Rect *r, int dh, int dv);
pascal void InsetRgn(RgnHandle, int dh, int dv);
pascal void InvertArc(Rect *r, int startAngle, int arcAngle);
pascal void InvertOval(Rect *r);
pascal void InvertPoly(PolyHandle);
pascal void InvertRect(Rect *r);
pascal void InvertRgn(RgnHandle);
pascal void InvertRoundRect(Rect *r, int ovalWidth, int ovalHeight);
pascal void KillPicture(PicHandle);
pascal void KillPoly(PolyHandle);
pascal void Line(int dh, int dv);
pascal void LineTo(int h, int v);
pascal void LocalToGlobal(Point *p);
pascal void MapPoly(PolyHandle, Rect *srcRect, Rect *dstRect);
pascal void MapPt(Point *p, Rect *srcRect, Rect *dstRect);
pascal void MapRect(Rect *r, Rect *srcRect, Rect *dstRect);
pascal void MapRgn(RgnHandle, Rect *srcRect, Rect *dstRect);
pascal void Move(int dh, int dv);
pascal void MovePortTo(int leftGlobal, int topGlobal);
pascal void MoveTo(int h, int v);
pascal RgnHandle NewRgn(void);
pascal void ObscureCursor(void);
pascal void OffsetPoly(PolyHandle, int dh, int dv);
pascal void OffsetRect(Rect *r, int dh, int dv);
pascal void OffsetRgn(RgnHandle, int dh, int dv);
pascal PicHandle OpenPicture(Rect *picFrame);
pascal PolyHandle OpenPoly(void);
pascal void OpenPort(GrafPtr);
pascal void OpenRgn(void);
pascal void PaintArc(Rect *r, int startAngle, int arcAngle);
pascal void PaintOval(Rect *r);
pascal void PaintPoly(PolyHandle);
pascal void PaintRect(Rect *r);
pascal void PaintRgn(RgnHandle);
pascal void PaintRoundRect(Rect *r, int ovalWidth, int ovalHeight);
pascal void PenMode(int mode);
pascal void PenNormal(void);
pascal void PenPat(Pattern *pat);
pascal void PenSize(int width, int height);
pascal void PicComment(int kind, int datasize, Handle dataHandle);
pascal void PortSize(int width, int height);
pascal void Pt2Rect(Point pt1, Point pt2, Rect *dstRect);
pascal Boolean PtInRect(Point, Rect *r);
pascal Boolean PtInRgn(Point, RgnHandle);
pascal void PtToAngle(Rect *r, Point, int *angle);
pascal int Random(void);
pascal Boolean RectInRgn(Rect *r, RgnHandle);
pascal void RectRgn(RgnHandle, Rect *r);
pascal void ScalePt(Point *p, Rect *srcRect, Rect *dstRect);
pascal void ScrollRect(Rect *r, int dh, int dv, RgnHandle updateRgn);
pascal Boolean SectRect(Rect *src1, Rect *src2, Rect *dstRect);
pascal void SectRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
pascal void SetClip(RgnHandle);
pascal void SetCursor(Cursor *c);
pascal void SetEmptyRgn(RgnHandle);
pascal void SetOrigin(int h, int v);
pascal void SetPenState(PenState *pnState);
pascal void SetPort(GrafPtr);
pascal void SetPortBits(BitMap *bm);
pascal void SetPt(Point *p, int h, int v);
pascal void SetRect(Rect *r, int left, int top, int right, int bottom);
pascal void SetRectRgn(RgnHandle, int left, int top, int right, int bottom);
pascal void SetStdProcs(QDProcs *procs);
pascal void ShowCursor(void);
pascal void ShowPen(void);
pascal void SpaceExtra(Fixed extra);
pascal void StdArc(GrafVerb, Rect *r, int startAngle, int arcAngle);
pascal void StdBits(BitMap *srcBits, Rect *srcRect, Rect *dstRect, int mode, RgnHandle maskRgn);
pascal void StdComment(int kind, int dataSize, Handle dataHandle);
pascal void StdGetPic(Ptr dataPtr, int byteCount);
pascal void StdLine(Point newPt);
pascal void StdOval(GrafVerb, Rect *r);
pascal void StdPoly(GrafVerb, PolyHandle);
pascal void StdPutPic(Ptr dataPtr, int byteCount);
pascal void StdRect(GrafVerb, Rect *r);
pascal void StdRgn(GrafVerb, RgnHandle);
pascal void StdRRect(GrafVerb, Rect *r, int ovalwidth, int ovalheight);
pascal void StdText(int byteCount, Ptr textBuf, Point numer, Point denom);
pascal int StdTxMeas(int byteCount, Ptr textAddr, Point *numer, Point *denom, FontInfo *info);
pascal int StringWidth(StringPtr);
pascal void StuffHex(Ptr thingPtr, StringPtr);
pascal void SubPt(Point srcPt, Point *dstPT);
pascal void TextFace(int face);
pascal void TextFont(int font);
pascal void TextMode(int mode);
pascal void TextSize(int size);
pascal int TextWidth(Ptr textBuf, int firstByte, int byteCount);
pascal void UnionRect(Rect *src1, Rect *src2, Rect *dstRect);
pascal void UnionRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
pascal void XorRgn(RgnHandle srcRgnA, RgnHandle srcRgnB, RgnHandle dstRgn);
pascal void SeedFill(Ptr srcPtr, Ptr dstPtr, int srcRow, int dstRow, int height, int words, int seedH, int seedV);
pascal void CalcMask(Ptr srcPtr, Ptr dstPtr, int srcRow, int dstRow, int height, int words);
pascal void CopyMask(BitMap *srcBits, BitMap *maskBits, BitMap *dstBits, Rect *srcRect, Rect *maskRect, Rect *dstRect);
pascal void MeasureText(int count, Ptr textAddr, Ptr charLocs);
#endif
/* Resource Manager [RM] */
#ifdef _ResourceMgr_
pascal void AddResource(Handle theData, ResType, int theID, StringPtr name);
pascal void ChangedResource(Handle theResource);
pascal void CloseResFile(int refNum);
pascal int CountResources(ResType);
pascal int CountTypes(void);
pascal void CreateResFile(StringPtr fileName);
pascal int CurResFile(void);
pascal void DetachResource(Handle theResource);
pascal Handle GetIndResource(ResType, int index);
pascal void GetIndType(ResType *, int index);
pascal Handle GetNamedResource(ResType, StringPtr name);
pascal int GetResAttrs(Handle theResource);
pascal int GetResFileAttrs(int refNum);
pascal void GetResInfo(Handle theResource, int *theID, ResType *theType, StringPtr name);
pascal Handle GetResource(ResType, int theID);
pascal int HomeResFile(Handle theResource);
pascal int InitResources(void);
pascal void LoadResource(Handle theResource);
pascal int OpenResFile(StringPtr fileName);
pascal void ReleaseResource(Handle theResource);
pascal void RmveResource(Handle theResource);
pascal int ResError(void);
pascal void RsrcZoneInit(void);
pascal void SetResAttrs(Handle theResource, int attrs);
pascal void SetResFileAttrs(int refNum, int attrs);
pascal void SetResInfo(Handle theResource, int theID, StringPtr name);
pascal void SetResLoad(Boolean load);
pascal void SetResPurge(Boolean install);
pascal long SizeResource(Handle theResource);
pascal int UniqueID(ResType);
pascal void UpdateResFile(int refNum);
pascal void UseResFile(int refNum);
pascal void WriteResource(Handle theResource);
pascal int Count1Types(void);
pascal void Get1IndType(ResType *theType, int index);
pascal int Count1Resources(ResType);
pascal Handle Get1IndResource(ResType, int index);
pascal Handle Get1Resource(ResType, int theID);
pascal Handle Get1NamedResource(ResType, StringPtr name);
pascal int Unique1ID(ResType);
pascal long MaxSizeRsrc(Handle);
pascal long RsrcMapEntry(Handle);
/*
pascal int OpenRFPerm(StringPtr fileName, int vRefNum, int permission);
*/
#endif
/* Scrap Manager [SM] */
#ifdef _ScrapMgr_
pascal long GetScrap(Handle hDest, ResType, long *offset);
pascal ScrapStuff *InfoScrap(void);
pascal long LoadScrap(void);
pascal long PutScrap(long length, ResType, Ptr source);
pascal long UnloadScrap(void);
pascal long ZeroScrap(void);
#endif
/* SCSI Manager [SCSI] */
#ifdef _SCSIMgr_
pascal OSErr SCSIReset(void);
pascal OSErr SCSIGet(void);
pascal OSErr SCSISelect(int targetID);
pascal OSErr SCSICmd(Ptr buffer, int count);
pascal OSErr SCSIRead(Ptr tibPtr);
pascal OSErr SCSIRBlind(Ptr tibPtr);
pascal OSErr SCSIWrite(Ptr tibPtr);
pascal OSErr SCSIWBlind(Ptr tibPtr);
pascal OSErr SCSIComplete(int *stat, int *message, long wait);
pascal int SCSIStat(void);
#endif
/* Segment Loader [SL] */
#ifdef _SegmentLdr_
pascal void ClrAppFiles(int index);
pascal void CountAppFiles(int *message, int *count);
pascal void ExitToShell(void);
pascal void GetAppFiles(int index, AppFile *theFile);
pascal void GetAppParms(StringPtr apName, int *apRefNum, Handle *apParam);
pascal void UnloadSeg(ProcPtr routineAddr);
#endif
/* Serial Driver [SR] */
#ifdef _SerialDvr_
pascal void RAMSDClose(SPortSel whichPort);
pascal OSErr RAMSDOpen(SPortSel whichPort);
pascal OSErr SerClrBrk(int refNum);
pascal OSErr SerGetBuf(int refNum, long *count);
pascal OSErr SerHShake(int refNum, SerShk *flags);
pascal OSErr SerReset(int refNum, int serConfig);
pascal OSErr SerSetBrk(int refNum);
pascal OSErr SerSetBuf(int refNum, Ptr serBPtr, int serBLen);
pascal OSErr SerStatus(int refNum, SerStaRec *serSta);
#endif
/* Sound Driver [SN] */
#ifdef _SoundDvr_
pascal void GetSoundVol(int *level);
pascal void SetSoundVol(int level);
pascal Boolean SoundDone(void);
pascal void StartSound(Ptr synthRec, long numBytes, ProcPtr completionRtn);
pascal void StopSound(void);
#endif
/* TextEdit [TE] */
#ifdef _TextEdit_
/*
pascal void SetClikLoop(FilterProc clikProc, TEHandle);
pascal void SetWordBreak(FilterProc wBrkProc, TEHandle);
*/
pascal void TEActivate(TEHandle);
pascal void TEAutoView(Boolean, TEHandle);
pascal void TECalText(TEHandle);
pascal void TEClick(Point, Boolean extend, TEHandle);
pascal void TECopy(TEHandle);
pascal void TECut(TEHandle);
pascal void TEDeactivate(TEHandle);
pascal void TEDelete(TEHandle);
pascal void TEDispose(TEHandle);
pascal OSErr TEFromScrap(void);
pascal long TEGetScrapLen(void);
pascal CharsHandle TEGetText(TEHandle);
pascal void TEIdle(TEHandle);
pascal void TEInit(void);
pascal void TEInsert(Ptr text, long length, TEHandle);
pascal void TEKey(int ch, TEHandle);
pascal TEHandle TENew(Rect *dstRect, Rect *viewRect);
pascal void TEPaste(TEHandle);
pascal void TEPinScroll(int dh, int dv, TEHandle);
pascal Handle TEScrapHandle(void);
pascal void TEScroll(int dh, int dv, TEHandle);
pascal void TESelView(TEHandle);
pascal void TESetJust(int just, TEHandle);
pascal void TESetScrapLen(long length);
pascal void TESetSelect(long selStart, long selEnd, TEHandle);
pascal void TESetText(Ptr text, long length, TEHandle);
pascal OSErr TEToScrap(void);
pascal void TEUpdate(Rect *rUpdate, TEHandle);
pascal void TextBox(Ptr text, long length, Rect *box, int just);
#endif
/* Time Manager [TIME] */
#ifdef _TimeMgr_
pascal void InsTime(QElemPtr);
pascal void RmvTime(QElemPtr);
pascal void PrimeTime(QElemPtr);
#endif
/* ToolBox Utilities [TU] */
#ifdef _ToolboxUtil_
pascal Fract Fix2Frac(Fixed);
pascal long Fix2Long(Fixed);
/* double Fix2X(Fixed); ** In ToolboxUtil.h ** */
pascal Fixed FixATan2(long a, long b);
pascal Fixed FixDiv(Fixed a, Fixed b);
pascal Fixed FixMul(Fixed a, Fixed b);
pascal Fixed FixRatio(int numer, int denom);
pascal int FixRound(Fixed);
pascal Fixed Frac2Fix(Fract);
/* double Frac2X(Fract); ** In ToolboxUtil.h ** */
pascal Fract FracCos(Fixed);
pascal Fract FracDiv(Fract, Fract);
pascal Fract FracMul(Fract, Fract);
pascal Fract FracSin(Fixed);
pascal Fract FracSqrt(Fract);
pascal Fixed Long2Fix(long);
pascal Fixed X2Fix(double *);
pascal Fract X2Frac(double *);
pascal StringHandle NewString(StringPtr);
pascal void SetString(StringHandle, StringPtr);
pascal StringHandle GetString(int stringID);
pascal void GetIndString(StringPtr, int strListID, int index);
pascal long Munger(Handle, long offset, void *, long len1, void *, long len2);
pascal void PackBits(Ptr *srcPtr, Ptr *dstPtr, int srcBytes);
pascal void UnpackBits(Ptr *srcPtr, Ptr *dstPtr, int dstBytes);
pascal Boolean BitTst(Ptr bytePtr, long bitNum);
pascal void BitSet(Ptr bytePtr, long bitNum);
pascal void BitClr(Ptr bytePtr, long bitNum);
pascal long BitAnd(long val1, long val2);
pascal long BitOr(long val1, long val2);
pascal long BitXor(long val1, long val2);
pascal long BitNot(long val);
pascal long BitShift(long val, int count);
pascal int HiWord(long);
pascal int LoWord(long);
pascal void LongMul(long a, long b, Int64Bit *dest);
pascal void ScreenRes(int *scrnVRes, int *scrnHres);
pascal Handle GetIcon(int iconID);
pascal void PlotIcon(Rect *r, Handle theIcon);
pascal PatHandle GetPattern(int patID);
pascal void GetIndPattern(PatPtr, int patListID, int index);
pascal CursHandle GetCursor(int cursorID);
pascal void ShieldCursor(Rect *shieldRect, Point offsetPt);
pascal PicHandle GetPicture(int picID);
pascal long DeltaPoint(Point ptA, Point PtB);
pascal Fixed SlopeFromAngle(int angle);
pascal int AngleFromSlope(Fixed slope);
#endif
/* Vertical Retrace [VR] */
#ifdef _VRetraceMgr_
pascal QHdrPtr GetVBLQHdr(void);
pascal OSErr VInstall(QElemPtr vblTaskPtr);
pascal OSErr VRemove(QElemPtr vblTaskPtr);
#endif
/* Window Manager [WM] */
#ifdef _WindowMgr_
pascal void BeginUpdate(WindowPtr);
pascal void BringToFront(WindowPtr);
pascal void CalcVis(WindowPeek);
pascal void CalcVisBehind(WindowPeek startWindow, RgnHandle clobberedRgn);
#ifdef _EventMgr_
pascal Boolean CheckUpdate(EventRecord *theEvent);
#endif
pascal void ClipAbove(WindowPeek);
pascal void CloseWindow(WindowPtr);
pascal void DisposeWindow(WindowPtr);
pascal long DragGrayRgn(RgnHandle, Point startPt, Rect *limitRect, Rect *slopRect, int axis, ProcPtr actionProc);
pascal void DragWindow(WindowPtr, Point startPt, Rect *boundsRect);
pascal void DrawGrowIcon(WindowPtr);
pascal void DrawNew(WindowPeek, Boolean update);
pascal void EndUpdate(WindowPtr);
pascal int FindWindow(Point thePt, WindowPtr *whichWind);
pascal WindowPtr FrontWindow(void);
pascal WindowPtr GetNewWindow(int windowID, WindowPeek wStorage, WindowPtr behind);
pascal PicHandle GetWindowPic(WindowPtr);
pascal void GetWMgrPort(GrafPtr *wPort);
pascal long GetWRefCon(WindowPtr);
pascal void GetWTitle(WindowPtr, StringPtr title);
pascal long GrowWindow(WindowPtr, Point startPt, Rect *sizeRect);
pascal void HideWindow(WindowPtr);
pascal void HiliteWindow(WindowPtr, Boolean fHilite);
pascal void InitWindows(void);
pascal void InvalRect(Rect *badRect);
pascal void InvalRgn(RgnHandle badRgn);
pascal void MoveWindow(WindowPtr, int hGlobal, int vGlobal, Boolean front);
pascal WindowPtr NewWindow(WindowPeek wStorage, Rect *boundsRect, StringPtr title, Boolean visible, int procID, WindowPtr behind, Boolean goAwayFlag, long refCon);
pascal void PaintBehind(WindowPeek startWindow, RgnHandle clobberedRgn);
pascal void PaintOne(WindowPeek, RgnHandle clobberedRgn);
pascal long PinRect(Rect *r, Point);
pascal void SaveOld(WindowPeek);
pascal void SelectWindow(WindowPtr);
pascal void SendBehind(WindowPtr theWindow, WindowPtr behindWindow);
pascal void SetWindowPic(WindowPtr, PicHandle);
pascal void SetWTitle(WindowPtr, StringPtr title);
pascal void SetWRefCon(WindowPtr, long data);
pascal void ShowHide(WindowPtr, Boolean showFlag);
pascal void ShowWindow(WindowPtr);
pascal void SizeWindow(WindowPtr, int w, int h, Boolean fUpdate);
pascal Boolean TrackGoAway(WindowPtr, Point thePt);
pascal void ValidRect(Rect *goodRect);
pascal void ValidRgn(RgnHandle goodRgn);
pascal Boolean TrackBox(WindowPtr, Point, int partCode);
pascal void ZoomWindow(WindowPtr, int partCode, Boolean front);
#endif
#endif