X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/04ef50df3a0fa3c343800c554e609f98fc7575cc..82baa5e4f1992b701e183544c935bcb424503f5b:/src/msw/font.cpp diff --git a/src/msw/font.cpp b/src/msw/font.cpp index 1800a135c0..14b78ac9e6 100644 --- a/src/msw/font.cpp +++ b/src/msw/font.cpp @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: font.cpp +// Name: src/msw/font.cpp // Purpose: wxFont class // Author: Julian Smart // Modified by: // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows licence +// Copyright: (c) wxWidgets team +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,7 +17,7 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "font.h" #endif @@ -35,22 +35,68 @@ #include "wx/app.h" #include "wx/font.h" #include "wx/log.h" + #include "wx/encinfo.h" #endif // WX_PRECOMP +#include "wx/msw/private.h" + #include "wx/fontutil.h" -#include "wx/tokenzr.h" +#include "wx/fontmap.h" -#include "wx/msw/private.h" #include "wx/tokenzr.h" -IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#if wxUSE_EXTENDED_RTTI + +wxBEGIN_ENUM( wxFontFamily ) + wxENUM_MEMBER( wxDEFAULT ) + wxENUM_MEMBER( wxDECORATIVE ) + wxENUM_MEMBER( wxROMAN ) + wxENUM_MEMBER( wxSCRIPT ) + wxENUM_MEMBER( wxSWISS ) + wxENUM_MEMBER( wxMODERN ) + wxENUM_MEMBER( wxTELETYPE ) +wxEND_ENUM( wxFontFamily ) + +wxBEGIN_ENUM( wxFontStyle ) + wxENUM_MEMBER( wxNORMAL ) + wxENUM_MEMBER( wxITALIC ) + wxENUM_MEMBER( wxSLANT ) +wxEND_ENUM( wxFontStyle ) + +wxBEGIN_ENUM( wxFontWeight ) + wxENUM_MEMBER( wxNORMAL ) + wxENUM_MEMBER( wxLIGHT ) + wxENUM_MEMBER( wxBOLD ) +wxEND_ENUM( wxFontWeight ) + +IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI(wxFont, wxGDIObject,"wx/font.h") + +wxBEGIN_PROPERTIES_TABLE(wxFont) + wxPROPERTY( Size,int, SetPointSize, GetPointSize, 12 , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY( Family, int , SetFamily, GetFamily, (int)wxDEFAULT , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontFamily + wxPROPERTY( Style, int , SetStyle, GetStyle, (int)wxNORMAL , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontStyle + wxPROPERTY( Weight, int , SetWeight, GetWeight, (int)wxNORMAL , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // wxFontWeight + wxPROPERTY( Underlined, bool , SetUnderlined, GetUnderlined, false , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY( Face, wxString , SetFaceName, GetFaceName, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) + wxPROPERTY( Encoding, wxFontEncoding , SetEncoding, GetEncoding, wxFONTENCODING_DEFAULT , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) +wxEND_PROPERTIES_TABLE() + +wxCONSTRUCTOR_6( wxFont , int , Size , int , Family , int , Style , int , Weight , bool , Underlined , wxString , Face ) + +wxBEGIN_HANDLERS_TABLE(wxFont) +wxEND_HANDLERS_TABLE() + +#else + IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#endif + // ---------------------------------------------------------------------------- // constants // ---------------------------------------------------------------------------- -// the default font size in points -static const int wxDEFAULT_FONT_SIZE = 12; +// the mask used to extract the pitch from LOGFONT::lfPitchAndFamily field +static const int PITCH_MASK = FIXED_PITCH | VARIABLE_PITCH; // ---------------------------------------------------------------------------- // wxFontRefData - the internal description of the font @@ -58,21 +104,12 @@ static const int wxDEFAULT_FONT_SIZE = 12; class WXDLLEXPORT wxFontRefData: public wxGDIRefData { -friend class WXDLLEXPORT wxFont; - public: + // constructors wxFontRefData() { - Init(wxDEFAULT_FONT_SIZE, wxDEFAULT, wxNORMAL, wxNORMAL, FALSE, - "", wxFONTENCODING_DEFAULT); - } - - wxFontRefData(const wxFontRefData& data) - { - Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight, - data.m_underlined, data.m_faceName, data.m_encoding); - - m_fontId = data.m_fontId; + Init(-1, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL, + FALSE, wxEmptyString, wxFONTENCODING_DEFAULT); } wxFontRefData(int size, @@ -91,8 +128,135 @@ public: Init(info, hFont); } + wxFontRefData(const wxFontRefData& data) + { + if ( data.m_nativeFontInfoOk ) + { + Init(data.m_nativeFontInfo); + } + else + { + Init(data.m_pointSize, data.m_family, data.m_style, data.m_weight, + data.m_underlined, data.m_faceName, data.m_encoding); + } + } + virtual ~wxFontRefData(); + // operations + bool Alloc(wxFont *font); + + void Free(); + + // all wxFont accessors + int GetPointSize() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetPointSize() + : m_pointSize; + } + + int GetFamily() const + { + return m_family; + } + + int GetStyle() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetStyle() + : m_style; + } + + int GetWeight() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetWeight() + : m_weight; + } + + bool GetUnderlined() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetUnderlined() + : m_underlined; + } + + wxString GetFaceName() const + { + wxString s; + if ( m_nativeFontInfoOk ) + s = m_nativeFontInfo.GetFaceName(); + else + s = m_faceName; + + return s; + } + + wxFontEncoding GetEncoding() const + { + return m_nativeFontInfoOk ? m_nativeFontInfo.GetEncoding() + : m_encoding; + } + + WXHFONT GetHFONT() const { return m_hFont; } + + // ... and setters + void SetPointSize(int pointSize) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetPointSize(pointSize); + else + m_pointSize = pointSize; + } + + void SetFamily(int family) + { + m_family = family; + } + + void SetStyle(int style) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetStyle((wxFontStyle)style); + else + m_style = style; + } + + void SetWeight(int weight) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetWeight((wxFontWeight)weight); + else + m_weight = weight; + } + + void SetFaceName(const wxString& faceName) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetFaceName(faceName); + else + m_faceName = faceName; + } + + void SetUnderlined(bool underlined) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetUnderlined(underlined); + else + m_underlined = underlined; + } + + void SetEncoding(wxFontEncoding encoding) + { + if ( m_nativeFontInfoOk ) + m_nativeFontInfo.SetEncoding(encoding); + else + m_encoding = encoding; + } + + // native font info tests + bool HasNativeFontInfo() const { return m_nativeFontInfoOk; } + + const wxNativeFontInfo& GetNativeFontInfo() const + { return m_nativeFontInfo; } + protected: // common part of all ctors void Init(int size, @@ -105,12 +269,6 @@ protected: void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0); - // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE - // DELETED by destructor - bool m_temporary; - - int m_fontId; - // font characterstics int m_pointSize; int m_family; @@ -145,7 +303,7 @@ void wxFontRefData::Init(int pointSize, wxFontEncoding encoding) { m_style = style; - m_pointSize = pointSize; + m_pointSize = pointSize == -1 ? wxNORMAL_FONT->GetPointSize() : pointSize; m_family = family; m_style = style; m_weight = weight; @@ -153,9 +311,6 @@ void wxFontRefData::Init(int pointSize, m_faceName = faceName; m_encoding = encoding; - m_fontId = 0; - m_temporary = FALSE; - m_hFont = 0; m_nativeFontInfoOk = FALSE; @@ -163,98 +318,280 @@ void wxFontRefData::Init(int pointSize, void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont) { - // extract family from pitch-and-family - int lfFamily = info.lf.lfPitchAndFamily; - if ( lfFamily & FIXED_PITCH ) - lfFamily -= FIXED_PITCH; - if ( lfFamily & VARIABLE_PITCH ) - lfFamily -= VARIABLE_PITCH; + // hFont may be zero, or it be passed in case we really want to + // use the exact font created in the underlying system + // (for example where we can't guarantee conversion from HFONT + // to LOGFONT back to HFONT) + m_hFont = hFont; + + m_nativeFontInfoOk = TRUE; + m_nativeFontInfo = info; + // This is the best we can do since we don't have the + // correct information at this point. + m_family = wxSWISS; +} + +wxFontRefData::~wxFontRefData() +{ + Free(); +} + +bool wxFontRefData::Alloc(wxFont *font) +{ + if ( !m_nativeFontInfoOk ) + { + wxFillLogFont(&m_nativeFontInfo.lf, font); + m_nativeFontInfoOk = TRUE; + } - switch ( lfFamily ) + HFONT hfont = ::CreateFontIndirect(&m_nativeFontInfo.lf); + if ( !hfont ) + { + wxLogLastError(wxT("CreateFont")); + + return FALSE; + } + + m_hFont = (WXHFONT)hfont; + + return TRUE; +} + +void wxFontRefData::Free() +{ + if ( m_hFont ) + { + if ( !::DeleteObject((HFONT) m_hFont) ) + { + wxLogLastError(wxT("DeleteObject(font)")); + } + + m_hFont = 0; + } +} + +// ---------------------------------------------------------------------------- +// wxNativeFontInfo +// ---------------------------------------------------------------------------- + +void wxNativeFontInfo::Init() +{ + wxZeroMemory(lf); +} + +int wxNativeFontInfo::GetPointSize() const +{ + // FIXME: using the screen here results in incorrect font size calculation + // for printing! + const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); + + return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5); +} + +wxFontStyle wxNativeFontInfo::GetStyle() const +{ + return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL; +} + +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + if ( lf.lfWeight <= 300 ) + return wxFONTWEIGHT_LIGHT; + + if ( lf.lfWeight >= 600 ) + return wxFONTWEIGHT_BOLD; + + return wxFONTWEIGHT_NORMAL; +} + +bool wxNativeFontInfo::GetUnderlined() const +{ + return lf.lfUnderline != 0; +} + +wxString wxNativeFontInfo::GetFaceName() const +{ + return lf.lfFaceName; +} + +wxFontFamily wxNativeFontInfo::GetFamily() const +{ + wxFontFamily family; + + // extract family from pitch-and-family + switch ( lf.lfPitchAndFamily & ~PITCH_MASK ) { case FF_ROMAN: - m_family = wxROMAN; + family = wxFONTFAMILY_ROMAN; break; + default: + wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") ); + // fall through + case FF_SWISS: - m_family = wxSWISS; + family = wxFONTFAMILY_SWISS; break; case FF_SCRIPT: - m_family = wxSCRIPT; + family = wxFONTFAMILY_SCRIPT; break; case FF_MODERN: - m_family = wxMODERN; + family = wxFONTFAMILY_MODERN; break; case FF_DECORATIVE: - m_family = wxDECORATIVE; + family = wxFONTFAMILY_DECORATIVE; break; + } + + return family; +} + +wxFontEncoding wxNativeFontInfo::GetEncoding() const +{ + return wxGetFontEncFromCharSet(lf.lfCharSet); +} + +void wxNativeFontInfo::SetPointSize(int pointsize) +{ +#if wxFONT_SIZE_COMPATIBILITY + // Incorrect, but compatible with old wxWidgets behaviour + lf.lfHeight = (pointSize*ppInch)/72; +#else // wxFONT_SIZE_COMPATIBILITY + // FIXME: using the screen here results in incorrect font size calculation + // for printing! + const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); + + lf.lfHeight = -(int)((pointsize*((double)ppInch)/72.0) + 0.5); +#endif // wxFONT_SIZE_COMPATIBILITY/!wxFONT_SIZE_COMPATIBILITY +} +void wxNativeFontInfo::SetStyle(wxFontStyle style) +{ + switch ( style ) + { default: - m_family = wxSWISS; + wxFAIL_MSG( _T("unknown font style") ); + // fall through + + case wxFONTSTYLE_NORMAL: + lf.lfItalic = FALSE; + break; + + case wxFONTSTYLE_ITALIC: + case wxFONTSTYLE_SLANT: + lf.lfItalic = TRUE; + break; } +} - // weight and style - switch ( info.lf.lfWeight ) +void wxNativeFontInfo::SetWeight(wxFontWeight weight) +{ + switch ( weight ) { - case FW_LIGHT: - m_weight = wxLIGHT; + default: + wxFAIL_MSG( _T("unknown font weight") ); + // fall through + + case wxFONTWEIGHT_NORMAL: + lf.lfWeight = FW_NORMAL; break; - default: - case FW_NORMAL: - m_weight = wxNORMAL; + case wxFONTWEIGHT_LIGHT: + lf.lfWeight = FW_LIGHT; break; - case FW_BOLD: - m_weight = wxBOLD; + case wxFONTWEIGHT_BOLD: + lf.lfWeight = FW_BOLD; break; } +} - m_style = info.lf.lfItalic ? wxITALIC : wxNORMAL; +void wxNativeFontInfo::SetUnderlined(bool underlined) +{ + lf.lfUnderline = underlined; +} - m_underlined = info.lf.lfUnderline != 0; +void wxNativeFontInfo::SetFaceName(wxString facename) +{ + wxStrncpy(lf.lfFaceName, facename, WXSIZEOF(lf.lfFaceName)); +} - m_faceName = info.lf.lfFaceName; +void wxNativeFontInfo::SetFamily(wxFontFamily family) +{ + int ff_family; + wxString facename; - int height = abs(info.lf.lfHeight); + switch ( family ) + { + case wxSCRIPT: + ff_family = FF_SCRIPT; + facename = _T("Script"); + break; - // remember that 1pt = 1/72inch - const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); - m_pointSize = (int) (((72.0*((double)height))/(double) ppInch) + 0.5); + case wxDECORATIVE: + ff_family = FF_DECORATIVE; + facename = _T("Old English Text MT"); + break; - m_encoding = wxGetFontEncFromCharSet(info.lf.lfCharSet); + case wxROMAN: + ff_family = FF_ROMAN; + facename = _T("Times New Roman"); + break; - m_fontId = 0; - m_temporary = FALSE; + case wxTELETYPE: + case wxMODERN: + ff_family = FF_MODERN; + facename = _T("Courier New"); + break; - // hFont may be zero, or it be passed in case we really want to - // use the exact font created in the underlying system - // (for example where we can't guarantee conversion from HFONT - // to LOGFONT back to HFONT) - m_hFont = hFont; + case wxSWISS: + ff_family = FF_SWISS; + facename = _T("Arial"); + break; - m_nativeFontInfoOk = TRUE; - m_nativeFontInfo = info; + case wxDEFAULT: + default: + ff_family = FF_SWISS; + facename = _T("MS Sans Serif"); + } + + lf.lfPitchAndFamily = DEFAULT_PITCH | ff_family; + + if ( !wxStrlen(lf.lfFaceName) ) + { + SetFaceName(facename); + } } -wxFontRefData::~wxFontRefData() +void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding) { - if ( m_hFont ) + wxNativeEncodingInfo info; + if ( !wxGetNativeFontEncoding(encoding, &info) ) { - if ( !::DeleteObject((HFONT) m_hFont) ) +#if wxUSE_FONTMAP + if ( wxFontMapper::Get()->GetAltForEncoding(encoding, &info) ) { - wxLogLastError(wxT("DeleteObject(font)")); + if ( !info.facename.empty() ) + { + // if we have this encoding only in some particular facename, use + // the facename - it is better to show the correct characters in a + // wrong facename than unreadable text in a correct one + SetFaceName(info.facename); + } + } + else +#endif // wxUSE_FONTMAP + { + // unsupported encoding, replace with the default + info.charset = DEFAULT_CHARSET; } } -} - -// ---------------------------------------------------------------------------- -// wxNativeFontInfo -// ---------------------------------------------------------------------------- + lf.lfCharSet = info.charset; +} bool wxNativeFontInfo::FromString(const wxString& s) { @@ -262,10 +599,10 @@ bool wxNativeFontInfo::FromString(const wxString& s) wxStringTokenizer tokenizer(s, _T(";")); + // first the version wxString token = tokenizer.GetNextToken(); - // - // Ignore the version for now - // + if ( token != _T('0') ) + return FALSE; token = tokenizer.GetNextToken(); if ( !token.ToLong(&l) ) @@ -344,7 +681,7 @@ wxString wxNativeFontInfo::ToString() const { wxString s; - s.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"), + s.Printf(_T("%d;%ld;%ld;%ld;%ld;%ld;%d;%d;%d;%d;%d;%d;%d;%d;%s"), 0, // version, in case we want to change the format later lf.lfHeight, lf.lfWidth, @@ -370,8 +707,6 @@ wxString wxNativeFontInfo::ToString() const void wxFont::Init() { - if ( wxTheFontList ) - wxTheFontList->Append(this); } bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont) @@ -408,7 +743,9 @@ bool wxFont::Create(int pointSize, // wxDEFAULT is a valid value for the font size too so we must treat it // specially here (otherwise the size would be 70 == wxDEFAULT value) if ( pointSize == wxDEFAULT ) - pointSize = wxDEFAULT_FONT_SIZE; + { + pointSize = wxNORMAL_FONT->GetPointSize(); + } m_refData = new wxFontRefData(pointSize, family, style, weight, underlined, faceName, encoding); @@ -420,8 +757,6 @@ bool wxFont::Create(int pointSize, wxFont::~wxFont() { - if ( wxTheFontList ) - wxTheFontList->DeleteObject(this); } // ---------------------------------------------------------------------------- @@ -437,56 +772,34 @@ bool wxFont::RealizeResource() return TRUE; } - if(!M_FONTDATA->m_nativeFontInfoOk) - { - wxFillLogFont(&M_FONTDATA->m_nativeFontInfo.lf, this); - M_FONTDATA->m_nativeFontInfoOk = TRUE; - } - - M_FONTDATA->m_hFont = (WXHFONT)::CreateFontIndirect(&M_FONTDATA->m_nativeFontInfo.lf); - M_FONTDATA->m_faceName = M_FONTDATA->m_nativeFontInfo.lf.lfFaceName; - if ( !M_FONTDATA->m_hFont ) - { - wxLogLastError(wxT("CreateFont")); - - return FALSE; - } - - return TRUE; + return M_FONTDATA->Alloc(this); } bool wxFont::FreeResource(bool WXUNUSED(force)) { if ( GetResourceHandle() ) { - if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) ) - { - wxLogLastError(wxT("DeleteObject(font)")); - } - - M_FONTDATA->m_hFont = 0; + M_FONTDATA->Free(); return TRUE; } + return FALSE; } -WXHANDLE wxFont::GetResourceHandle() +WXHANDLE wxFont::GetResourceHandle() const { - return GetHFONT(); + return (WXHANDLE)GetHFONT(); } WXHFONT wxFont::GetHFONT() const { - if ( !M_FONTDATA ) - return 0; - else - return (WXHANDLE)M_FONTDATA->m_hFont; + return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0; } bool wxFont::IsFree() const { - return (M_FONTDATA && (M_FONTDATA->m_hFont == 0)); + return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0); } void wxFont::Unshare() @@ -512,8 +825,7 @@ void wxFont::SetPointSize(int pointSize) { Unshare(); - M_FONTDATA->m_pointSize = pointSize; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetPointSize(pointSize); RealizeResource(); } @@ -522,8 +834,7 @@ void wxFont::SetFamily(int family) { Unshare(); - M_FONTDATA->m_family = family; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetFamily(family); RealizeResource(); } @@ -532,8 +843,7 @@ void wxFont::SetStyle(int style) { Unshare(); - M_FONTDATA->m_style = style; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetStyle(style); RealizeResource(); } @@ -542,8 +852,7 @@ void wxFont::SetWeight(int weight) { Unshare(); - M_FONTDATA->m_weight = weight; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetWeight(weight); RealizeResource(); } @@ -552,8 +861,7 @@ void wxFont::SetFaceName(const wxString& faceName) { Unshare(); - M_FONTDATA->m_faceName = faceName; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetFaceName(faceName); RealizeResource(); } @@ -562,8 +870,7 @@ void wxFont::SetUnderlined(bool underlined) { Unshare(); - M_FONTDATA->m_underlined = underlined; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetUnderlined(underlined); RealizeResource(); } @@ -572,19 +879,18 @@ void wxFont::SetEncoding(wxFontEncoding encoding) { Unshare(); - M_FONTDATA->m_encoding = encoding; - M_FONTDATA->m_nativeFontInfoOk = FALSE; + M_FONTDATA->SetEncoding(encoding); RealizeResource(); } -void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info) +void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info) { Unshare(); FreeResource(); - M_FONTDATA->Init(info); + *M_FONTDATA = wxFontRefData(info); RealizeResource(); } @@ -597,63 +903,69 @@ int wxFont::GetPointSize() const { wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); - return M_FONTDATA->m_pointSize; + return M_FONTDATA->GetPointSize(); } int wxFont::GetFamily() const { wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); - return M_FONTDATA->m_family; -} - -int wxFont::GetFontId() const -{ - wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); - - return M_FONTDATA->m_fontId; + return M_FONTDATA->GetFamily(); } int wxFont::GetStyle() const { wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); - return M_FONTDATA->m_style; + return M_FONTDATA->GetStyle(); } int wxFont::GetWeight() const { wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); - return M_FONTDATA->m_weight; + return M_FONTDATA->GetWeight(); } bool wxFont::GetUnderlined() const { wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") ); - return M_FONTDATA->m_underlined; + return M_FONTDATA->GetUnderlined(); } wxString wxFont::GetFaceName() const { - wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") ); + wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") ); - return M_FONTDATA->m_faceName; + return M_FONTDATA->GetFaceName(); } wxFontEncoding wxFont::GetEncoding() const { wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); - return M_FONTDATA->m_encoding; + return M_FONTDATA->GetEncoding(); +} + +const wxNativeFontInfo *wxFont::GetNativeFontInfo() const +{ + return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo()) + : NULL; } -wxNativeFontInfo *wxFont::GetNativeFontInfo() const +bool wxFont::IsFixedWidth() const { - if( M_FONTDATA->m_nativeFontInfoOk ) - return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo); + if ( M_FONTDATA->HasNativeFontInfo() ) + { + // the two low-order bits specify the pitch of the font, the rest is + // family + BYTE pitch = M_FONTDATA->GetNativeFontInfo(). + lf.lfPitchAndFamily & PITCH_MASK; + + return pitch == FIXED_PITCH; + } - return 0; + return wxFontBase::IsFixedWidth(); }