Although it has no outlets, the Country class defines a number of instance variables that correspond to the fields on Travel Advisor’s user interface.

@interface Country : NSObject <NSCoding> 
{
    NSString *name;
    NSString *airports;
    NSString *airlines;
    NSString *transportation;
    NSString *hotels;
    NSString *languages;
    BOOL     englishSpoken;
    NSString *currencyName;
    float    currencyRate;
    NSString *comments;
}

Now you must declare the methods that the Country class supports. These methods fall into the following three categories:

/* Initialization and De-allocation
*/
- (id)init; 
- (void)dealloc;

/* Archiving and Unarchiving */
- (void)encodeWithCoder:(NSCoder *)coder; 
- (id)initWithCoder:(NSCoder *)coder;

/* Accessor Methods */
- (NSString *)name;
- (void)setName:(NSString *)str;

- (NSString *)airports;
- (void)setAirports:(NSString *)str;

- (NSString *)airlines;
- (void)setAirlines:(NSString *)str;

- (NSString *)transportation;
- (void)setTransportation:(NSString *)str;

- (NSString *)hotels;
- (void)setHotels:(NSString *)str;

- (NSString *)languages;
- (void)setLanguages:(NSString *)str;

- (BOOL)englishSpoken;
- (void)setEnglishSpoken:(BOOL)flag;

- (NSString *)currencyName;
- (void)setCurrencyName:(NSString *)str;

- (float)currencyRate;
- (void)setCurrencyRate:(float)val;

- (NSString *)comments;
- (void)setComments:(NSString *)str;

The init method first invokes super’s (the superclass’s) init method so that inherited instance variables will be initialized. You should always do this first in an init method. The init method also initializes the NSString instance variables to an empty string. @"" is a compiler-supported construction that creates an immutable constant NSString object from the text enclosed by the quotes. Being constants, these objects cannot be deallocated, so they do not obey the regular reference-counting technique. They do accept retain and release messages sent to them, although they are ignored, allowing these strings to be treated like regularly allocated NSStrings.

- (id)init
{
    [super init]; 

    [self setName:@""];
    [self setAirports:@""];
    [self setAirlines:@""];
    [self setTransportation:@""];
    [self setHotels:@""];
    [self setLanguages:@""];
    [self setCurrencyName:@""];
    [self setComments:@""];

    return self; 
}

You don’t need to initialize nonobject instance variables to null values (nil, zero, NULL, and so on) because the runtime system does it for you. But you should initialize instance variables that take other starting values. Also, don’t substitute nil when empty objects are expected, and vice versa. The Objective-C keyword nil represents a null “object” with an ID (value) of zero. An empty object (such as @"") is a true object; it just has no “real” content. By returning self you’re returning a true instance of your object; up until this point, the instance is considered undefined.

In this method you release objects that you’ve created, copied, or retained (that don’t have an impending autorelease). For the Country class, release all objects held as instance variables. If you had other retained objects, you would release them, and if you had dynamically allocated data, you would free it. When this method completes, the Country object is deallocated. The dealloc method should send dealloc to super as the last thing it does, so that the Country object isn’t released by its superclass before it’s had the chance to release all objects it owns.

Add the implementation of the dealloc method from Example 10.3.

- (void)dealloc
{
    [name release];
    [airports release];
    [airlines release];
    [transportation release];
    [hotels release];
    [languages release];
    [currencyName release];
    [comments release];

    [super dealloc]; 
}

For “get” accessor methods (at least when the instance variables, like Travel Advisor’s, hold immutable objects), simply return the instance variable. For accessor methods that set object values, first send autorelease to the current instance variable, then copy (or retain) the passed-in value to the variable. You’ll recall that the autorelease message causes the previously assigned object to be released at the end of the current event loop, keeping current references to the object valid until then.

If the instance variable has a nonobject value (such as an integer or float value), you don’t need to autorelease and copy; just assign the new value.

In many situations you can send retain instead of copy to keep an object around. But for value-type objects, such as NSStrings and our Country objects, copy is better.

The controller’s extractFields: method retrieves values from the application’s user interface objects and stores the values in the current Country object’s instance variables.

- (void)extractFields:(Country *)aRec
{
    [aRec setName:[countryField stringValue]];

    [aRec setAirports:[[logisticsForm 
            cellAtIndex:LGAirports] stringValue]];
    [aRec setAirlines:[[logisticsForm 
            cellAtIndex:LGAirlines] stringValue]];
    [aRec setTransportation:[[logisticsForm 
            cellAtIndex:LGTransportation] stringValue]];
    [aRec setHotels:[[logisticsForm 
            cellAtIndex:LGHotels] stringValue]];

    [aRec setCurrencyName:[currencyNameField stringValue]];
    [aRec setCurrencyRate:[currencyRateField floatValue]];
    [aRec setLanguages:[languagesField stringValue]];
    [aRec setEnglishSpoken:[englishSpokenSwitch state]];

    [aRec setComments:[commentsField string]];
}

Now that you have an implementation for extractFields:, test it. TAController’s addRecord: method is connected to the Add button on the user interface. One of the things addRecord: will need to do is get the data from the UI, so add the call to extractFields: in the implementation of addRecord: and set a breakpoint at the invocation of extractFields::

- (IBAction)addRecord:(id)sender
{
    Country *aCountry = [[Country alloc] init];

    [self extractFields:aCountry];
}

Build and debug the app, step through the code, and see if the data you enter in the UI makes it into the Country object properly. Experiment with the use of the gdb command po to print information about an object in the gdb Console pane.

The controller’s populateFields: method is the inverse of extractFields:. It takes values from the current Country object’s instance variables and displays them in the user interface.

- (void)populateFields:(Country *)aRec
{
    [countryField setStringValue:[aRec name]]; 

    [[logisticsForm cellAtIndex:LGAirports] setStringValue:
            [aRec airports]]; 
    [[logisticsForm cellAtIndex:LGAirlines] setStringValue:
            [aRec airlines]];
    [[logisticsForm cellAtIndex:LGTransportation] setStringValue:
            [aRec transportation]];
    [[logisticsForm cellAtIndex:LGHotels] setStringValue:
            [aRec hotels]];

    [currencyNameField setStringValue:[aRec currencyName]];
    [currencyRateField setFloatValue:[aRec currencyRate]];
    [languagesField setStringValue:[aRec languages]];
    [englishSpokenSwitch setState:[aRec englishSpoken]];

    [commentsLabel setStringValue:[NSString stringWithFormat:
            @"Notes and Itinerary for %@", [aRec name]]];
    [commentsField setString:[aRec comments]]; 

    [countryField selectText:self]; 
}

The first thing populateFields: does is display the name of the current country in the Country field. The value is retrieved from the name instance variable of the Country record (aRec) passed into the populateFields: method. The object returned by the expression [aRecname] is used as the argument of the setStringValue: method, which sets the text content of the receiver (in this case, the countryField object). Next, the remainder of the user interface elements are updated. Finally, the selectText: message is sent to Country field so that any text is selected, or if there is no text, the cursor is inserted into the field.

Implement TAController’s awakeFromNib method. Designate self as the data source:

- (void)awakeFromNib
{
    [countryTableView setDataSource:self];
    [countryTableView sizeLastColumnToFit];
}

The [countryTableView setDataSource:self] message identifies the TAController object as the table view’s data source. The table view will commence sending NSTableDataSource messages to TAController. (You can effect the same thing by setting the NSTableView’s dataSource outlet in Interface Builder.)

To fulfill its role as data source, TAController must implement two methods of the NSTableDataSource informal protocol: numberOfRowsInTableView: and tableView:objectValueForTableColumn:row:, as shown in Example 10.8.

- (int)numberOfRowsInTableView:(NSTableView *)theTableView { 
    return [countryKeys count];
}

- (id)tableView:(NSTableView *)theTableView 
    objectValueForTableColumn:(NSTableColumn *)theColumn
    row:(int)rowIndex
{
    if ([[theColumn identifier] isEqualToString:@"Countries"])
        return [countryKeys objectAtIndex:rowIndex];
    else
        return nil;
}

The first method returns the number of country names in the countryKeys array. The table view uses this information to determine how many rows to create.

The second method evaluates the column identifier to determine if it’s the correct column (it should always be Countries). If it is, the method returns the country name from the countryKeys array that is associated with rowIndex. This name is then displayed at rowIndex of the column. (Remember, the array and the cells of the column are synchronized in terms of their indexes.)

The NSTableDataSource informal protocol has another method, tableView:setObjectValue:forTableColumn:row:, which you won’t implement in this tutorial. This method allows the data source to extract data entered by users into table view cells; since Travel Advisor’s table view is read-only, there is no need to implement it.

If you had an application with multiple table views, each table view would invoke these NSTableView delegation methods (as well as the others). By evaluating the theTableView argument, you could distinguish which table view was involved.

Finally, you have to have the table view respond to mouse clicks in it, which indicate a request that a new record be displayed. As you recall, you defined in Interface Builder the handleTVClick: action for this purpose. This method must do a number of things:

- (IBAction)handleTVClick:(id)sender
{
    Country *aRec;
    NSString *countryName;
    int index = [sender selectedRow];

    if (index == -1) return;
    countryName = [countryKeys objectAtIndex:index];

    if (recordNeedsSaving) {
        [self addRecord:self];
        index = [countryKeys indexOfObject:countryName];
        [countryTableView selectRow:index byExtendingSelection:NO];
    }

    aRec = [countryDict objectForKey:countryName];
    [self populateFields:aRec];
}

The first thing handleTVClick: does is identify which row (and hence country) the user selected. If no row is selected, NSTableView’s selectedRow method returns -1 and handleTVClick: exits. Otherwise, the row index is used to get the country’s name.

When any Country-object data is added or altered, Travel Advisor sets the recordNeedsSaving flag to YES (you’ll learn how to do this later on). If recordNeedsSaving is YES, the code calls the addRecord: method, which will update a modified record or insert a new one, as appropriate. Because inserting a new record will alter the contents of the table, the selected row may need to be updated to highlight the correct country. To do this, the current position of the country’s name within countryKeys is obtained, using the indexOfObject: method. The corresponding row is then selected within the table view.

Finally, the country’s name is used as the key to get the associated Country instance from the dictionary. It then calls populateFields: to update the window with the country’s instance-variable values.

Users often like to have key alternatives to mouse actions such as clicking a table view. One way of acquiring a key alternative is to add a menu command in Interface Builder, specify a key as an attribute of the command, define an action method that the command will invoke, and then implement that method.

The methods nextRecord: and prevRecord: should be invoked when users choose Next or Previous from the Records menu or type the key equivalents Command-Option-N and Command-Option-P. In TAController.m, implement these methods, keeping the following hints in mind:

Implement the init and dealloc methods from Example 10.12.

- (id)init
{
    NSString *storePath = [NSHomeDirectory()
            stringByAppendingPathComponent:@"Documents/TravelData.travela"];
    [super init];

    countryDict = [NSUnarchiver unarchiveObjectWithFile:storePath];

    if (!countryDict) {
        countryDict = [[NSMutableDictionary alloc] init];
        countryKeys = [[NSMutableArray alloc] initWithCapacity:10];
    } else {
        countryDict = [[NSMutableDictionary alloc]
                initWithDictionary:countryDict];
        countryKeys = [[NSMutableArray alloc]
                initWithArray:[[countryDict allKeys]
                sortedArrayUsingSelector:
                @selector(caseInsensitiveCompare:)]];
    }

    recordNeedsSaving = NO;
    return self;
}

- (void)dealloc
{
    [countryDict release];
    [countryKeys release];
    [super dealloc];
}

The init method locates the archive file TravelData in the user’s Documents directory and returns the path to it.

The unarchiveObjectWithFile: message unarchives (that is, restores) the object whose attributes are encoded in the specified file. The object that is unarchived and returned is the NSDictionary of Country objects (countryDict).

If no NSDictionary is unarchived, the countryDict instance variable remains nil. If this is the case, TAController creates an empty countryDict dictionary and an empty countryKeys array. Otherwise, it retains the instance variable and builds the country keys array.

The [countryDict allKeys] message returns an array of keys (country names) from countryDict, the unarchived dictionary that contains Country objects as values. The sortedArrayUsingSelector: message sorts the items in this “raw” array using the caseInsensitiveCompare: method defined by the class of the objects in the array, in this case NSString (this is an example of polymorphism and dynamic binding). The sorted names go into a temporary (autoreleased) NSArray—since that is the type of the returned value—and this temporary array is used to create a mutable array, which is then assigned to countryKeys. A mutable array is necessary because users may add or delete countries.

The dealloc method releases the objects created by the init method. It then calls its superclass’s implementation of dealloc to continue the process until the object itself is freed.

When users modify data in fields of Travel Advisor, you want to mark the current record as modified so later you’ll know to save it. The Application Kit broadcasts a notification whenever text in the application is altered. To receive this notification, add TAController to the list of the notification’s observers.