src/gtk/font.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/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
  23 #ifndef WX_PRECOMP
  24     #include "wx/log.h"
  25     #include "wx/utils.h"
  26     #include "wx/settings.h"
  27     #include "wx/cmndata.h"
  28     #include "wx/gdicmn.h"
  29 #endif
  30
  31 #include "wx/fontutil.h"
  32 #include "wx/tokenzr.h"
  33
  34 #include "wx/gtk/private.h"
  35
  36 // ----------------------------------------------------------------------------
  37 // constants
  38 // ----------------------------------------------------------------------------
  39
  40 // the default size (in points) for the fonts
  41 static const int wxDEFAULT_FONT_SIZE = 12;
  42
  43 // ----------------------------------------------------------------------------
  44 // wxScaledFontList: maps the font sizes to the GDK fonts for the given font
  45 // ----------------------------------------------------------------------------
  46
  47 WX_DECLARE_HASH_MAP(int, GdkFont *, wxIntegerHash, wxIntegerEqual,
  48                     wxScaledFontList);
  49
  50 // ----------------------------------------------------------------------------
  51 // wxFontRefData
  52 // ----------------------------------------------------------------------------
  53
  54 class wxFontRefData : public wxObjectRefData
  55 {
  56 public:
  57     // from broken down font parameters, also default ctor
  58     wxFontRefData(int size = -1,
  59                   int family = wxFONTFAMILY_DEFAULT,
  60                   int style = wxFONTSTYLE_NORMAL,
  61                   int weight = wxFONTWEIGHT_NORMAL,
  62                   bool underlined = false,
  63                   const wxString& faceName = wxEmptyString,
  64                   wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
  65
  66     // from XFLD
  67     wxFontRefData(const wxString& fontname);
  68
  69     // copy ctor
  70     wxFontRefData( const wxFontRefData& data );
  71
  72     virtual ~wxFontRefData();
  73
  74     // do we have the native font info?
  75     bool HasNativeFont() const
  76     {
  77         // we always have a Pango font description
  78         return true;
  79     }
  80
  81     // setters: all of them also take care to modify m_nativeFontInfo if we
  82     // have it so as to not lose the information not carried by our fields
  83     void SetPointSize(int pointSize);
  84     void SetFamily(int family);
  85     void SetStyle(int style);
  86     void SetWeight(int weight);
  87     void SetUnderlined(bool underlined);
  88     bool SetFaceName(const wxString& facename);
  89     void SetEncoding(wxFontEncoding encoding);
  90
  91     void SetNoAntiAliasing( bool no = true ) { m_noAA = no; }
  92     bool GetNoAntiAliasing() const { return m_noAA; }
  93
  94     // and this one also modifies all the other font data fields
  95     void SetNativeFontInfo(const wxNativeFontInfo& info);
  96
  97 protected:
  98     // common part of all ctors
  99     void Init(int pointSize,
 100               int family,
 101               int style,
 102               int weight,
 103               bool underlined,
 104               const wxString& faceName,
 105               wxFontEncoding encoding);
 106
 107     // set all fields from (already initialized and valid) m_nativeFontInfo
 108     void InitFromNative();
 109
 110 private:
 111     // clear m_scaled_xfonts if any
 112     void ClearGdkFonts();
 113
 114     int             m_pointSize;
 115     int             m_family,
 116                     m_style,
 117                     m_weight;
 118     bool            m_underlined;
 119     wxString        m_faceName;
 120     wxFontEncoding  m_encoding;
 121     bool            m_noAA;      // No anti-aliasing
 122
 123     // The native font info, basicly an XFLD under GTK 1.2 and
 124     // the pango font description under GTK 2.0.
 125     wxNativeFontInfo m_nativeFontInfo;
 126
 127     friend class wxFont;
 128 };
 129
 130 #define M_FONTDATA ((wxFontRefData*)m_refData)
 131
 132 // ----------------------------------------------------------------------------
 133 // wxFontRefData
 134 // ----------------------------------------------------------------------------
 135
 136 void wxFontRefData::Init(int pointSize,
 137                          int family,
 138                          int style,
 139                          int weight,
 140                          bool underlined,
 141                          const wxString& faceName,
 142                          wxFontEncoding encoding)
 143 {
 144     m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
 145
 146     m_faceName = faceName;
 147
 148     // we accept both wxDEFAULT and wxNORMAL here - should we?
 149     m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
 150     m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
 151
 152     // and here, do we really want to forbid creation of the font of the size
 153     // 90 (the value of wxDEFAULT)??
 154     m_pointSize = pointSize == wxDEFAULT || pointSize == -1
 155                     ? wxDEFAULT_FONT_SIZE
 156                     : pointSize;
 157
 158     m_underlined = underlined;
 159     m_encoding = encoding;
 160
 161     m_noAA = false;
 162
 163     // Create native font info
 164     m_nativeFontInfo.description = pango_font_description_new();
 165
 166     // And set its values
 167     if (!m_faceName.empty())
 168     {
 169        pango_font_description_set_family( m_nativeFontInfo.description,
 170                                           wxGTK_CONV_SYS(m_faceName) );
 171     }
 172     else
 173     {
 174         switch (m_family)
 175         {
 176             case wxFONTFAMILY_MODERN:
 177             case wxFONTFAMILY_TELETYPE:
 178                pango_font_description_set_family( m_nativeFontInfo.description, "monospace" );
 179                break;
 180             case wxFONTFAMILY_ROMAN:
 181                pango_font_description_set_family( m_nativeFontInfo.description, "serif" );
 182                break;
 183             case wxFONTFAMILY_SWISS:
 184                // SWISS = sans serif
 185             default:
 186                pango_font_description_set_family( m_nativeFontInfo.description, "sans" );
 187                break;
 188         }
 189     }
 190
 191     SetStyle( m_style );
 192     SetPointSize( m_pointSize );
 193     SetWeight( m_weight );
 194 }
 195
 196 void wxFontRefData::InitFromNative()
 197 {
 198     m_noAA = false;
 199
 200     // Get native info
 201     PangoFontDescription *desc = m_nativeFontInfo.description;
 202
 203     // init fields
 204     m_faceName = wxGTK_CONV_BACK_SYS(pango_font_description_get_family(desc));
 205
 206     // Pango sometimes needs to have a size
 207     int pango_size = pango_font_description_get_size( desc );
 208     if (pango_size == 0)
 209         m_nativeFontInfo.SetPointSize(12);
 210
 211     m_pointSize = m_nativeFontInfo.GetPointSize();
 212     m_style = m_nativeFontInfo.GetStyle();
 213     m_weight = m_nativeFontInfo.GetWeight();
 214
 215     if (m_faceName == wxT("monospace"))
 216     {
 217         m_family = wxFONTFAMILY_TELETYPE;
 218     }
 219     else if (m_faceName == wxT("sans"))
 220     {
 221         m_family = wxFONTFAMILY_SWISS;
 222     }
 223     else if (m_faceName == wxT("serif"))
 224     {
 225         m_family = wxFONTFAMILY_ROMAN;
 226     }
 227     else
 228     {
 229         m_family = wxFONTFAMILY_UNKNOWN;
 230     }
 231
 232     // Pango description are never underlined (?)
 233     m_underlined = false;
 234
 235     // always with GTK+ 2
 236     m_encoding = wxFONTENCODING_UTF8;
 237 }
 238
 239 wxFontRefData::wxFontRefData( const wxFontRefData& data )
 240              : wxObjectRefData()
 241 {
 242     m_pointSize = data.m_pointSize;
 243     m_family = data.m_family;
 244     m_style = data.m_style;
 245     m_weight = data.m_weight;
 246
 247     m_underlined = data.m_underlined;
 248
 249     m_faceName = data.m_faceName;
 250     m_encoding = data.m_encoding;
 251
 252     m_noAA = data.m_noAA;
 253
 254     // Forces a copy of the internal data.  wxNativeFontInfo should probably
 255     // have a copy ctor and assignment operator to fix this properly but that
 256     // would break binary compatibility...
 257     m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
 258 }
 259
 260 wxFontRefData::wxFontRefData(int size, int family, int style,
 261                              int weight, bool underlined,
 262                              const wxString& faceName,
 263                              wxFontEncoding encoding)
 264 {
 265     Init(size, family, style, weight, underlined, faceName, encoding);
 266 }
 267
 268 wxFontRefData::wxFontRefData(const wxString& fontname)
 269 {
 270     m_nativeFontInfo.FromString( fontname );
 271
 272     InitFromNative();
 273 }
 274
 275 void wxFontRefData::ClearGdkFonts()
 276 {
 277 }
 278
 279 wxFontRefData::~wxFontRefData()
 280 {
 281     ClearGdkFonts();
 282 }
 283
 284 // ----------------------------------------------------------------------------
 285 // wxFontRefData SetXXX()
 286 // ----------------------------------------------------------------------------
 287
 288 void wxFontRefData::SetPointSize(int pointSize)
 289 {
 290     m_pointSize = pointSize;
 291
 292     m_nativeFontInfo.SetPointSize(pointSize);
 293 }
 294
 295 void wxFontRefData::SetFamily(int family)
 296 {
 297     m_family = family;
 298
 299     // TODO: what are we supposed to do with m_nativeFontInfo here?
 300 }
 301
 302 void wxFontRefData::SetStyle(int style)
 303 {
 304     m_style = style;
 305
 306     m_nativeFontInfo.SetStyle((wxFontStyle)style);
 307 }
 308
 309 void wxFontRefData::SetWeight(int weight)
 310 {
 311     m_weight = weight;
 312
 313     m_nativeFontInfo.SetWeight((wxFontWeight)weight);
 314 }
 315
 316 void wxFontRefData::SetUnderlined(bool underlined)
 317 {
 318     m_underlined = underlined;
 319
 320     // the XLFD doesn't have "underlined" field anyhow
 321 }
 322
 323 bool wxFontRefData::SetFaceName(const wxString& facename)
 324 {
 325     m_faceName = facename;
 326
 327     return m_nativeFontInfo.SetFaceName(facename);
 328 }
 329
 330 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
 331 {
 332     m_encoding = encoding;
 333 }
 334
 335 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
 336 {
 337     // previously cached fonts shouldn't be used
 338     ClearGdkFonts();
 339
 340     m_nativeFontInfo = info;
 341
 342     // set all the other font parameters from the native font info
 343     InitFromNative();
 344 }
 345
 346 // ----------------------------------------------------------------------------
 347 // wxFont creation
 348 // ----------------------------------------------------------------------------
 349
 350 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
 351
 352 wxFont::wxFont(const wxNativeFontInfo& info)
 353 {
 354     Create( info.GetPointSize(),
 355             info.GetFamily(),
 356             info.GetStyle(),
 357             info.GetWeight(),
 358             info.GetUnderlined(),
 359             info.GetFaceName(),
 360             info.GetEncoding() );
 361 }
 362
 363 bool wxFont::Create( int pointSize,
 364                      int family,
 365                      int style,
 366                      int weight,
 367                      bool underlined,
 368                      const wxString& face,
 369                      wxFontEncoding encoding)
 370 {
 371     UnRef();
 372
 373     m_refData = new wxFontRefData(pointSize, family, style, weight,
 374                                   underlined, face, encoding);
 375
 376     return true;
 377 }
 378
 379 bool wxFont::Create(const wxString& fontname)
 380 {
 381     // VZ: does this really happen?
 382     if ( fontname.empty() )
 383     {
 384         *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 385
 386         return true;
 387     }
 388
 389     m_refData = new wxFontRefData(fontname);
 390
 391     return true;
 392 }
 393
 394 wxFont::~wxFont()
 395 {
 396 }
 397
 398 // ----------------------------------------------------------------------------
 399 // accessors
 400 // ----------------------------------------------------------------------------
 401
 402 int wxFont::GetPointSize() const
 403 {
 404     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 405
 406     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetPointSize()
 407                                        : M_FONTDATA->m_pointSize;
 408 }
 409
 410 wxString wxFont::GetFaceName() const
 411 {
 412     wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
 413
 414     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetFaceName()
 415                                        : M_FONTDATA->m_faceName;
 416 }
 417
 418 int wxFont::GetFamily() const
 419 {
 420     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 421
 422     int ret = M_FONTDATA->m_family;
 423     if (M_FONTDATA->HasNativeFont())
 424         // wxNativeFontInfo::GetFamily is expensive, must not call more than once
 425         ret = M_FONTDATA->m_nativeFontInfo.GetFamily();
 426
 427     if (ret == wxFONTFAMILY_DEFAULT)
 428         ret = M_FONTDATA->m_family;
 429
 430     return ret;
 431 }
 432
 433 int wxFont::GetStyle() const
 434 {
 435     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 436
 437     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetStyle()
 438                                        : M_FONTDATA->m_style;
 439 }
 440
 441 int wxFont::GetWeight() const
 442 {
 443     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 444
 445     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetWeight()
 446                                        : M_FONTDATA->m_weight;
 447 }
 448
 449 bool wxFont::GetUnderlined() const
 450 {
 451     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 452
 453     return M_FONTDATA->m_underlined;
 454 }
 455
 456 wxFontEncoding wxFont::GetEncoding() const
 457 {
 458     wxCHECK_MSG( Ok(), wxFONTENCODING_SYSTEM, wxT("invalid font") );
 459
 460     return M_FONTDATA->m_encoding;
 461 }
 462
 463 bool wxFont::GetNoAntiAliasing() const
 464 {
 465     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 466
 467     return M_FONTDATA->m_noAA;
 468 }
 469
 470 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 471 {
 472     wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
 473
 474     return &(M_FONTDATA->m_nativeFontInfo);
 475 }
 476
 477 bool wxFont::IsFixedWidth() const
 478 {
 479     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 480
 481     return wxFontBase::IsFixedWidth();
 482 }
 483
 484 // ----------------------------------------------------------------------------
 485 // change font attributes
 486 // ----------------------------------------------------------------------------
 487
 488 void wxFont::SetPointSize(int pointSize)
 489 {
 490     AllocExclusive();
 491
 492     M_FONTDATA->SetPointSize(pointSize);
 493 }
 494
 495 void wxFont::SetFamily(int family)
 496 {
 497     AllocExclusive();
 498
 499     M_FONTDATA->SetFamily(family);
 500 }
 501
 502 void wxFont::SetStyle(int style)
 503 {
 504     AllocExclusive();
 505
 506     M_FONTDATA->SetStyle(style);
 507 }
 508
 509 void wxFont::SetWeight(int weight)
 510 {
 511     AllocExclusive();
 512
 513     M_FONTDATA->SetWeight(weight);
 514 }
 515
 516 bool wxFont::SetFaceName(const wxString& faceName)
 517 {
 518     AllocExclusive();
 519
 520     return M_FONTDATA->SetFaceName(faceName) &&
 521            wxFontBase::SetFaceName(faceName);
 522 }
 523
 524 void wxFont::SetUnderlined(bool underlined)
 525 {
 526     AllocExclusive();
 527
 528     M_FONTDATA->SetUnderlined(underlined);
 529 }
 530
 531 void wxFont::SetEncoding(wxFontEncoding encoding)
 532 {
 533     AllocExclusive();
 534
 535     M_FONTDATA->SetEncoding(encoding);
 536 }
 537
 538 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
 539 {
 540     AllocExclusive();
 541
 542     M_FONTDATA->SetNativeFontInfo( info );
 543 }
 544
 545 void wxFont::SetNoAntiAliasing( bool no )
 546 {
 547     AllocExclusive();
 548
 549     M_FONTDATA->SetNoAntiAliasing( no );
 550 }
 551
 552 wxObjectRefData* wxFont::CreateRefData() const
 553 {
 554     return new wxFontRefData;
 555 }
 556
 557 wxObjectRefData* wxFont::CloneRefData(const wxObjectRefData* data) const
 558 {
 559     return new wxFontRefData(*wx_static_cast(const wxFontRefData*, data));
 560 }