1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/fontcmn.cpp
3 // Purpose: implementation of wxFontBase methods
4 // Author: Vadim Zeitlin
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
32 #include "wx/dcscreen.h"
34 #include "wx/gdicmn.h"
37 #if defined(__WXMSW__)
38 #include "wx/msw/private.h" // includes windows.h for LOGFONT
39 #include "wx/msw/winundef.h"
42 #include "wx/fontutil.h" // for wxNativeFontInfo
43 #include "wx/fontmap.h"
44 #include "wx/fontenum.h"
46 #include "wx/tokenzr.h"
48 // ============================================================================
50 // ============================================================================
52 // ----------------------------------------------------------------------------
54 // ----------------------------------------------------------------------------
56 static void AdjustFontSize(wxFont
& font
, wxDC
& dc
, const wxSize
& pixelSize
)
62 bool initialGoodFound
= false;
63 bool initialBadFound
= false;
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)
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()))
78 largestGood
= currentSize
;
79 initialGoodFound
= true;
83 smallestBad
= currentSize
;
84 initialBadFound
= true;
86 if (!initialGoodFound
)
90 else if (!initialBadFound
)
96 int distance
= smallestBad
- largestGood
;
100 currentSize
= largestGood
+ distance
/ 2;
103 font
.SetPointSize(currentSize
);
106 if (currentSize
!= largestGood
)
107 font
.SetPointSize(largestGood
);
110 // ----------------------------------------------------------------------------
112 // ----------------------------------------------------------------------------
114 wxFontEncoding
wxFontBase::ms_encodingDefault
= wxFONTENCODING_SYSTEM
;
117 void wxFontBase::SetDefaultEncoding(wxFontEncoding encoding
)
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") );
124 ms_encodingDefault
= encoding
;
127 wxFontBase::~wxFontBase()
129 // this destructor is required for Darwin
133 wxFont
*wxFontBase::New(int size
,
138 const wxString
& face
,
139 wxFontEncoding encoding
)
141 return new wxFont(size
, family
, style
, weight
, underlined
, face
, encoding
);
144 static inline int flags2Style(int flags
)
146 return flags
& wxFONTFLAG_ITALIC
148 : flags
& wxFONTFLAG_SLANT
150 : wxFONTSTYLE_NORMAL
;
153 static inline int flags2Weight(int flags
)
155 return flags
& wxFONTFLAG_LIGHT
157 : flags
& wxFONTFLAG_BOLD
159 : wxFONTWEIGHT_NORMAL
;
162 static inline bool flags2Underlined(int flags
)
164 return (flags
& wxFONTFLAG_UNDERLINED
) != 0;
168 wxFont
*wxFontBase::New(int pointSize
,
171 const wxString
& face
,
172 wxFontEncoding encoding
)
174 return New(pointSize
, family
, flags2Style(flags
), flags2Weight(flags
),
175 flags2Underlined(flags
), face
, encoding
);
179 wxFont
*wxFontBase::New(const wxSize
& pixelSize
,
184 const wxString
& face
,
185 wxFontEncoding encoding
)
187 #if defined(__WXMSW__)
188 return new wxFont(pixelSize
, family
, style
, weight
, underlined
,
191 wxFont
*self
= New(10, family
, style
, weight
, underlined
, face
, encoding
);
193 AdjustFontSize(*(wxFont
*)self
, dc
, pixelSize
);
199 wxFont
*wxFontBase::New(const wxSize
& pixelSize
,
202 const wxString
& face
,
203 wxFontEncoding encoding
)
205 return New(pixelSize
, family
, flags2Style(flags
), flags2Weight(flags
),
206 flags2Underlined(flags
), face
, encoding
);
209 wxSize
wxFontBase::GetPixelSize() const
212 dc
.SetFont(*(wxFont
*)this);
213 return wxSize(dc
.GetCharWidth(), dc
.GetCharHeight());
216 bool wxFontBase::IsUsingSizeInPixels() const
221 void wxFontBase::SetPixelSize( const wxSize
& pixelSize
)
224 AdjustFontSize(*(wxFont
*)this, dc
, pixelSize
);
228 wxFont
*wxFontBase::New(const wxNativeFontInfo
& info
)
230 return new wxFont(info
);
234 wxFont
*wxFontBase::New(const wxString
& strNativeFontDesc
)
236 wxNativeFontInfo fontInfo
;
237 if ( !fontInfo
.FromString(strNativeFontDesc
) )
238 return new wxFont(*wxNORMAL_FONT
);
240 return New(fontInfo
);
243 bool wxFontBase::IsFixedWidth() const
245 return GetFamily() == wxFONTFAMILY_TELETYPE
;
248 void wxFontBase::DoSetNativeFontInfo(const wxNativeFontInfo
& info
)
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
);
263 wxString
wxFontBase::GetNativeFontInfoDesc() const
266 const wxNativeFontInfo
*fontInfo
= GetNativeFontInfo();
269 fontDesc
= fontInfo
->ToString();
270 wxASSERT_MSG(!fontDesc
.empty(), wxT("This should be a non-empty string!"));
274 wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
280 wxString
wxFontBase::GetNativeFontInfoUserDesc() const
283 const wxNativeFontInfo
*fontInfo
= GetNativeFontInfo();
286 fontDesc
= fontInfo
->ToUserString();
287 wxASSERT_MSG(!fontDesc
.empty(), wxT("This should be a non-empty string!"));
291 wxFAIL_MSG(wxT("Derived class should have created the wxNativeFontInfo!"));
297 bool wxFontBase::SetNativeFontInfo(const wxString
& info
)
299 wxNativeFontInfo fontInfo
;
300 if ( !info
.empty() && fontInfo
.FromString(info
) )
302 SetNativeFontInfo(fontInfo
);
309 bool wxFontBase::SetNativeFontInfoUserDesc(const wxString
& info
)
311 wxNativeFontInfo fontInfo
;
312 if ( !info
.empty() && fontInfo
.FromUserString(info
) )
314 SetNativeFontInfo(fontInfo
);
321 bool wxFontBase::operator==(const wxFont
& font
) const
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
) ||
328 GetPointSize() == font
.GetPointSize() &&
329 // in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
330 // operator==() resulting in infinite recursion so we can't use it
332 #if !defined(__WXGTK__) || defined(__WXGTK20__)
333 GetPixelSize() == font
.GetPixelSize() &&
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()
344 bool wxFontBase::operator!=(const wxFont
& font
) const
346 return !(*this == font
);
349 wxString
wxFontBase::GetFamilyString() const
351 wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
353 switch ( GetFamily() )
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");
365 wxString
wxFontBase::GetStyleString() const
367 wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
369 switch ( GetStyle() )
371 case wxNORMAL
: return wxT("wxNORMAL");
372 case wxSLANT
: return wxT("wxSLANT");
373 case wxITALIC
: return wxT("wxITALIC");
374 default: return wxT("wxDEFAULT");
378 wxString
wxFontBase::GetWeightString() const
380 wxCHECK_MSG( Ok(), wxT("wxDEFAULT"), wxT("invalid font") );
382 switch ( GetWeight() )
384 case wxNORMAL
: return wxT("wxNORMAL");
385 case wxBOLD
: return wxT("wxBOLD");
386 case wxLIGHT
: return wxT("wxLIGHT");
387 default: return wxT("wxDEFAULT");
391 bool wxFontBase::SetFaceName(const wxString
&facename
)
393 if (!wxFontEnumerator::IsValidFacename(facename
))
395 UnRef(); // make Ok() return false
403 // ----------------------------------------------------------------------------
405 // ----------------------------------------------------------------------------
407 // Up to now, there are no native implementations of this function:
408 void wxNativeFontInfo::SetFaceName(const wxArrayString
&facenames
)
410 for (size_t i
=0; i
< facenames
.GetCount(); i
++)
412 if (wxFontEnumerator::IsValidFacename(facenames
[i
]))
414 SetFaceName(facenames
[i
]);
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
);
426 #ifdef wxNO_NATIVE_FONTINFO
428 // These are the generic forms of FromString()/ToString.
430 // convert to/from the string representation: format is
431 // version;pointsize;family;style;weight;underlined;facename;encoding
433 bool wxNativeFontInfo::FromString(const wxString
& s
)
437 wxStringTokenizer
tokenizer(s
, _T(";"));
439 wxString token
= tokenizer
.GetNextToken();
441 // Ignore the version for now
444 token
= tokenizer
.GetNextToken();
445 if ( !token
.ToLong(&l
) )
449 token
= tokenizer
.GetNextToken();
450 if ( !token
.ToLong(&l
) )
452 family
= (wxFontFamily
)l
;
454 token
= tokenizer
.GetNextToken();
455 if ( !token
.ToLong(&l
) )
457 style
= (wxFontStyle
)l
;
459 token
= tokenizer
.GetNextToken();
460 if ( !token
.ToLong(&l
) )
462 weight
= (wxFontWeight
)l
;
464 token
= tokenizer
.GetNextToken();
465 if ( !token
.ToLong(&l
) )
469 faceName
= tokenizer
.GetNextToken();
476 token
= tokenizer
.GetNextToken();
477 if ( !token
.ToLong(&l
) )
479 encoding
= (wxFontEncoding
)l
;
484 wxString
wxNativeFontInfo::ToString() const
488 s
.Printf(_T("%d;%d;%d;%d;%d;%d;%s;%d"),
501 void wxNativeFontInfo::Init()
504 family
= wxFONTFAMILY_DEFAULT
;
505 style
= wxFONTSTYLE_NORMAL
;
506 weight
= wxFONTWEIGHT_NORMAL
;
509 encoding
= wxFONTENCODING_DEFAULT
;
512 int wxNativeFontInfo::GetPointSize() const
517 wxFontStyle
wxNativeFontInfo::GetStyle() const
522 wxFontWeight
wxNativeFontInfo::GetWeight() const
527 bool wxNativeFontInfo::GetUnderlined() const
532 wxString
wxNativeFontInfo::GetFaceName() const
537 wxFontFamily
wxNativeFontInfo::GetFamily() const
542 wxFontEncoding
wxNativeFontInfo::GetEncoding() const
547 void wxNativeFontInfo::SetPointSize(int pointsize
)
549 pointSize
= pointsize
;
552 void wxNativeFontInfo::SetStyle(wxFontStyle style_
)
557 void wxNativeFontInfo::SetWeight(wxFontWeight weight_
)
562 void wxNativeFontInfo::SetUnderlined(bool underlined_
)
564 underlined
= underlined_
;
567 bool wxNativeFontInfo::SetFaceName(const wxString
& facename_
)
569 faceName
= facename_
;
573 void wxNativeFontInfo::SetFamily(wxFontFamily family_
)
578 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding_
)
580 encoding
= encoding_
;
583 #endif // generic wxNativeFontInfo implementation
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)
590 #if defined(wxNO_NATIVE_FONTINFO) || defined(__WXMSW__) || defined (__WXPM__)
592 wxString
wxNativeFontInfo::ToUserString() const
596 // first put the adjectives, if any - this is English-centric, of course,
597 // but what else can we do?
598 if ( GetUnderlined() )
600 desc
<< _("underlined");
603 switch ( GetWeight() )
606 wxFAIL_MSG( _T("unknown font weight") );
609 case wxFONTWEIGHT_NORMAL
:
612 case wxFONTWEIGHT_LIGHT
:
616 case wxFONTWEIGHT_BOLD
:
621 switch ( GetStyle() )
624 wxFAIL_MSG( _T("unknown font style") );
627 case wxFONTSTYLE_NORMAL
:
630 // we don't distinguish between the two for now anyhow...
631 case wxFONTSTYLE_ITALIC
:
632 case wxFONTSTYLE_SLANT
:
633 desc
<< _(" italic");
637 wxString face
= GetFaceName();
640 desc
<< _T(' ') << face
;
643 int size
= GetPointSize();
644 if ( size
!= wxNORMAL_FONT
->GetPointSize() )
646 desc
<< _T(' ') << size
;
650 wxFontEncoding enc
= GetEncoding();
651 if ( enc
!= wxFONTENCODING_DEFAULT
&& enc
!= wxFONTENCODING_SYSTEM
)
653 desc
<< _T(' ') << wxFontMapper::GetEncodingName(enc
);
655 #endif // wxUSE_FONTMAP
657 return desc
.Strip(wxString::both
).MakeLower();
660 bool wxNativeFontInfo::FromUserString(const wxString
& s
)
662 // reset to the default state
665 // parse a more or less free form string
667 // TODO: we should handle at least the quoted facenames
668 wxStringTokenizer
tokenizer(s
, _T(";, "), wxTOKEN_STRTOK
);
672 bool weightfound
= false, pointsizefound
= false;
674 bool encodingfound
= false;
677 while ( tokenizer
.HasMoreTokens() )
679 wxString token
= tokenizer
.GetNextToken();
682 token
.Trim(true).Trim(false).MakeLower();
684 // look for the known tokens
685 if ( token
== _T("underlined") || token
== _("underlined") )
689 else if ( token
== _T("light") || token
== _("light") )
691 SetWeight(wxFONTWEIGHT_LIGHT
);
694 else if ( token
== _T("bold") || token
== _("bold") )
696 SetWeight(wxFONTWEIGHT_BOLD
);
699 else if ( token
== _T("italic") || token
== _("italic") )
701 SetStyle(wxFONTSTYLE_ITALIC
);
703 else if ( token
.ToULong(&size
) )
706 pointsizefound
= true;
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
716 SetEncoding(encoding
);
717 encodingfound
= true;
721 #endif // wxUSE_FONTMAP
723 // assume it is the face name
731 // skip the code which resets face below
736 #endif // wxUSE_FONTMAP
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
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
) ||
749 SetFaceName(wxNORMAL_FONT
->GetFaceName());
754 // we might not have flushed it inside the loop
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
) ||
762 SetFaceName(wxNORMAL_FONT
->GetFaceName());
765 // set point size to default value if size was not given
766 if ( !pointsizefound
)
767 SetPointSize(wxNORMAL_FONT
->GetPointSize());
769 // set font weight to default value if weight was not given
771 SetWeight(wxFONTWEIGHT_NORMAL
);
774 // set font encoding to default value if encoding was not given
775 if ( !encodingfound
)
776 SetEncoding(wxFONTENCODING_SYSTEM
);
777 #endif // wxUSE_FONTMAP
782 #endif // generic or wxMSW or wxOS2