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