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