If you look back to Chapter 1 of this minibook, you can see that the Utility Application template supplies the following code in DeepThoughtsAppDelegate.h:

@class MainViewController;
@interface DeepThoughtsAppDelegate : NSObject
   <UIApplicationDelegate> {
    UIWindow *window;
    MainViewController *mainViewController;
}

Figure 2-2. The MainView. xib file's Main view in Interface Builder.

Figure 2-3. The MainView. xib File's Owner.

This sets up the UIApplicationDelegate protocol with window. The template also declares an accessor method for window and tags it with an IBOutlet so that Interface Builder can discover it, while also declaring an accessor method for mainViewController:

@property (nonatomic, retain) IBOutlet UIWindow *window;
@property (nonatomic, retain) MainViewController
   *mainViewController;

In the file DeepThoughtsAppDelegate.m, when the application has finished launching, the code implements the appropriate method from the UIApplicationDelegate protocol:

@implementation DeepThoughtsAppDelegate
@synthesize window;
@synthesize mainViewController;

- (void)applicationDidFinishLaunching:(UIApplication *)
   application {

   MainViewController *aController = [[MainViewController
   alloc] initWithNibName:@"MainView" bundle:nil];
   self.mainViewController = aController;
   [aController release];
     mainViewController.view.frame = [UIScreen mainScreen].
   applicationFrame;
   [window addSubview:[mainViewController view]];
[window makeKeyAndVisible];
}

The MainView view controller is initialized, and addSubView adds this view to window in order to display the Main view. Calling makeKeyAndVisible on window makes it visible as well as making it the first responder for events (touches).

In MainViewController.h, you find this:

@interface MainViewController : UIViewController
   <FlipsideViewControllerDelegate> {
}

This tells you that MainViewController is a subclass of UIViewController. The UIViewController class provides the fundamental view-management model for iPhone apps. You use each instance of UIViewController to manage a full-screen view. Because the amount of available screen space is limited, user interfaces must be divided into one or more screen's worth of information. The views used to present each distinct screen are then managed by one of your UIViewController subclasses (such as MainViewController).

In MainViewController.m near the top, you find the code that sets up Main View initialization:

@implementation MainViewController
- (id)initWithNibName:(NSString *)nibNameOrNil
   bundle:(NSBundle *)nibBundleOrNil {
    if (self = [super initWithNibName:nibNameOrNil
   bundle:nibBundleOrNil]) {
        // Custom initialization
   }
   return self;
}

The MainViewController object is created by a nib file directly passed on to UIViewController to handle the initialization. (You can add custom initialization at the point where the // comment appears.)

Now look in MainView.h, and you find the following statement:

@interface MainView : UIView {
}

This statement declares MainView to be a subclass of UIView, which is an abstract superclass that provides concrete subclasses with a structure for drawing and handling events. The UIView class provides common methods you use to create all types of views and access their properties. For example, unless a subclass has its own designated initializer, you use the initWithFrame: method to create a view. So, in MainView.m, you find this code:

@implementation MainView
- (id)initWithFrame:(CGRect)frame {

if (self = [super initWithFrame:frame]) {
        // Initialization code
    }
    return self;
}
- (void)drawRect:(CGRect)rect {
    // Drawing code
}

The Main view is initialized by passing a CGRect — which defines a rectangular frame that sets the size of the view.

The return type is id because it returns the MainView object. The CGRect frame is then passed to UIView to be initialized. If the UIView initialization works, it returns a non-null pointer to an UIView in self.

As you see in Chapter 3 of this minibook, you can add code to MainViewController.h and MainViewController.m to control the Main view.

As you may recall from Chapter 1 of this minibook, the showInfo method in MainViewController.m initializes the Flipside view with the initWithNibName:bundle: method when the user touches the i information button.

First, take another look at MainViewController.h:

@interface MainViewController : UIViewController
   <FlipsideViewControllerDelegate> {
}
- (IBAction)showInfo;

This tells you that MainViewController is adopting the FlipsideViewControllerDelegate formal protocol of UIViewController (put in angle brackets). What does it plan to do with it?

Take a look further down in MainViewController.m, and you find this:

- (void)flipsideViewControllerDidFinish:(FlipsideViewControl
   ler *)controller {
   [self dismissModalViewControllerAnimated:YES];

}
- (IBAction)showInfo {
   FlipsideViewController *controller
   = [[FlipsideViewController alloc] initWithNibName:@"FlipsideView" bundle:nil];
   controller.delegate = self;
   controller.modalTransitionStyle =
   UIModalTransitionStyleFlipHorizontal;
   [self presentModalViewController:controller animated:YES];
   [controller release];
}

This initializes the Flipside View nib file (FlipsideView.xib) when showInfo is activated. While doing so, it also sets the controller.modalTransitionStyle to UIModalTransitionStyleFlipHorizontal for the slick animated flip transition when opening the Flipside view.

In FlipSideViewController.h, the UIViewController protocol FlipsideViewControllerDelegate is used:

@protocol FlipsideViewControllerDelegate;
@interface FlipsideViewController : UIViewController {
   id <FlipsideViewControllerDelegate> delegate;
}
@property (nonatomic, assign) id
   <FlipsideViewControllerDelegate> delegate;
- (IBAction)done;
@end
@protocol FlipsideViewControllerDelegate
- (void)flipsideViewControllerDidFinish:(FlipsideViewControl
   ler *)controller;
@end

In FlipSideViewController.m, the class doesn't use an initialization method like MainViewController.m. Instead, it uses a method called viewDidLoad, which is most commonly used to perform additional initialization steps on views that are loaded from nib files:

@implementation FlipsideViewController
@synthesize delegate;
- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor
    viewFlipsideBackgroundColor];
}
- (IBAction)done {
   [self.delegate flipsideViewControllerDidFinish:self];
}

This method is implemented in UIViewController — the code overrides it in order to change something after the view has been loaded from a nib (the background color).

In FlipsideView.h, you find the following statement:

@interface FlipsideView: UIView {
}

This statement declares FlipsideView to be a subclass of UIView. And in FlipsideView.m, you find this code:

@implementation FlipsideView
- (id)initWithFrame:(CGRect)frame {
    if (self = [super initWithFrame:frame]) {
        // Initialization code
    }
    return self;
}
- (void)drawRect:(CGRect)rect {
    // Drawing code
}

The view is initialized the same way as the Main view — by passing a CGRect defining a rectangular frame. The return type is id since it returns the FlipsideView object.

As you see in Chapter 4 of this minibook, you can add code to FlipsideViewController.h and FlipsideViewController.m to control the Flipside view.

To find out more about the Info button in the Main view, Control-click (or right-click if you have a two-button pointing device) the Info button, as Figure 2-7 demonstrates, to see the button's possible events. The one highlighted is the button's actual event.

Figure 2-7. The Info button's event is highlighted.

Tip

To see these events clearly, click the center View Mode button at the top of the MainView.xib window to show the window in hierarchical navigation view mode, and then click the triangle next to Main View to reveal its contents. You should see Light Info Button under Main View, as shown in Figure 2-8. Select Light Info Button to see the button attributes in the Inspector window, and click the Connections tab in the Inspector window (or choose Tools

Figure 2-8. The Info button reacts to a Touch Up Inside event.

The Info button reacts to a Touch Up Inside event — which occurs when the button is touched and then released, symbolizing a click. When that happens, it invokes showinfo in MainViewController — see Listing 2-1 and 2-2 (code for showinfo in bold).

#import "FlipsideViewController.h"
@interface MainViewController : UIViewController
   <FlipsideViewControllerDelegate> {
}
- (IBAction)showInfo;
@end

#import "MainViewController.h"
#import "MainView.h"

@implementation MainViewController
- (id)initWithNibName:(NSString *)nibNameOrNil
   bundle:(NSBundle *)nibBundleOrNil {
    if (self = [super initWithNibName:nibNameOrNil
   bundle:nibBundleOrNil]) {
        // Custom initialization
    }
    return self;
}
/*
 // Implement viewDidLoad to do additional setup after
   loading the view, typically from a nib.
 - (void)viewDidLoad {
 [super viewDidLoad];
 }
 */

/*
 // Override to allow orientations other than the default
   portrait orientation.
 - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceO
   rientation)interfaceOrientation {
 // Return YES for supported orientations
 return (interfaceOrientation ==
   UIInterfaceOrientationPortrait);
 }
 */
- (void)flipsideViewControllerDidFinish:(FlipsideViewControl
   ler *)controller {

   [self dismissModalViewControllerAnimated:YES];

}
- (IBAction)showInfo {

   FlipsideViewController *controller
   = [[FlipsideViewController alloc]
   initWithNibName:@"FlipsideView" bundle:nil];
   controller.delegate = self;

   controller.modalTransitionStyle =
   UIModalTransitionStyleFlipHorizontal;
   [self presentModalViewController:controller animated:YES];

   [controller release];

}
/*
 // Override to allow orientations other than the default
    portrait orientation.
 - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceO
   rientation)interfaceOrientation {
 // Return YES for supported orientations
 return (interfaceOrientation ==
   UIInterfaceOrientationPortrait);
 }
 */

- (void)didReceiveMemoryWarning {
   // Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];

   // Release any cached data, images, etc that aren't in
   use.
}
- (void)viewDidUnload {
   // Release any retained subviews of the main view.
   // e.g. self.myOutlet = nil;
}
- (void)dealloc {
    [super dealloc];
}
@end

To see how the Done button in the Flipside view works, double-click the FlipsideView.xib file (in Resource) to launch Interface Builder. In the Flipside View window, select the Done button in the upper-left corner and then click the Attributes tab in the Inspector window or choose Tools

To see what's really going on, click the center View Mode button at the top of the FlipsideView.xib window to show it in hierarchical navigation view mode, and then click the triangle next to FlipsideView to reveal its contents. As shown in Figure 2-9, Navigation Bar appears first; click its triangle to reveal Navigation Item (Title), and click its triangle to reveal (finally!) the Bar Button Item (Done). The template has embedded the Bar Button Item (Done) object within the Navigation Item (title), which is embedded in the Navigation Bar.

The Navigation Bar's class is UINavigationBar, of course. The UINavigationBar class implements a control for navigating hierarchical content. It's a bar at the top of the screen that can offer buttons for navigating up and down a hierarchy. The primary properties are a left (back) button, a center title, and an optional right button. You use a navigation item (an instance of the UINavigationItem class) to specify what buttons or custom views you want displayed in the bar. A navigation bar manages a stack of UINavigationItem objects such as the Navigation Item (Title) (UINavigationItem) and the Bar Button Item (Done) (UIBarButtonItem).

Select Bar Button Item (Done) to see the button attributes in the Inspector window, and click the Connections tab in the Inspector window (or choose Tools

In Sent Actions, "done" is connected to the File's Owner (in this case, FlipsideViewController). You can see how this is set up in Listing 2-3 and 2-4.

Figure 2-9. The Bar Button Item (Done) is connected to the File's Owner.

@protocol FlipsideViewControllerDelegate;

@interface FlipsideViewController : UIViewController {
   id <FlipsideViewControllerDelegate> delegate;
}
@property (nonatomic, assign) id
   <FlipsideViewControllerDelegate> delegate;
- (IBAction)done;
@end

@protocol FlipsideViewControllerDelegate
- (void)flipsideViewControllerDidFinish:(FlipsideViewControl
   ler *)controller;
@end

#import "FlipsideViewController.h"

@implementation FlipsideViewController
@synthesize delegate;

- (void)viewDidLoad {
    [super viewDidLoad];
    self.view.backgroundColor = [UIColor
   viewFlipsideBackgroundColor];
}
- (IBAction)done {
   [self.delegate flipsideViewControllerDidFinish:self];
}
/*
 // Override to allow orientations other than the default
   portrait orientation.
 - (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceO
   rientation)interfaceOrientation {
 // Return YES for supported orientations
 return (interfaceOrientation ==
   UIInterfaceOrientationPortrait);
 }
 */
- (void)didReceiveMemoryWarning {
   // Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];

   // Release any cached data, images, etc that aren't in
   use.
}

- (void)viewDidUnload {
   // Release any retained subviews of the main view.
   // e.g. self.myOutlet = nil;
}
- (void)dealloc {
    [super dealloc];
}
@end

The code in FlipsideViewController.h (Listing 2-3) declares the delegate for the FlipsideViewController and adds it as a property. The code in FlipsideViewController.m (Listing 2-4) uses the delegate object to intercept the "done" message.