Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxFont can now raelly use the native fonts

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@13160 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2001-12-22 03:31:48 +00:00
parent 7c349adb6e
commit a9249b2eb2
3 changed files with 321 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
include/wx/msw/font.h
View File

@@ -86,7 +86,6 @@ public:
// implementation only from now on
// -------------------------------
int GetFontId() const;
virtual bool IsFree() const;
virtual bool RealizeResource();
virtual WXHANDLE GetResourceHandle();

22
src/common/fontcmn.cpp
View File

@@ -423,19 +423,29 @@ wxString wxNativeFontInfo::ToUserString() const
// we don't distinguish between the two for now anyhow...
case wxFONTSTYLE_ITALIC:
case wxFONTSTYLE_SLANT:
desc << _("italic ");
desc << _("italic");
break;
}
if ( !facename.empty() )
wxString face = GetFaceName();
if ( !face.empty() )
{
desc << facename << _T(' ');
desc << _T(' ') << face;
}
if ( pointsize != wxNORMAL_FONT->GetPointSize() )
int size = GetPointSize();
if ( size != wxNORMAL_FONT->GetPointSize() )
{
desc << pointsize;
desc << _T(' ') << size;
}
wxFontEncoding enc = GetEncoding();
if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
{
desc << _T(' ') << wxTheFontMapper->GetEncodingName(enc);
}
return desc;
}
bool wxNativeFontInfo::FromUserString(const wxString& s)
@@ -478,7 +488,7 @@ bool wxNativeFontInfo::FromUserString(const wxString& s)
}
else if ( token.ToULong(&size) )
{
pointsize = (int)size;
SetPointSize(size);
}
else if ( (encoding = wxTheFontMapper->CharsetToEncoding(token, FALSE))
!= wxFONTENCODING_DEFAULT )

430
src/msw/font.cpp
View File

@@ -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
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
@@ -49,30 +49,18 @@ IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
// constants
// ----------------------------------------------------------------------------
// the default font size in points
static const int wxDEFAULT_FONT_SIZE = 12;
// ----------------------------------------------------------------------------
// wxFontRefData - the internal description of the font
// ----------------------------------------------------------------------------
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, _T(""), wxFONTENCODING_DEFAULT);
}
wxFontRefData(int size,
@@ -91,8 +79,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 +220,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 +254,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 +262,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,6 +269,8 @@ void wxFontRefData::Init(int pointSize,
void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont)
{
// we don't really need the family, what for?
#if 0
// extract family from pitch-and-family
int lfFamily = info.lf.lfPitchAndFamily;
if ( lfFamily & FIXED_PITCH )
@@ -195,40 +303,7 @@ void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont)
default:
m_family = wxSWISS;
}
// weight and style
switch ( info.lf.lfWeight )
{
case FW_LIGHT:
m_weight = wxLIGHT;
break;
default:
case FW_NORMAL:
m_weight = wxNORMAL;
break;
case FW_BOLD:
m_weight = wxBOLD;
break;
}
m_style = info.lf.lfItalic ? wxITALIC : wxNORMAL;
m_underlined = info.lf.lfUnderline != 0;
m_faceName = info.lf.lfFaceName;
int height = abs(info.lf.lfHeight);
// remember that 1pt = 1/72inch
const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
m_pointSize = (int) (((72.0*((double)height))/(double) ppInch) + 0.5);
m_encoding = wxGetFontEncFromCharSet(info.lf.lfCharSet);
m_fontId = 0;
m_temporary = FALSE;
#endif // 0
// hFont may be zero, or it be passed in case we really want to
// use the exact font created in the underlying system
@@ -241,6 +316,32 @@ void wxFontRefData::Init(const wxNativeFontInfo& info, WXHFONT hFont)
}
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 )
{
@@ -248,24 +349,137 @@ wxFontRefData::~wxFontRefData()
{
wxLogLastError(wxT("DeleteObject(font)"));
}
m_hFont = 0;
}
}
// ----------------------------------------------------------------------------
// wxNativeFontInfo
// ----------------------------------------------------------------------------
void wxNativeFontInfo::Init()
{
wxZeroMemory(lf);
}
int wxNativeFontInfo::GetPointSize() const
{
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;
}
wxFontEncoding wxNativeFontInfo::GetEncoding() const
{
return wxGetFontEncFromCharSet(lf.lfCharSet);
}
void wxNativeFontInfo::SetPointSize(int pointsize)
{
const int ppInch = ::GetDeviceCaps(ScreenHDC(), LOGPIXELSY);
lf.lfHeight = -(int)((pointsize*((double)ppInch)/72.0) + 0.5);
}
void wxNativeFontInfo::SetStyle(wxFontStyle style)
{
switch ( style )
{
default:
wxFAIL_MSG( _T("unknown font style") );
// fall through
case wxFONTSTYLE_NORMAL:
break;
case wxFONTSTYLE_ITALIC:
case wxFONTSTYLE_SLANT:
lf.lfItalic = TRUE;
break;
}
}
void wxNativeFontInfo::SetWeight(wxFontWeight weight)
{
switch ( weight )
{
default:
wxFAIL_MSG( _T("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::SetFaceName(wxString facename)
{
wxStrncpy(lf.lfFaceName, facename, sizeof(lf.lfFaceName));
}
void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding)
{
wxNativeEncodingInfo info;
if ( !wxGetNativeFontEncoding(encoding, &info) )
{
// unsupported encoding, replace with the default
info.charset = ANSI_CHARSET;
}
lf.lfCharSet = info.charset;
}
bool wxNativeFontInfo::FromString(const wxString& s)
{
long l;
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) )
@@ -406,7 +620,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);
@@ -433,37 +649,18 @@ 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;
}
@@ -474,15 +671,12 @@ WXHANDLE wxFont::GetResourceHandle()
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()
@@ -508,8 +702,7 @@ void wxFont::SetPointSize(int pointSize)
{
Unshare();
M_FONTDATA->m_pointSize = pointSize;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetPointSize(pointSize);
RealizeResource();
}
@@ -518,8 +711,7 @@ void wxFont::SetFamily(int family)
{
Unshare();
M_FONTDATA->m_family = family;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetFamily(family);
RealizeResource();
}
@@ -528,8 +720,7 @@ void wxFont::SetStyle(int style)
{
Unshare();
M_FONTDATA->m_style = style;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetStyle(style);
RealizeResource();
}
@@ -538,8 +729,7 @@ void wxFont::SetWeight(int weight)
{
Unshare();
M_FONTDATA->m_weight = weight;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetWeight(weight);
RealizeResource();
}
@@ -548,8 +738,7 @@ void wxFont::SetFaceName(const wxString& faceName)
{
Unshare();
M_FONTDATA->m_faceName = faceName;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetFaceName(faceName);
RealizeResource();
}
@@ -558,8 +747,7 @@ void wxFont::SetUnderlined(bool underlined)
{
Unshare();
M_FONTDATA->m_underlined = underlined;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetUnderlined(underlined);
RealizeResource();
}
@@ -568,8 +756,7 @@ void wxFont::SetEncoding(wxFontEncoding encoding)
{
Unshare();
M_FONTDATA->m_encoding = encoding;
M_FONTDATA->m_nativeFontInfoOk = FALSE;
M_FONTDATA->SetEncoding(encoding);
RealizeResource();
}
@@ -580,7 +767,7 @@ void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
FreeResource();
M_FONTDATA->Init(info);
*M_FONTDATA = wxFontRefData(info);
RealizeResource();
}
@@ -593,62 +780,55 @@ 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") );
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();
}
wxNativeFontInfo *wxFont::GetNativeFontInfo() const
{
if( M_FONTDATA->m_nativeFontInfoOk )
return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
if ( M_FONTDATA->HasNativeFontInfo() )
return new wxNativeFontInfo(M_FONTDATA->GetNativeFontInfo());
return 0;
}