src/msw/font.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/font.cpp
   3 // Purpose:     wxFont class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWindows team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "font.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/setup.h"
  33     #include "wx/list.h"
  34     #include "wx/utils.h"
  35     #include "wx/app.h"
  36     #include "wx/font.h"
  37     #include "wx/log.h"
  38 #endif // WX_PRECOMP
  39
  40 #include "wx/msw/private.h"
  41
  42 #include "wx/fontutil.h"
  43 #include "wx/fontmap.h"
  44
  45 #include "wx/tokenzr.h"
  46
  47 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
  48
  49 // ----------------------------------------------------------------------------
  50 // constants
  51 // ----------------------------------------------------------------------------
  52
  53 // the mask used to extract the pitch from LOGFONT::lfPitchAndFamily field
  54 static const int PITCH_MASK = FIXED_PITCH | VARIABLE_PITCH;
  55
  56 // ----------------------------------------------------------------------------
  57 // wxFontRefData - the internal description of the font
  58 // ----------------------------------------------------------------------------
  59
  60 class WXDLLEXPORT wxFontRefData: public wxGDIRefData
  61 {
  62 public:
  63     // constructors
  64     wxFontRefData()
  65     {
  66         Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL,
  67              FALSE, _T(""), wxFONTENCODING_DEFAULT);
  68     }
  69
  70     wxFontRefData(int size,
  71                   int family,
  72                   int style,
  73                   int weight,
  74                   bool underlined,
  75                   const wxString& faceName,
  76                   wxFontEncoding encoding)
  77     {
  78         Init(size, family, style, weight, underlined, faceName, encoding);
  79     }
  80
  81     wxFontRefData(const wxNativeFontInfo& info, WXHFONT hFont = 0)
  82     {
  83         Init(info, hFont);
  84     }
  85
  86     wxFontRefData(const wxFontRefData& data)
  87     {
  88         if ( data.m_nativeFontInfoOk )
  89         {
  90             Init(data.m_nativeFontInfo);
  91         }
  92         else
  93         {
  94             Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
  95                  data.m_underlined, data.m_faceName, data.m_encoding);
  96         }
  97     }
  98
  99     virtual ~wxFontRefData();
 100
 101     // operations
 102     bool Alloc(wxFont *font);
 103
 104     void Free();
 105
 106     // all wxFont accessors
 107     int GetPointSize() const
 108     {
 109         return m_nativeFontInfoOk ? m_nativeFontInfo.GetPointSize()
 110                                   : m_pointSize;
 111     }
 112
 113     int GetFamily() const
 114     {
 115         return m_family;
 116     }
 117
 118     int GetStyle() const
 119     {
 120         return m_nativeFontInfoOk ? m_nativeFontInfo.GetStyle()
 121                                   : m_style;
 122     }
 123
 124     int GetWeight() const
 125     {
 126         return m_nativeFontInfoOk ? m_nativeFontInfo.GetWeight()
 127                                   : m_weight;
 128     }
 129
 130     bool GetUnderlined() const
 131     {
 132         return m_nativeFontInfoOk ? m_nativeFontInfo.GetUnderlined()
 133                                   : m_underlined;
 134     }
 135
 136     wxString GetFaceName() const
 137     {
 138         wxString s;
 139         if ( m_nativeFontInfoOk )
 140             s = m_nativeFontInfo.GetFaceName();
 141         else
 142             s = m_faceName;
 143
 144         return s;
 145     }
 146
 147     wxFontEncoding GetEncoding() const
 148     {
 149         return m_nativeFontInfoOk ? m_nativeFontInfo.GetEncoding()
 150                                   : m_encoding;
 151     }
 152
 153     WXHFONT GetHFONT() const { return m_hFont; }
 154
 155     // ... and setters
 156     void SetPointSize(int pointSize)
 157     {
 158         if ( m_nativeFontInfoOk )
 159             m_nativeFontInfo.SetPointSize(pointSize);
 160         else
 161             m_pointSize = pointSize;
 162     }
 163
 164     void SetFamily(int family)
 165     {
 166         m_family = family;
 167     }
 168
 169     void SetStyle(int style)
 170     {
 171         if ( m_nativeFontInfoOk )
 172             m_nativeFontInfo.SetStyle((wxFontStyle)style);
 173         else
 174             m_style = style;
 175     }
 176
 177     void SetWeight(int weight)
 178     {
 179         if ( m_nativeFontInfoOk )
 180             m_nativeFontInfo.SetWeight((wxFontWeight)weight);
 181         else
 182             m_weight = weight;
 183     }
 184
 185     void SetFaceName(const wxString& faceName)
 186     {
 187         if ( m_nativeFontInfoOk )
 188             m_nativeFontInfo.SetFaceName(faceName);
 189         else
 190             m_faceName = faceName;
 191     }
 192
 193     void SetUnderlined(bool underlined)
 194     {
 195         if ( m_nativeFontInfoOk )
 196             m_nativeFontInfo.SetUnderlined(underlined);
 197         else
 198             m_underlined = underlined;
 199     }
 200
 201     void SetEncoding(wxFontEncoding encoding)
 202     {
 203         if ( m_nativeFontInfoOk )
 204             m_nativeFontInfo.SetEncoding(encoding);
 205         else
 206             m_encoding = encoding;
 207     }
 208
 209     // native font info tests
 210     bool HasNativeFontInfo() const { return m_nativeFontInfoOk; }
 211
 212     const wxNativeFontInfo& GetNativeFontInfo() const
 213         { return m_nativeFontInfo; }
 214
 215 protected:
 216     // common part of all ctors
 217     void Init(int size,
 218               int family,
 219               int style,
 220               int weight,
 221               bool underlined,
 222               const wxString& faceName,
 223               wxFontEncoding encoding);
 224
 225     void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0);
 226
 227     // font characterstics
 228     int           m_pointSize;
 229     int           m_family;
 230     int           m_style;
 231     int           m_weight;
 232     bool          m_underlined;
 233     wxString      m_faceName;
 234     wxFontEncoding m_encoding;
 235
 236     // Windows font handle
 237     WXHFONT       m_hFont;
 238
 239     // Native font info
 240     wxNativeFontInfo m_nativeFontInfo;
 241     bool             m_nativeFontInfoOk;
 242 };
 243
 244 // ============================================================================
 245 // implementation
 246 // ============================================================================
 247
 248 // ----------------------------------------------------------------------------
 249 // wxFontRefData
 250 // ----------------------------------------------------------------------------
 251
 252 void wxFontRefData::Init(int pointSize,
 253                          int family,
 254                          int style,
 255                          int weight,
 256                          bool underlined,
 257                          const wxString& faceName,
 258                          wxFontEncoding encoding)
 259 {
 260     m_style = style;
 261     m_pointSize = pointSize == -1 ? wxNORMAL_FONT->GetPointSize() : pointSize;
 262     m_family = family;
 263     m_style = style;
 264     m_weight = weight;
 265     m_underlined = underlined;
 266     m_faceName = faceName;
 267     m_encoding = encoding;
 268
 269     m_hFont = 0;
 270
 271     m_nativeFontInfoOk = FALSE;
 272 }
 273
 274 void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont)
 275 {
 276     // hFont may be zero, or it be passed in case we really want to
 277     // use the exact font created in the underlying system
 278     // (for example where we can't guarantee conversion from HFONT
 279     // to LOGFONT back to HFONT)
 280     m_hFont = hFont;
 281
 282     m_nativeFontInfoOk = TRUE;
 283     m_nativeFontInfo = info;
 284 }
 285
 286 wxFontRefData::~wxFontRefData()
 287 {
 288     Free();
 289 }
 290
 291 bool wxFontRefData::Alloc(wxFont *font)
 292 {
 293     if ( !m_nativeFontInfoOk )
 294     {
 295         wxFillLogFont(&m_nativeFontInfo.lf, font);
 296         m_nativeFontInfoOk = TRUE;
 297     }
 298
 299     HFONT hfont = ::CreateFontIndirect(&m_nativeFontInfo.lf);
 300     if ( !hfont )
 301     {
 302         wxLogLastError(wxT("CreateFont"));
 303
 304         return FALSE;
 305     }
 306
 307     m_hFont = (WXHFONT)hfont;
 308
 309     return TRUE;
 310 }
 311
 312 void wxFontRefData::Free()
 313 {
 314     if ( m_hFont )
 315     {
 316         if ( !::DeleteObject((HFONT) m_hFont) )
 317         {
 318             wxLogLastError(wxT("DeleteObject(font)"));
 319         }
 320
 321         m_hFont = 0;
 322     }
 323 }
 324
 325 // ----------------------------------------------------------------------------
 326 // wxNativeFontInfo
 327 // ----------------------------------------------------------------------------
 328
 329 void wxNativeFontInfo::Init()
 330 {
 331     wxZeroMemory(lf);
 332 }
 333
 334 int wxNativeFontInfo::GetPointSize() const
 335 {
 336     // FIXME: using the screen here results in incorrect font size calculation
 337     //        for printing!
 338     const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
 339
 340     return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5);
 341 }
 342
 343 wxFontStyle wxNativeFontInfo::GetStyle() const
 344 {
 345     return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL;
 346 }
 347
 348 wxFontWeight wxNativeFontInfo::GetWeight() const
 349 {
 350     if ( lf.lfWeight <= 300 )
 351         return wxFONTWEIGHT_LIGHT;
 352
 353     if ( lf.lfWeight >= 600 )
 354         return wxFONTWEIGHT_BOLD;
 355
 356     return wxFONTWEIGHT_NORMAL;
 357 }
 358
 359 bool wxNativeFontInfo::GetUnderlined() const
 360 {
 361     return lf.lfUnderline != 0;
 362 }
 363
 364 wxString wxNativeFontInfo::GetFaceName() const
 365 {
 366     return lf.lfFaceName;
 367 }
 368
 369 wxFontFamily wxNativeFontInfo::GetFamily() const
 370 {
 371     wxFontFamily family;
 372
 373     // extract family from pitch-and-family
 374     switch ( lf.lfPitchAndFamily & ~PITCH_MASK )
 375     {
 376         case FF_ROMAN:
 377             family = wxFONTFAMILY_ROMAN;
 378             break;
 379
 380         default:
 381             wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") );
 382             // fall through
 383
 384         case FF_SWISS:
 385             family = wxFONTFAMILY_SWISS;
 386             break;
 387
 388         case FF_SCRIPT:
 389             family = wxFONTFAMILY_SCRIPT;
 390             break;
 391
 392         case FF_MODERN:
 393             family = wxFONTFAMILY_MODERN;
 394             break;
 395
 396         case FF_DECORATIVE:
 397             family = wxFONTFAMILY_DECORATIVE;
 398             break;
 399     }
 400
 401     return family;
 402 }
 403
 404 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 405 {
 406     return wxGetFontEncFromCharSet(lf.lfCharSet);
 407 }
 408
 409 void wxNativeFontInfo::SetPointSize(int pointsize)
 410 {
 411 #if wxFONT_SIZE_COMPATIBILITY
 412     // Incorrect, but compatible with old wxWindows behaviour
 413     lf.lfHeight = (pointSize*ppInch)/72;
 414 #else // wxFONT_SIZE_COMPATIBILITY
 415     // FIXME: using the screen here results in incorrect font size calculation
 416     //        for printing!
 417     const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
 418
 419     lf.lfHeight = -(int)((pointsize*((double)ppInch)/72.0) + 0.5);
 420 #endif // wxFONT_SIZE_COMPATIBILITY/!wxFONT_SIZE_COMPATIBILITY
 421 }
 422
 423 void wxNativeFontInfo::SetStyle(wxFontStyle style)
 424 {
 425     switch ( style )
 426     {
 427         default:
 428             wxFAIL_MSG( _T("unknown font style") );
 429             // fall through
 430
 431         case wxFONTSTYLE_NORMAL:
 432             break;
 433
 434         case wxFONTSTYLE_ITALIC:
 435         case wxFONTSTYLE_SLANT:
 436             lf.lfItalic = TRUE;
 437             break;
 438     }
 439 }
 440
 441 void wxNativeFontInfo::SetWeight(wxFontWeight weight)
 442 {
 443     switch ( weight )
 444     {
 445         default:
 446             wxFAIL_MSG( _T("unknown font weight") );
 447             // fall through
 448
 449         case wxFONTWEIGHT_NORMAL:
 450             lf.lfWeight = FW_NORMAL;
 451             break;
 452
 453         case wxFONTWEIGHT_LIGHT:
 454             lf.lfWeight = FW_LIGHT;
 455             break;
 456
 457         case wxFONTWEIGHT_BOLD:
 458             lf.lfWeight = FW_BOLD;
 459             break;
 460     }
 461 }
 462
 463 void wxNativeFontInfo::SetUnderlined(bool underlined)
 464 {
 465     lf.lfUnderline = underlined;
 466 }
 467
 468 void wxNativeFontInfo::SetFaceName(wxString facename)
 469 {
 470     wxStrncpy(lf.lfFaceName, facename, WXSIZEOF(lf.lfFaceName));
 471 }
 472
 473 void wxNativeFontInfo::SetFamily(wxFontFamily family)
 474 {
 475     int ff_family;
 476     wxString facename;
 477
 478     switch ( family )
 479     {
 480         case wxSCRIPT:
 481             ff_family = FF_SCRIPT;
 482             facename = _T("Script");
 483             break;
 484
 485         case wxDECORATIVE:
 486             ff_family = FF_DECORATIVE;
 487             facename = _T("Old English Text MT");
 488             break;
 489
 490         case wxROMAN:
 491             ff_family = FF_ROMAN;
 492             facename = _T("Times New Roman");
 493             break;
 494
 495         case wxTELETYPE:
 496         case wxMODERN:
 497             ff_family = FF_MODERN;
 498             facename = _T("Courier New");
 499             break;
 500
 501         case wxSWISS:
 502             ff_family = FF_SWISS;
 503             facename = _T("Arial");
 504             break;
 505
 506         case wxDEFAULT:
 507         default:
 508             ff_family = FF_SWISS;
 509             facename = _T("MS Sans Serif");
 510     }
 511
 512     lf.lfPitchAndFamily = DEFAULT_PITCH | ff_family;
 513
 514     if ( !wxStrlen(lf.lfFaceName) )
 515     {
 516         SetFaceName(facename);
 517     }
 518 }
 519
 520 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding)
 521 {
 522     wxNativeEncodingInfo info;
 523     if ( !wxGetNativeFontEncoding(encoding, &info) )
 524     {
 525 #if wxUSE_FONTMAP
 526         if ( wxTheFontMapper->GetAltForEncoding(encoding, &info) )
 527         {
 528             if ( !info.facename.empty() )
 529             {
 530                 // if we have this encoding only in some particular facename, use
 531                 // the facename - it is better to show the correct characters in a
 532                 // wrong facename than unreadable text in a correct one
 533                 SetFaceName(info.facename);
 534             }
 535         }
 536         else
 537 #endif // wxUSE_FONTMAP
 538         {
 539             // unsupported encoding, replace with the default
 540             info.charset = DEFAULT_CHARSET;
 541         }
 542     }
 543
 544     lf.lfCharSet = info.charset;
 545 }
 546
 547 bool wxNativeFontInfo::FromString(const wxString& s)
 548 {
 549     long l;
 550
 551     wxStringTokenizer tokenizer(s, _T(";"));
 552
 553     // first the version
 554     wxString token = tokenizer.GetNextToken();
 555     if ( token != _T('0') )
 556         return FALSE;
 557
 558     token = tokenizer.GetNextToken();
 559     if ( !token.ToLong(&l) )
 560         return FALSE;
 561     lf.lfHeight = l;
 562
 563     token = tokenizer.GetNextToken();
 564     if ( !token.ToLong(&l) )
 565         return FALSE;
 566     lf.lfWidth = l;
 567
 568     token = tokenizer.GetNextToken();
 569     if ( !token.ToLong(&l) )
 570         return FALSE;
 571     lf.lfEscapement = l;
 572
 573     token = tokenizer.GetNextToken();
 574     if ( !token.ToLong(&l) )
 575         return FALSE;
 576     lf.lfOrientation = l;
 577
 578     token = tokenizer.GetNextToken();
 579     if ( !token.ToLong(&l) )
 580         return FALSE;
 581     lf.lfWeight = l;
 582
 583     token = tokenizer.GetNextToken();
 584     if ( !token.ToLong(&l) )
 585         return FALSE;
 586     lf.lfItalic = (BYTE)l;
 587
 588     token = tokenizer.GetNextToken();
 589     if ( !token.ToLong(&l) )
 590         return FALSE;
 591     lf.lfUnderline = (BYTE)l;
 592
 593     token = tokenizer.GetNextToken();
 594     if ( !token.ToLong(&l) )
 595         return FALSE;
 596     lf.lfStrikeOut = (BYTE)l;
 597
 598     token = tokenizer.GetNextToken();
 599     if ( !token.ToLong(&l) )
 600         return FALSE;
 601     lf.lfCharSet = (BYTE)l;
 602
 603     token = tokenizer.GetNextToken();
 604     if ( !token.ToLong(&l) )
 605         return FALSE;
 606     lf.lfOutPrecision = (BYTE)l;
 607
 608     token = tokenizer.GetNextToken();
 609     if ( !token.ToLong(&l) )
 610         return FALSE;
 611     lf.lfClipPrecision = (BYTE)l;
 612
 613     token = tokenizer.GetNextToken();
 614     if ( !token.ToLong(&l) )
 615         return FALSE;
 616     lf.lfQuality = (BYTE)l;
 617
 618     token = tokenizer.GetNextToken();
 619     if ( !token.ToLong(&l) )
 620         return FALSE;
 621     lf.lfPitchAndFamily = (BYTE)l;
 622
 623     token = tokenizer.GetNextToken();
 624     if(!token)
 625         return FALSE;
 626     wxStrcpy(lf.lfFaceName, token.c_str());
 627
 628     return TRUE;
 629 }
 630
 631 wxString wxNativeFontInfo::ToString() const
 632 {
 633     wxString s;
 634
 635     s.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
 636              0, // version, in case we want to change the format later
 637              lf.lfHeight,
 638              lf.lfWidth,
 639              lf.lfEscapement,
 640              lf.lfOrientation,
 641              lf.lfWeight,
 642              lf.lfItalic,
 643              lf.lfUnderline,
 644              lf.lfStrikeOut,
 645              lf.lfCharSet,
 646              lf.lfOutPrecision,
 647              lf.lfClipPrecision,
 648              lf.lfQuality,
 649              lf.lfPitchAndFamily,
 650              lf.lfFaceName);
 651
 652     return s;
 653 }
 654
 655 // ----------------------------------------------------------------------------
 656 // wxFont
 657 // ----------------------------------------------------------------------------
 658
 659 void wxFont::Init()
 660 {
 661 }
 662
 663 bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont)
 664 {
 665     UnRef();
 666
 667     m_refData = new wxFontRefData(info, hFont);
 668
 669     RealizeResource();
 670
 671     return TRUE;
 672 }
 673
 674 wxFont::wxFont(const wxString& fontdesc)
 675 {
 676     wxNativeFontInfo info;
 677     if ( info.FromString(fontdesc) )
 678         (void)Create(info);
 679 }
 680
 681 /* Constructor for a font. Note that the real construction is done
 682  * in wxDC::SetFont, when information is available about scaling etc.
 683  */
 684 bool wxFont::Create(int pointSize,
 685                     int family,
 686                     int style,
 687                     int weight,
 688                     bool underlined,
 689                     const wxString& faceName,
 690                     wxFontEncoding encoding)
 691 {
 692     UnRef();
 693
 694     // wxDEFAULT is a valid value for the font size too so we must treat it
 695     // specially here (otherwise the size would be 70 == wxDEFAULT value)
 696     if ( pointSize == wxDEFAULT )
 697     {
 698         pointSize = wxNORMAL_FONT->GetPointSize();
 699     }
 700
 701     m_refData = new wxFontRefData(pointSize, family, style, weight,
 702                                   underlined, faceName, encoding);
 703
 704     RealizeResource();
 705
 706     return TRUE;
 707 }
 708
 709 wxFont::~wxFont()
 710 {
 711 }
 712
 713 // ----------------------------------------------------------------------------
 714 // real implementation
 715 // ----------------------------------------------------------------------------
 716
 717 bool wxFont::RealizeResource()
 718 {
 719     if ( GetResourceHandle() )
 720     {
 721         // VZ: the old code returned FALSE in this case, but it doesn't seem
 722         //     to make sense because the font _was_ created
 723         return TRUE;
 724     }
 725
 726     return M_FONTDATA->Alloc(this);
 727 }
 728
 729 bool wxFont::FreeResource(bool WXUNUSED(force))
 730 {
 731     if ( GetResourceHandle() )
 732     {
 733         M_FONTDATA->Free();
 734
 735         return TRUE;
 736     }
 737
 738     return FALSE;
 739 }
 740
 741 WXHANDLE wxFont::GetResourceHandle()
 742 {
 743     return GetHFONT();
 744 }
 745
 746 WXHFONT wxFont::GetHFONT() const
 747 {
 748     return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0;
 749 }
 750
 751 bool wxFont::IsFree() const
 752 {
 753     return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0);
 754 }
 755
 756 void wxFont::Unshare()
 757 {
 758     // Don't change shared data
 759     if ( !m_refData )
 760     {
 761         m_refData = new wxFontRefData();
 762     }
 763     else
 764     {
 765         wxFontRefData* ref = new wxFontRefData(*M_FONTDATA);
 766         UnRef();
 767         m_refData = ref;
 768     }
 769 }
 770
 771 // ----------------------------------------------------------------------------
 772 // change font attribute: we recreate font when doing it
 773 // ----------------------------------------------------------------------------
 774
 775 void wxFont::SetPointSize(int pointSize)
 776 {
 777     Unshare();
 778
 779     M_FONTDATA->SetPointSize(pointSize);
 780
 781     RealizeResource();
 782 }
 783
 784 void wxFont::SetFamily(int family)
 785 {
 786     Unshare();
 787
 788     M_FONTDATA->SetFamily(family);
 789
 790     RealizeResource();
 791 }
 792
 793 void wxFont::SetStyle(int style)
 794 {
 795     Unshare();
 796
 797     M_FONTDATA->SetStyle(style);
 798
 799     RealizeResource();
 800 }
 801
 802 void wxFont::SetWeight(int weight)
 803 {
 804     Unshare();
 805
 806     M_FONTDATA->SetWeight(weight);
 807
 808     RealizeResource();
 809 }
 810
 811 void wxFont::SetFaceName(const wxString& faceName)
 812 {
 813     Unshare();
 814
 815     M_FONTDATA->SetFaceName(faceName);
 816
 817     RealizeResource();
 818 }
 819
 820 void wxFont::SetUnderlined(bool underlined)
 821 {
 822     Unshare();
 823
 824     M_FONTDATA->SetUnderlined(underlined);
 825
 826     RealizeResource();
 827 }
 828
 829 void wxFont::SetEncoding(wxFontEncoding encoding)
 830 {
 831     Unshare();
 832
 833     M_FONTDATA->SetEncoding(encoding);
 834
 835     RealizeResource();
 836 }
 837
 838 void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
 839 {
 840     Unshare();
 841
 842     FreeResource();
 843
 844     *M_FONTDATA = wxFontRefData(info);
 845
 846     RealizeResource();
 847 }
 848
 849 // ----------------------------------------------------------------------------
 850 // accessors
 851 // ----------------------------------------------------------------------------
 852
 853 int wxFont::GetPointSize() const
 854 {
 855     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 856
 857     return M_FONTDATA->GetPointSize();
 858 }
 859
 860 int wxFont::GetFamily() const
 861 {
 862     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 863
 864     return M_FONTDATA->GetFamily();
 865 }
 866
 867 int wxFont::GetStyle() const
 868 {
 869     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 870
 871     return M_FONTDATA->GetStyle();
 872 }
 873
 874 int wxFont::GetWeight() const
 875 {
 876     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 877
 878     return M_FONTDATA->GetWeight();
 879 }
 880
 881 bool wxFont::GetUnderlined() const
 882 {
 883     wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
 884
 885     return M_FONTDATA->GetUnderlined();
 886 }
 887
 888 wxString wxFont::GetFaceName() const
 889 {
 890     wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
 891
 892     return M_FONTDATA->GetFaceName();
 893 }
 894
 895 wxFontEncoding wxFont::GetEncoding() const
 896 {
 897     wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
 898
 899     return M_FONTDATA->GetEncoding();
 900 }
 901
 902 wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 903 {
 904     if ( M_FONTDATA->HasNativeFontInfo() )
 905         return new wxNativeFontInfo(M_FONTDATA->GetNativeFontInfo());
 906
 907     return 0;
 908 }
 909
 910 bool wxFont::IsFixedWidth() const
 911 {
 912     if ( M_FONTDATA->HasNativeFontInfo() )
 913     {
 914         // the two low-order bits specify the pitch of the font, the rest is
 915         // family
 916         BYTE pitch = M_FONTDATA->GetNativeFontInfo().
 917                         lf.lfPitchAndFamily & PITCH_MASK;
 918
 919         return pitch == FIXED_PITCH;
 920     }
 921
 922     return wxFontBase::IsFixedWidth();
 923 }
 924