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 // ----------------------------------------------------------------------------
 131 // wxFontRefData
 132 // ----------------------------------------------------------------------------
 133
 134 void wxFontRefData::Init(int pointSize,
 135                          int family,
 136                          int style,
 137                          int weight,
 138                          bool underlined,
 139                          const wxString& faceName,
 140                          wxFontEncoding encoding)
 141 {
 142     m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
 143
 144     m_faceName = faceName;
 145
 146     // we accept both wxDEFAULT and wxNORMAL here - should we?
 147     m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
 148     m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
 149
 150     // and here, do we really want to forbid creation of the font of the size
 151     // 90 (the value of wxDEFAULT)??
 152     m_pointSize = pointSize == wxDEFAULT || pointSize == -1
 153                     ? wxDEFAULT_FONT_SIZE
 154                     : pointSize;
 155
 156     m_underlined = underlined;
 157     m_encoding = encoding;
 158
 159     m_noAA = false;
 160
 161     // Create native font info
 162     m_nativeFontInfo.description = pango_font_description_new();
 163
 164     // And set its values
 165     if (!m_faceName.empty())
 166     {
 167        pango_font_description_set_family( m_nativeFontInfo.description,
 168                                           wxGTK_CONV_SYS(m_faceName) );
 169     }
 170     else
 171     {
 172         switch (m_family)
 173         {
 174             case wxFONTFAMILY_MODERN:
 175             case wxFONTFAMILY_TELETYPE:
 176                pango_font_description_set_family( m_nativeFontInfo.description, "monospace" );
 177                break;
 178             case wxFONTFAMILY_ROMAN:
 179                pango_font_description_set_family( m_nativeFontInfo.description, "serif" );
 180                break;
 181             case wxFONTFAMILY_SWISS:
 182                // SWISS = sans serif
 183             default:
 184                pango_font_description_set_family( m_nativeFontInfo.description, "sans" );
 185                break;
 186         }
 187     }
 188
 189     SetStyle( m_style );
 190     SetPointSize( m_pointSize );
 191     SetWeight( m_weight );
 192 }
 193
 194 void wxFontRefData::InitFromNative()
 195 {
 196     m_noAA = false;
 197
 198     // Get native info
 199     PangoFontDescription *desc = m_nativeFontInfo.description;
 200
 201     // init fields
 202     m_faceName = wxGTK_CONV_BACK( pango_font_description_get_family( desc ) );
 203
 204     // Pango sometimes needs to have a size
 205     int pango_size = pango_font_description_get_size( desc );
 206     if (pango_size == 0)
 207         m_nativeFontInfo.SetPointSize(12);
 208
 209     m_pointSize = m_nativeFontInfo.GetPointSize();
 210     m_style = m_nativeFontInfo.GetStyle();
 211     m_weight = m_nativeFontInfo.GetWeight();
 212
 213     if (m_faceName == wxT("monospace"))
 214     {
 215         m_family = wxFONTFAMILY_TELETYPE;
 216     }
 217     else if (m_faceName == wxT("sans"))
 218     {
 219         m_family = wxFONTFAMILY_SWISS;
 220     }
 221     else if (m_faceName == wxT("serif"))
 222     {
 223         m_family = wxFONTFAMILY_ROMAN;
 224     }
 225     else
 226     {
 227         m_family = wxFONTFAMILY_UNKNOWN;
 228     }
 229
 230     // Pango description are never underlined (?)
 231     m_underlined = false;
 232
 233     // always with GTK+ 2
 234     m_encoding = wxFONTENCODING_UTF8;
 235 }
 236
 237 wxFontRefData::wxFontRefData( const wxFontRefData& data )
 238              : wxObjectRefData()
 239 {
 240     m_pointSize = data.m_pointSize;
 241     m_family = data.m_family;
 242     m_style = data.m_style;
 243     m_weight = data.m_weight;
 244
 245     m_underlined = data.m_underlined;
 246
 247     m_faceName = data.m_faceName;
 248     m_encoding = data.m_encoding;
 249
 250     m_noAA = data.m_noAA;
 251
 252     // Forces a copy of the internal data.  wxNativeFontInfo should probably
 253     // have a copy ctor and assignment operator to fix this properly but that
 254     // would break binary compatibility...
 255     m_nativeFontInfo.FromString(data.m_nativeFontInfo.ToString());
 256 }
 257
 258 wxFontRefData::wxFontRefData(int size, int family, int style,
 259                              int weight, bool underlined,
 260                              const wxString& faceName,
 261                              wxFontEncoding encoding)
 262 {
 263     Init(size, family, style, weight, underlined, faceName, encoding);
 264 }
 265
 266 wxFontRefData::wxFontRefData(const wxString& fontname)
 267 {
 268     m_nativeFontInfo.FromString( fontname );
 269
 270     InitFromNative();
 271 }
 272
 273 void wxFontRefData::ClearGdkFonts()
 274 {
 275 }
 276
 277 wxFontRefData::~wxFontRefData()
 278 {
 279     ClearGdkFonts();
 280 }
 281
 282 // ----------------------------------------------------------------------------
 283 // wxFontRefData SetXXX()
 284 // ----------------------------------------------------------------------------
 285
 286 void wxFontRefData::SetPointSize(int pointSize)
 287 {
 288     m_pointSize = pointSize;
 289
 290     m_nativeFontInfo.SetPointSize(pointSize);
 291 }
 292
 293 void wxFontRefData::SetFamily(int family)
 294 {
 295     m_family = family;
 296
 297     // TODO: what are we supposed to do with m_nativeFontInfo here?
 298 }
 299
 300 void wxFontRefData::SetStyle(int style)
 301 {
 302     m_style = style;
 303
 304     m_nativeFontInfo.SetStyle((wxFontStyle)style);
 305 }
 306
 307 void wxFontRefData::SetWeight(int weight)
 308 {
 309     m_weight = weight;
 310
 311     m_nativeFontInfo.SetWeight((wxFontWeight)weight);
 312 }
 313
 314 void wxFontRefData::SetUnderlined(bool underlined)
 315 {
 316     m_underlined = underlined;
 317
 318     // the XLFD doesn't have "underlined" field anyhow
 319 }
 320
 321 bool wxFontRefData::SetFaceName(const wxString& facename)
 322 {
 323     m_faceName = facename;
 324
 325     return m_nativeFontInfo.SetFaceName(facename);
 326 }
 327
 328 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
 329 {
 330     m_encoding = encoding;
 331 }
 332
 333 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
 334 {
 335     // previously cached fonts shouldn't be used
 336     ClearGdkFonts();
 337
 338     m_nativeFontInfo = info;
 339
 340     // set all the other font parameters from the native font info
 341     InitFromNative();
 342 }
 343
 344 // ----------------------------------------------------------------------------
 345 // wxFont creation
 346 // ----------------------------------------------------------------------------
 347
 348 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
 349
 350 wxFont::wxFont(const wxNativeFontInfo& info)
 351 {
 352     Create( info.GetPointSize(),
 353             info.GetFamily(),
 354             info.GetStyle(),
 355             info.GetWeight(),
 356             info.GetUnderlined(),
 357             info.GetFaceName(),
 358             info.GetEncoding() );
 359 }
 360
 361 bool wxFont::Create( int pointSize,
 362                      int family,
 363                      int style,
 364                      int weight,
 365                      bool underlined,
 366                      const wxString& face,
 367                      wxFontEncoding encoding)
 368 {
 369     UnRef();
 370
 371     m_refData = new wxFontRefData(pointSize, family, style, weight,
 372                                   underlined, face, encoding);
 373
 374     return true;
 375 }
 376
 377 bool wxFont::Create(const wxString& fontname)
 378 {
 379     // VZ: does this really happen?
 380     if ( fontname.empty() )
 381     {
 382         *this = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
 383
 384         return true;
 385     }
 386
 387     m_refData = new wxFontRefData(fontname);
 388
 389     return true;
 390 }
 391
 392 wxFont::~wxFont()
 393 {
 394 }
 395
 396 // ----------------------------------------------------------------------------
 397 // accessors
 398 // ----------------------------------------------------------------------------
 399
 400 int wxFont::GetPointSize() const
 401 {
 402     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 403
 404     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetPointSize()
 405                                        : M_FONTDATA->m_pointSize;
 406 }
 407
 408 wxString wxFont::GetFaceName() const
 409 {
 410     wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
 411
 412     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetFaceName()
 413                                        : M_FONTDATA->m_faceName;
 414 }
 415
 416 int wxFont::GetFamily() const
 417 {
 418     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 419
 420     int ret = M_FONTDATA->m_family;
 421     if (M_FONTDATA->HasNativeFont())
 422         // wxNativeFontInfo::GetFamily is expensive, must not call more than once
 423         ret = M_FONTDATA->m_nativeFontInfo.GetFamily();
 424
 425     if (ret == wxFONTFAMILY_DEFAULT)
 426         ret = M_FONTDATA->m_family;
 427
 428     return ret;
 429 }
 430
 431 int wxFont::GetStyle() const
 432 {
 433     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 434
 435     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetStyle()
 436                                        : M_FONTDATA->m_style;
 437 }
 438
 439 int wxFont::GetWeight() const
 440 {
 441     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 442
 443     return M_FONTDATA->HasNativeFont() ? M_FONTDATA->m_nativeFontInfo.GetWeight()
 444                                        : M_FONTDATA->m_weight;
 445 }
 446
 447 bool wxFont::GetUnderlined() const
 448 {
 449     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 450
 451     return M_FONTDATA->m_underlined;
 452 }
 453
 454 wxFontEncoding wxFont::GetEncoding() const
 455 {
 456     wxCHECK_MSG( Ok(), wxFONTENCODING_SYSTEM, wxT("invalid font") );
 457
 458     return M_FONTDATA->m_encoding;
 459 }
 460
 461 bool wxFont::GetNoAntiAliasing() const
 462 {
 463     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 464
 465     return M_FONTDATA->m_noAA;
 466 }
 467
 468 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 469 {
 470     wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
 471
 472     return &(M_FONTDATA->m_nativeFontInfo);
 473 }
 474
 475 bool wxFont::IsFixedWidth() const
 476 {
 477     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 478
 479     return wxFontBase::IsFixedWidth();
 480 }
 481
 482 // ----------------------------------------------------------------------------
 483 // change font attributes
 484 // ----------------------------------------------------------------------------
 485
 486 void wxFont::SetPointSize(int pointSize)
 487 {
 488     AllocExclusive();
 489
 490     M_FONTDATA->SetPointSize(pointSize);
 491 }
 492
 493 void wxFont::SetFamily(int family)
 494 {
 495     AllocExclusive();
 496
 497     M_FONTDATA->SetFamily(family);
 498 }
 499
 500 void wxFont::SetStyle(int style)
 501 {
 502     AllocExclusive();
 503
 504     M_FONTDATA->SetStyle(style);
 505 }
 506
 507 void wxFont::SetWeight(int weight)
 508 {
 509     AllocExclusive();
 510
 511     M_FONTDATA->SetWeight(weight);
 512 }
 513
 514 bool wxFont::SetFaceName(const wxString& faceName)
 515 {
 516     AllocExclusive();
 517
 518     return M_FONTDATA->SetFaceName(faceName) &&
 519            wxFontBase::SetFaceName(faceName);
 520 }
 521
 522 void wxFont::SetUnderlined(bool underlined)
 523 {
 524     AllocExclusive();
 525
 526     M_FONTDATA->SetUnderlined(underlined);
 527 }
 528
 529 void wxFont::SetEncoding(wxFontEncoding encoding)
 530 {
 531     AllocExclusive();
 532
 533     M_FONTDATA->SetEncoding(encoding);
 534 }
 535
 536 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
 537 {
 538     AllocExclusive();
 539
 540     M_FONTDATA->SetNativeFontInfo( info );
 541 }
 542
 543 void wxFont::SetNoAntiAliasing( bool no )
 544 {
 545     AllocExclusive();
 546
 547     M_FONTDATA->SetNoAntiAliasing( no );
 548 }
 549
 550 wxObjectRefData* wxFont::CreateRefData() const
 551 {
 552     return new wxFontRefData;
 553 }
 554
 555 wxObjectRefData* wxFont::CloneRefData(const wxObjectRefData* data) const
 556 {
 557     return new wxFontRefData(*wx_static_cast(const wxFontRefData*, data));
 558 }