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 // ============================================================================
  49 // implementation
  50 // ============================================================================
  51
  52 // ----------------------------------------------------------------------------
  53 // helper functions
  54 // ----------------------------------------------------------------------------
  55
  56 static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize)
  57 {
  58     int largestGood = 0;
  59     int smallestBad = 0;
  60
  61     bool initialGoodFound = false;
  62     bool initialBadFound = false;
  63
  64     // NB: this assignment was separated from the variable definition
  65     // in order to fix a gcc v3.3.3 compiler crash
  66     int currentSize = font.GetPointSize();
  67     while (currentSize > 0)
  68     {
  69         dc.SetFont(font);
  70
  71         // if currentSize (in points) results in a font that is smaller
  72         // than required by pixelSize it is considered a good size
  73         if (dc.GetCharHeight() <= pixelSize.GetHeight() &&
  74                 (!pixelSize.GetWidth() ||
  75                  dc.GetCharWidth() <= pixelSize.GetWidth()))
  76         {
  77             largestGood = currentSize;
  78             initialGoodFound = true;
  79         }
  80         else
  81         {
  82             smallestBad = currentSize;
  83             initialBadFound = true;
  84         }
  85         if (!initialGoodFound)
  86         {
  87             currentSize /= 2;
  88         }
  89         else if (!initialBadFound)
  90         {
  91             currentSize *= 2;
  92         }
  93         else
  94         {
  95             int distance = smallestBad - largestGood;
  96             if (distance == 1)
  97                 break;
  98
  99             currentSize = largestGood + distance / 2;
 100         }
 101
 102         font.SetPointSize(currentSize);
 103     }
 104
 105     if (currentSize != largestGood)
 106         font.SetPointSize(largestGood);
 107 }
 108
 109 // ----------------------------------------------------------------------------
 110 // wxFontBase
 111 // ----------------------------------------------------------------------------
 112
 113 wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
 114
 115 /* static */
 116 void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding)
 117 {
 118     // GetDefaultEncoding() should return something != wxFONTENCODING_DEFAULT
 119     // and, besides, using this value here doesn't make any sense
 120     wxCHECK_RET( encoding != wxFONTENCODING_DEFAULT,
 121                  _T("can't set default encoding to wxFONTENCODING_DEFAULT") );
 122
 123     ms_encodingDefault = encoding;
 124 }
 125
 126 wxFontBase::~wxFontBase()
 127 {
 128     // this destructor is required for Darwin
 129 }
 130
 131 /* static */
 132 wxFont *wxFontBase::New(int size,
 133                         wxFontFamily family,
 134                         wxFontStyle style,
 135                         wxFontWeight weight,
 136                         bool underlined,
 137                         const wxString& face,
 138                         wxFontEncoding encoding)
 139 {
 140     return new wxFont(size, family, style, weight, underlined, face, encoding);
 141 }
 142
 143 static inline int flags2Style(int flags)
 144 {
 145     return flags & wxFONTFLAG_ITALIC
 146                     ? wxFONTSTYLE_ITALIC
 147                     : flags & wxFONTFLAG_SLANT
 148                         ? wxFONTSTYLE_SLANT
 149                         : wxFONTSTYLE_NORMAL;
 150 }
 151
 152 static inline int flags2Weight(int flags)
 153 {
 154     return flags & wxFONTFLAG_LIGHT
 155                     ? wxFONTWEIGHT_LIGHT
 156                     : flags & wxFONTFLAG_BOLD
 157                         ? wxFONTWEIGHT_BOLD
 158                         : wxFONTWEIGHT_NORMAL;
 159 }
 160
 161 static inline bool flags2Underlined(int flags)
 162 {
 163     return (flags & wxFONTFLAG_UNDERLINED) != 0;
 164 }
 165
 166 /* static */
 167 wxFont *wxFontBase::New(int pointSize,
 168                         wxFontFamily family,
 169                         int flags,
 170                         const wxString& face,
 171                         wxFontEncoding encoding)
 172 {
 173     return New(pointSize, family, flags2Style(flags), flags2Weight(flags),
 174                flags2Underlined(flags), face, encoding);
 175 }
 176
 177 /* static */
 178 wxFont *wxFontBase::New(const wxSize& pixelSize,
 179                         wxFontFamily family,
 180                         wxFontStyle style,
 181                         wxFontWeight weight,
 182                         bool underlined,
 183                         const wxString& face,
 184                         wxFontEncoding encoding)
 185 {
 186 #if defined(__WXMSW__)
 187     return new wxFont(pixelSize, family, style, weight, underlined,
 188                       face, encoding);
 189 #else
 190     wxFont *self = New(10, family, style, weight, underlined, face, encoding);
 191     wxScreenDC dc;
 192     AdjustFontSize(*(wxFont *)self, dc, pixelSize);
 193     return self;
 194 #endif
 195 }
 196
 197 /* static */
 198 wxFont *wxFontBase::New(const wxSize& pixelSize,
 199                         wxFontFamily family,
 200                         int flags,
 201                         const wxString& face,
 202                         wxFontEncoding encoding)
 203 {
 204     return New(pixelSize, family, flags2Style(flags), flags2Weight(flags),
 205                flags2Underlined(flags), face, encoding);
 206 }
 207
 208 wxSize wxFontBase::GetPixelSize() const
 209 {
 210     wxScreenDC dc;
 211     dc.SetFont(*(wxFont *)this);
 212     return wxSize(dc.GetCharWidth(), dc.GetCharHeight());
 213 }
 214
 215 bool wxFontBase::IsUsingSizeInPixels() const
 216 {
 217     return false;
 218 }
 219
 220 void wxFontBase::SetPixelSize( const wxSize& pixelSize )
 221 {
 222     wxScreenDC dc;
 223     AdjustFontSize(*(wxFont *)this, dc, pixelSize);
 224 }
 225
 226 /* static */
 227 wxFont *wxFontBase::New(const wxNativeFontInfo& info)
 228 {
 229     return new wxFont(info);
 230 }
 231
 232 /* static */
 233 wxFont *wxFontBase::New(const wxString& strNativeFontDesc)
 234 {
 235     wxNativeFontInfo fontInfo;
 236     if ( !fontInfo.FromString(strNativeFontDesc) )
 237         return new wxFont(*wxNORMAL_FONT);
 238
 239     return New(fontInfo);
 240 }
 241
 242 bool wxFontBase::IsFixedWidth() const
 243 {
 244     return GetFamily() == wxFONTFAMILY_TELETYPE;
 245 }
 246
 247 void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo& info)
 248 {
 249 #ifdef wxNO_NATIVE_FONTINFO
 250     SetPointSize(info.pointSize);
 251     SetFamily(info.family);
 252     SetStyle(info.style);
 253     SetWeight(info.weight);
 254     SetUnderlined(info.underlined);
 255     SetFaceName(info.faceName);
 256     SetEncoding(info.encoding);
 257 #else
 258     (void)info;
 259 #endif
 260 }
 261
 262 wxString wxFontBase::GetNativeFontInfoDesc() const
 263 {
 264     wxString fontDesc;
 265     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
 266     if ( fontInfo )
 267     {
 268         fontDesc = fontInfo->ToString();
 269         wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
 270     }
 271     else
 272     {
 273         wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
 274     }
 275
 276     return fontDesc;
 277 }
 278
 279 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 280 {
 281     wxString fontDesc;
 282     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
 283     if ( fontInfo )
 284     {
 285         fontDesc = fontInfo->ToUserString();
 286         wxASSERT_MSG(!fontDesc.empty(), wxT("This should be a non-empty string!"));
 287     }
 288     else
 289     {
 290         wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
 291     }
 292
 293     return fontDesc;
 294 }
 295
 296 bool wxFontBase::SetNativeFontInfo(const wxString& info)
 297 {
 298     wxNativeFontInfo fontInfo;
 299     if ( !info.empty() && fontInfo.FromString(info) )
 300     {
 301         SetNativeFontInfo(fontInfo);
 302         return true;
 303     }
 304
 305     return false;
 306 }
 307
 308 bool wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
 309 {
 310     wxNativeFontInfo fontInfo;
 311     if ( !info.empty() && fontInfo.FromUserString(info) )
 312     {
 313         SetNativeFontInfo(fontInfo);
 314         return true;
 315     }
 316
 317     return false;
 318 }
 319
 320 bool wxFontBase::operator==(const wxFont& font) const
 321 {
 322     // either it is the same font, i.e. they share the same common data or they
 323     // have different ref datas but still describe the same font
 324     return IsSameAs(font) ||
 325            (
 326             Ok() == font.Ok() &&
 327             GetPointSize() == font.GetPointSize() &&
 328             // in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
 329             // operator==() resulting in infinite recursion so we can't use it
 330             // in that port
 331 #if !defined(__WXGTK__) || defined(__WXGTK20__)
 332             GetPixelSize() == font.GetPixelSize() &&
 333 #endif
 334             GetFamily() == font.GetFamily() &&
 335             GetStyle() == font.GetStyle() &&
 336             GetWeight() == font.GetWeight() &&
 337             GetUnderlined() == font.GetUnderlined() &&
 338             GetFaceName().IsSameAs(font.GetFaceName(), false) &&
 339             GetEncoding() == font.GetEncoding()
 340            );
 341 }
 342
 343 wxString wxFontBase::GetFamilyString() const
 344 {
 345     wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
 346
 347     switch ( GetFamily() )
 348     {
 349         case wxDECORATIVE:   return wxT("wxDECORATIVE");
 350         case wxROMAN:        return wxT("wxROMAN");
 351         case wxSCRIPT:       return wxT("wxSCRIPT");
 352         case wxSWISS:        return wxT("wxSWISS");
 353         case wxMODERN:       return wxT("wxMODERN");
 354         case wxTELETYPE:     return wxT("wxTELETYPE");
 355         default:             return wxT("wxDEFAULT");
 356     }
 357 }
 358
 359 wxString wxFontBase::GetStyleString() const
 360 {
 361     wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
 362
 363     switch ( GetStyle() )
 364     {
 365         case wxNORMAL:   return wxT("wxNORMAL");
 366         case wxSLANT:    return wxT("wxSLANT");
 367         case wxITALIC:   return wxT("wxITALIC");
 368         default:         return wxT("wxDEFAULT");
 369     }
 370 }
 371
 372 wxString wxFontBase::GetWeightString() const
 373 {
 374     wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
 375
 376     switch ( GetWeight() )
 377     {
 378         case wxNORMAL:   return wxT("wxNORMAL");
 379         case wxBOLD:     return wxT("wxBOLD");
 380         case wxLIGHT:    return wxT("wxLIGHT");
 381         default:         return wxT("wxDEFAULT");
 382     }
 383 }
 384
 385 bool wxFontBase::SetFaceName(const wxString& facename)
 386 {
 387 #if wxUSE_FONTENUM
 388     if (!wxFontEnumerator::IsValidFacename(facename))
 389     {
 390         UnRef();        // make Ok() return false
 391         return false;
 392     }
 393 #else // !wxUSE_FONTENUM
 394     wxUnusedVar(facename);
 395 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
 396
 397     return true;
 398 }
 399
 400
 401 // ----------------------------------------------------------------------------
 402 // wxNativeFontInfo
 403 // ----------------------------------------------------------------------------
 404
 405 // Up to now, there are no native implementations of this function:
 406 void wxNativeFontInfo::SetFaceName(const wxArrayString& facenames)
 407 {
 408 #if wxUSE_FONTENUM
 409     for (size_t i=0; i < facenames.GetCount(); i++)
 410     {
 411         if (wxFontEnumerator::IsValidFacename(facenames[i]))
 412         {
 413             SetFaceName(facenames[i]);
 414             return;
 415         }
 416     }
 417
 418     // set the first valid facename we can find on this system
 419     wxString validfacename = wxFontEnumerator::GetFacenames().Item(0);
 420     wxLogTrace(wxT("font"), wxT("Falling back to '%s'"), validfacename.c_str());
 421     SetFaceName(validfacename);
 422 #else // !wxUSE_FONTENUM
 423     SetFaceName(facenames[0]);
 424 #endif // wxUSE_FONTENUM/!wxUSE_FONTENUM
 425 }
 426
 427
 428 #ifdef wxNO_NATIVE_FONTINFO
 429
 430 // These are the generic forms of FromString()/ToString.
 431 //
 432 // convert to/from the string representation: format is
 433 //      version;pointsize;family;style;weight;underlined;facename;encoding
 434
 435 bool wxNativeFontInfo::FromString(const wxString& s)
 436 {
 437     long l;
 438
 439     wxStringTokenizer tokenizer(s, _T(";"));
 440
 441     wxString token = tokenizer.GetNextToken();
 442     //
 443     //  Ignore the version for now
 444     //
 445
 446     token = tokenizer.GetNextToken();
 447     if ( !token.ToLong(&l) )
 448         return false;
 449     pointSize = (int)l;
 450
 451     token = tokenizer.GetNextToken();
 452     if ( !token.ToLong(&l) )
 453         return false;
 454     family = (wxFontFamily)l;
 455
 456     token = tokenizer.GetNextToken();
 457     if ( !token.ToLong(&l) )
 458         return false;
 459     style = (wxFontStyle)l;
 460
 461     token = tokenizer.GetNextToken();
 462     if ( !token.ToLong(&l) )
 463         return false;
 464     weight = (wxFontWeight)l;
 465
 466     token = tokenizer.GetNextToken();
 467     if ( !token.ToLong(&l) )
 468         return false;
 469     underlined = l != 0;
 470
 471     faceName = tokenizer.GetNextToken();
 472
 473 #ifndef __WXMAC__
 474     if( !faceName )
 475         return false;
 476 #endif
 477
 478     token = tokenizer.GetNextToken();
 479     if ( !token.ToLong(&l) )
 480         return false;
 481     encoding = (wxFontEncoding)l;
 482
 483     return true;
 484 }
 485
 486 wxString wxNativeFontInfo::ToString() const
 487 {
 488     wxString s;
 489
 490     s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
 491              0,                                 // version
 492              pointSize,
 493              family,
 494              (int)style,
 495              (int)weight,
 496              underlined,
 497              faceName.GetData(),
 498              (int)encoding);
 499
 500     return s;
 501 }
 502
 503 void wxNativeFontInfo::Init()
 504 {
 505     pointSize = 0;
 506     family = wxFONTFAMILY_DEFAULT;
 507     style = wxFONTSTYLE_NORMAL;
 508     weight = wxFONTWEIGHT_NORMAL;
 509     underlined = false;
 510     faceName.clear();
 511     encoding = wxFONTENCODING_DEFAULT;
 512 }
 513
 514 int wxNativeFontInfo::GetPointSize() const
 515 {
 516     return pointSize;
 517 }
 518
 519 wxFontStyle wxNativeFontInfo::GetStyle() const
 520 {
 521     return style;
 522 }
 523
 524 wxFontWeight wxNativeFontInfo::GetWeight() const
 525 {
 526     return weight;
 527 }
 528
 529 bool wxNativeFontInfo::GetUnderlined() const
 530 {
 531     return underlined;
 532 }
 533
 534 wxString wxNativeFontInfo::GetFaceName() const
 535 {
 536     return faceName;
 537 }
 538
 539 wxFontFamily wxNativeFontInfo::GetFamily() const
 540 {
 541     return family;
 542 }
 543
 544 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 545 {
 546     return encoding;
 547 }
 548
 549 void wxNativeFontInfo::SetPointSize(int pointsize)
 550 {
 551     pointSize = pointsize;
 552 }
 553
 554 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
 555 {
 556     style = style_;
 557 }
 558
 559 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
 560 {
 561     weight = weight_;
 562 }
 563
 564 void wxNativeFontInfo::SetUnderlined(bool underlined_)
 565 {
 566     underlined = underlined_;
 567 }
 568
 569 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
 570 {
 571     faceName = facename_;
 572     return true;
 573 }
 574
 575 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
 576 {
 577     family = family_;
 578 }
 579
 580 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
 581 {
 582     encoding = encoding_;
 583 }
 584
 585 #endif // generic wxNativeFontInfo implementation
 586
 587 // conversion to/from user-readable string: this is used in the generic
 588 // versions and under MSW as well because there is no standard font description
 589 // format there anyhow (but there is a well-defined standard for X11 fonts used
 590 // by wxGTK and wxMotif)
 591
 592 #if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__)
 593
 594 wxString wxNativeFontInfo::ToUserString() const
 595 {
 596     wxString desc;
 597
 598     // first put the adjectives, if any - this is English-centric, of course,
 599     // but what else can we do?
 600     if ( GetUnderlined() )
 601     {
 602         desc << _("underlined");
 603     }
 604
 605     switch ( GetWeight() )
 606     {
 607         default:
 608             wxFAIL_MSG( _T("unknown font weight") );
 609             // fall through
 610
 611         case wxFONTWEIGHT_NORMAL:
 612             break;
 613
 614         case wxFONTWEIGHT_LIGHT:
 615             desc << _(" light");
 616             break;
 617
 618         case wxFONTWEIGHT_BOLD:
 619             desc << _(" bold");
 620             break;
 621     }
 622
 623     switch ( GetStyle() )
 624     {
 625         default:
 626             wxFAIL_MSG( _T("unknown font style") );
 627             // fall through
 628
 629         case wxFONTSTYLE_NORMAL:
 630             break;
 631
 632             // we don't distinguish between the two for now anyhow...
 633         case wxFONTSTYLE_ITALIC:
 634         case wxFONTSTYLE_SLANT:
 635             desc << _(" italic");
 636             break;
 637     }
 638
 639     wxString face = GetFaceName();
 640     if ( !face.empty() )
 641     {
 642         desc << _T(' ') << face;
 643     }
 644
 645     int size = GetPointSize();
 646     if ( size != wxNORMAL_FONT->GetPointSize() )
 647     {
 648         desc << _T(' ') << size;
 649     }
 650
 651 #if wxUSE_FONTMAP
 652     wxFontEncoding enc = GetEncoding();
 653     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
 654     {
 655         desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
 656     }
 657 #endif // wxUSE_FONTMAP
 658
 659     return desc.Strip(wxString::both).MakeLower();
 660 }
 661
 662 bool wxNativeFontInfo::FromUserString(const wxString& s)
 663 {
 664     // reset to the default state
 665     Init();
 666
 667     // parse a more or less free form string
 668     //
 669     // TODO: we should handle at least the quoted facenames
 670     wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK);
 671
 672     wxString face;
 673     unsigned long size;
 674     bool weightfound = false, pointsizefound = false;
 675 #if wxUSE_FONTMAP
 676     bool encodingfound = false;
 677 #endif
 678
 679     while ( tokenizer.HasMoreTokens() )
 680     {
 681         wxString token = tokenizer.GetNextToken();
 682
 683         // normalize it
 684         token.Trim(true).Trim(false).MakeLower();
 685
 686         // look for the known tokens
 687         if ( token == _T("underlined") || token == _("underlined") )
 688         {
 689             SetUnderlined(true);
 690         }
 691         else if ( token == _T("light") || token == _("light") )
 692         {
 693             SetWeight(wxFONTWEIGHT_LIGHT);
 694             weightfound = true;
 695         }
 696         else if ( token == _T("bold") || token == _("bold") )
 697         {
 698             SetWeight(wxFONTWEIGHT_BOLD);
 699             weightfound = true;
 700         }
 701         else if ( token == _T("italic") || token == _("italic") )
 702         {
 703             SetStyle(wxFONTSTYLE_ITALIC);
 704         }
 705         else if ( token.ToULong(&size) )
 706         {
 707             SetPointSize(size);
 708             pointsizefound = true;
 709         }
 710         else
 711         {
 712 #if wxUSE_FONTMAP
 713             // try to interpret this as an encoding
 714             wxFontEncoding encoding = wxFontMapper::Get()->CharsetToEncoding(token, false);
 715             if ( encoding != wxFONTENCODING_DEFAULT &&
 716                  encoding != wxFONTENCODING_SYSTEM )    // returned when the recognition failed
 717         {
 718             SetEncoding(encoding);
 719                 encodingfound = true;
 720         }
 721             else
 722         {
 723 #endif // wxUSE_FONTMAP
 724
 725                 // assume it is the face name
 726             if ( !face.empty() )
 727             {
 728                 face += _T(' ');
 729             }
 730
 731             face += token;
 732
 733             // skip the code which resets face below
 734             continue;
 735
 736 #if wxUSE_FONTMAP
 737         }
 738 #endif // wxUSE_FONTMAP
 739         }
 740
 741         // if we had had the facename, we shouldn't continue appending tokens
 742         // to it (i.e. "foo bold bar" shouldn't result in the facename "foo
 743         // bar")
 744         if ( !face.empty() )
 745         {
 746             // NB: the check on the facename is implemented in wxFontBase::SetFaceName
 747             //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
 748             //     call here wxFontEnumerator::IsValidFacename
 749             if (
 750 #if wxUSE_FONTENUM
 751                     !wxFontEnumerator::IsValidFacename(face) ||
 752 #endif // wxUSE_FONTENUM
 753                     !SetFaceName(face) )
 754             {
 755                 SetFaceName(wxNORMAL_FONT->GetFaceName());
 756             }
 757
 758             face.clear();
 759         }
 760     }
 761
 762     // we might not have flushed it inside the loop
 763     if ( !face.empty() )
 764     {
 765         // NB: the check on the facename is implemented in wxFontBase::SetFaceName
 766         //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
 767         //     call here wxFontEnumerator::IsValidFacename
 768         if (
 769 #if wxUSE_FONTENUM
 770                 !wxFontEnumerator::IsValidFacename(face) ||
 771 #endif // wxUSE_FONTENUM
 772                 !SetFaceName(face) )
 773             {
 774                 SetFaceName(wxNORMAL_FONT->GetFaceName());
 775             }
 776     }
 777
 778     // set point size to default value if size was not given
 779     if ( !pointsizefound )
 780         SetPointSize(wxNORMAL_FONT->GetPointSize());
 781
 782     // set font weight to default value if weight was not given
 783     if ( !weightfound )
 784         SetWeight(wxFONTWEIGHT_NORMAL);
 785
 786 #if wxUSE_FONTMAP
 787     // set font encoding to default value if encoding was not given
 788     if ( !encodingfound )
 789         SetEncoding(wxFONTENCODING_SYSTEM);
 790 #endif // wxUSE_FONTMAP
 791
 792     return true;
 793 }
 794
 795 #endif // generic or wxMSW or wxOS2
 796
 797
 798 // wxFont <-> wxString utilities, used by wxConfig
 799 wxString wxToString(const wxFontBase& font)
 800 {
 801     return font.IsOk() ? font.GetNativeFontInfoDesc()
 802                        : wxString();
 803 }
 804
 805 bool wxFromString(const wxString& str, wxFontBase *font)
 806 {
 807     wxCHECK_MSG( font, false, _T("NULL output parameter") );
 808
 809     if ( str.empty() )
 810     {
 811         *font = wxNullFont;
 812         return true;
 813     }
 814
 815     return font->SetNativeFontInfo(str);
 816 }
 817
 818