Typecasting
Volume Number: 2
Issue Number: 8
Column Tag: Intermediate Mac'ing
Typecasting Rascal to Pascal 
By David E. Smith, Editor & Publisher
A Complete (nearly) TML Shell
When I first saw this Keyboard Sleuth program, I thought, "How neat! But who
has Rascal?", so after looking over the program, I figured I would just translate it into
TML Pascal. Right! Three days and 60 hours later, I finally duplicated the program
function in Pascal. In so doing, I gained an appreciation for how much work the
development system shell in Rascal does for you, and how much programming effort
must be spent typecasting variables in Pascal. Admittedly, I am an assembly language
programmer, so when you tell me I need four bytes for a pointer, I don't care in the
least what object the pointer points to. Not so in Pascal. Every time you turn around,
you have to figure out some "magic" variable type to fool Pascal into letting you violate
it's strongly typed variable rules. This is particularly a pain in the neck when dealing
with the message field of the event record, since it's meaning changes (and hence it's
type!) with each different event, even though it's length of course is always four bytes,
or LONGINT. If I had understood typecasting better, the conversion would have been
much easier.Whoever thought strongly typed variables would make a programmer's life
easier never had to program for a living. Macintosh programs would decrease in size
and complexity dramatically if mixing of variable types was both allowed and automatic
by the compiler. This is one area where a good Basic compiler could really make toolbox
programming simple and quick. (Perhaps that is the appeal of a langauge like Rascal in
the first place!) Here are some typecasting rules that should make this easier for you
than it was for me.
Typecasting on the Mac
Types in the Macintosh:
SignedByte: any byte in memory (-128..127)
Byte: unsigned byte (0..255)
Ptr: a pointer or address (^SignedByte)
Handle: address of a Ptr (^Ptr)
The Signed Byte is the fundamental type. Any size of bytes of memory can be
created as a pascal data structure using the following:
Packed Array[1..size] of SignedByte
I'm still not sure what a string is, but the Macintosh string type is Str255,
which is defined as STRING[255], which I finally found out on page I-91 of Inside
Macintosh, means a four byte pointer to what I assume is a packed array of char that can
be up to 255 characters in length. A byte length count is added at the beginning for a
total size of 256 bytes. This was my assumption in the program, and it seems to work.
So everytime you see Str255 in a program, it's not really the string, but a four byte
ptr to the length byte of the string.
To get around the type casting problem for a pre-defined Pascal type, you do
something like this:
Var
key: Byte
code: Char
Begin
key:=Byte(code); {types must be same length}
This forces code, which is a Char type into Key, which is a Byte type, by
"reminding" Pascal with the Byte designator, that key is of type Byte. You'd think the
compiler could figure that out for himself!
For non-predefinded types, it gets more complicated. Basically you have to
create something in an allowed type and then force it into your type. The example below
shows how to peek at a byte location in memory. We create a Handle (which always
points to a signed byte), then typecast it into the Handle we really want (magicHandle),
then use another Pascal mystery, the case boolean of, to equate the four byte LONGINT
type to four individual bytes of Byte type so we can read a single byte. This is the most
magic of all. It seems as if it violates the fundamental law of the universe, by making
TRUE and FALSE both valid at the same time! I guess only a computer could accomplish
that.
Peeking into Memory
magicHandle = ^magicptr;
magicptr = ^magic;
magic = packed record
case boolean of
true: (L:LONGINT);
false: (byte3,byte2,byte1,byte0:Byte)
end;
Var
tempHandle: Handle; {to signed byte}
magicman: magicHandle; {this seems magic to me}
addr: integer;
mysize: integer;
Begin
addr:=$021E; {some place in memory to peek}
mysize:=SIZEOF(magicman);
tempHandle:=NEWHANDLE(mysize);
magicman:=magicHandle(tempHandle); {typecasting!}
magicman^:=pointer(addr); {more typecasting!}
KbdType:=magicman^^.byte3; {Finally!}
disposHandle(tempHandle);
End;
Inside Macintosh says strong typing ability lets Pascal programmers write
programs without really considering the size of variables (page I-86), which would be
an advantage if we were writing Pascal programs. But on the Mac, you really write
toolbox programs, which are assembly programs, which requires you to know the
length of each type, which requires a lot of typecasting (I guess). If anyone else has an
explanation of why we should ever have to typecast same length variables, I'd like to
hear it.
The final problem is one of incrementing or decrementing an address in memory
so you can point somewhere else. This gave me fits until I learned how you do it. First
you convert the pointer back into a number (it wasn't already?). Then you do your
number thing on it (add, subtract, etc.) Then you convert it back into a pointer. A whole
set of functions let you do all this mashing of types. Here they are from page I-80 of
Inside Macintosh:
Var
anInteger: INTEGER;
ALongInt: LONGINT;
aPointer: Ptr;
Begin
anInteger: = ORD(aLongInt); {two low bytes}
anInteger:= ORD(aPointer); {two low bytes}
aLongInt:= ORD(anInteger); {packed in high order}
aLongInt:= ORD4(anInteger); {packed in low order}
aLongInt:= ORD(aPointer); {make ptr a number}
aPointer:= POINTER(anInteger); {make into an address}
aPointer:= POINTER(aLongInt); {make into an address}
end;
The POINTER function converts a number into an address. So to increment an
address, you:
NewAddress:=POINTER(ORD(@Str)+1);
This converts the pointer to the string to a LONGINT number, allowing you to
increment it by one, and converts it back to a pointer. Now you've learned what took me
60 hours of Mac study to figure out. Namely how to point to the string data past the
length byte. If it's old hat to you, then you're a Mac Hacker of long standing. If it's new,
then welcome to the Macintosh world.
How Do You Print a String?
The main thing that Keyboard Sleuth does is poke around in the Mac and try and
figure out what kind of keyboard you have. Then it prints all the information to the
screen and a log file and sits in a loop waiting for you to press a key. When you do, it
zaps out a message of what key number you pressed and what it's ascii value is and
displays the character itself, if it's not a control character. So the main idea is to
display back a lot of information to the user. How do you do that on the Mac? If you look
at all the Mac programming books, and I've been through them all, generally they all
assume its the user that wants to display stuff on the screen, not the program. In
Rascal, it's easy as the following example shows from our program.
Rascal PutString Procedure
Procedure PutString(str: PtrB);
BEGIN
writestring(str); (* to the screen *)
IF logfile THEN
fPutS(logfile, str); (* to the file *)
END;
Making the Simple into the Complex
What they don't tell you is a lot of housekeeping is done on the Mac for you. For
example, if you print a bunch of stuff on the screen, what happens when you get to the
bottom of the screen? Oh, you mean you want scrolling? Well, that's a horse of a
different color. Or suppose someone opens the calculator DA, and your list is
obliterated. Oh, you mean you want updating? That's TextEdit. Or suppose you want to
save the data you displayed for the user. Oh, you want files? Well better go see standard
file dialog about that! Or suppose you want to back up so the user can see what you
printed out for him. Oh, well, you better get some controls then and handle a scroller
event. And on and on it goes until your simple Print "hello world" becomes a full blown
mac application. Such is what I got caught up into when I started converting this
program to Pascal. I quit when I got to scrolling and saved controls for another day!
Pascal Version of PutString
Take a look at the procedure PutString in our Pascal program listing and you
will see all of these issues we've discussed. We insert the text, pointing to the string
data, not the length, into our text edit record. This basically gets the data on the screen.
Then we check to see if we have reached the end of the screen, by looking at the line
counts times the character height from the text edit record. In this way, it still works
if someone changes fonts later. If we need scrolling, we scroll up, again using the
character height as a scroll value. The TEInsert writes our text to the screen, and
generates a new update event if the insertion changes anything downstream, which is
doesn't in the case of printing lists.
KeyTrans Assembly Routine
The final problem had to do with the keytrans routine. This routine pokes around
for the correct ROM routine to translate a key code into ascii. The clever thing is that
this routine changes depending on what your country is, so by installing custom
translation routines, you make custom Macs. By using this Mac routine to convert to
ascii for us, we can see what character is returned and guess at the keyboard type. To do
this we have to call a machine language routine. So keytrans is an assembly glue
routine that allows us to call a Mac routine and return the results back to Pascal. This
led to more investigations on how to call assembly from Pascal and how to call Pascal
from assembly. The key to it all is the A6 frame pointer. How it works is shown in the
figure below.
File Stuff Not Polished
Be aware that the file routine in OpenLog is very primitive and doesn't do
anything with the error checking. I had the program bomb on me once or twice for some
reason after the standard file dialog, so you should put some effort into beefing up the
error checking coming back from the various disk I/O routines. This is a great little
Mac demo program that is both useful and makes a good shell program showing off file
I/O, text edit and scrolling. I learned a lot from it. Thanks Joel!
program KeyboardSleuth;
{ Keyboard Sleuth: analyze key mappings
Stand-alone version written in Rascal
By Joel West, August 1986, for MacTutor
** Converted to TML Pascal by David E. Smith **
Tries to figure out what keyboard is installed
Uses several approaches:
-Dump and analyze keyboard #
-Check keypad for Mac 512 vs. Mac Plus
-Look at INTL resources to find for country code
-Check for mapping of space key (US vs. Foreign)
Then allows user to type keys and shows their keycodes
and ASCII values. Dumps this to screen and to a logfile }
{ Include files and constants }
{$I MemTypes.ipas }
{$I QuickDraw.ipas }
{$I OSIntf.ipas }
{$I ToolIntf.ipas }
{$I PackIntf.ipas }
{$I HFS.ipas }
{ ---------------- GLOBAL CONSTANTS ------------ }
CONST
Key1Trans = $29E; { Low Memory Globals }
Key2Trans = $2A2;
EOL = 13; { end of line file delimiter (RETURN)
}
{menu res id's }
AppleMenu = 256;
FileMenu = 257;
EditMenu = 258;
{ ---------------- ASCII values ------------ }
Space = $20; { }
{ Key #10, where US,UK "/" is (key # differs in US) }
Slash = $2F; { / UK }
Minus = $2D; { - German, Spanish, Swedish }
Equals = $3D; { = French }
Ograve = $98; { ò Italian }
Eaigu = $8E; { é French Canadian }
{ Key # 36, where UK "`" (accent grave) is
Used only to distinguish Spanish from German and Swedish }
Degree = $A1; { ° Spanish/Latin American }
Hash = $8A; { # German }
Apos = $27; { ' Swedish }
{ ---------------- Keycap Numbers ------------ }
USspKey = 49; { space bar in US }
UKspKey = 52; { space bar in UK, Euro-Classics}
UKslKey = 10; { / key in UK }
UKgrKey = 36; { ` (dead) key in UK }
{ ---------------- GLOBAL VARIABLES ------------ }
VAR
{my stuff}
my window: WindowPtr; { our window pointer }
finished: Boolean; {program terminator}
ClockCursor:CursHandle; {handle to waiting watch }
{STDFile stuff}
logfile: INTEGER; { file status }
logname: STR255; { file name }
volNumber: INTEGER; { vRefNum }
fileNumber: INTEGER; { file number }
{Screen stuff}
DragArea: Rect;
GrowArea: Rect;
Screen: Rect; {holds the screen dimensions }
{TextEdit stuff}
DestRect: Rect;
ViewRect: Rect;
theText: TEHandle;
scrollflg: Boolean;
{ ---------------- BEGIN CODE ------------ }
Function KeyTrans(keyno,modifies: Integer) : Integer; EXTERNAL;
{$U keytrans }
{ Translate key number and modifiers to
their corresponding ASCII value }
Function CR:str255;
begin
CR:= chr(EOL)
end;
PROCEDURE Openlog;
{ open keyboard logfile to save all messages for later review }
label 1;
Var
where: Point;
Prompt: STR255;
origName: STR255;
reply: SFReply; { standard file reply record }
Info: FInfo; { Finder file info reply record }
vol: INTEGER; { vRefNum }
fileno: INTEGER; { file number }
resultCode: OSErr;
Begin
where.v := 50;
where.h := 50;
Prompt := 'Save your log file as:';
origName := 'KeyBoard Log';
DILoad; {in case disks are switched}
SFPutFile(Where, Prompt, origName, Nil, reply);
logname := reply.fName;
vol := reply.vRefNum;
IF reply.good = FALSE THEN
logfile := 0 {bad file}
ELSE
logfile:= 1; {good file}
IF logfile = 0 THEN goto 1;
resultCode:=GetFInfo (logname, vol, Info);
case resultCode of
NoErr: { file exists..delete it }
Begin
if Info.fdType <>'TEXT' then
begin
logfile:=0;
goto 1;
end;
resultCode:=RstFlock(logname,vol);
if resultCode <> NoErr then
begin
logfile:=0;
goto 1;
end;
resultCode:=FSDelete(logname,vol);
if resultCode <> NoErr then
begin
logfile:=0;
goto 1;
end;
resultCode:= Create (logname, vol, 'MACA', 'TEXT');
if resultCode <> NoErr then
begin
logfile:=0;
goto 1;
end;
end;
FNFErr: { file not found so create one }
begin
resultCode:= Create (logname, vol, 'MACA', 'TEXT');
if resultCode <> NoErr then
begin
logfile:=0;
goto 1;
end;
end;
OTHERWISE logfile:=0;
End; { case }
if logfile = 0 then goto 1;
resultCode:= FSOpen (logname, vol,fileno); { open log file }
if resultCode <> NoErr then
begin
logfile:=0;
goto 1;
end;
resultCode:= SetFPos (fileno, FSFromStart, 0);
if resultCode <> NoErr then
begin
logfile:=0;
goto 1
end;
volNumber:=vol;
fileNumber:=fileno;
1:
if logfile = 1 then
SetWTitle(my window, logname)
else
SetWTitle(my window, 'No Log File!');
End;
Procedure PutString(str: Str255);
{ Write a string to the log file and to the screen }
Var
resultCode: OSErr;
strlen: LONGINT;
scrollup: integer;
curlines: integer;
linepos: integer;
newpos: integer;
endpos: integer;
BEGIN
strlen:=length(str);
TEInsert(POINTER(ORD(@str)+1),strlen,theText);
TEIdle(theText);
HLock( handle(theText));
IF (not scrollflg) then
begin
scrollup:=theText^^.lineHeight;
curlines:=theText^^.nLines;
linepos:=curlines*scrollup;
endpos:=theText^^.ViewRect.bottom;
if (linepos>=endpos) then
scrollflg:=true;
end;
if scrollflg then TEScroll(0,-theText^^.lineHeight,theText)H
HUnlock( handle(theText));
IF logfile = 1 THEN
Begin
resultCode:= FSWrite (fileNumber, strlen, POINTER(ORD(@str)+1));
if resultCode <> NoErr then logfile:=0;
End;
END;
Function IntToString(num: Integer):str255;
{integer to string}
VAR
s: Str255;
longnum: LongInt;
BEGIN
longnum:=num;
NumToString(longnum, s);
IntToString:=s;
END;
Function KbdType: Integer;
{ Get low memory value at $21E, a byte, the keyboard no. }
magicHandle=^magicptr;
magicptr = ^magic;
magic = packed record
case boolean of
true: (l: longint);
false: (byte3,byte2,byte1,byte0: Byte)
end;
Var
tempHandle: Handle; {handle to signed byte}
magicman: magicHandle; {handle to magic}
addr: INTEGER;
mysize: INTEGER;
BEGIN
addr:= $021E;
mysize:=SIZEOF(magicman);
tempHandle:=NewHandle(mysize);
magicman:=magicHandle(tempHandle);
magicman^:=pointer(addr);
KbdType:=magicman^^.byte3;
disposHandle(tempHandle);
END;
Procedure ShowIntlNation;
{ Show }
VAR
country: integer;
ih: intl0Hndl;
s:str255;
known: Boolean;
BEGIN
ih := intl0Hndl(IUGetIntl(0)); { get INTL 0 resource }
country := (ih^^.intl0Vers) div 16; { country is upper byte
}
s:='This Mac is configured for ';
known:=true; {be optomistic}
{ There are symbolic constants for these (verUS, verFrance, etc.),
but unless even if you have the latest update to your development
system, you probably won't have all 26. I've hard-coded them for
clarity. }
CASE country OF
0: s:=concat(s,'the US or Canada');
1: s:=concat(s,'France');
2: s:=concat(s,'U.K. or Ireland');
3: s:=concat(s,'Deutschland'); { Germany }
4: s:=concat(s,'Italia');
5: s:=concat(s,'Nederland'); { Netherlands }
6: s:=concat(s,'Belgique ou Luxembourg');
7: s:=concat(s,'Sverige'); { Sweden }
8: s:=concat(s,'Españá'); { Spain }
9: s:=concat(s,'Danmark');
10: s:=concat(s,'Portugal');
11: s:=concat(s,'Quebec'); { French Canada }
12: s:=concat(s,'Norge'); { Norway }
13: s:=concat(s,'Yisra'el');
14: s:=concat(s,'Nippon'); { Japan }
15: s:=concat(s,'Australia or New Zealand');
16: s:=concat(s,'Arabiyah');
17: s:=concat(s,'Suomi'); { Finland }
18: s:=concat(s,'Suisse'); { French Swiss }
19: s:=concat(s,'Schweiz'); { German Swiss }
20: s:=concat(s,'Ellas'); { Greece }
21: s:=concat(s,'Island'); { Iceland }
22: s:=concat(s,'Malta');
23: s:=concat(s,'Kypros'); { Cyprus }
24: s:=concat(s,'Türkiye');
25: s:=concat(s,'Jugoslavija');
OTHERWISE
Begin
known:=false;
s:=concat(s,'an unknown country, #',IntToString(country),'. ');
End;
END; {case}
if known then s:=concat(s,'. ');
s:=concat(s,CR,CR);
PutString(s);
END;
Procedure ShowModel;
{ Guess which type of Macintosh keyboard }
Var
s,ss:str255;
Kbd:INTEGER;
BEGIN
{ Use derived keyboard numbers }
Kbd:=KbdType;
ss:=IntToString(Kbd);
s:=concat('The keyboard type is ',ss);
CASE Kbd OF
11: s:=concat(s,', which is a Mac Plus keyboard.');
3: s:=concat(s,', which is the Classic Mac
keyboard.');
OTHERWISE s:=concat(s,', which is unknown.');
END; {case}
s:=concat(s,CR);
PutString(s);
END;
Procedure GuessKeyNation;
{ Guess which country keyboard mappings are set for }
Var
s: str255;
BEGIN
{ Try mapping of certain keys to figure US vs. non-US board }
IF (KeyTrans(USspKey,0) = Space) THEN
begin
s:='This is US, Canadian or down under.';
end {IF..THEN}
ELSE
BEGIN
IF (KeyTrans(UKspKey,0) = Space) THEN
BEGIN
{ Use UK "/" key to guess at nationality }
CASE KeyTrans(UKslKey,0) OF
Slash: { / UK }
s:=concat(s,'I am British or Dutch.');
Ograve: { ò Italian }
s:=concat(s,'Sono Italiano.');
Equals: { = French }
s:=concat(s,'Je suis français, suisse ou belge.');
Eaigu: { é French Canadian }
s:=concat(s,'Je suis canadien.');
Minus: { - German, Spanish, Swedish }
{ Use UK accent grave (dead `) to tell
German, Spanish, and Swedish }
CASE KeyTrans(UKgrKey,0) OF
Hash: { # German }
s:=concat(s,'Ich bin ein Deutscher.');
Degree: { ç Spanish }
s:=concat(s,'Habla Español.');
Apos: { ' Swedish }
s:=concat(s,'This is Swedish.');
OTHERWISE { I have no country! }
s:=concat(s,'No tengo un país!');
END; {case UKgrKey}
OTHERWISE
begin
s:=concat(s,'I am a Mac without a country!');
end; {otherwise}
END; {CASE}
END {IF...THEN}
ELSE
begin
s:=concat(s,'Neither US nor European, what is it?');
end; {else}
END; {IF..THEN..ELSE}
s:=concat(s,CR,CR,'Type keys, or click mouse to quit.',CR);
PutString(s);
END; {proc}
Procedure DoMyStuff;
Var
s: str255;
BEGIN
OpenLog; { log file }
ShowIntlNation; { Find country code }
ShowModel; { Examine keyboard type }
GuessKeyNation; { Look at key mappings }
showWindow(my window);
END;
{ Following is standard Mac Shell stolen from TML Examples}
PROCEDURE DoMenu(select:longint);
Var
Menu_No: integer;
Item_No: integer;
NameHolder: Str255; {DA or Font name holder }
DNA: integer; {OpenDA result
Begin
If select <> 0 then
begin
Menu_No := HiWord(select); {get the Hi word of...}
Item_no := LoWord(select); {get the Lo word of...}
Case Menu_No of
AppleMenu:
Begin
GetItem(GetMHandle(AppleMenu), Item_No, NameHolder);
DNA := OpenDeskAcc(NameHolder);
End; { applemenu}
FileMenu: Finished:=true; {quit}
EditMenu:
Begin
If Not SystemEdit(Item_no - 1) then
Case Item_No of
1: begin end; {undo}
{ 2: line divider}
3: TECut(theText); {cut}
4: TECopy(theText ); {copy}
5: TEPaste(theText ); {paste}
6: TEDelete(theText ); {clear}
End; {case}
End; {editmenu}
end; {case menu_no}
HiliteMenu(0); {unhilite after processing menu}
end; {If select <> 0}
End; {of DoMenu procedure}
PROCEDURE doMouseDowns(Event:EventRecord);
Var
Location :integer;
WindowPointedTo :WindowPtr;
MouseLoc :Point;
WindoLoc :integer;
Begin
MouseLoc := Event.Where;
WindoLoc := FindWindow(MouseLoc, WindowPointedTo);
Case WindoLoc of
inMenuBar: DoMenu(MenuSelect(MouseLoc));
inSysWindow: SystemClick(Event,WindowPointedTo);
inContent:
if WindowPointedto <> FrontWindow then
SelectWindow(WindowPointedTo);
inGrow: Begin End; {no grow} inDrag: D
DragWindow(WindowPointedTo,MouseLoc,DragArea); inGoAway:
Begin
If TrackGoAway(WindowPointedTo,MouseLoc) then
Begin
DisposeWindow(WindowPointedTo);
finished:=true;
End;
End; {inGoAway}
End{ of case};
End;
PROCEDURE doKeyDowns(Event:EventRecord);
magicHandle=^magicptr;
magicptr = ^magic;
magic = packed record
case boolean of
true: (l: longint);
false: (byte3,byte2,byte1:Byte;chr0: Char)
end;
Var
CharCode: char;
keycode: Byte;
mods: INTEGER;
s: str255;
keyc: INTEGER;
asc: INTEGER;
tempHandle: Handle; {handle to signed byte}
magicman: magicHandle; {handle to magic}
mysize: INTEGER;
Begin
mysize :=SIZEOF(magicman);
tempHandle :=NewHandle(mysize);
magicman :=magicHandle(tempHandle);
magicman^^.l :=Event.message;
CharCode :=magicman^^.chr0;
keycode :=magicman^^.byte1;
keyc := keycode;
mods := Event.modifiers;
s:=concat('Key #',IntToString(keyc));
IF BitAnd(mods,optionKey) = optionKey THEN
s:=concat(s,' with Option');
IF BitAnd(mods,shiftKey) = shiftKey THEN
s:=concat(s,', shifted');
IF BitAnd(mods,alphaLock) = alphaLock THEN
s:=concat(s,', Caps Locked');
asc := KeyTrans(keyc,mods); { try translate to ASCII }
{ Don't want to print control characters }
IF asc >= 32 THEN
BEGIN
s:=concat(s,' is ',chr(asc),' (ascii ',IntToString(asc),').');
END;
s:=concat(s,CR);
PutString(s)
END;
PROCEDURE doActivates(Event: EventRecord);
Var TargetWindow:WindowPtr;
Begin
TargetWindow := pointer(ord4(Event.message));
If Odd(Event.modifiers) then
Begin {activate}
SetPort(TargetWindow);
End
else {deactivate}
Begin End;
End;
PROCEDURE doUpdates(Event:EventRecord);
Var
UpDateWindow,TempPort: WindowPtr;
Begin
UpDateWindow := pointer(ord4(Event.message));
if UpDateWindow = mywindow then
Begin
GetPort(TempPort); {Save the current port}
SetPort(my window); {set the port to one in Evt.msg}
BeginUpDate(my window);
EraseRect(my window^.visRgn^^.rgnBBox);
TEUpdate(my window^.visRgn^^.rgnBBox,theText);
EndUpDate(my window);
SetPort(TempPort); {restore to the previous port}
End;
End;
PROCEDURE EndProgram;
Var
resultcode: OSErr;
Begin
IF logfile =1 THEN
begin
resultCode:= FSClose(fileNumber);
end;
ExitToShell;
End;
PROCEDURE MainEventLoop;
Var Event:EventRecord;
DoIt: Boolean;
Begin
InitCursor;
Repeat
SystemTask; {support DAs}
DoIt := GetNextEvent(EveryEvent,Event);
If DoIt{is true} then {we'll DoIt}
Case Event.what of
mouseDown : doMouseDowns(Event); {1}
mouseUp : begin end; {2}
KeyDown : doKeyDowns (Event); {3}
keyUp : begin end; {4}
autoKey : begin end; {5}
updateEvt : doUpdates (Event); {6}
diskEvt : begin end; {7}
activateEvt : doActivates (Event); {8}
{abort evt now reserved for future} {9}
networkEvt : begin end; {A}
driverEvt : begin end; {B}
app1Evt : begin end; {C}
app2Evt : begin end; {D}
app3Evt : begin end; {E}
app4Evt : begin end; {F}
End;{of Case}
Until Finished; {end program}
EndProgram; {call our finish up stuff}
End;
PROCEDURE InitThings;
Begin
InitGraf(@thePort);
ClockCursor := GetCursor(watchCursor);
HLock(Handle(ClockCursor));
SetCursor(ClockCursor^^);
InitFonts;
InitWindows;
InitMenus;
TEInit;
InitDialogs(Nil);
FlushEvents(everyEvent,0);
scrollflg:=false; {too early to scroll!}
finished:=false; {clear program terminator}
End;
PROCEDURE SetupLimits;
Begin
Screen := ScreenBits.Bounds; {screen 512 by 342 pixels}
SetRect(DragArea,Screen.left+4,Screen.top+24,
Screen.right-4,Screen.bottom-4);
SetRect(GrowArea,Screen.left,Screen.top+24,
Screen.right,Screen.bottom);
End;
Procedure SetupWindows;
Const
sbarwidth=16; {width of scroll bars}
Var
myrect: Rect;
windtype: integer;
Visible: boolean;
GoAway: boolean;
RefVal: LongInt;
Begin
SetRect(myrect,10,40,500,330); { window size -global cord}
windtype := 4; {set window type - nogrowdocproc
}
Visible := false; {set the window to invisible }
GoAway := true; {give the window a GoAway box }
my window:= NewWindow(Nil, { allocate space in Heap}
myrect,
'Keyboard Sleuth',
Visible,
windtype,
POINTER(-1), {front}
GoAway, { goaway region in title area }
RefVal); { 32-bit value used by App}
SetPort(my window);
TextFont(Geneva);
{ Set Up Text Edit Record for this Window }
with myWindow^.portRect do
SetRect(ViewRect,4,4,right-(sbarwidth-1),
bottom-(sbarwidth-1));
DestRect:=ViewRect;
theText:= TENew(DestRect,ViewRect);
{ NOTE: NewWindow initiated an ActivatEvt and an }
{ UpDateEvt event. Being queued up by event manager.}
End;
PROCEDURE SetupMenus;
Var myMenu :MenuHandle;
NameHolder :STR255;
Begin
myMenu := GetMenu(AppleMenu);{from resource file}
AddResMenu(myMenu,'DRVR'); {adds DAs}
InsertMenu(myMenu,0);
myMenu := GetMenu(FileMenu); {Quiting...}
InsertMenu(myMenu,0);
myMenu := GetMenu(EditMenu); {DA support...}
InsertMenu(myMenu,0);
DrawMenuBar; {show the menu bar}
End;
{ ---------------- MAIN PROGRAM ------------ }
BEGIN
InitThings;
SetupLimits;
SetupWindows; {do first so its low in heap}
SetupMenus;
DoMyStuff;
MainEventLoop;
END.
; EXAMPLE ASSEMBLY SUBROUTINE
; key test thing
; VERSION 11 July 1986
; (C) Copyright 1986 MacTutor
INCLUDE MACTRAPS.D
XDEF keyTrans ; required for linker
; =========== system globals =============
Key1Trans equ $29E; { Low Memory Globals }
Key2Trans equ $2A2;
; =========== key translation routine ======
KeyTrans:
; key code (2 bytes) and modifiers (2 bytes) passed
; ascii char code returned (2 bytes)
link a6, #-4
movem.l A0-A1/D0-D2, -(SP)
; get key code from stack into D2
; get modifiers from stack into D1
move.w 8(A6), D1 ;second parameter (modifiers)
move.w 10(A6), D2 ;first parameter (key code)
move.w #9, D0 ;shift count for flags
lsr D0,D1 ;move bits to lower byte
andi #7, D1 ;mask 3 bits to get modify in D1
cmpi #64, D2 ;keycode <64 then key1
BGE key2 ;=>64 then key2
key1:
clr.l D0
LEA showit, A0 ;get return address
move.l A0, -(SP) ;return address to stack
move.l #key1trans, A0 ;global for ptr to key1trans
move.l (A0), A0 ;get address of key1trans
jmp (A0) ;call subroutine
key2:
subi #64, D2 ;adjust key code
clr.l D0
LEA showit, A0 ;get return address
move.l A0, -(SP) ;return address to stack
move.l #key2trans, A0 ;global for ptr to key2trans
move.l (A0), A0 ;get address of key1trans
jmp (A0) ;call subroutine
showit:
; return function result from D0
move.w D0, 12(A6) ;pass back function result
movem.l (SP)+, A0-A1/D0-D2
unlk a6
move.l (SP)+, A0 ;get return address
addq.l #4, SP ;remove passed parameters
JMP (A0)
; ------------ END OF PROGRAM ----------------
Link file
!PAS$Xfer
/Globals -4
PAS$Library
OSTraps
ToolTraps
PackTraps
keytrans
/TYPE 'APPL' 'DAV1'
/BUNDLE
/RESOURCES
Sleuth/Rsrc
$
* Sleuth.R
*
Sleuth/Rsrc.Rel
Type DAV1 = STR
,0
D. Smith & J. West
Type FREF
,128
APPL 0
Type BNDL
,128
DAV1 0
ICN#
0 128
FREF
0 128
Type MENU
* the desk acc menu
,256
\14
* the file menu
,257
Quit /Q
* the edit menu
,258
Undo /Z
(-
Cut /X
Copy /C
Paste /V
Clear
Type ICN# = GNRL
,128 (32)
.H
001F C000
0060 2000
0080 1000
011F 8800
0120 4400
0240 2200
0240 1200
0280 1200
0380 1200
0000 1200
0000 2200
0000 2400
0000 4400
0000 8800
0001 1000
0002 2000
0004 4000
0004 8000
0004 8000
0004 8000
0004 8000
0004 8000
3FFF FFFC
76DB 6DBA
B6DB 6DB9
8000 0001
BB6D B6DF
BB6D B6DF
8000 0001
B6FF FEED
76FF FEEE
3FFF FFFC
*
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF
FFFFFFFF