]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/cocoa/font.mm
64 bit clean printing
[wxWidgets.git] / src / cocoa / font.mm
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/cocoa/font.cpp
3// Purpose: wxFont class
4// Author: AUTHOR
5// Modified by:
6// Created: ??/??/98
7// RCS-ID: $Id$
8// Copyright: (c) AUTHOR
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12/*! @file font.mm
13 @disucssion
14 Cocoa has three classes which interact to form the font system:
15
16 NSFont: Represents a specific font (e.g. Times-Bold) at a specific size
17 with specific attributes. That is, it's basically like this class.
18 Notably, it doesn't hold an underlined flag, so this class does.
19 Available on all OS X versions.
20
21 NSFontManager: Fairly broad controller class which ties together the
22 model (NSFont) with the view (NSFontPanel). We are ignoring NSFontPanel
23 in this discussion. NSFontManager is actually a little broader than just
24 a controller though. It's also the traditional way of mutating fonts
25 and asking for a font with a certain family and certain attributes.
26 For example, you can use NSFont's factor methods to create a font named
27 @"Times-Roman" then use NSFontManager to imbue attributes like italic and
28 bold. You might do this if, for instance, you already have times at the
29 Roman weight but want to make it bold.
30
31 Alternatively, you can use NSFontManager to ask for a font in the @"Times"
32 family with the bold attribute.
33
34 NSFontManager is available on all OS X versions.
35
36 NSFontDescriptor: Added in OS X 10.3. Prior to this there was no specific
37 class to represent all of the attributes of a font. Instead, a regular
38 NSDictionary was used with a set of well-defined keys. Unfortunately,
39 there was no method accepting the attributes dictionary, only a method
40 to retrieve it from an NSFont. That meant that in order to create
41 a new font by imbueing certain attributes like Bold one would need
42 to use the specific method in NSFontManager to do so.
43
44 The NSFontDescriptor class, on the other hand, has factory methods which
45 can create a new font descriptor with an attributes dictionary as well
46 as mutate (by copy) an existing font descriptor using attributes from
47 an attributes dictionary.
48
49 In theory, most of what can be done using NSFontDescriptor can just as
50 well be done without it. NSFontDescriptor is basically just a shell
51 around an NSMutableDictionary with well-defined keys.
52
53
54 Getting back to the broad overview, font matching is one of the weaker points
55 in Cocoa's API and NSFontDescriptor is the easier to use solution.
56
57 That said, it's not impossible to implement font matching without it. For instance,
58 if you have a family name and want to list available variants (e.g. Bold, italic,
59 underlined) then you can ask NSFontManager for availableMembersOfFontFamily:.
60
61 The problem is that you can either match on family name or on font attributes
62 but not on both. To match both you have to do one then the other.
63 NSFontDescriptor allows you to get a list of fonts matching both a family name
64 and a particular set of attributes. Furthermore, the attributes instead of
65 being flags as in NSFontManager are instead well-defined keys in a dictionary.
66
67 The only way to get that behavior without NSFontManager is to pare down the
68 list as much as possible using the classic NSFontManager methods and then
69 to instantiate each font in the list and match on each font's afmDictionary.
70
71 A reasonable guess is that that's probably more or less exactly what
72 NSFontDescriptor does internally.
73 */
74#include "wx/wxprec.h"
75
76#include "wx/font.h"
77
78#ifndef WX_PRECOMP
79 #include "wx/string.h"
80 #include "wx/gdicmn.h"
81#endif
82
83#include "wx/fontutil.h"
84#include "wx/encinfo.h"
85
86#include "wx/cocoa/string.h"
87#include "wx/cocoa/private/fontfactory.h"
88#include "wx/cocoa/autorelease.h"
89
90#include <AppKit/NSFont.h>
91#include <AppKit/NSFontManager.h>
92
93// Helper methods for NSFont/wxNativeFontInfo
94static NSFont* GetNSFontForNativeFontInfo(const wxNativeFontInfo &info);
95static void UpdateNativeFontInfoWithNSFont(wxNativeFontInfo &info, NSFont *cocoaNSFont);
96static wxNativeFontInfo MakeNativeFontInfoForNSFont(NSFont *cocoaNSFont, bool underlined = false);
97static wxNativeFontInfo MakeNativeFontInfo(int size, int family, int style, int weight, bool underlined, const wxString& faceName, wxFontEncoding encoding);
98
99/*! @discussion
100 Due to 2.8 ABI compatibility concerns we probably don't want to change wxNativeFontInfo
101 although this may be unfounded because this class is supposed to be internal as is
102 wxNativeFontInfo so anyone who subclassed it or created one without going through
103 wxFont should expect what they get (i.e. horrible breakage)
104 There's a concern that wxFontRefData was in the public header when 2.8 shipped so
105 it's possible that someone did subclass it to get better font behavior.
106
107 For right now, the plan is to write it strictly ABI compatible with 2.8 and eventually
108 to enhance it in trunk to accurately represent font attributes as Cocoa sees them.
109
110 I'd like to let at least one 2.8 release go out the door and get feedback as to whether
111 this is going to be a problem or not. If so, we'll keep it strictly ABI compatible.
112 If not, we'll update it.
113 */
114class WXDLLEXPORT wxFontRefData: public wxGDIRefData
115{
116 friend class WXDLLIMPEXP_FWD_CORE wxFont;
117public:
118 wxFontRefData()
119 : m_cocoaNSFont(nil)
120 , m_info(MakeNativeFontInfo(10, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE,
121 wxT("Geneva"), wxFONTENCODING_DEFAULT))
122 {
123 CreateNSFontAndUpdateInfo();
124 }
125
126 wxFontRefData(const wxFontRefData& data)
127 : wxGDIRefData()
128 , m_cocoaNSFont([data.m_cocoaNSFont retain])
129 , m_info(data.m_info)
130 {
131 }
132
133 wxFontRefData(NSFont *cocoaNSFont, bool underlined)
134 : wxGDIRefData()
135 , m_cocoaNSFont([cocoaNSFont retain])
136 , m_info(MakeNativeFontInfoForNSFont(m_cocoaNSFont, underlined))
137 {
138 }
139
140 wxFontRefData(const wxNativeFontInfo& info)
141 : wxGDIRefData()
142 , m_cocoaNSFont(nil)
143 , m_info(info)
144 {
145 CreateNSFontAndUpdateInfo();
146 }
147
148 wxFontRefData(int size,
149 int family,
150 int style,
151 int weight,
152 bool underlined,
153 const wxString& faceName,
154 wxFontEncoding encoding)
155 : m_cocoaNSFont(nil)
156 , m_info(MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding))
157 {
158 CreateNSFontAndUpdateInfo();
159 }
160
161 virtual ~wxFontRefData();
162protected:
163 /*! @abstract common part of some ctors
164 @discussion
165 This is a leftover of sorts from the old stub code.
166 FIXME: Remove from trunk
167 */
168 void Init(int size,
169 int family,
170 int style,
171 int weight,
172 bool underlined,
173 const wxString& faceName,
174 wxFontEncoding encoding);
175
176 /*! @discussion
177 Uses the native font info to create an NSFont and then updates that info with
178 the attributes of the font. This is necessary because, for example, a font
179 can be created with an empty faceName in which case some concrete typeface must
180 be chosen.
181 We choose to handle this by first initializing the wxNativeFontInfo with the
182 properties as given by the user and then creating the NSFont and updating
183 the wxNativeFontInfo to match the NSFont.
184 */
185 void CreateNSFontAndUpdateInfo()
186 {
187 wxAutoNSAutoreleasePool pool;
188 [m_cocoaNSFont release];
189 m_cocoaNSFont = [GetNSFontForNativeFontInfo(m_info) retain];
190 UpdateNativeFontInfoWithNSFont(m_info, m_cocoaNSFont);
191 }
192
193 // font characterstics
194 NSFont *m_cocoaNSFont;
195 wxNativeFontInfo m_info;
196
197public:
198};
199
200NSString *GetFamilyName(wxFontFamily family)
201{
202 switch(family)
203 {
204 case wxFONTFAMILY_DEFAULT:
205 default:
206 return @"Times";
207 case wxFONTFAMILY_DECORATIVE:
208 case wxFONTFAMILY_ROMAN:
209 case wxFONTFAMILY_SCRIPT:
210 return @"Times";
211 case wxFONTFAMILY_SWISS:
212 return @"Lucida Grande";
213 case wxFONTFAMILY_MODERN:
214 case wxFONTFAMILY_TELETYPE:
215 return @"Monaco";
216 };
217}
218// Returns an NSFont given the native font info
219// NOTE: It is not considered alloc'd (i.e. this is a get method not an alloc/new method)
220static NSFont* GetNSFontForNativeFontInfo(const wxNativeFontInfo &info)
221{
222 if(!info.faceName.empty())
223 {
224 NSFont *font = [NSFont fontWithName:wxNSStringWithWxString(info.faceName) size:info.pointSize];
225 // TODO: use NSFontManager to mix in the weights and whatnot
226 if(font != nil)
227 return font;
228 // To err or not to err?
229 }
230 // No font with that face name or no face name
231
232 NSFontTraitMask cocoaTraits = 0;
233 int cocoaWeight = 5;
234 NSFont *font = [[NSFontManager sharedFontManager] fontWithFamily:GetFamilyName(info.family) traits:cocoaTraits weight:cocoaWeight size:info.pointSize];
235 return font;
236}
237
238/*! @discussion
239 Updates all fields of @a info except for underlined which is not a property of NSFont.
240 */
241static void UpdateNativeFontInfoWithNSFont(wxNativeFontInfo &info, NSFont *cocoaNSFont)
242{
243 info.pointSize = [cocoaNSFont pointSize];
244
245 // FIXME: We could maybe improve on this?
246 info.family = wxFONTFAMILY_DEFAULT;
247
248 // FIXME: italicAngle might indicate a slanted rather than truly italic font?
249 info.style = [cocoaNSFont italicAngle] == 0.0?wxFONTSTYLE_NORMAL:wxFONTSTYLE_ITALIC;
250
251 int cocoaWeight = [[NSFontManager sharedFontManager] weightOfFont:cocoaNSFont];
252 if(cocoaWeight < 5)
253 info.weight = wxFONTWEIGHT_LIGHT;
254 else if(cocoaWeight < 9)
255 info.weight = wxFONTWEIGHT_NORMAL;
256 else
257 info.weight = wxFONTWEIGHT_BOLD;
258
259 // FIXME: Is this right? I think so.
260 info.faceName = wxStringWithNSString([cocoaNSFont fontName]);
261
262 // TODO: Translate NSStringEncoding to wxFontEncoding
263 info.encoding = wxFONTENCODING_SYSTEM;
264}
265
266/*! @discussion
267 Creates a new generic wxNativeFontInfo from an NSFont and an underlined flag.
268 Uses UpdateNativeFontInfoWithNSFont to do the work and sets the underlined field
269 of wxNativeFontInfo to the @a underlined argument.
270 */
271static wxNativeFontInfo MakeNativeFontInfoForNSFont(NSFont *cocoaNSFont, bool underlined)
272{
273 wxNativeFontInfo info;
274 UpdateNativeFontInfoWithNSFont(info, cocoaNSFont);
275
276 // NSFont are never underlined.. that's a function of the drawing system
277 info.underlined = underlined;
278
279 return info;
280}
281
282//#include "_font_test_2_8_abi_compat.h"
283
284IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
285
286static wxNativeFontInfo MakeNativeFontInfo(int size, int family, int style, int weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
287{
288 wxNativeFontInfo m_info; // NOTE: not an i-var despite name
289 m_info.pointSize = size;
290 m_info.family = static_cast<wxFontFamily>(family);
291 m_info.style = static_cast<wxFontStyle>(style);
292 m_info.weight = static_cast<wxFontWeight>(weight);
293 m_info.underlined = underlined;
294 m_info.faceName = faceName;
295 m_info.encoding = encoding;
296 return m_info;
297}
298
299void wxFontRefData::Init(int size, int family, int style, int weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
300{
301 m_info = MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding);
302}
303
304wxFontRefData::~wxFontRefData()
305{
306 [m_cocoaNSFont release];
307 m_cocoaNSFont = nil;
308 // TODO: delete font data
309}
310
311#define M_FONTDATA ((wxFontRefData*)m_refData)
312
313wxFont wxCocoaFontFactory::InstanceForNSFont(WX_NSFont cocoaFont, bool underlined)
314{
315 return wxFont(new wxFontRefData(cocoaFont, underlined));
316}
317
318bool wxFont::Create(wxFontRefData *refData)
319{
320 UnRef();
321 m_refData = refData;
322
323 return m_refData != NULL;
324}
325
326bool wxFont::Create(const wxNativeFontInfo& nativeFontInfo)
327{
328 UnRef();
329 m_refData = new wxFontRefData(nativeFontInfo);
330
331 return true;
332}
333
334void wxFont::SetEncoding(wxFontEncoding)
335{
336}
337
338wxFontEncoding wxFont::GetEncoding() const
339{
340 return wxFontEncoding();
341}
342
343int wxFont::GetPointSize() const
344{
345 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
346 return M_FONTDATA->m_info.pointSize;
347}
348
349bool wxFont::GetUnderlined() const
350{
351 if(M_FONTDATA)
352 return M_FONTDATA->m_info.underlined;
353 else
354 return false;
355}
356
357int wxFont::GetStyle() const
358{
359 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
360 return M_FONTDATA->m_info.style;
361}
362
363int wxFont::GetFamily() const
364{
365 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
366 return M_FONTDATA->m_info.family;
367}
368
369int wxFont::GetWeight() const
370{
371 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
372 return M_FONTDATA->m_info.weight;
373}
374
375const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
376{
377 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
378 return &M_FONTDATA->m_info;
379}
380
381bool wxFont::Create(int pointSize, int family, int style, int weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
382{
383 UnRef();
384 m_refData = new wxFontRefData(pointSize, family, style, weight, underlined, faceName, encoding);
385
386 RealizeResource();
387
388 return true;
389}
390
391wxFont::~wxFont()
392{
393}
394
395bool wxFont::RealizeResource()
396{
397 // TODO: create the font (if there is a native font object)
398 return false;
399}
400
401void wxFont::Unshare()
402{
403 // Don't change shared data
404 if (!m_refData)
405 {
406 m_refData = new wxFontRefData();
407 }
408 else
409 {
410 wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
411 UnRef();
412 m_refData = ref;
413 }
414}
415
416void wxFont::SetPointSize(int pointSize)
417{
418 Unshare();
419
420 M_FONTDATA->m_info.pointSize = pointSize;
421
422 RealizeResource();
423}
424
425void wxFont::SetFamily(int family)
426{
427 Unshare();
428
429 M_FONTDATA->m_info.family = static_cast<wxFontFamily>(family);
430
431 RealizeResource();
432}
433
434void wxFont::SetStyle(int style)
435{
436 Unshare();
437
438 M_FONTDATA->m_info.style = static_cast<wxFontStyle>(style);
439
440 RealizeResource();
441}
442
443void wxFont::SetWeight(int weight)
444{
445 Unshare();
446
447 M_FONTDATA->m_info.weight = static_cast<wxFontWeight>(weight);
448
449 RealizeResource();
450}
451
452bool wxFont::SetFaceName(const wxString& faceName)
453{
454 Unshare();
455
456 M_FONTDATA->m_info.faceName = faceName;
457
458 RealizeResource();
459
460 return wxFontBase::SetFaceName(faceName);
461}
462
463void wxFont::SetUnderlined(bool underlined)
464{
465 Unshare();
466
467 M_FONTDATA->m_info.underlined = underlined;
468
469 RealizeResource();
470}
471
472/* New font system */
473wxString wxFont::GetFaceName() const
474{
475 wxString str;
476 if (M_FONTDATA)
477 str = M_FONTDATA->m_info.faceName;
478 return str;
479}
480
481// vim:sts=4:sw=4:et