In this section, we’ll implement methods in the CalcWindow class that will search for NSButton object single-character titles such as “2” and “+” and will build a corresponding NSMutableDictionary object, as described earlier.

The new keyTable instance variable will point to the NSMutableDictionary object we’ll create later. We’ll use the four new methods (findButtons, etc.) to search the Calculator window for all of the buttons, as described in Table 8-3.

Now we’ll describe the implementations of each of these CalcWindow methods in detail. CalcWindow’s new findButtons method simply removes all of the objects from the NSMutableDictionary object (keyTable) and then invokes the checkView: method for the Calculator window’s content view to set up the NSMutableDictionary.

                     - (void)findButtons
                     {
                       // Check all the views recursively
                       [keyTable removeAllObjects];
                       [self checkView:[self contentView] ];
                     }

The checkView: method is more interesting than findButtons. It can be invoked with any NSView object in the window as its argument, and it checks to see whether the NSView is of the NSMatrix class, the NSButton class, or neither. (An NSView object is any object that belongs to a subclass or descendant class of NSView.) If the NSView is of the NSMatrix or NSButton class, checkView: invokes the checkMatrix: method or the checkButton: method (respectively). Otherwise, checkView: gets the list of subviews for the NSView passed and invokes itself recursively for each one (yes, methods can invoke themselves recursively). In this manner, all of the NSViews in the window are processed. We need separate methods to check the NSMatrix and NSButton objects because the cells (i.e., NSCell objects) stored inside these objects are not subviews (cells are not views).

The following code shows CalcWindow’s new checkView: method:

                     - (void)checkView:(NSView *)aView
                     {
                         id view;
                         NSEnumerator *enumerator;
                         // Log which aView is being processed; see PB for output
                         NSLog(@"checkView(%@)
",aView);
                         // Process the aView if it's an NSMatrix
                         if ([aView isKindOfClass: [NSMatrix class] ]) {
                             [self checkMatrix: aView];
                             return;
                         }
                         // Process the aView if it's an NSButton
                         if ([aView isKindOfClass: [NSButton class] ]) {
                             [self checkButton: aView];
                             return;
                         }
                         // Recursively check all the subviews in the window
                         enumerator = [ [aView subviews] objectEnumerator];
                         while (view = [enumerator nextObject]) {
                             [self checkView:view];
                         }
                     }

This checkView: method sends the isKindOfClass: message to the aView argument object to determine its class (NSMatrix, NSButton, or other). If the aView object is of the NSMatrix class, the checkMatrix: method is invoked. If the aView object is of the NSButton class, the checkButton: method is invoked. If aView is neither an NSMatrix nor an NSButton object, the checkView: method recursively invokes itself for all of the subviews contained within the NSView. Actually, the objects that are passed to checkView: are instances of subclasses of the NSView class, not instances of NSView itself. However, because they inherit from the NSView class, we still refer to them as “views.”

CalcWindow’s checkButton: method, shown in the following example, checks a button to see if its title is a single character. If it is, the button is stored in the keyTable object (an NSMutableDictionary object that we’ll create when the CalcWindow object is initialized, as we’ll see a bit later).

                     - (void)checkButton:(NSButton *)aButton
                     {
                        NSString *title = [aButton title];
                        // Check for a cell with a title exactly one character long.
                        // Put both uppercase and lowercase strings into the dictionary.
                        // The "c" key on the keyboard will clear, not display a hex "c".
                         if ([title length]==1 && [aButton tag] != 0x0c ) {
                           [keyTable setObject:aButton forKey:[title uppercaseString]];
                           [keyTable setObject:aButton forKey:[title lowercaseString]];
                         }
                     }

This method uses the NSMutableDictionary instance method setObject:forKey: to insert the button’s id, namely aButton, into the dictionary object. The key is an NSString with the single-character title of the button.

CalcWindow’s checkMatrix: method now checks all of the NSButton objects in an NSMatrix. NSMatrix objects must be checked separately, because the NSButtons that they contain are not subviews of the NSMatrix. This was originally done for performance reasons.^[26] The fact that NSCell objects are not views complicates our task, but not significantly.

                     - (void)checkMatrix:(NSMatrix *)aMatrix
                     {
                         id button;
                         NSEnumerator *enumerator;
                         enumerator = [[aMatrix cells] objectEnumerator];
                         while (button = [enumerator nextObject]) {
                             [self checkButton: button];
                         }
                     }

This method first gets the list of cells (NSButtonCells, in our example) that are contained in the NSMatrix, then invokes the checkButton: method for each of them.

Now we have the four methods that we need to set up the NSMutableDictionary object with key-value pairs.

The CalcWindow class requires two additional methods in order to work properly. The first (keyDown:) is the method that actually handles the key-down events. The other is the method that initializes the NSMutableDictionary object.

                     - (void)keyDown:(NSEvent *)theEvent 
                     {
                     
    id button;
                     
    button = [keyTable objectForKey: [theEvent characters] ];
                     
    if (button) {
                             [button performClick:self];
                         }
                         else {
                             [super keyDown:theEvent];
                         }
                     }

This keyDown: method will be invoked only when a keyboard event is not otherwise handled by an object in the NSResponder chain. It sends the objectForKey: message to the NSMutableDictionary object (keyTable) to obtain the id for the NSButton whose title is the same as the keyboard character ([theEvent characters]) that was typed.

If no such NSMutableDictionary key exists, objectForKey: returns nil and keyDown: passes the original message to its superclass to handle the event. If the key does exist, the keyDown: method sends the performClick: message to the NSButton whose id is stored for the key. The performClick: message causes the NSButton target object to perform as if it had been clicked. The message is not sent if the on-screen button is disabled.

Finally, we need to set up an initialization method — the method that is automatically invoked when the CalcWindow object is created and sets up the NSMutableDictionary object.

We typically create initialization methods in our subclasses by overriding one of the parent’s initialization methods. There are two NSWindow initialization methods to choose from for CalcWindow. If you look in the NSWindow.h header file in PB, you’ll find the declarations of these two initialization methods:

- (id)initWithContentRect:(NSRect)contentRect 
                     styleMask:(unsigned int)aStyle
                     backing:(NSBackingStoreType)bufferingType 
                    defer:(BOOL)flag;

- (id)initWithContentRect:(NSRect)contentRect 
                     styleMask:(unsigned int)aStyle
                     backing:(NSBackingStoreType)bufferingType 
                    defer:(BOOL)flag
                     screen:(NSScreen *)screen;

One of these methods is the designated initializer of the NSWindow class. The designated initializer is the one and only initialization method for a class that is guaranteed to be invoked by all of the other initialization methods of that same class. Thus, if you subclass a class, you need only write a method for the designated initializer method to catch all initialization events.

But which method is the designated initializer? The only way to find out is to read the documentation. The designated initializer is typically the method that has the most arguments, but the NSWindow class is different. Its designated initializer is the first (shorter) method listed. That’s because the initWithContentRect:styleMask:backing:defer: method was designated as the designated initializer before NeXTSTEP supported multiple screens (note the one additional screen: argument in the last initialization method). It has thus been left as the designated initializer for historical reasons.

We discussed the initWithContentRect:styleMask:backing:defer: method in detail in Section 4.3.1. Next, we override this method to create and initialize the CalcWindow, which is like a normal window except that it has an NSMutableDictionary that must be allocated. We also override the dealloc method to release the keyTable that we created to prevent a memory leak:^[27]

                     - (id)initWithContentRect:(NSRect)contentRect
                           styleMask:(unsigned int)aStyle
                           backing:(NSBackingStoreType)bufferingType
                           defer:(BOOL)flag
                     {
                         keyTable = [ [NSMutableDictionary alloc] init];
                         [self setInitialFirstResponder:self];
                         return [super initWithContentRect:contentRect
                                 styleMask:aStyle
                                 backing:bufferingType
                                 defer:flag];
                     }
                     - (void)dealloc
                     {
                         [keyTable release];
                         [super dealloc];
                     }

Our designated initializer method creates and initializes an NSMutableDictionary object (keyTable). The method then specifies that the CalcWindow object itself will be its own initialFirstResponder (this is necessary so that the CalcWindow object will receive the keypresses). Finally, it forwards the initialization message to its superclass (NSWindow) to actually do the rest of the work of initializing the CalcWindow object. This initWithContentRect:styleMask:backing:defer: method is invoked automatically whenever an instance of the CalcWindow class is created.^[28]

The dealloc method is called when the window is destroyed. It releases the keyTable. In practice, the CalcWindow’s dealloc method may never be called, because the window is destroyed when the application exits. We have included the dealloc method because it is good programming practice to write the code that releases the memory that you have allocated. Otherwise, you are likely to get sloppy, and other programs that you write will inadvertently have memory leaks in them.

Now it’s time to put all this code into the CalcWindow.m file.