Preface xvii
Acknowledgments xix
Chapter 1: Cocoa: What Is It? 1
A Little History 1
Tools 3
Language 4
Objects, Classes, Methods, and Messages 4
Frameworks 6
How to Read This Book 6
Typographical Conventions 7
Common Mistakes 7
How to Learn 8
Chapter 2: Let’s Get Started 9
In Xcode 9
In Interface Builder 13
Back in Xcode 23
Documentation 29
What Have You Done? 30
Chapter 3: Objective-C 33
Creating and Using Instances 33
Using Existing Classes 35
Creating Your Own Classes 46
The Debugger 58
What Have You Done? 62
For the More Curious: How Does Messaging Work? 62
Challenge 64
Chapter 4: Memory Management 65
Turning the Garbage Collector On and Off 66
Living with the Garbage Collector 68
Living with Retain Counts 68
What Have You Done? 77
Chapter 5: Target/Action 79
Some Commonly Used Subclasses of NSControl 81
Start the SpeakLine Example 85
Lay Out the Nib File 86
Implementing the AppController Class 88
For the More Curious: Setting the Target Programmatically 90
Challenge 90
Debugging Hints 92
Chapter 6: Helper Objects 95
Delegates 96
The NSTableView and Its dataSource 99
Lay Out the User Interface 102
Make Connections 103
Edit AppController.m 105
For the More Curious: How Delegates Work 108
Challenge: Make a Delegate 109
Challenge: Make a Data Source 110
Chapter 7: Key-Value Coding; Key-Value Observing 111
Key-Value Coding 111
Bindings 113
Key-Value Observing 115
Making Keys Observable 116
Properties and Their Attributes 118
For the More Curious: Key Paths 120
Forthe More Curious: Key-Value Observing 121
Chapter 8: NSArrayController 123
Starting the RaiseMan Application 124
Key-Value Coding and nil 132
Add Sorting 133
For the More Curious: Sorting without NSArrayController 134
Challenge 1 135
Challenge 2 135
Chapter 9: NSUndoManager 139
NSInvocation 139
How the NSUndoManager Works 140
Adding Undo to RaiseMan 142
Key-Value Observing 145
Undo for Edits 146
Begin Editing on Insert 149
For the More Curious: Windows and the Undo Manager 151
Chapter 10: Archiving 153
NSCoder and NSCoding 154
The Document Architecture 157
Saving and NSKeyedArchiver 161
Loading and NSKeyedUnarchiver 162
Setting the Extension and Icon for the File Type 163
For the More Curious: Preventing Infinite Loops 166
For the More Curious: Creating a Protocol 167
For the More Curious: Document-Based Applications without Undo 167
Universal Type Identifiers 168
Chapter 11: Basic Core Data 171
NSManagedObjectModel 171
Interface 173
How Core Data Works 180
Chapter 12: Nib Files and NSWindowController 183
NSPanel 183
Adding a Panel to the Application 184
For the More Curious: NSBundle 194
Challenge 195
Chapter 13: User Defaults 197
NSDictionary and NSMutableDictionary 198
NSUserDefaults 200
Setting the Identifier for the Application 202
Creating Keys for the Names of the Defaults 202
Registering Defaults 203
Letting the User Edit the Defaults 203
Using the Defaults 205
For the More Curious: NSUserDefaultsController 207
For the More Curious: Reading and Writing Defaults from the Command Line 207
Challenge 208
Chapter 14: Using Notifications 209
What Notifications Are 209
What Notifications Are Not 210
NSNotification and NSNotificationCenter 210
Posting a Notification 212
Registering as an Observer 213
Handling the Notification When It Arrives 214
The userInfo Dictionary 214
For the More Curious: Delegates and Notifications 215
Challenge 216
Chapter 15: Using Alert Panels 217
Make the User Confirm the Deletion 218
Challenge 221
Chapter 16: Localization 223
Localizing a Nib File 224
String Tables 226
For the More Curious: ibtool 230
For the More Curious: Explicit Ordering of Tokens in Format Strings 231
Chapter 17: Custom Views 233
The View Hierarchy 233
Getting a View to Draw Itself 235
Drawing with NSBezierPath 240
NSScrollView 242
Creating Views Programmatically 245
For the More Curious: Cells 245
For the More Curious: isFlipped 247
Challenge 248
Chapter 18: Images and Mouse Events 249
NSResponder 249
NSEvent 249
Getting Mouse Events 251
Using NSOpenPanel 251
Composite an Image onto Your View 256
The View’s Coordinate System 258
Autoscrolling 261
For the More Curious: NSImage 261
Challenge 262
Chapter 19: Keyboard Events 263
NSResponder 265
NSEvent 265
Create a New Project with a Custom View 266
For the More Curious: Rollovers 274
The Fuzzy Blue Box 275
Chapter 20: Drawing Text with Attributes 277
NSFont 277
NSAttributedString 278
Drawing Strings and Attributed Strings 280
Making Letters Appear 281
Getting Your View to Generate PDF Data 283
For the More Curious: NSFontManager 286
Challenge 1 286
Challenge 2 286
Chapter 21: Pasteboards and Nil-Targeted Actions 287
NSPasteboard 288
Add Cut, Copy, and Paste to BigLetterView 289
Nil-Targeted Actions 290
For the More Curious: Which Object Sends the Action Message? 293
For the More Curious: Lazy Copying 293
Challenge 1 294
Challenge 2 294
Chapter 22: Categories 295
Add a Method to NSString 295
For the More Curious: Declaring Private Methods 297
For the More Curious: Declaring Informal Protocols 297
Chapter 23: Drag-and-Drop 299
Make BigLetterView a Drag Source 300
Make BigLetterView a Drag Destination 303
For the More Curious: Operation Mask 307
Chapter 24: NSTimer 309
Lay Out the Interface 311
Make Connections 312
Adding Code to AppController 314
For the More Curious: NSRunLoop 316
Challenge 316
Chapter 25: Sheets 317
Adding a Sheet 318
For the More Curious: contextInfo 324
For the More Curious: Modal Windows 325
Chapter 26: Creating NSFormatters 327
A Basic Formatter 328
The delegate of the NSControl 334
Checking Partial Strings 335
Formatters That Return Attributed Strings 337
Chapter 27: Printing 339
Dealing with Pagination 339
For the More Curious: Am I Drawing to the Screen? 344
Challenge 344
Chapter 28: Web Service 345
AmaZone 346
Lay Out the Interface 347
Write Code 349
Challenge: Add a WebView 353
Chapter 29: View Swapping 355
Design 356
Resizing the Window 362
Chapter 30: Core Data Relationships 365
Edit the Model 365
Create Custom NSManagedObject Classes 366
Lay Out the Interface 369
Events and nextResponder 372
Chapter 31: Garbage Collection 375
Non-object Data Types 376
Polynomials Example 377
Instruments 383
For the More Curious: Weak References 385
Challenge: Do Bad Things 385
Chapter 32: Core Animation 387
Creating CALayer 388
Using CALayer and CAAnimation 390
Chapter 33: A Simple Cocoa/OpenGL Application 397
Using NSOpenGLView 397
Writing the Application 398
Chapter 34: NSTask 405
Multithreading versus Multiprocessing 405
ZIPspector 406
Asynchronous Reads 410
iPing 411
Challenge: .tar and .tgz files 415
Chapter 35: The End 417
Challenge 418
Index 419
If you are developing applications for the Mac, or are hoping to do so, this book is just the resource you need. Does it cover everything you will ever want to know about programming for the Mac? Of course it doesn’t. But it does cover probably 80% of what you need to know. You can find the remaining 20%, the 20% that is unique to you, in Apple’s online documentation.
This book, then, acts as a foundation. It covers the Objective-C language and the major design patterns of Cocoa. It will also get you started with the three most commonly used developer tools: Xcode, Interface Builder, and Instruments. After reading this book, you will be able to understand and utilize Apple’s online documentation.
There is a lot of code in this book. Through that code, I will introduce you to the idioms of the Cocoa community. My hope is that by presenting exemplary code, I can help you to become not just a Cocoa developer, but a stylish Cocoa developer.
This third edition includes technologies introduced in Mac OS X 10.4 and 10.5. These include Xcode 3, Objective-C 2, Core Data, the garbage collector, and CoreAnimation.
This book is written for programmers who already know some C programming and something about objects. You are not expected to have any experience with Mac programming. It’s a hands-on book and assumes that you have access to Mac OS X and the developer tools. The developer tools are free. If you bought a shrink-wrapped copy of Mac OS X, the installer for the developer tools was on the DVD. The tools can also be downloaded from the Apple Developer Connection Web site (http://developer.apple.com/).
I have tried to make this book as useful for you aspossible, if not indispensable. That said, I’d love to hear from you if you have any suggestions for improving it.
All the visible objects in an application are either windows or views. In this chapter, you will create a subclass of NSView . From time to time, you will create a
custom view to do custom drawing or event handling. Even if you do not plan to do
custom drawing or event handling, by learning how to create a new view class, you
will learn a lot about how Cocoa works.
Windows are instances of the class NSWindow . Each window has a collection of views.
Each view is responsible for a rectangle of the window. The view draws inside that
rectangle and handles mouse events that occur there. A view may also handle keyboard events. You have worked with several subclasses of NSView already: NSButton, NSTextField, NSTableView, and NSColorWell are all views. (Note that a window is
not a subclass of NSView .)
Views are arranged in a hierarchy (Figure 12.1). The window has a content view that
completely fills its interior. The content view usually has several subviews. Each subview may have subviews of its own. Every view knows its superview, its subviews, and
the window it lives on.
Any view can have subviews, but most don't. Here are five views that commonly have
subviews.
In this section, you are going to create a very simple view. It will simply appear and
paint itself green. It will look like Figure 12.4.
Create a new project of type Cocoa Application (Figure 12.5).
After the new project is created, open MainMenu. nib, and select NSView in the classes
browser (Figure 12.6).
Press return to create a subclass, and name it StretchView (Figure 12.7).
Create the files for StretchView (Figure 12.8).
Save the files in the project directory.
Now create an instance of your class by dragging out a CustomView placeholder and
dropping it on the window (Figure 12.9).
Resize the view to fill most of the window. Open the info panel and set the class of
the view to be StretchView (Figure 12.10).
Notice that creating an instance of a view is different from creating an instance of a
controller object like AppController . To create an instance of AppController in
Chapter 7, you used the Instantiate menu item. When creating a view, it is important
that you attach it to a window and give it a size and location in that window.
Your StretchView object is a subview of the window's content view. An interesting
question is: What happens to the view when the superview resizes? There is a page in
the info panel that allows you to set that behavior. Open the size info panel, and set it
as shown in Figure 12.11. This means that it will grow and shrink as necessary to
keep the distance from its edges to the edges of its superview constant.
If you wanted the view to stay the same size, you could let the distance between the
edges of the view and the edges of the superview grow and shrink. In this exercise,
you do not want this behavior. But in a parallel universe where you did, the inspector
would look like this (Figure 12.12).
Save and close the nib file.
When a view needs to draw itself, it is sent the message drawRect: with the rectangle
that needs to be drawn or redrawn. This method is called automatically, and you will never need to call it directly. Instead, if you know that a view needs redrawing, you
will send the view the message setNeedsDisplay...
Loading...