bobc@tikal.UUCP (Bob Campbell) (05/08/86)
# The rest of this file is a shell script which will extract:
# BDPackage.DEF ControlManager.DEF Conversions.DEF Cursors.DEF
# DeskManager.DEF DialogManager.DEF EventManager.DEF FileManager.DEF
echo x - BDPackage.DEF
cat >BDPackage.DEF <<'!Funky!Stuff!'
DEFINITION MODULE BDPackage;
FROM MacSYSTEM IMPORT LONGINT;
EXPORT QUALIFIED NumToString,StringToNum;
PROCEDURE NumToString(theNum:LONGINT;VAR theString:ARRAY OF CHAR);
PROCEDURE StringToNum(VAR theString:ARRAY OF CHAR;VAR theNum:LONGINT);
END BDPackage.
!Funky!Stuff!
echo x - ControlManager.DEF
cat >ControlManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE ControlManager;
FROM SYSTEM IMPORT ADDRESS;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM QuickDraw IMPORT Point,Rect;
FROM WindowManager IMPORT WindowPtr;
EXPORT QUALIFIED (*CONST*)
pushButProc,checkBoxProc,radioButProc,useWFont,scrollBarProc,
(* Part codes *)
inButton,inCheckBox,inUpButton,inDownButton,inPageUp,inPageDown,inThumb,
(* Axis constraints for DragControl *)
noConstraint,hAxizOnly,vAxisOnly,
(* Messages to control definition function *)
drawCntl,testCnt,calcCRgns,initCntl,dispCntl,posCntl,
thumbCntl,dragCntl,autoTrack,
(*TYPE*)
ControlRecord,ControlPtr,ControlHandle,
(*PROC*)
(* Init and Alloc *)
NewControl,GetNewControl,DisposeControl,KillControls,
(* Control Display *)
SetCTitle,GetCTitle,HideControl,ShowControl,DrawControls,HiliteControl,
(* Mouse Location *)
TestControl,FindControl,TrackControl,TrackProcA,TrackProcB,
(* Control Movement and Sizing *)
MoveControl,DragControl,SizeControl,
(* Control Setting and Range *)
SetCtlValue,GetCtlValue,SetCtlMin,GetCtlMin,SetCtlMax,GetCtlMax,
(* Miscellaneous Utilities *)
SetCRefCon,GetCRefCon,SetCtlAction,GetCtlAction;
CONST
pushButProc = 0; (* simple button *)
checkBoxProc = 1; (* check box *)
radioButProc = 2; (* radio button *)
useWFont = 8; (* add to above to use window's font *)
scrollBarProc = 16; (* scroll bar *)
(* Part codes *)
inButton = 10; (* simple button *)
inCheckBox = 11; (* check box or radio button *)
inUpButton = 20; (* up arrow of a scroll bar *)
inDownButton = 21; (* down arrow of a scroll bar *)
inPageUp = 22; (* "page up" region of a scroll bar *)
inPageDown = 23; (* "page down" region of a scroll bar *)
inThumb = 129; (* thumb of a scroll bar *)
(* Axis constraints for DragControl *)
noConstraint = 0; (* no constraint *)
hAxizOnly = 1; (* horizontal axiz only *)
vAxisOnly = 2; (* vertical axis only *)
(* Messages to control definition function *)
drawCntl = 0; (* draw the control (of control part)*)
testCnt = 1; (* test where mouse button was pressed *)
calcCRgns = 2; (* calculate control's region (or indicator's) *)
initCntl = 3; (* do any additional control initialization *)
dispCntl = 4; (* take any additional disposal actions *)
posCntl = 5; (* reposition control's indicator and update it *)
thumbCntl = 6; (* calculate parameters for dragging indicator *)
dragCntl = 7; (* drag control (or its indicator) *)
autoTrack = 8; (* execute control's action procedure *)
TYPE
ControlHandle = POINTER TO ControlPtr;
ControlPtr = POINTER TO ControlRecord;
ControlRecord = RECORD
nextContrl: ControlHandle; (* next control *)
controlOwner: WindowPtr;
contrlRect: Rect;
contrlVis: BOOLEAN;
contrlHilite: BOOLEAN;
contrlValue: INTEGER;
contrlMin: INTEGER;
contrlMax: INTEGER;
contrlDefProc: Handle;
contrlData: Handle;
contrlAction: ADDRESS;
contrlRfCon: LONGINT;
ContrlTitle: ARRAY [0..255] OF CHAR;
END;
(* Init and Alloc *)
PROCEDURE NewControl(Wind: WindowPtr;
bounds: Rect;
VAR title: ARRAY OF CHAR;
visible: BOOLEAN;
value: INTEGER;
min,max: INTEGER;
procID: INTEGER;
refCon: LONGINT): ControlHandle;
PROCEDURE GetNewControl (controlID:INTEGER;wind:WindowPtr):ControlHandle;
PROCEDURE DisposeControl (theControl:ControlHandle);
PROCEDURE KillControls (wind:WindowPtr);
(* Control Display *)
PROCEDURE SetCTitle (theControl:ControlHandle;VAR title:ARRAY OF CHAR);
PROCEDURE GetCTitle (theControl:ControlHandle;VAR title:ARRAY OF CHAR);
PROCEDURE HideControl (theControl:ControlHandle);
PROCEDURE ShowControl (theControl:ControlHandle);
PROCEDURE DrawControls (theWindow:WindowPtr);
PROCEDURE HiliteControl (theControl:ControlHandle;hiliteState:INTEGER);
(* Mouse Location *)
PROCEDURE TestControl (theControl: ControlHandle;thePoint:Point):INTEGER;
PROCEDURE FindControl (thePoint:Point; theWindow: WindowPtr;
VAR whichControl: ControlHandle):INTEGER;
PROCEDURE TrackControl (theControl: ControlHandle; startPt:Point;
actionProc: ADDRESS):INTEGER;
PROCEDURE TrackProcA(p:PROC):ADDRESS;
TYPE PROCHI = PROCEDURE (ControlHandle,INTEGER);
PROCEDURE TrackProcB(c:PROCHI):ADDRESS;
(* Control Movement and Sizing *)
PROCEDURE MoveControl (theControl: ControlHandle; h,v: INTEGER);
PROCEDURE DragControl (theControl: ControlHandle; ptartPt:Point;
limitRect,slopRect: Rect; axis: INTEGER);
PROCEDURE SizeControl (theControl: ControlHandle; w,h: INTEGER);
(* Control Setting and Range *)
PROCEDURE SetCtlValue (theControl: ControlHandle; theValue: INTEGER);
PROCEDURE GetCtlValue (theControl: ControlHandle):INTEGER;
PROCEDURE SetCtlMin (theControl: ControlHandle;minValue:INTEGER);
PROCEDURE GetCtlMin (theControl: ControlHandle):INTEGER;
PROCEDURE SetCtlMax (theControl: ControlHandle; maxValue:INTEGER);
PROCEDURE GetCtlMax (theControl: ControlHandle):INTEGER;
(* Miscellaneous Utilities *)
PROCEDURE SetCRefCon (theControl: ControlHandle; data: LONGINT);
PROCEDURE GetCRefCon (theControl: ControlHandle):LONGINT;
PROCEDURE SetCtlAction (theControl: ControlHandle;actionProc:ADDRESS);
PROCEDURE GetCtlAction (theControl: ControlHandle):ADDRESS;
END ControlManager.
!Funky!Stuff!
echo x - Conversions.DEF
cat >Conversions.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Conversions;
FROM SYSTEM IMPORT WORD;
EXPORT QUALIFIED
IntToStr,StrToInt,CardToStr,StrToCard,HexToStr,
StrToHex,OctToStr,StrToOct;
PROCEDURE IntToStr(i : INTEGER;VAR s : ARRAY OF CHAR;
p : CARDINAL):BOOLEAN;
PROCEDURE StrToInt(VAR s : ARRAY OF CHAR; VAR i : INTEGER):BOOLEAN;
PROCEDURE CardToStr(c:CARDINAL; VAR s:ARRAY OF CHAR;
p : CARDINAL):BOOLEAN;
PROCEDURE StrToCard(VAR s:ARRAY OF CHAR; VAR c:CARDINAL):BOOLEAN;
PROCEDURE HexToStr(w:WORD;VAR s:ARRAY OF CHAR;
p : CARDINAL):BOOLEAN;
PROCEDURE StrToHex(VAR s:ARRAY OF CHAR;VAR w:WORD):BOOLEAN;
PROCEDURE OctToStr(w:WORD;VAR s:ARRAY OF CHAR;
p : CARDINAL):BOOLEAN;
PROCEDURE StrToOct(VAR s:ARRAY OF CHAR;VAR w:WORD):BOOLEAN;
END Conversions.
!Funky!Stuff!
echo x - Cursors.DEF
cat >Cursors.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Cursors;
FROM QuickDraw IMPORT Point,Rect,Bits16,Cursor;
EXPORT QUALIFIED
(*CONST*)
iBeamCursor,crossCursor,plusCursor,watchCursor,
(*TYPE*)
CursPtr,CursHandle,
(*PROCS*)
GetCursor,InitCursor,SetCursor,HideCursor,
ShowCursor,ObscureCursor,ShieldCursor;
CONST
(*Resource IDs of standard cursors *)
iBeamCursor = 1;
crossCursor = 2;
plusCursor = 3;
watchCursor = 4;
TYPE
CursPtr = POINTER TO Cursor;
CursHandle = POINTER TO CursPtr;
(* Cursor Routines *)
PROCEDURE GetCursor(cursorID:INTEGER):CursHandle;
PROCEDURE InitCursor;
PROCEDURE SetCursor(VAR crsr: Cursor);
PROCEDURE HideCursor;
PROCEDURE ShowCursor;
PROCEDURE ObscureCursor;
PROCEDURE ShieldCursor(shieldRect:Rect;offsetPt:Point);
END Cursors.
!Funky!Stuff!
echo x - DeskManager.DEF
cat >DeskManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE DeskManager;
FROM MacSYSTEM IMPORT LONGINT;
FROM EventManager IMPORT EventRecord;
FROM WindowManager IMPORT WindowPtr;
EXPORT QUALIFIED OpenDeskAcc,CloseDeskAcc,
SystemClick,SystemEdit,SystemTask,SystemEvent,SystemMenu;
PROCEDURE OpenDeskAcc(VAR theAcc:ARRAY OF CHAR):INTEGER;
PROCEDURE CloseDeskAcc(refNum:INTEGER);
PROCEDURE SystemClick(VAR theEvent:EventRecord;theWindow:WindowPtr);
PROCEDURE SystemEdit(editCmd:INTEGER):BOOLEAN;
PROCEDURE SystemTask;
PROCEDURE SystemEvent(VAR theEvent:EventRecord):BOOLEAN;
PROCEDURE SystemMenu(menuResult:LONGINT);
END DeskManager.
!Funky!Stuff!
echo x - DialogManager.DEF
cat >DialogManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE DialogManager;
FROM QuickDraw IMPORT Rect;
FROM MacSYSTEM IMPORT Handle, LONGINT, Ptr;
FROM WindowManager IMPORT WindowPtr, WindowRecord;
FROM TextEdit IMPORT TEHandle;
FROM EventManager IMPORT EventRecord;
FROM SYSTEM IMPORT ADDRESS;
EXPORT QUALIFIED
(*constants*)
ctrlItem,btnCtrl,chkCtrl,radCtrl,resCtrl,statText,editText,iconItem,
picItem,userItem,itemDisable,
ok,cancel,
stopIcon,noteIcon,cautionIcon,
(*types*)
DialogPtr,DialogPeek,DialogRecord,
DialogTHndl,DialogTPtr,DialogTemplate,
AlertTHndl,AlertTPtr,AlertTemplate,
StageList,
FilterProc,ItemProc,SoundProc,
(* Variables *)
ResumeProc,DAStrings,DABeeper,DlgFont,ACount,ANumber,
(*procedures*)
UseFilterProc,NoFilterProc,UseSoundProc,
InitDialogs,ErrorSound,SetDAFont,
NewDialog,GetNewDialog,CloseDialog,DisposDialog,CouldDialog,FreeDialog,
ModalDialog,IsDialogEvent,DialogSelect,
DlgCut,DlgCopy,DlgPaste,DlgDelete,DrawDialog,
Alert,StopAlert,NoteAlert,CautionAlert,CouldAlert,FreeAlert,
ParamText,GetDItem,SetDItem,GetIText,SetIText,SelIText,
GetAlrtStage,ResetAlrtStage;
CONST (* item types *)
ctrlItem = 4; (* add to following four constants *)
btnCtrl = 0;
chkCtrl = 1;
radCtrl = 2;
resCtrl = 3;
statText = 8;
editText = 16;
iconItem = 32;
picItem = 64;
itemDisable = 128;
userItem = 0;
(* Item numbers of OK and Cancel buttons *)
ok = 1;
cancel = 2;
(* Resource IDs of alert icons *)
stopIcon = 0;
noteIcon = 1;
cautionIcon = 2;
TYPE
DialogPtr = WindowPtr;
DialogPeek = POINTER TO DialogRecord;
DialogRecord = RECORD
window: WindowRecord;
items: Handle;
textH: TEHandle;
editField: INTEGER;
editOpen: INTEGER;
aDefItem: INTEGER;
END;
DialogTHndl = POINTER TO DialogTPtr;
DialogTPtr = POINTER TO DialogTemplate;
DialogTemplate = RECORD
boundsRect: Rect;
procID: BOOLEAN;
visible: BOOLEAN;
filler1: BOOLEAN;
goAwayFlag: BOOLEAN;
filler2: BOOLEAN;
refCon: LONGINT;
itemsID: INTEGER;
title: ARRAY [0..255] OF CHAR;
END;
StageList = BITSET;
AlertTHndl = POINTER TO AlertTPtr;
AlertTPtr = POINTER TO AlertTemplate;
AlertTemplate = RECORD
boundsRect: Rect;
itemsID: INTEGER;
stages: StageList;
END;
(* filterproc function for modal dialogs and alerts *)
FilterProc = PROCEDURE(DialogPtr,VAR EventRecord,VAR INTEGER):BOOLEAN;
(* useritem procedure *)
ItemProc = PROCEDURE(WindowPtr,INTEGER);
(* sound procedure *)
SoundProc = PROCEDURE(INTEGER);
VAR
ResumeProc[0A8CH] : ADDRESS;
DAStrings[0AA0H] : ARRAY [0..3] OF ADDRESS;
DABeeper[0A9CH] : ADDRESS;
DlgFont[0AFAH] : INTEGER;
ACount[0A9AH] : INTEGER;
ANumber : INTEGER;
(* initialization *)
PROCEDURE InitDialogs (restartProc: ADDRESS);
PROCEDURE UseSoundProc(MySound: SoundProc):ADDRESS;
PROCEDURE ErrorSound (MySound: ADDRESS);
PROCEDURE SetDAFont (fontNum: INTEGER);
(* Creating and disposing OF dialogs *)
PROCEDURE NewDialog(dStorage: ADDRESS; boundsRect:Rect;
VAR title:ARRAY OF CHAR;visible: BOOLEAN;procID: INTEGER;
behind: WindowPtr;goAwayFlag: BOOLEAN; refCon: LONGINT;
items: Handle) : DialogPtr;
PROCEDURE GetNewDialog(dialogID: INTEGER; dStorage: ADDRESS;
behind: WindowPtr) : DialogPtr;
PROCEDURE CloseDialog(theDialog: DialogPtr);
PROCEDURE DisposDialog(theDialog: DialogPtr);
PROCEDURE CouldDialog(dialogID: INTEGER);
PROCEDURE FreeDialog(dialogID: INTEGER);
(* Handling Dialog events *)
PROCEDURE NoFilterProc():ADDRESS;
PROCEDURE UseFilterProc(myFilter:FilterProc):ADDRESS;
PROCEDURE ModalDialog(myFilter:ADDRESS; VAR itemHit: INTEGER);
PROCEDURE IsDialogEvent(VAR theEvent: EventRecord) : BOOLEAN;
PROCEDURE DialogSelect(VAR theEvent: EventRecord; VAR theDialog: DialogPtr;
VAR itemHit: INTEGER) : BOOLEAN;
PROCEDURE DlgCut(theDialog: DialogPtr);
PROCEDURE DlgCopy(theDialog: DialogPtr);
PROCEDURE DlgPaste(theDialog: DialogPtr);
PROCEDURE DlgDelete(theDialog: DialogPtr);
PROCEDURE DrawDialog (theDialog: DialogPtr);
(* invoking alerts *)
PROCEDURE Alert(alertID: INTEGER; myFilter:ADDRESS): INTEGER;
PROCEDURE StopAlert(alertID: INTEGER; myFilter:ADDRESS): INTEGER;
PROCEDURE NoteAlert(alertID: INTEGER; myFilter:ADDRESS): INTEGER;
PROCEDURE CautionAlert(alertID: INTEGER; myFilter:ADDRESS): INTEGER;
PROCEDURE CouldAlert(alertID: INTEGER);
PROCEDURE FreeAlert(alertID: INTEGER);
(* manipulation items in dialog and alerts *)
PROCEDURE ParamText(VAR param0,param1,param2,param3: ARRAY OF CHAR);
PROCEDURE GetDItem(theDialog: DialogPtr; itemNo: INTEGER;
VAR type: INTEGER; VAR item: Handle; VAR box: Rect);
PROCEDURE SetDItem (theDialog: DialogPtr; itemNo: INTEGER; type: INTEGER;
item: Handle; VAR box: Rect);
PROCEDURE GetIText(item: Handle; VAR text: ARRAY OF CHAR);
PROCEDURE SetIText(item: Handle; VAR text: ARRAY OF CHAR);
PROCEDURE SelIText(theDialog: DialogPtr; itemNo: INTEGER;
strtSel,endSel: INTEGER);
PROCEDURE GetAlrtStage(): INTEGER;
PROCEDURE ResetAlrtStage;
END DialogManager.
!Funky!Stuff!
echo x - EventManager.DEF
cat >EventManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE EventManager;
(* MacIntosh ToolBox Event Manager Operations *)
(* Some Items still not present
* GetDblTime, GetCaretTime, and GetEvQHdr
*)
FROM MacSYSTEM IMPORT LONGINT,OSErr;
FROM QuickDraw IMPORT Point;
FROM SYSTEM IMPORT ADDRESS,WORD;
EXPORT QUALIFIED
(*Const*)
nullEvent,mouseDown,mouseUp,keyDown,keyUp,autoKey,
updateEvt,diskEvt,activateEvt,abortEvt,networkEvt,driverEvt,
app1Evt,app2Evt,app3Evt,app4Evt,
charCodeMask,keyCodeMask,
nullMask,mDownMask,mUpMask,keyDownMask,keyUpMask,autoKeyMask,
updateMask,diskMask,activMask,abortMask,networkMask,driverMask,
app1Mask,app2Mask,app3Mask,app4Mask,everyEvent,
activeFlag,btnState,cmdKey,shiftKey,alphaLock,optionKey,changeFlag,
activeFlagBit,btnStateBit,cmdKeyBit,shiftKeyBit,alphaLockBit,
optionKeyBit,changeFlagBit,
evtNotEnb,
(*Types*)
EventRecord,KeyMap,
(*Toolbox Procs*)
EventAvail,GetNextEvent,StillDown,WaitMouseUp,GetMouse,TickCount,
Button,GetKeys,
(*OS Procs*)
PostEvent,FlushEvents,SetEventMask,OSEventAvail,GetOSEvent;
CONST
(* Event Codes *)
nullEvent = 0;
mouseDown = 1;
mouseUp = 2;
keyDown = 3;
keyUp = 4;
autoKey = 5;
updateEvt = 6;
diskEvt = 7;
activateEvt = 8;
abortEvt = 9;
networkEvt = 10;
driverEvt = 11;
app1Evt = 12;
app2Evt = 13;
app3Evt = 14;
app4Evt = 15;
(* Masks for accessing keyboard event message *)
keyCodeMask = 00000FF00H;
charCodeMask= 0000000FFH;
(* Masks for forming event mask *)
nullMask = 00001H;
mDownMask = 00002H;
mUpMask = 00004H;
keyDownMask = 00008H;
keyUpMask = 00010H;
autoKeyMask = 00020H;
updateMask = 00040H;
diskMask = 00080H;
activMask = 00100H;
abortMask = 00200H;
networkMask = 00400H;
driverMask = 00800H;
app1Mask = 01000H;
app2Mask = 02000H;
app3Mask = 04000H;
app4Mask = 08000H;
everyEvent = 0FFFFH;
(* modifiers *)
optionKey = 00800H; (* Bit 3 of high byte *)
alphaLock = 00400H; (* Bit 2 *)
shiftKey = 00200H; (* Bit 1 *)
cmdKey = 00100H; (* Bit 0 *)
btnState = 00080H; (* Bit 7 of low byte is mouse button state *)
activeFlag = 00001H; (* bit 0 of modifiers for activate event *)
changeFlag = 00002H; (* bit 1 of modifiers for activate event *)
optionKeyBit = 11;
alphaLockBit = 10;
shiftKeyBit = 9;
cmdKeyBit = 8;
btnStateBit = 7;
changeFlagBit = 1;
activeFlagBit = 0;
(* Result codes returned by PostEvent *)
evtNotEnb = 1; (* event type not designated in system event mask *)
TYPE
EventRecord = RECORD
what: INTEGER;
CASE CARDINAL OF
0: message: LONGINT
| 1: Unused: CARDINAL;
KeyCode: CHAR;
CharacterCode: CHAR
| 2: Window: ADDRESS
| 3: Code: INTEGER;
Drive: INTEGER
END (*CASE*);
when: LONGINT;
where: Point;
CASE BOOLEAN OF
TRUE: modifiers: CARDINAL;
| FALSE: modifierSet: BITSET
END (* modifier word *)
END;
KeyMap = ARRAY[0..7] OF BITSET;(* PACKED ARRAY [1..128] OF BOOLEAN *)
PROCEDURE EventAvail(mask:WORD; VAR theEvent: EventRecord): BOOLEAN;
PROCEDURE GetNextEvent(mask:WORD; VAR theEvent: EventRecord): BOOLEAN;
PROCEDURE StillDown ():BOOLEAN;
PROCEDURE WaitMouseUp ():BOOLEAN;
PROCEDURE GetMouse (VAR pt: Point);
PROCEDURE TickCount ():LONGINT;
PROCEDURE Button (): BOOLEAN;
PROCEDURE GetKeys(VAR k: KeyMap);
PROCEDURE PostEvent (eventNum: WORD; eventMsg: LONGINT): OSErr;
PROCEDURE FlushEvents (whichMask,stopMask: WORD);
PROCEDURE SetEventMask (theMask: WORD);
PROCEDURE GetOSEvent (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
PROCEDURE OSEventAvail (mask: WORD; VAR theEvent: EventRecord): BOOLEAN;
END EventManager.
!Funky!Stuff!
echo x - FileManager.DEF
cat >FileManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE FileManager;
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM MacSYSTEM IMPORT LONGINT,StringPtr,OSErr;
FROM QuickDraw IMPORT Point;
FROM FileTypes IMPORT
(*CONST*)
fHasBundle,fInvisible,fTrash,fDesktop,fDisk,
fsAtMark,fsFromStart,fsFromLEOF,fsFromMark,
fsCurPerm,fsRdPerm,fsWrPerm,fsRdWrPerm,
badMDBErr,bdNamErr,dirFulErr,dskFulErr,dupFNErr,eofErr,
extFSErr,fBsyErr,fLckdErr,fnfErr,fnOpnErr,fsRnErr,
ioErr,mFulErr,nsDrvErr,noMacDskErr,nsvErr,
opWrErr,paramErr,permErr,posErr,rfNumErr,tmfoErr,
volOffLinErr,volOnLinErr,vLckdErr,wrPermErr,wPrErr,
(*TYPE*)
OSType,FInfo,ParamBlkPtr,ParamBlkType,ParamBlockRec;
EXPORT QUALIFIED
(* Accessing Volumes *)
GetVInfo,GetVol,SetVol,FlushVol,UnmountVol,Eject,
(* Changine File Contents *)
Create,FSOpen,FSRead,FSWrite,GetFPos,SetFPos,
GetEOF,SetEOF,Allocate,FSClose,
(* Changing Information About Files *)
GetFInfo,SetFInfo,SetFLock,RstFLock,Rename,FSDelete;
(* Accessing Volumes *)
PROCEDURE GetVInfo(drvNum:INTEGER;volName:StringPtr;
VAR vRefNum:INTEGER; VAR freeBytes:LONGINT):OSErr;
PROCEDURE GetVol(volName:StringPtr;VAR vRefNum:INTEGER):OSErr;
PROCEDURE SetVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
PROCEDURE FlushVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
PROCEDURE UnmountVol(volName:StringPtr;vRefNum:INTEGER):OSErr;
PROCEDURE Eject(volName:StringPtr;vRefNum:INTEGER):OSErr;
(* Changine File Contents *)
PROCEDURE Create(VAR fileName:ARRAY OF CHAR;vRefNum:INTEGER;
creator,filetype:OSType):OSErr;
PROCEDURE FSOpen(VAR fileName:ARRAY OF CHAR;vRefNum:INTEGER;
VAR refNum:INTEGER):OSErr;
PROCEDURE FSRead(refNum:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
PROCEDURE FSWrite(ref:INTEGER;VAR count:LONGINT;buff:ADDRESS):OSErr;
PROCEDURE GetFPos(refNum:INTEGER;VAR filePos:LONGINT):OSErr;
PROCEDURE SetFPos(ref:INTEGER;posMode:INTEGER;posOff:LONGINT):OSErr;
PROCEDURE GetEOF(ref:INTEGER;VAR logEOF:LONGINT):OSErr;
PROCEDURE SetEOF(ref:INTEGER;logEOF:LONGINT):OSErr;
PROCEDURE Allocate(ref:INTEGER;VAR count:LONGINT):OSErr;
PROCEDURE FSClose(ref:INTEGER):OSErr;
(* Changing Information About Files *)
PROCEDURE GetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;VAR fndr:FInfo):OSErr;
PROCEDURE SetFInfo(VAR file:ARRAY OF CHAR;vRef:INTEGER;fndrInfo:FInfo):OSErr;
PROCEDURE SetFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
PROCEDURE RstFLock(VAR file:ARRAY OF CHAR;vRef:INTEGER):OSErr;
PROCEDURE Rename(VAR old:ARRAY OF CHAR;vRef:INTEGER;VAR new:ARRAY OF CHAR):OSErr;
PROCEDURE FSDelete(VAR name:ARRAY OF CHAR;vRef:INTEGER):OSErr;
END FileManager.
!Funky!Stuff!bobc@tikal.UUCP (Bob Campbell) (05/08/86)
# The rest of this file is a shell script which will extract:
# FileTypes.DEF FontManager.DEF IUPackage.DEF InOut.DEF MacSYSTEM.DEF
# MathLib0.DEF MathLib1.DEF
echo x - FileTypes.DEF
cat >FileTypes.DEF <<'!Funky!Stuff!'
DEFINITION MODULE FileTypes;
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM MacSYSTEM IMPORT LONGINT,StringPtr;
FROM QuickDraw IMPORT Point;
EXPORT QUALIFIED
(*CONST*)
fHasBundle,fInvisible,fTrash,fDesktop,fDisk,
fsAtMark,fsFromStart,fsFromLEOF,fsFromMark,
fsCurPerm,fsRdPerm,fsWrPerm,fsRdWrPerm,
badMDBErr,bdNamErr,dirFulErr,dskFulErr,dupFNErr,eofErr,
extFSErr,fBsyErr,fLckdErr,fnfErr,fnOpnErr,fsRnErr,
ioErr,mFulErr,nsDrvErr,noMacDskErr,nsvErr,
opWrErr,paramErr,permErr,posErr,rfNumErr,tmfoErr,
volOffLinErr,volOnLinErr,vLckdErr,wrPermErr,wPrErr,
(*TYPE*)
OSType,FInfo,ParamBlkPtr,ParamBlkType,ParamBlockRec;
CONST
fHasBundle = 32; (* File has bundle *)
fInvisible = 64; (* file's icon is invisible *)
fTrash = -3; (* file is in trash window *)
fDesktop = -2; (* file is on desktop *)
fDisk = 0; (* file is in disk window *)
(* Values for posMode and ioPosMode *)
fsAtMark = 0; (* at current position of mark *)
(* (posOff or ioPosOffset ignored) *)
fsFromStart = 1; (* offset from beginning of file *)
fsFromLEOF = 2; (* offset from logical end-of-file *)
fsFromMark = 3; (* offset from current mark *)
(* Values for requesting read/write access *)
fsCurPerm = 0C; (* whatever is currently allowed *)
fsRdPerm = 1C; (* read only *)
fsWrPerm = 2C; (* write only *)
fsRdWrPerm = 3C; (* request to read and write *)
(* Result Codes *)
badMDBErr = -60; (* Master Block Bad *)
bdNamErr = -37; (* Bad file name or volume name *)
dirFulErr = -33; (* File directory full *)
dskFulErr = -34; (* All allocation blocks on volume are full *)
dupFNErr = -48; (* file name already exists *)
eofErr = -39;
extFSErr = -58; (* External FS error, .... *)
fBsyErr = -47; (* One or more files open? *)
fLckdErr = -45; (* File is locked *)
fnfErr = -43; (* File not found *)
fnOpnErr = -38; (* File not open *)
fsRnErr = -59; (* Problem during Rename *)
ioErr = -36; (* Disk I/O error *)
mFulErr = -41; (* System heap is full *)
nsDrvErr = -56; (* Drive not in Drive Queue *)
noMacDskErr = -57; (* Volume lacks Macintosh-format *)
nsvErr = -35; (* Volume does not exist *)
opWrErr = -49; (* Permissions only allow one access path *)
paramErr = -50; (* No Default Volume *)
permErr = -54; (* Permission disallowed *)
posErr = -40; (* Attempt to position before start of file *)
rfNumErr = -51; (* Nonexistent access path *)
tmfoErr = -42; (* only 12 files can be open at one time *)
volOffLinErr= -53; (* volume not on line *)
volOnLinErr = -55; (* volume already on line *)
vLckdErr = -46; (* volume is locked by a software flag *)
wrPermErr = -61; (* writing not allowed *)
wPrErr = -44; (* volume is locked by hardware *)
TYPE
OSErr = INTEGER;
OSType = ARRAY [0..3] OF CHAR;
FInfo = RECORD
fdType: OSType; (* file type *)
fdCreator: OSType; (* file's creator *)
fdFlags: INTEGER;(* flags *)
fdLocation: Point; (* file's location *)
fdFldr: INTEGER;(* file's window *)
END;
ParamBlkPtr = POINTER TO ParamBlockRec;
ParamBlkType = (ioParam,fileParam,volumeParam,cntrlParam);
ParamBlockRec = RECORD
qLink: ADDRESS; (* next queue entry *)
qType: INTEGER; (* queue type *)
ioTrap: INTEGER; (* routine trap *)
ioCmdAddr: ADDRESS; (* routine address *)
ioCompletion: ADDRESS; (* completion routine *)
ioResult: OSErr; (* result code *)
ioNamePtr: POINTER TO ARRAY [0..255] OF CHAR;
ioVRefNum: INTEGER;
CASE ParamBlkType OF
ioParam:
ioRefNum: INTEGER; (* Path reference number *)
ioVersNum: CHAR; (* version number *)
ioPermssn: CHAR; (* read/write permission *)
ioMisc: ADDRESS; (* miscellaneous *)
ioBuffer: ADDRESS; (* data buffer *)
ioReqCount: LONGINT; (* requested number of bytes *)
ioActCount: LONGINT; (* actual number of bytes *)
ioPosMode: INTEGER; (* newlint character any type of
* positioning operation
*)
ioPosOffset:LONGINT; (* size of positioning offset *)
| fileParam:
ioFRefNum: INTEGER; (* path reference number *)
ioFVersNum: CHAR; (* version Number *)
filler1: CHAR; (* pad *)
ioFDirIndex: INTEGER; (* File Number *)
ioFlAttrib: CHAR; (* File Attributes *)
ioFlVersNum: CHAR; (* version number *)
ioFlFndrInfo: FInfo; (* finder information *)
ioFlNum: LONGINT; (* file number *)
ioFlStBlk: INTEGER; (* first block of data fork *)
ioFlLgLen: LONGINT; (* Logical end-of-file data fork *)
ioFlPyLen: LONGINT; (* physical end-of-file data fork *)
ioFlRStBlk: INTEGER; (* first block of resource fork *)
ioFlRLgLen: LONGINT; (* logical EOF resource fork *)
ioFlRPyLen: LONGINT; (* physical EOF resource fork *)
ioFlCrDat: LONGINT; (* date and time of creation *)
ioFlMdDat: LONGINT; (* date and time of modification *)
| volumeParam:
filler2: LONGINT; (* not used *)
ioVolIndex: INTEGER; (* volume index *)
ioVCrDate: LONGINT; (* time of initialization *)
ioVLsBkUp: LONGINT; (* time of last back up *)
ioVAtrb: INTEGER; (* bit 15=1 if volume locked *)
ioVNmFls: INTEGER; (* number of files in directory *)
ioVDirSt: INTEGER; (* first block of file directory *)
ioVBlLn: INTEGER; (* number of blocks in directory *)
ioVNmAlBlks: INTEGER; (* number of blocks on volume *)
ioVAlBlkSiz: LONGINT; (* number of bytes per block *)
ioVClpSiz: LONGINT; (* number of bytes to allocate *)
ioAlBlSt: INTEGER; (* first block in volume block map*)
ioVNxtFNum: LONGINT; (* next free file number *)
ioVFrBlk: INTEGER;
END (*CASE*)
END (*RECORD*);
(* NOT USED
* VCB = RECORD
* qLink: QElemPtr; (* next queue entry *)
* qType: INTEGER; (* not used *)
* vcbFlags: INTEGER; (* bit 15=1 if dirty *)
* vcbSigWord: INTEGER; (* always $D2D7 *)
* vcbCrDate: LONGINT; (* date volume was initialized *)
* vcbLsBkUp: LONGINT; (* date volume was last backed up *)
* vcbAtrb: INTEGER; (* volume attributes *)
* vcbNmFls: INTEGER; (* number of fines in directory *)
* vcbDirSt: INTEGER; (* directory's first block *)
* vcbBlLn: INTEGER; (* length of file directory *)
* vcbNmBlks: INTEGER; (* number of allocation blocks *)
* vcbAlBlkSize:LONGINT; (* size of allocation blocks *)
* vcbClpSiz: LONGINT; (* number of bytes to allocate *)
* vcbAlBlSt: INTEGER; (* first block in block map *)
* vcbNxtFNum: LONGINT; (* next unused file number *)
* vcbFreeBks: INTEGER; (* number of unused blocks *)
* vcbVN: ARRAY [0..27] OF CHAR; (* vol Name *)
* vcbDrvNum: INTEGER;
* vcbDRefNum: INTEGER; (* Driver reference number *)
* vcbFSID: INTEGER; (* file system identifier *)
* vcbVRefNum: INTEGER; (* volume reference number *)
* vcbMAdr: ADDRESS; (* location of block map *)
* vcbBufAdr: ADDRESS; (* location of volume buffer *)
* vcbMLen: INTEGER; (* number of bytes in block map *)
* vcbDirIndex:INTEGER; (* internal use *)
* vcbDirBlk: INTEGER; (* internal use *)
* END;
*
* DrvQEl = RECORD
* (* flags: LONGINT *)
* qLink: QElemPtr;
* qType: INTEGER;
* dQDrive:INTEGER;
* dQRefNum:INTEGER;
* dQFSID: INTEGER;
* dQDrvSize:INTEGER
* END;
*
*VAR
*(*FSQHdr EQU $360; file system queue header (10 bytes)*)
* FSQHdr[0360H]:QHdr;
*(*VCBQHdr EQU $356; VCB queue header*)
* VCBQHdr[0356H]:QHdr;
*(*DrvQHdr EQU $308; queue header of drives in system [10 bytes]*)
* DrvQHdr[0308H]:QHdr;
*)
END FileTypes.
!Funky!Stuff!
echo x - FontManager.DEF
cat >FontManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE FontManager;
FROM MacSYSTEM IMPORT LONGINT,BYTE,Handle;
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM QuickDraw IMPORT Style,Point;
(*
* This is the Font Manager from Inside Macintosh(TM) Volume I
*
* Because of problems with the extreme size of QuickDraw, the font
* routine GetFontInfo, and the record FontInfo are in here not
* in QuickDraw.
*)
EXPORT QUALIFIED
(*CONST*)
systemFont,applFont,newYork,geneva,monaco,venice,london,
athens,sanFran,toronto,cairo,losAngeles,times,helvetica,courier,
symbol,taliesin,
commandMark,checkMark,diamondMark,appleMark,
propFont,fixedFont,fontWid,
(*TYPE*)
FMInput,FMOutPtr,FMOutput,FontRec,FontInfo,
(*PROC*)
GetFontName,GetFNum,RealFont,GetFontInfo,SetFontLock,FMSwapFont;
CONST
systemFont = 0;
applFont = 1;
newYork = 2;
geneva = 3;
monaco = 4;
venice = 5;
london = 6;
athens = 7;
sanFran = 8;
toronto = 9;
cairo = 11;
losAngeles = 12;
times = 20;
helvetica = 21;
courier = 22;
symbol = 23;
taliesin = 24;
(* special characters *)
commandMark = 21C;
checkMark = 22C;
diamondMark = 23C;
appleMark = 24C;
propFont = 09000H; (* proportional font *)
fixedFont = 0B000H; (* fixed-width font *)
fontWid = 0ACB0H; (* font width table *)
TYPE
FMInput = RECORD
family: INTEGER; (* font number *)
size: INTEGER; (* font size *)
face: Style; (* character style *)
needBits: BOOLEAN; (* TRUE if drawing *)
device: INTEGER; (* device-specific information *)
numer: Point; (* numerators of scaling factors *)
denom: Point; (* denominators of scaling factors *)
END;
FMOutPtr = POINTER TO FMOutput;
FMOutput = RECORD
errNum: INTEGER; (* not used *)
fontHandle: Handle; (* handle to font record *)
bold: BYTE; (* bold factor *)
italic: BYTE; (* italic factor *)
ulOffset: BYTE; (* underline shadow *)
ulThick: BYTE; (* underline thickness *)
shadow: BYTE; (* shadow factor *)
extra: BYTE; (* width of style *)
ascent: BYTE; (* ascent *)
descent: BYTE; (* descent *)
widMax: BYTE; (* width of style *)
leading: BYTE; (* leading *)
unused: BYTE; (* not used *)
numer: Point; (* numerators of scaling factors *)
denom: Point; (* denominators of scaling factors *)
END;
FontRec = RECORD
fontType: INTEGER; (* proportional or fixed width *)
firstChar: INTEGER; (* code of first defined char *)
lastChar: INTEGER; (* code of last defined char *)
widMax: INTEGER; (* maximum character width *)
kernMax: INTEGER; (* negative of maximum character kern *)
nDescent: INTEGER; (* negative of descent in pixels *)
fRectWidth: INTEGER; (* width of font rectangle *)
fRectHeight: INTEGER; (* height of font rectangle *)
owTLoc: INTEGER; (* Offset to owTable in words *)
ascent: INTEGER; (* Ascent in pixels *)
descent: INTEGER; (* Descent in pixels *)
leading: INTEGER; (* Leading in pixels *)
rowWords: INTEGER; (* Row width of bitImage in Words *)
(* bitImage: ARRAY [1..rowWords,1..chHeight] OF INTEGER; *)
(* locTable: ARRAY [firstChar..lastChar+2] OF INTEGER; *)
(* owTable: ARRAY [firstChar..lastChar+2] OF INTEGER; *)
END;
FontInfo = RECORD
ascent: INTEGER;
descent: INTEGER;
widMax: INTEGER;
leading: INTEGER;
END;
PROCEDURE GetFontName(fontNumber:INTEGER;VAR name:ARRAY OF CHAR);
PROCEDURE GetFNum(VAR name:ARRAY OF CHAR;VAR fontNumber:INTEGER);
PROCEDURE RealFont(fontNumber:INTEGER;pointSize:INTEGER):BOOLEAN;
PROCEDURE GetFontInfo(VAR info:FontInfo);
PROCEDURE SetFontLock(lock:BOOLEAN);
PROCEDURE FMSwapFont (inRec: FMInput) : FMOutPtr;
END FontManager.
!Funky!Stuff!
echo x - IUPackage.DEF
cat >IUPackage.DEF <<'!Funky!Stuff!'
DEFINITION MODULE IUPackage;
FROM SYSTEM IMPORT ADDRESS;
FROM MacSYSTEM IMPORT LONGINT,Handle;
EXPORT QUALIFIED
(*CONST*)
currSymLead,currNegSym,currTrailingZ,currLeadingZ,
mdy,dmy,ymd,
dayLeadingZ,mntLeadingZ,century,
secLeadingZ,minLeadingZ,hrLeadingZ,
verUS,verFrance,verBritain,verGermany,verItaly,
(*TYPE*)
Intl0Hndl,Intl0Ptr,Intl0Rec,
Intl1Hndl,Intl1Ptr,Intl1Rec,
DateForm,
(* Routines *)
IUDateString,IUDatePString,IUTimeString,IUTimePString,
IUMetric,IUGetIntl,IUSetIntl,IUCompString,IUMagString,
IUEqualString,IUMagIDString;
CONST
(* Masks for currency format *)
currSymLead = 16; (* set if currency symbol leads *)
currNegSym = 32; (* set if minus sign for negative *)
currTrailingZ = 64; (* set if trailing decimal zeroes *)
currLeadingZ = 128; (* set if leading integer zero *)
(* order of short date elements *)
mdy = 0; (* Month Day Year *)
dmy = 1; (* day month year *)
ymd = 2; (* year month day *)
(* masks for short date format *)
dayLeadingZ = 32; (* set if leading zero for day *)
mntLeadingZ = 64; (* set if leading zero for month *)
century = 128; (* set if century included *)
(* Masks for time format *)
secLeadingZ = 32; (* set if leading zero for seconds *)
minLeadingZ = 64; (* set if leading zero for minutes *)
hrLeadingZ = 128; (* set if leading zero for hours *)
(* High-order byte of version information *)
verUS = 0;
verFrance = 1;
verBritain = 2;
verGermany = 3;
verItaly = 4;
TYPE
Intl0Hndl = POINTER TO Intl0Ptr;
Intl0Ptr = POINTER TO Intl0Rec;
Intl0Rec = RECORD
decimalPt: CHAR; (* decimal point character *)
thousSep: CHAR; (* thousands separator *)
listSep: CHAR; (* list separator *)
currSym1: CHAR; (* currency symbol *)
currSym2: CHAR;
currSym3: CHAR;
currFmt: CHAR; (* currency format *)
dateOrder: CHAR; (* order of short date elements *)
shortDateFmt: CHAR; (* short date format *)
dateSep: CHAR; (* date separator *)
timeCycle: CHAR; (* 0 if 24-hour, 255 if 12-hour *)
timeFmt: CHAR; (* time format *)
mornStr: ARRAY [1..4] OF CHAR;
(* trailing string for first 12-hour cycle *)
eveStr: ARRAY [1..4] OF CHAR;
(* trailing string for second 12-hour cycle *)
timeSep: CHAR; (* time separator *)
time1Suff: CHAR; (* trailing string for 24-hour cycle *)
time2Suff: CHAR;
time3Suff: CHAR;
time4Suff: CHAR;
time5Suff: CHAR;
time6Suff: CHAR;
time7Suff: CHAR;
time8Suff: CHAR;
metricSys: CHAR; (* 255 if metric, 0 if not *)
intl0Vers: INTEGER;(* version information *)
END;
Intl1Hndl = POINTER TO Intl1Ptr;
Intl1Ptr = POINTER TO Intl1Rec;
Intl1Rec = RECORD
days: ARRAY [1..7] OF ARRAY [0..15] OF CHAR; (* Day Names *)
months: ARRAY [1..12] OF ARRAY [0..15] OF CHAR; (* month names *)
suppressDay: CHAR; (* 0 for day name, 255 for none *)
longDateFmt: CHAR; (* order of long date elements *)
dayleading0: CHAR; (* 255 for leading 0 in day number *)
abbrLen: CHAR; (* length for abbreviating names *)
st0: ARRAY [1..4] OF CHAR; (* strings *)
st1: ARRAY [1..4] OF CHAR; (* for *)
st2: ARRAY [1..4] OF CHAR; (* long *)
st3: ARRAY [1..4] OF CHAR; (* date *)
st4: ARRAY [1..4] OF CHAR; (* format *)
intl1Vers: INTEGER; (* version information *)
localRtn: INTEGER; (* routine for localizing string *)
(* comparision; actually may be longer than one integer *)
END;
DateForm = (shortDate, longDate, abbbrevDate,DFPad3,DFPad4,
DFPad5,DFPad6,DFPad7,DFPad8); (* force to be WORD size *)
(* Routines *)
PROCEDURE IUDateString (dateTime:LONGINT;form:DateForm;
VAR result:ARRAY OF CHAR);
PROCEDURE IUDatePString (dateTime:LONGINT;form:DateForm;
VAR result:ARRAY OF CHAR;intlParam:Handle);
PROCEDURE IUTimeString(dateTime:LONGINT;wantSeconds:BOOLEAN;
VAR result:ARRAY OF CHAR);
PROCEDURE IUTimePString(dateTime:LONGINT;wantSeconds:BOOLEAN;
VAR result:ARRAY OF CHAR; intlParam:Handle);
PROCEDURE IUMetric():BOOLEAN;
PROCEDURE IUGetIntl(theID:INTEGER):Handle;
PROCEDURE IUSetIntl(refNum:INTEGER; theID:INTEGER;intlParam:Handle);
PROCEDURE IUCompString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(* Pascal Only *)
PROCEDURE IUMagString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
PROCEDURE IUEqualString(VAR aStr,bStr:ARRAY OF CHAR):INTEGER;
(* Pascal Only *)
PROCEDURE IUMagIDString(aPtr,bPtr:ADDRESS;aLen,bLen:INTEGER):INTEGER;
END IUPackage.
!Funky!Stuff!
echo x - InOut.DEF
cat >InOut.DEF <<'!Funky!Stuff!'
DEFINITION MODULE InOut;
(*
* copied from the book "PROGRAMMING IN
* MODULA-2" by Miklaus Wirth Edited by
* David Gries pages 103 and 104.
*)
FROM SYSTEM IMPORT WORD;
EXPORT QUALIFIED
EOL, Done, termCH,
OpenInput, OpenOutput, CloseInput, CloseOutput,
Read, ReadString, ReadInt, ReadCard,
Write, WriteLn, WriteString, WriteInt, WriteCard,
WriteOct,WriteHex;
CONST
EOL = 15C; (* SYSTEM DEPENDENT *)
VAR Done: BOOLEAN;
VAR termCH: CHAR;
PROCEDURE OpenInput (VAR defext: ARRAY OF CHAR);
(* request a file name and open input file "in".
Done := "file was successfully opened".
If open, subsequent input is read from this
file. If name ends with ".", append extension defext*)
(* This procedure will use the SFPackage on the Mac BC *)
PROCEDURE OpenOutput (VAR defext: ARRAY OF CHAR);
(* request a file name and open output file "out"
Done := "file was successfully opened.
If open, subsequent output is written on this file *)
(* This procedure will also use the SFPackage on the Mac BC *)
PROCEDURE CloseInput;
(* closes input file; returns input to the terminal *)
PROCEDURE CloseOutput;
(* closes output file; returns output to terminal*)
PROCEDURE Read (VAR ch:CHAR);
(* Done := NOT in.eof *)
(* if EOF then ch = 0C *)
PROCEDURE ReadString (VAR s:ARRAY OF CHAR);
(*read string, i.e. sequence of characters not containing
blanks nor control characters; leading blanks are ignored.
Input is terminated by any character <= " ";
this character is assigned to termCH.
DEL is used for backspacing when input from terminal*)
(* I will make this a backspace for the Mac BC *)
PROCEDURE ReadInt (VAR x:INTEGER);
(* read strings and convert to integer. Syntax:
integer = ["+"|"-"]digit{digit}.
leading blanks are ignored.
Done := "integer was read" *)
PROCEDURE ReadCard (VAR x:CARDINAL);
(*read string and convert to cardinal. Syntax:
cardinal = digit {digit}
Leading blanks are ignored.
Done := "cardinal was read"*)
PROCEDURE Write (ch:CHAR);
PROCEDURE WriteLn; (*terminate line*)
PROCEDURE WriteString (VAR s:ARRAY OF CHAR);
PROCEDURE WriteInt (x: INTEGER; n: CARDINAL);
(*write integer x with (at least) n characters on file "out".
If n is greater than the number of digits needed,
blanks are added preceding the number*)
PROCEDURE WriteCard (x,n: CARDINAL);
PROCEDURE WriteOct (x: WORD; n: CARDINAL);
PROCEDURE WriteHex (x: WORD; n: CARDINAL);
END InOut.
!Funky!Stuff!
echo x - MacSYSTEM.DEF
cat >MacSYSTEM.DEF <<'!Funky!Stuff!'
DEFINITION MODULE MacSYSTEM;
FROM SYSTEM IMPORT WORD,ADDRESS;
EXPORT QUALIFIED LONGINT,LONGCARD,DOUBLE,EXTENDED,COMP,BYTE,
Fixed,Int64Bit,Ptr,Handle,Str255,StringPtr,StringHandle,OSErr,noErr;
CONST
noErr = 0;
TYPE
LONGINT = ADDRESS;
LONGCARD = ADDRESS;
DOUBLE = RECORD
Long1:LONGCARD;
Long2:LONGCARD;
END;
EXTENDED = ARRAY [0..4] OF CARDINAL;
COMP = DOUBLE;
BYTE = CHAR;
Fixed = LONGINT;
Int64Bit = RECORD
hiLong: LONGINT;
loLong: LONGINT;
END;
Ptr = ADDRESS;
Handle = POINTER TO Ptr;
Str255 = ARRAY [0..255] OF CHAR;
StringPtr = POINTER TO Str255;
StringHandle = POINTER TO StringPtr;
OSErr = INTEGER;
END MacSYSTEM.
!Funky!Stuff!
echo x - MathLib0.DEF
cat >MathLib0.DEF <<'!Funky!Stuff!'
DEFINITION MODULE MathLib0; (*Mathematical library 0 *)
EXPORT QUALIFIED
sqrt, sin, cos, arctan, exp, ln, real, entier;
PROCEDURE sqrt (x: REAL) : REAL;
PROCEDURE sin (x: REAL) : REAL;
PROCEDURE cos (x: REAL) : REAL;
PROCEDURE arctan (x: REAL) : REAL;
PROCEDURE exp (x: REAL) : REAL;
PROCEDURE ln (x: REAL) : REAL;
PROCEDURE entier (x: REAL) : INTEGER;
PROCEDURE real (x: INTEGER) : REAL;
END MathLib0.
!Funky!Stuff!
echo x - MathLib1.DEF
cat >MathLib1.DEF <<'!Funky!Stuff!'
DEFINITION MODULE MathLib1; (* Math. library 1 *)
(* additional mathematical functions*)
(* M. Schneider 4. Juli 1983 *)
EXPORT QUALIFIED
exp2, log2, tan,
random, setrandom, PI;
PROCEDURE exp2 ( x: REAL ): REAL;
PROCEDURE log2 ( x: REAL ): REAL;
PROCEDURE tan ( x: REAL ): REAL;
PROCEDURE random(): REAL;
(* range: 0.0 <= random < 1.0 *)
PROCEDURE setrandom( x0: REAL );
PROCEDURE PI(): REAL;
END MathLib1.
!Funky!Stuff!bobc@tikal.UUCP (Bob Campbell) (05/08/86)
# The rest of this file is a shell script which will extract:
# MemoryManager.DEF MenuManager.DEF PascalStrings.DEF Pictures.DEF
# QuickDraw.DEF Regions.DEF
echo x - MemoryManager.DEF
cat >MemoryManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE MemoryManager;
FROM SYSTEM IMPORT ADDRESS;
FROM MacSYSTEM IMPORT Handle,LONGINT,OSErr,noErr;
EXPORT QUALIFIED
(*CONST*)
maxSize,
(* Result codes *)
memFullErr,memLockedErr,memPurErr,memWZErr,nilHandleErr,
(*TYPES*)
Size,THz,Zone,MyGrowZone,
(*VAR*)
DefltStack,MinStack,MemTop,ScrnBase,BufPtr,CurrentA5,
CurStackBase,ApplLimit,HeapEnd,ApplZone,SysZone,TheZone,GZRootHnd,
(* Routines *)
InitApplZone,SetApplBase,InitZone,GetApplLimit,SetApplLimit,MaxApplZone,
MoreMasters,
GetZone,SetZone,SystemZone,ApplicZone,
NewHandle,DisposHandle,GetHandleSize,SetHandleSize,
HandleZone,RecoverHandle,ReallocHandle,
NewPtr,DisposPtr,GetPtrSize,SetPtrSize,PtrZone,
FreeMem,MaxMem,CompactMem,ResrvMem,PurgeMem,EmptyHandle,
HLock,HUnlock,HPurge,HNoPurge,
SetGrowZone,GZSaveHnd,
BlockMove,TopMem,MoveHHi,MemError;
CONST
maxSize = 0800000H;
(* Result codes *)
memFullErr = -108; (* not enough room in zone *)
memLockedErr = -117; (* block is locked *)
memPurErr = -112; (* attempt to purge a locked block *)
memWZErr = -111; (* attempt to operate on a free block *)
nilHandleErr = -109; (* NIL master pointer *)
TYPE
Size = LONGINT;
THz = POINTER TO Zone;
Zone = RECORD
bkLim: ADDRESS; (* limit pointer *)
purgePtr: ADDRESS; (* used internally *)
hFatFree: ADDRESS; (* first free master pointer *)
zcbFree: LONGINT; (* number of free bytes *)
gzProc: ADDRESS; (* grow zone function *)
moreMast: INTEGER; (* master pointers to allocate *)
flags: INTEGER; (* used internally *)
cntRel: INTEGER; (* relocatable blocks *)
maxRel: INTEGER; (* maximum cntRel value *)
cntNRel: INTEGER; (* nonrelocatable blocks *)
maxNRel: INTEGER; (* maximum maxRel value *)
cntEmpty: INTEGER; (* empty master pointers *)
cntHandles: INTEGER; (* total master pointers *)
minCBFree: LONGINT; (* minimum zcbFree value *)
purgeProc: ADDRESS; (* purge warning procedure *)
sparePtr: ADDRESS; (* used internally *)
allocPtr: ADDRESS; (* used internally *)
heapData: INTEGER; (* first usable byte in zone *)
END;
MyGrowZone = PROCEDURE(Size):Size;
VAR
DefltStack[0322H]: LONGINT;
MinStack[031EH]: LONGINT;
MemTop[0108H]: ADDRESS;
ScrnBase[0824H]: ADDRESS;
BufPtr[010CH]: ADDRESS;
CurrentA5[0904H]: ADDRESS;
CurStackBase[0908H]: ADDRESS;
ApplLimit[0130H]: ADDRESS;
HeapEnd[0114H]: ADDRESS;
ApplZone[02AAH]: ADDRESS;
SysZone[02A6H]: ADDRESS;
TheZone[0118H]: ADDRESS;
GZRootHnd[0328H]: ADDRESS;
(* Routines *)
(* Initialization and Allocation *)
PROCEDURE InitApplZone;
PROCEDURE SetApplBase(startPtr:ADDRESS);
PROCEDURE InitZone(pGrowZone:ADDRESS;cMoreMasters:INTEGER;
limitPtr,startPtr:ADDRESS);
PROCEDURE GetApplLimit():ADDRESS;(* Not in ROM *)
PROCEDURE SetApplLimit(zoneLimit:ADDRESS);
PROCEDURE MaxApplZone; (* No trap Macro *)
PROCEDURE MoreMasters;
(* Heap Zone Access *)
PROCEDURE GetZone():THz;
PROCEDURE SetZone(hz:THz);
PROCEDURE SystemZone():THz; (* No trap macro *)
PROCEDURE ApplicZone():THz; (* No trap macro *)
(* Allocating and Releasing Relocatable Blocks *)
PROCEDURE NewHandle(logicalSize:Size):Handle;
PROCEDURE DisposHandle(h:Handle);
PROCEDURE GetHandleSize(h:Handle):Size;
PROCEDURE SetHandleSize(h:Handle;newSize:Size);
PROCEDURE HandleZone(h:Handle):THz;
PROCEDURE RecoverHandle(p:ADDRESS):Handle;
PROCEDURE ReallocHandle(h:Handle;logicalSize:Size);
(* Allocating and Releasing Nonrelocatable Blocks *)
PROCEDURE NewPtr(logicalSize:Size):ADDRESS;
PROCEDURE DisposPtr(p:ADDRESS);
PROCEDURE GetPtrSize(p:ADDRESS):Size;
PROCEDURE SetPtrSize(p:ADDRESS;newSize:Size);
PROCEDURE PtrZone(p:ADDRESS):THz;
(* Freeing Space in the Heap *)
PROCEDURE FreeMem():LONGINT;
PROCEDURE MaxMem(VAR grow:Size):Size;
PROCEDURE CompactMem(cbNeeded:Size):Size;
PROCEDURE ResrvMem(cbNeeded:Size);
PROCEDURE PurgeMem(cbNeeded:Size);
PROCEDURE EmptyHandle(h:Handle);
(* Properties of Relocatable Blocks *)
PROCEDURE HLock(h:Handle);
PROCEDURE HUnlock(h:Handle);
PROCEDURE HPurge(h:Handle);
PROCEDURE HNoPurge(h:Handle);
(* Grow Zone Operations *)
PROCEDURE SetGrowZone(growZone:ADDRESS);
PROCEDURE GZSaveHnd():Handle; (* No trap macro *)
(* Miscellaneous Routines *)
PROCEDURE BlockMove(src,dst:ADDRESS;count:Size);
PROCEDURE TopMem():ADDRESS; (* No trap macro *)
PROCEDURE MoveHHi(h:Handle); (* No trap macro *)
PROCEDURE MemError():OSErr; (* No trap macro *)
END MemoryManager.
!Funky!Stuff!
echo x - MenuManager.DEF
cat >MenuManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE MenuManager;
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM MacSYSTEM IMPORT LONGINT,Handle;
FROM QuickDraw IMPORT Point,Rect,Style;
FROM ResourceManager IMPORT ResType;
EXPORT QUALIFIED
(*CONST*)
(* Special Characters *)
noMark,commandMark,checkMark,diamondMark,appleMark,
(* Messages to menu definition procedure *)
mDrawMsg,mChooseMsg,mSizeMsg,
(* Resource ID of standard menu definition procedure *)
textMenuProc,
(*TYPE*)
MenuHandle,MenuPtr,MenuInfo,
(*PROC*)
NewMenu,GetMenu,DisposeMenu,
(*Forming the Menus*)
AppendMenu,AddResMenu,InsertResMenu,
(*Forming the Menus*)
InsertMenu,DrawMenuBar,DeleteMenu,ClearMenuBar,GetNewMBar,
GetMenuBar,SetMenuBar,
(*Choosing from a menu*)
MenuSelect,MenuKey,HiliteMenu,
(*Controlling Items' Appearance*)
SetItem,GetItem,DisableItem,EnableItem,CheckItem,SetItemMark,
GetItemMark,SetItemIcon,GetItemIcon,SetItemStyle,GetItemStyle,
(*Miscellaneous Routines*)
CalcMenuSize,CountMItems,GetMHandle,FlashMenuBar,SetMenuFlash;
CONST
(* Special Characters *)
noMark = 0C; (* NULL Char, to remove a mark *)
commandMark = 021C; (* Command Key Symbol *)
checkMark = 022C;
diamondMark = 023C;
appleMark = 024C;
(* Messages to menu definition procedure *)
mDrawMsg = 0; (* draw the menu *)
mChooseMsg = 1; (* tell which item was chosen and highlight it *)
mSizeMsg = 2; (* calculate the menu's dimensions *)
(* Resource ID of standard menu definition procedure *)
textMenuProc = 0;
TYPE
MenuHandle = POINTER TO MenuPtr;
MenuPtr = POINTER TO MenuInfo;
MenuInfo = RECORD
menuID: INTEGER;
menuWidth: INTEGER;
menuHeight: INTEGER;
menuProc: Handle;
enableFlags: LONGINT;
menuData: ARRAY [0..255] OF CHAR;
END;
PROCEDURE NewMenu(menuID:INTEGER;VAR menuTitle:ARRAY OF CHAR):MenuHandle;
PROCEDURE GetMenu(resourceID:INTEGER):MenuHandle;
PROCEDURE DisposeMenu(theMenu:MenuHandle);
(*Forming the Menus*)
PROCEDURE AppendMenu(theMenu:MenuHandle;VAR data:ARRAY OF CHAR);
PROCEDURE AddResMenu(theMenu:MenuHandle;theType:ResType);
PROCEDURE InsertResMenu(theMenu:MenuHandle;theType:ResType;
afterItem:INTEGER);
(*Forming the Menus*)
PROCEDURE InsertMenu(theMenu:MenuHandle;beforeID:INTEGER);
PROCEDURE DrawMenuBar;
PROCEDURE DeleteMenu(menuID:INTEGER);
PROCEDURE ClearMenuBar;
PROCEDURE GetNewMBar(menuBarID:INTEGER):Handle;
PROCEDURE GetMenuBar():Handle;
PROCEDURE SetMenuBar(menuList:Handle);
(*Choosing from a menu*)
PROCEDURE MenuSelect(startPt:Point):LONGINT;
PROCEDURE MenuKey(ch:CHAR):LONGINT;
PROCEDURE HiliteMenu(menuID:INTEGER);
(*Controlling Items' Appearance*)
PROCEDURE SetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
PROCEDURE GetItem(theMenu:MenuHandle;item:INTEGER;VAR itemString:ARRAY OF CHAR);
PROCEDURE DisableItem(theMenu:MenuHandle;item:INTEGER);
PROCEDURE EnableItem(theMenu:MenuHandle;item:INTEGER);
PROCEDURE CheckItem(theMenu:MenuHandle;item:INTEGER;checked:BOOLEAN);
PROCEDURE SetItemMark(theMenu:MenuHandle;item:INTEGER;markChar:CHAR);
PROCEDURE GetItemMark(theMenu:MenuHandle;item:INTEGER;VAR markChar:CHAR);
PROCEDURE SetItemIcon(theMenu:MenuHandle;item:INTEGER;icon:CHAR);
PROCEDURE GetItemIcon(theMenu:MenuHandle;item:INTEGER;VAR icon:CHAR);
PROCEDURE SetItemStyle(theMenu:MenuHandle;item:INTEGER;chStyle:Style);
PROCEDURE GetItemStyle (theMenu: MenuHandle;item:INTEGER; VAR chStyle:Style);
(*Miscellaneous Routines*)
PROCEDURE CalcMenuSize(theMenu:MenuHandle);
PROCEDURE CountMItems(theMenu:MenuHandle):INTEGER;
PROCEDURE GetMHandle(menuID:INTEGER):MenuHandle;
PROCEDURE FlashMenuBar(menuID:INTEGER);
PROCEDURE SetMenuFlash(count:INTEGER);
END MenuManager.
!Funky!Stuff!
echo x - PascalStrings.DEF
cat >PascalStrings.DEF <<'!Funky!Stuff!'
DEFINITION MODULE PascalStrings; (* A.W. 20-NOV-84*)
(* last modification 19.01.85 fxk *)
(*
* This module converts arrays of characters into strings, as expected by
* the Lisa's or MacIntoshOS, and vice versa.
*)
EXPORT QUALIFIED MakePascalString, MakeModulaString,
emptyPascalString;
PROCEDURE MakePascalString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
(* converts a modula string into a pascal string. NOTE: If "out" is not
* long enough to hold the converted string, the latter is truncated!
*)
PROCEDURE MakeModulaString(VAR in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
(* converts a pascal string into a modula string. NOTE: If "out" is not
* long enough to hold the converted string, the latter is truncated!
*)
PROCEDURE emptyPascalString(VAR string:ARRAY OF CHAR);
(* makes an empty PascalString by setting length byte to zero *)
END PascalStrings.
!Funky!Stuff!
echo x - Pictures.DEF
cat >Pictures.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Pictures;
FROM QuickDraw IMPORT Rect;
EXPORT QUALIFIED
(*CONST*)
picLParen,picRParen,
(*TYPES*)
PicHandle,PicPtr,Picture,
(* Picture Routines *)
GetPicture,OpenPicture,ClosePicture,
KillPicture,DrawPicture,PicComment;
CONST
picLParen =0; picRParen =1; (* standard picture comments *)
TYPE
PicHandle = POINTER TO PicPtr;
PicPtr = POINTER TO Picture;
Picture = RECORD
picSize: INTEGER;
picFrame: Rect; (* picture definition data *)
END;
(* Picture Routines *)
PROCEDURE GetPicture(picID:INTEGER):PicHandle;
PROCEDURE OpenPicture (VAR picFrame:Rect):PicHandle;
PROCEDURE ClosePicture;
PROCEDURE KillPicture (thePicture:PicHandle);
PROCEDURE DrawPicture (thePicture:PicHandle;VAR inRect:Rect);
PROCEDURE PicComment (kind,dataSize:INTEGER;data:PicHandle);
END Pictures.
!Funky!Stuff!
echo x - QuickDraw.DEF
cat >QuickDraw.DEF <<'!Funky!Stuff!'
DEFINITION MODULE QuickDraw; (* Franz Kronseder 07.12.84 *)
(* last modification 06.02.85 *)
(* standalone modification 20.02.86 *)
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM MacSYSTEM IMPORT LONGINT;
(*
* This code is addapted from Inside Macintosh(TM) Volume I
*
* Because of the extreme size of this module some parts have been
* put in other modules where they make more sence.
*
* FontManager: GetFontInfo, and FontInfo.
* Cursors: InitCursor, SetCursor, HideCursor, ShowCursor,
* and ObscureCursor.
* Pictures: picLParen, picRParen, PicHandle, PicPtr, Picture, OpenPicture,
* PicComment, ClosePicture, DrawPicture, and KillPicture.
* Regions: NewRgn, OpenRgn, CloseRgn, DisposeRgn, SetEmptyRgn,
* RectRgn, CopyRgn, PtInRgn, RectInRgn, OffsetRgn, InsetRgn, EmptyRgn,
* UnionRgn, SectRgn, DiffRgn, XOrRgn, EqualRgn, MapRgn, FrameRgn,
* PaintRgn, FillRgn, EraseRgn, and InvertRgn.
* Toolbox: Random, and StuffHex.
*)
EXPORT QUALIFIED
(*CONST*)
srcCopy,srcOr,srcXor,srcBic,notSrcCopy,notSrcOr,notSrcXor,notSrcBic,
patCopy,patOr,patXor,patBic,notPatCopy,notPatOr,notPatXor,notPatBic,
blackColor,whiteColor,redColor,greenColor,blueColor,cyanColor,
magentaColor,yellowColor,
(*TYPE*)
Str255,QDHandle,
StyleItem,Style,VHSelect,Point,Rect,RgnHandle,RgnPtr,Region,
BitMap,Pattern,Bits16,Cursor,(*QDProcsPtr,QDProcs,*) GrafPtr,
GrafPort,PolyHandle,PolyPtr,Polygon,PenState,GrafVerb,
(*VAR*)
randSeed,screenBits,arrow,dkGray,ltGray,gray,black,white,thePort,
(* GrafPort Routines *)
OpenPort,InitPort,ClosePort,SetPort,GetPort,GrafDevice,
SetPortBits,PortSize,MovePortTo,SetOrigin,SetClip,GetClip,
ClipRect,BackPat,
(* Line Routines *)
HidePen,ShowPen,GetPen,GetPenState,SetPenState,PenSize,PenMode,
PenPat,PenNormal,MoveTo,Move,LineTo,Line,
(* Text Routines *)
TextFont,TextFace,TextMode,TextSize,SpaceExtra,DrawChar,DrawString,
DrawText,CharWidth,StringWidth,TextWidth,
(* Point Calculations *)
AddPt,SubPt,SetPt,EqualPt,ScalePt,MapPt,LocalToGlobal,GlobalToLocal,
(* Rectangle Calculations *)
SetRect,EqualRect,EmptyRect,OffsetRect,MapRect,InsetRect,SectRect,
UnionRect,PtInRect,Pt2Rect,
(* Graphical Operations on Rectangles *)
FrameRect,PaintRect,EraseRect,InvertRect,FillRect,
(* RoundRect Routines *)
FrameRoundRect,PaintRoundRect,FillRoundRect,EraseRoundRect,
InvertRoundRect,
(* Drawing Ovals *)
FrameOval,PaintOval,EraseOval,InvertOval,FillOval,
(* Arc Routines *)
FrameArc,PaintArc,FillArc,EraseArc,InvertArc,PtToAngle,
(* Polygon Routines *)
OpenPoly,ClosePoly,KillPoly,OffsetPoly,MapPoly,FramePoly,PaintPoly,
FillPoly,ErasePoly,InvertPoly,
(* Graphical Operations on BitMaps *)
ScrollRect,CopyBits,
(* Misc Utility Routines *)
GetPixel,ForeColor,BackColor,ColorBit;
(* these definitions come from the MacIntosh Interface files
* on the Lisa Workshop Supplement for the MAC.
* Copyright 1983 Apple Computer Inc.
*)
(* the 16 transfer modes *)
CONST
srcCopy = 0; 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;
(* normal screen mapping inverse screen mapping *)
(* RGB additive mapping CMYBk subtractive mapping *)
(* colors expressed in these mappings *)
blackColor = 33; whiteColor = 30;
redColor = 205; greenColor = 341;
blueColor = 409; cyanColor = 273;
magentaColor = 137; yellowColor = 69;
TYPE
QDHandle = POINTER TO ADDRESS; (* blind handle *)
Str255 = ARRAY [0..255] OF CHAR; (* Pascal compatible String *)
StyleItem = (bold,italic,underline,outline,shadow,condense,extend,
unused1,unused2); (* sets of < 8 elements are a byte *)
Style = SET OF StyleItem;
VHSelect = (v,h);
Point = RECORD
CASE INTEGER OF
0: v: INTEGER;h: INTEGER;
| 1: vh: ARRAY VHSelect OF INTEGER
| 2: param:LONGINT
END
END;
Rect = RECORD
CASE INTEGER OF
0: top: INTEGER;
left: INTEGER;
bottom: INTEGER;
right: INTEGER;
| 1: topLeft: Point;
botRight: Point;
END
END;
(* Region Definitions are here to avoid cyclic imports *)
RgnHandle = POINTER TO RgnPtr;
RgnPtr = POINTER TO Region;
Region = RECORD
rgnSize: INTEGER; (* rgnSize = 10 for rectangular *)
rgnBBox: Rect; (* plus more data if not rectangular *)
END;
BitMap = RECORD
baseAddr: ADDRESS;
rowBytes: INTEGER;
bounds: Rect;
END;
Pattern = ARRAY[0..7] OF SET OF [0..7];
Bits16 = ARRAY[0..15] OF INTEGER;
Cursor = RECORD
data: Bits16;
mask: Bits16;
hotSpot: Point;
END;
(*
* Not supported yet, removed to save space.
*
* QDProcsPtr = POINTER TO QDProcs;
* QDProcs = RECORD
* textProc: ADDRESS;
* lineProc: ADDRESS;
* rectProc: ADDRESS;
* rRectProc: ADDRESS;
* ovalProc: ADDRESS;
* arcProc: ADDRESS;
* polyProc: ADDRESS;
* rgnProc: ADDRESS;
* bitsProc: ADDRESS;
* commentProc: ADDRESS;
* txMeasProc: ADDRESS;
* getPicProc: ADDRESS;
* putPicProc: ADDRESS;
* END;
*)
GrafPtr = POINTER TO 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;
txMode: INTEGER;
txSize: INTEGER;
spExtra: LONGINT;
fgColor: LONGINT;
bkColor: LONGINT;
colrBit: INTEGER;
patStretch: INTEGER;
picSave: QDHandle;
rgnSave: QDHandle;
polySave: QDHandle;
grafProcs: ADDRESS; (* was QDProcsPtr *)
END;
(* PicHandle, PicPtr, and Picture moved to Pictures *)
PolyHandle = POINTER TO PolyPtr;
PolyPtr = POINTER TO Polygon;
Polygon = RECORD
polySize: INTEGER;
polyBBox: Rect;
polyPoints: ARRAY [0..0] OF Point
END;
PenState = RECORD
pnLoc: Point;
pnSize: Point;
pnMode: INTEGER;
pnPat: Pattern;
END;
GrafVerb = (frame,paint,erase,invert,fill);
VAR (* Must pad for Private QuickDraw Values *)
QDPad: ARRAY[0..37] OF CARDINAL;
(*
wideOpen EQU $FFFFFF7E ; RgnHandle
wideMaster EQU $FFFFFF7A ; RgnPtr
wideData EQU $FFFFFF70 ; Fake Region
rgnBuf EQU $FFFFFF6C ; PointsHandle
rgnIndex EQU $FFFFFF6A ; INTEGER
rgnMax EQU $FFFFFF68 ; INTEGER
playPic EQU $FFFFFF64 ; Long
playIndex EQU $FFFFFF62 ; INTEGER
thePoly EQU $FFFFFF5E ; POLYHANDLE
polyMax EQU $FFFFFF5C ; INTEGER
patAlign EQU $FFFFFF58 ; Point
fontAdj EQU $FFFFFF54 ; Fixed Point
fontPtr EQU $FFFFFF50 ; long, ^FMOutput record
fontData EQU $FFFFFF36 ; FMOutput record
lastGrafGlob EQU $FFFFFF36
*)
randSeed: LONGINT; (* -126 *)
screenBits: BitMap; (* -122 *)
arrow: Cursor; (* -108 *)
dkGray: Pattern; (* -40 *)
ltGray: Pattern; (* -32 *)
gray: Pattern; (* -24 *)
black: Pattern; (* -16 *)
white: Pattern; (* -8 *)
thePort: GrafPtr; (* 0 *)
(* GrafPort Routines *)
(* InitGraf is automaticly called *)
PROCEDURE OpenPort (port: GrafPtr);
PROCEDURE InitPort (port: GrafPtr);
PROCEDURE ClosePort (port: GrafPtr);
PROCEDURE SetPort (port: GrafPtr);
PROCEDURE GetPort (VAR port: GrafPtr);
PROCEDURE GrafDevice (device: INTEGER);
PROCEDURE SetPortBits(VAR bm: BitMap);
PROCEDURE PortSize (width,height: INTEGER);
PROCEDURE MovePortTo (leftGlobal,topGlobal: INTEGER);
PROCEDURE SetOrigin (h,v: INTEGER);
PROCEDURE SetClip (rgn: RgnHandle);
PROCEDURE GetClip (rgn: RgnHandle);
PROCEDURE ClipRect (VAR r: Rect);
PROCEDURE BackPat (VAR pat: Pattern);
(* Cursor Routines moved to Cursors *)
(* Line Routines *)
PROCEDURE HidePen;
PROCEDURE ShowPen;
PROCEDURE GetPen (VAR pt: Point);
PROCEDURE GetPenState(VAR pnState: PenState);
PROCEDURE SetPenState(VAR pnState: PenState);
PROCEDURE PenSize (width,height: INTEGER);
PROCEDURE PenMode (mode: INTEGER);
PROCEDURE PenPat (VAR pat: Pattern);
PROCEDURE PenNormal;
PROCEDURE MoveTo (h,v: INTEGER);
PROCEDURE Move (dh,dv: INTEGER);
PROCEDURE LineTo (h,v: INTEGER);
PROCEDURE Line (dh,dv: INTEGER);
(* Text Routines *)
PROCEDURE TextFont (font: INTEGER);
PROCEDURE TextFace (face: Style);
PROCEDURE TextMode (mode: INTEGER);
PROCEDURE TextSize (size: INTEGER);
PROCEDURE SpaceExtra (extra: LONGINT);
PROCEDURE DrawChar (ch: CHAR);
PROCEDURE DrawString (VAR s:ARRAY OF CHAR);
PROCEDURE DrawText (textBuf: ADDRESS; firstByte,byteCount: INTEGER);
PROCEDURE CharWidth (ch: CHAR): INTEGER;
PROCEDURE StringWidth (VAR s:ARRAY OF CHAR): INTEGER;
PROCEDURE TextWidth (textBuf: ADDRESS; firstByte,byteCount: INTEGER): INTEGER;
(* GetFontInfo moved to FontManager *)
(* Drawing In Color *)
PROCEDURE ForeColor (color:LONGINT);
PROCEDURE BackColor (color:LONGINT);
PROCEDURE ColorBit (whichBit:INTEGER);
(* Rectangle Calculations *)
PROCEDURE SetRect (VAR r:Rect;left,top,right,bottom:INTEGER);
PROCEDURE OffsetRect(VAR r:Rect;dh,dv:INTEGER);
PROCEDURE InsetRect (VAR r:Rect;dh,dv:INTEGER);
PROCEDURE SectRect (VAR src1,src2:Rect;VAR dstRect:Rect):BOOLEAN;
PROCEDURE UnionRect (VAR src1,src2:Rect;VAR dstRect:Rect);
PROCEDURE PtInRect (pt: Point; dstRect:Rect):BOOLEAN;
PROCEDURE Pt2Rect (pt1,pt2:Point;VAR dstRect:Rect);
PROCEDURE PtToAngle(inRect:Rect;thePoint:Point;VAR theAngle:INTEGER);
PROCEDURE EqualRect(VAR rect1,rect2:Rect):BOOLEAN;
PROCEDURE EmptyRect(VAR r:Rect):BOOLEAN;
(* Graphical Operations on Rectangles *)
PROCEDURE FrameRect (VAR r: Rect);
PROCEDURE PaintRect (VAR r: Rect);
PROCEDURE EraseRect (VAR r: Rect);
PROCEDURE InvertRect (VAR r: Rect);
PROCEDURE FillRect (VAR r: Rect;VAR pat: Pattern);
(* Drawing Ovals *)
PROCEDURE FrameOval(VAR inRect:Rect);
PROCEDURE PaintOval(VAR inRect:Rect);
PROCEDURE EraseOval(VAR inRect:Rect);
PROCEDURE InvertOval(VAR inRect:Rect);
PROCEDURE FillOval(VAR inRect:Rect;VAR pat:Pattern);
(* RoundRect Routines *)
PROCEDURE FrameRoundRect (VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
PROCEDURE PaintRoundRect (VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
PROCEDURE EraseRoundRect(VAR theRect:Rect;cornerWidth,cornerHeight:INTEGER);
PROCEDURE InvertRoundRect(VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER);
PROCEDURE FillRoundRect (VAR theRect:Rect;cornerWidth,cornerHeigth:INTEGER;
VAR fillPat:Pattern);
(* Arc Routines *)
PROCEDURE FrameArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
PROCEDURE PaintArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
PROCEDURE EraseArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
PROCEDURE InvertArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER);
PROCEDURE FillArc(VAR inRect:Rect;startAngle,arcAngle:INTEGER;
VAR fillpat:Pattern);
(* Region routines move to Regions *)
(* Graphical Operations on BitMaps *)
PROCEDURE ScrollRect(VAR dstRect: Rect; dh,dv: INTEGER; updateRgn: RgnHandle);
PROCEDURE CopyBits (VAR srcBits,dstBits: BitMap;
VAR srcRect,dstRect: Rect;
mode: INTEGER;
maskRgn: RgnHandle);
(* Picture routines moved to Pictures *)
(* Polygon Routines *)
PROCEDURE OpenPoly():PolyHandle;
PROCEDURE ClosePoly;
PROCEDURE KillPoly (thePolygon:PolyHandle);
PROCEDURE OffsetPoly (thePolygon:PolyHandle;hOffset,vOffset:INTEGER);
PROCEDURE FramePoly (thePolygon:PolyHandle);
PROCEDURE PaintPoly (thePolygon:PolyHandle);
PROCEDURE ErasePoly (thePolygon:PolyHandle);
PROCEDURE InvertPoly (thePolygon:PolyHandle);
PROCEDURE FillPoly (thePolygon:PolyHandle;VAR fillPat:Pattern);
(* Point Calculations *)
PROCEDURE AddPt (src:Point;VAR dst:Point);
PROCEDURE SubPt (src:Point;VAR dst:Point);
PROCEDURE SetPt (VAR pt: Point;h,v:INTEGER);
PROCEDURE EqualPt (pt1,pt2: Point) :BOOLEAN;
PROCEDURE LocalToGlobal (VAR pt:Point);
PROCEDURE GlobalToLocal (VAR pt:Point);
(* Misc Utility Routines *)
PROCEDURE GetPixel(h,v:INTEGER):BOOLEAN;
PROCEDURE ScalePt (VAR pt:Point;VAR fromRect,toRect:Rect);
PROCEDURE MapPt (VAR pt:Point;VAR fromRect,toRect:Rect);
PROCEDURE MapRect (VAR r:Rect;VAR fromRect,toRect:Rect);
(* MapRgn moved to Regions *)
PROCEDURE MapPoly (thePolygon:PolyHandle;VAR fromRect,toRect:Rect);
END QuickDraw.
!Funky!Stuff!
echo x - Regions.DEF
cat >Regions.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Regions;
FROM QuickDraw IMPORT RgnHandle,RgnPtr,Region,Point,Rect,Pattern;
EXPORT QUALIFIED
(* Region Calculations *)
NewRgn,OpenRgn,CloseRgn,DisposeRgn,SetEmptyRgn,RectRgn,CopyRgn,
PtInRgn,RectInRgn,OffsetRgn,InsetRgn,EmptyRgn,UnionRgn,SectRgn,
DiffRgn,XOrRgn,EqualRgn,MapRgn,
(* Drawing Regions *)
FrameRgn,PaintRgn,FillRgn,EraseRgn,InvertRgn;
(* Region Calculations *)
PROCEDURE NewRgn ():RgnHandle;
PROCEDURE OpenRgn;
PROCEDURE CloseRgn (theRegion:RgnHandle);
PROCEDURE DisposeRgn (theRegion:RgnHandle);
PROCEDURE SetEmptyRgn (theRegion:RgnHandle);
PROCEDURE RectRgn (theRegion:RgnHandle;VAR theRect:Rect);
PROCEDURE SetRectRgn (theRegion:RgnHandle;left,top,right,bottom:INTEGER);
PROCEDURE CopyRgn (fromRegion,toRegion:RgnHandle);
PROCEDURE PtInRgn (thePoint:Point;theRegion:RgnHandle):BOOLEAN;
PROCEDURE RectInRgn (VAR theRect:Rect;theRegion:RgnHandle):BOOLEAN;
PROCEDURE OffsetRgn (theRegion:RgnHandle;hOffset,vOffset:INTEGER);
PROCEDURE InsetRgn (theRegion:RgnHandle;hInset,vInset:INTEGER);
PROCEDURE EmptyRgn (theRegion:RgnHandle):BOOLEAN;
PROCEDURE UnionRgn (region1,region2,resultRegion:RgnHandle);
PROCEDURE SectRgn (region1,region2,resultRegion:RgnHandle);
PROCEDURE DiffRgn (region1,region2,resultRegion:RgnHandle);
PROCEDURE XOrRgn (region1,region2,resultRegion:RgnHandle);
PROCEDURE EqualRgn (region1,region2:RgnHandle):BOOLEAN;
PROCEDURE MapRgn (theRegion:RgnHandle;VAR fromRect,toRect:Rect);
(* Drawing Regions *)
PROCEDURE FrameRgn (theRegion:RgnHandle);
PROCEDURE PaintRgn (theRegion:RgnHandle);
PROCEDURE FillRgn (theRegion:RgnHandle;VAR fillPat:Pattern);
PROCEDURE EraseRgn (theRegion:RgnHandle);
PROCEDURE InvertRgn (theRegion:RgnHandle);
END Regions.
!Funky!Stuff!bobc@tikal.UUCP (Bob Campbell) (05/08/86)
# The rest of this file is a shell script which will extract:
# ResourceManager.DEF SFPackage.DEF SYSTEMX.DEF ScrapManager.DEF
# Storage.DEF Streams.DEF Terminal.DEF TextEdit.DEF Toolbox.DEF
# WindowManager.DEF
echo x - ResourceManager.DEF
cat >ResourceManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE ResourceManager;
FROM SYSTEM IMPORT ADDRESS;
FROM MacSYSTEM IMPORT LONGINT,Handle;
EXPORT QUALIFIED
(*CONST*)
(* Resource attributes *)
resSysRef,resSysHeap,resPurgeable,resLocked,resProtected,
resPreload,resChanged,
(* Resource Manager Result codes *)
resNotFound,resFNotFound,addResFailed,addRefFailed,rmvResFailed,
rmvRefFailed,
(* Resource file attributes *)
mapReadOnly,mapCompact,mapChanged,
(*TYPE*)
ResType,ParamResType,
(*VAR*)
CurMap,CurApRefNum,SysMap,SysResName,SysMapHndl,TopMapHndl,ResLoad,
ResErr,
(*PROC*)
CreateResFile,OpenResFile,CloseResFile,
ResError,
CurResFile,HomeResFile,UseResFile,
CountTypes,GetIndType,
SetResLoad,CountResources,GetIndResource,GetResource,
GetNamedResource,LoadResource,ReleaseResource,DetachResource,
UniqueID,GetResInfo,GetResAttrs,SizeResource,
SetResInfo,SetResAttrs,ChangedResource,AddResource,
RmveResource,UpdateResFile,WriteResource,SetResPurge,
GetResFileAttrs,SetResFileAttrs;
CONST
(* Resource attributes *)
resSysRef = 128; (* set if system reference *)
resSysHeap = 64; (* set if read into system heap *)
resPurgeable = 32; (* set if purgeable *)
resLocked = 16; (* set if locked *)
resProtected = 8; (* set if protected *)
resPreload = 4; (* set if to be preloaded *)
resChanged = 2; (* set if to be written to res file *)
(* Resource Manager Result codes *)
resNotFound = -192; (* resource not found *)
resFNotFound = -193; (* resource file not found *)
addResFailed = -194; (* AddResource failed *)
addRefFailed = -195; (* AddReference failed *)
rmvResFailed = -196; (* RmveResource failed *)
rmvRefFailed = -197; (* RmveReference failed *)
(* Resource file attributes *)
mapReadOnly = 128; (* set if file is read-only *)
mapCompact = 64; (* set to compact file on update*)
mapChanged = 32; (* set to write map on update *)
TYPE
ResType = ARRAY [0..3] OF CHAR;
ParamResType = RECORD
CASE INTEGER OF
0:
res:ResType
| 1:
param:LONGINT
END
END;
VAR
TopMapHndl[0A50H]: Handle;
SysMapHndl[0A54H]: Handle;
SysMap[0A58H]: CARDINAL;
CurMap[0A5AH]: CARDINAL;
ResLoad[0A5EH]: BOOLEAN;
ResErr[0A60H]: INTEGER;
CurApRefNum[0900H]: CARDINAL;
SysResName[0AD8H]: ARRAY [0..20] OF CHAR;
(* Opening and Closing Resource Files *)
PROCEDURE CreateResFile(VAR fileName:ARRAY OF CHAR);
PROCEDURE OpenResFile(VAR fileName:ARRAY OF CHAR):INTEGER;
PROCEDURE CloseResFile(refNum:INTEGER);
(* Checking for Errors *)
PROCEDURE ResError():INTEGER;
(* Setting the Current Resource File *)
PROCEDURE CurResFile():INTEGER;
PROCEDURE HomeResFile(theResource:Handle):INTEGER;
PROCEDURE UseResFile(refNum:INTEGER);
(* Getting Resource Types *)
PROCEDURE CountTypes():INTEGER;
PROCEDURE GetIndType(VAR theType:ResType;index:INTEGER);
(* Getting and Disposing of Resources *)
PROCEDURE SetResLoad(load:BOOLEAN);
PROCEDURE CountResources(theType:ResType):INTEGER;
PROCEDURE GetIndResource(theType:ResType;index:INTEGER):Handle;
PROCEDURE GetResource(theType:ResType;theID:INTEGER):Handle;
PROCEDURE GetNamedResource(theType:ResType;VAR name:ARRAY OF CHAR):Handle;
PROCEDURE LoadResource(theResource:Handle);
PROCEDURE ReleaseResource(theResource:Handle);
PROCEDURE DetachResource(theResource:Handle);
(* Getting Resource Information *)
PROCEDURE UniqueID(theType:ResType):INTEGER;
PROCEDURE GetResInfo(theResource:Handle;VAR theID:INTEGER;
VAR theType:ResType; VAR name:ARRAY OF CHAR);
PROCEDURE GetResAttrs(theResource:Handle):INTEGER;
PROCEDURE SizeResource(theResource:Handle):LONGINT;
(* Modifying Resources *)
PROCEDURE SetResInfo(theResource:Handle; theID:INTEGER;VAR name:ARRAY OF CHAR);
PROCEDURE SetResAttrs(theResource:Handle;attrs:INTEGER);
PROCEDURE ChangedResource(theResource:Handle);
PROCEDURE AddResource(theData:Handle;theType:ResType;theID:INTEGER;
VAR name:ARRAY OF CHAR);
PROCEDURE RmveResource(theResource:Handle);
PROCEDURE UpdateResFile(refNum:INTEGER);
PROCEDURE WriteResource(theResource:Handle);
PROCEDURE SetResPurge(install:BOOLEAN);
(* Advanced Routines *)
PROCEDURE GetResFileAttrs(refNum:INTEGER):INTEGER;
PROCEDURE SetResFileAttrs(refNum:INTEGER;attrs:INTEGER);
END ResourceManager.
!Funky!Stuff!
echo x - SFPackage.DEF
cat >SFPackage.DEF <<'!Funky!Stuff!'
DEFINITION MODULE SFPackage;
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM QuickDraw IMPORT Point;
FROM FileTypes IMPORT OSType,ParamBlkPtr;
FROM DialogManager IMPORT DialogPtr;
EXPORT QUALIFIED putDlgID,getDlgID,SFReply,SFTypeList,
SFPutFile,SFPPutFile, SFGetFile,SFPGetFile,
putSave ,putCancel,putEject ,putDrive ,putName,
getOpen,getCancel,getEject,getDrive,getScroll,
getNmList,MyDlgType,MyFileFilterType,NoFileFilter,NoDlg,
UseDlg,UseFileFilter;
(* constants for Standard File package *)
CONST
putDlgID = -3999; (* SFPutFile dialog template ID} *)
getDlgID = -4000; (* SFGetFile dialog template ID} *)
putSave = 1; (* save button} *)
putCancel = 2; (* cancel button} *)
putEject = 5; (* eject button} *)
putDrive = 6; (* drive button} *)
putName = 7; (* editTExt item for file name} *)
getOpen = 1; (* open button} *)
getCancel = 3; (* cancel button} *)
getEject = 5; (* eject button} *)
getDrive = 6; (* drive button} *)
getNmList = 7; (* userItem for file name list} *)
getScroll = 8; (* userItem for scroll bar} *)
TYPE
SFReply = RECORD
good: BOOLEAN; (* ignore command if FALSE} *)
copy: BOOLEAN; (* not used} *)
fType: OSType; (* file type or not used} *)
vRefNum: INTEGER; (* volume reference number} *)
version: INTEGER; (* file's version number} *)
fName: ARRAY [0..63] OF CHAR
END; (* SFReply *)
SFTypeList = ARRAY[0..3] OF OSType;
MyDlgType = PROCEDURE(INTEGER,DialogPtr):INTEGER;
MyFileFilterType = PROCEDURE(ParamBlkPtr):BOOLEAN;
PROCEDURE NoDlg():ADDRESS;
PROCEDURE UseDlg(Dlg:MyDlgType):ADDRESS;
PROCEDURE NoFileFilter():ADDRESS;
PROCEDURE UseFileFilter(FileFilter:MyFileFilterType):ADDRESS;
PROCEDURE SFPutFile(lefttop:Point;
VAR prompt: ARRAY OF CHAR; VAR origName: ARRAY OF CHAR;
dlgHook: ADDRESS; VAR reply: SFReply);
PROCEDURE SFPPutFile(lefttop:Point;
VAR prompt: ARRAY OF CHAR; VAR origName: ARRAY OF CHAR;
dlgHook: ADDRESS; VAR reply: SFReply; dlgID: INTEGER;
filterProc: ADDRESS);
PROCEDURE SFGetFile(lefttop:Point;
VAR prompt: ARRAY OF CHAR; fileFilter: ADDRESS;
numTypes: INTEGER; VAR typeList: SFTypeList;
dlgHook: ADDRESS; VAR reply: SFReply);
PROCEDURE SFPGetFile(lefttop:Point;
VAR prompt: ARRAY OF CHAR; fileFilter: ADDRESS;
numTypes: INTEGER; VAR typeList: SFTypeList;
dlgHook: ADDRESS; VAR reply: SFReply;
dlgID: INTEGER; filterProc: ADDRESS);
END SFPackage.
!Funky!Stuff!
echo x - SYSTEMX.DEF
cat >SYSTEMX.DEF <<'!Funky!Stuff!'
DEFINITION MODULE SYSTEMX;
FROM SYSTEM IMPORT ADDRESS,PROCESS;
EXPORT QUALIFIED SaveA5,SaveA6,SaveA7,SaveA0,
DoCASE,DoHALT,CheckStack,NEWPROCESS,TRANSFER,IOTRANSFER,
SYSProc7,SYSLongMult,SYSLongDivMod,SYSLongIntMult,SYSProc11,
SYSRealAdd,SYSRealSub,SYSRealMult,SYSRealDiv,SYSRealCMP,
SYSRealTST,SYSRealFLOAT,SYSRealTRUNC;
VAR
SaveA5,SaveA7,SaveA6,SaveA0:ADDRESS;
PROCEDURE DoCASE; (* 1 *)
PROCEDURE DoHALT; (* 2 *)
PROCEDURE CheckStack; (* 3 *)
PROCEDURE NEWPROCESS; (* 4 *)
PROCEDURE TRANSFER; (* 5 *)
PROCEDURE IOTRANSFER(p1,p2:PROCESS; via:ADDRESS); (* 6 *)
PROCEDURE SYSProc7; (* 7 *)
(* IF D0 = 2 THEN LISTEN ELSIF D0 = 3 THEN SYSRESET END *)
PROCEDURE SYSLongMult; (* 8 *)
PROCEDURE SYSLongDivMod; (* 9 *)
PROCEDURE SYSLongIntMult; (* 10 *)
PROCEDURE SYSProc11; (* 11 *)
PROCEDURE SYSRealAdd; (* 12 *)
PROCEDURE SYSRealSub; (* 13 *)
PROCEDURE SYSRealMult; (* 14 *)
PROCEDURE SYSRealDiv; (* 15 *)
PROCEDURE SYSRealCMP; (* 16 *)
PROCEDURE SYSRealTST; (* 17 *)
PROCEDURE SYSRealFLOAT; (* 18 *)
PROCEDURE SYSRealTRUNC; (* 19 *)
END SYSTEMX.
!Funky!Stuff!
echo x - ScrapManager.DEF
cat >ScrapManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE ScrapManager;
FROM MacSYSTEM IMPORT LONGINT,Handle,StringPtr;
FROM ResourceManager IMPORT ResType;
FROM SYSTEM IMPORT ADDRESS;
EXPORT QUALIFIED noScrapErr,noTypeErr,PScrapStuff,ScrapStuff,
InfoScrap,UnloadScrap,LoadScrap,ZeroScrap,PutScrap,GetScrap,
ScrapSize,ScrapHandle,ScrapCount,ScrapState,ScrapName;
CONST
noScrapErr = -100; (* desk scrap isn't initialized *)
noTypeErr = -102; (* no data of the requested type *)
TYPE
PScrapStuff = POINTER TO ScrapStuff;
ScrapStuff = RECORD
scrapSize: LONGINT; (* size of desk scrap *)
scrapHandle: Handle; (* handle to desk scrap *)
scrapCount: INTEGER; (* count changed by ZeroScrap *)
scrapState: INTEGER; (* tells where desk scrap is *)
scrapName: StringPtr; (* scrap file name *)
END;
VAR
ScrapSize[0960H]: LONGINT;
ScrapHandle[0964H]: Handle;
ScrapCount[0968H]: INTEGER;
ScrapState[096AH]: INTEGER;
ScrapName[096CH]: StringPtr;
PROCEDURE InfoScrap():PScrapStuff;
PROCEDURE UnloadScrap():LONGINT;
PROCEDURE LoadScrap():LONGINT;
PROCEDURE ZeroScrap():LONGINT;
PROCEDURE PutScrap(length: LONGINT; theType: ResType; source: ADDRESS):LONGINT;
PROCEDURE GetScrap(hDest:Handle;theType: ResType; VAR offset: LONGINT):LONGINT;
END ScrapManager.
!Funky!Stuff!
echo x - Storage.DEF
cat >Storage.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Storage;
(* to be used unchanged for MacIntosh by Franz Kronseder 30.01.85 *)
(* Modified for standalone MacIntosh Code By Bob Campbell 10.02.86
* The Implementation now used the A-Line calls to the memory manager
* All of the storage allocated is set to zero. The Calls CreateHeap,
* and DestroyHeap have been removed.
*)
FROM SYSTEM IMPORT ADDRESS;
EXPORT QUALIFIED
ALLOCATE, DEALLOCATE, Available;
PROCEDURE ALLOCATE (VAR addr : ADDRESS; amount : CARDINAL);
(* allocates the requested amount of memory (in bytes) and returns the *)
(* starting address . Return NIL if the amount is not available *)
PROCEDURE DEALLOCATE (VAR addr : ADDRESS; amount : CARDINAL);
(* deallocates the given amount of memory (in bytes). *)
PROCEDURE Available (amount : CARDINAL) : BOOLEAN;
(* returns TRUE if an ALLOCATE of the specified amount (in bytes) *)
(* of memory would be possible *)
END Storage.
!Funky!Stuff!
echo x - Streams.DEF
cat >Streams.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Streams;
(*
* Modified from the book "PROGRAMMING IN
* MODULA-2" by Miklaus Wirth Edited by
* David Gries pages 103 and 104.
*)
FROM SYSTEM IMPORT WORD,ADDRESS;
FROM MacSYSTEM IMPORT LONGINT;
FROM FileTypes IMPORT ParamBlkRec,OSType;
EXPORT QUALIFIED
STREAM,OpenMode,Open,Close,Create,
WriteWord,WriteChar,WriteBuffer,
ReadWord,ReadChar,ReadBuffer,
EOS,Reset,SetPos,GetPos,eolc;
CONST
eolc = 15C;
TYPE
STREAM = POINTER TO StreamRec;
StreamRec = RECORD
IsOpen : BOOLEAN;
Buffer : ADDRESS;
FileNum : INTEGER;
EOSPos : LONGINT;
CurrentPos : LONGINT;
PB : ParamBlkRec;
END;
OpenMode = (ReadOnly,WriteOnly,ReadWrite);
OSType = ARRAY [0..3] OF CHAR;
PROCEDURE Open(VAR file:STREAM; VAR Name:ARRAY OF CHAR;vref:INTEGER;
Mode:OpenMode);
PROCEDURE Create(VAR Name:ARRAY OF CHAR;vRef:INTEGER;
creator,type:OSType);
PROCEDURE Close(s:STREAM);
PROCEDURE WriteWord(s:STREAM;w:WORD);
PROCEDURE WriteChar(s:STREAM;c:CHAR);
PROCEDURE WriteBuffer(s:STREAM;b:ADDRESS;len:LONGINT):LONGINT;
PROCEDURE ReadWord(s:STREAM;VAR w:WORD);
PROCEDURE ReadChar(s:STREAM;VAR c:CHAR);
PROCEDURE ReadBuffer(s:STREAM;b:ADDRESS;len:LONGINT):LONGINT;
PROCEDURE EOS(s:STREAM):BOOLEAN;
PROCEDURE Reset(s:STREAM);
PROCEDURE SetPos(s:STREAM;pos:LONGINT);
PROCEDURE GetPos(s:STREAM;VAR pos:LONGINT);
END Streams.
!Funky!Stuff!
echo x - Terminal.DEF
cat >Terminal.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Terminal;
(* A.Wespisser, 20-NOV-84
*---------------------------
* J.Wyttenbach, 11-jan-85
* B.Campbell, 10-FEB-86
*
* NOTE: - The procedures "KeyPress" and "GotoXY" and "ClearTerminal" are
* not contained in module "Terminal" on SMAKY8.
* - "BusyRead", "ReadString", "KeyPress" and "GotoXY" and
* "ClearTerminal" are not required by the compiler itself.
*)
EXPORT QUALIFIED Write, WriteString, WriteLn, Read, ReadString, ReadLn,
BusyRead, ReadAgain,KeyPress, GotoXY, ClearTerminal;
PROCEDURE Write (ch: CHAR);
PROCEDURE WriteString(VAR s:ARRAY OF CHAR);
PROCEDURE WriteLn; (*terminate line*)
PROCEDURE Read(VAR ch:CHAR);
PROCEDURE ReadString(VAR s:ARRAY OF CHAR);
PROCEDURE ReadLn (VAR s:ARRAY OF CHAR);
PROCEDURE BusyRead(VAR ch:CHAR);
PROCEDURE ReadAgain;
(* causes the last character read to be returned again
* upon the next call of Read
*)
PROCEDURE KeyPress():BOOLEAN;
PROCEDURE GotoXY(x,y:CARDINAL); (* Move to column x, row y *)
PROCEDURE ClearTerminal;
END Terminal.
!Funky!Stuff!
echo x - TextEdit.DEF
cat >TextEdit.DEF <<'!Funky!Stuff!'
DEFINITION MODULE TextEdit;
FROM SYSTEM IMPORT ADDRESS;
FROM MacSYSTEM IMPORT Handle,LONGINT,OSErr;
FROM QuickDraw IMPORT Style,Rect,Point,GrafPtr;
EXPORT QUALIFIED
teJustLeft,teJustCenter,teJustRight,
CharsHandle,CharsPtr,Chars,TEHandle,TEPtr,
TERec,
DoubleTime,CaretTime,TEScrpHandle,TEScrpLength,
TENew,TEDispose,TESetText,TEGetText,
TEIdle,TEClick,TESetSelect,TEActivate,TEDeactivate,
TEKey,TECut,TECopy,TEPaste,TEDelete,TEInsert,
TESetJust,TEUpdate,TextBox,TEScroll,
TEFromScrap,TEToScrap,TEScrapHandle,TEGetScrapLen,TESetScrapLen,
SetWordBreak,SetClikLoop,TECalText;
CONST
teJustLeft = 0;
teJustCenter = 1;
teJustRight = -1;
TYPE
Chars = ARRAY [0..32000] OF CHAR;
CharsPtr = POINTER TO Chars;
CharsHandle = POINTER TO CharsPtr;
TERec = RECORD
destRect: Rect;
viewRect: Rect;
selRect: Rect; (* used from assembly *)
lineHeight: INTEGER;
fontAscent: INTEGER;
selPoint: Point;
selStart: INTEGER;
selEnd: INTEGER;
active: INTEGER;
wordBreak: ADDRESS; (* ADDRESS of wordBreak Routine*)
clikLoop: ADDRESS; (* ADDRESS of clikLoop Routine *)
clickTime: LONGINT;
clickLoc: INTEGER;
caretTime: LONGINT;
caretState: INTEGER;
just: INTEGER;
teLength: INTEGER;
hText: Handle;
recalBack: INTEGER;
recalLines: INTEGER;
clikStuff: INTEGER;
crOnly: INTEGER;
txFont: INTEGER;
txFace: Style;
txMode: INTEGER;
txSize: INTEGER;
inPort: GrafPtr;
highHook: ADDRESS;
caretHook: ADDRESS;
nLines: INTEGER;
lineStarts: ARRAY [0..16000] OF INTEGER;
END;
TEPtr = POINTER TO TERec;
TEHandle = POINTER TO TEPtr;
VAR
DoubleTime[02F0H]: LONGINT;
CaretTime[02F4H]: LONGINT;
TEScrpHandle[0AB4H]: Handle;
TEScrpLength[0AB0H]: LONGINT;
PROCEDURE TENew(VAR destRect,viewRect:Rect):TEHandle;
(* VAR is for Modula is really by value *)
PROCEDURE TEDispose(hTE:TEHandle);
(* Accessing the Text of an Edit Record *)
PROCEDURE TESetText (text:ADDRESS;length:LONGINT;hTE:TEHandle);
PROCEDURE TEGetText (hTE: TEHandle):CharsHandle;
(*Insertion Point and Selection Range*)
PROCEDURE TEIdle (hTE:TEHandle);
PROCEDURE TEClick (pt:Point;extend:BOOLEAN;hTE:TEHandle);
PROCEDURE TESetSelect (selStart,selEnd: LONGINT; hTE:TEHandle);
PROCEDURE TEActivate (hTE: TEHandle);
PROCEDURE TEDeactivate (hTE:TEHandle);
(* Editing *)
PROCEDURE TEKey (key:CHAR;hTE:TEHandle);
PROCEDURE TECut (hTE:TEHandle);
PROCEDURE TECopy (hTE:TEHandle);
PROCEDURE TEPaste (hTE:TEHandle);
PROCEDURE TEDelete (hTE: TEHandle);
PROCEDURE TEInsert (text:ADDRESS;length:LONGINT;hTE:TEHandle);
(* Text Display and Scrolling *)
PROCEDURE TESetJust (just:INTEGER;hTE:TEHandle);
PROCEDURE TEUpdate (VAR rUpdate: Rect; hTE:TEHandle);
PROCEDURE TextBox (text:ADDRESS;
length:LONGINT;
VAR box:Rect;
just:INTEGER);
PROCEDURE TEScroll (dh,dv:INTEGER;hTE:TEHandle);
(* Scrap Handling *)
PROCEDURE TEFromScrap():OSErr;
PROCEDURE TEToScrap():OSErr;
PROCEDURE TEScrapHandle():Handle;
PROCEDURE TEGetScrapLen():LONGINT;
PROCEDURE TESetScrapLen(length:LONGINT);
(* Advanced Routine *)
PROCEDURE SetWordBreak(wBrkProc:ADDRESS; hTE: TEHandle);
PROCEDURE SetClikLoop(clickProc:ADDRESS; hTE: TEHandle);
PROCEDURE TECalText (hTE:TEHandle);
END TextEdit.
!Funky!Stuff!
echo x - Toolbox.DEF
cat >Toolbox.DEF <<'!Funky!Stuff!'
DEFINITION MODULE Toolbox;
(* Cursor routines and constants moved to Cursors *)
(* GetPic moved to Pictures *)
FROM SYSTEM IMPORT ADDRESS;
FROM MacSYSTEM IMPORT LONGINT,Handle,Fixed,Int64Bit,StringHandle;
FROM QuickDraw IMPORT Pattern,Str255,Point,Rect;
EXPORT QUALIFIED
(*CONST*)
sysPatListID,PatPtr,PatHandle,
(*VAR*)
ScrVRes,ScrHRes,
(*math*)
FixRatio,FixMul,FixRound,
(*strings*)
NewString,SetString,GetString,GetIndString,
(*byte manipulation*)
Munger,PackBits,UnpackBits,
(*bit Manipulation*)
BitTst,BitSet,BitClr,
(*Logical Operations*)
BitAnd,BitOr,BitXor,BitNot,BitShift,
(*Other Operations on Long Integers*)
HiWord,LoWord,LongMul,
(* Graphics Utilities *)
ScreenRes,GetIcon,PlotIcon,GetPattern,GetIndPattern,
(* Miscellaneous Utilities *)
Random,StuffHex,DeltaPoint,SlopeFromAngle,AngleFromSlope;
CONST
sysPatListID = 0;
TYPE
PatPtr = POINTER TO Pattern;
PatHandle = POINTER TO PatPtr;
VAR
ScrHRes[0104H]:INTEGER;
ScrVRes[0102H]:INTEGER;
PROCEDURE FixRatio(numer,denom:INTEGER):Fixed;
PROCEDURE FixMul(a,b:Fixed):Fixed;
PROCEDURE FixRound(x:Fixed):INTEGER;
(*String*)
PROCEDURE NewString(VAR theString:ARRAY OF CHAR):StringHandle;
PROCEDURE SetString(h:StringHandle;VAR theString:ARRAY OF CHAR);
PROCEDURE GetString(StringID:INTEGER):StringHandle;
PROCEDURE GetIndString(VAR theString:ARRAY OF CHAR;strListID:INTEGER;
index:INTEGER); (* no trap macro *)
(*byte manipulation*)
PROCEDURE Munger(h:Handle;offset:LONGINT;ptrl:ADDRESS;len1:LONGINT;
ptr2:ADDRESS;len2:LONGINT):LONGINT;
PROCEDURE PackBits(VAR srcPtr,dstPtr:ADDRESS; srcBytes:INTEGER);
PROCEDURE UnpackBits(VAR srcPtr,dstPtr:ADDRESS; dstBytes:INTEGER);
(*bit Manipulation*)
PROCEDURE BitTst(bytePtr:ADDRESS;bitNum:LONGINT):BOOLEAN;
PROCEDURE BitSet(bytePtr:ADDRESS;bitNum:LONGINT);
PROCEDURE BitClr(bytePtr:ADDRESS;bitNum:LONGINT);
(*Logical Operations*)
PROCEDURE BitAnd(val1,val2:LONGINT):LONGINT;
PROCEDURE BitOr (val1,val2:LONGINT):LONGINT;
PROCEDURE BitXor(val1,val2:LONGINT):LONGINT;
PROCEDURE BitNot(val:LONGINT):LONGINT;
PROCEDURE BitShift(value:LONGINT;count:INTEGER):LONGINT;
(*Other Operations on Long Integers*)
PROCEDURE HiWord(x:LONGINT):INTEGER;
PROCEDURE LoWord(x:LONGINT):INTEGER;
PROCEDURE LongMul(a,b:LONGINT;VAR dest:Int64Bit);
(* Graphics Utilities *)
PROCEDURE ScreenRes(VAR scrnHRes,scrnVRes:INTEGER);
PROCEDURE GetIcon(iconID:INTEGER):Handle;
PROCEDURE PlotIcon(theRect:Rect;theIcon:Handle);
PROCEDURE GetPattern(patID:INTEGER):PatHandle;
PROCEDURE GetIndPattern(VAR thePattern:Pattern;patListID:INTEGER;
index:INTEGER); (* no trap macro *)
(* ShieldCursor Left here because of cyclic input *)
(* Miscellaneous Utilities *)
PROCEDURE Random ():INTEGER;
PROCEDURE StuffHex (thingPtr:ADDRESS;VAR s:ARRAY OF CHAR);
PROCEDURE DeltaPoint(ptA,ptB:Point):LONGINT;
PROCEDURE SlopeFromAngle(angle:INTEGER):Fixed;
PROCEDURE AngleFromSlope(slope:Fixed):INTEGER;
END Toolbox.
!Funky!Stuff!
echo x - WindowManager.DEF
cat >WindowManager.DEF <<'!Funky!Stuff!'
DEFINITION MODULE WindowManager;
FROM SYSTEM IMPORT ADDRESS,WORD;
FROM MacSYSTEM IMPORT LONGINT,Handle,StringHandle;
FROM QuickDraw IMPORT GrafPort,GrafPtr,Point,VHSelect,Rect,RgnHandle;
FROM Pictures IMPORT PicHandle;
FROM EventManager IMPORT EventRecord;
EXPORT QUALIFIED
(*CONST*)
(* Window definition procedure IDs *)
documentProc,dBoxProc,plainDBox,altDBoxProc,noGrowDocProc,
rDocProc,
(* Types of Windows *)
dialogKind,userKind,
(* FindWindow result codes *)
inDesk,inMenuBar,inSysWindow,inContent,inDrag,inGrow,inGoAway,
(* Axis constraints for DragGrayRgn call *)
noConstraint,hAxsOnly,vAxsOnly,
(* Window Messages *)
wDraw,wHit,wCalcRgns,wNew,wDispose,wGrow,wDrawGIcon,
(* ... hit test codes *)
wNoHit,wInContent,wInDrag,wInGrow,wInGoAway,
deskPatID,
(*TYPE*)
WindowPtr,WindowPeek,WindowRecord,
(*PROCS*)
NewWindow,GetNewWindow,CloseWindow,DisposeWindow,
SetWTitle,GetWTitle,SetWRefCon,GetWRefCon,
HideWindow,ShowWindow,ShowHide,
MoveWindow,
SizeWindow,
FrontWindow,BringToFront,SendBehind,
HiliteWindow,
DrawGrowIcon,
BeginUpdate,EndUpdate,
InvalRect,InvalRgn,ValidRect,ValidRgn,
SetWindowPic,GetWindowPic,
FindWindow,
SelectWindow,
DragWindow,GrowWindow,TrackGoAway,
GetWMgrPort;
CONST
(* Types of Windows *)
dialogKind = 2;
userKind = 8;
(* Window definition procedure IDs *)
documentProc = 0;
dBoxProc = 1;
plainDBox = 2;
altDBoxProc = 3;
noGrowDocProc = 4;
rDocProc = 16;
(* FindWindow result codes *)
inDesk = 0;
inMenuBar = 1;
inSysWindow = 2;
inContent = 3;
inDrag = 4;
inGrow = 5;
inGoAway = 6;
(* Axis constraints for DragGrayRgn call *)
noConstraint = 0;
hAxsOnly = 1;
vAxsOnly = 2;
(* Window Messages *)
wDraw = 0;
wHit = 1;
wCalcRgns = 2;
wNew = 3;
wDispose = 4;
wGrow = 5;
wDrawGIcon = 6;
(* ... hit test codes *)
wNoHit = 0;
wInContent = 1;
wInDrag = 2;
wInGrow = 3;
wInGoAway = 4;
(* Resource ID of desktop pattern *)
deskPatID = 16;
TYPE
WindowPtr = GrafPtr;
WindowPeek = POINTER TO WindowRecord;
WindowRecord = RECORD
port: GrafPort; (* Graphics port for this window *)
windowKind: INTEGER; (* Window Class *)
visible: BOOLEAN;
hilited: BOOLEAN;
goAwayFlag: BOOLEAN;
spareFlag: BOOLEAN;
strucRgn: RgnHandle; (* Handle to structure region *)
contRgn: RgnHandle; (* Handle to content region *)
updateRgn: RgnHandle; (* Handle to update region *)
windowDefProc: Handle; (* Handle to Window Definition
* function
*)
dataHandle: Handle; (* Handle to definition function's
* data
*)
titleHandle: StringHandle;(*Handle to window's title *)
titleWidth: INTEGER; (* Private *)
controlList: Handle;
nextWindow: WindowPeek;
windowPic: PicHandle;
refCon: LONGINT
END;
PROCEDURE NewWindow(wStorage:ADDRESS;
VAR windowRect: Rect;
VAR title: ARRAY OF CHAR;
visible: BOOLEAN;
windowType: INTEGER;
behindWindow: WindowPtr;
hasClose: BOOLEAN;
refCon: LONGINT):WindowPtr;
PROCEDURE GetNewWindow(templateID:INTEGER;
wStorage: ADDRESS;
behindWindow: WindowPtr):WindowPtr;
PROCEDURE CloseWindow(theWindow:WindowPtr);
PROCEDURE DisposeWindow(theWindow:WindowPtr);
PROCEDURE SetWTitle(theWindow:WindowPtr;VAR newTitle:ARRAY OF CHAR);
PROCEDURE GetWTitle(theWindow:WindowPtr;VAR theTitle:ARRAY OF CHAR);
PROCEDURE SetWRefCon(theWindow:WindowPtr;newRefCon:LONGINT);
PROCEDURE GetWRefCon(theWindow:WindowPtr):LONGINT;
PROCEDURE HideWindow(theWindow:WindowPtr);
PROCEDURE ShowWindow(theWindow:WindowPtr);
PROCEDURE ShowHide(theWindow:WindowPtr;showFlag:BOOLEAN);
PROCEDURE MoveWindow(theWindow: WindowPtr;
hGlobal,vGlobal: INTEGER;
active: BOOLEAN);
PROCEDURE SizeWindow
(theWindow: WindowPtr;
newWidth,newHeight: INTEGER;
update: BOOLEAN);
PROCEDURE FrontWindow():WindowPtr;
PROCEDURE BringToFront(theWindow:WindowPtr);
PROCEDURE SendBehind(theWindow:WindowPtr;behindWindow:WindowPtr);
PROCEDURE HiliteWindow(theWindow:WindowPtr;onOrOff:BOOLEAN);
PROCEDURE DrawGrowIcon(theWindow:WindowPtr);
PROCEDURE BeginUpdate(theWindow:WindowPtr);
PROCEDURE EndUpdate(theWindow:WindowPtr);
PROCEDURE InvalRect(VAR badRect:Rect);
PROCEDURE InvalRgn(badRegion:RgnHandle);
PROCEDURE ValidRect(VAR goodRect:Rect);
PROCEDURE ValidRgn(goodRegion:RgnHandle);
PROCEDURE SetWindowPic (theWindow:WindowPtr;thePicture:PicHandle);
PROCEDURE GetWindowPic(theWindow:WindowPtr):PicHandle;
PROCEDURE FindWindow(MousePoint:Point;VAR theWindow:WindowPtr):INTEGER;
PROCEDURE SelectWindow(theWindow:WindowPtr);
PROCEDURE DragWindow
(theWindow:WindowPtr;
startPoint:Point;
LimitRect:Rect);
PROCEDURE GrowWindow
(theWindow: WindowPtr;
startPoint: Point;
sizeRect: Rect):LONGINT;
PROCEDURE TrackGoAway(wind:WindowPtr;start:Point):BOOLEAN;
PROCEDURE GetWMgrPort(VAR wMgrPort:GrafPtr);
END WindowManager.
!Funky!Stuff!