]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/osx/carbon/font.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Add wxVersionInfo and functions returning it for 3rd party libraries.
[wxWidgets.git] / src / osx / carbon / font.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/osx/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#include "wx/settings.h"
27#include "wx/tokenzr.h"
28
29#include "wx/osx/private.h"
30
31#include <map>
32#include <string>
33
34IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
35
36class WXDLLEXPORT wxFontRefData: public wxGDIRefData
37{
38public:
39
40 wxFontRefData()
41 {
42 Init();
43 m_info.Init(10, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
44 false, wxEmptyString, wxFONTENCODING_DEFAULT);
45 }
46
47 wxFontRefData(const wxFontRefData& data);
48
49 wxFontRefData( const wxNativeFontInfo& info ) : m_info(info)
50 {
51 Init();
52 }
53
54 wxFontRefData(wxOSXSystemFont font, int size);
55
56#if wxOSX_USE_CORE_TEXT
57 wxFontRefData( wxUint32 coreTextFontType );
58 wxFontRefData( CTFontRef font );
59 wxFontRefData( CTFontDescriptorRef fontdescriptor, int size );
60#endif
61
62 virtual ~wxFontRefData();
63
64 void SetPointSize( int size )
65 {
66 if( GetPointSize() != size )
67 {
68 m_info.SetPointSize(size);
69 Free();
70 }
71 }
72
73 int GetPointSize() const { return m_info.GetPointSize(); }
74
75 void SetFamily( wxFontFamily family )
76 {
77 if ( m_info.m_family != family )
78 {
79 m_info.SetFamily( family );
80 Free();
81 }
82 }
83
84 wxFontFamily GetFamily() const { return m_info.GetFamily(); }
85
86 void SetStyle( wxFontStyle style )
87 {
88 if ( m_info.m_style != style )
89 {
90 m_info.SetStyle( style );
91 Free();
92 }
93 }
94
95
96 wxFontStyle GetStyle() const { return m_info.GetStyle(); }
97
98 void SetWeight( wxFontWeight weight )
99 {
100 if ( m_info.m_weight != weight )
101 {
102 m_info.SetWeight( weight );
103 Free();
104 }
105 }
106
107
108 wxFontWeight GetWeight() const { return m_info.GetWeight(); }
109
110 void SetUnderlined( bool u )
111 {
112 if ( m_info.m_underlined != u )
113 {
114 m_info.SetUnderlined( u );
115 Free();
116 }
117 }
118
119 bool GetUnderlined() const { return m_info.GetUnderlined(); }
120
121 void SetFaceName( const wxString& facename )
122 {
123 if ( m_info.m_faceName != facename )
124 {
125 m_info.SetFaceName( facename );
126 Free();
127 }
128 }
129
130 wxString GetFaceName() const { return m_info.GetFaceName(); }
131
132 void SetEncoding( wxFontEncoding encoding )
133 {
134 if ( m_info.m_encoding != encoding )
135 {
136 m_info.SetEncoding( encoding );
137 Free();
138 }
139 }
140
141 wxFontEncoding GetEncoding() const { return m_info.GetEncoding(); }
142
143 void Free();
144
145 void MacFindFont();
146
147protected:
148 // common part of all ctors
149 void Init();
150#if wxOSX_USE_CORE_TEXT
151 // void Init( CTFontRef font );
152#endif
153public:
154 bool m_fontValid;
155#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
156 // for true theming support we must store the correct font
157 // information here, as this speeds up and optimizes rendering
158 ThemeFontID m_macThemeFontID ;
159#endif
160#if wxOSX_USE_CORE_TEXT
161 wxCFRef<CTFontRef> m_ctFont;
162#endif
163#if wxOSX_USE_ATSU_TEXT
164 void CreateATSUFont();
165
166 ATSUStyle m_macATSUStyle ;
167#endif
168 wxCFRef<CGFontRef> m_cgFont;
169#if wxOSX_USE_COCOA
170 WX_NSFont m_nsFont;
171#endif
172#if wxOSX_USE_IPHONE
173 WX_UIFont m_uiFont;
174#endif
175 wxNativeFontInfo m_info;
176};
177
178#define M_FONTDATA ((wxFontRefData*)m_refData)
179
180wxFontRefData::wxFontRefData(const wxFontRefData& data)
181{
182 Init();
183 m_info = data.m_info;
184 m_fontValid = data.m_fontValid;
185#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
186 m_macThemeFontID = data.m_macThemeFontID;
187#endif
188#if wxOSX_USE_CORE_TEXT
189 m_ctFont = data.m_ctFont;
190#endif
191 m_cgFont = data.m_cgFont;
192#if wxOSX_USE_ATSU_TEXT
193 if ( data.m_macATSUStyle != NULL )
194 {
195 ATSUCreateStyle(&m_macATSUStyle) ;
196 ATSUCopyAttributes(data.m_macATSUStyle, m_macATSUStyle);
197 }
198#endif
199#if wxOSX_USE_COCOA
200 m_nsFont = (NSFont*) wxMacCocoaRetain(data.m_nsFont);
201#endif
202#if wxOSX_USE_IPHONE
203 m_uiFont = (UIFont*) wxMacCocoaRetain(data.m_uiFont);
204#endif
205
206}
207
208// ============================================================================
209// implementation
210// ============================================================================
211
212// ----------------------------------------------------------------------------
213// wxFontRefData
214// ----------------------------------------------------------------------------
215
216void wxFontRefData::Init()
217{
218#if wxOSX_USE_CARBON && wxOSX_USE_ATSU_TEXT
219 m_macThemeFontID = kThemeCurrentPortFont ;
220#endif
221#if wxOSX_USE_ATSU_TEXT
222 m_macATSUStyle = NULL ;
223#endif
224#if wxOSX_USE_COCOA
225 m_nsFont = NULL;
226#endif
227#if wxOSX_USE_IPHONE
228 m_uiFont = NULL;
229#endif
230 m_fontValid = false;
231}
232
233wxFontRefData::~wxFontRefData()
234{
235 Free();
236}
237
238void wxFontRefData::Free()
239{
240#if wxOSX_USE_CORE_TEXT
241 m_ctFont.reset();
242#endif
243 m_cgFont.reset();
244#if wxOSX_USE_ATSU_TEXT
245#if wxOSX_USE_CARBON
246 m_macThemeFontID = kThemeCurrentPortFont ;
247#endif
248 if ( m_macATSUStyle )
249 {
250 ::ATSUDisposeStyle((ATSUStyle)m_macATSUStyle);
251 m_macATSUStyle = NULL ;
252 }
253#endif
254#if wxOSX_USE_COCOA
255 if (m_nsFont != NULL)
256 {
257 wxMacCocoaRelease(m_nsFont);
258 m_nsFont = NULL;
259 }
260#endif
261#if wxOSX_USE_IPHONE
262 if (m_uiFont != NULL)
263 {
264 wxMacCocoaRelease(m_uiFont);
265 m_uiFont = NULL;
266 }
267#endif
268 m_fontValid = false;
269}
270
271wxFontRefData::wxFontRefData(wxOSXSystemFont font, int size)
272{
273 wxASSERT( font != wxOSX_SYSTEM_FONT_NONE );
274 Init();
275
276#if wxOSX_USE_CORE_TEXT
277 if ( UMAGetSystemVersion() >= 0x1050 )
278 {
279 CTFontUIFontType uifont = kCTFontSystemFontType;
280 switch( font )
281 {
282 case wxOSX_SYSTEM_FONT_NORMAL:
283 uifont = kCTFontSystemFontType;
284 break;
285 case wxOSX_SYSTEM_FONT_BOLD:
286 uifont = kCTFontEmphasizedSystemFontType;
287 break;
288 case wxOSX_SYSTEM_FONT_SMALL:
289 uifont = kCTFontSmallSystemFontType;
290 break;
291 case wxOSX_SYSTEM_FONT_SMALL_BOLD:
292 uifont = kCTFontSmallEmphasizedSystemFontType;
293 break;
294 case wxOSX_SYSTEM_FONT_MINI:
295 uifont = kCTFontMiniSystemFontType;
296 break;
297 case wxOSX_SYSTEM_FONT_MINI_BOLD:
298 uifont = kCTFontMiniEmphasizedSystemFontType;
299 break;
300 case wxOSX_SYSTEM_FONT_LABELS:
301 uifont = kCTFontLabelFontType;
302 break;
303 case wxOSX_SYSTEM_FONT_VIEWS:
304 uifont = kCTFontViewsFontType;
305 break;
306 default:
307 break;
308 }
309 m_ctFont.reset(CTFontCreateUIFontForLanguage( uifont, (CGFloat) size, NULL ));
310 wxCFRef<CTFontDescriptorRef> descr;
311 descr.reset( CTFontCopyFontDescriptor( m_ctFont ) );
312 m_info.Init(descr);
313 }
314#endif
315#if wxOSX_USE_ATSU_TEXT
316 {
317#if !wxOSX_USE_CARBON
318 // not needed outside
319 ThemeFontID m_macThemeFontID = kThemeSystemFont;
320#endif
321 switch( font )
322 {
323 case wxOSX_SYSTEM_FONT_NORMAL:
324 m_macThemeFontID = kThemeSystemFont;
325 break;
326 case wxOSX_SYSTEM_FONT_BOLD:
327 m_macThemeFontID = kThemeEmphasizedSystemFont;
328 break;
329 case wxOSX_SYSTEM_FONT_SMALL:
330 m_macThemeFontID = kThemeSmallSystemFont;
331 break;
332 case wxOSX_SYSTEM_FONT_SMALL_BOLD:
333 m_macThemeFontID = kThemeSmallEmphasizedSystemFont;
334 break;
335 case wxOSX_SYSTEM_FONT_MINI:
336 m_macThemeFontID = kThemeMiniSystemFont;
337 break;
338 case wxOSX_SYSTEM_FONT_MINI_BOLD:
339 // bold not available under theming
340 m_macThemeFontID = kThemeMiniSystemFont;
341 break;
342 case wxOSX_SYSTEM_FONT_LABELS:
343 m_macThemeFontID = kThemeLabelFont;
344 break;
345 case wxOSX_SYSTEM_FONT_VIEWS:
346 m_macThemeFontID = kThemeViewsFont;
347 break;
348 default:
349 break;
350 }
351 if ( m_info.m_faceName.empty() )
352 {
353 Style style ;
354 FMFontSize fontSize;
355 Str255 qdFontName ;
356
357 GetThemeFont( m_macThemeFontID, GetApplicationScript(), qdFontName, &fontSize, &style );
358 if ( size != 0 )
359 fontSize = size;
360
361 wxFontStyle fontstyle = wxFONTSTYLE_NORMAL;
362 wxFontWeight fontweight = wxFONTWEIGHT_NORMAL;
363 bool underlined = false;
364
365 if ( style & bold )
366 fontweight = wxFONTWEIGHT_BOLD ;
367 else
368 fontweight = wxFONTWEIGHT_NORMAL ;
369 if ( style & italic )
370 fontstyle = wxFONTSTYLE_ITALIC ;
371 if ( style & underline )
372 underlined = true ;
373
374 m_info.Init(fontSize,wxFONTFAMILY_DEFAULT,fontstyle,fontweight,underlined,
375 wxMacMakeStringFromPascal( qdFontName ), wxFONTENCODING_DEFAULT);
376 }
377 }
378#endif
379#if wxOSX_USE_COCOA
380 m_nsFont = wxFont::OSXCreateNSFont( font, &m_info );
381#endif
382#if wxOSX_USE_IPHONE
383 m_uiFont = wxFont::OSXCreateUIFont( font, &m_info );
384#endif
385 m_info.EnsureValid();
386#if wxOSX_USE_ATSU_TEXT
387 CreateATSUFont();
388#endif
389
390 m_fontValid = true;
391}
392
393#if wxOSX_USE_ATSU_TEXT
394void wxFontRefData::CreateATSUFont()
395{
396 // we try to get as much styles as possible into ATSU
397
398 OSStatus status = ::ATSUCreateStyle(&m_macATSUStyle);
399 wxASSERT_MSG( status == noErr , wxT("couldn't create ATSU style") );
400
401 ATSUAttributeTag atsuTags[] =
402 {
403 kATSUFontTag ,
404 kATSUSizeTag ,
405 kATSUVerticalCharacterTag,
406 kATSUQDBoldfaceTag ,
407 kATSUQDItalicTag ,
408 kATSUQDUnderlineTag ,
409 kATSUQDCondensedTag ,
410 kATSUQDExtendedTag ,
411 };
412 ByteCount atsuSizes[WXSIZEOF(atsuTags)] =
413 {
414 sizeof( ATSUFontID ) ,
415 sizeof( Fixed ) ,
416 sizeof( ATSUVerticalCharacterType),
417 sizeof( Boolean ) ,
418 sizeof( Boolean ) ,
419 sizeof( Boolean ) ,
420 sizeof( Boolean ) ,
421 sizeof( Boolean ) ,
422 };
423
424 Boolean kTrue = true ;
425 Boolean kFalse = false ;
426
427 Fixed atsuSize = IntToFixed( m_info.m_pointSize );
428 ATSUVerticalCharacterType kHorizontal = kATSUStronglyHorizontal;
429 FMFontStyle addQDStyle = m_info.m_atsuAdditionalQDStyles;
430 ATSUAttributeValuePtr atsuValues[WXSIZEOF(atsuTags)] =
431 {
432 &m_info.m_atsuFontID ,
433 &atsuSize ,
434 &kHorizontal,
435 (addQDStyle & bold) ? &kTrue : &kFalse ,
436 (addQDStyle & italic) ? &kTrue : &kFalse ,
437 (addQDStyle & underline) ? &kTrue : &kFalse ,
438 (addQDStyle & condense) ? &kTrue : &kFalse ,
439 (addQDStyle & extend) ? &kTrue : &kFalse ,
440 };
441
442 status = ::ATSUSetAttributes(
443 (ATSUStyle)m_macATSUStyle,
444 WXSIZEOF(atsuTags),
445 atsuTags, atsuSizes, atsuValues);
446
447 wxASSERT_MSG( status == noErr , wxString::Format(wxT("couldn't modify ATSU style. Status was %d"), (int) status).c_str() );
448
449 if ( m_cgFont.get() == NULL )
450 {
451 ATSFontRef fontRef = FMGetATSFontRefFromFont(m_info.m_atsuFontID);
452 m_cgFont.reset( CGFontCreateWithPlatformFont( &fontRef ) );
453 }
454}
455#endif
456
457static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
458static const CGAffineTransform kSlantTransform = CGAffineTransformMake( 1, 0, tan(DegToRad(11)), 1, 0, 0 );
459
460void wxFontRefData::MacFindFont()
461{
462 if ( m_fontValid )
463 return;
464
465 wxCHECK_RET( m_info.m_pointSize > 0, wxT("Point size should not be zero.") );
466
467 m_info.EnsureValid();
468
469#if wxOSX_USE_CORE_TEXT
470 if ( UMAGetSystemVersion() >= 0x1050 )
471 {
472 CTFontSymbolicTraits traits = 0;
473
474 if (m_info.m_weight == wxFONTWEIGHT_BOLD)
475 traits |= kCTFontBoldTrait;
476 if (m_info.m_style == wxFONTSTYLE_ITALIC || m_info.m_style == wxFONTSTYLE_SLANT)
477 traits |= kCTFontItalicTrait;
478
479 // use font caching
480 wxString lookupnameWithSize = wxString::Format( "%s_%u_%d", m_info.m_faceName, traits, m_info.m_pointSize );
481
482 static std::map< std::wstring , wxCFRef< CTFontRef > > fontcache ;
483 m_ctFont = fontcache[ std::wstring(lookupnameWithSize.wc_str()) ];
484 if ( !m_ctFont )
485 {
486 m_ctFont.reset(CTFontCreateWithName( wxCFStringRef(m_info.m_faceName), m_info.m_pointSize , NULL ));
487 if ( m_ctFont.get() == NULL )
488 {
489 // TODO try fallbacks according to font type
490 m_ctFont.reset(CTFontCreateUIFontForLanguage( kCTFontSystemFontType, m_info.m_pointSize , NULL ));
491 }
492 else
493 {
494 if ( traits != 0 )
495 {
496 // attempt native font variant, if not available, fallback to italic emulation mode and remove bold
497 CTFontRef fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, NULL, traits, traits );
498 if ( fontWithTraits == NULL )
499 {
500 CTFontSymbolicTraits remainingTraits = traits;
501 const CGAffineTransform* remainingTransform = NULL;
502
503 if( remainingTraits & kCTFontItalicTrait )
504 {
505 remainingTraits &= ~kCTFontItalicTrait;
506 remainingTransform = &kSlantTransform;
507 if ( remainingTraits & kCTFontBoldTrait )
508 {
509 // first try an emulated oblique with an existing bold font
510 fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, remainingTransform, remainingTraits, remainingTraits );
511 if ( fontWithTraits == NULL )
512 {
513 // give in on the bold, try native oblique
514 fontWithTraits = CTFontCreateCopyWithSymbolicTraits( m_ctFont, 0, NULL, kCTFontItalicTrait, kCTFontItalicTrait );
515 }
516 }
517 }
518
519 if ( fontWithTraits == NULL )
520 {
521 fontWithTraits = CTFontCreateWithName( wxCFStringRef(m_info.m_faceName), m_info.m_pointSize, remainingTransform );
522 }
523
524 }
525 if ( fontWithTraits != NULL )
526 m_ctFont.reset(fontWithTraits);
527 }
528 }
529 }
530
531 m_cgFont.reset(CTFontCopyGraphicsFont(m_ctFont, NULL));
532 }
533
534#endif
535#if wxOSX_USE_ATSU_TEXT
536 CreateATSUFont();
537#endif
538#if wxOSX_USE_COCOA
539 m_nsFont = wxFont::OSXCreateNSFont( &m_info );
540#endif
541#if wxOSX_USE_IPHONE
542 m_uiFont = wxFont::OSXCreateUIFont( &m_info );
543#endif
544 m_fontValid = true;
545}
546
547// ----------------------------------------------------------------------------
548// wxFont
549// ----------------------------------------------------------------------------
550
551bool wxFont::Create(const wxNativeFontInfo& info)
552{
553 UnRef();
554
555 m_refData = new wxFontRefData( info );
556 RealizeResource();
557
558 return true;
559}
560
561wxFont::wxFont(wxOSXSystemFont font)
562{
563 m_refData = new wxFontRefData( font, 0 );
564}
565
566wxFont::wxFont(const wxString& fontdesc)
567{
568 wxNativeFontInfo info;
569 if ( info.FromString(fontdesc) )
570 (void)Create(info);
571}
572
573bool wxFont::Create(int pointSize,
574 wxFontFamily family,
575 wxFontStyle style,
576 wxFontWeight weight,
577 bool underlined,
578 const wxString& faceNameParam,
579 wxFontEncoding encoding)
580{
581 UnRef();
582
583 wxString faceName = faceNameParam;
584
585 if ( faceName.empty() )
586 {
587 switch ( family )
588 {
589 case wxFONTFAMILY_DEFAULT :
590 faceName = wxT("Lucida Grande");
591 break;
592
593 case wxFONTFAMILY_SCRIPT :
594 case wxFONTFAMILY_ROMAN :
595 case wxFONTFAMILY_DECORATIVE :
596 faceName = wxT("Times");
597 break ;
598
599 case wxFONTFAMILY_SWISS :
600 faceName = wxT("Helvetica");
601 break ;
602
603 case wxFONTFAMILY_MODERN :
604 case wxFONTFAMILY_TELETYPE:
605 faceName = wxT("Courier");
606 break ;
607
608 default:
609 faceName = wxT("Times");
610 break ;
611 }
612 }
613
614 wxNativeFontInfo info;
615
616 info.Init(pointSize, family, style, weight,
617 underlined, faceName, encoding);
618
619 m_refData = new wxFontRefData(info);
620
621 return true;
622}
623
624wxFont::~wxFont()
625{
626}
627
628void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info)
629{
630 UnRef();
631
632 m_refData = new wxFontRefData( info);
633}
634
635
636bool wxFont::RealizeResource()
637{
638 M_FONTDATA->MacFindFont();
639
640 return true;
641}
642
643void wxFont::SetEncoding(wxFontEncoding encoding)
644{
645 AllocExclusive();
646
647 M_FONTDATA->SetEncoding( encoding );
648}
649
650wxGDIRefData *wxFont::CreateGDIRefData() const
651{
652 return new wxFontRefData;
653}
654
655wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
656{
657 return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
658}
659
660void wxFont::SetPointSize(int pointSize)
661{
662 if ( M_FONTDATA->GetPointSize() == pointSize )
663 return;
664
665 AllocExclusive();
666
667 M_FONTDATA->SetPointSize( pointSize );
668}
669
670void wxFont::SetFamily(wxFontFamily family)
671{
672 AllocExclusive();
673
674 M_FONTDATA->SetFamily( family );
675}
676
677void wxFont::SetStyle(wxFontStyle style)
678{
679 AllocExclusive();
680
681 M_FONTDATA->SetStyle( style );
682}
683
684void wxFont::SetWeight(wxFontWeight weight)
685{
686 AllocExclusive();
687
688 M_FONTDATA->SetWeight( weight );
689}
690
691bool wxFont::SetFaceName(const wxString& faceName)
692{
693 AllocExclusive();
694
695 M_FONTDATA->SetFaceName( faceName );
696
697 return wxFontBase::SetFaceName(faceName);
698}
699
700void wxFont::SetUnderlined(bool underlined)
701{
702 AllocExclusive();
703
704 M_FONTDATA->SetUnderlined( underlined );
705}
706
707// ----------------------------------------------------------------------------
708// accessors
709// ----------------------------------------------------------------------------
710
711// TODO: insert checks everywhere for M_FONTDATA == NULL!
712
713int wxFont::GetPointSize() const
714{
715 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
716
717 return M_FONTDATA->GetPointSize();
718}
719
720wxSize wxFont::GetPixelSize() const
721{
722#if wxUSE_GRAPHICS_CONTEXT
723 // TODO: consider caching the value
724 wxGraphicsContext* dc = wxGraphicsContext::CreateFromNative((CGContextRef) NULL);
725 dc->SetFont(*(wxFont *)this,*wxBLACK);
726 wxDouble width, height = 0;
727 dc->GetTextExtent( wxT("g"), &width, &height, NULL, NULL);
728 delete dc;
729 return wxSize((int)width, (int)height);
730#else
731 return wxFontBase::GetPixelSize();
732#endif
733}
734
735wxFontFamily wxFont::DoGetFamily() const
736{
737 return M_FONTDATA->GetFamily();
738}
739
740wxFontStyle wxFont::GetStyle() const
741{
742 wxCHECK_MSG( M_FONTDATA != NULL , wxFONTSTYLE_MAX, wxT("invalid font") );
743
744 return M_FONTDATA->GetStyle() ;
745}
746
747wxFontWeight wxFont::GetWeight() const
748{
749 wxCHECK_MSG( M_FONTDATA != NULL , wxFONTWEIGHT_MAX, wxT("invalid font") );
750
751 return M_FONTDATA->GetWeight();
752}
753
754bool wxFont::GetUnderlined() const
755{
756 wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
757
758 return M_FONTDATA->GetUnderlined();
759}
760
761wxString wxFont::GetFaceName() const
762{
763 wxCHECK_MSG( M_FONTDATA != NULL , wxEmptyString , wxT("invalid font") );
764
765 return M_FONTDATA->GetFaceName() ;
766}
767
768wxFontEncoding wxFont::GetEncoding() const
769{
770 wxCHECK_MSG( M_FONTDATA != NULL , wxFONTENCODING_DEFAULT , wxT("invalid font") );
771
772 return M_FONTDATA->GetEncoding() ;
773}
774
775#if wxOSX_USE_ATSU_TEXT && wxOSX_USE_CARBON
776
777short wxFont::MacGetFontNum() const
778{
779 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
780
781 // cast away constness otherwise lazy font resolution is not possible
782 const_cast<wxFont *>(this)->RealizeResource();
783
784 return M_FONTDATA->m_info.m_qdFontFamily;
785}
786
787wxByte wxFont::MacGetFontStyle() const
788{
789 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
790
791 // cast away constness otherwise lazy font resolution is not possible
792 const_cast<wxFont *>(this)->RealizeResource();
793
794 return M_FONTDATA->m_info.m_qdFontStyle;
795}
796
797wxUint16 wxFont::MacGetThemeFontID() const
798{
799 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
800
801 return M_FONTDATA->m_macThemeFontID;
802}
803
804#endif
805
806#if wxOSX_USE_ATSU_TEXT
807void * wxFont::MacGetATSUStyle() const
808{
809 wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
810
811 // cast away constness otherwise lazy font resolution is not possible
812 const_cast<wxFont *>(this)->RealizeResource();
813
814 return M_FONTDATA->m_macATSUStyle;
815}
816
817wxUint32 wxFont::MacGetATSUFontID() const
818{
819 wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
820
821 // cast away constness otherwise lazy font resolution is not possible
822 const_cast<wxFont *>(this)->RealizeResource();
823
824 return M_FONTDATA->m_info.m_atsuFontID;
825}
826
827wxUint32 wxFont::MacGetATSUAdditionalQDStyles() const
828{
829 wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
830
831 // cast away constness otherwise lazy font resolution is not possible
832 const_cast<wxFont *>(this)->RealizeResource();
833
834 return M_FONTDATA->m_info.m_atsuAdditionalQDStyles;
835}
836#endif
837
838#if wxOSX_USE_CORE_TEXT
839
840CTFontRef wxFont::OSXGetCTFont() const
841{
842 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
843
844 // cast away constness otherwise lazy font resolution is not possible
845 const_cast<wxFont *>(this)->RealizeResource();
846
847 return (CTFontRef)(M_FONTDATA->m_ctFont);
848}
849
850#endif
851
852#if wxOSX_USE_COCOA_OR_CARBON
853
854CGFontRef wxFont::OSXGetCGFont() const
855{
856 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
857
858 // cast away constness otherwise lazy font resolution is not possible
859 const_cast<wxFont *>(this)->RealizeResource();
860
861 return (M_FONTDATA->m_cgFont);
862}
863
864#endif
865
866
867#if wxOSX_USE_COCOA
868
869NSFont* wxFont::OSXGetNSFont() const
870{
871 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
872
873 // cast away constness otherwise lazy font resolution is not possible
874 const_cast<wxFont *>(this)->RealizeResource();
875
876 return (M_FONTDATA->m_nsFont);
877}
878
879#endif
880
881#if wxOSX_USE_IPHONE
882
883UIFont* wxFont::OSXGetUIFont() const
884{
885 wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
886
887 // cast away constness otherwise lazy font resolution is not possible
888 const_cast<wxFont *>(this)->RealizeResource();
889
890 return (M_FONTDATA->m_uiFont);
891}
892
893#endif
894
895const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
896{
897 wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
898 wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
899
900 // cast away constness otherwise lazy font resolution is not possible
901 const_cast<wxFont *>(this)->RealizeResource();
902
903 // M_FONTDATA->m_info.InitFromFont(*this);
904
905 return &(M_FONTDATA->m_info);
906}
907
908// ----------------------------------------------------------------------------
909// wxNativeFontInfo
910// ----------------------------------------------------------------------------
911
912#if 0 // wxOSX_USE_CORE_TEXT
913
914/* from Core Text Manual Common Operations */
915
916static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
917{
918 CTFontDescriptorRef descriptor = NULL;
919 CFMutableDictionaryRef attributes;
920
921 wxASSERT(iFamilyName != NULL);
922 // Create a mutable dictionary to hold our attributes.
923 attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
924 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
925 wxASSERT(attributes != NULL);
926
927 if (attributes != NULL) {
928 // Add a family name to our attributes.
929 CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
930
931
932 if ( iTraits ) {
933 CFMutableDictionaryRef traits;
934 CFNumberRef symTraits;
935
936 // Create the traits dictionary.
937 symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
938 &iTraits);
939 wxASSERT(symTraits != NULL);
940
941 if (symTraits != NULL) {
942 // Create a dictionary to hold our traits values.
943 traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
944 &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
945 wxASSERT(traits != NULL);
946
947 if (traits != NULL) {
948 // Add the symbolic traits value to the traits dictionary.
949 CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
950
951 // Add the traits attribute to our attributes.
952 CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
953 CFRelease(traits);
954 }
955 CFRelease(symTraits);
956 }
957 }
958 // Create the font descriptor with our attributes
959 descriptor = CTFontDescriptorCreateWithAttributes(attributes);
960 wxASSERT(descriptor != NULL);
961
962 CFRelease(attributes);
963 }
964 // Return our font descriptor.
965 return descriptor ;
966}
967
968#endif
969
970void wxNativeFontInfo::Init()
971{
972#if wxOSX_USE_ATSU_TEXT
973 m_atsuFontID = 0 ;
974 m_atsuAdditionalQDStyles = 0;
975 m_atsuFontValid = false;
976#if wxOSX_USE_CARBON
977 m_qdFontStyle = 0;
978 m_qdFontFamily = 0;
979#endif
980#endif
981 m_pointSize = 0;
982 m_family = wxFONTFAMILY_DEFAULT;
983 m_style = wxFONTSTYLE_NORMAL;
984 m_weight = wxFONTWEIGHT_NORMAL;
985 m_underlined = false;
986 m_faceName.clear();
987 m_encoding = wxFont::GetDefaultEncoding();
988 m_descriptorValid = false;
989}
990
991#if wxOSX_USE_CORE_TEXT
992void wxNativeFontInfo::Init(CTFontDescriptorRef descr)
993{
994 Init();
995
996 wxCFRef< CFNumberRef > sizevalue( (CFNumberRef) CTFontDescriptorCopyAttribute( descr, kCTFontSizeAttribute ) );
997 float fsize;
998 if ( CFNumberGetValue( sizevalue , kCFNumberFloatType , &fsize ) )
999 m_pointSize = (int)( fsize + 0.5 );
1000
1001 wxCFRef< CFDictionaryRef > traitsvalue( (CFDictionaryRef) CTFontDescriptorCopyAttribute( descr, kCTFontTraitsAttribute ) );
1002 CTFontSymbolicTraits traits;
1003 if ( CFNumberGetValue((CFNumberRef) CFDictionaryGetValue(traitsvalue,kCTFontSymbolicTrait),kCFNumberIntType,&traits) )
1004 {
1005 if ( traits & kCTFontItalicTrait )
1006 m_style = wxFONTSTYLE_ITALIC;
1007 if ( traits & kCTFontBoldTrait )
1008 m_weight = wxFONTWEIGHT_BOLD ;
1009 }
1010
1011 wxCFStringRef familyName( (CFStringRef) CTFontDescriptorCopyAttribute(descr, kCTFontFamilyNameAttribute));
1012 m_faceName = familyName.AsString();
1013}
1014#endif
1015
1016void wxNativeFontInfo::EnsureValid()
1017{
1018 if ( m_descriptorValid )
1019 return;
1020
1021#if wxOSX_USE_ATSU_TEXT
1022 if ( !m_atsuFontValid )
1023 {
1024#if !wxOSX_USE_CARBON
1025 // not needed outside
1026 wxInt16 m_qdFontFamily;
1027 wxInt16 m_qdFontStyle;
1028#endif
1029 wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
1030 ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
1031 if ( atsfamily == (ATSFontFamilyRef) -1 )
1032 {
1033 wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
1034 m_qdFontFamily = GetAppFont();
1035 }
1036 else
1037 {
1038 m_qdFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
1039 }
1040
1041 m_qdFontStyle = 0;
1042 if (m_weight == wxFONTWEIGHT_BOLD)
1043 m_qdFontStyle |= bold;
1044 if (m_style == wxFONTSTYLE_ITALIC || m_style == wxFONTSTYLE_SLANT)
1045 m_qdFontStyle |= italic;
1046 if (m_underlined)
1047 m_qdFontStyle |= underline;
1048
1049
1050 // we try to get as much styles as possible into ATSU
1051
1052 // ATSUFontID and FMFont are equivalent
1053 FMFontStyle intrinsicStyle = 0 ;
1054 OSStatus status = FMGetFontFromFontFamilyInstance( m_qdFontFamily , m_qdFontStyle , (FMFont*)&m_atsuFontID , &intrinsicStyle);
1055 if ( status != noErr )
1056 {
1057 wxFAIL_MSG( wxT("couldn't get an ATSUFont from font family") );
1058 }
1059 m_atsuAdditionalQDStyles = m_qdFontStyle & (~intrinsicStyle );
1060 m_atsuFontValid = true;
1061 }
1062#endif
1063 m_descriptorValid = true;
1064}
1065
1066void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
1067{
1068 Init();
1069#if wxOSX_USE_ATSU_TEXT
1070 m_atsuFontValid = info.m_atsuFontValid;
1071 m_atsuFontID = info.m_atsuFontID ;
1072 m_atsuAdditionalQDStyles = info.m_atsuAdditionalQDStyles;
1073#if wxOSX_USE_CARBON
1074 m_qdFontFamily = info.m_qdFontFamily;
1075 m_qdFontStyle = info.m_qdFontStyle;
1076#endif
1077#endif
1078 m_pointSize = info.m_pointSize;
1079 m_family = info.m_family;
1080 m_style = info.m_style;
1081 m_weight = info.m_weight;
1082 m_underlined = info.m_underlined;
1083 m_faceName = info.m_faceName;
1084 m_encoding = info.m_encoding;
1085 m_descriptorValid = info.m_descriptorValid;
1086}
1087
1088void wxNativeFontInfo::Init(int size,
1089 wxFontFamily family,
1090 wxFontStyle style,
1091 wxFontWeight weight,
1092 bool underlined,
1093 const wxString& faceName,
1094 wxFontEncoding encoding)
1095{
1096 Init();
1097 m_pointSize = size;
1098 m_family = family;
1099 m_style = style;
1100 m_weight = weight;
1101 m_underlined = underlined;
1102 m_faceName = faceName;
1103 if ( encoding == wxFONTENCODING_DEFAULT )
1104 encoding = wxFont::GetDefaultEncoding();
1105 m_encoding = encoding;
1106
1107}
1108
1109void wxNativeFontInfo::Free()
1110{
1111#if wxOSX_USE_ATSU_TEXT
1112 m_atsuFontID = 0 ;
1113 m_atsuAdditionalQDStyles = 0;
1114 m_atsuFontValid = false;
1115#endif
1116 m_descriptorValid = false;
1117}
1118
1119bool wxNativeFontInfo::FromString(const wxString& s)
1120{
1121 long l;
1122
1123 wxStringTokenizer tokenizer(s, wxT(";"));
1124
1125 wxString token = tokenizer.GetNextToken();
1126 //
1127 // Ignore the version for now
1128 //
1129
1130 token = tokenizer.GetNextToken();
1131 if ( !token.ToLong(&l) )
1132 return false;
1133 m_pointSize = (int)l;
1134
1135 token = tokenizer.GetNextToken();
1136 if ( !token.ToLong(&l) )
1137 return false;
1138 m_family = (wxFontFamily)l;
1139
1140 token = tokenizer.GetNextToken();
1141 if ( !token.ToLong(&l) )
1142 return false;
1143 m_style = (wxFontStyle)l;
1144
1145 token = tokenizer.GetNextToken();
1146 if ( !token.ToLong(&l) )
1147 return false;
1148 m_weight = (wxFontWeight)l;
1149
1150 token = tokenizer.GetNextToken();
1151 if ( !token.ToLong(&l) )
1152 return false;
1153 m_underlined = l != 0;
1154
1155 m_faceName = tokenizer.GetNextToken();
1156
1157#ifndef __WXMAC__
1158 if( !faceName )
1159 return false;
1160#endif
1161
1162 token = tokenizer.GetNextToken();
1163 if ( !token.ToLong(&l) )
1164 return false;
1165 m_encoding = (wxFontEncoding)l;
1166
1167 return true;
1168}
1169
1170wxString wxNativeFontInfo::ToString() const
1171{
1172 wxString s;
1173
1174 s.Printf(wxT("%d;%d;%d;%d;%d;%d;%s;%d"),
1175 0, // version
1176 m_pointSize,
1177 m_family,
1178 (int)m_style,
1179 (int)m_weight,
1180 m_underlined,
1181 m_faceName.GetData(),
1182 (int)m_encoding);
1183
1184 return s;
1185}
1186
1187int wxNativeFontInfo::GetPointSize() const
1188{
1189 return m_pointSize;
1190}
1191
1192wxFontStyle wxNativeFontInfo::GetStyle() const
1193{
1194 return m_style;
1195}
1196
1197wxFontWeight wxNativeFontInfo::GetWeight() const
1198{
1199 return m_weight;
1200}
1201
1202bool wxNativeFontInfo::GetUnderlined() const
1203{
1204 return m_underlined;
1205}
1206
1207wxString wxNativeFontInfo::GetFaceName() const
1208{
1209 return m_faceName;
1210}
1211
1212wxFontFamily wxNativeFontInfo::GetFamily() const
1213{
1214 return m_family;
1215}
1216
1217wxFontEncoding wxNativeFontInfo::GetEncoding() const
1218{
1219 return m_encoding;
1220}
1221
1222// changing the font descriptor
1223
1224void wxNativeFontInfo::SetPointSize(int pointsize)
1225{
1226 if ( m_pointSize != pointsize )
1227 {
1228 m_pointSize = pointsize;
1229 Free();
1230 }
1231}
1232
1233void wxNativeFontInfo::SetStyle(wxFontStyle style_)
1234{
1235 if ( m_style != style_ )
1236 {
1237 m_style = style_;
1238 Free();
1239 }
1240}
1241
1242void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
1243{
1244 if ( m_weight != weight_ )
1245 {
1246 m_weight = weight_;
1247 Free();
1248 }
1249}
1250
1251void wxNativeFontInfo::SetUnderlined(bool underlined_)
1252{
1253 if ( m_underlined != underlined_ )
1254 {
1255 m_underlined = underlined_;
1256 Free();
1257 }
1258}
1259
1260bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
1261{
1262 if ( m_faceName != facename_ )
1263 {
1264 m_faceName = facename_;
1265 Free();
1266 }
1267 return true;
1268}
1269
1270void wxNativeFontInfo::SetFamily(wxFontFamily family_)
1271{
1272 if ( m_family != family_ )
1273 {
1274 m_family = family_;
1275 Free();
1276 }
1277}
1278
1279void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
1280{
1281 if ( encoding_ == wxFONTENCODING_DEFAULT )
1282 encoding_ = wxFont::GetDefaultEncoding();
1283 m_encoding = encoding_;
1284 // not reflected in native descriptors
1285}
wxWidgets (Impactor)