src/osx/carbon/font.cpp

   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
  34 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
  35
  36 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
  37 {
  38 public:
  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
 147 protected:
 148     // common part of all ctors
 149     void Init();
 150 #if wxOSX_USE_CORE_TEXT
 151     // void Init( CTFontRef font );
 152 #endif
 153 public:
 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
 180 wxFontRefData::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
 216 void 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
 233 wxFontRefData::~wxFontRefData()
 234 {
 235     Free();
 236 }
 237
 238 void 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
 271 wxFontRefData::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
 394 void 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
 457 static inline double DegToRad(double deg) { return (deg * M_PI) / 180.0; }
 458 static const CGAffineTransform kSlantTransform = CGAffineTransformMake( 1, 0, tan(DegToRad(11)), 1, 0, 0 );
 459
 460 void 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_%ld_%ld", m_info.m_faceName.c_str(), 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
 551 bool wxFont::Create(const wxNativeFontInfo& info)
 552 {
 553     UnRef();
 554
 555     m_refData = new wxFontRefData( info );
 556     RealizeResource();
 557
 558     return true;
 559 }
 560
 561 wxFont::wxFont(wxOSXSystemFont font)
 562 {
 563     m_refData = new wxFontRefData( font, 0 );
 564 }
 565
 566 wxFont::wxFont(const wxString& fontdesc)
 567 {
 568     wxNativeFontInfo info;
 569     if ( info.FromString(fontdesc) )
 570         (void)Create(info);
 571 }
 572
 573 bool 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
 624 wxFont::~wxFont()
 625 {
 626 }
 627
 628 void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info)
 629 {
 630     UnRef();
 631
 632     m_refData = new wxFontRefData( info);
 633 }
 634
 635
 636 bool wxFont::RealizeResource()
 637 {
 638     M_FONTDATA->MacFindFont();
 639
 640     return true;
 641 }
 642
 643 void wxFont::SetEncoding(wxFontEncoding encoding)
 644 {
 645     AllocExclusive();
 646
 647     M_FONTDATA->SetEncoding( encoding );
 648 }
 649
 650 wxGDIRefData *wxFont::CreateGDIRefData() const
 651 {
 652     return new wxFontRefData;
 653 }
 654
 655 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 656 {
 657     return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
 658 }
 659
 660 void wxFont::SetPointSize(int pointSize)
 661 {
 662     if ( M_FONTDATA->GetPointSize() == pointSize )
 663         return;
 664
 665     AllocExclusive();
 666
 667     M_FONTDATA->SetPointSize( pointSize );
 668 }
 669
 670 void wxFont::SetFamily(wxFontFamily family)
 671 {
 672     AllocExclusive();
 673
 674     M_FONTDATA->SetFamily( family );
 675 }
 676
 677 void wxFont::SetStyle(wxFontStyle style)
 678 {
 679     AllocExclusive();
 680
 681     M_FONTDATA->SetStyle( style );
 682 }
 683
 684 void wxFont::SetWeight(wxFontWeight weight)
 685 {
 686     AllocExclusive();
 687
 688     M_FONTDATA->SetWeight( weight );
 689 }
 690
 691 bool wxFont::SetFaceName(const wxString& faceName)
 692 {
 693     AllocExclusive();
 694
 695     M_FONTDATA->SetFaceName( faceName );
 696
 697     return wxFontBase::SetFaceName(faceName);
 698 }
 699
 700 void 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
 713 int wxFont::GetPointSize() const
 714 {
 715     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 716
 717     return M_FONTDATA->GetPointSize();
 718 }
 719
 720 wxSize 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
 735 wxFontFamily wxFont::GetFamily() const
 736 {
 737     wxCHECK_MSG( M_FONTDATA != NULL , wxFONTFAMILY_MAX, wxT("invalid font") );
 738
 739     return M_FONTDATA->GetFamily();
 740 }
 741
 742 wxFontStyle wxFont::GetStyle() const
 743 {
 744     wxCHECK_MSG( M_FONTDATA != NULL , wxFONTSTYLE_MAX, wxT("invalid font") );
 745
 746     return M_FONTDATA->GetStyle() ;
 747 }
 748
 749 wxFontWeight wxFont::GetWeight() const
 750 {
 751     wxCHECK_MSG( M_FONTDATA != NULL , wxFONTWEIGHT_MAX, wxT("invalid font") );
 752
 753     return M_FONTDATA->GetWeight();
 754 }
 755
 756 bool wxFont::GetUnderlined() const
 757 {
 758     wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
 759
 760     return M_FONTDATA->GetUnderlined();
 761 }
 762
 763 wxString wxFont::GetFaceName() const
 764 {
 765     wxCHECK_MSG( M_FONTDATA != NULL , wxEmptyString , wxT("invalid font") );
 766
 767     return M_FONTDATA->GetFaceName() ;
 768 }
 769
 770 wxFontEncoding wxFont::GetEncoding() const
 771 {
 772     wxCHECK_MSG( M_FONTDATA != NULL , wxFONTENCODING_DEFAULT , wxT("invalid font") );
 773
 774     return M_FONTDATA->GetEncoding() ;
 775 }
 776
 777 #if wxOSX_USE_ATSU_TEXT && wxOSX_USE_CARBON
 778
 779 short wxFont::MacGetFontNum() const
 780 {
 781     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 782
 783     // cast away constness otherwise lazy font resolution is not possible
 784     const_cast<wxFont *>(this)->RealizeResource();
 785
 786     return M_FONTDATA->m_info.m_qdFontFamily;
 787 }
 788
 789 wxByte wxFont::MacGetFontStyle() const
 790 {
 791     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 792
 793     // cast away constness otherwise lazy font resolution is not possible
 794     const_cast<wxFont *>(this)->RealizeResource();
 795
 796     return M_FONTDATA->m_info.m_qdFontStyle;
 797 }
 798
 799 wxUint16 wxFont::MacGetThemeFontID() const
 800 {
 801     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 802
 803     return M_FONTDATA->m_macThemeFontID;
 804 }
 805
 806 #endif
 807
 808 #if wxOSX_USE_ATSU_TEXT
 809 void * wxFont::MacGetATSUStyle() const
 810 {
 811     wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
 812
 813     // cast away constness otherwise lazy font resolution is not possible
 814     const_cast<wxFont *>(this)->RealizeResource();
 815
 816     return M_FONTDATA->m_macATSUStyle;
 817 }
 818
 819 #if WXWIN_COMPATIBILITY_2_8
 820 wxUint32 wxFont::MacGetATSUFontID() const
 821 {
 822     wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
 823
 824     // cast away constness otherwise lazy font resolution is not possible
 825     const_cast<wxFont *>(this)->RealizeResource();
 826
 827     return M_FONTDATA->m_info.m_atsuFontID;
 828 }
 829
 830 wxUint32 wxFont::MacGetATSUAdditionalQDStyles() const
 831 {
 832     wxCHECK_MSG( M_FONTDATA != NULL, 0, wxT("invalid font") );
 833
 834     // cast away constness otherwise lazy font resolution is not possible
 835     const_cast<wxFont *>(this)->RealizeResource();
 836
 837     return M_FONTDATA->m_info.m_atsuAdditionalQDStyles;
 838 }
 839 #endif
 840
 841 #endif
 842
 843 #if wxOSX_USE_CORE_TEXT
 844
 845 CTFontRef wxFont::OSXGetCTFont() const
 846 {
 847     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 848
 849     // cast away constness otherwise lazy font resolution is not possible
 850     const_cast<wxFont *>(this)->RealizeResource();
 851
 852     return (CTFontRef)(M_FONTDATA->m_ctFont);
 853 }
 854
 855 #endif
 856
 857 #if wxOSX_USE_COCOA_OR_CARBON
 858
 859 CGFontRef wxFont::OSXGetCGFont() const
 860 {
 861     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 862
 863     // cast away constness otherwise lazy font resolution is not possible
 864     const_cast<wxFont *>(this)->RealizeResource();
 865
 866     return (M_FONTDATA->m_cgFont);
 867 }
 868
 869 #endif
 870
 871
 872 #if wxOSX_USE_COCOA
 873
 874 NSFont* wxFont::OSXGetNSFont() const
 875 {
 876     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 877
 878     // cast away constness otherwise lazy font resolution is not possible
 879     const_cast<wxFont *>(this)->RealizeResource();
 880
 881     return (M_FONTDATA->m_nsFont);
 882 }
 883
 884 #endif
 885
 886 const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
 887 {
 888     wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
 889     wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
 890
 891     // cast away constness otherwise lazy font resolution is not possible
 892     const_cast<wxFont *>(this)->RealizeResource();
 893
 894     // M_FONTDATA->m_info.InitFromFont(*this);
 895
 896     return &(M_FONTDATA->m_info);
 897 }
 898
 899 // ----------------------------------------------------------------------------
 900 // wxNativeFontInfo
 901 // ----------------------------------------------------------------------------
 902
 903 #if 0 // wxOSX_USE_CORE_TEXT
 904
 905 /* from Core Text Manual Common Operations */
 906
 907 static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
 908 {
 909     CTFontDescriptorRef descriptor = NULL;
 910     CFMutableDictionaryRef attributes;
 911
 912     wxASSERT(iFamilyName != NULL);
 913     // Create a mutable dictionary to hold our attributes.
 914     attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
 915                                            &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 916     wxASSERT(attributes != NULL);
 917
 918     if (attributes != NULL) {
 919         // Add a family name to our attributes.
 920         CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
 921
 922
 923         if ( iTraits ) {
 924             CFMutableDictionaryRef traits;
 925             CFNumberRef symTraits;
 926
 927             // Create the traits dictionary.
 928             symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
 929                                        &iTraits);
 930             wxASSERT(symTraits != NULL);
 931
 932             if (symTraits != NULL) {
 933                 // Create a dictionary to hold our traits values.
 934                 traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
 935                                                    &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 936                 wxASSERT(traits != NULL);
 937
 938                 if (traits != NULL) {
 939                     // Add the symbolic traits value to the traits dictionary.
 940                     CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
 941
 942                     // Add the traits attribute to our attributes.
 943                     CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
 944                     CFRelease(traits);
 945                 }
 946                 CFRelease(symTraits);
 947             }
 948         }
 949         // Create the font descriptor with our attributes
 950         descriptor = CTFontDescriptorCreateWithAttributes(attributes);
 951         wxASSERT(descriptor != NULL);
 952
 953         CFRelease(attributes);
 954     }
 955     // Return our font descriptor.
 956     return descriptor ;
 957 }
 958
 959 #endif
 960
 961 void wxNativeFontInfo::Init()
 962 {
 963 #if wxOSX_USE_ATSU_TEXT
 964     m_atsuFontID = 0 ;
 965     m_atsuAdditionalQDStyles = 0;
 966     m_atsuFontValid = false;
 967 #if wxOSX_USE_CARBON
 968     m_qdFontStyle = 0;
 969     m_qdFontFamily = 0;
 970 #endif
 971 #endif
 972     m_pointSize = 0;
 973     m_family = wxFONTFAMILY_DEFAULT;
 974     m_style = wxFONTSTYLE_NORMAL;
 975     m_weight = wxFONTWEIGHT_NORMAL;
 976     m_underlined = false;
 977     m_faceName.clear();
 978     m_encoding = wxFont::GetDefaultEncoding();
 979     m_descriptorValid = false;
 980 }
 981
 982 #if wxOSX_USE_CORE_TEXT
 983 void wxNativeFontInfo::Init(CTFontDescriptorRef descr)
 984 {
 985     Init();
 986
 987     wxCFRef< CFNumberRef > sizevalue( (CFNumberRef) CTFontDescriptorCopyAttribute( descr, kCTFontSizeAttribute ) );
 988     float fsize;
 989     if ( CFNumberGetValue( sizevalue , kCFNumberFloatType , &fsize ) )
 990         m_pointSize = (int)( fsize + 0.5 );
 991
 992     wxCFRef< CFDictionaryRef > traitsvalue( (CFDictionaryRef) CTFontDescriptorCopyAttribute( descr, kCTFontTraitsAttribute ) );
 993     CTFontSymbolicTraits traits;
 994     if ( CFNumberGetValue((CFNumberRef) CFDictionaryGetValue(traitsvalue,kCTFontSymbolicTrait),kCFNumberIntType,&traits) )
 995     {
 996         if ( traits & kCTFontItalicTrait )
 997             m_style = wxFONTSTYLE_ITALIC;
 998         if (  traits & kCTFontBoldTrait )
 999             m_weight = wxFONTWEIGHT_BOLD ;
1000     }
1001
1002     wxCFStringRef familyName( (CFStringRef) CTFontDescriptorCopyAttribute(descr, kCTFontFamilyNameAttribute));
1003     m_faceName = familyName.AsString();
1004 }
1005 #endif
1006
1007 void wxNativeFontInfo::EnsureValid()
1008 {
1009     if ( m_descriptorValid )
1010         return;
1011
1012 #if wxOSX_USE_ATSU_TEXT
1013     if ( !m_atsuFontValid )
1014     {
1015 #if !wxOSX_USE_CARBON
1016         // not needed outside
1017         wxInt16 m_qdFontFamily;
1018         wxInt16 m_qdFontStyle;
1019 #endif
1020         wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
1021         ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
1022         if ( atsfamily == (ATSFontFamilyRef) -1 )
1023         {
1024             wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
1025             m_qdFontFamily = GetAppFont();
1026         }
1027         else
1028         {
1029             m_qdFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
1030         }
1031
1032         m_qdFontStyle = 0;
1033         if (m_weight == wxFONTWEIGHT_BOLD)
1034             m_qdFontStyle |= bold;
1035         if (m_style == wxFONTSTYLE_ITALIC || m_style == wxFONTSTYLE_SLANT)
1036             m_qdFontStyle |= italic;
1037         if (m_underlined)
1038             m_qdFontStyle |= underline;
1039
1040
1041         // we try to get as much styles as possible into ATSU
1042
1043         // ATSUFontID and FMFont are equivalent
1044         FMFontStyle intrinsicStyle = 0 ;
1045         OSStatus status = FMGetFontFromFontFamilyInstance( m_qdFontFamily , m_qdFontStyle , (FMFont*)&m_atsuFontID , &intrinsicStyle);
1046         if ( status != noErr )
1047         {
1048             wxFAIL_MSG( wxT("couldn't get an ATSUFont from font family") );
1049         }
1050         m_atsuAdditionalQDStyles = m_qdFontStyle & (~intrinsicStyle );
1051         m_atsuFontValid = true;
1052     }
1053 #endif
1054     m_descriptorValid = true;
1055 }
1056
1057 void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
1058 {
1059     Init();
1060 #if wxOSX_USE_ATSU_TEXT
1061     m_atsuFontValid = info.m_atsuFontValid;
1062     m_atsuFontID = info.m_atsuFontID ;
1063     m_atsuAdditionalQDStyles = info.m_atsuAdditionalQDStyles;
1064 #if wxOSX_USE_CARBON
1065     m_qdFontFamily = info.m_qdFontFamily;
1066     m_qdFontStyle = info.m_qdFontStyle;
1067 #endif
1068 #endif
1069     m_pointSize = info.m_pointSize;
1070     m_family = info.m_family;
1071     m_style = info.m_style;
1072     m_weight = info.m_weight;
1073     m_underlined = info.m_underlined;
1074     m_faceName = info.m_faceName;
1075     m_encoding = info.m_encoding;
1076     m_descriptorValid = info.m_descriptorValid;
1077 }
1078
1079 void wxNativeFontInfo::Init(int size,
1080                   wxFontFamily family,
1081                   wxFontStyle style,
1082                   wxFontWeight weight,
1083                   bool underlined,
1084                   const wxString& faceName,
1085                   wxFontEncoding encoding)
1086 {
1087     Init();
1088     m_pointSize = size;
1089     m_family = family;
1090     m_style = style;
1091     m_weight = weight;
1092     m_underlined = underlined;
1093     m_faceName = faceName;
1094     if ( encoding == wxFONTENCODING_DEFAULT )
1095         encoding = wxFont::GetDefaultEncoding();
1096     m_encoding = encoding;
1097
1098 }
1099
1100 void wxNativeFontInfo::Free()
1101 {
1102 #if wxOSX_USE_ATSU_TEXT
1103     m_atsuFontID = 0 ;
1104     m_atsuAdditionalQDStyles = 0;
1105     m_atsuFontValid = false;
1106 #endif
1107     m_descriptorValid = false;
1108 }
1109
1110 bool wxNativeFontInfo::FromString(const wxString& s)
1111 {
1112     long l;
1113
1114     wxStringTokenizer tokenizer(s, wxT(";"));
1115
1116     wxString token = tokenizer.GetNextToken();
1117     //
1118     //  Ignore the version for now
1119     //
1120
1121     token = tokenizer.GetNextToken();
1122     if ( !token.ToLong(&l) )
1123         return false;
1124     m_pointSize = (int)l;
1125
1126     token = tokenizer.GetNextToken();
1127     if ( !token.ToLong(&l) )
1128         return false;
1129     m_family = (wxFontFamily)l;
1130
1131     token = tokenizer.GetNextToken();
1132     if ( !token.ToLong(&l) )
1133         return false;
1134     m_style = (wxFontStyle)l;
1135
1136     token = tokenizer.GetNextToken();
1137     if ( !token.ToLong(&l) )
1138         return false;
1139     m_weight = (wxFontWeight)l;
1140
1141     token = tokenizer.GetNextToken();
1142     if ( !token.ToLong(&l) )
1143         return false;
1144     m_underlined = l != 0;
1145
1146     m_faceName = tokenizer.GetNextToken();
1147
1148 #ifndef __WXMAC__
1149     if( !faceName )
1150         return false;
1151 #endif
1152
1153     token = tokenizer.GetNextToken();
1154     if ( !token.ToLong(&l) )
1155         return false;
1156     m_encoding = (wxFontEncoding)l;
1157
1158     return true;
1159 }
1160
1161 wxString wxNativeFontInfo::ToString() const
1162 {
1163     wxString s;
1164
1165     s.Printf(wxT("%d;%d;%d;%d;%d;%d;%s;%d"),
1166              0,                                 // version
1167              m_pointSize,
1168              m_family,
1169              (int)m_style,
1170              (int)m_weight,
1171              m_underlined,
1172              m_faceName.GetData(),
1173              (int)m_encoding);
1174
1175     return s;
1176 }
1177
1178 int wxNativeFontInfo::GetPointSize() const
1179 {
1180     return m_pointSize;
1181 }
1182
1183 wxFontStyle wxNativeFontInfo::GetStyle() const
1184 {
1185     return m_style;
1186 }
1187
1188 wxFontWeight wxNativeFontInfo::GetWeight() const
1189 {
1190     return m_weight;
1191 }
1192
1193 bool wxNativeFontInfo::GetUnderlined() const
1194 {
1195     return m_underlined;
1196 }
1197
1198 wxString wxNativeFontInfo::GetFaceName() const
1199 {
1200     return m_faceName;
1201 }
1202
1203 wxFontFamily wxNativeFontInfo::GetFamily() const
1204 {
1205     return m_family;
1206 }
1207
1208 wxFontEncoding wxNativeFontInfo::GetEncoding() const
1209 {
1210     return m_encoding;
1211 }
1212
1213 // changing the font descriptor
1214
1215 void wxNativeFontInfo::SetPointSize(int pointsize)
1216 {
1217     if ( m_pointSize != pointsize )
1218     {
1219         m_pointSize = pointsize;
1220         Free();
1221     }
1222 }
1223
1224 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
1225 {
1226     if ( m_style != style_ )
1227     {
1228         m_style = style_;
1229         Free();
1230     }
1231 }
1232
1233 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
1234 {
1235     if ( m_weight != weight_ )
1236     {
1237         m_weight = weight_;
1238         Free();
1239     }
1240 }
1241
1242 void wxNativeFontInfo::SetUnderlined(bool underlined_)
1243 {
1244     if ( m_underlined != underlined_ )
1245     {
1246         m_underlined = underlined_;
1247         Free();
1248     }
1249 }
1250
1251 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
1252 {
1253     if ( m_faceName != facename_ )
1254     {
1255         m_faceName = facename_;
1256         Free();
1257     }
1258     return true;
1259 }
1260
1261 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
1262 {
1263     if ( m_family != family_ )
1264     {
1265         m_family = family_;
1266         Free();
1267     }
1268 }
1269
1270 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
1271 {
1272     if ( encoding_ == wxFONTENCODING_DEFAULT )
1273         encoding_ = wxFont::GetDefaultEncoding();
1274     m_encoding = encoding_;
1275     // not reflected in native descriptors
1276 }