src/x11/font.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/x11/font.cpp
   3 // Purpose:     wxFont class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     17/09/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // for compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 // ============================================================================
  16 // declarations
  17 // ============================================================================
  18
  19 // ----------------------------------------------------------------------------
  20 // headers
  21 // ----------------------------------------------------------------------------
  22
  23 #ifdef __VMS
  24 #pragma message disable nosimpint
  25 #include "wx/vms_x_fix.h"
  26 #endif
  27
  28 #ifdef __VMS
  29 #pragma message enable nosimpint
  30 #endif
  31
  32 #include "wx/font.h"
  33
  34 #ifndef WX_PRECOMP
  35     #include "wx/string.h"
  36     #include "wx/utils.h"       // for wxGetDisplay()
  37     #include "wx/settings.h"
  38     #include "wx/gdicmn.h"
  39 #endif
  40
  41 #include "wx/fontutil.h"    // for wxNativeFontInfo
  42 #include "wx/tokenzr.h"
  43 #include "wx/fontenum.h"
  44
  45 #include "wx/x11/private.h"
  46
  47 IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
  48
  49 // ----------------------------------------------------------------------------
  50 // constants
  51 // ----------------------------------------------------------------------------
  52
  53 // the default size (in points) for the fonts
  54 static const int wxDEFAULT_FONT_SIZE = 12;
  55
  56
  57 #if wxUSE_UNICODE
  58 #else
  59 // ----------------------------------------------------------------------------
  60 // wxXFont
  61 // ----------------------------------------------------------------------------
  62
  63 // For every wxFont, there must be a font for each display and scale requested.
  64 // So these objects are stored in wxFontRefData::m_fonts
  65 class wxXFont : public wxObject
  66 {
  67 public:
  68     wxXFont();
  69     virtual ~wxXFont();
  70
  71     WXFontStructPtr     m_fontStruct;   // XFontStruct
  72     WXDisplay*          m_display;      // XDisplay
  73     int                 m_scale;        // Scale * 100
  74 };
  75
  76 wxXFont::wxXFont()
  77 {
  78     m_fontStruct = (WXFontStructPtr) 0;
  79     m_display = (WXDisplay*) 0;
  80     m_scale = 100;
  81 }
  82
  83 wxXFont::~wxXFont()
  84 {
  85     // Freeing the font used to produce a segv, but
  86     // appears to be OK now (bug fix in X11?)
  87     XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;
  88     XFreeFont((Display*) m_display, fontStruct);
  89 }
  90 #endif
  91
  92 // ----------------------------------------------------------------------------
  93 // wxFontRefData
  94 // ----------------------------------------------------------------------------
  95
  96 class wxFontRefData: public wxGDIRefData
  97 {
  98 friend class wxFont;
  99
 100 public:
 101     wxFontRefData(int size = wxDEFAULT,
 102                   wxFontFamily family = wxFONTFAMILY_DEFAULT,
 103                   wxFontStyle style = wxFONTSTYLE_NORMAL,
 104                   wxFontWeight weight = wxFONTWEIGHT_NORMAL,
 105                   bool underlined = false,
 106                   const wxString& faceName = wxEmptyString,
 107                   wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
 108
 109     // copy cstr
 110     wxFontRefData(const wxFontRefData& data);
 111
 112     // from XFLD
 113     wxFontRefData(const wxString& fontname);
 114
 115     // dstr
 116     virtual ~wxFontRefData();
 117
 118     // setters: all of them also take care to modify m_nativeFontInfo if we
 119     // have it so as to not lose the information not carried by our fields
 120     void SetPointSize(int pointSize);
 121     void SetFamily(wxFontFamily family);
 122     void SetStyle(wxFontStyle style);
 123     void SetWeight(wxFontWeight weight);
 124     void SetUnderlined(bool underlined);
 125     bool SetFaceName(const wxString& facename);
 126     void SetEncoding(wxFontEncoding encoding);
 127
 128     void SetNoAntiAliasing( bool no = true ) { m_noAA = no; }
 129     bool GetNoAntiAliasing() const { return m_noAA; }
 130
 131     // and this one also modifies all the other font data fields
 132     void SetNativeFontInfo(const wxNativeFontInfo& info);
 133
 134 protected:
 135     // common part of all ctors
 136     void Init(int size,
 137               wxFontFamily family,
 138               wxFontStyle style,
 139               wxFontWeight weight,
 140               bool underlined,
 141               const wxString& faceName,
 142               wxFontEncoding encoding);
 143
 144     // set all fields from (already initialized and valid) m_nativeFontInfo
 145     void InitFromNative();
 146
 147     // font attributes
 148     int           m_pointSize;
 149     wxFontFamily  m_family;
 150     wxFontStyle   m_style;
 151     wxFontWeight  m_weight;
 152     bool          m_underlined;
 153     wxString      m_faceName;
 154     wxFontEncoding m_encoding;   // Unused in Unicode mode
 155     bool            m_noAA;      // No anti-aliasing
 156
 157     wxNativeFontInfo m_nativeFontInfo;
 158
 159     void ClearX11Fonts();
 160
 161 #if wxUSE_UNICODE
 162 #else
 163     // A list of wxXFonts
 164     wxList        m_fonts;
 165 #endif
 166 };
 167
 168 #define M_FONTDATA ((wxFontRefData*)m_refData)
 169
 170 // ----------------------------------------------------------------------------
 171 // wxFontRefData
 172 // ----------------------------------------------------------------------------
 173
 174 void wxFontRefData::Init(int pointSize,
 175                          wxFontFamily family,
 176                          wxFontStyle style,
 177                          wxFontWeight weight,
 178                          bool underlined,
 179                          const wxString& faceName,
 180                          wxFontEncoding encoding)
 181 {
 182     m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
 183
 184     m_faceName = faceName;
 185
 186     // we accept both wxDEFAULT and wxNORMAL here - should we?
 187     m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
 188     m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
 189
 190     m_underlined = underlined;
 191     m_encoding = encoding;
 192
 193 #if wxUSE_UNICODE
 194     if ( m_nativeFontInfo.description )
 195         pango_font_description_free(m_nativeFontInfo.description);
 196
 197     // Create native font info
 198     m_nativeFontInfo.description = pango_font_description_new();
 199
 200     // if a face name is specified, use it if it's available, otherwise use
 201     // just the family
 202     if ( faceName.empty() || !wxFontEnumerator::IsValidFacename(faceName) )
 203     {
 204         // TODO: scan system for valid fonts matching the given family instead
 205         //       of hardcoding them here
 206         switch ( m_family )
 207         {
 208             case wxFONTFAMILY_TELETYPE:
 209                 m_faceName = wxT("monospace");
 210                 break;
 211
 212             case wxFONTFAMILY_ROMAN:
 213                 m_faceName = wxT("serif");
 214                 break;
 215
 216             default:
 217                 m_faceName = wxT("sans");
 218         }
 219     }
 220     else // specified face name is available, use it
 221     {
 222         m_faceName = faceName;
 223     }
 224
 225     m_nativeFontInfo.SetFaceName(m_faceName);
 226     m_nativeFontInfo.SetWeight((wxFontWeight)m_weight);
 227     m_nativeFontInfo.SetStyle((wxFontStyle)m_style);
 228 #endif // wxUSE_UNICODE
 229
 230     SetPointSize(pointSize);
 231 }
 232
 233 void wxFontRefData::InitFromNative()
 234 {
 235     m_noAA = false;
 236
 237 #if wxUSE_UNICODE
 238     // Get native info
 239     PangoFontDescription *desc = m_nativeFontInfo.description;
 240
 241     // init fields
 242     m_faceName = wxGTK_CONV_BACK( pango_font_description_get_family( desc ) );
 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 // Not defined in some Pango versions
 260 #define wxPANGO_WEIGHT_SEMIBOLD 600
 261
 262     switch (pango_font_description_get_weight( desc ))
 263     {
 264         case PANGO_WEIGHT_ULTRALIGHT:
 265         case PANGO_WEIGHT_LIGHT:
 266             m_weight = wxFONTWEIGHT_LIGHT;
 267             break;
 268
 269         default:
 270             wxFAIL_MSG(_T("unknown Pango font weight"));
 271             // fall through
 272
 273         case PANGO_WEIGHT_NORMAL:
 274             m_weight = wxFONTWEIGHT_NORMAL;
 275             break;
 276
 277         case wxPANGO_WEIGHT_SEMIBOLD:
 278         case PANGO_WEIGHT_BOLD:
 279         case PANGO_WEIGHT_ULTRABOLD:
 280         case PANGO_WEIGHT_HEAVY:
 281             m_weight = wxFONTWEIGHT_BOLD;
 282             break;
 283     }
 284
 285     if (m_faceName == wxT("monospace"))
 286     {
 287         m_family = wxFONTFAMILY_TELETYPE;
 288     }
 289     else if (m_faceName == wxT("sans"))
 290     {
 291         m_family = wxFONTFAMILY_SWISS;
 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 // X11
 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)[0u]).GetValue() )
 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 // Pango/X11
 402 }
 403
 404 wxFontRefData::wxFontRefData( const wxFontRefData& data )
 405              : wxGDIRefData()
 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     m_nativeFontInfo = data.m_nativeFontInfo;
 420 }
 421
 422 wxFontRefData::wxFontRefData(int size, wxFontFamily family, wxFontStyle style,
 423                              wxFontWeight weight, bool underlined,
 424                              const wxString& faceName,
 425                              wxFontEncoding encoding)
 426 {
 427     Init(size, family, style, weight, underlined, faceName, encoding);
 428 }
 429
 430 wxFontRefData::wxFontRefData(const wxString& fontname)
 431 {
 432     // VZ: FromString() should really work in both cases, doesn't it?
 433 #if wxUSE_UNICODE
 434     m_nativeFontInfo.FromString( fontname );
 435 #else
 436     m_nativeFontInfo.SetXFontName(fontname);
 437 #endif
 438
 439     InitFromNative();
 440 }
 441
 442 void wxFontRefData::ClearX11Fonts()
 443 {
 444 #if wxUSE_UNICODE
 445 #else
 446     wxList::compatibility_iterator node = m_fonts.GetFirst();
 447     while (node)
 448     {
 449         wxXFont* f = (wxXFont*) node->GetData();
 450         delete f;
 451         node = node->GetNext();
 452     }
 453     m_fonts.Clear();
 454 #endif
 455 }
 456
 457 wxFontRefData::~wxFontRefData()
 458 {
 459     ClearX11Fonts();
 460 }
 461
 462 // ----------------------------------------------------------------------------
 463 // wxFontRefData SetXXX()
 464 // ----------------------------------------------------------------------------
 465
 466 void wxFontRefData::SetPointSize(int pointSize)
 467 {
 468     // NB: Pango doesn't support point sizes less than 1
 469     m_pointSize = pointSize == wxDEFAULT || pointSize < 1 ? wxDEFAULT_FONT_SIZE
 470                                                           : pointSize;
 471
 472 #if wxUSE_UNICODE
 473     m_nativeFontInfo.SetPointSize(m_pointSize);
 474 #endif
 475 }
 476
 477 void wxFontRefData::SetFamily(wxFontFamily family)
 478 {
 479     m_family = family;
 480
 481     // TODO: what are we supposed to do with m_nativeFontInfo here?
 482 }
 483
 484 void wxFontRefData::SetStyle(wxFontStyle style)
 485 {
 486     m_style = style;
 487
 488 #if wxUSE_UNICODE
 489     // Get native info
 490     PangoFontDescription *desc = m_nativeFontInfo.description;
 491
 492     switch ( style )
 493     {
 494         case wxFONTSTYLE_ITALIC:
 495             pango_font_description_set_style( desc, PANGO_STYLE_ITALIC );
 496             break;
 497         case wxFONTSTYLE_SLANT:
 498             pango_font_description_set_style( desc, PANGO_STYLE_OBLIQUE );
 499             break;
 500         default:
 501             wxFAIL_MSG( _T("unknown font style") );
 502             // fall through
 503         case wxFONTSTYLE_NORMAL:
 504             pango_font_description_set_style( desc, PANGO_STYLE_NORMAL );
 505             break;
 506     }
 507 #endif
 508 }
 509
 510 void wxFontRefData::SetWeight(wxFontWeight weight)
 511 {
 512     m_weight = weight;
 513 }
 514
 515 void wxFontRefData::SetUnderlined(bool underlined)
 516 {
 517     m_underlined = underlined;
 518
 519     // the XLFD doesn't have "underlined" field anyhow
 520 }
 521
 522 bool wxFontRefData::SetFaceName(const wxString& facename)
 523 {
 524     m_faceName = facename;
 525     return true;
 526 }
 527
 528 void wxFontRefData::SetEncoding(wxFontEncoding encoding)
 529 {
 530     m_encoding = encoding;
 531 }
 532
 533 void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
 534 {
 535     // previously cached fonts shouldn't be used
 536     ClearX11Fonts();
 537
 538     m_nativeFontInfo = info;
 539
 540     // set all the other font parameters from the native font info
 541     InitFromNative();
 542 }
 543
 544 // ----------------------------------------------------------------------------
 545 // wxFont
 546 // ----------------------------------------------------------------------------
 547
 548 wxFont::wxFont(const wxNativeFontInfo& info)
 549 {
 550 #if wxUSE_UNICODE
 551     Create( info.GetPointSize(),
 552             info.GetFamily(),
 553             info.GetStyle(),
 554             info.GetWeight(),
 555             info.GetUnderlined(),
 556             info.GetFaceName(),
 557             info.GetEncoding() );
 558 #else
 559     (void) Create(info.GetXFontName());
 560 #endif
 561 }
 562
 563 bool wxFont::Create(int pointSize,
 564                     wxFontFamily family,
 565                     wxFontStyle style,
 566                     wxFontWeight weight,
 567                     bool underlined,
 568                     const wxString& faceName,
 569                     wxFontEncoding encoding)
 570 {
 571     UnRef();
 572
 573     m_refData = new wxFontRefData(pointSize, family, style, weight,
 574                                   underlined, faceName, encoding);
 575
 576     return true;
 577 }
 578
 579 #if !wxUSE_UNICODE
 580
 581 bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
 582 {
 583     if( !fontname )
 584     {
 585         *this = wxSystemSettings::GetFont( wxSYS_DEFAULT_GUI_FONT);
 586         return true;
 587     }
 588
 589     m_refData = new wxFontRefData();
 590
 591     M_FONTDATA->m_nativeFontInfo.SetXFontName(fontname);  // X font name
 592
 593     wxString tmp;
 594
 595     wxStringTokenizer tn( fontname, wxT("-") );
 596
 597     tn.GetNextToken();                           // skip initial empty token
 598     tn.GetNextToken();                           // foundry
 599
 600
 601     M_FONTDATA->m_faceName = tn.GetNextToken();  // family
 602
 603     tmp = tn.GetNextToken().MakeUpper();         // weight
 604     if (tmp == wxT("BOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
 605     if (tmp == wxT("BLACK")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
 606     if (tmp == wxT("EXTRABOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
 607     if (tmp == wxT("DEMIBOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
 608     if (tmp == wxT("ULTRABOLD")) M_FONTDATA->m_weight = wxFONTWEIGHT_BOLD;
 609
 610     if (tmp == wxT("LIGHT")) M_FONTDATA->m_weight = wxFONTWEIGHT_LIGHT;
 611     if (tmp == wxT("THIN")) M_FONTDATA->m_weight = wxFONTWEIGHT_LIGHT;
 612
 613     tmp = tn.GetNextToken().MakeUpper();        // slant
 614     if (tmp == wxT("I")) M_FONTDATA->m_style = wxFONTSTYLE_ITALIC;
 615     if (tmp == wxT("O")) M_FONTDATA->m_style = wxFONTSTYLE_ITALIC;
 616
 617     tn.GetNextToken();                           // set width
 618     tn.GetNextToken();                           // add. style
 619     tn.GetNextToken();                           // pixel size
 620
 621     tmp = tn.GetNextToken();                     // pointsize
 622     if (tmp != wxT("*"))
 623     {
 624         long num = wxStrtol (tmp.c_str(), (wxChar **) NULL, 10);
 625         M_FONTDATA->m_pointSize = (int)(num / 10);
 626     }
 627
 628     tn.GetNextToken();                           // x-res
 629     tn.GetNextToken();                           // y-res
 630
 631     tmp = tn.GetNextToken().MakeUpper();         // spacing
 632
 633     if (tmp == wxT("M"))
 634         M_FONTDATA->m_family = wxFONTFAMILY_MODERN;
 635     else if (M_FONTDATA->m_faceName == wxT("TIMES"))
 636         M_FONTDATA->m_family = wxFONTFAMILY_ROMAN;
 637     else if (M_FONTDATA->m_faceName == wxT("HELVETICA"))
 638         M_FONTDATA->m_family = wxFONTFAMILY_SWISS;
 639     else if (M_FONTDATA->m_faceName == wxT("LUCIDATYPEWRITER"))
 640         M_FONTDATA->m_family = wxFONTFAMILY_TELETYPE;
 641     else if (M_FONTDATA->m_faceName == wxT("LUCIDA"))
 642         M_FONTDATA->m_family = wxFONTFAMILY_DECORATIVE;
 643     else if (M_FONTDATA->m_faceName == wxT("UTOPIA"))
 644         M_FONTDATA->m_family = wxFONTFAMILY_SCRIPT;
 645
 646     tn.GetNextToken();                           // avg width
 647
 648     // deal with font encoding
 649     M_FONTDATA->m_encoding = enc;
 650     if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
 651     {
 652         wxString registry = tn.GetNextToken().MakeUpper(),
 653                  encoding = tn.GetNextToken().MakeUpper();
 654
 655         if ( registry == _T("ISO8859") )
 656         {
 657             int cp;
 658             if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
 659             {
 660                 M_FONTDATA->m_encoding =
 661                     (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
 662             }
 663         }
 664         else if ( registry == _T("MICROSOFT") )
 665         {
 666             int cp;
 667             if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
 668             {
 669                 M_FONTDATA->m_encoding =
 670                     (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
 671             }
 672         }
 673         else if ( registry == _T("KOI8") )
 674         {
 675             M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
 676         }
 677         //else: unknown encoding - may be give a warning here?
 678         else
 679             return false;
 680     }
 681     return true;
 682 }
 683 #endif // !wxUSE_UNICODE
 684
 685 wxFont::~wxFont()
 686 {
 687 }
 688
 689 wxGDIRefData *wxFont::CreateGDIRefData() const
 690 {
 691     return new wxFontRefData;
 692 }
 693
 694 wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
 695 {
 696     return new wxFontRefData(*static_cast<const wxFontRefData *>(data));
 697 }
 698
 699 // ----------------------------------------------------------------------------
 700 // change the font attributes
 701 // ----------------------------------------------------------------------------
 702
 703 void wxFont::Unshare()
 704 {
 705     // Don't change shared data
 706     if (!m_refData)
 707     {
 708         m_refData = new wxFontRefData();
 709     }
 710     else
 711     {
 712         wxFontRefData* ref = new wxFontRefData(*(wxFontRefData*)m_refData);
 713         UnRef();
 714         m_refData = ref;
 715     }
 716 }
 717
 718 // ----------------------------------------------------------------------------
 719 // accessors
 720 // ----------------------------------------------------------------------------
 721
 722 int wxFont::GetPointSize() const
 723 {
 724     wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
 725
 726     return M_FONTDATA->m_pointSize;
 727 }
 728
 729 wxString wxFont::GetFaceName() const
 730 {
 731     wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
 732
 733     return M_FONTDATA->m_faceName;
 734 }
 735
 736 wxFontFamily wxFont::GetFamily() const
 737 {
 738     wxCHECK_MSG( Ok(), wxFONTFAMILY_MAX, wxT("invalid font") );
 739
 740     return M_FONTDATA->m_family;
 741 }
 742
 743 wxFontStyle wxFont::GetStyle() const
 744 {
 745     wxCHECK_MSG( Ok(), wxFONTSTYLE_MAX, wxT("invalid font") );
 746
 747     return M_FONTDATA->m_style;
 748 }
 749
 750 wxFontWeight wxFont::GetWeight() const
 751 {
 752     wxCHECK_MSG( Ok(), wxFONTWEIGHT_MAX, wxT("invalid font") );
 753
 754     return M_FONTDATA->m_weight;
 755 }
 756
 757 bool wxFont::GetUnderlined() const
 758 {
 759     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 760
 761     return M_FONTDATA->m_underlined;
 762 }
 763
 764 wxFontEncoding wxFont::GetEncoding() const
 765 {
 766     wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
 767
 768     return M_FONTDATA->m_encoding;
 769 }
 770
 771 bool wxFont::GetNoAntiAliasing() const
 772 {
 773     wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
 774
 775     return M_FONTDATA->m_noAA;
 776 }
 777
 778 const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
 779 {
 780     wxCHECK_MSG( Ok(), NULL, wxT("invalid font") );
 781
 782 #if wxUSE_UNICODE
 783 #else
 784     if ( M_FONTDATA->m_nativeFontInfo.GetXFontName().empty() )
 785         GetInternalFont();
 786 #endif
 787
 788     return &(M_FONTDATA->m_nativeFontInfo);
 789 }
 790
 791 bool wxFont::IsFixedWidth() const
 792 {
 793     wxCHECK_MSG( Ok(), false, wxT("invalid font") );
 794
 795 #if wxUSE_UNICODE
 796    return wxFontBase::IsFixedWidth();
 797 #else
 798     // Robert, is this right? HasNativeFont doesn't exist.
 799     if ( true )
 800     //    if ( M_FONTDATA->HasNativeFont() )
 801     {
 802         // the monospace fonts are supposed to have "M" in the spacing field
 803         wxString spacing = M_FONTDATA->
 804                             m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING);
 805
 806         return spacing.Upper() == _T('M');
 807     }
 808    // Unreaceable code for now
 809    // return wxFontBase::IsFixedWidth();
 810 #endif
 811
 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(wxFontFamily family)
 826 {
 827     Unshare();
 828
 829     M_FONTDATA->SetFamily(family);
 830 }
 831
 832 void wxFont::SetStyle(wxFontStyle style)
 833 {
 834     Unshare();
 835
 836     M_FONTDATA->SetStyle(style);
 837 }
 838
 839 void wxFont::SetWeight(wxFontWeight weight)
 840 {
 841     Unshare();
 842
 843     M_FONTDATA->SetWeight(weight);
 844 }
 845
 846 bool wxFont::SetFaceName(const wxString& faceName)
 847 {
 848     Unshare();
 849
 850     return M_FONTDATA->SetFaceName(faceName) &&
 851         wxFontBase::SetFaceName(faceName);
 852 }
 853
 854 void wxFont::SetUnderlined(bool underlined)
 855 {
 856     Unshare();
 857
 858     M_FONTDATA->SetUnderlined(underlined);
 859 }
 860
 861 void wxFont::SetEncoding(wxFontEncoding encoding)
 862 {
 863     Unshare();
 864
 865     M_FONTDATA->SetEncoding(encoding);
 866 }
 867
 868 void wxFont::DoSetNativeFontInfo( const wxNativeFontInfo& info )
 869 {
 870     Unshare();
 871
 872     M_FONTDATA->SetNativeFontInfo( info );
 873 }
 874
 875 void wxFont::SetNoAntiAliasing( bool no )
 876 {
 877     Unshare();
 878
 879     M_FONTDATA->SetNoAntiAliasing( no );
 880 }
 881
 882 #if wxUSE_UNICODE
 883 #else
 884
 885 // ----------------------------------------------------------------------------
 886 // X11 implementation
 887 // ----------------------------------------------------------------------------
 888
 889 // Find an existing, or create a new, XFontStruct
 890 // based on this wxFont and the given scale. Append the
 891 // font to list in the private data for future reference.
 892 wxXFont* wxFont::GetInternalFont(double scale, WXDisplay* display) const
 893 {
 894     if ( !Ok() )
 895         return NULL;
 896
 897     long intScale = long(scale * 100.0 + 0.5); // key for wxXFont
 898     int pointSize = (M_FONTDATA->m_pointSize * 10 * intScale) / 100;
 899
 900     // search existing fonts first
 901     wxList::compatibility_iterator node = M_FONTDATA->m_fonts.GetFirst();
 902     while (node)
 903     {
 904         wxXFont* f = (wxXFont*) node->GetData();
 905         if ((!display || (f->m_display == display)) && (f->m_scale == intScale))
 906             return f;
 907         node = node->GetNext();
 908     }
 909
 910     wxString xFontName = M_FONTDATA->m_nativeFontInfo.GetXFontName();
 911     if (xFontName == "-*-*-*-*-*--*-*-*-*-*-*-*-*")
 912       // wxFont constructor not called with native font info parameter => take M_FONTDATA values
 913       xFontName.Clear();
 914
 915     // not found, create a new one
 916     XFontStruct *font = (XFontStruct *)
 917                         wxLoadQueryNearestFont(pointSize,
 918                                                M_FONTDATA->m_family,
 919                                                M_FONTDATA->m_style,
 920                                                M_FONTDATA->m_weight,
 921                                                M_FONTDATA->m_underlined,
 922                                                wxT(""),
 923                                                M_FONTDATA->m_encoding,
 924                                                & xFontName);
 925
 926     if ( !font )
 927     {
 928         wxFAIL_MSG( wxT("Could not allocate even a default font -- something is wrong.") );
 929
 930         return NULL;
 931     }
 932
 933     wxXFont* f = new wxXFont;
 934     f->m_fontStruct = (WXFontStructPtr)font;
 935     f->m_display = ( display ? display : wxGetDisplay() );
 936     f->m_scale = intScale;
 937     M_FONTDATA->m_fonts.Append(f);
 938
 939     return f;
 940 }
 941
 942 WXFontStructPtr wxFont::GetFontStruct(double scale, WXDisplay* display) const
 943 {
 944     wxXFont* f = GetInternalFont(scale, display);
 945
 946     return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
 947 }
 948
 949 #endif