Text rendering is a special type of drawing that is an important part of most applications. Cocoa provides a range of options for rendering text that should satisfy the needs of most developers. The following sections cover these options briefly. For more detailed information, you should see the documents in Reference Library > Cocoa > Text & Fonts.
Cocoa provides support for programmatically getting font information using the
NSFont class. You can apply fonts as attributes to strings or use them to set the default font in the current context. The Cocoa text system also uses font objects for formatting text. You request
NSFont objects from Cocoa using the name and size of the font you want, as shown in the following example.
NSFont* font1= [NSFont fontWithName:@"Helvetica" size:9.0];
NSFont* font2 = [NSFont fontWithName:@"Helvetica Bold" size:10.0];
NSFont class does not provide a programmatic way to modify other text attributes, such as the character spacing and text drawing mode. Cocoa does, however, provide a system Font panel that you can display to the user. From this panel, the user can make changes to the current font attributes. You can also set most text options using the Cocoa text system, which is described in Advanced Text Drawing.
Although you usually specify font attributes directly when drawing
NSAttributedString objects, you can also change the font and font size information in the current graphics state. To change these values, you create an
NSFont object and invoke its
For information about working with fonts and font objects, see Font Handling. For information about how to display the Font panel, see Creating a Font Panel.
Simple Text Drawing
If you need to draw a small amount of text quickly, the simplest way to do it is using the methods of
NSAttributedString. The Application Kit defines methods on these classes that support drawing the string in the current context. For an
NSString object, you can apply basic attributes (such as font, color, and style settings) to the entire string during drawing. For an
NSAttributedString object, you can apply multiple sets of attributes to different parts of the string.
Prior to OS X v10.4, the
NSAttributedString classes were intended for rendering text occasionally in your program. The performance of these drawing methods was not as good as the performance you could get by rendering text using the Cocoa text system. Also, the layout for strings is limited to a simple rectangular area in the current view. In OS X v10.4, performance of the string drawing methods improved significantly and is useful in many situations; of course, you should always measure the performance yourself and see if it is adequate for your program. If you need to do more complex text layout, you should still consider using the Cocoa text system.
For information on string drawing methods, see NSString Application Kit Additions Reference or NSAttributedString Application Kit Additions Reference in AppKit Framework Reference.
Advanced Text Drawing
If your program displays a lot of text or needs to arrange text in complex ways, you should use the Cocoa text system. This system provides advanced text-handling capabilities on top of basic features such as text input, layout, display, editing, copying, and pasting. The system supports multiple fonts and paragraph styles, embedded images, spell checking, nonrectangular text containers, and sophisticated typesetting features, among many other features.
Text layout is one of the most expensive drawing-related operations you can do and the Cocoa text system is optimized for the best possible performance. The text system manages a sophisticated set of caches and optimizes the times at which it performs layout to reduce the impact on your program’s drawing cycle. Of course, these optimizations work only if your program reuses its text objects, but doing so is relatively simple.
The simplest way to use the Cocoa text system is to place an
NSTextView object in one of your windows. A text view object creates and maintains the text layout objects it needs to draw text and responds to user events to modify the text.
If you want to have more control over the text layout and editing behavior, you can tie into the Cocoa text system at several places. The text engine at the heart of the Cocoa text system is highly customizable. You can subclass several text system classes to provide custom layout and typesetting behavior. You can also create your own text-based views to provide features beyond what the default
For information about the Cocoa text system, you should start by reading Cocoa Text Architecture Guide. That document describes the basic concepts of the text system and introduces you to many of the classes involved in text layout and management. It also provides simple tutorials to get you started and pointers to other text-related documents.