src/gtk1/font.cpp

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