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