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