ADVERTISEMENT

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.