]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/font.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Use IsOk() instead of Ok()
[wxWidgets.git] / src / mac / carbon / font.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/mac/carbon/font.cpp
3// Purpose: wxFont class
4// Author: Stefan Csomor
5// Modified by:
6// Created: 1998-01-01
7// RCS-ID: $Id$
8// Copyright: (c) Stefan Csomor
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12#include "wx/wxprec.h"
13
14#include "wx/font.h"
15
16#ifndef WX_PRECOMP
17 #include "wx/string.h"
18 #include "wx/utils.h"
19 #include "wx/intl.h"
20 #include "wx/gdicmn.h"
21 #include "wx/log.h"
22#endif
23
24#include "wx/fontutil.h"
25#include "wx/graphics.h"
26
27#include "wx/mac/uma.h"
28
29#ifndef __DARWIN__
30#include <ATSUnicode.h>
31#endif
32
33#include <map>
34#include <string>
35
36IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
37
38
39class WXDLLEXPORT wxFontRefData: public wxGDIRefData
40{
41public:
42 wxFontRefData()
43 {
44 Init(10, wxDEFAULT, wxNORMAL, wxNORMAL,
45 false, wxT("applicationfont"), wxFONTENCODING_DEFAULT);
46 }
47
48 wxFontRefData(const wxFontRefData& data)
49 {
50 Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
51 data.m_underlined, data.m_faceName, data.m_encoding);
52 }
53
54 wxFontRefData(int size,
55 int family,
56 int style,
57 int weight,
58 bool underlined,
59 const wxString& faceName,
60 wxFontEncoding encoding)
61 {
62 Init(size, family, style, weight, underlined, faceName, encoding);
63 }
64
65#if wxMAC_USE_CORE_TEXT
66 wxFontRefData( wxUint32 coreTextFontType );
67 wxFontRefData( CTFontRef font );
68 wxFontRefData( CTFontDescriptorRef fontdescriptor, int size );
69#endif
70
71 virtual ~wxFontRefData();
72
73 void SetNoAntiAliasing( bool no = true ) { m_noAA = no; }
74
75 bool GetNoAntiAliasing() const { return m_noAA; }
76
77 void SetPointSize( int size )
78 {
79 m_pointSize = size;
80 MacInvalidateNativeFont();
81 }
82
83 int GetPointSize() const { return m_pointSize; }
84
85 void SetFamily( int family )
86 {
87 m_family = family;
88 MacInvalidateNativeFont();
89 }
90
91
92 int GetFamily() const { return m_family; }
93
94 void SetStyle( int style )
95 {
96 m_style = style;
97 MacInvalidateNativeFont();
98 }
99
100
101 int GetStyle() const { return m_style; }
102
103 void SetWeight( int weight )
104 {
105 m_weight = weight;
106 MacInvalidateNativeFont();
107 }
108
109
110 int GetWeight() const { return m_weight; }
111
112 void SetUnderlined( bool u )
113 {
114 m_underlined = u;
115 MacInvalidateNativeFont();
116 }
117
118 bool GetUnderlined() const { return m_underlined; }
119
120 void SetFaceName( const wxString& facename )
121 {
122 m_faceName = facename;
123 MacInvalidateNativeFont();
124 }
125
126 const wxString& GetFaceName() const { return m_faceName; }
127
128 void SetEncoding( wxFontEncoding encoding )
129 {
130 m_encoding = encoding;
131 MacInvalidateNativeFont();
132 }
133
134 wxFontEncoding GetEncoding() const { return m_encoding; }
135
136 void MacInvalidateNativeFont();
137
138 void MacFindFont();
139
140protected:
141 // common part of all ctors
142 void Init(int size,
143 int family,
144 int style,
145 int weight,
146 bool underlined,
147 const wxString& faceName,
148 wxFontEncoding encoding);
149
150#if wxMAC_USE_CORE_TEXT
151 void Init( CTFontRef font );
152#endif
153 // font characterstics
154 int m_pointSize;
155 int m_family;
156 int m_style;
157 int m_weight;
158 bool m_underlined;
159 wxString m_faceName;
160 wxFontEncoding m_encoding;
161 bool m_noAA; // No anti-aliasing
162
163public:
164#if wxMAC_USE_ATSU_TEXT
165 FMFontFamily m_macFontFamily;
166 FMFontSize m_macFontSize;
167 FMFontStyle m_macFontStyle;
168
169 // ATSU Font Information
170
171 // this is split into an ATSU font id that may
172 // contain some styles (special bold fonts etc) and
173 // these are the additional qd styles that are not
174 // included in the ATSU font id
175 ATSUFontID m_macATSUFontID;
176 FMFontStyle m_macATSUAdditionalQDStyles ;
177
178 // for true themeing support we must store the correct font
179 // information here, as this speeds up and optimizes rendering
180 ThemeFontID m_macThemeFontID ;
181#endif
182#if wxMAC_USE_CORE_TEXT
183 wxCFRef<CTFontRef> m_ctFont;
184 wxCFRef<CTFontDescriptorRef> m_ctFontDescriptor;
185#endif
186#if wxMAC_USE_CORE_TEXT || wxMAC_USE_ATSU_TEXT
187 ATSUStyle m_macATSUStyle ;
188#endif
189 wxNativeFontInfo m_info;
190};
191
192#define M_FONTDATA ((wxFontRefData*)m_refData)
193
194
195// ============================================================================
196// implementation
197// ============================================================================
198
199// ----------------------------------------------------------------------------
200// wxFontRefData
201// ----------------------------------------------------------------------------
202
203void wxFontRefData::Init(int pointSize,
204 int family,
205 int style,
206 int weight,
207 bool underlined,
208 const wxString& faceName,
209 wxFontEncoding encoding)
210{
211 m_style = style;
212 m_pointSize = pointSize;
213 m_family = family;
214 m_style = style;
215 m_weight = weight;
216 m_underlined = underlined;
217 m_faceName = faceName;
218 m_encoding = encoding;
219 m_noAA = false;
220#if wxMAC_USE_ATSU_TEXT
221 m_macFontFamily = 0 ;
222 m_macFontSize = 0;
223 m_macFontStyle = 0;
224 m_macATSUFontID = 0;
225 m_macATSUAdditionalQDStyles = 0 ;
226 m_macThemeFontID = kThemeCurrentPortFont ;
227#endif
228#if wxMAC_USE_CORE_TEXT || wxMAC_USE_ATSU_TEXT
229 m_macATSUStyle = NULL ;
230#endif
231}
232
233wxFontRefData::~wxFontRefData()
234{
235#if wxMAC_USE_CORE_TEXT || wxMAC_USE_ATSU_TEXT
236 if ( m_macATSUStyle )
237 {
238 ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
239 m_macATSUStyle = NULL ;
240 }
241#endif
242}
243
244void wxFontRefData::MacInvalidateNativeFont()
245{
246#if wxMAC_USE_CORE_TEXT
247 m_ctFont.reset();
248 m_ctFontDescriptor.reset();
249#endif
250#if wxMAC_USE_CORE_TEXT || wxMAC_USE_ATSU_TEXT
251 if ( m_macATSUStyle )
252 {
253 ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
254 m_macATSUStyle = NULL ;
255 }
256#endif
257}
258
259#if wxMAC_USE_CORE_TEXT
260
261/* from Core Text Manual Common Operations */
262
263static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
264{
265 CTFontDescriptorRef descriptor = NULL;
266 CFMutableDictionaryRef attributes;
267
268 assert(iFamilyName != NULL);
269 // Create a mutable dictionary to hold our attributes.
270 attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
271 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
272 check(attributes != NULL);
273
274 if (attributes != NULL) {
275 // Add a family name to our attributes.
276 CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
277
278
279 if ( iTraits ) {
280 CFMutableDictionaryRef traits;
281 CFNumberRef symTraits;
282
283 // Create the traits dictionary.
284 symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
285 &iTraits);
286 check(symTraits != NULL);
287
288 if (symTraits != NULL) {
289 // Create a dictionary to hold our traits values.
290 traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
291 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
292 check(traits != NULL);
293
294 if (traits != NULL) {
295 // Add the symbolic traits value to the traits dictionary.
296 CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
297
298 // Add the traits attribute to our attributes.
299 CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
300 CFRelease(traits);
301 }
302 CFRelease(symTraits);
303 }
304 }
305 // Create the font descriptor with our attributes
306 descriptor = CTFontDescriptorCreateWithAttributes(attributes);
307 check(descriptor != NULL);
308
309 CFRelease(attributes);
310 }
311 // Return our font descriptor.
312 return descriptor ;
313}
314
315wxFontRefData::wxFontRefData( wxUint32 coreTextFontType )
316{
317 CTFontRef font = CTFontCreateUIFontForLanguage( coreTextFontType, 0.0, NULL ) ;
318 if ( CTFontGetSize(m_ctFont) == 0 )
319 {
320 CFRelease(font);
321 font = CTFontCreateUIFontForLanguage( coreTextFontType, 12.0, NULL );
322 }
323 Init( font );
324}
325
326wxFontRefData::wxFontRefData( CTFontRef font )
327{
328 Init( font );
329}
330
331wxFontRefData::wxFontRefData( CTFontDescriptorRef fontdescriptor, int size )
332{
333 if ( size == 0 )
334 {
335 wxCFRef< CFNumberRef > value( (CFNumberRef) CTFontDescriptorCopyAttribute( fontdescriptor, kCTFontSizeAttribute ) );
336
337 float fsize;
338 if ( CFNumberGetValue( value , kCFNumberFloatType , &fsize ) )
339 {
340 size = (int) fsize + 0.5 ;
341 }
342 }
343 Init( CTFontCreateWithFontDescriptor(fontdescriptor, size,NULL) );
344}
345
346void wxFontRefData::Init( CTFontRef font )
347{
348 Init(10, wxDEFAULT, wxNORMAL, wxNORMAL,
349 false, wxT("applicationfont"), wxFONTENCODING_DEFAULT);
350
351 m_ctFont.reset( font );
352}
353
354#endif
355
356void wxFontRefData::MacFindFont()
357{
358
359#if wxMAC_USE_CORE_TEXT
360 if ( UMAGetSystemVersion() >= 0x1050 )
361 {
362 if ( m_faceName.empty() && m_family == wxDEFAULT )
363 {
364 m_ctFont.reset(CTFontCreateUIFontForLanguage( kCTFontSystemFontType, 0.0, NULL ));
365 }
366
367 if ( m_ctFont )
368 {
369 wxCFStringRef name( CTFontCopyFamilyName( m_ctFont ) );
370 m_faceName = name.AsString();
371 m_pointSize = CTFontGetSize(m_ctFont) ;
372 CTFontSymbolicTraits traits = CTFontGetSymbolicTraits( m_ctFont );
373 if ( traits & kCTFontItalicTrait )
374 m_style = wxITALIC;
375 if ( traits & kCTFontBoldTrait )
376 m_weight = wxBOLD ;
377 if ( !m_ctFontDescriptor.get() )
378 m_ctFontDescriptor.reset( CTFontCopyFontDescriptor( m_ctFont ) );
379 }
380 else
381 {
382 if ( m_faceName.empty() )
383 {
384 switch ( m_family )
385 {
386 case wxSCRIPT :
387 case wxROMAN :
388 case wxDECORATIVE :
389 m_faceName = wxT("Times");
390 break ;
391
392 case wxSWISS :
393 m_faceName = wxT("Lucida Grande");
394 break ;
395
396 case wxMODERN :
397 case wxTELETYPE:
398 m_faceName = wxT("Monaco");
399 break ;
400
401 default:
402 m_faceName = wxT("Times");
403 break ;
404 }
405 }
406
407
408 CTFontSymbolicTraits traits = 0;
409
410 if (m_weight == wxBOLD)
411 traits |= kCTFontBoldTrait;
412 if (m_style == wxITALIC || m_style == wxSLANT)
413 traits |= kCTFontItalicTrait;
414
415// use font descriptor caching
416#if 1
417 wxString lookupname = wxString::Format( "%s_%ld", m_faceName.c_str(), traits );
418
419 static std::map< std::wstring , wxCFRef< CTFontDescriptorRef > > fontdescriptorcache ;
420
421 m_ctFontDescriptor = fontdescriptorcache[ std::wstring(lookupname.wc_str()) ];
422 if ( !m_ctFontDescriptor )
423 {
424 wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
425 m_ctFontDescriptor.reset( wxMacCreateCTFontDescriptor( cf, traits ) );
426 fontdescriptorcache[ std::wstring(lookupname.wc_str()) ] = m_ctFontDescriptor;
427 }
428#else
429 wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
430 m_ctFontDescriptor.reset( wxMacCreateCTFontDescriptor( cf, traits ) );
431#endif
432
433// use font caching
434#if 1
435 wxString lookupnameWithSize = wxString::Format( "%s_%ld_%ld", m_faceName.c_str(), traits, m_pointSize );
436
437 static std::map< std::wstring , wxCFRef< CTFontRef > > fontcache ;
438 m_ctFont = fontcache[ std::wstring(lookupnameWithSize.wc_str()) ];
439 if ( !m_ctFont )
440 {
441 m_ctFont.reset( CTFontCreateWithFontDescriptor( m_ctFontDescriptor, m_pointSize, NULL ) );
442 fontcache[ std::wstring(lookupnameWithSize.wc_str()) ] = m_ctFont;
443 }
444#else
445 m_ctFont.reset( CTFontCreateWithFontDescriptor( m_ctFontDescriptor, m_pointSize, NULL ) );
446#endif
447 }
448#if wxMAC_USE_ATSU_TEXT == 0
449 OSStatus status = noErr;
450 CTFontDescriptorRef desc = m_ctFontDescriptor ;
451 ATSFontRef atsfont = CTFontGetPlatformFont( m_ctFont, &desc );
452 FMFont fmfont = FMGetFontFromATSFontRef( atsfont );
453 ATSUAttributeTag atsuTags[] =
454 {
455 kATSUFontTag ,
456 kATSUSizeTag ,
457 kATSUVerticalCharacterTag,
458 kATSUQDBoldfaceTag ,
459 kATSUQDItalicTag ,
460 kATSUQDUnderlineTag ,
461 };
462 ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
463 {
464 sizeof( ATSUFontID ) ,
465 sizeof( Fixed ) ,
466 sizeof( ATSUVerticalCharacterType),
467 sizeof( Boolean ) ,
468 sizeof( Boolean ) ,
469 sizeof( Boolean ) ,
470 };
471 Boolean kTrue = true ;
472 Boolean kFalse = false ;
473
474 Fixed atsuSize = IntToFixed( m_pointSize );
475 ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
476 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
477 {
478 &fmfont ,
479 &atsuSize ,
480 &kHorizontal,
481 (m_weight == wxBOLD) ? &kTrue : &kFalse ,
482 (m_style == wxITALIC || m_style == wxSLANT) ? &kTrue : &kFalse ,
483 (m_underlined) ? &kTrue : &kFalse ,
484 };
485
486 if ( m_macATSUStyle )
487 {
488 ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
489 m_macATSUStyle = NULL ;
490 }
491 status = ::ATSUCreateStyle((ATSUStyle *)&m_macATSUStyle);
492 wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
493 status = ::ATSUSetAttributes(
494 (ATSUStyle)m_macATSUStyle,
495 sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
496 atsuTags, atsuSizes, atsuValues);
497#endif
498 }
499#endif
500#if wxMAC_USE_ATSU_TEXT
501 {
502 OSStatus status = noErr;
503 Str255 qdFontName ;
504 if ( m_macThemeFontID != kThemeCurrentPortFont )
505 {
506 Style style ;
507 GetThemeFont( m_macThemeFontID, GetApplicationScript(), qdFontName, &m_macFontSize, &style );
508 if ( m_macFontSize == 0 )
509 m_macFontSize = 12;
510 m_macFontStyle = style ;
511 m_faceName = wxMacMakeStringFromPascal( qdFontName );
512 if ( m_macFontStyle & bold )
513 m_weight = wxBOLD ;
514 else
515 m_weight = wxNORMAL ;
516 if ( m_macFontStyle & italic )
517 m_style = wxITALIC ;
518 if ( m_macFontStyle & underline )
519 m_underlined = true ;
520 m_pointSize = m_macFontSize ;
521 m_macFontFamily = FMGetFontFamilyFromName( qdFontName );
522 }
523 else
524 {
525 if ( m_faceName.empty() )
526 {
527 if ( m_family == wxDEFAULT )
528 {
529 m_macFontFamily = GetAppFont();
530 FMGetFontFamilyName(m_macFontFamily,qdFontName);
531 m_faceName = wxMacMakeStringFromPascal( qdFontName );
532 }
533 else
534 {
535 switch ( m_family )
536 {
537 case wxSCRIPT :
538 case wxROMAN :
539 case wxDECORATIVE :
540 m_faceName = wxT("Times");
541 break ;
542
543 case wxSWISS :
544 m_faceName = wxT("Lucida Grande");
545 break ;
546
547 case wxMODERN :
548 case wxTELETYPE:
549 m_faceName = wxT("Monaco");
550 break ;
551
552 default:
553 m_faceName = wxT("Times");
554 break ;
555 }
556 wxMacStringToPascal( m_faceName , qdFontName );
557 m_macFontFamily = FMGetFontFamilyFromName( qdFontName );
558 if ( m_macFontFamily == kInvalidFontFamily )
559 {
560 wxLogDebug( wxT("ATSFontFamilyFindFromName failed for %s"), m_faceName.c_str() );
561 m_macFontFamily = GetAppFont();
562 }
563 }
564 }
565 else
566 {
567 if ( m_faceName == wxT("systemfont") )
568 m_macFontFamily = GetSysFont();
569 else if ( m_faceName == wxT("applicationfont") )
570 m_macFontFamily = GetAppFont();
571 else
572 {
573 wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
574 ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
575 if ( atsfamily == (ATSFontFamilyRef) -1 )
576 {
577 wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
578 m_macFontFamily = GetAppFont();
579 }
580 else
581 m_macFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
582 }
583 }
584
585 m_macFontStyle = 0;
586 if (m_weight == wxBOLD)
587 m_macFontStyle |= bold;
588 if (m_style == wxITALIC || m_style == wxSLANT)
589 m_macFontStyle |= italic;
590 if (m_underlined)
591 m_macFontStyle |= underline;
592 m_macFontSize = m_pointSize ;
593 }
594
595 // we try to get as much styles as possible into ATSU
596
597
598 // ATSUFontID and FMFont are equivalent
599 FMFontStyle intrinsicStyle = 0 ;
600 status = FMGetFontFromFontFamilyInstance( m_macFontFamily , m_macFontStyle , &m_macATSUFontID , &intrinsicStyle);
601 wxASSERT_MSG( status == noErr , wxT("couldn't get an ATSUFont from font family") );
602 m_macATSUAdditionalQDStyles = m_macFontStyle & (~intrinsicStyle );
603
604 if ( m_macATSUStyle )
605 {
606 ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
607 m_macATSUStyle = NULL ;
608 }
609
610 status = ::ATSUCreateStyle((ATSUStyle *)&m_macATSUStyle);
611 wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
612
613 ATSUAttributeTag atsuTags[] =
614 {
615 kATSUFontTag ,
616 kATSUSizeTag ,
617 kATSUVerticalCharacterTag,
618 kATSUQDBoldfaceTag ,
619 kATSUQDItalicTag ,
620 kATSUQDUnderlineTag ,
621 kATSUQDCondensedTag ,
622 kATSUQDExtendedTag ,
623 };
624 ByteCount atsuSizes[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
625 {
626 sizeof( ATSUFontID ) ,
627 sizeof( Fixed ) ,
628 sizeof( ATSUVerticalCharacterType),
629 sizeof( Boolean ) ,
630 sizeof( Boolean ) ,
631 sizeof( Boolean ) ,
632 sizeof( Boolean ) ,
633 sizeof( Boolean ) ,
634 };
635
636 Boolean kTrue = true ;
637 Boolean kFalse = false ;
638
639 Fixed atsuSize = IntToFixed( m_macFontSize );
640 ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
641 ATSUAttributeValuePtr atsuValues[sizeof(atsuTags) / sizeof(ATSUAttributeTag)] =
642 {
643 &m_macATSUFontID ,
644 &atsuSize ,
645 &kHorizontal,
646 (m_macATSUAdditionalQDStyles & bold) ? &kTrue : &kFalse ,
647 (m_macATSUAdditionalQDStyles & italic) ? &kTrue : &kFalse ,
648 (m_macATSUAdditionalQDStyles & underline) ? &kTrue : &kFalse ,
649 (m_macATSUAdditionalQDStyles & condense) ? &kTrue : &kFalse ,
650 (m_macATSUAdditionalQDStyles & extend) ? &kTrue : &kFalse ,
651 };
652
653 status = ::ATSUSetAttributes(
654 (ATSUStyle)m_macATSUStyle,
655 sizeof(atsuTags) / sizeof(ATSUAttributeTag) ,
656 atsuTags, atsuSizes, atsuValues);
657
658 wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") );
659 return;
660 }
661#endif
662}
663
664// ----------------------------------------------------------------------------
665// wxFont
666// ----------------------------------------------------------------------------
667
668bool wxFont::Create(const wxNativeFontInfo& info)
669{
670 return Create(
671 info.pointSize, info.family, info.style, info.weight,
672 info.underlined, info.faceName, info.encoding );
673}
674
675wxFont::wxFont(const wxString& fontdesc)
676{
677 wxNativeFontInfo info;
678 if ( info.FromString(fontdesc) )
679 (void)Create(info);
680}
681
682bool wxFont::Create(int pointSize,
683 int family,
684 int style,
685 int weight,
686 bool underlined,
687 const wxString& faceName,
688 wxFontEncoding encoding)
689{
690 UnRef();
691
692 m_refData = new wxFontRefData(
693 pointSize, family, style, weight,
694 underlined, faceName, encoding);
695
696 RealizeResource();
697
698 return true;
699}
700
701#if wxMAC_USE_CORE_TEXT
702
703bool wxFont::MacCreateFromUIFont(wxUint32 ctFontType )
704{
705 UnRef();
706
707 m_refData = new wxFontRefData(ctFontType);
708 RealizeResource();
709
710 return true;
711}
712
713bool wxFont::MacCreateFromCTFontDescriptor( const void * ctFontDescriptor , int size )
714{
715 UnRef();
716
717 m_refData = new wxFontRefData((CTFontDescriptorRef)ctFontDescriptor, size);;
718 RealizeResource();
719
720 return true;
721}
722
723
724#endif
725
726bool wxFont::MacCreateFromThemeFont(wxUint16 themeFontID)
727{
728#if wxMAC_USE_CORE_TEXT
729 if ( UMAGetSystemVersion() >= 0x1050)
730 {
731 return MacCreateFromUIFont(HIThemeGetUIFontType(themeFontID));
732 }
733#endif
734#if wxMAC_USE_ATSU_TEXT
735 {
736 UnRef();
737
738 m_refData = new wxFontRefData(
739 12, wxDEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
740 false, wxEmptyString, wxFONTENCODING_DEFAULT );
741
742 M_FONTDATA->m_macThemeFontID = themeFontID ;
743 RealizeResource();
744 return true;
745 }
746#endif
747 return false;
748}
749
750wxFont::~wxFont()
751{
752}
753
754bool wxFont::RealizeResource()
755{
756 M_FONTDATA->MacFindFont();
757
758 return true;
759}
760
761void wxFont::SetEncoding(wxFontEncoding encoding)
762{
763 Unshare();
764
765 M_FONTDATA->SetEncoding( encoding );
766
767 RealizeResource();
768}
769
770void wxFont::Unshare()
771{
772 // Don't change shared data
773 if (!m_refData)
774 {
775 m_refData = new wxFontRefData();
776 }
777 else
778 {
779 wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
780 UnRef();
781 m_refData = ref;
782 }
783}
784
785wxGDIRefData *wxFont::CreateGDIRefData() const
786{
787 return new wxFontRefData;
788}
789
790wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
791{
792 return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
793}
794
795void wxFont::SetPointSize(int pointSize)
796{
797 if ( M_FONTDATA->GetPointSize() == pointSize )
798 return;
799
800 Unshare();
801
802 M_FONTDATA->SetPointSize( pointSize );
803
804 RealizeResource();
805}
806
807void wxFont::SetFamily(int family)
808{
809 Unshare();
810
811 M_FONTDATA->SetFamily( family );
812
813 RealizeResource();
814}
815
816void wxFont::SetStyle(int style)
817{
818 Unshare();
819
820 M_FONTDATA->SetStyle( style );
821
822 RealizeResource();
823}
824
825void wxFont::SetWeight(int weight)
826{
827 Unshare();
828
829 M_FONTDATA->SetWeight( weight );
830
831 RealizeResource();
832}
833
834bool wxFont::SetFaceName(const wxString& faceName)
835{
836 Unshare();
837
838 M_FONTDATA->SetFaceName( faceName );
839
840 RealizeResource();
841
842 return wxFontBase::SetFaceName(faceName);
843}
844
845void wxFont::SetUnderlined(bool underlined)
846{
847 Unshare();
848
849 M_FONTDATA->SetUnderlined( underlined );
850
851 RealizeResource();
852}
853
854void wxFont::SetNoAntiAliasing( bool no )
855{
856 Unshare();
857
858 M_FONTDATA->SetNoAntiAliasing( no );
859
860 RealizeResource();
861}
862
863// ----------------------------------------------------------------------------
864// accessors
865// ----------------------------------------------------------------------------
866
867// TODO: insert checks everywhere for M_FONTDATA == NULL!
868
869int wxFont::GetPointSize() const
870{
871 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
872
873 return M_FONTDATA->GetPointSize();
874}
875
876wxSize wxFont::GetPixelSize() const
877{
878#if wxUSE_GRAPHICS_CONTEXT
879 // TODO: consider caching the value
880 wxGraphicsContext* dc = wxGraphicsContext::CreateFromNative((CGContextRef) NULL);
881 dc->SetFont(*(wxFont *)this,*wxBLACK);
882 wxDouble width, height = 0;
883 dc->GetTextExtent( wxT("g"), &width, &height, NULL, NULL);
884 delete dc;
885 return wxSize((int)width, (int)height);
886#else
887 return wxFontBase::GetPixelSize();
888#endif
889}
890
891int wxFont::GetFamily() const
892{
893 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
894
895 return M_FONTDATA->GetFamily();
896}
897
898int wxFont::GetStyle() const
899{
900 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
901
902 return M_FONTDATA->GetStyle() ;
903}
904
905int wxFont::GetWeight() const
906{
907 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
908
909 return M_FONTDATA->GetWeight();
910}
911
912bool wxFont::GetUnderlined() const
913{
914 wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
915
916 return M_FONTDATA->GetUnderlined();
917}
918
919wxString wxFont::GetFaceName() const
920{
921 wxCHECK_MSG( M_FONTDATA != NULL , wxEmptyString , wxT("invalid font") );
922
923 return M_FONTDATA->GetFaceName() ;
924}
925
926wxFontEncoding wxFont::GetEncoding() const
927{
928 wxCHECK_MSG( M_FONTDATA != NULL , wxFONTENCODING_DEFAULT , wxT("invalid font") );
929
930 return M_FONTDATA->GetEncoding() ;
931}
932
933bool wxFont::GetNoAntiAliasing() const
934{
935 wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
936
937 return M_FONTDATA->GetNoAntiAliasing();
938}
939
940#if wxMAC_USE_ATSU_TEXT
941
942short wxFont::MacGetFontNum() const
943{
944 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
945
946 return M_FONTDATA->m_macFontFamily;
947}
948
949short wxFont::MacGetFontSize() const
950{
951 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
952
953 return M_FONTDATA->m_macFontSize;
954}
955
956wxByte wxFont::MacGetFontStyle() const
957{
958 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
959
960 return M_FONTDATA->m_macFontStyle;
961}
962
963wxUint32 wxFont::MacGetATSUFontID() const
964{
965 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
966
967 return M_FONTDATA->m_macATSUFontID;
968}
969
970wxUint32 wxFont::MacGetATSUAdditionalQDStyles() const
971{
972 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
973
974 return M_FONTDATA->m_macATSUAdditionalQDStyles;
975}
976
977wxUint16 wxFont::MacGetThemeFontID() const
978{
979 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
980
981 return M_FONTDATA->m_macThemeFontID;
982}
983#endif
984
985#if wxMAC_USE_CORE_TEXT || wxMAC_USE_ATSU_TEXT
986void * wxFont::MacGetATSUStyle() const
987{
988 wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
989
990 return M_FONTDATA->m_macATSUStyle;
991}
992#endif
993
994#if wxMAC_USE_CORE_TEXT
995
996const void * wxFont::MacGetCTFont() const
997{
998 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
999
1000 return (CTFontRef)(M_FONTDATA->m_ctFont);
1001}
1002
1003const void * wxFont::MacGetCTFontDescriptor() const
1004{
1005 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
1006
1007 return (CTFontDescriptorRef)(M_FONTDATA->m_ctFontDescriptor);
1008}
1009
1010#endif
1011
1012const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
1013{
1014 wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
1015 wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
1016
1017 M_FONTDATA->m_info.InitFromFont(*this);
1018
1019 return &(M_FONTDATA->m_info);
1020}
wxWidgets (Impactor)