A Window in Two Parts

Double-click MainMenu.xib in the Xcode project to open it in an Interface Builder pane. This brings up the standard empty application nib we’ve used previously. Select the NSWindow instance in the main nib window, and use the resizing control to make it taller (about twice as tall as it started out). We’ll need this space because we’re going to put two sets of views in here, one for the Show entity and one for the Quote entity.

Showing Shows

We’ll start with a view for the Show. Drag out an NSTableView from the Object Library and position it near the top of the window. Resize it to take up most of the space. Don’t worry about the blue guidelines this time; in fact, make it a bit smaller than the guidelines would suggest. We’re going to group it into a box with some other controls, so the sizing isn’t critical yet. Open up the Attributes Inspector, and make the table view view-based with one column. Resize the column itself to take up the width of the table view, and set the column’s name to “Name.” Drag out a button and position it below the lower-right-hand corner of the table view, and label it “Add.” Drag out another button of the same time and position it to the left of the Add button, and label that one “Remove.” Select all three of those controls, and group them into a Box (select Editor Embed In Box). Set the title of the Box to be “Show.” Now we can adjust the size of the Box relative to the window, and then adjust the table view inside the Box to get a pleasing arrangement.

Now that we’ve got a place to list the shows, we need to connect them to the core data model, and we’ll use Cocoa bindings and an NSArrayController as the glue. Drag out an Array Controller from the Object Library, and title it “Shows.” In the Attribute Inspector, set the Mode to be “Entity Name” in the pop-up menu, and then enter “Show” in the Entity Name field to connect it to the Show entity in the Model Editor. Check the checkbox for Prepares Content, which will instruct the Array Controller to load all the Shows at launch time. Switch to the Bindings Inspector. Bind the Managed Object Context (at the bottom of the bindings list) to App Delegate, and set the Model Key Path to “managedObjectContext.”

For the bindings, we’ll start with the table view. Select the table view and then open the Bindings Inspector. Expand the Content section under Table Content, and check the checkbox next to Bind to. The pop-up menu should read “Shows”. The default Controller Key of “arrangedObjects” is what we want, and there’s nothing to go in Model Key Path. We also want the array controller to know about the selected row, so bind the Selection Indexes binding to Shows and set the Controller Key here to “selectionIndexes.” Then drill down in the view hierarchy within the table view, using the object dock, down to the “Static Text - Table View Cell.” In the Attributes Inspector, change the Behavior to Editable. Then, in the Bindings Inspector, bind the Value to the Table Cell View and set its Model Key Path to “objectValue.name.”

That covers the table view. To finish up the part of the window dealing with Shows, we need to wire up the buttons. This is done just like in the last chapter—with a combination of target-action for handling a click and Cocoa bindings for enabling or disabling the button as appropriate. We’ll do the target-action first. Control-drag from the Add button to the Shows array controller, and select add: as the received action. Do the same thing for the Remove button, this time selecting remove: as the received action. Select the Add button again, and go to the Bindings Inspector. Check the Bind to checkbox to connect the button to the Shows controller, and enter “canAdd” as the Controller Key. Repeat with the Remove button, binding it to the “canRemove” Controller Key.

The window should look like Figure 10-3. Note the Outlets Inspector view in the utility area, showing the bindings and target-action connections for the Array Controller. This view can be really useful for troubleshooting when things don’t work as expected!

Quoting Quotes

Now we’re going to repeat most of that same setup below the Show box, for Quotes. As before, drag out a table view and two buttons, positioning them in the bottom half of the window and titling the buttons as done previously. For this table view, however, we’re going to leave it with two columns. Change it to view-based, as before, and check the checkbox labeled Alternating Rows, which will make the content somewhat easier to read. Title the left column “Quote Text” and the right column “Character,” and resize them to give the Quote Text column some more room. In the Quote Text column, double-click the “Table Cell View” text inside the column, and change it to “Quote”. Do the same thing to the “Table Cell View” text in the Character column, changing it to read “Character.” This will help us tell the two columns apart in just a moment. Group these three controls into a box, as before, and title the box “Quote.”

This part of the window will also use an NSArrayController, but it’ll be configured a bit differently than the Shows array controller. Drag out a controller, and title it “Quotes.” In the Attributes Inspector, set its Mode to be Entity Name, and then set the Entity Name field to Quote (the same name as the entity that we defined in the Model Editor). Then, switch to the Bindings Inspector. By default, each array controller will fetch all objects for the corresponding entity. We’re going to change this one to only fetch quotes based on the selected Show. Open the Content Set binding, select “Shows” in the pop-up list, “selection” in the Controller Key combo box, and type in “quotes” in the Model Key Path combo box. Finally, press Return to turn on the binding. We also need to connect it to a managed object context, which is provided by the App Delegate. Bind the Managed Object Context (at the bottom of the bindings list) to App Delegate, and set the Model Key Path to “managedObjectContext.”

Now we can bind this table view to the Quotes controller. Select the table view and then open the Bindings Inspector. Expand the Content section under Table Content, and check the checkbox next to Bind to. The pop-up menu should read “Quotes.” The default Controller Key of “arrangedObjects” is what we want. As before, the array controller should be told about the selected row, so bind the Selection Indexes binding to Quotes, and set the Controller Key here to “selectionIndexes.”

To bind the two columns, drill down in the view hierarchy within the table view, using the object dock, down to the “Static Text – Quote” entry. In the Attributes Inspector, change the Behavior to Editable. Then, in the Bindings Inspector, bind the Value to the Table Cell View, and set its Model Key Path to “objectValue.quoteText.” Switch to the “Static Text – Character” entry in the object dock, change its Mode to Editable, and then bind it to the Table Cell View and set its Model Key Path to “objectValue.character.”

Lastly, we need to wire up the buttons. From each of the buttons, control-drag out to the Quotes controller, setting the action to add: or remove: as appropriate. Bind the enabled binding of each button to the canAdd or canRemove Controller Key on the Quotes controller, as appropriate.

The layout should be similar to that in Figure 10-4.

Adding a Predicate to the App Delegate

Start by adding a new property to the app delegate. Open the QMAppDelegate.h file, which looks just like the default app delegate header that was generated for MythBase. Add a new property called searchPredicate. The interface declaration should now look something like this (new lines are in bold):

@interface QMAppDelegate : NSObject <NSApplicationDelegate>

@property (assign) IBOutlet NSWindow *window;

@property (readonly, strong, nonatomic) NSPersistentStoreCoordinator *persistentStoreCoordinator;
@property (readonly, strong, nonatomic) NSManagedObjectModel *managedObjectModel;
@property (readonly, strong, nonatomic) NSManagedObjectContext *managedObjectContext;

@property (strong) NSPredicate *searchPredicate;

- (IBAction)saveAction:(id)sender;

@end

Now switch over to QMAppDelegate.m and add the following code near the top, just after the @synthesize directives generated by Xcode. The new lines are in bold.

@implementation QMAppDelegate

@synthesize persistentStoreCoordinator = _persistentStoreCoordinator;
@synthesize managedObjectModel = _managedObjectModel;
@synthesize managedObjectContext = _managedObjectContext;

#define DEFAULT_PREDICATE @"(quoteText CONTAINS[cd] 'space') OR " 
                           "(character CONTAINS[cd] 'Knight')"

- (id)init
{
    if ((self = [super init])) {
        self.searchPredicate = [NSPredicate predicateWithFormat:DEFAULT_PREDICATE];
    }
    return self;
}

The init method simply creates a default value for the searchPredicate property. Now let’s hook up our controller to use this new predicate. Go back to the Interface Builder canvas, select the FoundQuotes controller, and bring up the Attributes Inspector. Select all the text in the Fetch Predicate text view and delete it, then switch to the Bindings Inspector. In the Controller Content Parameters section, open the Filter Predicate binding info. Select App Delegate in the pop-up, type “searchPredicate” into the Model Key Path combo box, and press Return to turn on the binding.

Save the work, go back to Xcode, and click Run. You should now see a different set of results: quotes spoken by a character named “Knight” or containing the word “space.” If nothing is matching, add a quote with one of these characteristics in order to test out the search window.

Add a Predicate Editor to the Search Window

We now have the FoundQuotes controller fetching values based on the contents of a predicate that is “owned” by the app delegate. The next step is to add an NSPredicateEditor to the search window and configure it to let the user edit the predicate.

In Xcode, bring up the Quote Finder window. Make the whole window a bit taller, and drag the existing table view and text view down to the bottom. Then find an NSPredicateEditor in the Object Library, drag it into the empty space at the top of the window, and resize it to make it fill the available space. Figure 10-7 shows the idea.

Configuring the Predicate Editor

Now it’s time to bind the editor to the app delegate’s predicate instance. Select the NSPredicateEditor (don’t forget the extra click to select the editor itself, not the scroll view that contains it), open the Bindings Inspector, and then examine the Value binding info. Select App Delegate in the pop-up, then type in “searchPredicate” in the Model Key Path combo box, and press Return to activate this binding.

At this point, there’s only one more thing we need to do in order to enable searching with this predicate editor: we have to tailor it to the attributes we want to search on. NSPredicateEditor is a quite complex control, and fortunately most of its interesting features can be configured directly in Xcode. The predicate editor displays one or more NSPredicateEditorRowTemplate objects, which can each be configured to do searching in a variety of ways. We can make row templates that allow us to specify numbers or dates to compare against object values, or to pick from a list of predefined strings. In our case, we’re going to configure a row template that lets the user type a string in a text field to search by character names, show names, and quote contents. This row template can be reused, allowing the user to specify multiple search criteria simultaneously. In addition, another row template will let the user choose whether the search criteria must all be met (Boolean AND) or whether it’s enough that any match succeeds (Boolean OR) for a quote to appear in the results.

In the Interface Builder canvas, drill down into the predicate editor by clicking on the lower of the two visible rows (the one containing pop-up buttons showing name and contains). With that row template selected, bring up the Attributes Inspector. Note the checkboxes that let us choose which comparators we’ll allow the user to use, plus the pop-up buttons that let us choose the nature of the expressions used on either side of the comparator (key paths, strings, constant values, and the like). The default setup, with key paths on the left and strings on the right, is perfect for our purposes, but we do need to adjust the key paths for our searching needs.

Edit the three default values that are listed below Left Exprs key paths, changing them to quoteText, character, and show.name. Next, click to turn on the Case Insensitive and Diacritical Mark Insensitive checkboxes (see Figure 10-8).

Then, examine the pop-up button in the row template itself. This will show three entries with names the same as what we just entered for key paths. Change these to more human-readable names: “Quotation,” “Character Name,” and “Show Name.”

Now click the upper row template, the one showing “Any of the following are true.” The configuration for this is very simple. Checkboxes let us choose to allow Boolean AND, OR, and NOT for the user to search on. Enable all of those to allow the most utility.

Now there’s just one more piece of configuration that we need to do. By default, NSPredicateEditor lets the user delete all the rows, right down to the last one, at which point there is no longer a + button to add any back in. Change this by selecting the predicate editor itself (not one of the row templates) and clicking to turn off the Can Remove All Rows checkbox in the Attributes Inspector.

Save the work, hit Run in Xcode, and bask in the glory of QuoteMonger! We can now easily search through all saved quotes, using the three criteria we configured in the predicate editor.