First, you need to declare the MTPShowMoonFactsWindow function. Copy the following declaration to the main.c file, just after the function declaration for the Compute Travel Time command handler:

pascal void MTPShowMoonFactsWindow (WindowRef window);

You need to declare some global constants to represent the Show Facts menu command and the ID you assigned to the moon facts text box. You’ll also declare a constant to represent the text key—“Facts”—associated with the string in our Localizable.strings file. You assigned the menu command when you created the Moon menu in Chapter 7.

Put these constant declarations in the main file:

#define  kMTPShowMoonFactsCommand       'fAct'
#define  kMTPMoonFactsFieldID           131
#define  kMTPMoonFactsTextKey           "Facts"

You need to declare a window reference for the moon facts window. Modify the declaration for the main window—gMainWindow—so it includes the moon facts window:

WindowRef       gMainWindow,
                gMoonFactsWindow;

You need to add code to the main function so it constructs the interface from the main.nib file you modified in Interface Builder. Copy the following statement to the main function in the main.c file, after the statements that create the main window:

// Create the Facts for the Traveler window err = CreateWindowFromNib (nibRef, CFSTR("MoonFacts"),
                                    &gMoonFactsWindow);
require_noerr (err, CantCreateWindow);

The function MTPShowMoonFactsWindow does the following:

Copy the function in Example 8.2 to the main program, after the function MTPComputeCommandHandler.

pascal void MTPShowMoonFactsWindow (WindowRef window)
{
   CFStringRef      text;
   ControlHandle    moonFactsBox;
   ControlID        moonFactsControlID = {kMTPApplicationSignature, 
                                          kMTPMoonFactsFieldID };
        
   GetControlByID (window, &moonFactsControlID, &moonFactsBox);             //1
   ShowWindow (window);                                                     //2
   SelectWindow (window);
   text = CFCopyLocalizedString (CFSTR(kMTPMoonFactsTextKey),
                                    NULL);                                  //3
   SetControlData (moonFactsBox, 0, kControlEditTextCFStringTag, 
                                sizeof (CFStringRef),
                                &text);                                     //4
   CFRelease (text);                                                        //5
   DrawOneControl (moonFactsBox);                                           //6
 }

Here’s what the function does:

The three events we identified fall into two type of events: command events (setting up and printing the page) and window events (closing the window).

Command events are in the command event class (kEventClassCommand). The specific kind of event in which your application is interested is a process command (kEventProcessCommand). In particular, your handler must take care of the Print and Page Setup commands you added in Chapter 7.

A window close event is in the window event class (kEventClassWindow). The specific kind of event you need to handle is a close event (kEventWindowClose).

You need to declare an event type specification for the two events. As you recall from Chapter 6 an event type is made up of an event class and event kind. You can declare the event type specification by copying the following to the main function, after the EventTypeSpec declaration for mainSpec:

EventTypeSpec  moonSpec[] = {{kEventClassCommand, kEventCommandProcess},
                            {kEventClassWindow, kEventWindowClose}};

The handler for the moon facts window must first check to see which kind of event (window close or process command) it has been given by the Carbon Event Manager. If the kind is a process command event, the handler then needs to check the specific command to see whether it’s Print (pRnt), Page Setup (pGsu), or neither one. If it’s neither, the event gets passed back to the Carbon Event Manager. If it’s Print or Page Setup, the application must call the appropriate function. You’ll write functions that implement setup and printing in Chapter 9.

Before you write the handler, declare it by copying the following to the main.c file, just after the function declaration for the main window event handler:

pascal OSStatus MTPMoonFactsWindowEventHandler (
                                EventHandlerCallRef myHandler,
                                EventRef event, void *userData);

Notice it conforms to the prototype specified in Chapter 6.

You need to declare global constants for the commands you set up in Interface Builder. These are the commands you assigned to the Close, Print, and Page Setup menu commands. Copy the following into the main.c file, just after the constants you’ve already defined for the command IDs:

#define kMTPCloseCommand        'cLse'
#define kMTPPrintCommand        'pRnt'
#define kMTPPageSetupCommand    'pGsu'

Now you can add the handler. Copy the function in Example 8.3 into the main program, after the function MainWindowEventHandler. Make sure you comment out the functions MTPDoPrint and MTPDoPageSetup. You haven’t written those yet, so to build, run, and test the code, you’ll need to have them commented out. You can uncomment them once you’ve added those functions in the next chapter.

pascal OSStatus MTPMoonFactsWindowEventHandler (
                        EventHandlerCallRef myHandler,
                        EventRef event, void *userData)
{
    OSStatus        result = eventNotHandledErr;
    UInt32          eventKind;
    HICommand       command;
    eventKind = GetEventKind (event);                                  // 1
    switch (eventKind) 
    {
        case kEventWindowClose:                                        // 2
            HideWindow ( (WindowRef) userData);                        // 3
            result =  noErr;
            break;
        case kEventCommandProcess:                                     // 4
            GetEventParameter (event, kEventParamDirectObject,
                    typeHICommand, NULL, sizeof (HICommand), NULL,
                    &command);                                         // 5
             switch (command.commandID)
             {
                case kMTPCloseCommand:                                 // 6
                    HideWindow ( (WindowRef) userData);
                    result = noErr;
                    break;
                case kMTPPrintCommand:
            //      MTPDoPrint (gMoonFactsWindow);                     // 7
                    result = noErr;
                    break;
                case kMTPPageSetupCommand:
            //      MTPDoPageSetup (gMoonFactsWindow);                 // 8
                    result = noErr;
                    break;
            }
        }
   return result;
}

Here’s what the function does:

Just as you did for the main window event handler in Chapter 6 you use the Carbon Event Manager function InstallWindowEventHandler to register the moon facts window event handler. Add the following code to the main function, after the line in which you installed the main window event handler:

InstallWindowEventHandler (gMoonFactsWindow,
            NewEventHandlerUPP (MTPMoonFactsWindowEventHandler),
            2, moonSpec, (void *) gMoonFactsWindow, NULL);

These are the parameters to the function InstallWindowEventHandler: