X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/76e23cdba3a2e58e788dd18734e7893185531a5b..ad653fa23069c5d9378247084f03c9a718c3ad62:/src/msw/font.cpp?ds=sidebyside diff --git a/src/msw/font.cpp b/src/msw/font.cpp index 4fcafbeb96..ddeef61886 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,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "font.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,27 +24,33 @@ #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/msw/private.h" #endif // WX_PRECOMP +#include "wx/encinfo.h" #include "wx/fontutil.h" +#include "wx/fontmap.h" -#include "wx/msw/private.h" +#ifndef __WXWINCE__ + #include "wx/sysopt.h" +#endif -IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject) +#include "wx/scopeguard.h" +#include "wx/tokenzr.h" // ---------------------------------------------------------------------------- // 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 @@ -56,65 +58,283 @@ 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, wxSize(0,0), false, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL, + wxFONTWEIGHT_NORMAL, false, false, wxEmptyString, + wxFONTENCODING_DEFAULT); } wxFontRefData(int size, - int family, - int style, - int weight, + const wxSize& pixelSize, + bool sizeUsingPixels, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, + bool strikethrough, const wxString& faceName, wxFontEncoding encoding) { - Init(size, family, style, weight, underlined, faceName, encoding); + Init(size, pixelSize, sizeUsingPixels, family, style, weight, + underlined, strikethrough, faceName, encoding); + } + + wxFontRefData(const wxNativeFontInfo& info, WXHFONT hFont = 0) + { + Init(info, hFont); + } + + wxFontRefData(const wxFontRefData& data) : wxGDIRefData() + { + Init(data.m_nativeFontInfo); } virtual ~wxFontRefData(); + // operations + bool Alloc(); + + void Free(); + + // all wxFont accessors + int GetPointSize() const + { + return m_nativeFontInfo.GetPointSize(); + } + + wxSize GetPixelSize() const + { + return m_nativeFontInfo.GetPixelSize(); + } + + bool IsUsingSizeInPixels() const + { + return m_sizeUsingPixels; + } + + wxFontFamily GetFamily() const + { + return m_nativeFontInfo.GetFamily(); + } + + wxFontStyle GetStyle() const + { + return m_nativeFontInfo.GetStyle(); + } + + wxFontWeight GetWeight() const + { + return m_nativeFontInfo.GetWeight(); + } + + bool GetUnderlined() const + { + return m_nativeFontInfo.GetUnderlined(); + } + + bool GetStrikethrough() const + { + return m_nativeFontInfo.GetStrikethrough(); + } + + wxString GetFaceName() const + { + wxString facename = m_nativeFontInfo.GetFaceName(); + if ( facename.empty() ) + { + facename = GetMSWFaceName(); + if ( !facename.empty() ) + { + // cache the face name, it shouldn't change unless the family + // does and wxNativeFontInfo::SetFamily() resets the face name + const_cast(this)->SetFaceName(facename); + } + } + + return facename; + } + + wxFontEncoding GetEncoding() const + { + return m_nativeFontInfo.GetEncoding(); + } + + WXHFONT GetHFONT() const + { + AllocIfNeeded(); + + return (WXHFONT)m_hFont; + } + + bool HasHFONT() const + { + return m_hFont != 0; + } + + // ... 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) + { + Free(); + + m_nativeFontInfo.SetPointSize(pointSize); + m_sizeUsingPixels = false; + } + + void SetPixelSize(const wxSize& pixelSize) + { + wxCHECK_RET( pixelSize.GetWidth() >= 0, "negative font width" ); + wxCHECK_RET( pixelSize.GetHeight() != 0, "zero font height" ); + + Free(); + + m_nativeFontInfo.SetPixelSize(pixelSize); + m_sizeUsingPixels = true; + } + + void SetFamily(wxFontFamily family) + { + Free(); + + m_nativeFontInfo.SetFamily(family); + } + + void SetStyle(wxFontStyle style) + { + Free(); + + m_nativeFontInfo.SetStyle(style); + } + + void SetWeight(wxFontWeight weight) + { + Free(); + + m_nativeFontInfo.SetWeight(weight); + } + + bool SetFaceName(const wxString& faceName) + { + Free(); + + return m_nativeFontInfo.SetFaceName(faceName); + } + + void SetUnderlined(bool underlined) + { + Free(); + + m_nativeFontInfo.SetUnderlined(underlined); + } + + void SetStrikethrough(bool strikethrough) + { + Free(); + + m_nativeFontInfo.SetStrikethrough(strikethrough); + } + + void SetEncoding(wxFontEncoding encoding) + { + Free(); + + m_nativeFontInfo.SetEncoding(encoding); + } + + const wxNativeFontInfo& GetNativeFontInfo() const + { + // we need to create the font now to get the corresponding LOGFONT if + // it hadn't been done yet + AllocIfNeeded(); + + // ensure that we have a valid face name in our font information: + // GetFaceName() will try to retrieve it from our HFONT and save it if + // it was successful + (void)GetFaceName(); + + return m_nativeFontInfo; + } + + void SetNativeFontInfo(const wxNativeFontInfo& nativeFontInfo) + { + Free(); + + m_nativeFontInfo = nativeFontInfo; + } + protected: // common part of all ctors void Init(int size, - int family, - int style, - int weight, + const wxSize& pixelSize, + bool sizeUsingPixels, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, + bool strikethrough, 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; + void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0); + + void AllocIfNeeded() const + { + if ( !m_hFont ) + const_cast(this)->Alloc(); + } + + // retrieve the face name really being used by the font: this is used to + // get the face name selected by the system when we don't specify it (but + // use just the family for example) + wxString GetMSWFaceName() const + { + ScreenHDC hdc; + SelectInHDC selectFont(hdc, (HFONT)GetHFONT()); + + UINT otmSize = GetOutlineTextMetrics(hdc, 0, NULL); + if ( !otmSize ) + { + wxLogLastError("GetOutlineTextMetrics(NULL)"); + return wxString(); + } + + OUTLINETEXTMETRIC * const + otm = static_cast(malloc(otmSize)); + wxON_BLOCK_EXIT1( free, otm ); - int m_fontId; + otm->otmSize = otmSize; + if ( !GetOutlineTextMetrics(hdc, otmSize, otm) ) + { + wxLogLastError("GetOutlineTextMetrics()"); + return wxString(); + } + + // in spite of its type, the otmpFamilyName field of OUTLINETEXTMETRIC + // gives an offset in _bytes_ of the face (not family!) name from the + // struct start while the name itself is an array of TCHARs + // + // FWIW otmpFaceName contains the same thing as otmpFamilyName followed + // by a possible " Italic" or " Bold" or something else suffix + return reinterpret_cast(otm) + + wxPtrToUInt(otm->otmpFamilyName)/sizeof(wxChar); + } + + // are we using m_nativeFontInfo.lf.lfHeight for point size or pixel size? + bool m_sizeUsingPixels; - // font characterstics - int m_pointSize; - int m_family; - int m_style; - int m_weight; - bool m_underlined; - wxString m_faceName; - wxFontEncoding m_encoding; + // Windows font handle, created on demand in GetHFONT() + HFONT m_hFont; - // Windows font handle - WXHFONT m_hFont; + // Native font info + wxNativeFontInfo m_nativeFontInfo; }; +#define M_FONTDATA ((wxFontRefData*)m_refData) + // ============================================================================ // implementation // ============================================================================ @@ -124,235 +344,651 @@ protected: // ---------------------------------------------------------------------------- void wxFontRefData::Init(int pointSize, - int family, - int style, - int weight, + const wxSize& pixelSize, + bool sizeUsingPixels, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, bool underlined, + bool strikethrough, const wxString& faceName, wxFontEncoding encoding) { - m_style = style; - m_pointSize = pointSize; - m_family = family; - m_style = style; - m_weight = weight; - m_underlined = underlined; - m_faceName = faceName; - m_encoding = encoding; + m_hFont = NULL; + + m_sizeUsingPixels = sizeUsingPixels; + if ( m_sizeUsingPixels ) + SetPixelSize(pixelSize); + else + SetPointSize(pointSize); - m_fontId = 0; - m_temporary = FALSE; + SetStyle(style); + SetWeight(weight); + SetUnderlined(underlined); + SetStrikethrough(strikethrough); - m_hFont = 0; + // 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) +{ + // 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)hFont; + m_nativeFontInfo = info; + + // TODO: m_sizeUsingPixels? } wxFontRefData::~wxFontRefData() +{ + Free(); +} + +bool wxFontRefData::Alloc() +{ + m_hFont = ::CreateFontIndirect(&m_nativeFontInfo.lf); + if ( !m_hFont ) + { + wxLogLastError(wxT("CreateFont")); + return false; + } + + return true; +} + +void wxFontRefData::Free() { if ( m_hFont ) { - if ( !::DeleteObject((HFONT) m_hFont) ) + if ( !::DeleteObject(m_hFont) ) { wxLogLastError(wxT("DeleteObject(font)")); } + + m_hFont = 0; } } // ---------------------------------------------------------------------------- -// wxFont +// wxNativeFontInfo // ---------------------------------------------------------------------------- -void wxFont::Init() +void wxNativeFontInfo::Init() { - if ( wxTheFontList ) - wxTheFontList->Append(this); + 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 } -bool wxFont::Create(const wxNativeFontInfo& info) +int wxNativeFontInfo::GetPointSize() const { - return Create(info.pointSize, info.family, info.style, info.weight, - info.underlined, info.faceName, info.encoding); + // FIXME: using the screen here results in incorrect font size calculation + // for printing! + const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY); + + // BC++ 2007 doesn't provide abs(long) overload, hence the cast + return (int) (((72.0*abs((int)lf.lfHeight)) / (double) ppInch) + 0.5); } -wxFont::wxFont(const wxString& fontdesc) +wxSize wxNativeFontInfo::GetPixelSize() const { - wxNativeFontInfo info; - if ( info.FromString(fontdesc) ) - (void)Create(info); + wxSize ret; + ret.SetHeight(abs((int)lf.lfHeight)); + ret.SetWidth(lf.lfWidth); + return ret; } -/* 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) +wxFontStyle wxNativeFontInfo::GetStyle() const { - UnRef(); + return lf.lfItalic ? wxFONTSTYLE_ITALIC : wxFONTSTYLE_NORMAL; +} - // 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; +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + if ( lf.lfWeight <= 300 ) + return wxFONTWEIGHT_LIGHT; - m_refData = new wxFontRefData(pointSize, family, style, weight, - underlined, faceName, encoding); + if ( lf.lfWeight >= 600 ) + return wxFONTWEIGHT_BOLD; - RealizeResource(); + return wxFONTWEIGHT_NORMAL; +} - return TRUE; +bool wxNativeFontInfo::GetUnderlined() const +{ + return lf.lfUnderline != 0; } -wxFont::~wxFont() +bool wxNativeFontInfo::GetStrikethrough() const { - if ( wxTheFontList ) - wxTheFontList->DeleteObject(this); + return lf.lfStrikeOut != 0; } -// ---------------------------------------------------------------------------- -// real implementation -// ---------------------------------------------------------------------------- +wxString wxNativeFontInfo::GetFaceName() const +{ + return lf.lfFaceName; +} -bool wxFont::RealizeResource() +wxFontFamily wxNativeFontInfo::GetFamily() const { - if ( GetResourceHandle() ) + wxFontFamily family; + + // extract family from pitch-and-family + switch ( lf.lfPitchAndFamily & ~PITCH_MASK ) { - // VZ: the old code returned FALSE in this case, but it doesn't seem - // to make sense because the font _was_ created - return TRUE; + case 0: + family = wxFONTFAMILY_UNKNOWN; + break; + + case FF_ROMAN: + family = wxFONTFAMILY_ROMAN; + break; + + case FF_SWISS: + family = wxFONTFAMILY_SWISS; + break; + + case FF_SCRIPT: + family = wxFONTFAMILY_SCRIPT; + break; + + case FF_MODERN: + family = wxFONTFAMILY_MODERN; + break; + + case FF_DECORATIVE: + family = wxFONTFAMILY_DECORATIVE; + break; + + default: + wxFAIL_MSG( "unknown LOGFONT::lfFamily value" ); + family = wxFONTFAMILY_UNKNOWN; + // just to avoid a warning } - LOGFONT lf; - wxFillLogFont(&lf, this); - M_FONTDATA->m_hFont = (WXHFONT)::CreateFontIndirect(&lf); - M_FONTDATA->m_faceName = lf.lfFaceName; - if ( !M_FONTDATA->m_hFont ) + return family; +} + +wxFontEncoding wxNativeFontInfo::GetEncoding() const +{ + return wxGetFontEncFromCharSet(lf.lfCharSet); +} + +void wxNativeFontInfo::SetPointSize(int pointsize) +{ + // 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); +} + +void wxNativeFontInfo::SetPixelSize(const wxSize& pixelSize) +{ + // MSW accepts both positive and negative heights here but they mean + // different things: positive specifies the cell height while negative + // specifies the character height. We used to just pass the value to MSW + // unchanged but changed the behaviour for positive values in 2.9.1 to + // match other ports and, more importantly, the expected behaviour. So now + // passing the negative height doesn't make sense at all any more but we + // still accept it for compatibility with the existing code which worked + // around the wrong interpretation of the height argument in older wxMSW + // versions by passing a negative value explicitly itself. + lf.lfHeight = -abs(pixelSize.GetHeight()); + lf.lfWidth = pixelSize.GetWidth(); +} + +void wxNativeFontInfo::SetStyle(wxFontStyle style) +{ + switch ( style ) { - wxLogLastError(wxT("CreateFont")); + default: + wxFAIL_MSG( "unknown font style" ); + // fall through + + case wxFONTSTYLE_NORMAL: + lf.lfItalic = FALSE; + break; + + case wxFONTSTYLE_ITALIC: + case wxFONTSTYLE_SLANT: + lf.lfItalic = TRUE; + break; + } +} + +void wxNativeFontInfo::SetWeight(wxFontWeight weight) +{ + switch ( weight ) + { + default: + wxFAIL_MSG( "unknown font weight" ); + // fall through + + case wxFONTWEIGHT_NORMAL: + lf.lfWeight = FW_NORMAL; + break; + + case wxFONTWEIGHT_LIGHT: + lf.lfWeight = FW_LIGHT; + break; + + case wxFONTWEIGHT_BOLD: + lf.lfWeight = FW_BOLD; + break; + } +} + +void wxNativeFontInfo::SetUnderlined(bool underlined) +{ + lf.lfUnderline = underlined; +} + +void wxNativeFontInfo::SetStrikethrough(bool strikethrough) +{ + lf.lfStrikeOut = strikethrough; +} + +bool wxNativeFontInfo::SetFaceName(const wxString& facename) +{ + wxStrlcpy(lf.lfFaceName, facename.c_str(), WXSIZEOF(lf.lfFaceName)); + return true; +} + +void wxNativeFontInfo::SetFamily(wxFontFamily family) +{ + BYTE ff_family = FF_DONTCARE; - return FALSE; + switch ( family ) + { + case wxFONTFAMILY_SCRIPT: + ff_family = FF_SCRIPT; + break; + + case wxFONTFAMILY_DECORATIVE: + ff_family = FF_DECORATIVE; + break; + + case wxFONTFAMILY_ROMAN: + ff_family = FF_ROMAN; + break; + + case wxFONTFAMILY_TELETYPE: + case wxFONTFAMILY_MODERN: + ff_family = FF_MODERN; + break; + + case wxFONTFAMILY_SWISS: + case wxFONTFAMILY_DEFAULT: + ff_family = FF_SWISS; + break; + + case wxFONTFAMILY_UNKNOWN: + wxFAIL_MSG( "invalid font family" ); + return; } - return TRUE; + wxCHECK_RET( ff_family != FF_DONTCARE, "unknown wxFontFamily" ); + + lf.lfPitchAndFamily = (BYTE)(DEFAULT_PITCH) | ff_family; + + // reset the facename so that CreateFontIndirect() will automatically choose a + // face name based only on the font family. + lf.lfFaceName[0] = '\0'; } -bool wxFont::FreeResource(bool force) +void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding) { - if ( GetResourceHandle() ) + wxNativeEncodingInfo info; + if ( !wxGetNativeFontEncoding(encoding, &info) ) { - if ( !::DeleteObject((HFONT) M_FONTDATA->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; + } + } - M_FONTDATA->m_hFont = 0; + lf.lfCharSet = (BYTE)info.charset; +} - return TRUE; - } - return FALSE; +bool wxNativeFontInfo::FromString(const wxString& s) +{ + long l; + + wxStringTokenizer tokenizer(s, wxS(";"), wxTOKEN_RET_EMPTY_ALL); + + // first the version + wxString token = tokenizer.GetNextToken(); + if ( token != wxS('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; + + if ( !tokenizer.HasMoreTokens() ) + return false; + + // the face name may be empty + SetFaceName(tokenizer.GetNextToken()); + + return true; } -WXHANDLE wxFont::GetResourceHandle() +wxString wxNativeFontInfo::ToString() const { - return GetHFONT(); + wxString 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, + 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; } -WXHFONT wxFont::GetHFONT() const +// ---------------------------------------------------------------------------- +// wxFont +// ---------------------------------------------------------------------------- + +wxFont::wxFont(const wxString& fontdesc) { - if ( !M_FONTDATA ) - return 0; - else - return (WXHANDLE)M_FONTDATA->m_hFont; + wxNativeFontInfo info; + if ( info.FromString(fontdesc) ) + (void)Create(info); } -bool wxFont::IsFree() const +wxFont::wxFont(const wxFontInfo& info) { - return (M_FONTDATA && (M_FONTDATA->m_hFont == 0)); + m_refData = new wxFontRefData(info.GetPointSize(), + info.GetPixelSize(), + info.IsUsingSizeInPixels(), + info.GetFamily(), + info.GetStyle(), + info.GetWeight(), + info.IsUnderlined(), + info.IsStrikethrough(), + info.GetFaceName(), + info.GetEncoding()); } -void wxFont::Unshare() +bool wxFont::Create(const wxNativeFontInfo& info, WXHFONT hFont) { - // Don't change shared data - if ( !m_refData ) - { - m_refData = new wxFontRefData(); - } - else + UnRef(); + + m_refData = new wxFontRefData(info, hFont); + + return RealizeResource(); +} + +bool wxFont::DoCreate(int pointSize, + const wxSize& pixelSize, + bool sizeUsingPixels, + wxFontFamily family, + wxFontStyle style, + wxFontWeight weight, + bool underlined, + const wxString& faceName, + wxFontEncoding encoding) +{ + UnRef(); + + // 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 == -1 ) { - wxFontRefData* ref = new wxFontRefData(*M_FONTDATA); - UnRef(); - m_refData = ref; + pointSize = wxNORMAL_FONT->GetPointSize(); } + + m_refData = new wxFontRefData(pointSize, pixelSize, sizeUsingPixels, + family, style, weight, + underlined, false, faceName, encoding); + + return RealizeResource(); +} + +wxFont::~wxFont() +{ } // ---------------------------------------------------------------------------- -// change font attribute: we recreate font when doing it +// real implementation // ---------------------------------------------------------------------------- -void wxFont::SetPointSize(int pointSize) +wxGDIRefData *wxFont::CreateGDIRefData() const { - Unshare(); + return new wxFontRefData(); +} - M_FONTDATA->m_pointSize = pointSize; +wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const +{ + return new wxFontRefData(*static_cast(data)); +} - RealizeResource(); +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; } -void wxFont::SetFamily(int family) +bool wxFont::FreeResource(bool WXUNUSED(force)) { - Unshare(); + if ( !M_FONTDATA ) + return false; - M_FONTDATA->m_family = family; + M_FONTDATA->Free(); - RealizeResource(); + return true; } -void wxFont::SetStyle(int style) +WXHANDLE wxFont::GetResourceHandle() const { - Unshare(); + return (WXHANDLE)GetHFONT(); +} + +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->HasHFONT(); +} + +// ---------------------------------------------------------------------------- +// change font attribute: we recreate font when doing it +// ---------------------------------------------------------------------------- + +void wxFont::SetPointSize(int pointSize) +{ + AllocExclusive(); + + M_FONTDATA->Free(); + M_FONTDATA->SetPointSize(pointSize); +} - M_FONTDATA->m_style = style; +void wxFont::SetPixelSize(const wxSize& pixelSize) +{ + AllocExclusive(); - RealizeResource(); + M_FONTDATA->SetPixelSize(pixelSize); } -void wxFont::SetWeight(int weight) +void wxFont::SetFamily(wxFontFamily family) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_weight = weight; + M_FONTDATA->SetFamily(family); +} - RealizeResource(); +void wxFont::SetStyle(wxFontStyle style) +{ + AllocExclusive(); + + M_FONTDATA->SetStyle(style); } -void wxFont::SetFaceName(const wxString& faceName) +void wxFont::SetWeight(wxFontWeight weight) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_faceName = faceName; + M_FONTDATA->SetWeight(weight); +} - RealizeResource(); +bool wxFont::SetFaceName(const wxString& faceName) +{ + AllocExclusive(); + + if ( !M_FONTDATA->SetFaceName(faceName) ) + return false; + + // 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->m_underlined = underlined; + M_FONTDATA->SetUnderlined(underlined); +} - RealizeResource(); +void wxFont::SetStrikethrough(bool strikethrough) +{ + AllocExclusive(); + + M_FONTDATA->SetStrikethrough(strikethrough); } void wxFont::SetEncoding(wxFontEncoding encoding) { - Unshare(); + AllocExclusive(); - M_FONTDATA->m_encoding = encoding; + M_FONTDATA->SetEncoding(encoding); +} - RealizeResource(); +void wxFont::DoSetNativeFontInfo(const wxNativeFontInfo& info) +{ + AllocExclusive(); + + M_FONTDATA->SetNativeFontInfo(info); } // ---------------------------------------------------------------------------- @@ -361,44 +997,94 @@ void wxFont::SetEncoding(wxFontEncoding encoding) int wxFont::GetPointSize() const { - return M_FONTDATA->m_pointSize; + wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); + + return M_FONTDATA->GetPointSize(); } -int wxFont::GetFamily() const +wxSize wxFont::GetPixelSize() const { - return M_FONTDATA->m_family; + wxCHECK_MSG( IsOk(), wxDefaultSize, wxT("invalid font") ); + + return M_FONTDATA->GetPixelSize(); } -int wxFont::GetFontId() const +bool wxFont::IsUsingSizeInPixels() const { - return M_FONTDATA->m_fontId; + wxCHECK_MSG( IsOk(), 0, wxT("invalid font") ); + + return M_FONTDATA->IsUsingSizeInPixels(); } -int wxFont::GetStyle() const +wxFontFamily wxFont::DoGetFamily() const { - return M_FONTDATA->m_style; + return M_FONTDATA->GetFamily(); } -int wxFont::GetWeight() const +wxFontStyle wxFont::GetStyle() const { - return M_FONTDATA->m_weight; + wxCHECK_MSG( IsOk(), wxFONTSTYLE_MAX, wxT("invalid font") ); + + return M_FONTDATA->GetStyle(); +} + +wxFontWeight wxFont::GetWeight() const +{ + wxCHECK_MSG( IsOk(), wxFONTWEIGHT_MAX, wxT("invalid font") ); + + return M_FONTDATA->GetWeight(); } bool wxFont::GetUnderlined() const { - return M_FONTDATA->m_underlined; + wxCHECK_MSG( IsOk(), false, wxT("invalid font") ); + + return M_FONTDATA->GetUnderlined(); +} + +bool wxFont::GetStrikethrough() const +{ + wxCHECK_MSG( IsOk(), false, wxT("invalid font") ); + + return M_FONTDATA->GetStrikethrough(); } wxString wxFont::GetFaceName() const { - wxString str; - if ( M_FONTDATA ) - str = M_FONTDATA->m_faceName; - return str; + wxCHECK_MSG( IsOk(), wxEmptyString, wxT("invalid font") ); + + return M_FONTDATA->GetFaceName(); } wxFontEncoding wxFont::GetEncoding() const { - return M_FONTDATA->m_encoding; + wxCHECK_MSG( IsOk(), wxFONTENCODING_DEFAULT, wxT("invalid font") ); + + return M_FONTDATA->GetEncoding(); +} + +const wxNativeFontInfo *wxFont::GetNativeFontInfo() const +{ + return IsOk() ? &(M_FONTDATA->GetNativeFontInfo()) : NULL; } +bool wxFont::IsFixedWidth() const +{ + wxCHECK_MSG( IsOk(), false, wxT("invalid font") ); + + // LOGFONT doesn't contain the correct pitch information so we need to call + // GetTextMetrics() to get it + ScreenHDC hdc; + SelectInHDC selectFont(hdc, M_FONTDATA->GetHFONT()); + + TEXTMETRIC tm; + if ( !::GetTextMetrics(hdc, &tm) ) + { + wxLogLastError(wxT("GetTextMetrics")); + return false; + } + + // Quoting MSDN description of TMPF_FIXED_PITCH: "Note very carefully that + // those meanings are the opposite of what the constant name implies." + return !(tm.tmPitchAndFamily & TMPF_FIXED_PITCH); +}