]> git.saurik.com Git - wxWidgets.git/blob - src/cocoa/font.mm
Use wxMarkupParser in wxStaticText for dealing with markup.
[wxWidgets.git] / src / cocoa / font.mm
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
94 static NSFont* GetNSFontForNativeFontInfo(const wxNativeFontInfo &info);
95 static void UpdateNativeFontInfoWithNSFont(wxNativeFontInfo &info, NSFont *cocoaNSFont);
96 static wxNativeFontInfo MakeNativeFontInfoForNSFont(NSFont *cocoaNSFont, bool underlined = false);
97 static wxNativeFontInfo MakeNativeFontInfo(int size, wxFontFamily family, wxFontStyle style, wxFontWeight 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 */
114 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
115 {
116 friend class WXDLLIMPEXP_FWD_CORE wxFont;
117 public:
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 wxFontFamily family,
150 wxFontStyle style,
151 wxFontWeight 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();
162 protected:
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 wxFontFamily family,
170 wxFontStyle style,
171 wxFontWeight 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
197 public:
198 };
199
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
284 static wxNativeFontInfo MakeNativeFontInfo(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
285 {
286 wxNativeFontInfo m_info; // NOTE: not an i-var despite name
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;
294 return m_info;
295 }
296
297 void wxFontRefData::Init(int size, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
298 {
299 m_info = MakeNativeFontInfo(size, family, style, weight, underlined, faceName, encoding);
300 }
301
302 wxFontRefData::~wxFontRefData()
303 {
304 [m_cocoaNSFont release];
305 m_cocoaNSFont = nil;
306 // TODO: delete font data
307 }
308
309 #define M_FONTDATA ((wxFontRefData*)m_refData)
310
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;
320
321 return m_refData != NULL;
322 }
323
324 bool wxFont::Create(const wxNativeFontInfo& nativeFontInfo)
325 {
326 UnRef();
327 m_refData = new wxFontRefData(nativeFontInfo);
328
329 return true;
330 }
331
332 wxGDIRefData *wxFont::CreateGDIRefData() const
333 {
334 return new wxFontRefData;
335 }
336
337 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
338 {
339 return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
340 }
341
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 {
353 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
354 return M_FONTDATA->m_info.pointSize;
355 }
356
357 bool wxFont::GetUnderlined() const
358 {
359 if(M_FONTDATA)
360 return M_FONTDATA->m_info.underlined;
361 else
362 return false;
363 }
364
365 wxFontStyle wxFont::GetStyle() const
366 {
367 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
368 return M_FONTDATA->m_info.style;
369 }
370
371 wxFontFamily wxFont::DoGetFamily() const
372 {
373 return M_FONTDATA->m_info.family;
374 }
375
376 wxFontWeight wxFont::GetWeight() const
377 {
378 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
379 return M_FONTDATA->m_info.weight;
380 }
381
382 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
383 {
384 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
385 return &M_FONTDATA->m_info;
386 }
387
388 bool wxFont::Create(int pointSize, wxFontFamily family, wxFontStyle style, wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding)
389 {
390 UnRef();
391 m_refData = new wxFontRefData(pointSize, family, style, weight, underlined, faceName, encoding);
392
393 RealizeResource();
394
395 return true;
396 }
397
398 wxFont::~wxFont()
399 {
400 }
401
402 bool wxFont::RealizeResource()
403 {
404 // TODO: create the font (if there is a native font object)
405 return false;
406 }
407
408 void wxFont::SetPointSize(int pointSize)
409 {
410 AllocExclusive();
411
412 M_FONTDATA->m_info.pointSize = pointSize;
413
414 RealizeResource();
415 }
416
417 void wxFont::SetFamily(wxFontFamily family)
418 {
419 AllocExclusive();
420
421 M_FONTDATA->m_info.family = static_cast<wxFontFamily>(family);
422
423 RealizeResource();
424 }
425
426 void wxFont::SetStyle(wxFontStyle style)
427 {
428 AllocExclusive();
429
430 M_FONTDATA->m_info.style = static_cast<wxFontStyle>(style);
431
432 RealizeResource();
433 }
434
435 void wxFont::SetWeight(wxFontWeight weight)
436 {
437 AllocExclusive();
438
439 M_FONTDATA->m_info.weight = static_cast<wxFontWeight>(weight);
440
441 RealizeResource();
442 }
443
444 bool wxFont::SetFaceName(const wxString& faceName)
445 {
446 AllocExclusive();
447
448 M_FONTDATA->m_info.faceName = faceName;
449
450 RealizeResource();
451
452 return wxFontBase::SetFaceName(faceName);
453 }
454
455 void wxFont::SetUnderlined(bool underlined)
456 {
457 AllocExclusive();
458
459 M_FONTDATA->m_info.underlined = underlined;
460
461 RealizeResource();
462 }
463
464 /* New font system */
465 wxString wxFont::GetFaceName() const
466 {
467 wxString str;
468 if (M_FONTDATA)
469 str = M_FONTDATA->m_info.faceName;
470 return str;
471 }
472
473 // vim:sts=4:sw=4:et