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 (!wxFontEnumerator::IsValidFacename(facename))
 394     {
 395         UnRef();        // make Ok() return false
 396         return false;
 397     }
 398
 399     return true;
 400 }
 401
 402
 403 // ----------------------------------------------------------------------------
 404 // wxNativeFontInfo
 405 // ----------------------------------------------------------------------------
 406
 407 // Up to now, there are no native implementations of this function:
 408 void wxNativeFontInfo::SetFaceName(const wxArrayString &facenames)
 409 {
 410     for (size_t i=0; i < facenames.GetCount(); i++)
 411     {
 412         if (wxFontEnumerator::IsValidFacename(facenames[i]))
 413         {
 414             SetFaceName(facenames[i]);
 415             return;
 416         }
 417     }
 418
 419     // set the first valid facename we can find on this system
 420     wxString validfacename = wxFontEnumerator::GetFacenames().Item(0);
 421     wxLogTrace(wxT("font"), wxT("Falling back to '%s'"), validfacename.c_str());
 422     SetFaceName(validfacename);
 423 }
 424
 425
 426 #ifdef wxNO_NATIVE_FONTINFO
 427
 428 // These are the generic forms of FromString()/ToString.
 429 //
 430 // convert to/from the string representation: format is
 431 //      version;pointsize;family;style;weight;underlined;facename;encoding
 432
 433 bool wxNativeFontInfo::FromString(const wxString& s)
 434 {
 435     long l;
 436
 437     wxStringTokenizer tokenizer(s, _T(";"));
 438
 439     wxString token = tokenizer.GetNextToken();
 440     //
 441     //  Ignore the version for now
 442     //
 443
 444     token = tokenizer.GetNextToken();
 445     if ( !token.ToLong(&l) )
 446         return false;
 447     pointSize = (int)l;
 448
 449     token = tokenizer.GetNextToken();
 450     if ( !token.ToLong(&l) )
 451         return false;
 452     family = (wxFontFamily)l;
 453
 454     token = tokenizer.GetNextToken();
 455     if ( !token.ToLong(&l) )
 456         return false;
 457     style = (wxFontStyle)l;
 458
 459     token = tokenizer.GetNextToken();
 460     if ( !token.ToLong(&l) )
 461         return false;
 462     weight = (wxFontWeight)l;
 463
 464     token = tokenizer.GetNextToken();
 465     if ( !token.ToLong(&l) )
 466         return false;
 467     underlined = l != 0;
 468
 469     faceName = tokenizer.GetNextToken();
 470
 471 #ifndef __WXMAC__
 472     if( !faceName )
 473         return false;
 474 #endif
 475
 476     token = tokenizer.GetNextToken();
 477     if ( !token.ToLong(&l) )
 478         return false;
 479     encoding = (wxFontEncoding)l;
 480
 481     return true;
 482 }
 483
 484 wxString wxNativeFontInfo::ToString() const
 485 {
 486     wxString s;
 487
 488     s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
 489              0,                                 // version
 490              pointSize,
 491              family,
 492              (int)style,
 493              (int)weight,
 494              underlined,
 495              faceName.GetData(),
 496              (int)encoding);
 497
 498     return s;
 499 }
 500
 501 void wxNativeFontInfo::Init()
 502 {
 503     pointSize = 0;
 504     family = wxFONTFAMILY_DEFAULT;
 505     style = wxFONTSTYLE_NORMAL;
 506     weight = wxFONTWEIGHT_NORMAL;
 507     underlined = false;
 508     faceName.clear();
 509     encoding = wxFONTENCODING_DEFAULT;
 510 }
 511
 512 int wxNativeFontInfo::GetPointSize() const
 513 {
 514     return pointSize;
 515 }
 516
 517 wxFontStyle wxNativeFontInfo::GetStyle() const
 518 {
 519     return style;
 520 }
 521
 522 wxFontWeight wxNativeFontInfo::GetWeight() const
 523 {
 524     return weight;
 525 }
 526
 527 bool wxNativeFontInfo::GetUnderlined() const
 528 {
 529     return underlined;
 530 }
 531
 532 wxString wxNativeFontInfo::GetFaceName() const
 533 {
 534     return faceName;
 535 }
 536
 537 wxFontFamily wxNativeFontInfo::GetFamily() const
 538 {
 539     return family;
 540 }
 541
 542 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 543 {
 544     return encoding;
 545 }
 546
 547 void wxNativeFontInfo::SetPointSize(int pointsize)
 548 {
 549     pointSize = pointsize;
 550 }
 551
 552 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
 553 {
 554     style = style_;
 555 }
 556
 557 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
 558 {
 559     weight = weight_;
 560 }
 561
 562 void wxNativeFontInfo::SetUnderlined(bool underlined_)
 563 {
 564     underlined = underlined_;
 565 }
 566
 567 bool wxNativeFontInfo::SetFaceName(const wxString& facename_)
 568 {
 569     faceName = facename_;
 570     return true;
 571 }
 572
 573 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
 574 {
 575     family = family_;
 576 }
 577
 578 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
 579 {
 580     encoding = encoding_;
 581 }
 582
 583 #endif // generic wxNativeFontInfo implementation
 584
 585 // conversion to/from user-readable string: this is used in the generic
 586 // versions and under MSW as well because there is no standard font description
 587 // format there anyhow (but there is a well-defined standard for X11 fonts used
 588 // by wxGTK and wxMotif)
 589
 590 #if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__)
 591
 592 wxString wxNativeFontInfo::ToUserString() const
 593 {
 594     wxString desc;
 595
 596     // first put the adjectives, if any - this is English-centric, of course,
 597     // but what else can we do?
 598     if ( GetUnderlined() )
 599     {
 600         desc << _("underlined");
 601     }
 602
 603     switch ( GetWeight() )
 604     {
 605         default:
 606             wxFAIL_MSG( _T("unknown font weight") );
 607             // fall through
 608
 609         case wxFONTWEIGHT_NORMAL:
 610             break;
 611
 612         case wxFONTWEIGHT_LIGHT:
 613             desc << _(" light");
 614             break;
 615
 616         case wxFONTWEIGHT_BOLD:
 617             desc << _(" bold");
 618             break;
 619     }
 620
 621     switch ( GetStyle() )
 622     {
 623         default:
 624             wxFAIL_MSG( _T("unknown font style") );
 625             // fall through
 626
 627         case wxFONTSTYLE_NORMAL:
 628             break;
 629
 630             // we don't distinguish between the two for now anyhow...
 631         case wxFONTSTYLE_ITALIC:
 632         case wxFONTSTYLE_SLANT:
 633             desc << _(" italic");
 634             break;
 635     }
 636
 637     wxString face = GetFaceName();
 638     if ( !face.empty() )
 639     {
 640         desc << _T(' ') << face;
 641     }
 642
 643     int size = GetPointSize();
 644     if ( size != wxNORMAL_FONT->GetPointSize() )
 645     {
 646         desc << _T(' ') << size;
 647     }
 648
 649 #if wxUSE_FONTMAP
 650     wxFontEncoding enc = GetEncoding();
 651     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
 652     {
 653         desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
 654     }
 655 #endif // wxUSE_FONTMAP
 656
 657     return desc.Strip(wxString::both).MakeLower();
 658 }
 659
 660 bool wxNativeFontInfo::FromUserString(const wxString& s)
 661 {
 662     // reset to the default state
 663     Init();
 664
 665     // parse a more or less free form string
 666     //
 667     // TODO: we should handle at least the quoted facenames
 668     wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK);
 669
 670     wxString face;
 671     unsigned long size;
 672     bool weightfound = false, pointsizefound = false;
 673 #if wxUSE_FONTMAP
 674     bool encodingfound = false;
 675 #endif
 676
 677     while ( tokenizer.HasMoreTokens() )
 678     {
 679         wxString token = tokenizer.GetNextToken();
 680
 681         // normalize it
 682         token.Trim(true).Trim(false).MakeLower();
 683
 684         // look for the known tokens
 685         if ( token == _T("underlined") || token == _("underlined") )
 686         {
 687             SetUnderlined(true);
 688         }
 689         else if ( token == _T("light") || token == _("light") )
 690         {
 691             SetWeight(wxFONTWEIGHT_LIGHT);
 692             weightfound = true;
 693         }
 694         else if ( token == _T("bold") || token == _("bold") )
 695         {
 696             SetWeight(wxFONTWEIGHT_BOLD);
 697             weightfound = true;
 698         }
 699         else if ( token == _T("italic") || token == _("italic") )
 700         {
 701             SetStyle(wxFONTSTYLE_ITALIC);
 702         }
 703         else if ( token.ToULong(&size) )
 704         {
 705             SetPointSize(size);
 706             pointsizefound = true;
 707         }
 708         else
 709         {
 710 #if wxUSE_FONTMAP
 711             // try to interpret this as an encoding
 712             wxFontEncoding encoding = wxFontMapper::Get()->CharsetToEncoding(token, false);
 713             if ( encoding != wxFONTENCODING_DEFAULT &&
 714                  encoding != wxFONTENCODING_SYSTEM )    // returned when the recognition failed
 715         {
 716             SetEncoding(encoding);
 717                 encodingfound = true;
 718         }
 719             else
 720         {
 721 #endif // wxUSE_FONTMAP
 722
 723                 // assume it is the face name
 724             if ( !face.empty() )
 725             {
 726                 face += _T(' ');
 727             }
 728
 729             face += token;
 730
 731             // skip the code which resets face below
 732             continue;
 733
 734 #if wxUSE_FONTMAP
 735         }
 736 #endif // wxUSE_FONTMAP
 737         }
 738
 739         // if we had had the facename, we shouldn't continue appending tokens
 740         // to it (i.e. "foo bold bar" shouldn't result in the facename "foo
 741         // bar")
 742         if ( !face.empty() )
 743         {
 744             // NB: the check on the facename is implemented in wxFontBase::SetFaceName
 745             //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
 746             //     call here wxFontEnumerator::IsValidFacename
 747             if (!wxFontEnumerator::IsValidFacename(face) ||
 748                 !SetFaceName(face))
 749                 SetFaceName(wxNORMAL_FONT->GetFaceName());
 750             face.clear();
 751         }
 752     }
 753
 754     // we might not have flushed it inside the loop
 755     if ( !face.empty() )
 756     {
 757         // NB: the check on the facename is implemented in wxFontBase::SetFaceName
 758         //     and not in wxNativeFontInfo::SetFaceName thus we need to explicitely
 759         //     call here wxFontEnumerator::IsValidFacename
 760         if (!wxFontEnumerator::IsValidFacename(face) ||
 761             !SetFaceName(face))
 762             SetFaceName(wxNORMAL_FONT->GetFaceName());
 763     }
 764
 765     // set point size to default value if size was not given
 766     if ( !pointsizefound )
 767         SetPointSize(wxNORMAL_FONT->GetPointSize());
 768
 769     // set font weight to default value if weight was not given
 770     if ( !weightfound )
 771         SetWeight(wxFONTWEIGHT_NORMAL);
 772
 773 #if wxUSE_FONTMAP
 774     // set font encoding to default value if encoding was not given
 775     if ( !encodingfound )
 776         SetEncoding(wxFONTENCODING_SYSTEM);
 777 #endif // wxUSE_FONTMAP
 778
 779     return true;
 780 }
 781
 782 #endif // generic or wxMSW or wxOS2