Benefits of Cocoa Development

• Rapid development environment

• Object-oriented framework design

• Excellent integration with OS X developer tools

• Very robust feature set

• Can take advantage of existing C, C++, Objective-C, and Java code

• Similar level of abstraction to high level toolkits such as Qt, Tcl/Tk, and so on

Drawbacks of Cocoa Development

• Cross-platform deployment requires having a separate, non-Cocoa code base for the GUI portion

• Requires integrating Java, Objective C, or Objective C++ into your code base for the GUI layer

• Requires knowledge of Java, Objective C, or Objective C++

• Very different level of abstraction from raw X11 programming

• Potential performance penalties if used incorrectly

Example: Calling C or C++ Code With Cocoa

When designing an application from the ground up in Cocoa, you are in an object-oriented environment. You can also take advantage of Cocoa’s object-oriented nature when converting preexisting code, as you can use the Cocoa frameworks to wrap the functionality of C or C++ code.

The Objective-C language has been extended to understand C++. Often this is called Objective-C++, but the functionality remains basically the same. Because Cocoa understands Objective-C++, you can call native C and C++ code from Cocoa. This is one example of how you can take advantage of your code base while adding a Macintosh front end. An example is provided below of how Objective-C wraps together C, C++, and Objective-C++ functionality. Listing 4-1 shows the Objective-C main class.

Listing 4-1  main.m

#import <AppKit/AppKit.h>

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

    return NSApplicationMain(argc, argv);

}

This gets everything started when the user double-clicks the application icon. A call is then sent to invoke a HelloController object by the NIB, a file that holds interface information. The listings for HelloController.m and HelloController.h follow.

Listing 4-2  HelloController.m

#import "HelloController.h"

@implementation HelloController

- (void)doAbout:(id)sender

{

    NSRunAlertPanel(@"About",@"Welcome to Hello World!",@"OK",NULL,NULL);

}

- (IBAction)switchMessage:(id)sender

{

        int which=[sender selectedRow]+1;

        [helloButton setAction:NSSelectorFromString([NSString stringWithFormat:@"%@%d:",@"message",which])];

}

- (void)awakeFromNib

{

    [[helloButton window] makeKeyAndOrderFront:self];

}

@end

Listing 4-3  HelloController.h

#import <AppKit/AppKit.h>

@interface HelloController : NSObject

{

    id helloButton;

    id messageRadio;

}

- (void)doAbout:(id)sender;

- (void)switchMessage:(id)sender;

@end

The communication between the C, C++, and the Objective-C code is handled as shown in Listing 4-4. The header file SayHello.h is shown in Listing 4-5.

Listing 4-4  SayHello.mm

#import "SayHello.h"

#include "FooClass.h"

#include <Carbon/Carbon.h>

@implementation SayHello

- (void)message1:(id)sender

{

    NSRunAlertPanel(@"Regular Obj-C from Obj-C",@"Hello, World! This is a regular old NSRunAlertPanel call in Cocoa!",@"OK",NULL,NULL);

}

- (void)message2:(id)sender

{

    int howMany;

    NSString *theAnswer;

    Foo* myCPlusPlusObj;

    myCPlusPlusObj=new Foo();

    howMany=myCPlusPlusObj->getVariable();

    delete myCPlusPlusObj;

    theAnswer=[NSString stringWithFormat:@"Hello, World! When our C++ object is queried, it tells us that the number is %i!",howMany];

    NSRunAlertPanel(@"C++ from Obj-C",theAnswer,@"OK",NULL,NULL);

}

- (void)message3:(id)sender

{

    Alert(128,NULL); //This calls into Carbon

}

@end

Listing 4-5  SayHello.h

#import <AppKit/AppKit.h>

@interface SayHello : NSObject

{

}

- (void)message1:(id)sender;

- (void)message2:(id)sender;

- (void)message3:(id)sender;

@end

The C++ class wrapped by these Cocoa calls is shown in Listing 4-6. The header file, FooClass.h, is shown in Listing 4-7.

Listing 4-6  FooClass.cpp

#include "FooClass.h"

Foo::Foo()

{

 variable=3;

}

int Foo::getVariable()

{

 return variable;

}

Listing 4-7  FooClass.h

class Foo {

public:

    Foo();

    int getVariable();

    void * objCObject;

private:

    int variable;

};

You should be careful when writing code using Cocoa, because the same constructs that make it easy for the developer tend to degrade performance when overused. In particular, heavy use of message passing can result in a sluggish application.

The ideal use of Cocoa is as a thin layer on top of an existing application. Such a design gives you not only good performance and ease of GUI design, but also minimizes the amount of divergence between your UNIX code base and your OS X code base.

Benefits of Carbon Development

• Well-documented feature set

• Integration with OS X developer tools

• Very robust feature set

• Simple C and C++ integration

• Similar abstraction level to X11

• Procedural design rather than object-oriented

Drawbacks of Carbon Development

• No cross-platform deployment without a separate non-Carbon code base

• Slightly more effort required to take advantage of native OS X technologies

• Procedural design rather than object-oriented

In case you’re wondering, that isn’t a typo. Procedural design in a GUI can be both a benefit and a drawback.

Procedural design can be a benefit in terms of being able to easily integrate into any environment, regardless of language. It is also a benefit because it fits many styles of graphical programming well.

Procedural design can be a drawback, however, when dealing with more complex GUI designs where it would be more convenient to have the methods more closely tied to the data on which they operate.

Benefits of using Quartz

• PostScript-like drawing features

• PDF-based

• Included color management tools

• Unified print and imaging model

Drawbacks to using Quartz

• No cross-platform deployment

Benefits of using OpenGL

• Cross-platform technology

• Native OS X integration

• Included with every installation of OS X

• Very robust feature set for handling graphics

Drawbacks to using OpenGL

• Some level of integration at an application level is required

Benefits of using QuickTime

• Robust feature set for manipulating sound and video

• Cross-platform development

Drawbacks to using QuickTime

• Not supported on other UNIX-based systems.

Note that while QuickTime itself is not supported on UNIX-based systems, the QuickTime file format is supported by various third-party utilities.