1. Cocoa Overview

   1. Chapter 1 Understanding theAqua Interface

      1. What Makes Mac OS X So Special?
      2. A Quick Look at the Mac OS X User Interface
      3. Basic Principles of the Aqua Interface
      4. The Mouse and Cursor
      5. Window Types and Behavior
      6. Menus and the Menu Bar
      7. The Dock
      8. Controls
      9. The Finder
      10. Configuring Your Desktop, Step by Step
      11. Menu Guidelines and Keyboard Equivalents
      12. Working with the Filesystem,Step by Step
      13. Summary
      14. Exercises
      15. References

   2. Chapter 2 Tools for Developing Cocoa Applications

      1. Developer Tools
      2. Utilities
      3. Working with the Terminal
      4. Debugging Programs with gdb
      5. User Interface Design
      6. Summary
      7. Exercises

   3. Chapter 3 Creating a Simple Application with Interface Builder

      1. Getting Started with Interface Builder
      2. Adding Objects to Your Application
      3. Objects, Messages, and Targets
      4. Summary
      5. Exercise

   4. Chapter 4 An Objective-C ApplicationWithout Interface Builder

      1. The Tiny.m Program
      2. An Introduction to Objective-C
      3. Tiny.m Revisited
      4. Summary
      5. Exercises
      6. References

2. Calculator: Building a Simple Application

   1. Chapter 5 Building a Project: A Four-Function Calculator

      1. Getting Started: Building the Calculator Project
      2. Building the Calculator's User Interface
      3. Building the Calculator's Controller Class
      4. Customizing Buttons and Making Connections
      5. Compiling and Running a Program
      6. Compiler Error Messages
      7. The enterDigit: Action Method
      8. Adding the Four Calculator Functions
      9. Adding the Unary Minus Function to the Controller Class
      10. The Files in a Project
      11. Summary
      12. Exercises

   2. Chapter 6 Nibs and Icons

      1. Customizing MainMenu.nib
      2. Managing Multiple Nibs
      3. Adding Icons to Applications
      4. Changing Calculator's Application Icon
      5. Cocoa's NSImage Class
      6. Summary
      7. Exercises
      8. References

   3. Chapter 7 Delegation and Resizing

      1. Handling Different Bases
      2. Delegation
      3. Disabling Buttons for BetterMultiradix Input
      4. Resizing Windows Programmatically
      5. Two Very Important Classes: NSWindow and NSView
      6. Summary
      7. Exercises

   4. Chapter 8 Events and Responders

      1. Events and the NSResponder Chain
      2. Events and the NSApplication Object
      3. The Event Loop
      4. Catching Keyboard Eventsfor Our Calculator
      5. Summary
      6. Exercises
      7. References

   5. Chapter 9 Darwin and the Window Server

      1. Unix, Mach, and the Mac OS X Environment
      2. The Window Server and Quartz
      3. Seeing All the Processes
      4. Summary
      5. Exercises
      6. References

3. MathPaper: A Multiple-Document, Multiprocess Application

   1. Chapter 10 MathPaper and Cocoa'sDocument-Based Architecture

      1. The MathPaper Application
      2. The Evaluator Back End
      3. Cocoa's Document-Based Architecture
      4. Building MathPaper's Front End
      5. Summary
      6. Exercises
      7. References

   2. Chapter 11 Tasks, Pipes, and NSTextView

      1. Processes, Pipes, and Resources
      2. Making Evaluator a MathPaper Auxiliary Executable
      3. MathDocument Class Modifications
      4. Creating PaperController, a Subclass of NSWindowController
      5. The NSScrollView and NSTextView Classes
      6. PaperController Class Modifications
      7. Summary
      8. Exercises

   3. Chapter 12 Rich Text Format and NSText

      1. Rich Text Format
      2. Creating an RTF Class
      3. Integrating Our RTF Class into MathPaper
      4. Summary
      5. Exercises

   4. Chapter 13 Saving, Loading, and Printing

      1. Data Management with NSDocument
      2. Saving to a File
      3. Loading from a File
      4. Marking a Document Window as Edited
      5. Adding Printing Capability
      6. Summary
      7. Exercises

   5. Chapter 14 Drawing with Quartz

      1. Animation in an About Panel
      2. The Quartz Window Server
      3. Implementing the About Panel in MathPaper
      4. Quartz Graphics Data Types
      5. Timers
      6. Putting It All Together
      7. Summary
      8. Exercises
      9. References

   6. Chapter 15 Drawing in a Rectangle: More Fun with Cocoa Views

      1. The Advantages of NSView's drawRect: Method
      2. BlackView: An NSView That Paints Itself Black
      3. A Closer Look at the NSView Class
      4. BarView: An NSView with a Scaled Coordinate System
      5. PolygonView: A Non-Opaque NSView
      6. Responding to Events in an NSView
      7. Autosizing Multiple Views in a Window
      8. Summary
      9. Exercises

4. GraphPaper: A Multithreaded, Mouse-Tracking Application

   1. Chapter 16 GraphPaper: A Multithreaded Application with a Display List

      1. GraphPaper's Design
      2. Working with Multiple Threads
      3. Building the GraphPaper Application
      4. Extending the Display List
      5. Summary
      6. Exercises
      7. References

   2. Chapter 17 Color

      1. Colors and Color Objects
      2. Adding Color to GraphPaper
      3. Summary
      4. Exercises

   3. Chapter 18 Tracking the Mouse

      1. Tracking the Mouse
      2. Adding Mouse Tracking to GraphPaper
      3. Summary
      4. Exercises
      5. References

   4. Chapter 19 Zooming and Saving Graphics Files

      1. Adding a Zoom Button to GraphPaper
      2. Saving to PDF
      3. Saving to TIFF
      4. Creating an Accessory NSView
      5. Summary
      6. Exercises

   5. Chapter 20 Pasteboards, Services, Modal Sessions, and Drag-and-Drop

      1. Cut, Copy, and Paste with the Pasteboard
      2. Using the Pasteboard in GraphPaper
      3. Services
      4. Creating Your Own Service
      5. Drag-and-Drop
      6. Summary
      7. Exercises

   6. Chapter 21 Preferences and Defaults

      1. Preferences and the Defaults Database System
      2. Adding Defaults to GraphPaper
      3. Making the Preferences Panel Work with Defaults
      4. Setting Up a Multi-View Panel
      5. Summary
      6. Exercises

1. Appendix A Cocoa Resources

   1. Apple Resources

   2. Third-Party Resources

2. Colophon

Our look is the result of reader comments, our own experimentation, and feedback from distribution channels. Distinctive covers complement our distinctive approach to technical topics, breathing personality and life into potentially dry subjects. The animal on the cover of Building Cocoa Applications is a Mastiff (also known as an English or Old English Mastiff ). The Mastiff is a large-breed working dog with a long history-Mastiffs have been used as guard and fighting dogs in England for more than 2,000 years, and dogs of this type are found in European and Asian records dating back to 3000 BC. Shakespeare referred to Mastiffs as "the dogs of war," and Henry VIII is known to have given King Charles V of Spain several hundred Mastiffs to use as fighting dogs on the battlefield. Trained fighting mastiffs were also used by the ancient Celts, by Kubla Khan, and by Hannibal when he crossed the Alps. Even as recently as the two World Wars, Mastiffs were used to pull munitions carts on the fronts.

Mastiff owners are often first attracted to the breed by its large size-Mastiffs are the heaviest dog breed, weighing in at an average of 180-220 pounds. Despite their history as fighting dogs, modern breeders have bred the Mastiff for gentleness and have created an excellent companion, large enough to deter intruders yet gentle enough to be dependable around children. Mastiffs are loyal, patient, affectionate, and protective, and they tend to bond strongly to their owners and become depressed during long periods of separation. Rachel Wheeler was the production editor and copyeditor for Building Cocoa Applications. Leanne Soylemez was the proofreader. Linley Dolby provided quality control, and Mary Brady, David Chu, Phil Dangler, Julie Flanagan, and Sue Willing provided production assistance. John Bickelhaupt wrote the index.

Emma Colby designed the cover of this book, based on a series design by Edie Freedman. The cover image is from the Dover Treasury of Animal Illustrations, edited by Carol Belanger Grafton. Emma Colby produced the cover layout with QuarkXPress 4.1 using Adobe's ITC Garamond font.

David Futato designed the interior layout. This book was converted into FrameMaker 5.5.6 with a format conversion tool created by Erik Ray, Jason McIntosh, Neil Walls, and Mike Sierra that uses Perl and XML technologies. The text font is Linotype Birka; the heading font is Adobe Myriad Condensed; and the code font is LucasFont's TheSans Mono Condensed. The illustrations that appear in the book were produced by Robert Romano and Jessamyn Read using Macromedia FreeHand 9 and Adobe Photoshop 6. The tip and warning icons were drawn by Christopher Bing. This colophon was written by Rachel Wheeler.