src/common/fontcmn.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21 #pragma implementation "fontbase.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28 #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/dc.h"
  33     #include "wx/font.h"
  34     #include "wx/intl.h"
  35     #include "wx/dcscreen.h"
  36 #endif // WX_PRECOMP
  37
  38 #include "wx/gdicmn.h"
  39
  40 #if defined(__WXMSW__)
  41   #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
  42   #include  "wx/msw/winundef.h"
  43 #endif
  44
  45 #include "wx/fontutil.h" // for wxNativeFontInfo
  46 #include "wx/fontmap.h"
  47
  48 #include "wx/tokenzr.h"
  49
  50 // ============================================================================
  51 // implementation
  52 // ============================================================================
  53
  54 // ----------------------------------------------------------------------------
  55 // helper functions
  56 // ----------------------------------------------------------------------------
  57
  58 static void AdjustFontSize(wxFont& font, wxDC& dc, const wxSize& pixelSize)
  59 {
  60     int currentSize = font.GetPointSize();
  61     int largestGood = 0;
  62     int smallestBad = 0;
  63
  64     bool initialGoodFound = false;
  65     bool initialBadFound = false;
  66
  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                         int family,
 134                         int style,
 135                         int 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                         int family,
 180                         int style,
 181                         int 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     }
 270
 271     return fontDesc;
 272 }
 273
 274 wxString wxFontBase::GetNativeFontInfoUserDesc() const
 275 {
 276     wxString fontDesc;
 277     const wxNativeFontInfo *fontInfo = GetNativeFontInfo();
 278     if ( fontInfo )
 279     {
 280         fontDesc = fontInfo->ToUserString();
 281     }
 282
 283     return fontDesc;
 284 }
 285
 286 void wxFontBase::SetNativeFontInfo(const wxString& info)
 287 {
 288     wxNativeFontInfo fontInfo;
 289     if ( !info.empty() && fontInfo.FromString(info) )
 290     {
 291         SetNativeFontInfo(fontInfo);
 292     }
 293 }
 294
 295 void wxFontBase::SetNativeFontInfoUserDesc(const wxString& info)
 296 {
 297     wxNativeFontInfo fontInfo;
 298     if ( !info.empty() && fontInfo.FromUserString(info) )
 299     {
 300         SetNativeFontInfo(fontInfo);
 301     }
 302 }
 303
 304 wxFont& wxFont::operator=(const wxFont& font)
 305 {
 306     if ( this != &font )
 307         Ref(font);
 308
 309     return (wxFont &)*this;
 310 }
 311
 312 bool wxFontBase::operator==(const wxFont& font) const
 313 {
 314     // either it is the same font, i.e. they share the same common data or they
 315     // have different ref datas but still describe the same font
 316     return GetFontData() == font.GetFontData() ||
 317            (
 318             Ok() == font.Ok() &&
 319             GetPointSize() == font.GetPointSize() &&
 320             GetFamily() == font.GetFamily() &&
 321             GetStyle() == font.GetStyle() &&
 322             GetWeight() == font.GetWeight() &&
 323             GetUnderlined() == font.GetUnderlined() &&
 324             GetFaceName() == font.GetFaceName() &&
 325             GetEncoding() == font.GetEncoding()
 326            );
 327 }
 328
 329 bool wxFontBase::operator!=(const wxFont& font) const
 330 {
 331     return !(*this == font);
 332 }
 333
 334 wxString wxFontBase::GetFamilyString() const
 335 {
 336     wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
 337
 338     switch ( GetFamily() )
 339     {
 340         case wxDECORATIVE:   return wxT("wxDECORATIVE");
 341         case wxROMAN:        return wxT("wxROMAN");
 342         case wxSCRIPT:       return wxT("wxSCRIPT");
 343         case wxSWISS:        return wxT("wxSWISS");
 344         case wxMODERN:       return wxT("wxMODERN");
 345         case wxTELETYPE:     return wxT("wxTELETYPE");
 346         default:             return wxT("wxDEFAULT");
 347     }
 348 }
 349
 350 wxString wxFontBase::GetStyleString() const
 351 {
 352     wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
 353
 354     switch ( GetStyle() )
 355     {
 356         case wxNORMAL:   return wxT("wxNORMAL");
 357         case wxSLANT:    return wxT("wxSLANT");
 358         case wxITALIC:   return wxT("wxITALIC");
 359         default:         return wxT("wxDEFAULT");
 360     }
 361 }
 362
 363 wxString wxFontBase::GetWeightString() const
 364 {
 365     wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
 366
 367     switch ( GetWeight() )
 368     {
 369         case wxNORMAL:   return wxT("wxNORMAL");
 370         case wxBOLD:     return wxT("wxBOLD");
 371         case wxLIGHT:    return wxT("wxLIGHT");
 372         default:         return wxT("wxDEFAULT");
 373     }
 374 }
 375
 376 // ----------------------------------------------------------------------------
 377 // wxNativeFontInfo
 378 // ----------------------------------------------------------------------------
 379
 380 #ifdef wxNO_NATIVE_FONTINFO
 381
 382 // These are the generic forms of FromString()/ToString.
 383 //
 384 // convert to/from the string representation: format is
 385 //      version;pointsize;family;style;weight;underlined;facename;encoding
 386
 387 bool wxNativeFontInfo::FromString(const wxString& s)
 388 {
 389     long l;
 390
 391     wxStringTokenizer tokenizer(s, _T(";"));
 392
 393     wxString token = tokenizer.GetNextToken();
 394     //
 395     //  Ignore the version for now
 396     //
 397
 398     token = tokenizer.GetNextToken();
 399     if ( !token.ToLong(&l) )
 400         return false;
 401     pointSize = (int)l;
 402
 403     token = tokenizer.GetNextToken();
 404     if ( !token.ToLong(&l) )
 405         return false;
 406     family = (wxFontFamily)l;
 407
 408     token = tokenizer.GetNextToken();
 409     if ( !token.ToLong(&l) )
 410         return false;
 411     style = (wxFontStyle)l;
 412
 413     token = tokenizer.GetNextToken();
 414     if ( !token.ToLong(&l) )
 415         return false;
 416     weight = (wxFontWeight)l;
 417
 418     token = tokenizer.GetNextToken();
 419     if ( !token.ToLong(&l) )
 420         return false;
 421     underlined = l != 0;
 422
 423     faceName = tokenizer.GetNextToken();
 424
 425 #ifndef __WXMAC__
 426     if( !faceName )
 427         return false;
 428 #endif
 429
 430     token = tokenizer.GetNextToken();
 431     if ( !token.ToLong(&l) )
 432         return false;
 433     encoding = (wxFontEncoding)l;
 434
 435     return true;
 436 }
 437
 438 wxString wxNativeFontInfo::ToString() const
 439 {
 440     wxString s;
 441
 442     s.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
 443              0,                                 // version
 444              pointSize,
 445              family,
 446              (int)style,
 447              (int)weight,
 448              underlined,
 449              faceName.GetData(),
 450              (int)encoding);
 451
 452     return s;
 453 }
 454
 455 void wxNativeFontInfo::Init()
 456 {
 457     pointSize = 0;
 458     family = wxFONTFAMILY_DEFAULT;
 459     style = wxFONTSTYLE_NORMAL;
 460     weight = wxFONTWEIGHT_NORMAL;
 461     underlined = false;
 462     faceName.clear();
 463     encoding = wxFONTENCODING_DEFAULT;
 464 }
 465
 466 int wxNativeFontInfo::GetPointSize() const
 467 {
 468     return pointSize;
 469 }
 470
 471 wxFontStyle wxNativeFontInfo::GetStyle() const
 472 {
 473     return style;
 474 }
 475
 476 wxFontWeight wxNativeFontInfo::GetWeight() const
 477 {
 478     return weight;
 479 }
 480
 481 bool wxNativeFontInfo::GetUnderlined() const
 482 {
 483     return underlined;
 484 }
 485
 486 wxString wxNativeFontInfo::GetFaceName() const
 487 {
 488     return faceName;
 489 }
 490
 491 wxFontFamily wxNativeFontInfo::GetFamily() const
 492 {
 493     return family;
 494 }
 495
 496 wxFontEncoding wxNativeFontInfo::GetEncoding() const
 497 {
 498     return encoding;
 499 }
 500
 501 void wxNativeFontInfo::SetPointSize(int pointsize)
 502 {
 503     pointSize = pointsize;
 504 }
 505
 506 void wxNativeFontInfo::SetStyle(wxFontStyle style_)
 507 {
 508     style = style_;
 509 }
 510
 511 void wxNativeFontInfo::SetWeight(wxFontWeight weight_)
 512 {
 513     weight = weight_;
 514 }
 515
 516 void wxNativeFontInfo::SetUnderlined(bool underlined_)
 517 {
 518     underlined = underlined_;
 519 }
 520
 521 void wxNativeFontInfo::SetFaceName(wxString facename_)
 522 {
 523     faceName = facename_;
 524 }
 525
 526 void wxNativeFontInfo::SetFamily(wxFontFamily family_)
 527 {
 528     family = family_;
 529 }
 530
 531 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_)
 532 {
 533     encoding = encoding_;
 534 }
 535
 536 #endif // generic wxNativeFontInfo implementation
 537
 538 // conversion to/from user-readable string: this is used in the generic
 539 // versions and under MSW as well because there is no standard font description
 540 // format there anyhow (but there is a well-defined standard for X11 fonts used
 541 // by wxGTK and wxMotif)
 542
 543 #if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__)
 544
 545 wxString wxNativeFontInfo::ToUserString() const
 546 {
 547     wxString desc;
 548
 549     // first put the adjectives, if any - this is English-centric, of course,
 550     // but what else can we do?
 551     if ( GetUnderlined() )
 552     {
 553         desc << _("underlined ");
 554     }
 555
 556     switch ( GetWeight() )
 557     {
 558         default:
 559             wxFAIL_MSG( _T("unknown font weight") );
 560             // fall through
 561
 562         case wxFONTWEIGHT_NORMAL:
 563             break;
 564
 565         case wxFONTWEIGHT_LIGHT:
 566             desc << _("light ");
 567             break;
 568
 569         case wxFONTWEIGHT_BOLD:
 570             desc << _("bold ");
 571             break;
 572     }
 573
 574     switch ( GetStyle() )
 575     {
 576         default:
 577             wxFAIL_MSG( _T("unknown font style") );
 578             // fall through
 579
 580         case wxFONTSTYLE_NORMAL:
 581             break;
 582
 583             // we don't distinguish between the two for now anyhow...
 584         case wxFONTSTYLE_ITALIC:
 585         case wxFONTSTYLE_SLANT:
 586             desc << _("italic");
 587             break;
 588     }
 589
 590     wxString face = GetFaceName();
 591     if ( !face.empty() )
 592     {
 593         desc << _T(' ') << face;
 594     }
 595
 596     int size = GetPointSize();
 597     if ( size != wxNORMAL_FONT->GetPointSize() )
 598     {
 599         desc << _T(' ') << size;
 600     }
 601
 602 #if wxUSE_FONTMAP
 603     wxFontEncoding enc = GetEncoding();
 604     if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
 605     {
 606         desc << _T(' ') << wxFontMapper::GetEncodingName(enc);
 607     }
 608 #endif // wxUSE_FONTMAP
 609
 610     return desc;
 611 }
 612
 613 bool wxNativeFontInfo::FromUserString(const wxString& s)
 614 {
 615     // reset to the default state
 616     Init();
 617
 618     // parse a more or less free form string
 619     //
 620     // TODO: we should handle at least the quoted facenames
 621     wxStringTokenizer tokenizer(s, _T(";, "), wxTOKEN_STRTOK);
 622
 623     wxString face;
 624     unsigned long size;
 625
 626 #if wxUSE_FONTMAP
 627     wxFontEncoding encoding;
 628 #endif // wxUSE_FONTMAP
 629
 630     while ( tokenizer.HasMoreTokens() )
 631     {
 632         wxString token = tokenizer.GetNextToken();
 633
 634         // normalize it
 635         token.Trim(true).Trim(false).MakeLower();
 636
 637         // look for the known tokens
 638         if ( token == _T("underlined") || token == _("underlined") )
 639         {
 640             SetUnderlined(true);
 641         }
 642         else if ( token == _T("light") || token == _("light") )
 643         {
 644             SetWeight(wxFONTWEIGHT_LIGHT);
 645         }
 646         else if ( token == _T("bold") || token == _("bold") )
 647         {
 648             SetWeight(wxFONTWEIGHT_BOLD);
 649         }
 650         else if ( token == _T("italic") || token == _("italic") )
 651         {
 652             SetStyle(wxFONTSTYLE_ITALIC);
 653         }
 654         else if ( token.ToULong(&size) )
 655         {
 656             SetPointSize(size);
 657         }
 658 #if wxUSE_FONTMAP
 659         else if ( (encoding = wxFontMapper::Get()->CharsetToEncoding(token, false))
 660                     != wxFONTENCODING_DEFAULT )
 661         {
 662             SetEncoding(encoding);
 663         }
 664 #endif // wxUSE_FONTMAP
 665         else // assume it is the face name
 666         {
 667             if ( !face.empty() )
 668             {
 669                 face += _T(' ');
 670             }
 671
 672             face += token;
 673
 674             // skip the code which resets face below
 675             continue;
 676         }
 677
 678         // if we had had the facename, we shouldn't continue appending tokens
 679         // to it (i.e. "foo bold bar" shouldn't result in the facename "foo
 680         // bar")
 681         if ( !face.empty() )
 682         {
 683             SetFaceName(face);
 684             face.clear();
 685         }
 686     }
 687
 688     // we might not have flushed it inside the loop
 689     if ( !face.empty() )
 690     {
 691         SetFaceName(face);
 692     }
 693
 694     return true;
 695 }
 696
 697 #endif // generic or wxMSW or wxOS2
 698