#include "wx/fontutil.h"
#include "wx/fontmap.h"
+#ifndef __WXWINCE__
+ #include "wx/sysopt.h"
+#endif
+
#include "wx/tokenzr.h"
#if wxUSE_EXTENDED_RTTI
virtual ~wxFontRefData();
// operations
- bool Alloc(wxFont *font);
+ bool Alloc(const wxFont *font);
void Free();
: m_encoding;
}
- WXHFONT GetHFONT() const { return m_hFont; }
+ WXHFONT GetHFONT(const wxFont *font) const
+ {
+ if ( !m_hFont )
+ wx_const_cast(wxFontRefData *, this)->Alloc(font);
+
+ return (WXHFONT)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)
{
+ Free();
+
if ( m_nativeFontInfoOk )
{
m_nativeFontInfo.SetPointSize(pointSize);
void SetPixelSize(const wxSize& pixelSize)
{
+ Free();
+
if ( m_nativeFontInfoOk )
{
m_nativeFontInfo.SetPixelSize(pixelSize);
void SetFamily(int family)
{
+ Free();
+
m_family = family;
}
void SetStyle(int style)
{
+ Free();
+
if ( m_nativeFontInfoOk )
m_nativeFontInfo.SetStyle((wxFontStyle)style);
else
void SetWeight(int weight)
{
+ Free();
+
if ( m_nativeFontInfoOk )
m_nativeFontInfo.SetWeight((wxFontWeight)weight);
else
bool SetFaceName(const wxString& faceName)
{
+ Free();
+
if ( m_nativeFontInfoOk )
return m_nativeFontInfo.SetFaceName(faceName);
- m_faceName = faceName;
+ m_faceName = faceName;
return true;
}
void SetUnderlined(bool underlined)
{
+ Free();
+
if ( m_nativeFontInfoOk )
m_nativeFontInfo.SetUnderlined(underlined);
else
void SetEncoding(wxFontEncoding encoding)
{
+ Free();
+
if ( m_nativeFontInfoOk )
m_nativeFontInfo.SetEncoding(encoding);
else
m_encoding = encoding;
}
- // native font info tests
+ // native font info
bool HasNativeFontInfo() const { return m_nativeFontInfoOk; }
const wxNativeFontInfo& GetNativeFontInfo() const
{ return m_nativeFontInfo; }
+ void SetNativeFontInfo(const wxNativeFontInfo& nativeFontInfo)
+ {
+ Free();
+
+ m_nativeFontInfo = nativeFontInfo;
+ m_nativeFontInfoOk = true;
+ }
+
protected:
// common part of all ctors
void Init(int size,
void Init(const wxNativeFontInfo& info, WXHFONT hFont = 0);
- // font characterstics
+ // font characteristics
int m_pointSize;
wxSize m_pixelSize;
bool m_sizeUsingPixels;
wxString m_faceName;
wxFontEncoding m_encoding;
- // Windows font handle
- WXHFONT m_hFont;
+ // Windows font handle, created on demand in GetHFONT()
+ HFONT m_hFont;
// Native font info
wxNativeFontInfo m_nativeFontInfo;
// 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_hFont = (HFONT)hFont;
m_nativeFontInfoOk = true;
m_nativeFontInfo = info;
Free();
}
-bool wxFontRefData::Alloc(wxFont *font)
+bool wxFontRefData::Alloc(const wxFont *font)
{
if ( !m_nativeFontInfoOk )
{
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;
}
{
if ( m_hFont )
{
- if ( !::DeleteObject((HFONT) m_hFont) )
+ if ( !::DeleteObject(m_hFont) )
{
wxLogLastError(wxT("DeleteObject(font)"));
}
{
wxZeroMemory(lf);
- // we get better font quality if we use this instead of DEFAULT_QUALITY
- // apparently without any drawbacks
+ // 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 = PROOF_QUALITY;
+ lf.lfQuality = wxSystemOptions::GetOptionInt(_T("msw.font.no-proof-quality"))
+ ? DEFAULT_QUALITY
+ : PROOF_QUALITY;
#endif
}
// 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;
}
lf.lfClipPrecision,
lf.lfQuality,
lf.lfPitchAndFamily,
- lf.lfFaceName);
+ (const wxChar*)lf.lfFaceName);
return s;
}
m_refData = new wxFontRefData(info, hFont);
- RealizeResource();
-
- return true;
+ return RealizeResource();
}
wxFont::wxFont(const wxString& fontdesc)
(void)Create(info);
}
-/* 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,
family, style, weight,
underlined, faceName, encoding);
- RealizeResource();
-
- return true;
+ return RealizeResource();
}
wxFont::~wxFont()
// real implementation
// ----------------------------------------------------------------------------
+wxGDIRefData *wxFont::CreateGDIRefData() const
+{
+ return new wxFontRefData();
+}
+
+wxGDIRefData *wxFont::CloneGDIRefData(const wxGDIRefData *data) const
+{
+ return new wxFontRefData(*wx_static_cast(const wxFontRefData *, data));
+}
+
bool wxFont::RealizeResource()
{
- if ( GetResourceHandle() )
- {
- // VZ: the old code returned false in this case, but it doesn't seem
- // to make sense because the font _was_ created
+ // don't do anything if we already have a valid font
+ if ( GetHFONT() )
return true;
- }
return M_FONTDATA->Alloc(this);
}
bool wxFont::FreeResource(bool WXUNUSED(force))
{
- if ( GetResourceHandle() )
- {
- M_FONTDATA->Free();
+ if ( !GetHFONT() )
+ return false;
- return true;
- }
+ M_FONTDATA->Free();
- return false;
+ return true;
}
WXHANDLE wxFont::GetResourceHandle() const
WXHFONT wxFont::GetHFONT() const
{
- return M_FONTDATA ? M_FONTDATA->GetHFONT() : 0;
+ return M_FONTDATA ? M_FONTDATA->GetHFONT(this) : 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();
}
// ----------------------------------------------------------------------------
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)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->SetFamily(family);
-
- RealizeResource();
}
void wxFont::SetStyle(int style)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->SetStyle(style);
-
- RealizeResource();
}
void wxFont::SetWeight(int weight)
{
- Unshare();
+ AllocExclusive();
M_FONTDATA->SetWeight(weight);
-
- RealizeResource();
}
bool wxFont::SetFaceName(const wxString& faceName)
{
- Unshare();
+ AllocExclusive();
- bool refdataok = M_FONTDATA->SetFaceName(faceName);
-
- RealizeResource();
+ 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
// without any validity check.
// Thus we use wxFontBase::SetFaceName to check if facename
// is valid...
- return refdataok && wxFontBase::SetFaceName(faceName);
+ 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();
+ AllocExclusive();
- FreeResource();
-
- *M_FONTDATA = wxFontRefData(info);
-
- RealizeResource();
+ M_FONTDATA->SetNativeFontInfo(info);
}
// ----------------------------------------------------------------------------
wxSize wxFont::GetPixelSize() const
{
+ wxCHECK_MSG( Ok(), wxDefaultSize, wxT("invalid font") );
+
return M_FONTDATA->GetPixelSize();
}
const wxNativeFontInfo *wxFont::GetNativeFontInfo() const
{
- return M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo())
+ return Ok() && M_FONTDATA->HasNativeFontInfo() ? &(M_FONTDATA->GetNativeFontInfo())
: NULL;
}
wxString wxFont::GetNativeFontInfoDesc() const
{
+ wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
+
// be sure we have an HFONT associated...
wxConstCast(this, wxFont)->RealizeResource();
return wxFontBase::GetNativeFontInfoDesc();
wxString wxFont::GetNativeFontInfoUserDesc() const
{
+ wxCHECK_MSG( Ok(), wxEmptyString, wxT("invalid font") );
+
// be sure we have an HFONT associated...
wxConstCast(this, wxFont)->RealizeResource();
return wxFontBase::GetNativeFontInfoUserDesc();
projects / wxWidgets.git / blobdiff