Commit | Line | Data |
---|---|---|
a24aff65 | 1 | ///////////////////////////////////////////////////////////////////////////// |
80fdcdb9 | 2 | // Name: src/cocoa/font.mm |
a24aff65 DE |
3 | // Purpose: wxFont class |
4 | // Author: AUTHOR | |
5 | // Modified by: | |
6 | // Created: ??/??/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) AUTHOR | |
8898456d | 9 | // Licence: wxWindows licence |
a24aff65 DE |
10 | ///////////////////////////////////////////////////////////////////////////// |
11 | ||
51146826 DE |
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 | ||
4c51a665 | 67 | The only way to get that behaviour without NSFontManager is to pare down the |
51146826 DE |
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 | */ | |
8898456d WS |
74 | #include "wx/wxprec.h" |
75 | ||
48a1108e WS |
76 | #include "wx/font.h" |
77 | ||
8898456d WS |
78 | #ifndef WX_PRECOMP |
79 | #include "wx/string.h" | |
dd05139a | 80 | #include "wx/gdicmn.h" |
8898456d WS |
81 | #endif |
82 | ||
151b7b73 | 83 | #include "wx/fontutil.h" |
9c6e197f | 84 | #include "wx/encinfo.h" |
a24aff65 | 85 | |
51146826 DE |
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 | |
94 | static NSFont* GetNSFontForNativeFontInfo(const wxNativeFontInfo &info); | |
95 | static void UpdateNativeFontInfoWithNSFont(wxNativeFontInfo &info, NSFont *cocoaNSFont); | |
96 | static wxNativeFontInfo MakeNativeFontInfoForNSFont(NSFont *cocoaNSFont, bool underlined = false); | |
0c14b6c3 | 97 | static wxNativeFontInfo MakeNativeFontInfo(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding); |
51146826 DE |
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 | |
4c51a665 | 105 | it's possible that someone did subclass it to get better font behaviour. |
51146826 DE |
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 | */ | |
99d21c0e DE |
114 | class WXDLLEXPORT wxFontRefData: public wxGDIRefData |
115 | { | |
116 | friend class WXDLLIMPEXP_FWD_CORE wxFont; | |
117 | public: | |
118 | wxFontRefData() | |
51146826 DE |
119 | : m_cocoaNSFont(nil) |
120 | , m_info(MakeNativeFontInfo(10, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE, | |
121 | wxT("Geneva"), wxFONTENCODING_DEFAULT)) | |
99d21c0e | 122 | { |
51146826 | 123 | CreateNSFontAndUpdateInfo(); |
99d21c0e DE |
124 | } |
125 | ||
126 | wxFontRefData(const wxFontRefData& data) | |
151b7b73 | 127 | : wxGDIRefData() |
51146826 | 128 | , m_cocoaNSFont([data.m_cocoaNSFont retain]) |
151b7b73 | 129 | , m_info(data.m_info) |
99d21c0e | 130 | { |
99d21c0e DE |
131 | } |
132 | ||
51146826 DE |
133 | wxFontRefData(NSFont *cocoaNSFont, bool underlined) |
134 | : wxGDIRefData() | |
135 | , m_cocoaNSFont([cocoaNSFont retain]) | |
136 | , m_info(MakeNativeFontInfoForNSFont(m_cocoaNSFont, underlined)) | |
137 | { | |
138 | } | |
139 | ||
05725592 DE |
140 | wxFontRefData(const wxNativeFontInfo& info) |
141 | : wxGDIRefData() | |
51146826 | 142 | , m_cocoaNSFont(nil) |
05725592 | 143 | , m_info(info) |
51146826 DE |
144 | { |
145 | CreateNSFontAndUpdateInfo(); | |
146 | } | |
05725592 | 147 | |
99d21c0e | 148 | wxFontRefData(int size, |
0c14b6c3 FM |
149 | wxFontFamily family, |
150 | wxFontStyle style, | |
151 | wxFontWeight weight, | |
99d21c0e DE |
152 | bool underlined, |
153 | const wxString& faceName, | |
154 | wxFontEncoding encoding) | |
51146826 DE |
155 | : m_cocoaNSFont(nil) |
156 | , m_info(MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding)) | |
99d21c0e | 157 | { |
51146826 | 158 | CreateNSFontAndUpdateInfo(); |
99d21c0e DE |
159 | } |
160 | ||
161 | virtual ~wxFontRefData(); | |
162 | protected: | |
51146826 DE |
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 | */ | |
99d21c0e | 168 | void Init(int size, |
0c14b6c3 FM |
169 | wxFontFamily family, |
170 | wxFontStyle style, | |
171 | wxFontWeight weight, | |
99d21c0e DE |
172 | bool underlined, |
173 | const wxString& faceName, | |
174 | wxFontEncoding encoding); | |
175 | ||
51146826 DE |
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 | ||
99d21c0e | 193 | // font characterstics |
51146826 | 194 | NSFont *m_cocoaNSFont; |
151b7b73 DE |
195 | wxNativeFontInfo m_info; |
196 | ||
99d21c0e DE |
197 | public: |
198 | }; | |
151b7b73 | 199 | |
51146826 DE |
200 | NSString *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) | |
220 | static 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 | */ | |
241 | static 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 | */ | |
271 | static 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 | ||
0c14b6c3 | 284 | static wxNativeFontInfo MakeNativeFontInfo(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding) |
a24aff65 | 285 | { |
51146826 | 286 | wxNativeFontInfo m_info; // NOTE: not an i-var despite name |
151b7b73 DE |
287 | m_info.pointSize = size; |
288 | m_info.family = static_cast<wxFontFamily>(family); | |
289 | m_info.style = static_cast<wxFontStyle>(style); | |
290 | m_info.weight = static_cast<wxFontWeight>(weight); | |
291 | m_info.underlined = underlined; | |
292 | m_info.faceName = faceName; | |
293 | m_info.encoding = encoding; | |
51146826 DE |
294 | return m_info; |
295 | } | |
296 | ||
0c14b6c3 | 297 | void wxFontRefData::Init(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding) |
51146826 DE |
298 | { |
299 | m_info = MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding); | |
a24aff65 DE |
300 | } |
301 | ||
302 | wxFontRefData::~wxFontRefData() | |
303 | { | |
51146826 DE |
304 | [m_cocoaNSFont release]; |
305 | m_cocoaNSFont = nil; | |
a24aff65 DE |
306 | // TODO: delete font data |
307 | } | |
308 | ||
68c95704 | 309 | #define M_FONTDATA ((wxFontRefData*)m_refData) |
873fd4af | 310 | |
51146826 DE |
311 | wxFont wxCocoaFontFactory::InstanceForNSFont(WX_NSFont cocoaFont, bool underlined) |
312 | { | |
313 | return wxFont(new wxFontRefData(cocoaFont, underlined)); | |
314 | } | |
315 | ||
316 | bool wxFont::Create(wxFontRefData *refData) | |
317 | { | |
318 | UnRef(); | |
319 | m_refData = refData; | |
8f884a0d | 320 | |
51146826 DE |
321 | return m_refData != NULL; |
322 | } | |
323 | ||
05725592 | 324 | bool wxFont::Create(const wxNativeFontInfo& nativeFontInfo) |
a24aff65 | 325 | { |
05725592 DE |
326 | UnRef(); |
327 | m_refData = new wxFontRefData(nativeFontInfo); | |
8f884a0d | 328 | |
05725592 | 329 | return true; |
a24aff65 DE |
330 | } |
331 | ||
8f884a0d VZ |
332 | wxGDIRefData *wxFont::CreateGDIRefData() const |
333 | { | |
334 | return new wxFontRefData; | |
335 | } | |
336 | ||
337 | wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const | |
338 | { | |
5c33522f | 339 | return new wxFontRefData(*static_cast<const wxFontRefData *>(data)); |
8f884a0d VZ |
340 | } |
341 | ||
a24aff65 DE |
342 | void wxFont::SetEncoding(wxFontEncoding) |
343 | { | |
344 | } | |
345 | ||
346 | wxFontEncoding wxFont::GetEncoding() const | |
347 | { | |
348 | return wxFontEncoding(); | |
349 | } | |
350 | ||
351 | int wxFont::GetPointSize() const | |
352 | { | |
a1b806b9 | 353 | wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); |
05725592 | 354 | return M_FONTDATA->m_info.pointSize; |
a24aff65 DE |
355 | } |
356 | ||
357 | bool wxFont::GetUnderlined() const | |
358 | { | |
e7e97a59 | 359 | if(M_FONTDATA) |
151b7b73 | 360 | return M_FONTDATA->m_info.underlined; |
e7e97a59 DE |
361 | else |
362 | return false; | |
a24aff65 DE |
363 | } |
364 | ||
0c14b6c3 | 365 | wxFontStyle wxFont::GetStyle() const |
a24aff65 | 366 | { |
a1b806b9 | 367 | wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); |
05725592 | 368 | return M_FONTDATA->m_info.style; |
a24aff65 DE |
369 | } |
370 | ||
59b7da02 | 371 | wxFontFamily wxFont::DoGetFamily() const |
a24aff65 | 372 | { |
05725592 | 373 | return M_FONTDATA->m_info.family; |
a24aff65 DE |
374 | } |
375 | ||
0c14b6c3 | 376 | wxFontWeight wxFont::GetWeight() const |
a24aff65 | 377 | { |
a1b806b9 | 378 | wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); |
05725592 | 379 | return M_FONTDATA->m_info.weight; |
a24aff65 DE |
380 | } |
381 | ||
3bf5a59b VZ |
382 | const wxNativeFontInfo *wxFont::GetNativeFontInfo() const |
383 | { | |
a1b806b9 | 384 | wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); |
151b7b73 | 385 | return &M_FONTDATA->m_info; |
3bf5a59b VZ |
386 | } |
387 | ||
0c14b6c3 | 388 | bool wxFont::Create(int pointSize, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding) |
a24aff65 DE |
389 | { |
390 | UnRef(); | |
151b7b73 | 391 | m_refData = new wxFontRefData(pointSize, family, style, weight, underlined, faceName, encoding); |
a24aff65 DE |
392 | |
393 | RealizeResource(); | |
394 | ||
8898456d | 395 | return true; |
a24aff65 DE |
396 | } |
397 | ||
398 | wxFont::~wxFont() | |
399 | { | |
a24aff65 DE |
400 | } |
401 | ||
402 | bool wxFont::RealizeResource() | |
403 | { | |
404 | // TODO: create the font (if there is a native font object) | |
8898456d | 405 | return false; |
a24aff65 DE |
406 | } |
407 | ||
a24aff65 DE |
408 | void wxFont::SetPointSize(int pointSize) |
409 | { | |
8f884a0d | 410 | AllocExclusive(); |
a24aff65 | 411 | |
151b7b73 | 412 | M_FONTDATA->m_info.pointSize = pointSize; |
a24aff65 DE |
413 | |
414 | RealizeResource(); | |
415 | } | |
416 | ||
0c14b6c3 | 417 | void wxFont::SetFamily(wxFontFamily family) |
a24aff65 | 418 | { |
8f884a0d | 419 | AllocExclusive(); |
a24aff65 | 420 | |
151b7b73 | 421 | M_FONTDATA->m_info.family = static_cast<wxFontFamily>(family); |
a24aff65 DE |
422 | |
423 | RealizeResource(); | |
424 | } | |
425 | ||
0c14b6c3 | 426 | void wxFont::SetStyle(wxFontStyle style) |
a24aff65 | 427 | { |
8f884a0d | 428 | AllocExclusive(); |
a24aff65 | 429 | |
151b7b73 | 430 | M_FONTDATA->m_info.style = static_cast<wxFontStyle>(style); |
a24aff65 DE |
431 | |
432 | RealizeResource(); | |
433 | } | |
434 | ||
0c14b6c3 | 435 | void wxFont::SetWeight(wxFontWeight weight) |
a24aff65 | 436 | { |
8f884a0d | 437 | AllocExclusive(); |
a24aff65 | 438 | |
151b7b73 | 439 | M_FONTDATA->m_info.weight = static_cast<wxFontWeight>(weight); |
a24aff65 DE |
440 | |
441 | RealizeResource(); | |
442 | } | |
443 | ||
85ab460e | 444 | bool wxFont::SetFaceName(const wxString& faceName) |
a24aff65 | 445 | { |
8f884a0d | 446 | AllocExclusive(); |
a24aff65 | 447 | |
151b7b73 | 448 | M_FONTDATA->m_info.faceName = faceName; |
a24aff65 DE |
449 | |
450 | RealizeResource(); | |
85ab460e VZ |
451 | |
452 | return wxFontBase::SetFaceName(faceName); | |
a24aff65 DE |
453 | } |
454 | ||
455 | void wxFont::SetUnderlined(bool underlined) | |
456 | { | |
8f884a0d | 457 | AllocExclusive(); |
a24aff65 | 458 | |
151b7b73 | 459 | M_FONTDATA->m_info.underlined = underlined; |
a24aff65 DE |
460 | |
461 | RealizeResource(); | |
462 | } | |
463 | ||
464 | /* New font system */ | |
465 | wxString wxFont::GetFaceName() const | |
466 | { | |
b0c0a393 | 467 | wxString str; |
a24aff65 | 468 | if (M_FONTDATA) |
151b7b73 | 469 | str = M_FONTDATA->m_info.faceName; |
a24aff65 DE |
470 | return str; |
471 | } | |
472 | ||
473 | // vim:sts=4:sw=4:et |