src/gtk/font.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 // wxFontRefData
  39 // ----------------------------------------------------------------------------
  40
  41 class wxFontRefData : public wxObjectRefData
  42 {
  43 public:
  44     wxFontRefData(int size = wxDEFAULT,
  45                   int family = wxDEFAULT,
  46                   int style = wxDEFAULT,
  47                   int weight = wxDEFAULT,
  48                   bool underlined = FALSE,
  49                   const wxString& faceName = wxEmptyString,
  50                   wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
  51     wxFontRefData( const wxFontRefData& data );
  52     virtual ~wxFontRefData();
  53
  54 protected:
  55     // common part of all ctors
  56     void Init(int pointSize,
  57               int family,
  58               int style,
  59               int weight,
  60               bool underlined,
  61               const wxString& faceName,
  62               wxFontEncoding encoding);
  63
  64 private:
  65     wxList          m_scaled_xfonts;
  66     int             m_pointSize;
  67     int             m_family,
  68                     m_style,
  69                     m_weight;
  70     bool            m_underlined;
  71     wxString        m_faceName;
  72     wxFontEncoding  m_encoding;
  73
  74     wxNativeFontInfo m_nativeFontInfo;
  75
  76     friend class wxFont;
  77 };
  78
  79 // ============================================================================
  80 // implementation
  81 // ============================================================================
  82
  83 // ----------------------------------------------------------------------------
  84 // wxFontRefData
  85 // ----------------------------------------------------------------------------
  86
  87 void wxFontRefData::Init(int pointSize,
  88                          int family,
  89                          int style,
  90                          int weight,
  91                          bool underlined,
  92                          const wxString& faceName,
  93                          wxFontEncoding encoding)
  94 {
  95     if (family == wxDEFAULT)
  96         m_family = wxSWISS;
  97     else
  98         m_family = family;
  99
 100     m_faceName = faceName;
 101
 102     if (style == wxDEFAULT)
 103         m_style = wxNORMAL;
 104     else
 105         m_style = style;
 106
 107     if (weight == wxDEFAULT)
 108         m_weight = wxNORMAL;
 109     else
 110         m_weight = weight;
 111
 112     if (pointSize == wxDEFAULT)
 113         m_pointSize = 12;
 114     else
 115         m_pointSize = pointSize;
 116
 117     m_underlined = underlined;
 118     m_encoding = encoding;
 119 }
 120
 121 wxFontRefData::wxFontRefData( const wxFontRefData& data )
 122     : m_scaled_xfonts(wxKEY_INTEGER)
 123 {
 124     Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight,
 125          data.m_underlined, data.m_faceName, data.m_encoding);
 126 }
 127
 128 wxFontRefData::wxFontRefData(int size, int family, int style,
 129                              int weight, bool underlined,
 130                              const wxString& faceName,
 131                              wxFontEncoding encoding)
 132     : m_scaled_xfonts(wxKEY_INTEGER)
 133 {
 134     Init(size, family, style, weight, underlined, faceName, encoding);
 135 }
 136
 137 wxFontRefData::~wxFontRefData()
 138 {
 139     wxNode *node = m_scaled_xfonts.First();
 140     while (node)
 141     {
 142         GdkFont *font = (GdkFont*)node->Data();
 143         wxNode *next = node->Next();
 144         gdk_font_unref( font );
 145         node = next;
 146     }
 147 }
 148
 149 // ----------------------------------------------------------------------------
 150 // wxFont
 151 // ----------------------------------------------------------------------------
 152
 153 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
 154
 155 void wxFont::Init()
 156 {
 157 }
 158
 159 wxFont::wxFont(const wxNativeFontInfo& info)
 160 {
 161     Init();
 162
 163     Create(info.xFontName);
 164 }
 165
 166 bool wxFont::Create(const wxNativeFontInfo& info)
 167 {
 168     return Create(info.xFontName);
 169 }
 170
 171 bool wxFont::Create( int pointSize,
 172                      int family,
 173                      int style,
 174                      int weight,
 175                      bool underlined,
 176                      const wxString& face,
 177                      wxFontEncoding encoding)
 178 {
 179     m_refData = new wxFontRefData(pointSize, family, style, weight,
 180                                   underlined, face, encoding);
 181
 182     return TRUE;
 183 }
 184
 185 bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
 186 {
 187     if( !fontname )
 188     {
 189          *this = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT);
 190          return TRUE;
 191     }
 192
 193     m_refData = new wxFontRefData();
 194
 195     M_FONTDATA->m_nativeFontInfo.xFontName = fontname;  // X font name
 196
 197     wxString tmp;
 198
 199     wxStringTokenizer tn( fontname, wxT("-") );
 200
 201     tn.GetNextToken();                           // skip initial empty token
 202     tn.GetNextToken();                           // foundry
 203
 204
 205     M_FONTDATA->m_faceName = tn.GetNextToken();  // family
 206
 207     tmp = tn.GetNextToken().MakeUpper();         // weight
 208     if (tmp == wxT("BOLD")) M_FONTDATA->m_weight = wxBOLD;
 209     if (tmp == wxT("BLACK")) M_FONTDATA->m_weight = wxBOLD;
 210     if (tmp == wxT("EXTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
 211     if (tmp == wxT("DEMIBOLD")) M_FONTDATA->m_weight = wxBOLD;
 212     if (tmp == wxT("ULTRABOLD")) M_FONTDATA->m_weight = wxBOLD;
 213
 214     if (tmp == wxT("LIGHT")) M_FONTDATA->m_weight = wxLIGHT;
 215     if (tmp == wxT("THIN")) M_FONTDATA->m_weight = wxLIGHT;
 216
 217     tmp = tn.GetNextToken().MakeUpper();        // slant
 218     if (tmp == wxT("I")) M_FONTDATA->m_style = wxITALIC;
 219     if (tmp == wxT("O")) M_FONTDATA->m_style = wxITALIC;
 220
 221     tn.GetNextToken();                           // set width
 222     tn.GetNextToken();                           // add. style
 223     tn.GetNextToken();                           // pixel size
 224
 225     tmp = tn.GetNextToken();                     // pointsize
 226     if (tmp != wxT("*"))
 227     {
 228         long num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
 229         M_FONTDATA->m_pointSize = (int)(num / 10);
 230     }
 231
 232     tn.GetNextToken();                           // x-res
 233     tn.GetNextToken();                           // y-res
 234
 235     tmp = tn.GetNextToken().MakeUpper();         // spacing
 236
 237     if (tmp == wxT("M"))
 238         M_FONTDATA->m_family = wxMODERN;
 239     else if (M_FONTDATA->m_faceName == wxT("TIMES"))
 240         M_FONTDATA->m_family = wxROMAN;
 241     else if (M_FONTDATA->m_faceName == wxT("HELVETICA"))
 242         M_FONTDATA->m_family = wxSWISS;
 243     else if (M_FONTDATA->m_faceName == wxT("LUCIDATYPEWRITER"))
 244         M_FONTDATA->m_family = wxTELETYPE;
 245     else if (M_FONTDATA->m_faceName == wxT("LUCIDA"))
 246         M_FONTDATA->m_family = wxDECORATIVE;
 247     else if (M_FONTDATA->m_faceName == wxT("UTOPIA"))
 248         M_FONTDATA->m_family = wxSCRIPT;
 249
 250     tn.GetNextToken();                           // avg width
 251
 252     // deal with font encoding
 253     M_FONTDATA->m_encoding = enc;
 254     if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
 255     {
 256         wxString registry = tn.GetNextToken().MakeUpper(),
 257                  encoding = tn.GetNextToken().MakeUpper();
 258
 259         if ( registry == _T("ISO8859") )
 260         {
 261             int cp;
 262             if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
 263             {
 264                 M_FONTDATA->m_encoding =
 265                     (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_FONTDATA->m_encoding =
 274                     (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
 275             }
 276         }
 277         else if ( registry == _T("KOI8") )
 278         {
 279             M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
 280         }
 281         //else: unknown encoding - may be give a warning here?
 282         else
 283             return FALSE;
 284     }
 285     return TRUE;
 286 }
 287
 288 void wxFont::Unshare()
 289 {
 290     if (!m_refData)
 291     {
 292         m_refData = new wxFontRefData();
 293     }
 294     else
 295     {
 296         wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
 297         UnRef();
 298         m_refData = ref;
 299     }
 300 }
 301
 302 wxFont::~wxFont()
 303 {
 304 }
 305
 306 // ----------------------------------------------------------------------------
 307 // accessors
 308 // ----------------------------------------------------------------------------
 309
 310 bool wxFont::HasNativeFont() const
 311 {
 312     return !M_FONTDATA->m_nativeFontInfo.xFontName.empty();
 313 }
 314
 315 int wxFont::GetPointSize() const
 316 {
 317     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 318
 319     return M_FONTDATA->m_pointSize;
 320 }
 321
 322 wxString wxFont::GetFaceName() const
 323 {
 324     wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
 325
 326     return M_FONTDATA->m_faceName;
 327 }
 328
 329 int wxFont::GetFamily() const
 330 {
 331     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 332
 333     return M_FONTDATA->m_family;
 334 }
 335
 336 int wxFont::GetStyle() const
 337 {
 338     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 339
 340     return M_FONTDATA->m_style;
 341 }
 342
 343 int wxFont::GetWeight() const
 344 {
 345     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 346
 347     return M_FONTDATA->m_weight;
 348 }
 349
 350 bool wxFont::GetUnderlined() const
 351 {
 352     wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
 353
 354     return M_FONTDATA->m_underlined;
 355 }
 356
 357
 358 wxFontEncoding wxFont::GetEncoding() const
 359 {
 360     wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
 361
 362     return M_FONTDATA->m_encoding;
 363 }
 364
 365 wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 366 {
 367     wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
 368
 369     if(M_FONTDATA->m_nativeFontInfo.xFontName.IsEmpty())
 370         GetInternalFont();
 371
 372     return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
 373 }
 374
 375 bool wxFont::IsFixedWidth() const
 376 {
 377     wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
 378
 379     if ( HasNativeFont() )
 380     {
 381         // the monospace fonts are supposed to have "M" in the spacing field
 382         wxString spacing = M_FONTDATA->
 383                             m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING);
 384
 385         return spacing.Upper() == _T('M');
 386     }
 387
 388     return wxFontBase::IsFixedWidth();
 389 }
 390
 391 // ----------------------------------------------------------------------------
 392 // change font attributes
 393 // ----------------------------------------------------------------------------
 394
 395 void wxFont::SetPointSize(int pointSize)
 396 {
 397     Unshare();
 398
 399     M_FONTDATA->m_pointSize = pointSize;
 400     M_FONTDATA->m_nativeFontInfo.xFontName.Clear();            // invalid now
 401 }
 402
 403 void wxFont::SetFamily(int family)
 404 {
 405     Unshare();
 406
 407     M_FONTDATA->m_family = family;
 408     M_FONTDATA->m_nativeFontInfo.xFontName.Clear();            // invalid now
 409 }
 410
 411 void wxFont::SetStyle(int style)
 412 {
 413     Unshare();
 414
 415     M_FONTDATA->m_style = style;
 416     M_FONTDATA->m_nativeFontInfo.xFontName.Clear();            // invalid now
 417 }
 418
 419 void wxFont::SetWeight(int weight)
 420 {
 421     Unshare();
 422
 423     M_FONTDATA->m_weight = weight;
 424     M_FONTDATA->m_nativeFontInfo.xFontName.Clear();            // invalid now
 425 }
 426
 427 void wxFont::SetFaceName(const wxString& faceName)
 428 {
 429     Unshare();
 430
 431     M_FONTDATA->m_faceName = faceName;
 432     M_FONTDATA->m_nativeFontInfo.xFontName.Clear();            // invalid now
 433 }
 434
 435 void wxFont::SetUnderlined(bool underlined)
 436 {
 437     Unshare();
 438
 439     M_FONTDATA->m_underlined = underlined;
 440 }
 441
 442 void wxFont::SetEncoding(wxFontEncoding encoding)
 443 {
 444     Unshare();
 445
 446     M_FONTDATA->m_encoding = encoding;
 447     M_FONTDATA->m_nativeFontInfo.xFontName.Clear();            // invalid now
 448 }
 449
 450 void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
 451 {
 452     Unshare();
 453
 454     M_FONTDATA->m_nativeFontInfo = info;
 455 }
 456
 457 // ----------------------------------------------------------------------------
 458 // get internal representation of font
 459 // ----------------------------------------------------------------------------
 460
 461 static GdkFont *g_systemDefaultGuiFont = (GdkFont*) NULL;
 462
 463 GdkFont *GtkGetDefaultGuiFont()
 464 {
 465     if (!g_systemDefaultGuiFont)
 466     {
 467         GtkWidget *widget = gtk_button_new();
 468         GtkStyle *def = gtk_rc_get_style( widget );
 469         if (def)
 470         {
 471             g_systemDefaultGuiFont = gdk_font_ref( def->font );
 472         }
 473         else
 474         {
 475             def = gtk_widget_get_default_style();
 476             if (def)
 477                 g_systemDefaultGuiFont = gdk_font_ref( def->font );
 478         }
 479         gtk_widget_destroy( widget );
 480     }
 481     else
 482     {
 483         // already have it, but ref it once more before returning
 484         gdk_font_ref(g_systemDefaultGuiFont);
 485     }
 486
 487     return g_systemDefaultGuiFont;
 488 }
 489
 490 GdkFont *wxFont::GetInternalFont( float scale ) const
 491 {
 492     if (!Ok())
 493     {
 494         wxFAIL_MSG( wxT("invalid font") );
 495
 496         return (GdkFont*) NULL;
 497     }
 498
 499     long int_scale = long(scale * 100.0 + 0.5); /* key for fontlist */
 500     int point_scale = (int)((M_FONTDATA->m_pointSize * 10 * int_scale) / 100);
 501     GdkFont *font = (GdkFont *) NULL;
 502
 503     wxNode *node = M_FONTDATA->m_scaled_xfonts.Find(int_scale);
 504     if (node)
 505     {
 506         font = (GdkFont*)node->Data();
 507     }
 508     else
 509     {
 510         if (*this == wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT))
 511         {
 512             font = GtkGetDefaultGuiFont();
 513         }
 514         if (!font)
 515         {
 516             font = wxLoadQueryNearestFont( point_scale,
 517                                            M_FONTDATA->m_family,
 518                                            M_FONTDATA->m_style,
 519                                            M_FONTDATA->m_weight,
 520                                            M_FONTDATA->m_underlined,
 521                                            M_FONTDATA->m_faceName,
 522                                            M_FONTDATA->m_encoding,
 523                                            &M_FONTDATA->m_nativeFontInfo.xFontName );
 524         }
 525
 526         M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
 527     }
 528
 529     // it's quite useless to make it a wxCHECK because we're going to crash
 530     // anyhow...
 531     wxASSERT_MSG( font, wxT("could not load any font?") );
 532
 533     return font;
 534 }
 535