Related Info: ADB Manager

ADB Demo in ZBasic 5.0 & LS Pascal 2.0

By Dave Kelly, David E. Smith, MacTutor Editorial Board

Exploring the ADB

The Apple Desktop Bus (ADB) is a simple local-area network that connects low-speed input-only devices (for example: keyboard or mouse) to the operating system and Macintosh hardware. ADB is supported only on the Macintosh SE and Macintosh II (and future Macintosh computers). It should first be understood that the standard mouse and keyboard drivers automatically handle the ADB functions.

Communication with the ADB is accomplished with six routines located in the 256K ROM. These routines are used only if you need to access bus devices directly or communicate with a special device. This being the case, you will probably never use them. The typical access to ADB devices is through the Toolbox Event Manager routines (ex: GetNextEvent or WaitNextEvent). In BASIC, the DIALOG statement handles this process. We have discussed the DIALOG statement in detail in previous volumes of MacTutor (see Jan, 1987;Aug, 1987; Sep, 1987).

Macintosh Technical Note #206 is inspiration for this column. #206 explains how ADB works on the SE and II. The question was asked, “How can I turn on/off the LEDs on the Apple Extended Keyboard?”. The answer: “Using the LEDs on the extended keyboard involves the ADBOp call (Inside Macintosh Volume 5 ). Once you determine that you have the extended keyboard, (with CountADBs, GetIndADB), then register 2 of the extended keyboard has the LED toggles in the low 3 bits. Therefore, you would do a talk to register 2 to have the device send you the contents of register 2, manipulate the low three bits to set the LEDs, and then pass the now modified register 2 back to the device with a listen to register 2 command.”

The first task is determining that the extended keyboard is being used. The SysEnvirons Function is another good way to determine if the extended keyboard exists although CountADBs and GetIndADB will have to be used to get the actual keyboard address. The extended keyboard will have an ID of 2 and a device handler of 2. The standard apple keyboard will have an ID of 2 and a device handler ID of 1. Several examples of SysEnvirons have been given in previous articles. The use of the SysEnvirons function in ZBasic is shown in the Basic example in this column.

LS Pascal 2.0 Version

In addition to the ZBasic example, the same program was coded in LS Pascal 2.0 and extensively modified by David Smith, Editor and Publisher of MacTutor. This Pascal example shows how the same information displayed in the ZBasic program can be displayed using Text Edit in a fully operational text edit window. Multifinder is supported with suspend/resume events, text selection, cutting and pasting is supported, the scrap is updated properly for Multifinder, and the use of two new resources, vers and mstr are used. The vers resources allow the version to be displayed in two places in the GetInfo box. The mstr resources allows MultiFinder to find the Quit command so the program can exit gracefully after a shutdown command. Both programs parse and display the SysEnvirons information about the Mac and then blink the keyboard lights if an extended keyboard is present.

Fig. 1 Our ADB Demo in ZBasic: SysEnvirons Dump

Fig. 2 Same program in LS Pascal: MultiFinder Friendly Text Edit Window!

ZBASIC 5.0 Version

To use SysEnvirons in ZBASIC 5.0 you will first need to modify the function using the Toolbox editor program. The SysEnvirons function is register based and so the function is modified to reflect this. When I tried the SysEnvirons function included in ZBASIC 5.0, the function did not return the correct results. Change the function to: D0.W=FN SYSENVIRONS (D0.L, A0.L). This sets the result to register D0 with inputs passed to the function in the D0 and A0 registers as shown in Inside Macintosh Vol. V, pg. 6. An explanation of the SysEnvirons record is given on pg. 6-8. The source code disk for this month includes the ADB ZBasic 5.0 library which the Toolbox editor program can move into ZBasic to create a new version of ZBasic with the correct calling sequence for Sysenvirons. The ability to extend the language to new traps or correct old ones is a very clever ability in ZBasic 5.0. It means you don’t have to get a new version of the program when the toolbox calling routines or traps change.

Accessing an ADB Device

There are 16 possible device locations available on the ADB. Each device can maintain up to four variable-size registers which may be read or written from the device over the ADB network. All devices use register 0 and register 3. Register 0 is used to store input data for device interrupts. Register 3 is used for device identification and operating flags. The chapter on the ADB Manager in Inside Macintosh Vol. V explains these two registers in more detail for writing device drivers. The other two registers may or may not be used depending upon which device is being used. The Extended Keyboard uses register 2 as indicated by the comments in TN#206.

Devices which connect to the ADB contain their own micro-processors, which handle both device routines and the ADB interface. Sending commands to the device is accomplished with the ADBOp function. There are four possible commands which may be sent to the device. The ADB Command Formats are shown on pg. 363 of Inside Macintosh. A description of the commands is given on page 364. We use the Talk command to tell the device that we want to see register 2 by sending a command of $2E (binary ‘0010 1110’). The buffer pointed to by the ADBOpBlock parameter block will contain the contents of register 2 after the ADBOp function is called. As seen in the LightsBug window the contents of the buffer after the Talk command is sent is 02FFFF. Since the technical note states that the LEDs are toggled on/off in the lower three bits, changing the contents of the buffer to 02FFF8 and sending the Listen command should turn on all three lights. The first byte of the buffer ($02) is the number of bytes in the buffer. (See figures 3 & 4)

Fig. 3 Register 2 = 02FFFF after talk command

Fig. 4 Register 2 = 02FFF8 before listen command

The Listen command is used to write the register back to the device. When the Listen command is sent after modifying the lower 3 bytes of register 2 (as stored in the buffer area), the LEDs do in fact turn on. The reverse process may be used to turn off the LEDs or sending the Flush command also clears the LED status.

The ADBOpBlock record (referred to by the ADBOp function) contains a pointer to the buffer where the registers are stored (as discussed above) and a pointer to a completion routine and data pointer. The completion routine is called by ADBOp upon completion of the function. There are three ways that a completion routine may be used. 1) You may pass a nil pointer to ADBOp when you do not wish to have a completion routine. 2) You may use the service routine address which is fetched by the GetIndADB function or GetADBInfo function. Before calling ADBOp, set the completion pointer to the service address. 3) Use your own completion routine. The data pointer is an area which the completion routine may use (optionally) to store its own data.

There is rarely a reason to call ADBOp except to tell the device something or turn on LEDs as in this example. In most cases, the ADB device communication will be handled by the system’s internal polling/service request mechanism.

The two program examples included here, one in ZBasic 5.0, the other in LS Pascal 2.0, illustrate this process. The flow of the program is much easier to follow in Pascal because of the organization of the record structures. The result is the same. In order to get ZBasic to recognize the ADB Manager routines, they must be added using the Toolbox Editor. The definitions of the functions and procedures which must be added are shown below (these are included in a library file on this month’s source code disk):

In the Pascal version, a complete Macintosh text edit application is given. A menu function, ADB, in the File menu, causes the doADB procedure to be called from the procedure which handles a mouse down event. When the doADB proc executes, it parses the SysEnvirons call and inserts the same information as the Basic program into the text edit record for the program’s window. That information is then displayed as the result of an update event. This is how you would duplicate the functionality of Basic’s print statements using a text edit record in a Pascal program that entirely uses the Macintosh toolbox for output into a window. Pay particular attention to the resource file at the end of the program. There in RMaker format, is the two new resources for inserting a version in the GetInfo dialog box, and for helping MultiFinder quit your application. Note also that the SIZE resource has the necessary information to tell MultiFinder that our application understands a suspend/resume event. This event, number 15, is treated much like an activate/deactivate event. By allowing for event 15, we save MultiFinder from sending us a lot of activate/deactivate events we don’t need, thereby making the quasi-multi-tasking scheme work better. These two new resources are described in a recent tech note #189.

Fig. 5 ZBasic SysEnvirons and ADB Functions

The other significant feature of the Pascal program is that it correctly allows the window to be re-sized. This requires a proper Update Event procedure and a Grow procedure. The key is that the rectangles for the text edit viewing rectangle, the scroll bars and the grow box all must be defined properly. Controls are active and updated properly, but no value was assigned the control, so it doesn’t indicate scrolling even if the window is made small enough to cover some of the text. A scrolling unit is needed to match the control to the number of lines of text and the insertion point. For an example of how to do this, see the Text Edit example by David Smith from last year’s MacTutor volume 3. That program had a working multiple window example of text edit with scrollers.

Fig. 6 Our Pascal Demo supports Text Editing

For more information refer to the ADB Manager chapter of Inside Macintosh and technical notes on ADB.

‘ SysEnvirons and ADB Demo
‘ ©1989 MacTutor
‘ by Dave Kelly
‘ ZBasic 5.0
‘
‘******************************************************
‘  First check the System Environments
‘  To do this the SYSENVIRONS function needs to be 
‘modified to work. Replace old SYSENVIRONS with D0.W=FN 
‘SYSENVIRONS(D0.L, A0.L)
‘*******************************************************
WINDOW OFF
COORDINATE WINDOW
‘Find out screen size.
CALL GETWMGRPORT(WMgrPort&)
PortTop=PEEK WORD(WMgrPort&+8)
PortLeft=PEEK WORD(WMgrPort&+10)
PortBottom=PEEK WORD(WMgrPort&+12)
PortRight=PEEK WORD(WMgrPort&+14)

WINDOW 1,”Main Window”,(10,44)-(PortRight-4,PortBottom-4),1
‘Bring window to the front (necessary under Multifinder)
Wptr&=WINDOW(14)
CALL SELECTWINDOW(Wptr&)
‘ Set up SysEnvRec
DIM environsVersion,machineType, systemversion,processor,hasFPU,keyBoardType,atDrvrVersNum,sysVRefNum
OSErr%=FN SYSENVIRONS(1,VARPTR(environsVersion))
LONG IF OSErr%=0
 PRINT “Environment Version:”;environsVersion
 PRINT “Machine Type:”;
SELECT machineType
CASE 0
 PRINT “new version of Macintosh”
CASE 1
 PRINT “Macintosh 512K enhanced”
CASE 2
 PRINT “Macintosh Plus”
CASE 3
 PRINT “Macintosh SE”
CASE 4
 PRINT “Macintosh II”
CASE -1
 PRINT “Macintosh with 64K ROM”
CASE -2
 PRINT “Macintosh XL”
END SELECT
 PRINT “System Version:”;LEFT$(HEX$(systemversion),2);”.”;RIGHT$(HEX$(systemversion),2)
 PRINT “Processor:”;
SELECT processor
CASE 0
 PRINT “new processor”
CASE 1
 PRINT “MC68000 processor”
CASE 2
 PRINT “MC68010 processor”
CASE 3
 PRINT “MC68020 processor”
END SELECT
 b$=”&X”+RIGHT$(BIN$(hasFPU),8)
 hasColorQD=VAL(b$)
 b$=”&X”+LEFT$(BIN$(hasFPU),8)
 hasFPU=VAL(b$)
 PRINT “Has Floating Point Coprocessor:”;
IF hasFPU=1 THEN PRINT “Yes” ELSE PRINT “No”
 PRINT “Has Color QuickDraw:”;
IF hasColorQD=1 THEN PRINT “Yes” ELSE PRINT “No”
 PRINT “Keyboard Type:”;
SELECT keyBoardType
 CASE 0
 PRINT “Macintosh Plus keyboard with keypad”
 CASE 1
 PRINT “Macintosh keyboard”
 CASE 2
 PRINT “Macintosh keyboard and keypad”
 CASE 3
 PRINT “Macintosh Plus keyboard”
 CASE 4
 PRINT “Apple extended keyboard”
 CASE 5
 PRINT “standard Apple Desktop Bus keyboard”
 CASE ELSE
 PRINT “don’t recognize this one!”
END SELECT
 PRINT “AppleTalk Driver version:”;atDrvrVersNum
 PRINT “Working Directory Volume Reference #:”;sysVRefNum
XELSE
 PRINT “Error =”;OSErr%
END IF
‘*******************************************************
‘ Now Read the ADB
‘ This routine turns on and off the
‘ lights of the Extended keyboard
‘ ADB calls and functions need to be added to ZBasic 5.0
‘ using the Toolbox mover program.
‘*******************************************************
‘
IF keyBoardType<>4 THEN END
DIM DeviceType%,ServiceAddress&,DataAddress&:’ GETINDADB Parmeter block
DIM buffer%(2)
bufferptr&=VARPTR(buffer%(0))
compRoutptr&=0
Datablkptr&=0' ADBOP Parameter block
 
numberofADBdevices=FN COUNTADBS
PRINT “There are”;numberofADBdevices;”ADB devices present.”
IF numberofADBdevices=0 THEN STOP
FOR i%=1 TO numberofADBdevices
 ADBAdd%=FN GETINDADB(VARPTR(DeviceType%),i%)
 b$=”&X”+RIGHT$(BIN$(DeviceType%),8)
 OrgADBAddress%=VAL(b$)
 b$=”&X”+LEFT$(BIN$(DeviceType%),8)
 DeviceType%=VAL(b$)
 LONG IF ADBAdd%=2  ‘Got the address for the Extended Keyboard
 Talk%=&H2E:’ Talk command
 Listen%=&H2A:’ Listen command
 Flush%=&H21:’ Flush command
  PRINT “Press any key to continue...”
  DO
  X$=INKEY$
  GOSUB “MagicLights”
  UNTIL X$<>””
 END IF
 NEXT i%
 LONG IF X$=””
  PRINT “Press any key to continue...”
  DO
    X$=INKEY$
  UNTIL X$<>””
 END IF
END

“MagicLights”
 GOSUB “Togglelightson”
 GOSUB “Delay”
  GOSUB “Togglelightsoff”
 GOSUB “Delay”
 GOSUB “Togglelightson”
 GOSUB “Delay”
  GOSUB “Togglelightsoff”
  GOSUB “Delay”
RETURN

“Togglelightson”
compRoutptr&=ServiceAddress&:Datablkptr&=DataAddress&
‘This call reads register 2 of the ext. keyboard.
OSErr%=FN ADBOP(VARPTR(bufferptr&),Talk%)
GOSUB “Delay”
buffer%(1)=&HF800
‘The next call writes register 2 back to
‘the extended keyboard.  For some reason the register is not
‘being written back to the keyboard.  See Pascal version.
OSErr%=FN ADBOP(VARPTR(bufferptr&),Listen%)
RETURN

“Togglelightsoff”
 OSErr%=FN ADBOP(VARPTR(bufferptr&),Flush%)
RETURN

“Delay”
T1&=FN TICKCOUNT
DO
T&=FN TICKCOUNT
UNTIL T&-T1&=20
RETURN

Fig. 7 Our Pascal About Box. Note Memory Function and ID String displayed from resources!

{ ADBDemo }
{ ©1989 MacTutor}
{ By Dave Kelly, modified by David Smith}
{ This program will blink the LEDs of the Extended Keyboard on and off 
twice. This has no real value other than to show how to communication 
with ADB devices. NOTE: It is not clear what Apple has in mind for these 
LEDs, so you are using them at your own risk. Refer to Technical Note 
#206 for more information. Other tidbits include Multifinder friendly, 
about dialog, vers resources, working sizable window. }

program ADBDemo;

 uses
 OSIntf, PrintTraps, MyADBGlobals, MyADBStuff;

 procedure crash;
 begin
 ExitToShell;
 end;

 procedure InitMac;
 begin
 InitGraf(@thePort);
 InitFonts;
 InitWindows;
 InitMenus;
 TEInit;
 InitDialogs(@crash);
 InitCursor;
 FlushEvents(everyEvent, 0);
 Finished := false;
 end;

 procedure initRects;
 var
 MemoryPtr: ^Integer;
 begin
 MemoryPtr := pointer(mBarHeightGlobal); 
 mBarHeight := MemoryPtr^;
 screen := ScreenBits.Bounds; {current screen device}
 SetRect(DragArea, Screen.left + 4, Screen.top + mBarHeight + 4, Screen.right 
- 4, Screen.bottom - 4);
 SetRect(GrowArea, Screen.left + MinWidth, Screen.top + MinHeight, Screen.right 
- 8, Screen.bottom - 8);
 SetRect(ADBWindowRect, Screen.left + 15, Screen.top + 45, Screen.right 
- 95, Screen.bottom - 95);
 SetRect(ZoomRect, Screen.left + 4, Screen.top + mBarHeight + 4, Screen.right 
- 4, Screen.bottom - 4);
 end;

 procedure InitMyWindow;
 var
 windtype: integer;
 Visible: boolean;
 GoAway: boolean;
 RefVal: LongInt;
 title: str255;
 begin
 Visible := true;
 windtype := documentProc + ZoomBox;
 GoAway := true;
 RefVal := 0;
 title := ‘ADB Demo’;
 ADBWindow := NewWindow(nil, ADBWindowRect, title, Visible, windtype, 
pointer(-1), GoAway, RefVal);
 ADBWindowPeek := WindowPeek(ADBWindow);
 SetPort(ADBWindow);
 TextFont(Geneva);
 TextSize(10);
 TextFace([]); {plain}
 TextMode(1);  {Or}
 PenNormal;
 ForeColor(blackColor);
 BackColor(whiteColor);
 ADBWindowPeek^.windowKind := userKind;
 with ADBWindow^.portRect do
 begin
 SetRect(VCRect, right - (SBarWidth - 1), top - 1, right + 1, bottom 
- (SBarWidth - 2));
 SetRect(HCRect, left - 1, bottom - (SBarWidth - 1), right - (SBarWidth 
- 2), bottom + 1);
 SetRect(GrowRect, HCRect.right, HCRect.top, VCRect.right, HCRect.bottom);
 SetRect(ViewRect, left + 4, top + 4, right - (SBarWidth - 1), bottom 
- (SBarWidth - 1));
 end;  {of with }
 DestRect := ViewRect;
 myTextHandle := TENew(DestRect, ViewRect);
 title := ‘’;
 VControl := NewControl(ADBWindow, VCRect, title, Visible, 0, 0, 0, ScrollBarProc, 
1);
 ValidRect(VCRect);
 HControl := NewControl(ADBWindow, HCRect, title, Visible, 0, 0, 0, ScrollBarProc, 
1);
 ValidRect(HCRect);
 end;

 procedure InitMyPrint;
 begin
 myPrint := THPrint(NewHandle(SIZEOF(TPrint)));
 end;

 procedure InitMyMenus;
 var
 i: integer;
 begin
 myMenus[AppleM] := GetMenu(AppleMenu);
 AddResMenu(myMenus[AppleM], ‘DRVR’);
 myMenus[FileM] := GetMenu(FileMenu);
 myMenus[EditM] := GetMenu(EditMenu);
 for i := 1 to MenuCount do
 InsertMenu(myMenus[i], 0);

 DisableItem(myMenus[FileM], fSave);
 DisableItem(myMenus[FileM], fSaveAs);
 DisableItem(myMenus[FileM], fPageSet);
 DisableItem(myMenus[FileM], fPrint);
 DisableItem(myMenus[EditM], eUndo);
 DrawMenuBar;
 end; {of proc}

 procedure doMouse (myEvent: EventRecord);
 var
 whereIsIt: integer;
 whichWindow: WindowPtr;
 localPt, globalPt: Point;
 oldPort: GrafPtr;
 begin
 globalPt := myEvent.where;
 localPt := globalPt;{global coord of mouse}
 GlobalToLocal(localPt);  {local coord of mouse}
 whereIsIt := FindWindow(globalPt, whichWindow);
 case whereIsIt of
 inDesk:  {0}
 doMessage(‘Mouse Click on Desktop.’, ‘(Not handled in this program.)’, 
‘’, ‘’);
 inMenuBar:  {1}
 doMenuBar(MenuSelect(globalPt));
 inSysWindow:  {2}
 SystemClick(myEvent, whichWindow);
 inContent:      {3}
 doContent(myEvent, whichWindow);
 inDrag:  {4}
 doDrag(whichWindow, globalPt);
 inGrow:  {5}
 doGrow(whichWindow, globalPt, False);
 inGoAway:  {6}
 if TrackGoAway(whichWindow, globalPt) then
 HideWindow(whichWindow);
 inZoomIn, InZoomOut:{7, 8}
 begin
 if TrackBox(whichWindow, globalPt, whereIsIt) then
 begin
 GetPort(OldPort);
 SetPort(whichWindow); {safety device}
 EraseRect(whichWindow^.portRect);
 ZoomWindow(whichWindow, whereIsIt, True);
 doGrow(whichWindow, globalPt, True);
 SetPort(OldPort);
 end;
 end;
 otherwise
 begin
 end;
 end; {of whereIsIt}
 end;

 procedure doKeyDowns (myEvent: EventRecord);
 var
 ch: char;
 charCode: longInt;
 keyCode: longInt;
 begin
 charCode := BitAnd(myEvent.Message, charCodeMask);  {strip off key code}
 keyCode := BitShift(BitAnd(myEvent.Message, keyCodeMask), -8); {strip 
off char}
 ch := Chr(charCode);  {get keyboard char}
 if BitAnd(myEvent.Modifiers, CmdKey) = CmdKey then
 doMenuBar(MenuKey(ch))  { do menu command key}
 else
 begin  { do keystroke }
 ParamText(‘No typing supported ’, ‘’, ‘’, ‘’);
 itemhit := CautionAlert(AlertDialog, nil);
 end;  { of do key stroke }
 end;  { of proc}

 procedure doUpdates (myEvent: EventRecord);
 var
 UpdateWindow: WindowPtr;
 TempPort: GrafPtr;
 myRect: rect;
 begin
 UpdateWindow := WindowPtr(myEvent.message);
 if UpdateWindow = ADBWindow then
 begin
 GetPort(TempPort); {save port}
 SetPort(UpdateWindow);
 BeginUpDate(UpdateWindow);
 EraseRect(UpdateWindow^.portRect);
 DrawGrowIcon(UpdateWindow);
 DrawControls(UpdateWindow);
 TEUpdate(UpdateWindow^.portRect, myTextHandle);
 EndUpDate(UpdateWindow);
 SetPort(TempPort);{restore port}
 end;
 end; {of proc}

 procedure doActivates (myEvent: EventRecord);
 var
 TargetWindow: WindowPtr;
 TargetPeek: WindowPeek;
 begin
 TargetWindow := WindowPtr(myEvent.message);
 TargetPeek := windowPeek(TargetWindow);
 SetPort(TargetWindow);
 if Odd(myEvent.modifiers) then
 begin {activate}
 if TargetWindow = ADBWindow then
 begin
 DisableItem(myMenus[EditM], eUndo);
 DrawGrowIcon(TargetWindow);
 TEActivate(myTextHandle);
 ShowControl(VControl);
 ShowControl(HControl);
 end
 end  { of activate loop}
 else
 begin {deactivate}
 if TargetWindow = ADBWindow then
 begin
 EnableItem(myMenus[EditM], eUndo);
 EnableItem(myMenus[EditM], eCut);
 EnableItem(myMenus[EditM], eCopy);
 EnableItem(myMenus[EditM], ePaste);
 EnableItem(myMenus[EditM], eClear);
 DrawGrowIcon(TargetWindow);
 TEDeactivate(myTextHandle);
 HideControl(VControl);
 HideControl(HControl);
 end; { of my window activation}
 end; {of deactivate loop}
 end; {of proc}

 procedure doMulti (myEvent: EventRecord);
 const
 MouseMovedEvt = $FA;
 var
 HiByte: byte;
 bit0: LongInt;
 sysresult: boolean;
 ResumeWindow: WindowPtr;
 ResumePeek: WindowPeek;
 SuspendWindow: WindowPtr;
 SuspendPeek: WindowPeek;
 MouseMove: LongAndByte;
 begin
 bit0 := 31; {convert 68000 to toolbox}
 {check for mouse moved event}
 MouseMove.longView := myEvent.message;
 HiByte := Byte(MouseMove.byteView.byte0);
 if HiByte = MouseMovedEvt then
 begin {Handle mouse moved event}
 end;
 {check for resume event }
 if Odd(myEvent.message) then
 begin  {resume}
 { treat like activate Event if we are in front}
 ResumeWindow := FrontWindow;
 if ResumeWindow = ADBWindow then
 begin {adbWindow}
 SetPort(ResumeWindow);
 InvalRect(ResumeWindow^.portRect); 
 { force update event}
 DisableItem(myMenus[EditM], eUndo);
 ShowControl(VControl);
 ShowControl(HControl);
 DrawGrowIcon(ResumeWindow);
 end; {adbWindow}
 if FrontWindow <> nil then
 begin {DA check}
 ResumePeek := WindowPeek(FrontWindow);
 if ResumePeek^.windowKind < 0 then {DA}
 begin {da}
 myEvent.what := activateEvt;
 BitSet(@myEvent.modifiers, bit0);
 sysresult := SystemEvent(myEvent);
 end; {da}
 end; {DA check}
 { end of activate Event}
 end {of resume}
 else
 begin  {suspend}
 {de-activate Event}
 SuspendWindow := FrontWindow;
 if SuspendWindow = ADBWindow then
 begin {adbwindow}
 SetPort(SuspendWindow);
 InvalRect(SuspendWindow^.portRect);
 {force update}
 EnableItem(myMenus[EditM], eUndo);
 EnableItem(myMenus[EditM], eCut);
 EnableItem(myMenus[EditM], eCopy);
 EnableItem(myMenus[EditM], ePaste);
 EnableItem(myMenus[EditM], eClear);
 DrawGrowIcon(SuspendWindow);
 HideControl(VControl);
 HideControl(HControl);
 end; {adbwindow}
 if FrontWindow <> nil then
 begin {DA check}
 SuspendPeek := WindowPeek(FrontWindow);
 if SuspendPeek^.windowKind < 0 then
 begin {da}
 myEvent.what := activateEvt;
 BitClr(@myEvent.modifiers, bit0);
 sysresult := SystemEvent(myEvent);
 end; {da}
 end; {DA check}
 { end of de-activate Event}
 end; {suspend}
 end; {of proc}

 procedure MainEventLoop;
 const
 MultiFinderEvt = 15;
 var
 sleep: LongInt;
 Event: EventRecord;
 DoIt: Boolean;
 begin
 sleep := 10;
 repeat
 TEIdle(MyTextHandle);
 DoIt := WaitNextEvent(EveryEvent, Event, sleep, nil); {no mouse tracking}
 if DoIt then
 case Event.what of
 mouseDown: 
 doMouse(Event);
 KeyDown, Autokey: 
 doKeyDowns(Event);
 updateEvt: 
 doUpdates(Event);
 activateEvt: 
 doActivates(Event);
 MultiFinderEvt: 
 doMulti(Event);
 otherwise
 begin
 end;
 end; {of event case}
 until Finished; {end program}
 end;

begin  { main }
 InitMac;
 InitRects;
 InitMyWindow;
 InitMyPrint;
 InitMyMenus;
 MainEventLoop;
end.  { end of main }

unit MyADBStuff;

interface

 uses
 OSIntf, PrintTraps, MyADBGlobals;

 procedure doMessage (message0: str255; message1: str255; message2: str255; 
message3: str255);
 procedure doAbout;
 procedure doQuit;
 procedure doMenubar (menuResult: LongInt);
 procedure doContent (ConEvent: EventRecord; contentWindow: windowPtr);
 procedure doDrag (GrabWindow: WindowPtr; GlobalMouse: point);
 procedure doGrow (ResizeWindow: WindowPtr; Globalmouse: point; Zoomflg: 
Boolean);

implementation

 procedure doMessage; {(message0 : str255}
 {message1 : str255}
 {message2 : str255}
 {message3 : str255)}
 var
 dialogP: DialogPtr;
 item: integer;
 begin
 ParamText(message0, message1, message2, message3);
 dialogP := GetNewDialog(MessageDialog, nil, pointer(-1));
 if dialogP = nil then
 begin
 SysBeep(5);
 ExitToShell;
 end;
 initCursor; {change to arrow}
 ModalDialog(nil, item);
 DisposDialog(dialogP);
 end;

 procedure delay;
 const
 stalltime = 15; {quarter seconds in ticks}
 var
 i: LongInt;
 tick1, tick2: LongInt;
 begin
 tick1 := TickCount;
 tick2 := tick1;
 repeat
 tick2 := TickCount;
 until tick2 >= tick1 + stalltime;
 end;

 procedure togglelightsoff;
 const
 flushcommandNum = $21;  { 00100001 }
 begin
 Buf.opServiceRtPtr := Info.dbServiceRtPtr;  
 {service routine pointer}
 Buf.opDataAreaPtr := Info.dbDataAreaAddr;   
 {optional data area address}
 OSEr := ADBOp(nil, nil, Buf.dataBuffPtr, flushcommandNum);  { Flush 
command, clears the device }
 if OSEr = -1 then
 doMessage(‘Unable to flush device’, ‘’, ‘’, ‘’);
 end;

 procedure togglelightson;
 var
 LEDaddress: ptr;
 LEDbyte: signedbyte;
 const
 talkcommandNum = $2E;  { 00101010 }
 listencommandNum = $2A; { 00101110 }
 begin
 if OSEr = noErr then
 begin
 Buf.opServiceRtPtr := Info.dbServiceRtPtr;
 {service routine pointer}
 Buf.opDataAreaPtr := Info.dbDataAreaAddr;
   {optional data area address}
 togglelightsoff;
 OSEr := ADBOp(Buf.opDataAreaPtr, Buf.opServiceRtPtr, Buf.dataBuffPtr, 
talkcommandNum);
 if OSEr = -1 then
 begin
 doMessage(‘Unable to talk to device’, ‘’, ‘’, ‘’);
 exit(togglelightson);
 end;
 delay;
 LEDaddress := POINTER(ORD(Buf.dataBuffPtr) + 2);
 LEDbyte := LEDaddress^;
 if LEDbyte = -1 then
 LEDaddress^ := -8; {turn on}
 OSEr := ADBOp(Buf.opDataAreaPtr, Buf.opServiceRtPtr, Buf.dataBuffPtr, 
listencommandNum);
 if OSEr = -1 then
 begin
 doMessage(‘Unable to listen to device’, ‘’, ‘’, ‘’);
 exit(togglelightson);
 end;
 end; {of noErr}
 end;

 procedure LightsMagic;
 begin
 togglelightson;
 delay;
 togglelightsoff;
 delay;
 togglelightson;
 delay;
 togglelightsoff;
 delay;
 togglelightson;
 delay;
 togglelightsoff;
 delay;
 togglelightson;
 delay;
 togglelightsoff;
 delay;
 end;

 procedure QuerySystem;
 var
 str1, str2: str255;
 begin
 NumToString(LongInt(theWorld.environsVersion), str2);
 str1 := concat(‘Environment Version = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 case theWorld.machineType of
 0: 
 str2 := ‘new version of Macintosh’;
 1: 
 str2 := ‘Macintosh 512K enhanced’;
 2: 
 str2 := ‘Macintosh Plus’;
 3: 
 str2 := ‘Macintosh SE’;
 4: 
 str2 := ‘Macintosh II’;
 otherwise
 begin
 if theWorld.machineType = -1 then
 str2 := ‘Macintosh with 64K ROM’;
 if theWorld.machineType = -2 then
 str2 := ‘Macintosh XL’;
 end;
 end; {of case}
 str1 := concat(‘Machine Type = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 NumToString(LongInt(theWorld.systemVersion), str2);
 str1 := concat(‘System Version (must convert to hex) = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 case theWorld.processor of
 0: 
 str2 := ‘new processor’;
 1: 
 str2 := ‘MC68000 processor’;
 2: 
 str2 := ‘MC68010 processor’;
 3: 
 str2 := ‘MC68020 processor’;
 4: 
 str2 := ‘MC68030 processor’;
 otherwise
 begin
 str2 := ‘unknown processor’;
 end;
 end; {of case}
 str1 := concat(‘Processor = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 NumToString(LongInt(theWorld.hasFPU), str2);
 str1 := concat(‘Has Floating Point Coprocessor (1=Y) = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 NumToString(LongInt(theWorld.hasColorQD), str2);
 str1 := concat(‘Has Color QuickDraw (1=Y) = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 case theWorld.KeyBoardType of
 0: 
 str2 := ‘Macintosh Plus keyboard with keypad’;
 1: 
 str2 := ‘Macintosh keyboard’;
 2: 
 str2 := ‘Macintosh keyboard and keypad’;
 3: 
 str2 := ‘Macintosh Plus keyboard’;
 4: 
 str2 := ‘Apple extended keyboard’;
 5: 
 str2 := ‘Standard Apple Desktop Bus keyboard’;
 otherwise
 begin
 str2 := ‘Unknown keyboard value’;
 end;
 end; {of case}
 str1 := concat(‘Keyboard Type = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 NumToString(LongInt(theWorld.atDrvrVersNum), str2);
 str1 := concat(‘Appletalk Driver Version = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 NumToString(LongInt(theWorld.sysVRefNum), str2);
 str1 := concat(‘Working Directory Volume Ref = ‘, str2, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);
 end;

 procedure doADB;
 var
 devTableIndex: integer;
 str1: str255;
 begin
 TESetSelect(0, TEMax, MyTextHandle);
 TEDelete(MyTextHandle);
 ShowWindow(ADBWindow);

 OSEr := SysEnvirons(versRequested, theWorld);
 if OSEr = envNotPresent then
 doMessage(‘System File older than 4.1!’, ‘’, ‘’, ‘’);
 if OSEr = envBadVers then
 doMessage(‘Bad Version Requested’, ‘’, ‘’, ‘’);
 if OSEr = envVersTooBig then
 doMessage(‘Requested Version Not Available’, ‘’, ‘’, ‘’);
 if OSEr = noErr then
 begin {Query and Blinking routine}

 QuerySystem;

 {toggle keyboard lights on and off}
 if theWorld.keyBoardType = 4 then
 begin {keyboard type 4}
 str1 := concat(chr(13), ‘Watch the keyboard lights blink   ‘, chr(13));
 TEInsert(pointer(ord4(@str1) + 1), Length(str1), MyTextHandle);

 numberofADBs := CountADBs;
 for devTableIndex := 1 to numberofADBs do
 begin {devTableIndex}
 ADBAddr := GetIndADB(info, devTableIndex); 
 { find the device address }
 if ADBAddr = 2 then
 begin {ADBAddr}
 device := info.devType;
 LightsMagic;
 end; {of ADBAddr}
 end; {devTableIndex}
 end; {keybaord type 4}
 end; { of noErr}
 end; {of Proc}

 procedure doAbout;
 var
 IDStrHandle: StringHandle;
 dialogP: DialogPtr;
 item: integer;
 Str1, Str2, Str3: str255;
 myHeapSpace: LongInt;
 FreeSpace: Size;
 begin
 IDStrHandle := StringHandle(GetResource(rsrc, 0));
 if IDStrHandle = nil then
 begin
 doMessage(‘Get About box crash!’, ‘’, ‘’, ‘’);
 ExitToShell;
 end;
 MoveHHi(Handle(IDStrHandle));
 HLock(Handle(IDStrHandle));
 FreeSpace := FreeMem;
 myHeapSpace := MaxMem(FreeSpace);
 NumToString(myHeapSpace, Str2);
 Str2 := concat(‘Memory = ‘, Str2);
 Str3 := ‘’;
 Str1 := ‘’;
 ParamText(IDStrHandle^^, Str1, Str2, Str3);
 dialogP := GetNewDialog(AboutDialog, nil, pointer(-1));
 if dialogP = nil then
 begin
 doMessage(‘Dialog crash!’, ‘We are dead...’, ‘’, ‘’);
 ExitToShell;
 end;
 initCursor;
 ModalDialog(nil, item);
 DisposDialog(dialogP);
 HUnlock(Handle(IDStrHandle));
 end;

 procedure doQuit;
 begin
 DisposeWindow(ADBWindow);
 TEDispose(MyTextHandle);
 Finished := true;
 end; {of proc}

 procedure doSave;
 begin
 end;

 procedure doSaveAs;
 begin
 end;

 procedure doPrint;
 begin
 end;

 procedure doPageSet;
 begin
 end;

 procedure doMenubar; {(menuResult : LongInt)}
 var
 theMenu: integer;
 theItem: integer;
 daName: STR255;
 accItem: integer;
 temp: GrafPtr;
 dummy: LongInt; {Desk Scrap result var}
 ScrapReturn: OSErr; {TEScrap result var}
 TextLength: integer;
 ScrapLength: LongInt;
 begin
 theMenu := HiWord(menuResult); {menu}
 theItem := LoWord(menuResult); {item}
 case theMenu of
 AppleMenu: 
 begin
 if theItem = aAbout then
 doAbout
 else
 begin  {must be DA}
 GetItem(myMenus[AppleM], theItem, daName);
 GetPort(temp);  {protect against flacky DA}
 accItem := OpenDeskAcc(daName);
 SetPort(temp);
 end; {else}
 end; {of AppleMenu}
 FileMenu: 
 begin
 case theItem of
 fADB: 
 begin
 doADB;
 end;
 fSave: 
 begin
 doSave;
 end;
 fSaveAs: 
 begin
 doSaveAs;
 end;
 fPageSet: 
 begin
 doPageSet;
 end;
 fPrint: 
 begin
 doPrint;
 end;
 fQuit: 
 begin
 doQuit;
 end;
 otherwise
 begin
 end;
 end; {of theitem}
 end; {of FileMenu}
 EditMenu: 
 begin
 if not SystemEdit(theitem - 1) then
 begin
 case theItem of
 eUndo: 
 begin
 doMessage(‘Undo not available.’, ‘’, ‘’, ‘’);
 end;
 eCut: 
 begin
 TECut(MyTextHandle);
 dummy := ZeroScrap;
 ScrapReturn := TEToScrap; {update desk scrap}
 end;
 eCopy: 
 begin
 TECopy(MyTextHandle);
 dummy := ZeroScrap;
 ScrapReturn := TEToScrap; {update desk scrap}
 end;
 ePaste: 
 begin
 ScrapReturn := TEFromScrap;
 TextLength := MyTextHandle^^.teLength;
 ScrapLength := TEGetScrapLen;
 if (LongInt(TextLength + ScrapLength)) > longInt(TEMax - 1) then
 begin
 initCursor;
 paramText(‘Paste would exceed text edit 32000 buffer limit!’, ‘’, ‘’, 
‘’);
 ItemHit := StopAlert(AlertDialog, nil);
 end
 else
 TEPaste(MyTextHandle);
 end; { of paste}
 eClear: 
 begin
 TEDelete(MyTextHandle);
 end;
 otherwise
 begin
 end;
 end; {of case}
 end; {of system edit}
 end; {of EditMenu}
 otherwise
 begin
 end;
 end; {of theMenu}
 HiliteMenu(0);  {un-hilite selected menu}
 end;

 procedure doContent; {(ConEvent : EventRecord}
 {contentWindow : windowPtr);}
 var
 localPt, globalPt: Point;
 part: integer;
 myRect: Rect;
 control: ControlHandle;
 begin
 if contentWindow <> FrontWindow then
 SelectWindow(contentWindow);
 globalPt := ConEvent.where;
 localPt := globalPt;{global coord of mouse}
 GlobalToLocal(localPt);  {local coord of mouse}
 part := FindControl(localPt, contentWindow, control);

 if contentWindow = ADBWindow then
 begin
 SetPort(ADBWindow);
 if part <> 0 then
 begin {in control}
 end;
 if part = 0 then
 begin  {content region}
 myRect := ADBWindow^.portRect;
 if PtInRect(localPt, myRect) then
 begin
 TEClick(localPt, BitAnd(ConEvent.modifiers, ShiftKey) = ShiftKey, myTextHandle)
 end;  {of ptInRect}
 end; { of part=0 }
 end; {of contentwindow}
 end;  {of proc}

 procedure doDrag; {(GrabWindow : WindowPtr}
 {GlobalMouse : point);}
 begin
 DragWindow(GrabWindow, GlobalMouse, DragArea);
 end;

 procedure doGrow; {(ResizeWindow : WindowPtr;}
 {Globalmouse : point;}
 {ZoomFlg:Boolean);}
 var
 newSize: LongInt;
 hsize: integer;
 vsize: integer;
 oldPort: GrafPtr;
 myRect: rect;
 tempLong: LongInt;
 l, t, r, b: LongInt;
 begin
 if (ResizeWindow <> FrontWindow) then
 SelectWindow(ResizeWindow)
 else
 begin
 if (ZoomFlg) then
 begin
 with ResizeWindow^.portRect do
 begin
 tempLong := bottom - top;
 newSize := BitShift(tempLong, 16);
 newSize := newSize + (right - left);
 end;
 end
 else
 newSize := GrowWindow(ResizeWindow, Globalmouse, GrowArea);
 if newSize <> 0 then
 begin  {grow the window}
 hsize := LoWord(newSize);
 vsize := HiWord(newSize);
 if ResizeWindow = ADBWindow then
 begin
 with ResizeWindow^.portRect do 
 {Pre-Grow}
 begin
 SetRect(VCRect, right - (SBarWidth - 1), top - 1, right + 1, bottom 
- (SBarWidth - 2));
 SetRect(HCRect, left - 1, bottom - (SBarWidth - 1), right - (SBarWidth 
- 2), bottom + 1);
 SetRect(GrowRect, HCRect.right, HCRect.top, VCRect.right, HCRect.bottom);
 end;  {of with }
 SizeWindow(ResizeWindow, hsize, vsize, TRUE); {new portRect}
 InvalRect(GrowRect);
 EraseRect(GrowRect);
 with ResizeWindow^.portRect do 
 {Post Grow}
 begin
 SetRect(VCRect, right - (SBarWidth - 1), top - 1, right + 1, bottom 
- (SBarWidth - 2));
 SetRect(HCRect, left - 1, bottom - (SBarWidth - 1), right - (SBarWidth 
- 2), bottom + 1);
 SetRect(GrowRect, HCRect.right, HCRect.top, VCRect.right, HCRect.bottom);
 SetRect(ViewRect, left + 4, top + 4, right - (SBarWidth - 1), bottom 
- (SBarWidth - 1));
 end;  {of with }

 InvalRect(GrowRect); 
 HideControl(VControl);
 HideControl(HControl);
 MoveControl(VControl, VCRect.left, VCRect.top);
 MoveControl(HControl, HCRect.left, HCRect.top);
 SizeControl(VControl, SBarWidth, VCRect.bottom - VCRect.top);
 SizeControl(HControl, HCRect.right - HCRect.left, SBarWidth);
 ShowControl(VControl);
 ShowControl(HControl);
 ValidRect(VCRect);
 ValidRect(HCRect);

 MyTextHandle^^.ViewRect := ViewRect;
 InValRect(ViewRect);
 end; {of if ResizeWindow}
 end; {of grow window stuff}
 end; {of if then newsize}
 end;  { of proc }

end. {of unit}

unit MyADBGlobals;

interface

 uses
 OSIntf, PrintTraps;

 const
 {window constants}
 ZoomBox = 8;  {window type}
 MinWidth = 80;
 MinHeight = 80;
 mBarHeightGlobal = $BAA;
 GrayRgnLowMemGlobal = $9EE;
 sBarWidth = 16;
 TEMax = 32767;
 rsrc = ‘ADBx’;  {creator bytes restype}

 {dialog stuff}
 AboutDialog = 256;
 MessageDialog = 258;
 AlertDialog = 260;

 { menu res id’s}
 AppleMenu = 256;
 FileMenu = 257;
 EditMenu = 258;

 MenuCount = 3;
 AppleM = 1;
 FileM = 2;
 EditM = 3;

 {menu items}
 aAbout = 1;
 fADB = 1;
 fSave = 3;
 fSaveAs = 4;
 fPageSet = 5;
 fPrint = 6;
 fQuit = 8;
 eUndo = 1;
 eCut = 3;
 eCopy = 4;
 ePaste = 5;
 eClear = 6;

 versRequested = 1;
 numlock = 1;
 capslock = 2;
 scrolllock = 4;

 envBadVers = -5501;
 envVersTooBig = -5502;

 type
 LongAndByte = record
 case integer of
 1: ( longView: LongInt);
 2: ( byteView: record
 byte0: SignedByte;
 byte1: Signedbyte;
 byte2: Signedbyte;
 byte3: Signedbyte;
 end; );
 end;

 var
 {my misc stuff}
 Finished: boolean;
 mBarHeight: Integer;

 {menu stuff}
 myMenus: array[1..MenuCount] of MenuHandle;

 {rectangles}
 DragArea: Rect; {window drag area}
 GrowArea: Rect; {window grow area}
 Screen: Rect;   {physical screen area}
 ADBWindowRect: Rect;{beginning window size}
 ZoomRect: Rect; {zoomed window size}
 HCRect, VCRect, GrowRect: Rect; {scroller rects}
 DestRect, ViewRect: Rect;{text edit rects}

 {dialogs stuff}
 ItemHit: integer;
 dialogflg: boolean;

 {Window Stuff}
 ADBWindow: WindowPtr;
 ADBWindowPeek: WindowPeek;
 myTextHandle: TEHandle;
 VControl: ControlHandle;
 HControl: ControlHandle;
 myPrint: THPrint;

 {ADB Stuff}
 theWorld: SysEnvRec;
 OSEr: OSErr;
 numberofADBs: integer;
 info: ADBDataBlock;
 buf: ADBOpBlock;
 ADBAddr: ADBAddress;
 device: byte;

implementation

end.

* ADB.R
*

ADB.RSRC
????ADBx

Type ADBx = STR 
 ,0
ADB Demo \0D© by Dave Kelly & Dave Smith \0Dver 2 MAR 1989

* Multifinder Menu for Quit Cmd
Type mstr = STR 
 ,100
File

* Multifinder Quit name
Type mstr = STR 
 ,101
Quit

Type FREF
,128
APPL 0
,129
TEXT 1

Type BNDL
,128
ADBx 0
ICN#
0 128 1 129
FREF 
0 128 1 129

* ------ Multifinder events --------

* bit 15 = reserved
* bit 14 = accept suspend resume events
* bit 13 = reserved
* bit 12 = can do background on null events
* bit 11 = multifinder aware 
*         (activates & deactivates topmost 
*           window at resume, suspend events)

Type SIZE = GNRL
 ,-1
.H
4800    ;; $4800 = bits 14,11 set
.L
128000  ;; (for 150K recomended)
.L
80000 ;; (for 80K minimum)
.I

Type vers = GNRL
 , 1
.H
01 ;; byte vers # in BCD
10 ;; byte vers part 2 & 3
50 ;; byte release stage $50=release
00 ;; byte stage of non-release
00 00 ;; integer country 0=US
.P
V1.1 (US)
.P
ADB Demo 1.1, © by Dave Kelly & David Smith for MacTutor 1989

Type vers = GNRL
 , 2
.H
05 ;; byte vers # in BCD
30 ;; byte vers part 2 & 3
50 ;; byte release stage $50=release
00 ;; byte stage of non-release
00 00 ;; integer country 0=US
.P
V5.3
.P
MacTutor Volume 5 Number 3

* ------------ menus ------------

Type MENU
* the desk acc menu
 ,256
\14;;apple menu
 About ADB Demo 
 (-

* the file menu
 ,257
File
 ADB /A
 (-
 (Save /S
 Save as 
 Page Setup  /U
 (Print  /O
 (-
   Quit /Q

* the edit menu
 ,258
Edit
 (Undo /Z
 (-
 Cut /X
 Copy /C
 Paste /V
 Clear


* ------ Dialogs --------
* About Box dialog...
type DLOG
 ,256
About ADB Demo 
100 100 250 400 
visible NoGoAway 
1
0
256

type DITL
 ,256
3
BtnItem Enabled
112 235 141 284 
OK

StatText Disabled
10 88 141 289 
ADB Demo\0D\0D++
Queries System, blinks lights\0D^0\0D^1\0D^2\0D^3

PicItem Disabled
10 10 96 81 
128

* Program Messages Dialog box...
type DLOG
 ,258
Program Messages
100 100 200 400
Visible NoGoAway
1
0
258

type DITL
 ,258
3
BtnItem Enabled
65 230 95 285
OK

StatText Disabled
15 60 85 222 
^0\0D^1\0D^2\0D^3

IconItem Disabled
10 10 42 42
1

* ------ Alerts ------------

* Program error alerts...
type ALRT
 ,260
100 100 200 400
260
5555

type DITL
 ,260
2

BtnItem
65 230 95 285
OK

StatText Disabled
15 60 60 275 
Program Problem Alert:\0D^0^1^2^3

* misc resources
Type ICN# = GNRL
  ,128 (0)
.H
0001 0000 0002 8000 0004 4000 000B E000 
0015 5000 0026 B800 0045 5400 0086 B200 
0105 5100 0213 E080 0428 0040 0810 0020 
1102 0010 2204 0008 4480 3F04 8910 4082 
4220 8041 2441 3022 1081 C814 081E 7F8F 
0402 3005 0201 0007 0100 8005 0080 6007 
0040 1FE5 0020 021F 0010 0407 0008 0800 
0004 1000 0002 2000 0001 4000 0000 8000
*
0001 0000 0003 8000 0007 C000 000F E000 
001F F000 003F F800 007F FC00 00FF FE00 
01FF FF00 03FF FF80 07FF FFC0 0FFF FFE0 
1FFF FFF0 3FFF FFF8 7FFF FFFC FFFF FFFE 
7FFF FFFF 3FFF FFFE 1FFF FFFC 0FFF FFFF 
07FF FFFF 03FF FFFF 01FF FFFF 00FF FFFF 
007F FFFF 003F FE1F 001F FC07 000F F800 
0007 F000 0003 E000 0001 C000 0000 8000 

Type ICN# = GNRL
  ,129 (0)
.H
0FFF FE00 0800 0300 0800 0280 0800 0240 
0800 0220 0800 0210 0800 03F8 0800 0008 
0800 0008 0801 0008 0802 8008 0805 4008 
080A A008 0815 5008 082A A808 0815 5008 
080A A008 0805 4008 0802 8008 0801 0008 
0800 0008 0800 0008 0800 0008 0800 0008 
0820 79E8 0850 4528 0888 45E8 09FC 4528 
0A02 79E8 0800 0008 0800 0008 0FFF FFF8
*
0FFF FE00 0FFF FF00 0FFF FF80 0FFF FFC0 
0FFF FFE0 0FFF FFF0 0FFF FFF8 0FFF FFF8 
0FFF FFF8 0FFF FFF8 0FFF FFF8 0FFF FFF8 
0FFF FFF8 0FFF FFF8 0FFF FFF8 0FFF FFF8 
0FFF FFF8 0FFF FFF8 0FFF FFF8 0FFF FFF8 
0FFF FFF8 0FFF FFF8 0FFF FFF8 0FFF FFF8 
0FFF FFF8 0FFF FFF8 0FFF FFF8 0FFF FFF8 
0FFF FFF8 0FFF FFF8 0FFF FFF8 0FFF FFF8 

TYPE PICT = GNRL
 ,128
.I
891
195 254 281 325
.H
1101 A000 82A0 008E 0100 0A00 0000 0002
D002 4098 000A 00C3 00F8 00FF 0148 00C3
00FE 00FF 0145 00C3 00FE 00FF 0145 0000
02F7 0002 F700 02F7 0002 F700 02F7 0002
F700 02F7 0002 F700 02F7 0002 F700 02F7
0006 FD00 000E FC00 07FD 0001 1F80 FD00
07FD 0001 7FC0 FD00 07FD 0001 FFF0 FD00
08FE 0002 03FF FCFD 0008 FE00 0207 FFFE
FD00 09FE 0003 1FFF FF80 FE00 09FE 0003
3FFF FFE0 FE00 09FE 0003 7FFF FFF8 FE00
0A02 0000 01FE FF00 FCFE 0008 0200 0003
FDFF FE00 0A02 0000 0FFD FF00 C0FF 000B
0700 001F FFFF 3FFF E0FF 000B 0700 007F
FFFE 1FFF F8FF 000B 0700 00FF FFFE 1FFF
FCFF 000B 0100 01FE FF02 27FF FCFF 000B
0100 01FE FF02 F9FF F8FF 000B 0100 00FE
FF02 FE7F F0FF 000B 0200 003F FEFF 019F
E0FF 000B 0200 001F FEFF 01E7 C0FF 000B
0200 003F FEFF 01F9 80FF 000B 0200 0033
FEFF 01FE 80FF 000A 0200 0060 FDFF 00C0
FF00 0B07 0000 607F FFFF FCC0 FF00 0B07
0000 601F FFFF F870 FF00 0B07 0000 6007
FFFF F0F8 FF00 0B07 0000 6001 FFFF F0F8
FF00 0B07 0000 6000 FFFF F0F8 FF00 0B07
0000 6038 3FFF B050 FF00 0A06 0000 607C
0FFF 30FE 000B 0700 0060 F603 FE30 A8FF
000B 0700 0060 E301 FC30 50FF 000B 0700
0060 C000 7830 20FF 000B 0700 0060 0000
1030 88FF 000B 0200 0060 FE00 0130 50FF
000A 0200 0060 FE00 0030 FE00 0B02 0000
60FE 0001 30A8 FF00 0B07 0000 6807 0700
B050 FF00 0A06 0000 681F 8FC0 B0FE 000B
0700 006C 7FDF F1B0 A8FF 000A 0200 0067
FEFF 0030 FE00 0B09 0000 63FF FFFE 31F4
1000 0B09 0000 307F DFF0 6046 3000 0B09
0000 381F 8FC0 E045 5000 0B09 0000 1C00
0001 C044 9000 0B09 0000 0E00 0003 8044
1000 0802 0000 07FE FFFD 0009 0500 0001
FFFF FCFD 0008 FE00 0280 0004 FD00 9800
0A00 FF00 F801 1901 4800 FF00 FE01 1901
4500 FF00 FE01 1901 4500 0008 FE00 0280
0004 FD00 08FE 0002 FFFF FCFD 0008 0200
0001 FEAA FD00 0802 0000 03FE 55FD 000A
0600 0006 FEAF EA80 FE00 0A06 0000 0D83
5835 40FE 000A 0600 001B 01B0 1AA0 FE00
0A06 0000 3501 5015 50FE 000A 0600 006A
82A8 2AA8 FE00 0A06 0000 D57D 57D7 F4FE
000A 0600 01AF AAFA AC1A FE00 0A06 0003
5055 0558 0DFE 000B 0700 06A0 2A02 A80A
80FF 000B 0700 0D60 3603 5415 40FF 000B
0700 0AB0 6B06 ABEA C0FF 000B 0700 0D5F
D5FD 5555 40FF 0009 0100 0AFC AA00 C0FF
0009 0100 0DFC 5500 40FF 0009 0100 0FFC
FF00 C0FF 0002 F700 02F7 0002 F700 02F7
0002 F700 02F7 0002 F700 A000 8FA0 0083
FF

Link Segments for our Project