X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/b4772c241f010306b6f9e93edd2dabe763ff9c40..fb4079af5ba82f05e1115f0f0c734b77cf8164e7:/src/msw/font.cpp diff --git a/src/msw/font.cpp b/src/msw/font.cpp index c9f7b35890..d8d678fe8f 100644 --- a/src/msw/font.cpp +++ b/src/msw/font.cpp @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "font.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,12 +24,12 @@ #pragma hdrstop #endif +#include "wx/font.h" + #ifndef WX_PRECOMP - #include "wx/setup.h" #include "wx/list.h" #include "wx/utils.h" #include "wx/app.h" - #include "wx/font.h" #include "wx/log.h" #include "wx/encinfo.h" #endif // WX_PRECOMP @@ -43,6 +39,10 @@ #include "wx/fontutil.h" #include "wx/fontmap.h" +#ifndef __WXWINCE__ + #include "wx/sysopt.h" +#endif + #include "wx/tokenzr.h" #if wxUSE_EXTENDED_RTTI @@ -116,9 +116,9 @@ public: wxFontRefData(int size, const wxSize& pixelSize, bool sizeUsingPixels, - int family, - int style, - int weight, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding) @@ -134,196 +134,172 @@ public: wxFontRefData(const wxFontRefData& data) : wxGDIRefData() { - if ( data.m_nativeFontInfoOk ) - { - Init(data.m_nativeFontInfo); - } - else - { - Init(data.m_pointSize, data.m_pixelSize, data.m_sizeUsingPixels, - data.m_family, data.m_style, data.m_weight, - data.m_underlined, data.m_faceName, data.m_encoding); - } + Init(data.m_nativeFontInfo); } virtual ~wxFontRefData(); // operations - bool Alloc(wxFont *font); + bool Alloc(); void Free(); // all wxFont accessors int GetPointSize() const { - return m_nativeFontInfoOk ? m_nativeFontInfo.GetPointSize() - : m_pointSize; + return m_nativeFontInfo.GetPointSize(); } wxSize GetPixelSize() const { - return m_nativeFontInfoOk ? m_nativeFontInfo.GetPixelSize() - : m_pixelSize; + return m_nativeFontInfo.GetPixelSize(); } bool IsUsingSizeInPixels() const { - return m_nativeFontInfoOk ? true : m_sizeUsingPixels; + return m_sizeUsingPixels; } - int GetFamily() const + wxFontFamily GetFamily() const { - return m_family; + return m_nativeFontInfo.GetFamily(); } - int GetStyle() const + wxFontStyle GetStyle() const { - return m_nativeFontInfoOk ? m_nativeFontInfo.GetStyle() - : m_style; + return m_nativeFontInfo.GetStyle(); } - int GetWeight() const + wxFontWeight GetWeight() const { - return m_nativeFontInfoOk ? m_nativeFontInfo.GetWeight() - : m_weight; + return m_nativeFontInfo.GetWeight(); } bool GetUnderlined() const { - return m_nativeFontInfoOk ? m_nativeFontInfo.GetUnderlined() - : m_underlined; + return m_nativeFontInfo.GetUnderlined(); } wxString GetFaceName() const { - wxString s; - if ( m_nativeFontInfoOk ) - s = m_nativeFontInfo.GetFaceName(); - else - s = m_faceName; - - return s; + return m_nativeFontInfo.GetFaceName(); } wxFontEncoding GetEncoding() const { - return m_nativeFontInfoOk ? m_nativeFontInfo.GetEncoding() - : m_encoding; + return m_nativeFontInfo.GetEncoding(); + } + + WXHFONT GetHFONT() const + { + if ( !m_hFont ) + const_cast(this)->Alloc(); + + return (WXHFONT)m_hFont; } - WXHFONT GetHFONT() const { return m_hFont; } + bool HasHFONT() const + { + return m_hFont != 0; + } - // ... and setters + // ... and setters: notice that all of them invalidate the currently + // allocated HFONT, if any, so that the next call to GetHFONT() recreates a + // new one void SetPointSize(int pointSize) { - if ( m_nativeFontInfoOk ) - { - m_nativeFontInfo.SetPointSize(pointSize); - } - else - { - m_pointSize = pointSize; - m_sizeUsingPixels = false; - } + Free(); + + m_nativeFontInfo.SetPointSize(pointSize); + m_sizeUsingPixels = false; } void SetPixelSize(const wxSize& pixelSize) { - if ( m_nativeFontInfoOk ) - { - m_nativeFontInfo.SetPixelSize(pixelSize); - } - else - { - m_pixelSize = pixelSize; - m_sizeUsingPixels = true; - } + Free(); + + m_nativeFontInfo.SetPixelSize(pixelSize); + m_sizeUsingPixels = true; } - void SetFamily(int family) + void SetFamily(wxFontFamily family) { - m_family = family; + Free(); + + m_nativeFontInfo.SetFamily(family); } - void SetStyle(int style) + void SetStyle(wxFontStyle style) { - if ( m_nativeFontInfoOk ) - m_nativeFontInfo.SetStyle((wxFontStyle)style); - else - m_style = style; + Free(); + + m_nativeFontInfo.SetStyle(style); } - void SetWeight(int weight) + void SetWeight(wxFontWeight weight) { - if ( m_nativeFontInfoOk ) - m_nativeFontInfo.SetWeight((wxFontWeight)weight); - else - m_weight = weight; + Free(); + + m_nativeFontInfo.SetWeight(weight); } - void SetFaceName(const wxString& faceName) + bool SetFaceName(const wxString& faceName) { - if ( m_nativeFontInfoOk ) - m_nativeFontInfo.SetFaceName(faceName); - else - m_faceName = faceName; + Free(); + + return m_nativeFontInfo.SetFaceName(faceName); } void SetUnderlined(bool underlined) { - if ( m_nativeFontInfoOk ) - m_nativeFontInfo.SetUnderlined(underlined); - else - m_underlined = underlined; + Free(); + + m_nativeFontInfo.SetUnderlined(underlined); } void SetEncoding(wxFontEncoding encoding) { - if ( m_nativeFontInfoOk ) - m_nativeFontInfo.SetEncoding(encoding); - else - m_encoding = encoding; - } + Free(); - // native font info tests - bool HasNativeFontInfo() const { return m_nativeFontInfoOk; } + m_nativeFontInfo.SetEncoding(encoding); + } const wxNativeFontInfo& GetNativeFontInfo() const { return m_nativeFontInfo; } + void SetNativeFontInfo(const wxNativeFontInfo& nativeFontInfo) + { + Free(); + + m_nativeFontInfo = nativeFontInfo; + } + protected: // common part of all ctors void Init(int size, const wxSize& pixelSize, bool sizeUsingPixels, - int family, - int style, - int weight, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding); void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0); - // font characterstics - int m_pointSize; - wxSize m_pixelSize; - bool m_sizeUsingPixels; - int m_family; - int m_style; - int m_weight; - bool m_underlined; - wxString m_faceName; - wxFontEncoding m_encoding; + // are we using m_nativeFontInfo.lf.lfHeight for point size or pixel size? + bool m_sizeUsingPixels; - // Windows font handle - WXHFONT m_hFont; + // Windows font handle, created on demand in GetHFONT() + HFONT m_hFont; // Native font info wxNativeFontInfo m_nativeFontInfo; - bool m_nativeFontInfoOk; }; +#define M_FONTDATA ((wxFontRefData*)m_refData) + // ============================================================================ // implementation // ============================================================================ @@ -335,27 +311,33 @@ protected: void wxFontRefData::Init(int pointSize, const wxSize& pixelSize, bool sizeUsingPixels, - int family, - int style, - int weight, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding) { - m_style = style; - m_pointSize = pointSize == -1 ? wxNORMAL_FONT->GetPointSize() : pointSize; - m_pixelSize = pixelSize; + m_hFont = NULL; + m_sizeUsingPixels = sizeUsingPixels; - m_family = family; - m_style = style; - m_weight = weight; - m_underlined = underlined; - m_faceName = faceName; - m_encoding = encoding; + if ( m_sizeUsingPixels ) + SetPixelSize(pixelSize); + else + SetPointSize(pointSize); - m_hFont = 0; + SetStyle(style); + SetWeight(weight); + SetUnderlined(underlined); - m_nativeFontInfoOk = false; + // set the family/facename + SetFamily(family); + if ( !faceName.empty() ) + SetFaceName(faceName); + + // deal with encoding now (it may override the font family and facename + // so do it after setting them) + SetEncoding(encoding); } void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont) @@ -364,13 +346,10 @@ void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont) // 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_hFont = (HFONT)hFont; m_nativeFontInfo = info; - // This is the best we can do since we don't have the - // correct information at this point. - m_family = wxSWISS; + + // TODO: m_sizeUsingPixels? } wxFontRefData::~wxFontRefData() @@ -378,24 +357,15 @@ wxFontRefData::~wxFontRefData() Free(); } -bool wxFontRefData::Alloc(wxFont *font) +bool wxFontRefData::Alloc() { - if ( !m_nativeFontInfoOk ) - { - wxFillLogFont(&m_nativeFontInfo.lf, font); - m_nativeFontInfoOk = true; - } - - HFONT hfont = ::CreateFontIndirect(&m_nativeFontInfo.lf); - if ( !hfont ) + m_hFont = ::CreateFontIndirect(&m_nativeFontInfo.lf); + if ( !m_hFont ) { wxLogLastError(wxT("CreateFont")); - return false; } - m_hFont = (WXHFONT)hfont; - return true; } @@ -403,7 +373,7 @@ void wxFontRefData::Free() { if ( m_hFont ) { - if ( !::DeleteObject((HFONT) m_hFont) ) + if ( !::DeleteObject(m_hFont) ) { wxLogLastError(wxT("DeleteObject(font)")); } @@ -419,6 +389,18 @@ void wxFontRefData::Free() void wxNativeFontInfo::Init() { wxZeroMemory(lf); + + // we get better font quality if we use PROOF_QUALITY instead of + // DEFAULT_QUALITY but some fonts (e.g. "Terminal 6pt") are not available + // then so we allow to set a global option to choose between quality and + // wider font selection +#ifdef __WXWINCE__ + lf.lfQuality = CLEARTYPE_QUALITY; +#else + lf.lfQuality = wxSystemOptions::GetOptionInt("msw.font.no-proof-quality") + ? DEFAULT_QUALITY + : PROOF_QUALITY; +#endif } int wxNativeFontInfo::GetPointSize() const @@ -427,13 +409,14 @@ int wxNativeFontInfo::GetPointSize() const // for printing! const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); - return (int) (((72.0*(double)abs(lf.lfHeight)) / (double) ppInch) + 0.5); + // BC++ 2007 doesn't provide abs(long) overload, hence the cast + return (int) (((72.0*abs((int)lf.lfHeight)) / (double) ppInch) + 0.5); } wxSize wxNativeFontInfo::GetPixelSize() const { wxSize ret; - ret.SetHeight(lf.lfHeight); + ret.SetHeight(abs((int)lf.lfHeight)); ret.SetWidth(lf.lfWidth); return ret; } @@ -471,14 +454,14 @@ wxFontFamily wxNativeFontInfo::GetFamily() const // extract family from pitch-and-family switch ( lf.lfPitchAndFamily & ~PITCH_MASK ) { + case 0: + family = wxFONTFAMILY_UNKNOWN; + break; + case FF_ROMAN: family = wxFONTFAMILY_ROMAN; break; - default: - wxFAIL_MSG( _T("unknown LOGFONT::lfFamily value") ); - // fall through - case FF_SWISS: family = wxFONTFAMILY_SWISS; break; @@ -494,6 +477,11 @@ wxFontFamily wxNativeFontInfo::GetFamily() const case FF_DECORATIVE: family = wxFONTFAMILY_DECORATIVE; break; + + default: + wxFAIL_MSG( "unknown LOGFONT::lfFamily value" ); + family = wxFONTFAMILY_UNKNOWN; + // just to avoid a warning } return family; @@ -515,17 +503,22 @@ void wxNativeFontInfo::SetPointSize(int pointsize) void wxNativeFontInfo::SetPixelSize(const wxSize& pixelSize) { + // NOTE: although the MSW port allows for negative pixel size heights, + // other ports don't and since it's a very useful feature assert + // here if we get a negative height: + wxCHECK_RET( pixelSize.GetWidth() >= 0 && pixelSize.GetHeight() > 0, + "Negative values for the pixel size or zero pixel height are not allowed" ); + lf.lfHeight = pixelSize.GetHeight(); lf.lfWidth = pixelSize.GetWidth(); } - void wxNativeFontInfo::SetStyle(wxFontStyle style) { switch ( style ) { default: - wxFAIL_MSG( _T("unknown font style") ); + wxFAIL_MSG( "unknown font style" ); // fall through case wxFONTSTYLE_NORMAL: @@ -544,7 +537,7 @@ void wxNativeFontInfo::SetWeight(wxFontWeight weight) switch ( weight ) { default: - wxFAIL_MSG( _T("unknown font weight") ); + wxFAIL_MSG( "unknown font weight" ); // fall through case wxFONTWEIGHT_NORMAL: @@ -566,64 +559,91 @@ void wxNativeFontInfo::SetUnderlined(bool underlined) lf.lfUnderline = underlined; } -void wxNativeFontInfo::SetFaceName(wxString facename) +bool wxNativeFontInfo::SetFaceName(const wxString& facename) { - wxStrncpy(lf.lfFaceName, facename, WXSIZEOF(lf.lfFaceName)); + wxStrlcpy(lf.lfFaceName, facename.c_str(), WXSIZEOF(lf.lfFaceName)); + return true; } void wxNativeFontInfo::SetFamily(wxFontFamily family) { BYTE ff_family; - wxString facename; + wxArrayString facename; + + // the list of fonts associated with a family was partially + // taken from http://www.codestyle.org/css/font-family switch ( family ) { - case wxSCRIPT: + case wxFONTFAMILY_SCRIPT: ff_family = FF_SCRIPT; - facename = _T("Script"); + facename.Add(wxS("Script")); + facename.Add(wxS("Brush Script MT")); + facename.Add(wxS("Comic Sans MS")); + facename.Add(wxS("Lucida Handwriting")); break; - case wxDECORATIVE: + case wxFONTFAMILY_DECORATIVE: ff_family = FF_DECORATIVE; - facename = _T("Old English Text MT"); + facename.Add(wxS("Old English Text MT")); + facename.Add(wxS("Comic Sans MS")); + facename.Add(wxS("Lucida Handwriting")); break; - case wxROMAN: + case wxFONTFAMILY_ROMAN: ff_family = FF_ROMAN; - facename = _T("Times New Roman"); + facename.Add(wxS("Times New Roman")); + facename.Add(wxS("Georgia")); + facename.Add(wxS("Garamond")); + facename.Add(wxS("Bookman Old Style")); + facename.Add(wxS("Book Antiqua")); break; - case wxTELETYPE: - case wxMODERN: + case wxFONTFAMILY_TELETYPE: + case wxFONTFAMILY_MODERN: ff_family = FF_MODERN; - facename = _T("Courier New"); + facename.Add(wxS("Courier New")); + facename.Add(wxS("Lucida Console")); + facename.Add(wxS("Andale Mono")); + facename.Add(wxS("OCR A Extended")); + facename.Add(wxS("Terminal")); break; - case wxSWISS: + case wxFONTFAMILY_SWISS: ff_family = FF_SWISS; - facename = _T("Arial"); + facename.Add(wxS("Arial")); + facename.Add(wxS("Century Gothic")); + facename.Add(wxS("Lucida Sans Unicode")); + facename.Add(wxS("Tahoma")); + facename.Add(wxS("Trebuchet MS")); + facename.Add(wxS("Verdana")); break; - case wxDEFAULT: + case wxFONTFAMILY_DEFAULT: default: { // We want Windows 2000 or later to have new fonts even MS Shell Dlg // is returned as default GUI font for compatibility int verMaj; ff_family = FF_SWISS; - if(wxGetOsVersion(&verMaj) == wxWINDOWS_NT && verMaj >= 5) - facename = _T("MS Shell Dlg 2"); + if(wxGetOsVersion(&verMaj) == wxOS_WINDOWS_NT && verMaj >= 5) + facename.Add(wxS("MS Shell Dlg 2")); else - facename = _T("MS Shell Dlg"); + facename.Add(wxS("MS Shell Dlg")); + + // Quoting the MSDN: + // "MS Shell Dlg is a mapping mechanism that enables + // U.S. English Microsoft Windows NT, and Microsoft Windows 2000 to + // support locales that have characters that are not contained in code + // page 1252. It is not a font but a face name for a nonexistent font." } } lf.lfPitchAndFamily = (BYTE)(DEFAULT_PITCH) | ff_family; - if ( !wxStrlen(lf.lfFaceName) ) - { - SetFaceName(facename); - } + // reset the facename so that CreateFontIndirect() will automatically choose a + // face name based only on the font family. + lf.lfFaceName[0] = '\0'; } void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding) @@ -657,11 +677,11 @@ bool wxNativeFontInfo::FromString(const wxString& s) { long l; - wxStringTokenizer tokenizer(s, _T(";")); + wxStringTokenizer tokenizer(s, wxS(";"), wxTOKEN_RET_EMPTY_ALL); // first the version wxString token = tokenizer.GetNextToken(); - if ( token != _T('0') ) + if ( token != wxS('0') ) return false; token = tokenizer.GetNextToken(); @@ -729,10 +749,11 @@ bool wxNativeFontInfo::FromString(const wxString& s) return false; lf.lfPitchAndFamily = (BYTE)l; - token = tokenizer.GetNextToken(); - if(!token) + if ( !tokenizer.HasMoreTokens() ) return false; - wxStrcpy(lf.lfFaceName, token.c_str()); + + // the face name may be empty + wxStrcpy(lf.lfFaceName, tokenizer.GetNextToken()); return true; } @@ -741,7 +762,7 @@ wxString wxNativeFontInfo::ToString() const { wxString s; - s.Printf(_T("%d;%ld;%ld;%ld;%ld;%ld;%d;%d;%d;%d;%d;%d;%d;%d;%s"), + s.Printf(wxS("%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, @@ -765,8 +786,11 @@ wxString wxNativeFontInfo::ToString() const // wxFont // ---------------------------------------------------------------------------- -void wxFont::Init() +wxFont::wxFont(const wxString& fontdesc) { + wxNativeFontInfo info; + if ( info.FromString(fontdesc) ) + (void)Create(info); } bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont) @@ -775,27 +799,15 @@ bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont) m_refData = new wxFontRefData(info, hFont); - RealizeResource(); - - return true; -} - -wxFont::wxFont(const wxString& fontdesc) -{ - wxNativeFontInfo info; - if ( info.FromString(fontdesc) ) - (void)Create(info); + return RealizeResource(); } -/* Constructor for a font. Note that the real construction is done - * in wxDC::SetFont, when information is available about scaling etc. - */ bool wxFont::DoCreate(int pointSize, const wxSize& pixelSize, bool sizeUsingPixels, - int family, - int style, - int weight, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, const wxString& faceName, wxFontEncoding encoding) @@ -813,9 +825,7 @@ bool wxFont::DoCreate(int pointSize, family, style, weight, underlined, faceName, encoding); - RealizeResource(); - - return true; + return RealizeResource(); } wxFont::~wxFont() @@ -826,28 +836,32 @@ wxFont::~wxFont() // real implementation // ---------------------------------------------------------------------------- -bool wxFont::RealizeResource() +wxGDIRefData *wxFont::CreateGDIRefData() 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 - return true; - } + return new wxFontRefData(); +} + +wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const +{ + return new wxFontRefData(*static_cast(data)); +} - return M_FONTDATA->Alloc(this); +bool wxFont::RealizeResource() +{ + // NOTE: the GetHFONT() call automatically triggers a reallocation of + // the HFONT if necessary (will do nothing if we already have the resource); + // it returns NULL only if there is a failure in wxFontRefData::Alloc()... + return GetHFONT() != NULL; } bool wxFont::FreeResource(bool WXUNUSED(force)) { - if ( GetResourceHandle() ) - { - M_FONTDATA->Free(); + if ( !M_FONTDATA ) + return false; - return true; - } + M_FONTDATA->Free(); - return false; + return true; } WXHANDLE wxFont::GetResourceHandle() const @@ -857,27 +871,14 @@ WXHANDLE wxFont::GetResourceHandle() const WXHFONT wxFont::GetHFONT() const { + // NOTE: wxFontRefData::GetHFONT() will automatically call + // wxFontRefData::Alloc() if necessary return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0; } bool wxFont::IsFree() const { - return M_FONTDATA && (M_FONTDATA->GetHFONT() == 0); -} - -void wxFont::Unshare() -{ - // Don't change shared data - if ( !m_refData ) - { - m_refData = new wxFontRefData(); - } - else - { - wxFontRefData* ref = new wxFontRefData(*M_FONTDATA); - UnRef(); - m_refData = ref; - } + return M_FONTDATA && !M_FONTDATA->HasHFONT(); } // ---------------------------------------------------------------------------- @@ -886,85 +887,76 @@ void wxFont::Unshare() void wxFont::SetPointSize(int pointSize) { - Unshare(); + AllocExclusive(); + M_FONTDATA->Free(); M_FONTDATA->SetPointSize(pointSize); - - RealizeResource(); } void wxFont::SetPixelSize(const wxSize& pixelSize) { - Unshare(); + AllocExclusive(); M_FONTDATA->SetPixelSize(pixelSize); - - RealizeResource(); } -void wxFont::SetFamily(int family) +void wxFont::SetFamily(wxFontFamily family) { - Unshare(); + AllocExclusive(); M_FONTDATA->SetFamily(family); - - RealizeResource(); } -void wxFont::SetStyle(int style) +void wxFont::SetStyle(wxFontStyle style) { - Unshare(); + AllocExclusive(); M_FONTDATA->SetStyle(style); - - RealizeResource(); } -void wxFont::SetWeight(int weight) +void wxFont::SetWeight(wxFontWeight weight) { - Unshare(); + AllocExclusive(); M_FONTDATA->SetWeight(weight); - - RealizeResource(); } -void wxFont::SetFaceName(const wxString& faceName) +bool wxFont::SetFaceName(const wxString& faceName) { - Unshare(); + AllocExclusive(); - M_FONTDATA->SetFaceName(faceName); + if ( !M_FONTDATA->SetFaceName(faceName) ) + return false; - RealizeResource(); + // NB: using win32's GetObject() API on M_FONTDATA->GetHFONT() + // to retrieve a LOGFONT and then compare lf.lfFaceName + // with given facename is not reliable at all: + // Windows copies the facename given to ::CreateFontIndirect() + // without any validity check. + // Thus we use wxFontBase::SetFaceName to check if facename + // is valid... + return wxFontBase::SetFaceName(faceName); } void wxFont::SetUnderlined(bool underlined) { - Unshare(); + AllocExclusive(); M_FONTDATA->SetUnderlined(underlined); - - RealizeResource(); } void wxFont::SetEncoding(wxFontEncoding encoding) { - Unshare(); + AllocExclusive(); M_FONTDATA->SetEncoding(encoding); - - RealizeResource(); } void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info) { - Unshare(); - - FreeResource(); - - *M_FONTDATA = wxFontRefData(info); + AllocExclusive(); - RealizeResource(); + M_FONTDATA->SetNativeFontInfo(info); } // ---------------------------------------------------------------------------- @@ -973,83 +965,98 @@ void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info) int wxFont::GetPointSize() const { - wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); return M_FONTDATA->GetPointSize(); } wxSize wxFont::GetPixelSize() const { + wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid font") ); + return M_FONTDATA->GetPixelSize(); } bool wxFont::IsUsingSizeInPixels() const { - wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); return M_FONTDATA->IsUsingSizeInPixels(); } -int wxFont::GetFamily() const +wxFontFamily wxFont::GetFamily() const { - wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), wxFONTFAMILY_MAX, wxT("invalid font") ); return M_FONTDATA->GetFamily(); } -int wxFont::GetStyle() const +wxFontStyle wxFont::GetStyle() const { - wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") ); return M_FONTDATA->GetStyle(); } -int wxFont::GetWeight() const +wxFontWeight wxFont::GetWeight() const { - wxCHECK_MSG( Ok(), 0, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") ); return M_FONTDATA->GetWeight(); } bool wxFont::GetUnderlined() const { - wxCHECK_MSG( Ok(), false, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), false, wxT("invalid font") ); return M_FONTDATA->GetUnderlined(); } wxString wxFont::GetFaceName() const { - wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") ); return M_FONTDATA->GetFaceName(); } wxFontEncoding wxFont::GetEncoding() const { - wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); + wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); return M_FONTDATA->GetEncoding(); } const wxNativeFontInfo *wxFont::GetNativeFontInfo() const { - return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo()) - : NULL; + return IsOk() ? &(M_FONTDATA->GetNativeFontInfo()) : NULL; } -bool wxFont::IsFixedWidth() const +wxString wxFont::GetNativeFontInfoDesc() const { - if ( M_FONTDATA->HasNativeFontInfo() ) - { - // the two low-order bits specify the pitch of the font, the rest is - // family - BYTE pitch = - (BYTE)(M_FONTDATA->GetNativeFontInfo().lf.lfPitchAndFamily & PITCH_MASK); + wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") ); - return pitch == FIXED_PITCH; - } + // be sure we have an HFONT associated... + const_cast(this)->RealizeResource(); + return wxFontBase::GetNativeFontInfoDesc(); +} + +wxString wxFont::GetNativeFontInfoUserDesc() const +{ + wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") ); - return wxFontBase::IsFixedWidth(); + // be sure we have an HFONT associated... + const_cast(this)->RealizeResource(); + return wxFontBase::GetNativeFontInfoUserDesc(); } +bool wxFont::IsFixedWidth() const +{ + wxCHECK_MSG( IsOk(), false, wxT("invalid font") ); + + // the two low-order bits specify the pitch of the font, the rest is + // family + BYTE pitch = + (BYTE)(M_FONTDATA->GetNativeFontInfo().lf.lfPitchAndFamily & PITCH_MASK); + + return pitch == FIXED_PITCH; +}