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