1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/font.cpp
3 // Purpose: wxFont class
4 // Author: Julian Smart
8 // Copyright: (c) wxWindows team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "font.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
40 #include "wx/msw/private.h"
42 #include "wx/fontutil.h"
43 #include "wx/fontmap.h"
45 #include "wx/tokenzr.h"
47 IMPLEMENT_DYNAMIC_CLASS(wxFont
, wxGDIObject
)
49 // ----------------------------------------------------------------------------
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
54 // wxFontRefData - the internal description of the font
55 // ----------------------------------------------------------------------------
57 class WXDLLEXPORT wxFontRefData
: public wxGDIRefData
63 Init(-1, wxFONTFAMILY_DEFAULT
, wxFONTSTYLE_NORMAL
, wxFONTWEIGHT_NORMAL
,
64 FALSE
, _T(""), wxFONTENCODING_DEFAULT
);
67 wxFontRefData(int size
,
72 const wxString
& faceName
,
73 wxFontEncoding encoding
)
75 Init(size
, family
, style
, weight
, underlined
, faceName
, encoding
);
78 wxFontRefData(const wxNativeFontInfo
& info
, WXHFONT hFont
= 0)
83 wxFontRefData(const wxFontRefData
& data
)
85 if ( data
.m_nativeFontInfoOk
)
87 Init(data
.m_nativeFontInfo
);
91 Init(data
.m_pointSize
, data
.m_family
, data
.m_style
, data
.m_weight
,
92 data
.m_underlined
, data
.m_faceName
, data
.m_encoding
);
96 virtual ~wxFontRefData();
99 bool Alloc(wxFont
*font
);
103 // all wxFont accessors
104 int GetPointSize() const
106 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetPointSize()
110 int GetFamily() const
117 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetStyle()
121 int GetWeight() const
123 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetWeight()
127 bool GetUnderlined() const
129 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetUnderlined()
133 wxString
GetFaceName() const
136 if ( m_nativeFontInfoOk
)
137 s
= m_nativeFontInfo
.GetFaceName();
144 wxFontEncoding
GetEncoding() const
146 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetEncoding()
150 WXHFONT
GetHFONT() const { return m_hFont
; }
153 void SetPointSize(int pointSize
)
155 if ( m_nativeFontInfoOk
)
156 m_nativeFontInfo
.SetPointSize(pointSize
);
158 m_pointSize
= pointSize
;
161 void SetFamily(int family
)
166 void SetStyle(int style
)
168 if ( m_nativeFontInfoOk
)
169 m_nativeFontInfo
.SetStyle((wxFontStyle
)style
);
174 void SetWeight(int weight
)
176 if ( m_nativeFontInfoOk
)
177 m_nativeFontInfo
.SetWeight((wxFontWeight
)weight
);
182 void SetFaceName(const wxString
& faceName
)
184 if ( m_nativeFontInfoOk
)
185 m_nativeFontInfo
.SetFaceName(faceName
);
187 m_faceName
= faceName
;
190 void SetUnderlined(bool underlined
)
192 if ( m_nativeFontInfoOk
)
193 m_nativeFontInfo
.SetUnderlined(underlined
);
195 m_underlined
= underlined
;
198 void SetEncoding(wxFontEncoding encoding
)
200 if ( m_nativeFontInfoOk
)
201 m_nativeFontInfo
.SetEncoding(encoding
);
203 m_encoding
= encoding
;
206 // native font info tests
207 bool HasNativeFontInfo() const { return m_nativeFontInfoOk
; }
209 const wxNativeFontInfo
& GetNativeFontInfo() const
210 { return m_nativeFontInfo
; }
213 // common part of all ctors
219 const wxString
& faceName
,
220 wxFontEncoding encoding
);
222 void Init(const wxNativeFontInfo
& info
, WXHFONT hFont
= 0);
224 // font characterstics
231 wxFontEncoding m_encoding
;
233 // Windows font handle
237 wxNativeFontInfo m_nativeFontInfo
;
238 bool m_nativeFontInfoOk
;
241 // ============================================================================
243 // ============================================================================
245 // ----------------------------------------------------------------------------
247 // ----------------------------------------------------------------------------
249 void wxFontRefData::Init(int pointSize
,
254 const wxString
& faceName
,
255 wxFontEncoding encoding
)
258 m_pointSize
= pointSize
== -1 ? wxNORMAL_FONT
->GetPointSize() : pointSize
;
262 m_underlined
= underlined
;
263 m_faceName
= faceName
;
264 m_encoding
= encoding
;
268 m_nativeFontInfoOk
= FALSE
;
271 void wxFontRefData::Init(const wxNativeFontInfo
& info
, WXHFONT hFont
)
273 // we don't really need the family, what for?
275 // extract family from pitch-and-family
276 int lfFamily
= info
.lf
.lfPitchAndFamily
;
277 if ( lfFamily
& FIXED_PITCH
)
278 lfFamily
-= FIXED_PITCH
;
279 if ( lfFamily
& VARIABLE_PITCH
)
280 lfFamily
-= VARIABLE_PITCH
;
301 m_family
= wxDECORATIVE
;
309 // hFont may be zero, or it be passed in case we really want to
310 // use the exact font created in the underlying system
311 // (for example where we can't guarantee conversion from HFONT
312 // to LOGFONT back to HFONT)
315 m_nativeFontInfoOk
= TRUE
;
316 m_nativeFontInfo
= info
;
319 wxFontRefData::~wxFontRefData()
324 bool wxFontRefData::Alloc(wxFont
*font
)
326 if ( !m_nativeFontInfoOk
)
328 wxFillLogFont(&m_nativeFontInfo
.lf
, font
);
329 m_nativeFontInfoOk
= TRUE
;
332 HFONT hfont
= ::CreateFontIndirect(&m_nativeFontInfo
.lf
);
335 wxLogLastError(wxT("CreateFont"));
340 m_hFont
= (WXHFONT
)hfont
;
345 void wxFontRefData::Free()
349 if ( !::DeleteObject((HFONT
) m_hFont
) )
351 wxLogLastError(wxT("DeleteObject(font)"));
358 // ----------------------------------------------------------------------------
360 // ----------------------------------------------------------------------------
362 void wxNativeFontInfo::Init()
367 int wxNativeFontInfo::GetPointSize() const
369 // FIXME: using the screen here results in incorrect font size calculation
371 const int ppInch
= ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY
);
373 return (int) (((72.0*(double)abs(lf
.lfHeight
)) / (double) ppInch
) + 0.5);
376 wxFontStyle
wxNativeFontInfo::GetStyle() const
378 return lf
.lfItalic
? wxFONTSTYLE_ITALIC
: wxFONTSTYLE_NORMAL
;
381 wxFontWeight
wxNativeFontInfo::GetWeight() const
383 if ( lf
.lfWeight
<= 300 )
384 return wxFONTWEIGHT_LIGHT
;
386 if ( lf
.lfWeight
>= 600 )
387 return wxFONTWEIGHT_BOLD
;
389 return wxFONTWEIGHT_NORMAL
;
392 bool wxNativeFontInfo::GetUnderlined() const
394 return lf
.lfUnderline
!= 0;
397 wxString
wxNativeFontInfo::GetFaceName() const
399 return lf
.lfFaceName
;
402 wxFontEncoding
wxNativeFontInfo::GetEncoding() const
404 return wxGetFontEncFromCharSet(lf
.lfCharSet
);
407 void wxNativeFontInfo::SetPointSize(int pointsize
)
409 #if wxFONT_SIZE_COMPATIBILITY
410 // Incorrect, but compatible with old wxWindows behaviour
411 lf
.lfHeight
= (pointSize
*ppInch
)/72;
412 #else // wxFONT_SIZE_COMPATIBILITY
413 // FIXME: using the screen here results in incorrect font size calculation
415 const int ppInch
= ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY
);
417 lf
.lfHeight
= -(int)((pointsize
*((double)ppInch
)/72.0) + 0.5);
418 #endif // wxFONT_SIZE_COMPATIBILITY/!wxFONT_SIZE_COMPATIBILITY
421 void wxNativeFontInfo::SetStyle(wxFontStyle style
)
426 wxFAIL_MSG( _T("unknown font style") );
429 case wxFONTSTYLE_NORMAL
:
432 case wxFONTSTYLE_ITALIC
:
433 case wxFONTSTYLE_SLANT
:
439 void wxNativeFontInfo::SetWeight(wxFontWeight weight
)
444 wxFAIL_MSG( _T("unknown font weight") );
447 case wxFONTWEIGHT_NORMAL
:
448 lf
.lfWeight
= FW_NORMAL
;
451 case wxFONTWEIGHT_LIGHT
:
452 lf
.lfWeight
= FW_LIGHT
;
455 case wxFONTWEIGHT_BOLD
:
456 lf
.lfWeight
= FW_BOLD
;
461 void wxNativeFontInfo::SetUnderlined(bool underlined
)
463 lf
.lfUnderline
= underlined
;
466 void wxNativeFontInfo::SetFaceName(wxString facename
)
468 wxStrncpy(lf
.lfFaceName
, facename
, sizeof(lf
.lfFaceName
));
471 void wxNativeFontInfo::SetFamily(wxFontFamily family
)
479 ff_family
= FF_SCRIPT
;
480 facename
= _T("Script");
484 ff_family
= FF_DECORATIVE
;
485 facename
= _T("Old English Text MT");
489 ff_family
= FF_ROMAN
;
490 facename
= _T("Times New Roman");
495 ff_family
= FF_MODERN
;
496 facename
= _T("Courier New");
500 ff_family
= FF_SWISS
;
501 facename
= _T("Arial");
506 ff_family
= FF_SWISS
;
507 facename
= _T("MS Sans Serif");
510 lf
.lfPitchAndFamily
= DEFAULT_PITCH
| ff_family
;
512 if ( !wxStrlen(lf
.lfFaceName
) )
514 SetFaceName(facename
);
518 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding
)
520 wxNativeEncodingInfo info
;
521 if ( !wxGetNativeFontEncoding(encoding
, &info
) )
524 if ( !wxTheFontMapper
->GetAltForEncoding(encoding
, &info
) )
525 #endif // wxUSE_FONTMAP
527 // unsupported encoding, replace with the default
528 info
.charset
= ANSI_CHARSET
;
530 else if ( !info
.facename
.empty() )
532 // if we have this encoding only in some particular facename, use
533 // the facename - it is better to show the correct characters in a
534 // wrong facename than unreadable text in a correct one
535 SetFaceName(info
.facename
);
539 lf
.lfCharSet
= info
.charset
;
542 bool wxNativeFontInfo::FromString(const wxString
& s
)
546 wxStringTokenizer
tokenizer(s
, _T(";"));
549 wxString token
= tokenizer
.GetNextToken();
550 if ( token
!= _T('0') )
553 token
= tokenizer
.GetNextToken();
554 if ( !token
.ToLong(&l
) )
558 token
= tokenizer
.GetNextToken();
559 if ( !token
.ToLong(&l
) )
563 token
= tokenizer
.GetNextToken();
564 if ( !token
.ToLong(&l
) )
568 token
= tokenizer
.GetNextToken();
569 if ( !token
.ToLong(&l
) )
571 lf
.lfOrientation
= l
;
573 token
= tokenizer
.GetNextToken();
574 if ( !token
.ToLong(&l
) )
578 token
= tokenizer
.GetNextToken();
579 if ( !token
.ToLong(&l
) )
581 lf
.lfItalic
= (BYTE
)l
;
583 token
= tokenizer
.GetNextToken();
584 if ( !token
.ToLong(&l
) )
586 lf
.lfUnderline
= (BYTE
)l
;
588 token
= tokenizer
.GetNextToken();
589 if ( !token
.ToLong(&l
) )
591 lf
.lfStrikeOut
= (BYTE
)l
;
593 token
= tokenizer
.GetNextToken();
594 if ( !token
.ToLong(&l
) )
596 lf
.lfCharSet
= (BYTE
)l
;
598 token
= tokenizer
.GetNextToken();
599 if ( !token
.ToLong(&l
) )
601 lf
.lfOutPrecision
= (BYTE
)l
;
603 token
= tokenizer
.GetNextToken();
604 if ( !token
.ToLong(&l
) )
606 lf
.lfClipPrecision
= (BYTE
)l
;
608 token
= tokenizer
.GetNextToken();
609 if ( !token
.ToLong(&l
) )
611 lf
.lfQuality
= (BYTE
)l
;
613 token
= tokenizer
.GetNextToken();
614 if ( !token
.ToLong(&l
) )
616 lf
.lfPitchAndFamily
= (BYTE
)l
;
618 token
= tokenizer
.GetNextToken();
621 wxStrcpy(lf
.lfFaceName
, token
.c_str());
626 wxString
wxNativeFontInfo::ToString() const
630 s
.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
631 0, // version, in case we want to change the format later
650 // ----------------------------------------------------------------------------
652 // ----------------------------------------------------------------------------
658 bool wxFont::Create(const wxNativeFontInfo
& info
, WXHFONT hFont
)
662 m_refData
= new wxFontRefData(info
, hFont
);
669 wxFont::wxFont(const wxString
& fontdesc
)
671 wxNativeFontInfo info
;
672 if ( info
.FromString(fontdesc
) )
676 /* Constructor for a font. Note that the real construction is done
677 * in wxDC::SetFont, when information is available about scaling etc.
679 bool wxFont::Create(int pointSize
,
684 const wxString
& faceName
,
685 wxFontEncoding encoding
)
689 // wxDEFAULT is a valid value for the font size too so we must treat it
690 // specially here (otherwise the size would be 70 == wxDEFAULT value)
691 if ( pointSize
== wxDEFAULT
)
693 pointSize
= wxNORMAL_FONT
->GetPointSize();
696 m_refData
= new wxFontRefData(pointSize
, family
, style
, weight
,
697 underlined
, faceName
, encoding
);
708 // ----------------------------------------------------------------------------
709 // real implementation
710 // ----------------------------------------------------------------------------
712 bool wxFont::RealizeResource()
714 if ( GetResourceHandle() )
716 // VZ: the old code returned FALSE in this case, but it doesn't seem
717 // to make sense because the font _was_ created
721 return M_FONTDATA
->Alloc(this);
724 bool wxFont::FreeResource(bool WXUNUSED(force
))
726 if ( GetResourceHandle() )
736 WXHANDLE
wxFont::GetResourceHandle()
741 WXHFONT
wxFont::GetHFONT() const
743 return M_FONTDATA
? M_FONTDATA
->GetHFONT() : 0;
746 bool wxFont::IsFree() const
748 return M_FONTDATA
&& (M_FONTDATA
->GetHFONT() == 0);
751 void wxFont::Unshare()
753 // Don't change shared data
756 m_refData
= new wxFontRefData();
760 wxFontRefData
* ref
= new wxFontRefData(*M_FONTDATA
);
766 // ----------------------------------------------------------------------------
767 // change font attribute: we recreate font when doing it
768 // ----------------------------------------------------------------------------
770 void wxFont::SetPointSize(int pointSize
)
774 M_FONTDATA
->SetPointSize(pointSize
);
779 void wxFont::SetFamily(int family
)
783 M_FONTDATA
->SetFamily(family
);
788 void wxFont::SetStyle(int style
)
792 M_FONTDATA
->SetStyle(style
);
797 void wxFont::SetWeight(int weight
)
801 M_FONTDATA
->SetWeight(weight
);
806 void wxFont::SetFaceName(const wxString
& faceName
)
810 M_FONTDATA
->SetFaceName(faceName
);
815 void wxFont::SetUnderlined(bool underlined
)
819 M_FONTDATA
->SetUnderlined(underlined
);
824 void wxFont::SetEncoding(wxFontEncoding encoding
)
828 M_FONTDATA
->SetEncoding(encoding
);
833 void wxFont::SetNativeFontInfo(const wxNativeFontInfo
& info
)
839 *M_FONTDATA
= wxFontRefData(info
);
844 // ----------------------------------------------------------------------------
846 // ----------------------------------------------------------------------------
848 int wxFont::GetPointSize() const
850 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
852 return M_FONTDATA
->GetPointSize();
855 int wxFont::GetFamily() const
857 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
859 return M_FONTDATA
->GetFamily();
862 int wxFont::GetStyle() const
864 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
866 return M_FONTDATA
->GetStyle();
869 int wxFont::GetWeight() const
871 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
873 return M_FONTDATA
->GetWeight();
876 bool wxFont::GetUnderlined() const
878 wxCHECK_MSG( Ok(), FALSE
, wxT("invalid font") );
880 return M_FONTDATA
->GetUnderlined();
883 wxString
wxFont::GetFaceName() const
885 wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
887 return M_FONTDATA
->GetFaceName();
890 wxFontEncoding
wxFont::GetEncoding() const
892 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
894 return M_FONTDATA
->GetEncoding();
897 wxNativeFontInfo
*wxFont::GetNativeFontInfo() const
899 if ( M_FONTDATA
->HasNativeFontInfo() )
900 return new wxNativeFontInfo(M_FONTDATA
->GetNativeFontInfo());