1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/font.cpp
3 // Purpose: wxFont class
4 // Author: Julian Smart
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"
34 #include "wx/encinfo.h"
37 #include "wx/msw/private.h"
39 #include "wx/fontutil.h"
40 #include "wx/fontmap.h"
43 #include "wx/sysopt.h"
46 #include "wx/tokenzr.h"
48 #if wxUSE_EXTENDED_RTTI
50 wxBEGIN_ENUM( wxFontFamily
)
51 wxENUM_MEMBER( wxDEFAULT
)
52 wxENUM_MEMBER( wxDECORATIVE
)
53 wxENUM_MEMBER( wxROMAN
)
54 wxENUM_MEMBER( wxSCRIPT
)
55 wxENUM_MEMBER( wxSWISS
)
56 wxENUM_MEMBER( wxMODERN
)
57 wxENUM_MEMBER( wxTELETYPE
)
58 wxEND_ENUM( wxFontFamily
)
60 wxBEGIN_ENUM( wxFontStyle
)
61 wxENUM_MEMBER( wxNORMAL
)
62 wxENUM_MEMBER( wxITALIC
)
63 wxENUM_MEMBER( wxSLANT
)
64 wxEND_ENUM( wxFontStyle
)
66 wxBEGIN_ENUM( wxFontWeight
)
67 wxENUM_MEMBER( wxNORMAL
)
68 wxENUM_MEMBER( wxLIGHT
)
69 wxENUM_MEMBER( wxBOLD
)
70 wxEND_ENUM( wxFontWeight
)
72 IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI(wxFont
, wxGDIObject
,"wx/font.h")
74 wxBEGIN_PROPERTIES_TABLE(wxFont
)
75 wxPROPERTY( Size
,int, SetPointSize
, GetPointSize
, 12 , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
76 wxPROPERTY( Family
, int , SetFamily
, GetFamily
, (int)wxDEFAULT
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontFamily
77 wxPROPERTY( Style
, int , SetStyle
, GetStyle
, (int)wxNORMAL
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontStyle
78 wxPROPERTY( Weight
, int , SetWeight
, GetWeight
, (int)wxNORMAL
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontWeight
79 wxPROPERTY( Underlined
, bool , SetUnderlined
, GetUnderlined
, false , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
80 wxPROPERTY( Face
, wxString
, SetFaceName
, GetFaceName
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
81 wxPROPERTY( Encoding
, wxFontEncoding
, SetEncoding
, GetEncoding
, wxFONTENCODING_DEFAULT
, 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
82 wxEND_PROPERTIES_TABLE()
84 wxCONSTRUCTOR_6( wxFont
, int , Size
, int , Family
, int , Style
, int , Weight
, bool , Underlined
, wxString
, Face
)
86 wxBEGIN_HANDLERS_TABLE(wxFont
)
87 wxEND_HANDLERS_TABLE()
90 IMPLEMENT_DYNAMIC_CLASS(wxFont
, wxGDIObject
)
94 // ----------------------------------------------------------------------------
96 // ----------------------------------------------------------------------------
98 // the mask used to extract the pitch from LOGFONT::lfPitchAndFamily field
99 static const int PITCH_MASK
= FIXED_PITCH
| VARIABLE_PITCH
;
101 // ----------------------------------------------------------------------------
102 // wxFontRefData - the internal description of the font
103 // ----------------------------------------------------------------------------
105 class WXDLLEXPORT wxFontRefData
: public wxGDIRefData
111 Init(-1, wxSize(0,0), false, wxFONTFAMILY_DEFAULT
, wxFONTSTYLE_NORMAL
,
112 wxFONTWEIGHT_NORMAL
, false, wxEmptyString
,
113 wxFONTENCODING_DEFAULT
);
116 wxFontRefData(int size
,
117 const wxSize
& pixelSize
,
118 bool sizeUsingPixels
,
123 const wxString
& faceName
,
124 wxFontEncoding encoding
)
126 Init(size
, pixelSize
, sizeUsingPixels
, family
, style
, weight
,
127 underlined
, faceName
, encoding
);
130 wxFontRefData(const wxNativeFontInfo
& info
, WXHFONT hFont
= 0)
135 wxFontRefData(const wxFontRefData
& data
) : wxGDIRefData()
137 if ( data
.m_nativeFontInfoOk
)
139 Init(data
.m_nativeFontInfo
);
143 Init(data
.m_pointSize
, data
.m_pixelSize
, data
.m_sizeUsingPixels
,
144 data
.m_family
, data
.m_style
, data
.m_weight
,
145 data
.m_underlined
, data
.m_faceName
, data
.m_encoding
);
149 virtual ~wxFontRefData();
152 bool Alloc(const wxFont
*font
);
156 // all wxFont accessors
157 int GetPointSize() const
159 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetPointSize()
163 wxSize
GetPixelSize() const
165 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetPixelSize()
169 bool IsUsingSizeInPixels() const
171 return m_nativeFontInfoOk
? true : m_sizeUsingPixels
;
174 wxFontFamily
GetFamily() const
179 wxFontStyle
GetStyle() const
181 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetStyle()
185 wxFontWeight
GetWeight() const
187 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetWeight()
191 bool GetUnderlined() const
193 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetUnderlined()
197 wxString
GetFaceName() const
200 if ( m_nativeFontInfoOk
)
201 s
= m_nativeFontInfo
.GetFaceName();
208 wxFontEncoding
GetEncoding() const
210 return m_nativeFontInfoOk
? m_nativeFontInfo
.GetEncoding()
214 WXHFONT
GetHFONT(const wxFont
*font
) const
217 const_cast<wxFontRefData
*>(this)->Alloc(font
);
219 return (WXHFONT
)m_hFont
;
222 bool HasHFONT() const
227 // ... and setters: notice that all of them invalidate the currently
228 // allocated HFONT, if any, so that the next call to GetHFONT() recreates a
230 void SetPointSize(int pointSize
)
234 if ( m_nativeFontInfoOk
)
236 m_nativeFontInfo
.SetPointSize(pointSize
);
240 m_pointSize
= pointSize
;
241 m_sizeUsingPixels
= false;
245 void SetPixelSize(const wxSize
& pixelSize
)
249 if ( m_nativeFontInfoOk
)
251 m_nativeFontInfo
.SetPixelSize(pixelSize
);
255 m_pixelSize
= pixelSize
;
256 m_sizeUsingPixels
= true;
260 void SetFamily(wxFontFamily family
)
267 void SetStyle(wxFontStyle style
)
271 if ( m_nativeFontInfoOk
)
272 m_nativeFontInfo
.SetStyle((wxFontStyle
)style
);
277 void SetWeight(wxFontWeight weight
)
281 if ( m_nativeFontInfoOk
)
282 m_nativeFontInfo
.SetWeight((wxFontWeight
)weight
);
287 bool SetFaceName(const wxString
& faceName
)
291 if ( m_nativeFontInfoOk
)
292 return m_nativeFontInfo
.SetFaceName(faceName
);
294 m_faceName
= faceName
;
298 void SetUnderlined(bool underlined
)
302 if ( m_nativeFontInfoOk
)
303 m_nativeFontInfo
.SetUnderlined(underlined
);
305 m_underlined
= underlined
;
308 void SetEncoding(wxFontEncoding encoding
)
312 if ( m_nativeFontInfoOk
)
313 m_nativeFontInfo
.SetEncoding(encoding
);
315 m_encoding
= encoding
;
319 bool HasNativeFontInfo() const { return m_nativeFontInfoOk
; }
321 const wxNativeFontInfo
& GetNativeFontInfo() const
322 { return m_nativeFontInfo
; }
324 void SetNativeFontInfo(const wxNativeFontInfo
& nativeFontInfo
)
328 m_nativeFontInfo
= nativeFontInfo
;
329 m_nativeFontInfoOk
= true;
333 // common part of all ctors
335 const wxSize
& pixelSize
,
336 bool sizeUsingPixels
,
341 const wxString
& faceName
,
342 wxFontEncoding encoding
);
344 void Init(const wxNativeFontInfo
& info
, WXHFONT hFont
= 0);
346 // font characteristics
349 bool m_sizeUsingPixels
;
350 wxFontFamily m_family
;
352 wxFontWeight m_weight
;
355 wxFontEncoding m_encoding
;
357 // Windows font handle, created on demand in GetHFONT()
361 wxNativeFontInfo m_nativeFontInfo
;
362 bool m_nativeFontInfoOk
;
365 #define M_FONTDATA ((wxFontRefData*)m_refData)
367 // ============================================================================
369 // ============================================================================
371 // ----------------------------------------------------------------------------
373 // ----------------------------------------------------------------------------
375 void wxFontRefData::Init(int pointSize
,
376 const wxSize
& pixelSize
,
377 bool sizeUsingPixels
,
382 const wxString
& faceName
,
383 wxFontEncoding encoding
)
386 m_pointSize
= pointSize
== -1 ? wxNORMAL_FONT
->GetPointSize() : pointSize
;
387 m_pixelSize
= pixelSize
;
388 m_sizeUsingPixels
= sizeUsingPixels
;
392 m_underlined
= underlined
;
393 m_faceName
= faceName
;
394 m_encoding
= encoding
;
398 m_nativeFontInfoOk
= false;
401 void wxFontRefData::Init(const wxNativeFontInfo
& info
, WXHFONT hFont
)
403 // hFont may be zero, or it be passed in case we really want to
404 // use the exact font created in the underlying system
405 // (for example where we can't guarantee conversion from HFONT
406 // to LOGFONT back to HFONT)
407 m_hFont
= (HFONT
)hFont
;
409 m_nativeFontInfoOk
= true;
410 m_nativeFontInfo
= info
;
411 // This is the best we can do since we don't have the
412 // correct information at this point.
413 m_family
= wxFONTFAMILY_SWISS
;
416 wxFontRefData::~wxFontRefData()
421 bool wxFontRefData::Alloc(const wxFont
*font
)
423 if ( !m_nativeFontInfoOk
)
425 wxFillLogFont(&m_nativeFontInfo
.lf
, font
);
426 m_nativeFontInfoOk
= true;
429 m_hFont
= ::CreateFontIndirect(&m_nativeFontInfo
.lf
);
432 wxLogLastError(wxT("CreateFont"));
439 void wxFontRefData::Free()
443 if ( !::DeleteObject(m_hFont
) )
445 wxLogLastError(wxT("DeleteObject(font)"));
452 // ----------------------------------------------------------------------------
454 // ----------------------------------------------------------------------------
456 void wxNativeFontInfo::Init()
460 // we get better font quality if we use PROOF_QUALITY instead of
461 // DEFAULT_QUALITY but some fonts (e.g. "Terminal 6pt") are not available
462 // then so we allow to set a global option to choose between quality and
463 // wider font selection
465 lf
.lfQuality
= CLEARTYPE_QUALITY
;
467 lf
.lfQuality
= wxSystemOptions::GetOptionInt(_T("msw.font.no-proof-quality"))
473 int wxNativeFontInfo::GetPointSize() const
475 // FIXME: using the screen here results in incorrect font size calculation
477 const int ppInch
= ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY
);
479 // BC++ 2007 doesn't provide abs(long) overload, hence the cast
480 return (int) (((72.0*abs((int)lf
.lfHeight
)) / (double) ppInch
) + 0.5);
483 wxSize
wxNativeFontInfo::GetPixelSize() const
486 ret
.SetHeight(abs((int)lf
.lfHeight
));
487 ret
.SetWidth(lf
.lfWidth
);
491 wxFontStyle
wxNativeFontInfo::GetStyle() const
493 return lf
.lfItalic
? wxFONTSTYLE_ITALIC
: wxFONTSTYLE_NORMAL
;
496 wxFontWeight
wxNativeFontInfo::GetWeight() const
498 if ( lf
.lfWeight
<= 300 )
499 return wxFONTWEIGHT_LIGHT
;
501 if ( lf
.lfWeight
>= 600 )
502 return wxFONTWEIGHT_BOLD
;
504 return wxFONTWEIGHT_NORMAL
;
507 bool wxNativeFontInfo::GetUnderlined() const
509 return lf
.lfUnderline
!= 0;
512 wxString
wxNativeFontInfo::GetFaceName() const
514 return lf
.lfFaceName
;
517 wxFontFamily
wxNativeFontInfo::GetFamily() const
521 // extract family from pitch-and-family
522 switch ( lf
.lfPitchAndFamily
& ~PITCH_MASK
)
525 family
= wxFONTFAMILY_ROMAN
;
529 wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") );
533 family
= wxFONTFAMILY_SWISS
;
537 family
= wxFONTFAMILY_SCRIPT
;
541 family
= wxFONTFAMILY_MODERN
;
545 family
= wxFONTFAMILY_DECORATIVE
;
552 wxFontEncoding
wxNativeFontInfo::GetEncoding() const
554 return wxGetFontEncFromCharSet(lf
.lfCharSet
);
557 void wxNativeFontInfo::SetPointSize(int pointsize
)
559 // FIXME: using the screen here results in incorrect font size calculation
561 const int ppInch
= ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY
);
563 lf
.lfHeight
= -(int)((pointsize
*((double)ppInch
)/72.0) + 0.5);
566 void wxNativeFontInfo::SetPixelSize(const wxSize
& pixelSize
)
568 // NOTE: although the MSW port allows for negative pixel size heights,
569 // other ports don't and since it's a very useful feature assert
570 // here if we get a negative height:
571 wxCHECK_RET( pixelSize
.GetWidth() >= 0 && pixelSize
.GetHeight() > 0,
572 "Negative values for the pixel size or zero pixel height are not allowed" );
574 lf
.lfHeight
= pixelSize
.GetHeight();
575 lf
.lfWidth
= pixelSize
.GetWidth();
578 void wxNativeFontInfo::SetStyle(wxFontStyle style
)
583 wxFAIL_MSG( _T("unknown font style") );
586 case wxFONTSTYLE_NORMAL
:
590 case wxFONTSTYLE_ITALIC
:
591 case wxFONTSTYLE_SLANT
:
597 void wxNativeFontInfo::SetWeight(wxFontWeight weight
)
602 wxFAIL_MSG( _T("unknown font weight") );
605 case wxFONTWEIGHT_NORMAL
:
606 lf
.lfWeight
= FW_NORMAL
;
609 case wxFONTWEIGHT_LIGHT
:
610 lf
.lfWeight
= FW_LIGHT
;
613 case wxFONTWEIGHT_BOLD
:
614 lf
.lfWeight
= FW_BOLD
;
619 void wxNativeFontInfo::SetUnderlined(bool underlined
)
621 lf
.lfUnderline
= underlined
;
624 bool wxNativeFontInfo::SetFaceName(const wxString
& facename
)
626 wxStrlcpy(lf
.lfFaceName
, facename
.c_str(), WXSIZEOF(lf
.lfFaceName
));
630 void wxNativeFontInfo::SetFamily(wxFontFamily family
)
633 wxArrayString facename
;
635 // the list of fonts associated with a family was partially
636 // taken from http://www.codestyle.org/css/font-family
641 ff_family
= FF_SCRIPT
;
642 facename
.Add(_T("Script"));
643 facename
.Add(_T("Brush Script MT"));
644 facename
.Add(_T("Comic Sans MS"));
645 facename
.Add(_T("Lucida Handwriting"));
649 ff_family
= FF_DECORATIVE
;
650 facename
.Add(_T("Old English Text MT"));
651 facename
.Add(_T("Comic Sans MS"));
652 facename
.Add(_T("Lucida Handwriting"));
656 ff_family
= FF_ROMAN
;
657 facename
.Add(_T("Times New Roman"));
658 facename
.Add(_T("Georgia"));
659 facename
.Add(_T("Garamond"));
660 facename
.Add(_T("Bookman Old Style"));
661 facename
.Add(_T("Book Antiqua"));
666 ff_family
= FF_MODERN
;
667 facename
.Add(_T("Courier New"));
668 facename
.Add(_T("Lucida Console"));
669 facename
.Add(_T("Andale Mono"));
670 facename
.Add(_T("OCR A Extended"));
671 facename
.Add(_T("Terminal"));
675 ff_family
= FF_SWISS
;
676 facename
.Add(_T("Arial"));
677 facename
.Add(_T("Century Gothic"));
678 facename
.Add(_T("Lucida Sans Unicode"));
679 facename
.Add(_T("Tahoma"));
680 facename
.Add(_T("Trebuchet MS"));
681 facename
.Add(_T("Verdana"));
687 // We want Windows 2000 or later to have new fonts even MS Shell Dlg
688 // is returned as default GUI font for compatibility
690 ff_family
= FF_SWISS
;
691 if(wxGetOsVersion(&verMaj
) == wxOS_WINDOWS_NT
&& verMaj
>= 5)
692 facename
.Add(_T("MS Shell Dlg 2"));
694 facename
.Add(_T("MS Shell Dlg"));
697 // "MS Shell Dlg is a mapping mechanism that enables
698 // U.S. English Microsoft Windows NT, and Microsoft Windows 2000 to
699 // support locales that have characters that are not contained in code
700 // page 1252. It is not a font but a face name for a nonexistent font."
704 lf
.lfPitchAndFamily
= (BYTE
)(DEFAULT_PITCH
) | ff_family
;
706 if ( !wxStrlen(lf
.lfFaceName
) )
708 SetFaceName(facename
);
712 void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding
)
714 wxNativeEncodingInfo info
;
715 if ( !wxGetNativeFontEncoding(encoding
, &info
) )
718 if ( wxFontMapper::Get()->GetAltForEncoding(encoding
, &info
) )
720 if ( !info
.facename
.empty() )
722 // if we have this encoding only in some particular facename, use
723 // the facename - it is better to show the correct characters in a
724 // wrong facename than unreadable text in a correct one
725 SetFaceName(info
.facename
);
729 #endif // wxUSE_FONTMAP
731 // unsupported encoding, replace with the default
732 info
.charset
= DEFAULT_CHARSET
;
736 lf
.lfCharSet
= (BYTE
)info
.charset
;
739 bool wxNativeFontInfo::FromString(const wxString
& s
)
743 wxStringTokenizer
tokenizer(s
, _T(";"));
746 wxString token
= tokenizer
.GetNextToken();
747 if ( token
!= _T('0') )
750 token
= tokenizer
.GetNextToken();
751 if ( !token
.ToLong(&l
) )
755 token
= tokenizer
.GetNextToken();
756 if ( !token
.ToLong(&l
) )
760 token
= tokenizer
.GetNextToken();
761 if ( !token
.ToLong(&l
) )
765 token
= tokenizer
.GetNextToken();
766 if ( !token
.ToLong(&l
) )
768 lf
.lfOrientation
= l
;
770 token
= tokenizer
.GetNextToken();
771 if ( !token
.ToLong(&l
) )
775 token
= tokenizer
.GetNextToken();
776 if ( !token
.ToLong(&l
) )
778 lf
.lfItalic
= (BYTE
)l
;
780 token
= tokenizer
.GetNextToken();
781 if ( !token
.ToLong(&l
) )
783 lf
.lfUnderline
= (BYTE
)l
;
785 token
= tokenizer
.GetNextToken();
786 if ( !token
.ToLong(&l
) )
788 lf
.lfStrikeOut
= (BYTE
)l
;
790 token
= tokenizer
.GetNextToken();
791 if ( !token
.ToLong(&l
) )
793 lf
.lfCharSet
= (BYTE
)l
;
795 token
= tokenizer
.GetNextToken();
796 if ( !token
.ToLong(&l
) )
798 lf
.lfOutPrecision
= (BYTE
)l
;
800 token
= tokenizer
.GetNextToken();
801 if ( !token
.ToLong(&l
) )
803 lf
.lfClipPrecision
= (BYTE
)l
;
805 token
= tokenizer
.GetNextToken();
806 if ( !token
.ToLong(&l
) )
808 lf
.lfQuality
= (BYTE
)l
;
810 token
= tokenizer
.GetNextToken();
811 if ( !token
.ToLong(&l
) )
813 lf
.lfPitchAndFamily
= (BYTE
)l
;
815 token
= tokenizer
.GetNextToken();
818 wxStrcpy(lf
.lfFaceName
, token
.c_str());
823 wxString
wxNativeFontInfo::ToString() const
827 s
.Printf(_T("%d;%ld;%ld;%ld;%ld;%ld;%d;%d;%d;%d;%d;%d;%d;%d;%s"),
828 0, // version, in case we want to change the format later
842 (const wxChar
*)lf
.lfFaceName
);
847 // ----------------------------------------------------------------------------
849 // ----------------------------------------------------------------------------
851 bool wxFont::Create(const wxNativeFontInfo
& info
, WXHFONT hFont
)
855 m_refData
= new wxFontRefData(info
, hFont
);
857 return RealizeResource();
860 wxFont::wxFont(const wxString
& fontdesc
)
862 wxNativeFontInfo info
;
863 if ( info
.FromString(fontdesc
) )
867 bool wxFont::DoCreate(int pointSize
,
868 const wxSize
& pixelSize
,
869 bool sizeUsingPixels
,
874 const wxString
& faceName
,
875 wxFontEncoding encoding
)
879 // wxDEFAULT is a valid value for the font size too so we must treat it
880 // specially here (otherwise the size would be 70 == wxDEFAULT value)
881 if ( pointSize
== wxDEFAULT
)
883 pointSize
= wxNORMAL_FONT
->GetPointSize();
886 m_refData
= new wxFontRefData(pointSize
, pixelSize
, sizeUsingPixels
,
887 family
, style
, weight
,
888 underlined
, faceName
, encoding
);
890 return RealizeResource();
897 // ----------------------------------------------------------------------------
898 // real implementation
899 // ----------------------------------------------------------------------------
901 wxGDIRefData
*wxFont::CreateGDIRefData() const
903 return new wxFontRefData();
906 wxGDIRefData
*wxFont::CloneGDIRefData(const wxGDIRefData
*data
) const
908 return new wxFontRefData(*static_cast<const wxFontRefData
*>(data
));
911 bool wxFont::RealizeResource()
913 // don't do anything if we already have a valid font
917 return M_FONTDATA
->Alloc(this);
920 bool wxFont::FreeResource(bool WXUNUSED(force
))
930 WXHANDLE
wxFont::GetResourceHandle() const
932 return (WXHANDLE
)GetHFONT();
935 WXHFONT
wxFont::GetHFONT() const
937 return M_FONTDATA
? M_FONTDATA
->GetHFONT(this) : 0;
940 bool wxFont::IsFree() const
942 return M_FONTDATA
&& !M_FONTDATA
->HasHFONT();
945 // ----------------------------------------------------------------------------
946 // change font attribute: we recreate font when doing it
947 // ----------------------------------------------------------------------------
949 void wxFont::SetPointSize(int pointSize
)
954 M_FONTDATA
->SetPointSize(pointSize
);
957 void wxFont::SetPixelSize(const wxSize
& pixelSize
)
961 M_FONTDATA
->SetPixelSize(pixelSize
);
964 void wxFont::SetFamily(wxFontFamily family
)
968 M_FONTDATA
->SetFamily(family
);
971 void wxFont::SetStyle(wxFontStyle style
)
975 M_FONTDATA
->SetStyle(style
);
978 void wxFont::SetWeight(wxFontWeight weight
)
982 M_FONTDATA
->SetWeight(weight
);
985 bool wxFont::SetFaceName(const wxString
& faceName
)
989 if ( !M_FONTDATA
->SetFaceName(faceName
) )
992 // NB: using win32's GetObject() API on M_FONTDATA->GetHFONT()
993 // to retrieve a LOGFONT and then compare lf.lfFaceName
994 // with given facename is not reliable at all:
995 // Windows copies the facename given to ::CreateFontIndirect()
996 // without any validity check.
997 // Thus we use wxFontBase::SetFaceName to check if facename
999 return wxFontBase::SetFaceName(faceName
);
1002 void wxFont::SetUnderlined(bool underlined
)
1006 M_FONTDATA
->SetUnderlined(underlined
);
1009 void wxFont::SetEncoding(wxFontEncoding encoding
)
1013 M_FONTDATA
->SetEncoding(encoding
);
1016 void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo
& info
)
1020 M_FONTDATA
->SetNativeFontInfo(info
);
1023 // ----------------------------------------------------------------------------
1025 // ----------------------------------------------------------------------------
1027 int wxFont::GetPointSize() const
1029 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1031 return M_FONTDATA
->GetPointSize();
1034 wxSize
wxFont::GetPixelSize() const
1036 wxCHECK_MSG( Ok(), wxDefaultSize
, wxT("invalid font") );
1038 return M_FONTDATA
->GetPixelSize();
1041 bool wxFont::IsUsingSizeInPixels() const
1043 wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
1045 return M_FONTDATA
->IsUsingSizeInPixels();
1048 wxFontFamily
wxFont::GetFamily() const
1050 wxCHECK_MSG( Ok(), wxFONTFAMILY_MAX
, wxT("invalid font") );
1052 return M_FONTDATA
->GetFamily();
1055 wxFontStyle
wxFont::GetStyle() const
1057 wxCHECK_MSG( Ok(), wxFONTSTYLE_MAX
, wxT("invalid font") );
1059 return M_FONTDATA
->GetStyle();
1062 wxFontWeight
wxFont::GetWeight() const
1064 wxCHECK_MSG( Ok(), wxFONTWEIGHT_MAX
, wxT("invalid font") );
1066 return M_FONTDATA
->GetWeight();
1069 bool wxFont::GetUnderlined() const
1071 wxCHECK_MSG( Ok(), false, wxT("invalid font") );
1073 return M_FONTDATA
->GetUnderlined();
1076 wxString
wxFont::GetFaceName() const
1078 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid font") );
1080 return M_FONTDATA
->GetFaceName();
1083 wxFontEncoding
wxFont::GetEncoding() const
1085 wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT
, wxT("invalid font") );
1087 return M_FONTDATA
->GetEncoding();
1090 const wxNativeFontInfo
*wxFont::GetNativeFontInfo() const
1092 return Ok() && M_FONTDATA
->HasNativeFontInfo() ? &(M_FONTDATA
->GetNativeFontInfo())
1096 wxString
wxFont::GetNativeFontInfoDesc() const
1098 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid font") );
1100 // be sure we have an HFONT associated...
1101 wxConstCast(this, wxFont
)->RealizeResource();
1102 return wxFontBase::GetNativeFontInfoDesc();
1105 wxString
wxFont::GetNativeFontInfoUserDesc() const
1107 wxCHECK_MSG( Ok(), wxEmptyString
, wxT("invalid font") );
1109 // be sure we have an HFONT associated...
1110 wxConstCast(this, wxFont
)->RealizeResource();
1111 return wxFontBase::GetNativeFontInfoUserDesc();
1114 bool wxFont::IsFixedWidth() const
1116 if ( M_FONTDATA
->HasNativeFontInfo() )
1118 // the two low-order bits specify the pitch of the font, the rest is
1121 (BYTE
)(M_FONTDATA
->GetNativeFontInfo().lf
.lfPitchAndFamily
& PITCH_MASK
);
1123 return pitch
== FIXED_PITCH
;
1126 return wxFontBase::IsFixedWidth();