src/gtk1/font.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk1/font.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling and Julian Smart
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // ============================================================================
  11 // declarations
  12 // ============================================================================
  13
  14 // ----------------------------------------------------------------------------
  15 // headers
  16 // ----------------------------------------------------------------------------
  17
  18 // For compilers that support precompilation, includes "wx.h".
  19 #include "wx/wxprec.h"
  20
  21 #include "wx/font.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/log.h"
  25     #include "wx/settings.h"
  26     #include "wx/gdicmn.h"
  27     #include "wx/crt.h"
  28 #endif
  29
  30 #include "wx/fontutil.h"
  31 #include "wx/encinfo.h"
  32 #include "wx/utils.h"
  33 #include "wx/tokenzr.h"
  34
  35 #include <strings.h>
  36
  37 #include "wx/gtk1/private.h"
  38 #include <gdk/gdkprivate.h>
  39
  40 // ----------------------------------------------------------------------------
  41 // constants
  42 // ----------------------------------------------------------------------------
  43
  44 // the default size (in points) for the fonts
  45 static const int wxDEFAULT_FONT_SIZE = 12;
  46
  47 // ----------------------------------------------------------------------------
  48 // wxScaledFontList: maps the font sizes to the GDK fonts for the given font
  49 // ----------------------------------------------------------------------------
  50
  51 WX_DECLARE_HASH_MAP(int, GdkFont *, wxIntegerHash, wxIntegerEqual,
  52                     wxScaledFontList);
  53
  54 // ----------------------------------------------------------------------------
  55 // wxFontRefData
  56 // ----------------------------------------------------------------------------
  57
  58 class wxFontRefData : public wxGDIRefData
  59 {
  60 public:
  61     // from broken down font parameters, also default ctor
  62     wxFontRefData(int size = -1,
  63                   wxFontFamily family = wxFONTFAMILY_DEFAULT,
  64                   wxFontStyle style = wxFONTSTYLE_NORMAL,
  65                   wxFontWeight weight = wxFONTWEIGHT_NORMAL,
  66                   bool underlined = false,
  67                   const wxString& faceName = wxEmptyString,
  68                   wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
  69
  70     // from XFLD
  71     wxFontRefData(const wxString& fontname);
  72
  73     // copy ctor
  74     wxFontRefData( const wxFontRefData& data );
  75
  76     virtual ~wxFontRefData();
  77
  78     // do we have the native font info?
  79     bool HasNativeFont() const
  80     {
  81         // only use m_nativeFontInfo if it had been initialized
  82         return !m_nativeFontInfo.IsDefault();
  83     }
  84
  85     // setters: all of them also take care to modify m_nativeFontInfo if we
  86     // have it so as to not lose the information not carried by our fields
  87     void SetPointSize(int pointSize);
  88     void SetFamily(wxFontFamily family);
  89     void SetStyle(wxFontStyle style);
  90     void SetWeight(wxFontWeight weight);
  91     void SetUnderlined(bool underlined);
  92     bool SetFaceName(const wxString& facename);
  93     void SetEncoding(wxFontEncoding encoding);
  94
  95     // and this one also modifies all the other font data fields
  96     void SetNativeFontInfo(const wxNativeFontInfo& info);
  97
  98 protected:
  99     // common part of all ctors
 100     void Init(int pointSize,
 101               wxFontFamily family,
 102               wxFontStyle style,
 103               wxFontWeight weight,
 104               bool underlined,
 105               const wxString& faceName,
 106               wxFontEncoding encoding);
 107
 108     // set all fields from (already initialized and valid) m_nativeFontInfo
 109     void InitFromNative();
 110
 111 private:
 112     // clear m_scaled_xfonts if any
 113     void ClearGdkFonts();
 114
 115     // the map of font sizes to "GdkFont *"
 116     wxScaledFontList  m_scaled_xfonts;
 117
 118     int             m_pointSize;
 119     wxFontFamily    m_family;
 120     wxFontStyle     m_style;
 121     wxFontWeight    m_weight;
 122     bool            m_underlined;
 123     wxString        m_faceName;
 124     wxFontEncoding  m_encoding;  // Unused under GTK 2.0
 125
 126     // The native font info, basicly an XFLD under GTK 1.2 and
 127     // the pango font description under GTK 2.0.
 128     wxNativeFontInfo m_nativeFontInfo;
 129
 130     friend class wxFont;
 131 };
 132
 133 #define M_FONTDATA ((wxFontRefData*)m_refData)
 134
 135 // ----------------------------------------------------------------------------
 136 // wxFontRefData
 137 // ----------------------------------------------------------------------------
 138
 139 void wxFontRefData::Init(int pointSize,
 140                          wxFontFamily family,
 141                          wxFontStyle style,
 142                          wxFontWeight weight,
 143                          bool underlined,
 144                          const wxString& faceName,
 145                          wxFontEncoding encoding)
 146 {
 147     m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
 148
 149     m_faceName = faceName;
 150
 151     // we accept both wxDEFAULT and wxNORMAL here - should we?
 152     m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
 153     m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
 154
 155     // and here, do we really want to forbid creation of the font of the size
 156     // 90 (the value of wxDEFAULT)??
 157     m_pointSize = pointSize == wxDEFAULT || pointSize == -1
 158                     ? wxDEFAULT_FONT_SIZE
 159                     : pointSize;
 160
 161     m_underlined = underlined;
 162     m_encoding = encoding;
 163 }
 164
 165 void wxFontRefData::InitFromNative()
 166 {
 167     // get the font parameters from the XLFD
 168     // -------------------------------------
 169
 170     m_faceName = m_nativeFontInfo.GetXFontComponent(wxXLFD_FAMILY);
 171
 172     m_weight = wxFONTWEIGHT_NORMAL;
 173
 174     wxString w = m_nativeFontInfo.GetXFontComponent(wxXLFD_WEIGHT).Upper();
 175     if ( !w.empty() && w != wxT('*') )
 176     {
 177         // the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
 178         // and BLACK
 179         if ( ((w[0u] == wxT('B') && (!wxStrcmp(w.c_str() + 1, wxT("OLD")) ||
 180                                    !wxStrcmp(w.c_str() + 1, wxT("LACK"))))) ||
 181              wxStrstr(w.c_str() + 1, wxT("BOLD")) )
 182         {
 183             m_weight = wxFONTWEIGHT_BOLD;
 184         }
 185         else if ( w == wxT("LIGHT") || w == wxT("THIN") )
 186         {
 187             m_weight = wxFONTWEIGHT_LIGHT;
 188         }
 189     }
 190
 191     switch ( wxToupper(m_nativeFontInfo.
 192                            GetXFontComponent(wxXLFD_SLANT)[0u]).GetValue() )
 193     {
 194         case wxT('I'):   // italique
 195             m_style = wxFONTSTYLE_ITALIC;
 196             break;
 197
 198         case wxT('O'):   // oblique
 199             m_style = wxFONTSTYLE_SLANT;
 200             break;
 201
 202         default:
 203             m_style = wxFONTSTYLE_NORMAL;
 204     }
 205
 206     long ptSize;
 207     if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_POINTSIZE).ToLong(&ptSize) )
 208     {
 209         // size in XLFD is in 10 point units
 210         m_pointSize = (int)(ptSize / 10);
 211     }
 212     else
 213     {
 214         m_pointSize = wxDEFAULT_FONT_SIZE;
 215     }
 216
 217     // examine the spacing: if the font is monospaced, assume wxTELETYPE
 218     // family for compatibility with the old code which used it instead of
 219     // IsFixedWidth()
 220     if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING).Upper() == wxT('M') )
 221     {
 222         m_family = wxFONTFAMILY_TELETYPE;
 223     }
 224     else // not monospaceed
 225     {
 226         // don't even try guessing it, it doesn't work for too many fonts
 227         // anyhow
 228         m_family = wxFONTFAMILY_UNKNOWN;
 229     }
 230
 231     // X fonts are never underlined...
 232     m_underlined = false;
 233
 234     // deal with font encoding
 235     wxString
 236         registry = m_nativeFontInfo.GetXFontComponent(wxXLFD_REGISTRY).Upper(),
 237         encoding = m_nativeFontInfo.GetXFontComponent(wxXLFD_ENCODING).Upper();
 238
 239     if ( registry == wxT("ISO8859") )
 240     {
 241         int cp;
 242         if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
 243         {
 244             m_encoding = (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
 245         }
 246     }
 247     else if ( registry == wxT("MICROSOFT") )
 248     {
 249         int cp;
 250         if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
 251         {
 252             m_encoding = (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
 253         }
 254     }
 255     else if ( registry == wxT("KOI8") )
 256     {
 257         m_encoding = wxFONTENCODING_KOI8;
 258     }
 259     else // unknown encoding
 260     {
 261         // may be give a warning here? or use wxFontMapper?
 262         m_encoding = wxFONTENCODING_SYSTEM;
 263     }
 264 }
 265
 266 wxFontRefData::wxFontRefData( const wxFontRefData& data )
 267              : wxGDIRefData()
 268 {
 269     m_pointSize = data.m_pointSize;
 270     m_family = data.m_family;
 271     m_style = data.m_style;
 272     m_weight = data.m_weight;
 273
 274     m_underlined = data.m_underlined;
 275
 276     m_faceName = data.m_faceName;
 277     m_encoding = data.m_encoding;
 278
 279     // Forces a copy of the internal data.  wxNativeFontInfo should probably
 280     // have a copy ctor and assignment operator to fix this properly but that
 281     // would break binary compatibility...
 282     m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
 283 }
 284
 285 wxFontRefData::wxFontRefData(int size, wxFontFamily family, wxFontStyle style,
 286                              wxFontWeight weight, bool underlined,
 287                              const wxString& faceName,
 288                              wxFontEncoding encoding)
 289 {
 290     Init(size, family, style, weight, underlined, faceName, encoding);
 291 }
 292
 293 wxFontRefData::wxFontRefData(const wxString& fontname)
 294 {
 295     // FromString() should really work in GTK1 too, doesn't it?
 296     m_nativeFontInfo.SetXFontName(fontname);
 297
 298     InitFromNative();
 299 }
 300
 301 void wxFontRefData::ClearGdkFonts()
 302 {
 303     for ( wxScaledFontList::iterator i = m_scaled_xfonts.begin();
 304           i != m_scaled_xfonts.end();
 305           ++i )
 306     {
 307         GdkFont *font = i->second;
 308         gdk_font_unref( font );
 309     }
 310
 311     m_scaled_xfonts.clear();
 312 }
 313
 314 wxFontRefData::~wxFontRefData()
 315 {
 316     ClearGdkFonts();
 317 }
 318
 319 // ----------------------------------------------------------------------------
 320 // wxFontRefData SetXXX()
 321 // ----------------------------------------------------------------------------
 322
 323 void wxFontRefData::SetPointSize(int pointSize)
 324 {
 325     m_pointSize = pointSize;
 326
 327     if ( HasNativeFont() )
 328     {
 329         wxString size;
 330         if ( pointSize == -1 )
 331             size = wxT('*');
 332         else
 333             size.Printf(wxT("%d"), 10*pointSize);
 334
 335         m_nativeFontInfo.SetXFontComponent(wxXLFD_POINTSIZE, size);
 336     }
 337 }
 338
 339 void wxFontRefData::SetFamily(wxFontFamily family)
 340 {
 341     m_family = family;
 342
 343     // TODO: what are we supposed to do with m_nativeFontInfo here?
 344 }
 345
 346 void wxFontRefData::SetStyle(wxFontStyle style)
 347 {
 348     m_style = style;
 349
 350     if ( HasNativeFont() )
 351     {
 352         wxString slant;
 353         switch ( style )
 354         {
 355             case wxFONTSTYLE_ITALIC:
 356                 slant = wxT('i');
 357                 break;
 358
 359             case wxFONTSTYLE_SLANT:
 360                 slant = wxT('o');
 361                 break;
 362
 363             default:
 364                 wxFAIL_MSG( wxT("unknown font style") );
 365                 // fall through
 366
 367             case wxFONTSTYLE_NORMAL:
 368                 slant = wxT('r');
 369         }
 370
 371         m_nativeFontInfo.SetXFontComponent(wxXLFD_SLANT, slant);
 372     }
 373 }
 374
 375 void wxFontRefData::SetWeight(wxFontWeight weight)
 376 {
 377     m_weight = weight;
 378
 379     if ( HasNativeFont() )
 380     {
 381         wxString boldness;
 382         switch ( weight )
 383         {
 384             case wxFONTWEIGHT_BOLD:
 385                 boldness = wxT("bold");
 386                 break;
 387
 388             case wxFONTWEIGHT_LIGHT:
 389                 boldness = wxT("light");
 390                 break;
 391
 392             default:
 393                 wxFAIL_MSG( wxT("unknown font weight") );
 394                 // fall through
 395
 396             case wxFONTWEIGHT_NORMAL:
 397                 // unspecified
 398                 boldness = wxT("medium");
 399         }
 400
 401         m_nativeFontInfo.SetXFontComponent(wxXLFD_WEIGHT, boldness);
 402     }
 403 }
 404
 405 void wxFontRefData::SetUnderlined(bool underlined)
 406 {
 407     m_underlined = underlined;
 408
 409     // the XLFD doesn't have "underlined" field anyhow
 410 }
 411
 412 bool wxFontRefData::SetFaceName(const wxString& facename)
 413 {
 414     m_faceName = facename;
 415
 416     if ( HasNativeFont() )
 417     {
 418         m_nativeFontInfo.SetXFontComponent(wxXLFD_FAMILY, facename);
 419     }
 420
 421     return true;
 422 }
 423
 424 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
 425 {
 426     m_encoding = encoding;
 427
 428     if ( HasNativeFont() )
 429     {
 430         wxNativeEncodingInfo info;
 431         if ( wxGetNativeFontEncoding(encoding, &info) )
 432         {
 433             m_nativeFontInfo.SetXFontComponent(wxXLFD_REGISTRY, info.xregistry);
 434             m_nativeFontInfo.SetXFontComponent(wxXLFD_ENCODING, info.xencoding);
 435         }
 436     }
 437 }
 438
 439 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
 440 {
 441     // previously cached fonts shouldn't be used
 442     ClearGdkFonts();
 443
 444     m_nativeFontInfo = info;
 445
 446     // set all the other font parameters from the native font info
 447     InitFromNative();
 448 }
 449
 450 // ----------------------------------------------------------------------------
 451 // wxFont creation
 452 // ----------------------------------------------------------------------------
 453
 454 wxFont::wxFont(const wxNativeFontInfo& info)
 455 {
 456     (void) Create(info.GetXFontName());
 457 }
 458
 459 bool wxFont::Create( int pointSize,
 460                     wxFontFamily family,
 461                     wxFontStyle style,
 462                     wxFontWeight weight,
 463                      bool underlined,
 464                      const wxString& face,
 465                      wxFontEncoding encoding)
 466 {
 467     UnRef();
 468
 469     m_refData = new wxFontRefData(pointSize, family, style, weight,
 470                                   underlined, face, encoding);
 471
 472     return true;
 473 }
 474
 475 bool wxFont::Create(const wxString& fontname)
 476 {
 477     // VZ: does this really happen?
 478     if ( fontname.empty() )
 479     {
 480         *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 481
 482         return true;
 483     }
 484
 485     m_refData = new wxFontRefData(fontname);
 486
 487     return true;
 488 }
 489
 490 void wxFont::Unshare()
 491 {
 492     if (!m_refData)
 493     {
 494         m_refData = new wxFontRefData();
 495     }
 496     else
 497     {
 498         wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
 499         UnRef();
 500         m_refData = ref;
 501     }
 502 }
 503
 504 wxFont::~wxFont()
 505 {
 506 }
 507
 508 wxGDIRefData *wxFont::CreateGDIRefData() const
 509 {
 510     return new wxFontRefData;
 511 }
 512
 513 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 514 {
 515     return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
 516 }
 517
 518 // ----------------------------------------------------------------------------
 519 // accessors
 520 // ----------------------------------------------------------------------------
 521
 522 int wxFont::GetPointSize() const
 523 {
 524     wxCHECK_MSG( IsOk(), 0, wxT("invalid font") );
 525
 526     return M_FONTDATA->m_pointSize;
 527 }
 528
 529 wxString wxFont::GetFaceName() const
 530 {
 531     wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") );
 532
 533     return M_FONTDATA->m_faceName;
 534 }
 535
 536 wxFontFamily wxFont::DoGetFamily() const
 537 {
 538     return M_FONTDATA->m_family;
 539 }
 540
 541 wxFontStyle wxFont::GetStyle() const
 542 {
 543     wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") );
 544
 545     return M_FONTDATA->m_style;
 546 }
 547
 548 wxFontWeight wxFont::GetWeight() const
 549 {
 550     wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") );
 551
 552     return M_FONTDATA->m_weight;
 553 }
 554
 555 bool wxFont::GetUnderlined() const
 556 {
 557     wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
 558
 559     return M_FONTDATA->m_underlined;
 560 }
 561
 562 wxFontEncoding wxFont::GetEncoding() const
 563 {
 564     wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
 565
 566     // m_encoding is unused in wxGTK2, return encoding that the user set.
 567     return M_FONTDATA->m_encoding;
 568 }
 569
 570 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 571 {
 572     wxCHECK_MSG( IsOk(), NULL, wxT("invalid font") );
 573
 574     if ( !M_FONTDATA->HasNativeFont() )
 575     {
 576         // NB: this call has important side-effect: it not only finds
 577         //     GdkFont representation, it also initializes m_nativeFontInfo
 578         //     by calling its SetXFontName method
 579         GetInternalFont();
 580     }
 581
 582     return &(M_FONTDATA->m_nativeFontInfo);
 583 }
 584
 585 bool wxFont::IsFixedWidth() const
 586 {
 587     wxCHECK_MSG( IsOk(), false, wxT("invalid font") );
 588
 589     if ( M_FONTDATA->HasNativeFont() )
 590     {
 591         // the monospace fonts are supposed to have "M" in the spacing field
 592         wxString spacing = M_FONTDATA->
 593                             m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING);
 594
 595         return spacing.Upper() == wxT('M');
 596     }
 597
 598     return wxFontBase::IsFixedWidth();
 599 }
 600
 601 // ----------------------------------------------------------------------------
 602 // change font attributes
 603 // ----------------------------------------------------------------------------
 604
 605 void wxFont::SetPointSize(int pointSize)
 606 {
 607     Unshare();
 608
 609     M_FONTDATA->SetPointSize(pointSize);
 610 }
 611
 612 void wxFont::SetFamily(wxFontFamily family)
 613 {
 614     Unshare();
 615
 616     M_FONTDATA->SetFamily(family);
 617 }
 618
 619 void wxFont::SetStyle(wxFontStyle style)
 620 {
 621     Unshare();
 622
 623     M_FONTDATA->SetStyle(style);
 624 }
 625
 626 void wxFont::SetWeight(wxFontWeight weight)
 627 {
 628     Unshare();
 629
 630     M_FONTDATA->SetWeight(weight);
 631 }
 632
 633 bool wxFont::SetFaceName(const wxString& faceName)
 634 {
 635     Unshare();
 636
 637     return M_FONTDATA->SetFaceName(faceName) &&
 638            wxFontBase::SetFaceName(faceName);
 639 }
 640
 641 void wxFont::SetUnderlined(bool underlined)
 642 {
 643     Unshare();
 644
 645     M_FONTDATA->SetUnderlined(underlined);
 646 }
 647
 648 void wxFont::SetEncoding(wxFontEncoding encoding)
 649 {
 650     Unshare();
 651
 652     M_FONTDATA->SetEncoding(encoding);
 653 }
 654
 655 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
 656 {
 657     Unshare();
 658
 659     M_FONTDATA->SetNativeFontInfo( info );
 660 }
 661
 662 // ----------------------------------------------------------------------------
 663 // get internal representation of font
 664 // ----------------------------------------------------------------------------
 665
 666 static GdkFont *g_systemDefaultGuiFont = NULL;
 667
 668 // this is also used from toolbar.cpp and tooltip.cpp, hence extern
 669 extern GdkFont *GtkGetDefaultGuiFont()
 670 {
 671     if (!g_systemDefaultGuiFont)
 672     {
 673         GtkWidget *widget = gtk_button_new();
 674         GtkStyle *def = gtk_rc_get_style( widget );
 675         if (def)
 676         {
 677             g_systemDefaultGuiFont = gdk_font_ref( def->font );
 678         }
 679         else
 680         {
 681             def = gtk_widget_get_default_style();
 682             if (def)
 683                 g_systemDefaultGuiFont = gdk_font_ref( def->font );
 684         }
 685         gtk_widget_destroy( widget );
 686     }
 687     else
 688     {
 689         // already have it, but ref it once more before returning
 690         gdk_font_ref(g_systemDefaultGuiFont);
 691     }
 692
 693     return g_systemDefaultGuiFont;
 694 }
 695
 696 GdkFont *wxFont::GetInternalFont( float scale ) const
 697 {
 698     GdkFont *font = NULL;
 699
 700     wxCHECK_MSG( IsOk(), font, wxT("invalid font") );
 701
 702     long int_scale = long(scale * 100.0 + 0.5); // key for fontlist
 703     int point_scale = (int)((M_FONTDATA->m_pointSize * 10 * int_scale) / 100);
 704
 705     wxScaledFontList& list = M_FONTDATA->m_scaled_xfonts;
 706     wxScaledFontList::iterator i = list.find(int_scale);
 707     if ( i != list.end() )
 708     {
 709         font = i->second;
 710     }
 711     else // we don't have this font in this size yet
 712     {
 713         if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT))
 714         {
 715             font = GtkGetDefaultGuiFont();
 716         }
 717
 718         if ( !font )
 719         {
 720             // do we have the XLFD?
 721             if ( int_scale == 100 && M_FONTDATA->HasNativeFont() )
 722             {
 723                 font = wxLoadFont(M_FONTDATA->m_nativeFontInfo.GetXFontName());
 724             }
 725
 726             // no XLFD of no exact match - try the approximate one now
 727             if ( !font )
 728             {
 729                 wxString xfontname;
 730                 font = wxLoadQueryNearestFont( point_scale,
 731                                                M_FONTDATA->m_family,
 732                                                M_FONTDATA->m_style,
 733                                                M_FONTDATA->m_weight,
 734                                                M_FONTDATA->m_underlined,
 735                                                M_FONTDATA->m_faceName,
 736                                                M_FONTDATA->m_encoding,
 737                                                &xfontname);
 738                 // NB: wxFont::GetNativeFontInfo relies on this
 739                 //     side-effect of GetInternalFont
 740                 if ( int_scale == 100 )
 741                     M_FONTDATA->m_nativeFontInfo.SetXFontName(xfontname);
 742             }
 743         }
 744
 745         if ( font )
 746         {
 747             list[int_scale] = font;
 748         }
 749     }
 750
 751     // it's quite useless to make it a wxCHECK because we're going to crash
 752     // anyhow...
 753     wxASSERT_MSG( font, wxT("could not load any font?") );
 754
 755     return font;
 756 }