Now you have a navigation controller, a navigation bar, and two view controllers. Time to put all the pieces together. The user should be able to tap a row in ItemsViewController’s table view and have the ItemDetailViewController’s view slide onto the screen and display the properties of the selected Possession instance.
Of course, you need to create an instance of ItemDetailViewController. Where should this object be created? Think back to previous exercises where you instantiated all of your controllers in the method application:didFinishLaunchingWithOptions:. For example, in the Chapter 7 chapter, you created both view controllers and immediately added them to tab bar controller’s viewControllers array.
However, when using a UINavigationController, you cannot simply store all of the possible view controllers in its stack. The viewControllers array of a navigation controller is dynamic – you start with a root view controller and add view controllers depending on user input. Therefore, some object other than the navigation controller needs to create the instance of ItemDetailViewController and be responsible for adding it to the stack.
This object must meet two requirements: it needs to know when to push ItemDetailViewController onto the stack, and it needs a pointer to the navigation controller. Why must this object have a pointer to the navigation controller? If it is to dynamically add view controllers to the navigation controller’s stack, it must be able to send the navigation controller messages, namely, pushViewController:animated:.
ItemsViewController fills both requirements. First, it knows when a row is tapped in a table view because, as the table view’s delegate, it receives the message tableView:didSelectRowAtIndexPath:. Second, any view controller in a navigation controller’s stack can get a pointer to the navigation controller by sending itself the message navigationController. As the root view controller, ItemsViewController is always in the navigation controller’s stack and thus can always access it. Therefore, ItemsViewController will be responsible for creating the instance of ItemDetailViewController and adding it to the stack.
At the top of ItemsViewController.h, import the interface file for ItemDetailViewController.
#import "ItemDetailViewController.h" @interface ItemsViewController : UITableViewController
When a row is tapped, its delegate is sent tableView:didSelectRowAtIndexPath:, which contains the index path of the selected row. In ItemsViewController.m, implement this method to allocate a ItemDetailViewController and then push it on top of the navigation controller’s stack.
@implementation ItemsViewController
- (void)tableView:(UITableView *)aTableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
ItemDetailViewController *detailViewController =
[[[ItemDetailViewController alloc] init] autorelease];
// Push it onto the top of the navigation controller's stack
[[self navigationController] pushViewController:detailViewController
animated:YES];
}
Build and run the application. Select a row from the UITableView. Not only will you be taken to ItemDetailViewController’s view, but you will get a free animation and a button in the UINavigationBar titled Homepwner. Tapping this button will take you back to ItemsViewController.
Also, notice that the instance of ItemDetailViewController is autoreleased after it is instantiated. The UINavigationController will retain it and then release it when it is popped from the stack. Therefore, when the user taps the back button, the ItemDetailViewController will be deallocated. This is why you implemented the dealloc method for ItemDetailViewController – instances of this class definitely get destroyed while this application is running.
Having a view controller push the next view controller is a common pattern. In any application with a UINavigationController, the navigation controller has one root view controller. The root view controller typically creates the next view controller, and the next view controller creates the one after that, and so on. Some applications may have view controllers that can push different view controllers depending on user input. For example, the Photos will push a video view controller or an image view controller onto the navigation stack depending on what type of media was selected.
(The iPad-only class UISplitViewController calls for a different pattern. The iPad’s larger screen size allows two view controllers in a drill-down interface to appear on screen simultaneously instead of being pushed onto the same stack. You’ll learn more about UISplitViewController in Chapter 26.)
Of course, the UITextFields on the screen are currently empty. To fill these fields, you need a way to pass data between the ItemsViewController and the ItemDetailViewController. How do you pass data between UIViewControllers?
What you’re going to do is implement a method in ItemDetailViewController that accepts a Possession instance and fills the contents of its UITextFields. ItemsViewController will select the appropriate possession from its array and pass it through that method to the ItemDetailViewController.
In ItemDetailViewController.h, add an instance variable to hold the Possession that is being edited and declare a method to set that instance variable. The class declaration should now look like this:
#import <UIKit/UIKit.h>
@class Possession;
@interface ItemDetailViewController : UIViewController
{
IBOutlet UITextField *nameField;
IBOutlet UITextField *serialNumberField;
IBOutlet UITextField *valueField;
IBOutlet UILabel *dateLabel;
Possession *possession;
}
@property (nonatomic, retain) Possession *possession;
@end
In ItemDetailViewController.m, synthesize the accessors for possession and import Possession’s header file.
#import "Possession.h" @implementation ItemDetailViewController @synthesize possession;
Since an instance of ItemDetailViewController will retain its possession, this instance variable must be released when the view controller is deallocated. An instance of ItemDetailViewController will be deallocated when the user goes back to the ItemsViewController. That user action removes the ItemDetailViewController from the stack, which causes the navigation controller, its only owner, to release it. In ItemDetailViewController.m, add this to the dealloc method.
- (void)dealloc
{
[possession release];
[nameField release];
[serialNumberField release];
[valueField release];
[dateLabel release];
[super dealloc];
}
When the ItemDetailViewController’s view appears on the screen, it needs to set the values of its subviews to match the properties of the possession. Override viewWillAppear: in ItemDetailViewController.m to transfer the possession’s properties to the various UITextFields.
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
[nameField setText:[possession possessionName]];
[serialNumberField setText:[possession serialNumber]];
[valueField setText:[NSString stringWithFormat:@"%d",
[possession valueInDollars]]];
// Create a NSDateFormatter that will turn a date into a simple date string
NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init]
autorelease];
[dateFormatter setDateStyle:NSDateFormatterMediumStyle];
[dateFormatter setTimeStyle:NSDateFormatterNoStyle];
// Use filtered NSDate object to set dateLabel contents
[dateLabel setText:
[dateFormatter stringFromDate:[possession dateCreated]]];
// Change the navigation item to display name of possession
[[self navigationItem] setTitle:[possession possessionName]];
}
Now you must invoke this method when the ItemDetailViewController is being pushed onto the navigation stack. In ItemsViewController.m, add the following line of code to tableView:didSelectRowAtIndexPath:.
- (void)tableView:(UITableView *)aTableView
didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
ItemDetailViewController *detailViewController =
[[[ItemDetailViewController alloc] init] autorelease];
NSArray *possessions = [[PossessionStore defaultStore] allPossessions];
// Give detail view controller a pointer to the possession object in row
[detailViewController setPossession:
[possessions objectAtIndex:[indexPath row]]];
[[self navigationController] pushViewController:detailViewController
animated:YES];
}
Many programmers new to iOS struggle with how data is passed between UIViewControllers. The technique you just implemented, having all of the data in the root view controller and passing subsets of that data to the next UIViewController, is a clean and efficient way of performing this task.
Build and run your application. Select one of the rows in the UITableView, and the view that appears will contain the information for the Possession in that row. While you can edit this data, the UITableView won’t have changed when you return to it. To fix this problem, you need to implement code to update the properties of the Possession being edited. Next, we’ll look at when to do this.
Whenever a UINavigationController is about to swap views, it sends out two messages: viewWillDisappear: and viewWillAppear:. The UIViewController that is about to be popped off the stack is sent the message viewWillDisappear:. The UIViewController that will then be on top of the stack is sent viewWillAppear:.
When ItemDetailViewController is popped off the stack, you will set the properties of the possession to the values in the UITextFields. When implementing these methods for views appearing and disappearing, it is important to call the superclass’s implementation – it has some work to do as well. In ItemDetailViewController.m, implement viewWillDisappear:.
- (void)viewWillDisappear:(BOOL)animated
{
[super viewWillDisappear:animated];
// Clear first responder
[[self view] endEditing:YES];
// "Save" changes to possession
[possession setPossessionName:[nameField text]];
[possession setSerialNumber:[serialNumberField text]];
[possession setValueInDollars:[[valueField text] intValue]];
}
Notice the use of endEditing:. When the message endEditing: is sent to a view, if it or any of its subviews are currently the first responder, it will resign its first responder status, and the keyboard will be dismissed. (The argument passed determines whether the first responder is forced into retirement. Some first responders might refuse to resign, and passing YES ignores that refusal.)
Now the values of the Possession will be updated when the user taps the Homepwner back button on the UINavigationBar. When ItemsViewController appears back on the screen, it is sent the message viewWillAppear:. Take this opportunity to reload its UITableView so the user can immediately see the changes. In ItemsViewController.m, override viewWillAppear:.
- (void)viewWillAppear:(BOOL)animated
{
[super viewWillAppear:animated];
[[self tableView] reloadData];
}
Build and run your application now. Now you can move back and forth between the UIViewControllers you created and change the data with ease.