Question

I have recently started to learn about programming for the iPhone and after going through numerous online tutorials and books (most of which tell you to write this here without offering any explanation as to why or how stuff is working) I still have many questions unanswered and it would be great if someone could help me clarify them.

Here goes:

1) In Interface Builder, what is file’s owner, first responder, and a delegate, and where is the actual code that draws the view?

2) When using Interface Builder and you add components to the screen, I understand that Interface Builder doesn’t automatically write the code for you, but how should I handle the events fired by the different components? From a best design practice view, should each component have its events handled in a separate file? (would such file be the component’s delegate ?) or is it better to just make the viewcontroller class implement all of the interfaces of its components?

3) When creating a UITableView for example, and I define the function:

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
    return [listOfItems count];
}

I am saying that the object tableView of type UITableView has this callback function. Right? So in case I have another UITableView named MyTableView I should write a function as such:

- (NSInteger)MyTableView:(UITableView *)MyTableView numberOfRowsInSection:(NSInteger)section {
    return [listOfItems count];
}

Answer 1

There’s some big questions here and very hard to answer in a stack overflow post.

1)
A. What is the File Owner?
The nib is a file right? So what would own the nib file? Well the owner is whatever object you call initFromNib: on.

AClassName *theOwner = [[AClassName alloc] initFromNib:@"nibfile"];

A nib file is just a freeze dried object, a description of an object, a serialization of an object. The object is often freeze dried with a bunch of helper objects to it can be unfrozen and ready to go. Remind me of how Egyptian Pharaohs were buried with many of their servants and many of their possessions, they would be ready to go in the after life. The owner is the main object that has been frozen. In a frozen state (the nib file) the owner is frozen and you can’t work with it. When you unfreeze by loading the nib file the main object that’s unfrozen is the owner.

B. What is the First Responder?
When you interact with your program by touching the screen, shaking the phone, typing on the keyboard the program must respond to that event, many other frameworks call this handling the events or actions. The First Responder is the first object that gets to respond to the user’s interactions. This will typically be the NSView that the user touches, which responds by redrawing itself and sending updated information to the View’s Controller (Remember, NSView inherits from NSResponder – now you know why).

It’s in the nib file so you can override the typical behavior. The Cocoa Framework is used for the Mac too so programmers might want to have a single object handle keyboard input rather than letting each view handling the keyboard input itself. This is rarely used in iPhone programs directly, because you typically want what the user touches to respond to user interaction (redraw itself) and pass on updates. So you can usually just ignore it in the nib file.

C. What is a Delegate?
What does a person do when they delegate? They tell someone else to do this job for them and report back. People delegate all the time. I delegate fixing my car to a car mechanic. I delegate cooking dinner to the cook at a restaurant I’m dining at. “Johnson, I need you to write that TMI Report for me” said my boss delegating to me for I was company expert on TMI. Classes in the code are no different.

The delegate in the Interface Builder is the Application’s delegate. The UIApplication class is going to hand off lots responsibilities to it by sending messages to methods defined in the UIApplicationDelegate Protocol. For instance if your delegate implements the applicationDidFinishLaunching: method it’ll receive a message after the instance of UIApplication has initialized and finished its startup routine.

D. Where is the drawing code?
Apple has provided with the Framework in classes like NSView, NSWindow, NSTableView and it’s not open-source so you can’t view the source code. But the reason the window launches and appears when your first run an application built on one of Apple’s templates before adding your own code is due to what occurs in the file main.m.

int main(int argc, char *argv[]) {

    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    int retVal = UIApplicationMain(argc, argv, nil, nil);
    [pool release];
    return retVal;
}

The call UIApplicationMain(argc, argc, nil, nil) starts everything rolling. It loads in the nib file to unfreeze the UIApplication object and other objects in the nib file. Then it asks the application to start it’s main loop. Once unfrozen the UIApplication object (the nib’s owner) then tells it’s MainWindow to display on the iPhone Screen and keeps the UIApplicationDelegate in the loop about what’s going on.

Well that’s my answer to 1). Took a while to write I hope it helps. One thing that really helped my understanding was: creating a new Window-based Application project, deleting the MainWindow.nib and then attempting to recreate it from an empty nib file, so that it functions the same way.