src/common/fontcmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/fontcmn.cpp
   3 // Purpose:     implementation of wxFontBase methods
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     20.09.99
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #include "wx/font.h"
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/dc.h"
  31     #include "wx/intl.h"
  32     #include "wx/dcscreen.h"
  33     #include "wx/log.h"
  34     #include "wx/gdicmn.h"
  35 #endif // WX_PRECOMP
  36
  37 #if defined(__WXMSW__)
  38     #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
  39     #include  "wx/msw/winundef.h"
  40 #endif
  41
  42 #include "wx/fontutil.h" // for wxNativeFontInfo
  43 #include "wx/fontmap.h"
  44 #include "wx/fontenum.h"
  45
  46 #include "wx/tokenzr.h"
  47
  48 // debugger helper: this function can be called from a debugger to show what
  49 // the date really is
  50 extern const char *wxDumpFont(const wxFont *font)
  51 {
  52     static char buf[256];
  53
  54     const wxFontWeight weight = font->GetWeight();
  55
  56     wxString s;
  57     s.Printf(wxS("%s-%s-%s-%d-%d"),
  58              font->GetFaceName(),
  59              weight == wxFONTWEIGHT_NORMAL
  60                 ? _T("normal")
  61                 : weight == wxFONTWEIGHT_BOLD
  62                     ? _T("bold")
  63                     : _T("light"),
  64              font->GetStyle() == wxFONTSTYLE_NORMAL
  65                 ? _T("regular")
  66                 : _T("italic"),
  67              font->GetPointSize(),
  68              font->GetEncoding());
  69
  70     wxStrlcpy(buf, s.mb_str(), WXSIZEOF(buf));
  71     return buf;
  72 }
  73
  74 // ============================================================================
  75 // implementation
  76 // ============================================================================
  77
  78 // ----------------------------------------------------------------------------
  79 // helper functions
  80 // ----------------------------------------------------------------------------
  81
  82 static inline int flags2Style(int flags)
  83 {
  84     return flags & wxFONTFLAG_ITALIC
  85                     ? wxFONTSTYLE_ITALIC
  86                     : flags & wxFONTFLAG_SLANT
  87                         ? wxFONTSTYLE_SLANT
  88                         : wxFONTSTYLE_NORMAL;
  89 }
  90
  91 static inline int flags2Weight(int flags)
  92 {
  93     return flags & wxFONTFLAG_LIGHT
  94                     ? wxFONTWEIGHT_LIGHT
  95                     : flags & wxFONTFLAG_BOLD
  96                         ? wxFONTWEIGHT_BOLD
  97                         : wxFONTWEIGHT_NORMAL;
  98 }
  99
 100 static inline bool flags2Underlined(int flags)
 101 {
 102     return (flags & wxFONTFLAG_UNDERLINED) != 0;
 103 }
 104
 105 // ----------------------------------------------------------------------------
 106 // wxFontBase
 107 // ----------------------------------------------------------------------------
 108
 109 wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
 110
 111 /* static */
 112 void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding)
 113 {
 114     // GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT
 115     // and, besides, using this value here doesn't make any sense
 116     wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT,
 117                  _T("can't set default encoding to wxFONTENCODING_DEFAULT") );
 118
 119     ms_encodingDefault = encoding;
 120 }
 121
 122 wxFontBase::~wxFontBase()
 123 {
 124     // this destructor is required for Darwin
 125 }
 126
 127 /* static */
 128 wxFont *wxFontBase::New(int size,
 129                         wxFontFamily family,
 130                         wxFontStyle style,
 131                         wxFontWeight weight,
 132                         bool underlined,
 133                         const wxString& face,
 134                         wxFontEncoding encoding)
 135 {
 136     return new wxFont(size, family, style, weight, underlined, face, encoding);
 137 }
 138
 139 /* static */
 140 wxFont *wxFontBase::New(const wxSize& pixelSize,
 141                         wxFontFamily family,
 142                         wxFontStyle style,
 143                         wxFontWeight weight,
 144                         bool underlined,
 145                         const wxString& face,
 146                         wxFontEncoding encoding)
 147 {
 148     return new wxFont(pixelSize, family, style, weight, underlined,
 149                       face, encoding);
 150 }
 151
 152 /* static */
 153 wxFont *wxFontBase::New(int pointSize,
 154                         wxFontFamily family,
 155                         int flags,
 156                         const wxString& face,
 157                         wxFontEncoding encoding)
 158 {
 159     return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
 160                flags2Underlined(flags), face, encoding);
 161 }
 162
 163 /* static */
 164 wxFont *wxFontBase::New(const wxSize& pixelSize,
 165                         wxFontFamily family,
 166                         int flags,
 167                         const wxString& face,
 168                         wxFontEncoding encoding)
 169 {
 170     return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
 171                flags2Underlined(flags), face, encoding);
 172 }
 173
 174 /* static */
 175 wxFont *wxFontBase::New(const wxNativeFontInfo& info)
 176 {
 177     return new wxFont(info);
 178 }
 179
 180 /* static */
 181 wxFont *wxFontBase::New(const wxString& strNativeFontDesc)
 182 {
 183     wxNativeFontInfo fontInfo;
 184     if ( !fontInfo.FromString(strNativeFontDesc) )
 185         return new wxFont(*wxNORMAL_FONT);
 186
 187     return New(fontInfo);
 188 }
 189
 190 bool wxFontBase::IsFixedWidth() const
 191 {
 192     return GetFamily() == wxFONTFAMILY_TELETYPE;
 193 }
 194
 195 wxSize wxFontBase::GetPixelSize() const
 196 {
 197     wxScreenDC dc;
 198     dc.SetFont(*(wxFont *)this);
 199     return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
 200 }
 201
 202 bool wxFontBase::IsUsingSizeInPixels() const
 203 {
 204     return false;
 205 }
 206
 207 void wxFontBase::SetPixelSize( const wxSize& pixelSize )
 208 {
 209     wxCHECK_RET( pixelSize.GetWidth() >= 0 && pixelSize.GetHeight() > 0,
 210                  "Negative values for the pixel size or zero pixel height are not allowed" );
 211
 212     wxScreenDC dc;
 213
 214     // NOTE: this algorithm for adjusting the font size is used by all
 215     //       implementations of wxFont except under wxMSW and wxGTK where
 216     //       native support to font creation using pixel-size is provided.
 217
 218     int largestGood = 0;
 219     int smallestBad = 0;
 220
 221     bool initialGoodFound = false;
 222     bool initialBadFound = false;
 223
 224     // NB: this assignment was separated from the variable definition
 225     // in order to fix a gcc v3.3.3 compiler crash
 226     int currentSize = GetPointSize();
 227     while (currentSize > 0)
 228     {
 229         dc.SetFont(*static_cast<wxFont*>(this));
 230
 231         // if currentSize (in points) results in a font that is smaller
 232         // than required by pixelSize it is considered a good size
 233         // NOTE: the pixel size width may be zero
 234         if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
 235                 (pixelSize.GetWidth() == 0 ||
 236                  dc.GetCharWidth() <= pixelSize.GetWidth()))
 237         {
 238             largestGood = currentSize;
 239             initialGoodFound = true;
 240         }
 241         else
 242         {
 243             smallestBad = currentSize;
 244             initialBadFound = true;
 245         }
 246         if (!initialGoodFound)
 247         {
 248             currentSize /= 2;
 249         }
 250         else if (!initialBadFound)
 251         {
 252             currentSize *= 2;
 253         }
 254         else
 255         {
 256             int distance = smallestBad - largestGood;
 257             if (distance == 1)
 258                 break;
 259
 260             currentSize = largestGood + distance / 2;
 261         }
 262
 263         SetPointSize(currentSize);
 264     }
 265
 266     if (currentSize != largestGood)
 267         SetPointSize(largestGood);
 268 }
 269
 270 void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
 271 {
 272 #ifdef wxNO_NATIVE_FONTINFO
 273     SetPointSize(info.pointSize);
 274     SetFamily(info.family);
 275     SetStyle(info.style);
 276     SetWeight(info.weight);
 277     SetUnderlined(info.underlined);
 278     SetFaceName(info.faceName);
 279     SetEncoding(info.encoding);
 280 #else
 281     (void)info;
 282 #endif
 283 }
 284
 285 wxString wxFontBase::GetNativeFontInfoDesc() const
 286 {
 287     wxString fontDesc;
 288     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
 289     if ( fontInfo )
 290     {
 291         fontDesc = fontInfo->ToString();
 292         wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
 293     }
 294     else
 295     {
 296         wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
 297     }
 298
 299     return fontDesc;
 300 }
 301
 302 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 303 {
 304     wxString fontDesc;
 305     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
 306     if ( fontInfo )
 307     {
 308         fontDesc = fontInfo->ToUserString();
 309         wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
 310     }
 311     else
 312     {
 313         wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
 314     }
 315
 316     return fontDesc;
 317 }
 318
 319 bool wxFontBase::SetNativeFontInfo(const wxString& info)
 320 {
 321     wxNativeFontInfo fontInfo;
 322     if ( !info.empty() && fontInfo.FromString(info) )
 323     {
 324         SetNativeFontInfo(fontInfo);
 325         return true;
 326     }
 327
 328     return false;
 329 }
 330
 331 bool wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
 332 {
 333     wxNativeFontInfo fontInfo;
 334     if ( !info.empty() && fontInfo.FromUserString(info) )
 335     {
 336         SetNativeFontInfo(fontInfo);
 337         return true;
 338     }
 339
 340     return false;
 341 }
 342
 343 bool wxFontBase::operator==(const wxFont& font) const
 344 {
 345     // either it is the same font, i.e. they share the same common data or they
 346     // have different ref datas but still describe the same font
 347     return IsSameAs(font) ||
 348            (
 349             IsOk() == font.IsOk() &&
 350             GetPointSize() == font.GetPointSize() &&
 351             // in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
 352             // operator==() resulting in infinite recursion so we can't use it
 353             // in that port
 354 #if !defined(__WXGTK__) || defined(__WXGTK20__)
 355             GetPixelSize() == font.GetPixelSize() &&
 356 #endif
 357             GetFamily() == font.GetFamily() &&
 358             GetStyle() == font.GetStyle() &&
 359             GetWeight() == font.GetWeight() &&
 360             GetUnderlined() == font.GetUnderlined() &&
 361             GetFaceName().IsSameAs(font.GetFaceName(), false) &&
 362             GetEncoding() == font.GetEncoding()
 363            );
 364 }
 365
 366 wxString wxFontBase::GetFamilyString() const
 367 {
 368     wxCHECK_MSG( IsOk(), "wxFONTFAMILY_DEFAULT", "invalid font" );
 369
 370     switch ( GetFamily() )
 371     {
 372         case wxFONTFAMILY_DECORATIVE:   return "wxFONTFAMILY_DECORATIVE";
 373         case wxFONTFAMILY_ROMAN:        return "wxFONTFAMILY_ROMAN";
 374         case wxFONTFAMILY_SCRIPT:       return "wxFONTFAMILY_SCRIPT";
 375         case wxFONTFAMILY_SWISS:        return "wxFONTFAMILY_SWISS";
 376         case wxFONTFAMILY_MODERN:       return "wxFONTFAMILY_MODERN";
 377         case wxFONTFAMILY_TELETYPE:     return "wxFONTFAMILY_TELETYPE";
 378         case wxFONTFAMILY_UNKNOWN:      return "wxFONTFAMILY_UNKNOWN";
 379         default:                        return "wxFONTFAMILY_DEFAULT";
 380     }
 381 }
 382
 383 wxString wxFontBase::GetStyleString() const
 384 {
 385     wxCHECK_MSG( IsOk(), "wxFONTSTYLE_DEFAULT", "invalid font" );
 386
 387     switch ( GetStyle() )
 388     {
 389         case wxFONTSTYLE_NORMAL:   return "wxFONTSTYLE_NORMAL";
 390         case wxFONTSTYLE_SLANT:    return "wxFONTSTYLE_SLANT";
 391         case wxFONTSTYLE_ITALIC:   return "wxFONTSTYLE_ITALIC";
 392         default:                   return "wxFONTSTYLE_DEFAULT";
 393     }
 394 }
 395
 396 wxString wxFontBase::GetWeightString() const
 397 {
 398     wxCHECK_MSG( IsOk(), "wxFONTWEIGHT_DEFAULT", "invalid font" );
 399
 400     switch ( GetWeight() )
 401     {
 402         case wxFONTWEIGHT_NORMAL:   return "wxFONTWEIGHT_NORMAL";
 403         case wxFONTWEIGHT_BOLD:     return "wxFONTWEIGHT_BOLD";
 404         case wxFONTWEIGHT_LIGHT:    return "wxFONTWEIGHT_LIGHT";
 405         default:                    return "wxFONTWEIGHT_DEFAULT";
 406     }
 407 }
 408
 409 bool wxFontBase::SetFaceName(const wxString& facename)
 410 {
 411 #if wxUSE_FONTENUM
 412     if (!wxFontEnumerator::IsValidFacename(facename))
 413     {
 414         UnRef();        // make IsOk() return false
 415         return false;
 416     }
 417 #else // !wxUSE_FONTENUM
 418     wxUnusedVar(facename);
 419 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
 420
 421     return true;
 422 }
 423
 424 wxFont wxFont::MakeBold() const
 425 {
 426     wxFont font(*this);
 427     font.SetWeight(wxFONTWEIGHT_BOLD);
 428     return font;
 429 }
 430
 431 wxFont wxFont::MakeItalic() const
 432 {
 433     wxFont font(*this);
 434     font.SetStyle(wxFONTSTYLE_ITALIC);
 435     return font;
 436 }
 437
 438 wxFont wxFont::Scale(float x) const
 439 {
 440     wxFont font(*this);
 441     font.SetPointSize(int(x*GetPointSize() + 0.5));
 442     return font;
 443 }
 444
 445 // ----------------------------------------------------------------------------
 446 // wxNativeFontInfo
 447 // ----------------------------------------------------------------------------
 448
 449 // Up to now, there are no native implementations of this function:
 450 void wxNativeFontInfo::SetFaceName(const wxArrayString& facenames)
 451 {
 452 #if wxUSE_FONTENUM
 453     for (size_t i=0; i < facenames.GetCount(); i++)
 454     {
 455         if (wxFontEnumerator::IsValidFacename(facenames[i]))
 456         {
 457             SetFaceName(facenames[i]);
 458             return;
 459         }
 460     }
 461
 462     // set the first valid facename we can find on this system
 463     wxString validfacename = wxFontEnumerator::GetFacenames().Item(0);
 464     wxLogTrace(wxT("font"), wxT("Falling back to '%s'"), validfacename.c_str());
 465     SetFaceName(validfacename);
 466 #else // !wxUSE_FONTENUM
 467     SetFaceName(facenames[0]);
 468 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
 469 }
 470
 471
 472 #ifdef wxNO_NATIVE_FONTINFO
 473
 474 // These are the generic forms of FromString()/ToString.
 475 //
 476 // convert to/from the string representation: format is
 477 //      version;pointsize;family;style;weight;underlined;facename;encoding
 478
 479 bool wxNativeFontInfo::FromString(const wxString& s)
 480 {
 481     long l;
 482
 483     wxStringTokenizer tokenizer(s, _T(";"));
 484
 485     wxString token = tokenizer.GetNextToken();
 486     //
 487     //  Ignore the version for now
 488     //
 489
 490     token = tokenizer.GetNextToken();
 491     if ( !token.ToLong(&l) )
 492         return false;
 493     pointSize = (int)l;
 494
 495     token = tokenizer.GetNextToken();
 496     if ( !token.ToLong(&l) )
 497         return false;
 498     family = (wxFontFamily)l;
 499
 500     token = tokenizer.GetNextToken();
 501     if ( !token.ToLong(&l) )
 502         return false;
 503     style = (wxFontStyle)l;
 504
 505     token = tokenizer.GetNextToken();
 506     if ( !token.ToLong(&l) )
 507         return false;
 508     weight = (wxFontWeight)l;
 509
 510     token = tokenizer.GetNextToken();
 511     if ( !token.ToLong(&l) )
 512         return false;
 513     underlined = l != 0;
 514
 515     faceName = tokenizer.GetNextToken();
 516
 517 #ifndef __WXMAC__
 518     if( !faceName )
 519         return false;
 520 #endif
 521
 522     token = tokenizer.GetNextToken();
 523     if ( !token.ToLong(&l) )
 524         return false;
 525     encoding = (wxFontEncoding)l;
 526
 527     return true;
 528 }
 529
 530 wxString wxNativeFontInfo::ToString() const
 531 {
 532     wxString s;
 533
 534     s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
 535              0,                                 // version
 536              pointSize,
 537              family,
 538              (int)style,
 539              (int)weight,
 540              underlined,
 541              faceName.GetData(),
 542              (int)encoding);
 543
 544     return s;
 545 }
 546
 547 void wxNativeFontInfo::Init()
 548 {
 549     pointSize = 0;
 550     family = wxFONTFAMILY_DEFAULT;
 551     style = wxFONTSTYLE_NORMAL;
 552     weight = wxFONTWEIGHT_NORMAL;
 553     underlined = false;
 554     faceName.clear();
 555     encoding = wxFONTENCODING_DEFAULT;
 556 }
 557
 558 int wxNativeFontInfo::GetPointSize() const
 559 {
 560     return pointSize;
 561 }
 562
 563 wxFontStyle wxNativeFontInfo::GetStyle() const
 564 {
 565     return style;
 566 }
 567
 568 wxFontWeight wxNativeFontInfo::GetWeight() const
 569 {
 570     return weight;
 571 }
 572
 573 bool wxNativeFontInfo::GetUnderlined() const
 574 {
 575     return underlined;
 576 }
 577
 578 wxString wxNativeFontInfo::GetFaceName() const
 579 {
 580     return faceName;
 581 }
 582
 583 wxFontFamily wxNativeFontInfo::GetFamily() const
 584 {
 585     return family;
 586 }
 587
 588 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 589 {
 590     return encoding;
 591 }
 592
 593 void wxNativeFontInfo::SetPointSize(int pointsize)
 594 {
 595     pointSize = pointsize;
 596 }
 597
 598 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
 599 {
 600     style = style_;
 601 }
 602
 603 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
 604 {
 605     weight = weight_;
 606 }
 607
 608 void wxNativeFontInfo::SetUnderlined(bool underlined_)
 609 {
 610     underlined = underlined_;
 611 }
 612
 613 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
 614 {
 615     faceName = facename_;
 616     return true;
 617 }
 618
 619 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
 620 {
 621     family = family_;
 622 }
 623
 624 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
 625 {
 626     encoding = encoding_;
 627 }
 628
 629 #endif // generic wxNativeFontInfo implementation
 630
 631 // conversion to/from user-readable string: this is used in the generic
 632 // versions and under MSW as well because there is no standard font description
 633 // format there anyhow (but there is a well-defined standard for X11 fonts used
 634 // by wxGTK and wxMotif)
 635
 636 #if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__) || defined(__WXOSX__)
 637
 638 wxString wxNativeFontInfo::ToUserString() const
 639 {
 640     wxString desc;
 641
 642     // first put the adjectives, if any - this is English-centric, of course,
 643     // but what else can we do?
 644     if ( GetUnderlined() )
 645     {
 646         desc << _("underlined");
 647     }
 648
 649     switch ( GetWeight() )
 650     {
 651         default:
 652             wxFAIL_MSG( _T("unknown font weight") );
 653             // fall through
 654
 655         case wxFONTWEIGHT_NORMAL:
 656             break;
 657
 658         case wxFONTWEIGHT_LIGHT:
 659             desc << _(" light");
 660             break;
 661
 662         case wxFONTWEIGHT_BOLD:
 663             desc << _(" bold");
 664             break;
 665     }
 666
 667     switch ( GetStyle() )
 668     {
 669         default:
 670             wxFAIL_MSG( _T("unknown font style") );
 671             // fall through
 672
 673         case wxFONTSTYLE_NORMAL:
 674             break;
 675
 676             // we don't distinguish between the two for now anyhow...
 677         case wxFONTSTYLE_ITALIC:
 678         case wxFONTSTYLE_SLANT:
 679             desc << _(" italic");
 680             break;
 681     }
 682
 683     wxString face = GetFaceName();
 684     if ( !face.empty() )
 685     {
 686         if (face.Contains(' ') || face.Contains(';') || face.Contains(','))
 687         {
 688             face.Replace("'", "");
 689                 // eventually remove quote characters: most systems do not
 690                 // allow them in a facename anyway so this usually does nothing
 691
 692             // make it possible for FromUserString() function to understand
 693             // that the different words which compose this facename are
 694             // not different adjectives or other data but rather all parts
 695             // of the facename
 696             desc << _T(" '") << face << _("'");
 697         }
 698         else
 699             desc << _T(' ') << face;
 700     }
 701     else // no face name specified
 702     {
 703         // use the family
 704         wxString familyStr;
 705         switch ( GetFamily() )
 706         {
 707             case wxFONTFAMILY_DECORATIVE:
 708                 familyStr = "decorative";
 709                 break;
 710
 711             case wxFONTFAMILY_ROMAN:
 712                 familyStr = "roman";
 713                 break;
 714
 715             case wxFONTFAMILY_SCRIPT:
 716                 familyStr = "script";
 717                 break;
 718
 719             case wxFONTFAMILY_SWISS:
 720                 familyStr = "swiss";
 721                 break;
 722
 723             case wxFONTFAMILY_MODERN:
 724                 familyStr = "modern";
 725                 break;
 726
 727             case wxFONTFAMILY_TELETYPE:
 728                 familyStr = "teletype";
 729                 break;
 730
 731             case wxFONTFAMILY_DEFAULT:
 732             case wxFONTFAMILY_UNKNOWN:
 733                 break;
 734
 735             default:
 736                 wxFAIL_MSG( "unknown font family" );
 737         }
 738
 739         if ( !familyStr.empty() )
 740             desc << " '" << familyStr << " family'";
 741     }
 742
 743     int size = GetPointSize();
 744     if ( size != wxNORMAL_FONT->GetPointSize() )
 745     {
 746         desc << _T(' ') << size;
 747     }
 748
 749 #if wxUSE_FONTMAP
 750     wxFontEncoding enc = GetEncoding();
 751     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
 752     {
 753         desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
 754     }
 755 #endif // wxUSE_FONTMAP
 756
 757     return desc.Strip(wxString::both).MakeLower();
 758 }
 759
 760 bool wxNativeFontInfo::FromUserString(const wxString& s)
 761 {
 762     // reset to the default state
 763     Init();
 764
 765     // ToUserString() will quote the facename if it contains spaces, commas
 766     // or semicolons: we must be able to understand that quoted text is
 767     // a single token:
 768     wxString toparse(s);
 769
 770     // parse a more or less free form string
 771     wxStringTokenizer tokenizer(toparse, _T(";, "), wxTOKEN_STRTOK);
 772
 773     wxString face;
 774     unsigned long size;
 775     bool weightfound = false, pointsizefound = false;
 776 #if wxUSE_FONTMAP
 777     bool encodingfound = false;
 778 #endif
 779     bool insideQuotes = false;
 780
 781     while ( tokenizer.HasMoreTokens() )
 782     {
 783         wxString token = tokenizer.GetNextToken();
 784
 785         // normalize it
 786         token.Trim(true).Trim(false).MakeLower();
 787         if (insideQuotes)
 788         {
 789             if (token.StartsWith("'") ||
 790                 token.EndsWith("'"))
 791             {
 792                 insideQuotes = false;
 793
 794                 // add this last token to the facename:
 795                 face += " " + token;
 796
 797                 // normalize facename:
 798                 face = face.Trim(true).Trim(false);
 799                 face.Replace("'", "");
 800
 801                 continue;
 802             }
 803         }
 804         else
 805         {
 806             if (token.StartsWith("'"))
 807                 insideQuotes = true;
 808         }
 809
 810         // look for the known tokens
 811         if ( insideQuotes )
 812         {
 813             // only the facename may be quoted:
 814             face += " " + token;
 815             continue;
 816         }
 817         if ( token == _T("underlined") || token == _("underlined") )
 818         {
 819             SetUnderlined(true);
 820         }
 821         else if ( token == _T("light") || token == _("light") )
 822         {
 823             SetWeight(wxFONTWEIGHT_LIGHT);
 824             weightfound = true;
 825         }
 826         else if ( token == _T("bold") || token == _("bold") )
 827         {
 828             SetWeight(wxFONTWEIGHT_BOLD);
 829             weightfound = true;
 830         }
 831         else if ( token == _T("italic") || token == _("italic") )
 832         {
 833             SetStyle(wxFONTSTYLE_ITALIC);
 834         }
 835         else if ( token.ToULong(&size) )
 836         {
 837             SetPointSize(size);
 838             pointsizefound = true;
 839         }
 840         else
 841         {
 842 #if wxUSE_FONTMAP
 843             // try to interpret this as an encoding
 844             wxFontEncoding encoding = wxFontMapper::Get()->CharsetToEncoding(token, false);
 845             if ( encoding != wxFONTENCODING_DEFAULT &&
 846                  encoding != wxFONTENCODING_SYSTEM )    // returned when the recognition failed
 847         {
 848             SetEncoding(encoding);
 849                 encodingfound = true;
 850         }
 851             else
 852         {
 853 #endif // wxUSE_FONTMAP
 854
 855                 // assume it is the face name
 856             if ( !face.empty() )
 857             {
 858                 face += _T(' ');
 859             }
 860
 861             face += token;
 862
 863             // skip the code which resets face below
 864             continue;
 865
 866 #if wxUSE_FONTMAP
 867         }
 868 #endif // wxUSE_FONTMAP
 869         }
 870
 871         // if we had had the facename, we shouldn't continue appending tokens
 872         // to it (i.e. "foo bold bar" shouldn't result in the facename "foo
 873         // bar")
 874         if ( !face.empty() )
 875         {
 876             wxString familyStr;
 877             if ( face.EndsWith(" family", &familyStr) )
 878             {
 879                 // it's not a facename but rather a font family
 880                 wxFontFamily family;
 881                 if ( familyStr == "decorative" )
 882                     family = wxFONTFAMILY_DECORATIVE;
 883                 else if ( familyStr == "roman" )
 884                     family = wxFONTFAMILY_ROMAN;
 885                 else if ( familyStr == "script" )
 886                     family = wxFONTFAMILY_SCRIPT;
 887                 else if ( familyStr == "swiss" )
 888                     family = wxFONTFAMILY_SWISS;
 889                 else if ( familyStr == "modern" )
 890                     family = wxFONTFAMILY_MODERN;
 891                 else if ( familyStr == "teletype" )
 892                     family = wxFONTFAMILY_TELETYPE;
 893                 else
 894                     return false;
 895
 896                 SetFamily(family);
 897             }
 898             // NB: the check on the facename is implemented in wxFontBase::SetFaceName
 899             //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
 900             //     call here wxFontEnumerator::IsValidFacename
 901             else if (
 902 #if wxUSE_FONTENUM
 903                     !wxFontEnumerator::IsValidFacename(face) ||
 904 #endif // wxUSE_FONTENUM
 905                     !SetFaceName(face) )
 906             {
 907                 SetFaceName(wxNORMAL_FONT->GetFaceName());
 908             }
 909
 910             face.clear();
 911         }
 912     }
 913
 914     // we might not have flushed it inside the loop
 915     if ( !face.empty() )
 916     {
 917         // NB: the check on the facename is implemented in wxFontBase::SetFaceName
 918         //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
 919         //     call here wxFontEnumerator::IsValidFacename
 920         if (
 921 #if wxUSE_FONTENUM
 922                 !wxFontEnumerator::IsValidFacename(face) ||
 923 #endif // wxUSE_FONTENUM
 924                 !SetFaceName(face) )
 925             {
 926                 SetFaceName(wxNORMAL_FONT->GetFaceName());
 927             }
 928     }
 929
 930     // set point size to default value if size was not given
 931     if ( !pointsizefound )
 932         SetPointSize(wxNORMAL_FONT->GetPointSize());
 933
 934     // set font weight to default value if weight was not given
 935     if ( !weightfound )
 936         SetWeight(wxFONTWEIGHT_NORMAL);
 937
 938 #if wxUSE_FONTMAP
 939     // set font encoding to default value if encoding was not given
 940     if ( !encodingfound )
 941         SetEncoding(wxFONTENCODING_SYSTEM);
 942 #endif // wxUSE_FONTMAP
 943
 944     return true;
 945 }
 946
 947 #endif // generic or wxMSW or wxOS2
 948
 949
 950 // wxFont <-> wxString utilities, used by wxConfig
 951 wxString wxToString(const wxFontBase& font)
 952 {
 953     return font.IsOk() ? font.GetNativeFontInfoDesc()
 954                        : wxString();
 955 }
 956
 957 bool wxFromString(const wxString& str, wxFontBase *font)
 958 {
 959     wxCHECK_MSG( font, false, _T("NULL output parameter") );
 960
 961     if ( str.empty() )
 962     {
 963         *font = wxNullFont;
 964         return true;
 965     }
 966
 967     return font->SetNativeFontInfo(str);
 968 }
 969
 970