Creating the Bundle

To create the loadable bundle, you need to first decide what code this bundle will contain, and what class you want to serve as the principal class—the entry point. Once you have figured out what you want the bundle to contain, you can build a bundle project or target.

The process for creating a Xcode project for a loadable bundle is described in Creating Loadable Bundles.

Adding a new target to an existing project follows a similar pattern. Instead of creating a new project, however, perform the following steps to add a new target to an existing project:

1. Open the application project in Xcode.

2. Choose New Target… from the Project menu.

3. Choose Bundle for the target type and click Next.

4. Give the target a name in the Target Name field.

5. Ensure that your project is selected in the Add To Project pop-up menu and click Finish.

6. In the project window, make sure the Files tab is selected.

7. Choose your target from the target pop-up menu.

8. Click the checkboxes next to all the files you want included in this bundle. Make sure you include Cocoa.framework in the Frameworks > Linked Frameworks group. Be sure not to include implementations that appear in your application.

9. Modify settings for the bundle target as described in Modifying Target Settings.

Copying Loadable Bundles to the Application Bundle

To copy loadable bundles to the application bundle, you add a copy build phase to the application target, which copies the loadable bundle to the application bundle’s “plug-ins” directory.

To set up a copy build phase, go through the following steps:

1. Add the built bundle to your project in the Files tab.

2. Click the Targets tab, and view the application target.

3. Under Build Phases in the target pane, choose the last build phase (usually Frameworks & Libraries). This tells Xcode where to put the next build phase.

4. Choose New Build Phase > New Copy Files Build Phase from the Project menu.

5. In the Copy Files pane, choose Plug-ins from the pop-up menu labeled “Where:”.

6. Click the Files tab in the main project pane.

7. Drag the bundle from the list of project files to the box labeled “Files:” in the Copy Files section of the target pane.

Now, when you build your application, the bundle is copied to the PlugIns directory of the application bundle, giving you easy access to it from your code. You can add additional bundles to the same copy phase for additional components.

Loading Bundled Code

The generalized process for loading bundles from the application’s PlugIns directory is the same as described in Loading Bundles.

In applications that use a small number of bundles for large-scale application components, the easiest way to access the code is through a lazy accessor method. Lazy Bundle Loading describes how to lazily instantiate an object from a bundle.

Creating the Window Controller Bundle

Building a bundle for a window and associated window controller is essentially the same as described in Loading Bundles. In addition, you need to package a nib file in the bundle project containing a window and a window controller class associated with the window.

Once you have a new Cocoa bundle project, create the nib file and add it to your project:

1. Make sure your bundle project is open in Xcode.

2. Launch Interface Builder.

3. Choose New… from the File menu.

4. In the Starting Point window, choose Empty under the Cocoa group.

5. Choose Save As… from the File menu.

6. Navigate to language.lproj/ in your bundle project’s directory, where language is the language code for the nib file—for example, English or en.

7. Click Save.

8. In the Add File sheet, select the bundle target under Add to Targets, and click Add.

Next, create the window controller class:

1. Create an NSWindowController subclass.

2. Add any outlets and actions you want to add to the class.

3. Create source files for the class in your Xcode project.

4. Set the Custom Class for the File’s Owner proxy to your subclass.

Now you can create the window itself and hook everything up:

1. Add a new window object from the Cocoa-Windows palette and construct it with user interface elements.

2. Connect the window outlet of the File’s Owner to the newly created window and add any other connections you need to make between the controller and user interface elements.

Finally, write the code for the window controller class in Xcode. The one required method tells NSWindowController what nib file to use:

- (NSString *)windowNibName

{

    // Replace MyWindowController with the name of your window

    return @"MyWindowController";

}

Writing the Application Code

As with other code components, window controller bundles are best accessed through lazy accessor methods. Listing 2 shows the implementation for such a method.

Listing 2  Accessor method for bundled window controller

- (NSWindowController *)bundledWindowController

{

    // Assume _bundledWindowController is a private instance variable

    // of type id or NSWindowController *.

    if(!_bundledWindowController)

    {

        NSString *bundlePath = [[[NSBundle mainBundle] builtInPlugInsPath]

                         stringByAppendingPathComponent:@"MyBundle.bundle"];

        NSBundle *windowBundle = [NSBundle bundleWithPath:bundlePath];

        if(windowBundle)

        {

            Class windowControllerClass = [windowBundle principalClass];

            if(windowControllerClass)

            {

                _bundledWindowController = [[windowControllerClass

                                                              alloc] init];

            }

        }

    }

    return _bundledWindowController;

}

The rest of your application code should use the accessor method to refer to the object. For example, this line of code shows the window:

[[self bundledWindowController] showWindow:self];

Implicit in this example are potentially two lazy loading operations. First, the code for the window controller is loaded when the principalClass message is sent. Also, the window’s nib file is loaded when the showWindow: message is sent.