Now create an instance of your class by dragging out a CustomView placeholder and dropping it on the window (Figure 16.6).

Figure 16.6. Drop a View on the Window

Open the inspector and set the class of the view to be BigLetterView (Figure 16.7).

Figure 16.7. Set the Class of the View to BigLetterView

Select the new view, open the size info panel, and set it as shown in Figure 16.8. Now it will keep constant its distance from the upper-left corner of its superview. That is, it will grow and shrink with the superview.

Figure 16.8. Set Size Info

Really small windows will mess up your nice resizing, so open the size info panel for the window and click the Current button in the Min Size box. That will prevent the user from making the window any smaller.

Drop two text fields on the window (Figure 16.9).

Figure 16.9. Completed Interface

Now you need to create the loop of key views for your window. That is, you are setting the order in which the views will be selected as the user tabs from one element to the next. The order will be the text field on the left, the text field on the right, the BigLetterView, and then back to the text field on the left.

Set the left-hand text field's nextKeyView to be the right-hand text field (Figure 16.10).

Figure 16.10. Set nextKeyView of Left-Hand Text Field

Set the right-hand text field's nextKeyView to be the BigLetterView (Figure 16.11).

Figure 16.11. Set nextKeyView of Right-Hand Text Field

Finally, set the nextKeyView of the BigLetterView to be the left-hand text field (Figure 16.12). This will enable the user to tab between the three views. Shift-tabbing will move the selection in the opposite direction.

Figure 16.12. Set nextKeyView of the BigLetterView

Which view, then, should be the firstResponder when the window first appears? To make the BigLetterView be the initialFirstResponder of the window, drag from the window to the text field and set the initialFirst Responder outlet (Figure 16.13).

Figure 16.13. Set the initialFirstResponder of the Window

Save and close the nib file.

Your BigLetterView will have two instance variables and accessor methods for those variables. The bgColor variable will identify the background color of the view and will be an NSColor object. The string variable will hold on to the letter that the user most recently typed and will be an NSString object.

#import <Cocoa/Cocoa.h>

@interface BigLetterView : NSView
{
    NSColor *bgColor;
    NSString *string;
}

- (void)setBgColor:(NSColor *)c;
- (NSColor *)bgColor;
- (void)setString:(NSString *)c;
- (NSString *)string;

@end

The designated initializer for a view is initWithFrame:. In this method, you will call the superclass's initWithFrame: method and initialize bgColor and string to default values. Add the following method to BigLetterView.m:

- (id)initWithFrame:(NSRect)rect
{
    if (self = [super initWithFrame:rect]) {
      NSLog(@"initializing view");
      [self setBgColor:[NSColor yellowColor]];
      [self setString:@" "];
    }
    return self;
}

Create accessor methods for bgColor and string:

- (void)setBgColor:(NSColor *)c
{
    [c retain];
    [bgColor release];
    bgColor = c;
    [self setNeedsDisplay:YES];
}

- (NSColor *)bgColor
{
    return bgColor;
}
- (void)setString:(NSString *)c
{
    c = [c copy];
    [string release];
    string = c;
    NSLog(@"The string is now %@", string);
}

- (NSString *)string
{
    return string;
}

Add the following code to the drawRect: method. It will fill the view with bgColor. If the view is the window's firstResponder, it will stroke a black rectangle around its bounds to show the user that it will be the view receiving keyboard events:

- (void)drawRect:(NSRect)rect
{ 
    NSRect bounds = [self bounds];
    [bgColor set];
    [NSBezierPath fillRect:bounds];

    // Am I the window's first responder?
    if ([[self window] firstResponder] == self) {
        [[NSColor keyboardFocusIndicatorColor] set];
        [NSBezierPath setDefaultLineWidth:4.0];
        [NSBezierPath strokeRect:bounds];
    }
}

The system can optimize your drawing a bit if it knows that the view is completely opaque. Override NSView's isOpaque method.

- (BOOL)isOpaque
{
    return YES;
}

The methods to become firstResponder are as follows:

- (BOOL)acceptsFirstResponder
{
    NSLog(@"Accepting");
    return YES;
}

- (BOOL)resignFirstResponder
{
    NSLog(@"Resigning");
    [self setNeedsDisplay: YES];
    return YES;
}

- (BOOL)becomeFirstResponder{
    NSLog(@"Becoming");
    [self setNeedsDisplay: YES];
    return YES;
}

Once the view becomes the first responder, it will handle key events. For most keyDowns, the view will simply change string to be whatever the user typed. If, however, the user presses Tab or Shift-Tab, the view will ask the window to change the first responder.

NSResponder (from which NSView inherits) has a method called interpretKeyEvents:. For most key events, it just tells the view to insert the text. For events that might do something else (like Tab or Shift-Tab), it calls methods on itself.

In keyDown:, you simply call interpretKeyEvents:

- (void)keyDown:(NSEvent *)event
{
    [self interpretKeyEvents:[NSArray arrayWithObject:event]];
}

Then you need to override the methods that interpretKeyEvents: will call:

- (void)insertText:(NSString *)input
{
    // Set string to be what the user typed
    [self setString:input];
}

- (void)insertTab:(id)sender
{
    [[self window] selectKeyViewFollowingView:self];
}

- (void)insertBacktab:(id)sender
{
    [[self window] selectKeyViewPrecedingView:self];
}

Of course, you want to be a tidy programmer, so you will be sure to release your instance variables when the view is deallocated:

// release instance variables
- (void)dealloc
{
    [string release];
    [bgColor release];
    [super dealloc];
}
@end

Build and run your program. You should see that your view becomes the first responder. While it is first responder, it should take keyboard events and log them to the terminal. Also, note that you can Tab and Shift-Tab between the views (Figure 16.15).

Figure 16.15. Completed Application