Date FKEY
Volume Number: 9
Issue Number: 2
Column Tag: Pascal/FKEY
Related Info: Event Manager
A Date-Typing FKEY 
A one hour project
By Rob Spencer, East Lyme, Connecticut
This is a one-hour project with two goals: first, to provide a minor but useful
tidbit for everyday use, and second, to present a short example of an FKEY that posts
and modifies its own events.
For newcomers, an FKEY is a small routine that’s invoked when the user types a
command-shift-number sequence, such as the command-shift-3 FKEY that captures
the screen to a MacPaint document (under System 6) or Teach Text PICT document
(System 7). An FKEY consists of stand-alone code with no global variables and usually
little or no user interface; see Roy Lovejoy’s recent article (“FKEYs in THINK Pascal,
Easy...”, MacTutor, June 1992, p. 53-55) for more discussion.
This FKEY does something simple and useful for those of us who type letters and
memos every day: when the user types command-shift-6 (or whatever number from 0
to 9 you choose), the FKEY types the current date into the current document or edit
field. It does this by getting the date from the Toolbox and sending it to the event queue
as a sequence of keyDown events. The text appears in your document exactly as if you
had typed it.
ASSEMBLE THE EVENT
The heart of the FKEY is the SendAString routine that posts each character of its
input string as a keyDown event for the current application to catch. All that’s
necessary is to assemble the appropriate message (a longint) for each character.
The low byte of message is charCode, which is just ord(theStr[i]). The next byte
is the keyCode, which specifies which key was pressed. For most uses keyCode can be
zero, since most keyDown dispatch routines ignore the keyCode and look only at
charCode, like this:
with myEvent do begin
myChar := CHR(BitAnd(message, charCodeMask));
if BitAnd(modifiers, cmdKey) <> 0 then...
However, my testing with keyCode = 0 showed that some applications didn’t
receive the proper string, so to be safe I had to do a little more work to fill in the
correct keyCode byte.
Key codes are defined in the System’s KCHR resource, but rather than retrieve
and parse that, we use a small bit of it in a fixed look-up table string (called keyMap
in the listing). This contains the correct keyCode values for all letters, numbers, and
the comma. The space character is handled separately, rather than make keyMap too
long. Finally, keyCode is shifted to the second byte and added to charCode to produce the
correct message.
REMOVE THOSE MODIFIERS
In the first version of the FKEY I simply used PostEvent and got unexpected
results: since the user must have the command and shift keys down to invoke the FKEY,
the keyDown events that it posts come with the cmdKey and shiftKey modifier bits set.
Thus if the month is September, the first keyDown that the application sees will be
command-S, and it will promptly save the current document! What we want is the
FKEY to send the keyDowns without any modifiers; the solution is to use PPostEvent
and then clear the appropriate bits from the new event, as shown in the listing.
TESTING and DEBUGGING
As both Roy Lovejoy and the THINK Pascal demo FKEY “BlockComment” point out,
debugging an FKEY is simple. Just build a tiny program that includes the FKEY unit
and then call the obligatory FKEY entry point called main. In my program I then use
THINK’s Text window to receive the keyDown events, so we can see what day it is.
USING THE FKEY
Use ResEdit to paste the FKEY resource into the word processing application of
your choice, or, if you want the FKEY universally available, paste it into the System
file. That’s it!
BUT WAIT, THERE’S MORE!
Though FKEY’s are as old as the Mac, they aren’t widely appreciated. Perhaps
this is partly because of what I just wrote above: “Use ResEdit...”. I decided to provide
an easier way, though for the sake of brevity I’ll only mention it here: on the code disk
for this month is a HyperCard stack which does a one-button installation of the FKEY to
your System file.
Figure 1: bonus installation stack
This stack does this job with an original XFCN and XCMD. The XFCN,
SystemResources, returns a list of System resources of a given type (to see if the
FKEY already exists), while the XCMD, InstallFKEY, does the actual installation. The
stack also includes the THINK Pascal source code for these externals.
LISTINGS
unit DateFKEY;
{ Types today’s date when the user types }
{ cmd-shift-6. In THINK Pascal 4.0 by }
{ Rob Spencer, August 1992. }
interface
procedure main;
implementation
procedure main;
{ ----------------------------- }
function SendAString (theStr: str255): OSErr;
const
{ keyMap is a subset of the }
{ KCHR System resource. }
keyMap =
'ASDFHGZXCV*BQWERYT123465=97*80*OU*IP*LJ*K**,*NM';
space = char(32);
var
i, keyCode: integer;
theChar: char;
theErr: OSErr;
message, modifiers, modifierMask: longint;
myQPtr: EvQElPtr;
begin
theErr := noErr;
modifierMask := BitNot(shiftKey + cmdKey);
if theStr <> '' then
begin
FlushEvents(keyDown, 0);
for i := 1 to length(theStr) do
begin
{ Get the proper keyCode. }
theChar := theStr[i];
if theChar in ['a'..'z'] then
{ Make theChar uppercase for }
{ our look-up string. }
theChar := char(ord(theChar) - 32);
if theChar = space then
keyCode := $31
else
keyCode := pos(theChar, keyMap) - 1;
if keyCode = -1 then
keyCode := 0;
{ Assemble the message. }
message := BitShift(keyCode, 8) +
ord(theStr[i]);
{ Post the keyDown event. }
theErr := PPostEvent(keyDown, message,
myQPtr);
if theErr <> noErr then
leave;
{ Now strip off the cmdKey }
{ and shiftKey modifiers. }
modifiers := BitAnd(myQPtr^.evtQModifiers,
modifierMask);
myQPtr^.evtQModifiers := modifiers;
end;
end;
SendAString := theErr;
end;
{ ============== main ============== }
var
dateStr: str255;
tempLong: longint;
begin
{ The queue can only hold 20 characters, }
{ so we strip off the day of the week. }
GetDateTime(tempLong);
IUDateString(tempLong, LongDate, dateStr);
if dateStr <> '' then
if pos(char(32), dateStr) > 0 then
Delete(dateStr, 1, pos(char(32), dateStr));
if SendAString(dateStr) <> noErr then
SysBeep(10);
end;
end.
{ ====== shell program for debugging ===== }
program DateFKEYtest;
uses
DateFKEY;
var
myStr: str255;
begin
main; { Call our FKEY }
{ Make an active input window }
{ to receive the keyDown events. }
ShowText;
read(myStr);
writeLn;
writeLn(myStr);
end.
{ =========== end of listings =========== }
Figure 2: the project window for debugging
Figure 3: the project window for the stand-alone FKEY
Figure 4: set up for FKEY #6.