X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/8fb3a512a85572ebf4b4f46eaf536727dfe4e01e..19e30148e18cc99296b26503c155e5cef59045f4:/src/msw/font.cpp?ds=sidebyside diff --git a/src/msw/font.cpp b/src/msw/font.cpp index 50daad4e83..25ff0295e3 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) wxWindows team +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -29,23 +29,29 @@ #endif #ifndef WX_PRECOMP - #include #include "wx/setup.h" #include "wx/list.h" #include "wx/utils.h" #include "wx/app.h" #include "wx/font.h" + #include "wx/log.h" #endif // WX_PRECOMP #include "wx/msw/private.h" -#if !USE_SHARED_LIBRARIES - IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#include "wx/fontutil.h" +#include "wx/fontmap.h" - #if wxUSE_PORTABLE_FONTS_IN_MSW - IMPLEMENT_DYNAMIC_CLASS(wxFontNameDirectory, wxObject) - #endif -#endif +#include "wx/tokenzr.h" + +IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) + +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +// 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 @@ -53,21 +59,12 @@ class WXDLLEXPORT wxFontRefData: public wxGDIRefData { -friend class WXDLLEXPORT wxFont; - public: + // constructors wxFontRefData() { - Init(12, 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, _T(""), wxFONTENCODING_DEFAULT); } wxFontRefData(int size, @@ -81,8 +78,140 @@ public: Init(size, family, style, weight, underlined, faceName, encoding); } + wxFontRefData(const wxNativeFontInfo& info, WXHFONT hFont = 0) + { + 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, @@ -93,11 +222,7 @@ protected: const wxString& faceName, wxFontEncoding encoding); - // If TRUE, the pointer to the actual font is temporary and SHOULD NOT BE - // DELETED by destructor - bool m_temporary; - - int m_fontId; + void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0); // font characterstics int m_pointSize; @@ -110,6 +235,10 @@ protected: // Windows font handle WXHFONT m_hFont; + + // Native font info + wxNativeFontInfo m_nativeFontInfo; + bool m_nativeFontInfoOk; }; // ============================================================================ @@ -129,7 +258,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; @@ -137,315 +266,491 @@ void wxFontRefData::Init(int pointSize, m_faceName = faceName; m_encoding = encoding; - m_fontId = 0; - m_temporary = FALSE; - m_hFont = 0; + + m_nativeFontInfoOk = FALSE; +} + +void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont) +{ + // 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; } wxFontRefData::~wxFontRefData() +{ + Free(); +} + +bool wxFontRefData::Alloc(wxFont *font) +{ + if ( !m_nativeFontInfoOk ) + { + wxFillLogFont(&m_nativeFontInfo.lf, font); + m_nativeFontInfoOk = TRUE; + } + + 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("DeleteObject(font)"); + wxLogLastError(wxT("DeleteObject(font)")); } + + m_hFont = 0; } } // ---------------------------------------------------------------------------- -// wxFont +// wxNativeFontInfo // ---------------------------------------------------------------------------- -void wxFont::Init() +void wxNativeFontInfo::Init() { - if ( wxTheFontList ) - wxTheFontList->Append(this); + wxZeroMemory(lf); } -/* Constructor for a font. Note that the real construction is done - * in wxDC::SetFont, when information is available about scaling etc. - */ -bool wxFont::Create(int pointSize, - int family, - int style, - int weight, - bool underlined, - const wxString& faceName, - wxFontEncoding encoding) +int wxNativeFontInfo::GetPointSize() const { - UnRef(); - m_refData = new wxFontRefData(pointSize, family, style, weight, - underlined, faceName, encoding); + // FIXME: using the screen here results in incorrect font size calculation + // for printing! + const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); - RealizeResource(); - - return TRUE; + return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5); } -wxFont::~wxFont() +wxFontStyle wxNativeFontInfo::GetStyle() const { - if ( wxTheFontList ) - wxTheFontList->DeleteObject(this); + return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL; } -// ---------------------------------------------------------------------------- -// real implementation -// ---------------------------------------------------------------------------- +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + if ( lf.lfWeight <= 300 ) + return wxFONTWEIGHT_LIGHT; -bool wxFont::RealizeResource() + if ( lf.lfWeight >= 600 ) + return wxFONTWEIGHT_BOLD; + + return wxFONTWEIGHT_NORMAL; +} + +bool wxNativeFontInfo::GetUnderlined() const { - if ( GetResourceHandle() ) - { - // VZ: the old code returned FALSE in this case, but it doesn't seem - // to make sense because the font _was_ created - wxLogDebug(wxT("Calling wxFont::RealizeResource() twice")); + return lf.lfUnderline != 0; +} - return TRUE; - } +wxString wxNativeFontInfo::GetFaceName() const +{ + return lf.lfFaceName; +} - int ff_family = 0; - wxString ff_face; +wxFontFamily wxNativeFontInfo::GetFamily() const +{ + wxFontFamily family; - switch ( M_FONTDATA->m_family ) + // extract family from pitch-and-family + switch ( lf.lfPitchAndFamily & ~PITCH_MASK ) { - case wxSCRIPT: - ff_family = FF_SCRIPT ; - ff_face = wxT("Script") ; - break ; - - case wxDECORATIVE: - ff_family = FF_DECORATIVE; + case FF_ROMAN: + family = wxFONTFAMILY_ROMAN; break; - case wxROMAN: - ff_family = FF_ROMAN; - ff_face = wxT("Times New Roman") ; + default: + wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") ); + // fall through + + case FF_SWISS: + family = wxFONTFAMILY_SWISS; break; - case wxTELETYPE: - case wxMODERN: - ff_family = FF_MODERN; - ff_face = wxT("Courier New") ; + case FF_SCRIPT: + family = wxFONTFAMILY_SCRIPT; break; - case wxSWISS: - ff_family = FF_SWISS; - ff_face = wxT("Arial") ; + case FF_MODERN: + family = wxFONTFAMILY_MODERN; break; - case wxDEFAULT: - default: - ff_family = FF_SWISS; - ff_face = wxT("Arial") ; + case FF_DECORATIVE: + family = wxFONTFAMILY_DECORATIVE; + break; } - BYTE ff_italic; - switch ( M_FONTDATA->m_style ) - { - case wxITALIC: - case wxSLANT: - ff_italic = 1; - 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 wxWindows 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: - wxFAIL_MSG(wxT("unknown font slant")); + wxFAIL_MSG( _T("unknown font style") ); // fall through - case wxNORMAL: - ff_italic = 0; + case wxFONTSTYLE_NORMAL: + break; + + case wxFONTSTYLE_ITALIC: + case wxFONTSTYLE_SLANT: + lf.lfItalic = TRUE; + break; } +} - int ff_weight = 0; - switch ( M_FONTDATA->m_weight ) +void wxNativeFontInfo::SetWeight(wxFontWeight weight) +{ + switch ( weight ) { default: - wxFAIL_MSG(wxT("unknown font weight")); + wxFAIL_MSG( _T("unknown font weight") ); // fall through - case wxNORMAL: - ff_weight = FW_NORMAL; + case wxFONTWEIGHT_NORMAL: + lf.lfWeight = FW_NORMAL; break; - case wxLIGHT: - ff_weight = FW_LIGHT; + case wxFONTWEIGHT_LIGHT: + lf.lfWeight = FW_LIGHT; break; - case wxBOLD: - ff_weight = FW_BOLD; + case wxFONTWEIGHT_BOLD: + lf.lfWeight = FW_BOLD; break; } +} - const wxChar* pzFace; - if ( M_FONTDATA->m_faceName.IsEmpty() ) - pzFace = ff_face; - else - pzFace = M_FONTDATA->m_faceName ; +void wxNativeFontInfo::SetUnderlined(bool underlined) +{ + lf.lfUnderline = underlined; +} -#if 0 - /* Always calculate fonts using the screen DC (is this the best strategy?) - * There may be confusion if a font is selected into a printer - * DC (say), because the height will be calculated very differently. - */ - // What sort of display is it? - int technology = ::GetDeviceCaps(dc, TECHNOLOGY); +void wxNativeFontInfo::SetFaceName(wxString facename) +{ + wxStrncpy(lf.lfFaceName, facename, WXSIZEOF(lf.lfFaceName)); +} - int nHeight; +void wxNativeFontInfo::SetFamily(wxFontFamily family) +{ + int ff_family; + wxString facename; - if (technology != DT_RASDISPLAY && technology != DT_RASPRINTER) - { - // Have to get screen DC Caps, because a metafile will return 0. - HDC dc2 = ::GetDC(NULL); - nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc2, LOGPIXELSY)/72; - ::ReleaseDC(NULL, dc2); - } - else + switch ( family ) { - nHeight = M_FONTDATA->m_pointSize*GetDeviceCaps(dc, LOGPIXELSY)/72; - } -#endif // 0 + case wxSCRIPT: + ff_family = FF_SCRIPT; + facename = _T("Script"); + break; -#if 0 - // Have to get screen DC Caps, because a metafile will return 0. - HDC dc2 = ::GetDC(NULL); - ppInch = ::GetDeviceCaps(dc2, LOGPIXELSY); - ::ReleaseDC(NULL, dc2); -#endif // 0 + case wxDECORATIVE: + ff_family = FF_DECORATIVE; + facename = _T("Old English Text MT"); + break; - // New behaviour: apparently ppInch varies according to Large/Small Fonts - // setting in Windows. This messes up fonts. So, set ppInch to a constant - // 96 dpi. - static const int ppInch = 96; + case wxROMAN: + ff_family = FF_ROMAN; + facename = _T("Times New Roman"); + break; -#if wxFONT_SIZE_COMPATIBILITY - // Incorrect, but compatible with old wxWindows behaviour - int nHeight = (M_FONTDATA->m_pointSize*ppInch/72); -#else - // Correct for Windows compatibility - int nHeight = - (M_FONTDATA->m_pointSize*ppInch/72); -#endif + case wxTELETYPE: + case wxMODERN: + ff_family = FF_MODERN; + facename = _T("Courier New"); + break; + + case wxSWISS: + ff_family = FF_SWISS; + facename = _T("Arial"); + break; + + case wxDEFAULT: + default: + ff_family = FF_SWISS; + facename = _T("MS Sans Serif"); + } - BYTE ff_underline = M_FONTDATA->m_underlined; + lf.lfPitchAndFamily = DEFAULT_PITCH | ff_family; - wxFontEncoding encoding = M_FONTDATA->m_encoding; - if ( encoding == wxFONTENCODING_DEFAULT ) + if ( !wxStrlen(lf.lfFaceName) ) { - encoding = wxFont::GetDefaultEncoding(); + SetFaceName(facename); } +} - DWORD charset; - switch ( encoding ) +void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding) +{ + wxNativeEncodingInfo info; + if ( !wxGetNativeFontEncoding(encoding, &info) ) { - case wxFONTENCODING_ISO8859_1: - case wxFONTENCODING_ISO8859_15: - case wxFONTENCODING_CP1250: - charset = ANSI_CHARSET; - break; -#if !defined(__WIN16__) - case wxFONTENCODING_ISO8859_2: - case wxFONTENCODING_CP1252: - charset = EASTEUROPE_CHARSET; - break; +#if wxUSE_FONTMAP + if ( wxFontMapper::Get()->GetAltForEncoding(encoding, &info) ) + { + 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; + } + } - case wxFONTENCODING_ISO8859_4: - case wxFONTENCODING_ISO8859_10: - charset = BALTIC_CHARSET; - break; + lf.lfCharSet = info.charset; +} - case wxFONTENCODING_ISO8859_5: - case wxFONTENCODING_CP1251: - charset = RUSSIAN_CHARSET; - break; +bool wxNativeFontInfo::FromString(const wxString& s) +{ + long l; + + wxStringTokenizer tokenizer(s, _T(";")); + + // first the version + wxString token = tokenizer.GetNextToken(); + if ( token != _T('0') ) + return FALSE; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfHeight = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfWidth = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfEscapement = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfOrientation = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfWeight = l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfItalic = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfUnderline = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfStrikeOut = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfCharSet = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfOutPrecision = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfClipPrecision = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfQuality = (BYTE)l; + + token = tokenizer.GetNextToken(); + if ( !token.ToLong(&l) ) + return FALSE; + lf.lfPitchAndFamily = (BYTE)l; + + token = tokenizer.GetNextToken(); + if(!token) + return FALSE; + wxStrcpy(lf.lfFaceName, token.c_str()); - case wxFONTENCODING_ISO8859_6: - charset = ARABIC_CHARSET; - break; + return TRUE; +} - case wxFONTENCODING_ISO8859_7: - charset = GREEK_CHARSET; - break; +wxString wxNativeFontInfo::ToString() const +{ + wxString s; + + s.Printf(_T("%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%d;%s"), + 0, // version, in case we want to change the format later + lf.lfHeight, + lf.lfWidth, + lf.lfEscapement, + lf.lfOrientation, + lf.lfWeight, + lf.lfItalic, + lf.lfUnderline, + lf.lfStrikeOut, + lf.lfCharSet, + lf.lfOutPrecision, + lf.lfClipPrecision, + lf.lfQuality, + lf.lfPitchAndFamily, + lf.lfFaceName); + + return s; +} - case wxFONTENCODING_ISO8859_8: - charset = HEBREW_CHARSET; - break; +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- - case wxFONTENCODING_ISO8859_9: - charset = TURKISH_CHARSET; - break; +void wxFont::Init() +{ +} - case wxFONTENCODING_ISO8859_11: - charset = THAI_CHARSET; - break; -#endif // BC++ 16-bit +bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont) +{ + UnRef(); - case wxFONTENCODING_CP437: - charset = OEM_CHARSET; - break; + m_refData = new wxFontRefData(info, hFont); - default: - wxFAIL_MSG(wxT("unsupported encoding")); - // fall through + RealizeResource(); - case wxFONTENCODING_SYSTEM: - charset = ANSI_CHARSET; - } + return TRUE; +} + +wxFont::wxFont(const wxString& fontdesc) +{ + wxNativeFontInfo info; + if ( info.FromString(fontdesc) ) + (void)Create(info); +} - HFONT hFont = ::CreateFont - ( - nHeight, // height - 0, // width (choose best) - 0, // escapement - 0, // orientation - ff_weight, // weight - ff_italic, // italic? - ff_underline, // underlined? - 0, // strikeout? - charset, // charset - OUT_DEFAULT_PRECIS, // precision - CLIP_DEFAULT_PRECIS, // clip precision - PROOF_QUALITY, // quality of match - DEFAULT_PITCH | // fixed or variable - ff_family, // family id - pzFace // face name - ); +/* Constructor for a font. Note that the real construction is done + * in wxDC::SetFont, when information is available about scaling etc. + */ +bool wxFont::Create(int pointSize, + int family, + int style, + int weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) +{ + UnRef(); - M_FONTDATA->m_hFont = (WXHFONT)hFont; - if ( !hFont ) + // 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 ) { - wxLogLastError("CreateFont"); + pointSize = wxNORMAL_FONT->GetPointSize(); } - return hFont != 0; + m_refData = new wxFontRefData(pointSize, family, style, weight, + underlined, faceName, encoding); + + RealizeResource(); + + return TRUE; } -bool wxFont::FreeResource(bool force) +wxFont::~wxFont() +{ +} + +// ---------------------------------------------------------------------------- +// real implementation +// ---------------------------------------------------------------------------- + +bool wxFont::RealizeResource() { if ( GetResourceHandle() ) { - if ( !::DeleteObject((HFONT) M_FONTDATA->m_hFont) ) - { - wxLogLastError("DeleteObject(font)"); - } + // VZ: the old code returned FALSE in this case, but it doesn't seem + // to make sense because the font _was_ created + return TRUE; + } + + return M_FONTDATA->Alloc(this); +} - M_FONTDATA->m_hFont = 0; +bool wxFont::FreeResource(bool WXUNUSED(force)) +{ + if ( GetResourceHandle() ) + { + M_FONTDATA->Free(); return TRUE; } + return FALSE; } WXHANDLE wxFont::GetResourceHandle() { - if ( !M_FONTDATA ) - return 0; - else - return (WXHANDLE)M_FONTDATA->m_hFont ; + return GetHFONT(); +} + +WXHFONT wxFont::GetHFONT() const +{ + 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() @@ -471,7 +776,7 @@ void wxFont::SetPointSize(int pointSize) { Unshare(); - M_FONTDATA->m_pointSize = pointSize; + M_FONTDATA->SetPointSize(pointSize); RealizeResource(); } @@ -480,7 +785,7 @@ void wxFont::SetFamily(int family) { Unshare(); - M_FONTDATA->m_family = family; + M_FONTDATA->SetFamily(family); RealizeResource(); } @@ -489,7 +794,7 @@ void wxFont::SetStyle(int style) { Unshare(); - M_FONTDATA->m_style = style; + M_FONTDATA->SetStyle(style); RealizeResource(); } @@ -498,7 +803,7 @@ void wxFont::SetWeight(int weight) { Unshare(); - M_FONTDATA->m_weight = weight; + M_FONTDATA->SetWeight(weight); RealizeResource(); } @@ -507,7 +812,7 @@ void wxFont::SetFaceName(const wxString& faceName) { Unshare(); - M_FONTDATA->m_faceName = faceName; + M_FONTDATA->SetFaceName(faceName); RealizeResource(); } @@ -516,7 +821,7 @@ void wxFont::SetUnderlined(bool underlined) { Unshare(); - M_FONTDATA->m_underlined = underlined; + M_FONTDATA->SetUnderlined(underlined); RealizeResource(); } @@ -525,7 +830,18 @@ void wxFont::SetEncoding(wxFontEncoding encoding) { Unshare(); - M_FONTDATA->m_encoding = encoding; + M_FONTDATA->SetEncoding(encoding); + + RealizeResource(); +} + +void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info) +{ + Unshare(); + + FreeResource(); + + *M_FONTDATA = wxFontRefData(info); RealizeResource(); } @@ -536,43 +852,73 @@ void wxFont::SetEncoding(wxFontEncoding encoding) int wxFont::GetPointSize() const { - return M_FONTDATA->m_pointSize; + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetPointSize(); } int wxFont::GetFamily() const { - return M_FONTDATA->m_family; -} + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); -int wxFont::GetFontId() const -{ - return M_FONTDATA->m_fontId; + return M_FONTDATA->GetFamily(); } int wxFont::GetStyle() const { - return M_FONTDATA->m_style; + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetStyle(); } int wxFont::GetWeight() const { - return M_FONTDATA->m_weight; + wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetWeight(); } bool wxFont::GetUnderlined() const { - return M_FONTDATA->m_underlined; + wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") ); + + return M_FONTDATA->GetUnderlined(); } wxString wxFont::GetFaceName() const { - wxString str; - if ( M_FONTDATA ) - str = M_FONTDATA->m_faceName ; - return str; + wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") ); + + return M_FONTDATA->GetFaceName(); } wxFontEncoding wxFont::GetEncoding() const { - return M_FONTDATA->m_encoding; + wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); + + return M_FONTDATA->GetEncoding(); } + +wxNativeFontInfo *wxFont::GetNativeFontInfo() const +{ + if ( M_FONTDATA->HasNativeFontInfo() ) + return new wxNativeFontInfo(M_FONTDATA->GetNativeFontInfo()); + + return 0; +} + +bool wxFont::IsFixedWidth() const +{ + 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 wxFontBase::IsFixedWidth(); +} +