Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Path: utzoo!linus!philabs!cmcl2!harvard!seismo!rochester!bullwinkle!uw-beaver!tikal!bobc
From: bobc@tikal.UUCP (Bob Campbell)
Newsgroups: net.sources.mac
Subject: ETHZ Standalone Definition Modules (1 of 4)
Message-ID: <419@tikal.UUCP>
Date: Wed, 7-May-86 19:01:00 EDT
Article-I.D.: tikal.419
Posted: Wed May  7 19:01:00 1986
Date-Received: Sun, 11-May-86 02:05:54 EDT
Reply-To: bobc@tikal.UUCP (Bob Campbell)
Organization: Teltone Corp., Kirkland, WA
Lines: 625

# 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!