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_%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
 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 #if wxOSX_USE_IPHONE
 887
 888 UIFont* wxFont::OSXGetUIFont() const
 889 {
 890     wxCHECK_MSG( M_FONTDATA != NULL , 0, wxT("invalid font") );
 891
 892     // cast away constness otherwise lazy font resolution is not possible
 893     const_cast<wxFont *>(this)->RealizeResource();
 894
 895     return (M_FONTDATA->m_uiFont);
 896 }
 897
 898 #endif
 899
 900 const wxNativeFontInfo * wxFont::GetNativeFontInfo() const
 901 {
 902     wxCHECK_MSG( M_FONTDATA != NULL , NULL, wxT("invalid font") );
 903     wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
 904
 905     // cast away constness otherwise lazy font resolution is not possible
 906     const_cast<wxFont *>(this)->RealizeResource();
 907
 908     // M_FONTDATA->m_info.InitFromFont(*this);
 909
 910     return &(M_FONTDATA->m_info);
 911 }
 912
 913 // ----------------------------------------------------------------------------
 914 // wxNativeFontInfo
 915 // ----------------------------------------------------------------------------
 916
 917 #if 0 // wxOSX_USE_CORE_TEXT
 918
 919 /* from Core Text Manual Common Operations */
 920
 921 static CTFontDescriptorRef wxMacCreateCTFontDescriptor(CFStringRef iFamilyName, CTFontSymbolicTraits iTraits )
 922 {
 923     CTFontDescriptorRef descriptor = NULL;
 924     CFMutableDictionaryRef attributes;
 925
 926     wxASSERT(iFamilyName != NULL);
 927     // Create a mutable dictionary to hold our attributes.
 928     attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
 929                                            &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 930     wxASSERT(attributes != NULL);
 931
 932     if (attributes != NULL) {
 933         // Add a family name to our attributes.
 934         CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, iFamilyName);
 935
 936
 937         if ( iTraits ) {
 938             CFMutableDictionaryRef traits;
 939             CFNumberRef symTraits;
 940
 941             // Create the traits dictionary.
 942             symTraits = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type,
 943                                        &iTraits);
 944             wxASSERT(symTraits != NULL);
 945
 946             if (symTraits != NULL) {
 947                 // Create a dictionary to hold our traits values.
 948                 traits = CFDictionaryCreateMutable(kCFAllocatorDefault, 0,
 949                                                    &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
 950                 wxASSERT(traits != NULL);
 951
 952                 if (traits != NULL) {
 953                     // Add the symbolic traits value to the traits dictionary.
 954                     CFDictionaryAddValue(traits, kCTFontSymbolicTrait, symTraits);
 955
 956                     // Add the traits attribute to our attributes.
 957                     CFDictionaryAddValue(attributes, kCTFontTraitsAttribute, traits);
 958                     CFRelease(traits);
 959                 }
 960                 CFRelease(symTraits);
 961             }
 962         }
 963         // Create the font descriptor with our attributes
 964         descriptor = CTFontDescriptorCreateWithAttributes(attributes);
 965         wxASSERT(descriptor != NULL);
 966
 967         CFRelease(attributes);
 968     }
 969     // Return our font descriptor.
 970     return descriptor ;
 971 }
 972
 973 #endif
 974
 975 void wxNativeFontInfo::Init()
 976 {
 977 #if wxOSX_USE_ATSU_TEXT
 978     m_atsuFontID = 0 ;
 979     m_atsuAdditionalQDStyles = 0;
 980     m_atsuFontValid = false;
 981 #if wxOSX_USE_CARBON
 982     m_qdFontStyle = 0;
 983     m_qdFontFamily = 0;
 984 #endif
 985 #endif
 986     m_pointSize = 0;
 987     m_family = wxFONTFAMILY_DEFAULT;
 988     m_style = wxFONTSTYLE_NORMAL;
 989     m_weight = wxFONTWEIGHT_NORMAL;
 990     m_underlined = false;
 991     m_faceName.clear();
 992     m_encoding = wxFont::GetDefaultEncoding();
 993     m_descriptorValid = false;
 994 }
 995
 996 #if wxOSX_USE_CORE_TEXT
 997 void wxNativeFontInfo::Init(CTFontDescriptorRef descr)
 998 {
 999     Init();
1000
1001     wxCFRef< CFNumberRef > sizevalue( (CFNumberRef) CTFontDescriptorCopyAttribute( descr, kCTFontSizeAttribute ) );
1002     float fsize;
1003     if ( CFNumberGetValue( sizevalue , kCFNumberFloatType , &fsize ) )
1004         m_pointSize = (int)( fsize + 0.5 );
1005
1006     wxCFRef< CFDictionaryRef > traitsvalue( (CFDictionaryRef) CTFontDescriptorCopyAttribute( descr, kCTFontTraitsAttribute ) );
1007     CTFontSymbolicTraits traits;
1008     if ( CFNumberGetValue((CFNumberRef) CFDictionaryGetValue(traitsvalue,kCTFontSymbolicTrait),kCFNumberIntType,&traits) )
1009     {
1010         if ( traits & kCTFontItalicTrait )
1011             m_style = wxFONTSTYLE_ITALIC;
1012         if (  traits & kCTFontBoldTrait )
1013             m_weight = wxFONTWEIGHT_BOLD ;
1014     }
1015
1016     wxCFStringRef familyName( (CFStringRef) CTFontDescriptorCopyAttribute(descr, kCTFontFamilyNameAttribute));
1017     m_faceName = familyName.AsString();
1018 }
1019 #endif
1020
1021 void wxNativeFontInfo::EnsureValid()
1022 {
1023     if ( m_descriptorValid )
1024         return;
1025
1026 #if wxOSX_USE_ATSU_TEXT
1027     if ( !m_atsuFontValid )
1028     {
1029 #if !wxOSX_USE_CARBON
1030         // not needed outside
1031         wxInt16 m_qdFontFamily;
1032         wxInt16 m_qdFontStyle;
1033 #endif
1034         wxCFStringRef cf( m_faceName, wxLocale::GetSystemEncoding() );
1035         ATSFontFamilyRef atsfamily = ATSFontFamilyFindFromName( cf , kATSOptionFlagsDefault );
1036         if ( atsfamily == (ATSFontFamilyRef) -1 )
1037         {
1038             wxLogDebug( wxT("ATSFontFamilyFindFromName failed for ") + m_faceName );
1039             m_qdFontFamily = GetAppFont();
1040         }
1041         else
1042         {
1043             m_qdFontFamily = FMGetFontFamilyFromATSFontFamilyRef( atsfamily );
1044         }
1045
1046         m_qdFontStyle = 0;
1047         if (m_weight == wxFONTWEIGHT_BOLD)
1048             m_qdFontStyle |= bold;
1049         if (m_style == wxFONTSTYLE_ITALIC || m_style == wxFONTSTYLE_SLANT)
1050             m_qdFontStyle |= italic;
1051         if (m_underlined)
1052             m_qdFontStyle |= underline;
1053
1054
1055         // we try to get as much styles as possible into ATSU
1056
1057         // ATSUFontID and FMFont are equivalent
1058         FMFontStyle intrinsicStyle = 0 ;
1059         OSStatus status = FMGetFontFromFontFamilyInstance( m_qdFontFamily , m_qdFontStyle , (FMFont*)&m_atsuFontID , &intrinsicStyle);
1060         if ( status != noErr )
1061         {
1062             wxFAIL_MSG( wxT("couldn't get an ATSUFont from font family") );
1063         }
1064         m_atsuAdditionalQDStyles = m_qdFontStyle & (~intrinsicStyle );
1065         m_atsuFontValid = true;
1066     }
1067 #endif
1068     m_descriptorValid = true;
1069 }
1070
1071 void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
1072 {
1073     Init();
1074 #if wxOSX_USE_ATSU_TEXT
1075     m_atsuFontValid = info.m_atsuFontValid;
1076     m_atsuFontID = info.m_atsuFontID ;
1077     m_atsuAdditionalQDStyles = info.m_atsuAdditionalQDStyles;
1078 #if wxOSX_USE_CARBON
1079     m_qdFontFamily = info.m_qdFontFamily;
1080     m_qdFontStyle = info.m_qdFontStyle;
1081 #endif
1082 #endif
1083     m_pointSize = info.m_pointSize;
1084     m_family = info.m_family;
1085     m_style = info.m_style;
1086     m_weight = info.m_weight;
1087     m_underlined = info.m_underlined;
1088     m_faceName = info.m_faceName;
1089     m_encoding = info.m_encoding;
1090     m_descriptorValid = info.m_descriptorValid;
1091 }
1092
1093 void wxNativeFontInfo::Init(int size,
1094                   wxFontFamily family,
1095                   wxFontStyle style,
1096                   wxFontWeight weight,
1097                   bool underlined,
1098                   const wxString& faceName,
1099                   wxFontEncoding encoding)
1100 {
1101     Init();
1102     m_pointSize = size;
1103     m_family = family;
1104     m_style = style;
1105     m_weight = weight;
1106     m_underlined = underlined;
1107     m_faceName = faceName;
1108     if ( encoding == wxFONTENCODING_DEFAULT )
1109         encoding = wxFont::GetDefaultEncoding();
1110     m_encoding = encoding;
1111
1112 }
1113
1114 void wxNativeFontInfo::Free()
1115 {
1116 #if wxOSX_USE_ATSU_TEXT
1117     m_atsuFontID = 0 ;
1118     m_atsuAdditionalQDStyles = 0;
1119     m_atsuFontValid = false;
1120 #endif
1121     m_descriptorValid = false;
1122 }
1123
1124 bool wxNativeFontInfo::FromString(const wxString& s)
1125 {
1126     long l;
1127
1128     wxStringTokenizer tokenizer(s, wxT(";"));
1129
1130     wxString token = tokenizer.GetNextToken();
1131     //
1132     //  Ignore the version for now
1133     //
1134
1135     token = tokenizer.GetNextToken();
1136     if ( !token.ToLong(&l) )
1137         return false;
1138     m_pointSize = (int)l;
1139
1140     token = tokenizer.GetNextToken();
1141     if ( !token.ToLong(&l) )
1142         return false;
1143     m_family = (wxFontFamily)l;
1144
1145     token = tokenizer.GetNextToken();
1146     if ( !token.ToLong(&l) )
1147         return false;
1148     m_style = (wxFontStyle)l;
1149
1150     token = tokenizer.GetNextToken();
1151     if ( !token.ToLong(&l) )
1152         return false;
1153     m_weight = (wxFontWeight)l;
1154
1155     token = tokenizer.GetNextToken();
1156     if ( !token.ToLong(&l) )
1157         return false;
1158     m_underlined = l != 0;
1159
1160     m_faceName = tokenizer.GetNextToken();
1161
1162 #ifndef __WXMAC__
1163     if( !faceName )
1164         return false;
1165 #endif
1166
1167     token = tokenizer.GetNextToken();
1168     if ( !token.ToLong(&l) )
1169         return false;
1170     m_encoding = (wxFontEncoding)l;
1171
1172     return true;
1173 }
1174
1175 wxString wxNativeFontInfo::ToString() const
1176 {
1177     wxString s;
1178
1179     s.Printf(wxT("%d;%d;%d;%d;%d;%d;%s;%d"),
1180              0,                                 // version
1181              m_pointSize,
1182              m_family,
1183              (int)m_style,
1184              (int)m_weight,
1185              m_underlined,
1186              m_faceName.GetData(),
1187              (int)m_encoding);
1188
1189     return s;
1190 }
1191
1192 int wxNativeFontInfo::GetPointSize() const
1193 {
1194     return m_pointSize;
1195 }
1196
1197 wxFontStyle wxNativeFontInfo::GetStyle() const
1198 {
1199     return m_style;
1200 }
1201
1202 wxFontWeight wxNativeFontInfo::GetWeight() const
1203 {
1204     return m_weight;
1205 }
1206
1207 bool wxNativeFontInfo::GetUnderlined() const
1208 {
1209     return m_underlined;
1210 }
1211
1212 wxString wxNativeFontInfo::GetFaceName() const
1213 {
1214     return m_faceName;
1215 }
1216
1217 wxFontFamily wxNativeFontInfo::GetFamily() const
1218 {
1219     return m_family;
1220 }
1221
1222 wxFontEncoding wxNativeFontInfo::GetEncoding() const
1223 {
1224     return m_encoding;
1225 }
1226
1227 // changing the font descriptor
1228
1229 void wxNativeFontInfo::SetPointSize(int pointsize)
1230 {
1231     if ( m_pointSize != pointsize )
1232     {
1233         m_pointSize = pointsize;
1234         Free();
1235     }
1236 }
1237
1238 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
1239 {
1240     if ( m_style != style_ )
1241     {
1242         m_style = style_;
1243         Free();
1244     }
1245 }
1246
1247 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
1248 {
1249     if ( m_weight != weight_ )
1250     {
1251         m_weight = weight_;
1252         Free();
1253     }
1254 }
1255
1256 void wxNativeFontInfo::SetUnderlined(bool underlined_)
1257 {
1258     if ( m_underlined != underlined_ )
1259     {
1260         m_underlined = underlined_;
1261         Free();
1262     }
1263 }
1264
1265 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
1266 {
1267     if ( m_faceName != facename_ )
1268     {
1269         m_faceName = facename_;
1270         Free();
1271     }
1272     return true;
1273 }
1274
1275 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
1276 {
1277     if ( m_family != family_ )
1278     {
1279         m_family = family_;
1280         Free();
1281     }
1282 }
1283
1284 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
1285 {
1286     if ( encoding_ == wxFONTENCODING_DEFAULT )
1287         encoding_ = wxFont::GetDefaultEncoding();
1288     m_encoding = encoding_;
1289     // not reflected in native descriptors
1290 }