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::DoGetFamily() const
 736 {
 737     return M_FONTDATA->GetFamily();
 738 }
 739
 740 wxFontStyle wxFont::GetStyle() const
 741 {
 742     wxCHECK_MSG( M_FONTDATA != NULL , wxFONTSTYLE_MAX, wxT("invalid font") );
 743
 744     return M_FONTDATA->GetStyle() ;
 745 }
 746
 747 wxFontWeight wxFont::GetWeight() const
 748 {
 749     wxCHECK_MSG( M_FONTDATA != NULL , wxFONTWEIGHT_MAX, wxT("invalid font") );
 750
 751     return M_FONTDATA->GetWeight();
 752 }
 753
 754 bool wxFont::GetUnderlined() const
 755 {
 756     wxCHECK_MSG( M_FONTDATA != NULL , false, wxT("invalid font") );
 757
 758     return M_FONTDATA->GetUnderlined();
 759 }
 760
 761 wxString wxFont::GetFaceName() const
 762 {
 763     wxCHECK_MSG( M_FONTDATA != NULL , wxEmptyString , wxT("invalid font") );
 764
 765     return M_FONTDATA->GetFaceName() ;
 766 }
 767
 768 wxFontEncoding 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
 777 short 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
 787 wxByte 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
 797 wxUint16 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
 807 void * 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
 817 wxUint32 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
 827 wxUint32 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
 840 CTFontRef 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
 854 CGFontRef 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
 869 NSFont* 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
 883 UIFont* 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
 895 const 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
 916 static 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
 970 void 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
 992 void 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
1016 void 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
1066 void 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
1088 void 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
1109 void 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
1119 bool 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
1170 wxString 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
1187 int wxNativeFontInfo::GetPointSize() const
1188 {
1189     return m_pointSize;
1190 }
1191
1192 wxFontStyle wxNativeFontInfo::GetStyle() const
1193 {
1194     return m_style;
1195 }
1196
1197 wxFontWeight wxNativeFontInfo::GetWeight() const
1198 {
1199     return m_weight;
1200 }
1201
1202 bool wxNativeFontInfo::GetUnderlined() const
1203 {
1204     return m_underlined;
1205 }
1206
1207 wxString wxNativeFontInfo::GetFaceName() const
1208 {
1209     return m_faceName;
1210 }
1211
1212 wxFontFamily wxNativeFontInfo::GetFamily() const
1213 {
1214     return m_family;
1215 }
1216
1217 wxFontEncoding wxNativeFontInfo::GetEncoding() const
1218 {
1219     return m_encoding;
1220 }
1221
1222 // changing the font descriptor
1223
1224 void wxNativeFontInfo::SetPointSize(int pointsize)
1225 {
1226     if ( m_pointSize != pointsize )
1227     {
1228         m_pointSize = pointsize;
1229         Free();
1230     }
1231 }
1232
1233 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
1234 {
1235     if ( m_style != style_ )
1236     {
1237         m_style = style_;
1238         Free();
1239     }
1240 }
1241
1242 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
1243 {
1244     if ( m_weight != weight_ )
1245     {
1246         m_weight = weight_;
1247         Free();
1248     }
1249 }
1250
1251 void wxNativeFontInfo::SetUnderlined(bool underlined_)
1252 {
1253     if ( m_underlined != underlined_ )
1254     {
1255         m_underlined = underlined_;
1256         Free();
1257     }
1258 }
1259
1260 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
1261 {
1262     if ( m_faceName != facename_ )
1263     {
1264         m_faceName = facename_;
1265         Free();
1266     }
1267     return true;
1268 }
1269
1270 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
1271 {
1272     if ( m_family != family_ )
1273     {
1274         m_family = family_;
1275         Free();
1276     }
1277 }
1278
1279 void 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 }