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

merged 2.4 branch into the trunk

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@18040 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2002-12-04 14:11:26 +00:00
parent 59a944cb63
commit 2b5f62a0b2
1057 changed files with 37805 additions and 24034 deletions
Download Patch File Download Diff File Expand all files Collapse all files

707
src/x11/font.cpp
View File

@@ -38,12 +38,23 @@
#include "wx/fontutil.h" // for wxNativeFontInfo
#include "wx/tokenzr.h"
#include "wx/settings.h"
#include "wx/x11/private.h"
IMPLEMENT_DYNAMIC_CLASS(wxFont, wxGDIObject)
// ----------------------------------------------------------------------------
// private classes
// constants
// ----------------------------------------------------------------------------
// the default size (in points) for the fonts
static const int wxDEFAULT_FONT_SIZE = 12;
#if wxUSE_UNICODE
#else
// ----------------------------------------------------------------------------
// wxXFont
// ----------------------------------------------------------------------------
// For every wxFont, there must be a font for each display and scale requested.
@@ -59,63 +70,6 @@ public:
int m_scale; // Scale * 100
};
class wxFontRefData: public wxGDIRefData
{
friend class wxFont;
public:
wxFontRefData(int size = wxDEFAULT,
int family = wxDEFAULT,
int style = wxDEFAULT,
int weight = wxDEFAULT,
bool underlined = FALSE,
const wxString& faceName = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT)
{
Init(size, family, style, weight, underlined, faceName, encoding);
}
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);
}
~wxFontRefData();
protected:
// common part of all ctors
void Init(int size,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding);
// font attributes
int m_pointSize;
int m_family;
int m_style;
int m_weight;
bool m_underlined;
wxString m_faceName;
wxFontEncoding m_encoding;
wxNativeFontInfo m_nativeFontInfo;
// A list of wxXFonts
wxList m_fonts;
};
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxXFont
// ----------------------------------------------------------------------------
wxXFont::wxXFont()
{
m_fontStruct = (WXFontStructPtr) 0;
@@ -130,6 +84,83 @@ wxXFont::~wxXFont()
// XFontStruct* fontStruct = (XFontStruct*) m_fontStruct;
// XFreeFont((Display*) m_display, fontStruct);
}
#endif
// ----------------------------------------------------------------------------
// wxFontRefData
// ----------------------------------------------------------------------------
class wxFontRefData: public wxObjectRefData
{
friend class wxFont;
public:
wxFontRefData(int size = wxDEFAULT,
int family = wxDEFAULT,
int style = wxDEFAULT,
int weight = wxDEFAULT,
bool underlined = FALSE,
const wxString& faceName = wxEmptyString,
wxFontEncoding encoding = wxFONTENCODING_DEFAULT);
// copy cstr
wxFontRefData(const wxFontRefData& data);
// from XFLD
wxFontRefData(const wxString& fontname);
// dstr
virtual ~wxFontRefData();
// setters: all of them also take care to modify m_nativeFontInfo if we
// have it so as to not lose the information not carried by our fields
void SetPointSize(int pointSize);
void SetFamily(int family);
void SetStyle(int style);
void SetWeight(int weight);
void SetUnderlined(bool underlined);
void SetFaceName(const wxString& facename);
void SetEncoding(wxFontEncoding encoding);
void SetNoAntiAliasing( bool no = TRUE ) { m_noAA = no; }
bool GetNoAntiAliasing() { return m_noAA; }
// and this one also modifies all the other font data fields
void SetNativeFontInfo(const wxNativeFontInfo& info);
protected:
// common part of all ctors
void Init(int size,
int family,
int style,
int weight,
bool underlined,
const wxString& faceName,
wxFontEncoding encoding);
// set all fields from (already initialized and valid) m_nativeFontInfo
void InitFromNative();
// font attributes
int m_pointSize;
int m_family;
int m_style;
int m_weight;
bool m_underlined;
wxString m_faceName;
wxFontEncoding m_encoding; // Unused in Unicode mode
bool m_noAA; // No anti-aliasing
wxNativeFontInfo m_nativeFontInfo;
void ClearX11Fonts();
#if wxUSE_UNICODE
#else
// A list of wxXFonts
wxList m_fonts;
#endif
};
// ----------------------------------------------------------------------------
// wxFontRefData
@@ -143,34 +174,256 @@ void wxFontRefData::Init(int pointSize,
const wxString& faceName,
wxFontEncoding encoding)
{
if (family == wxDEFAULT)
m_family = wxSWISS;
else
m_family = family;
m_family = family == wxFONTFAMILY_DEFAULT ? wxFONTFAMILY_SWISS : family;
m_faceName = faceName;
if (style == wxDEFAULT)
m_style = wxNORMAL;
else
m_style = style;
// we accept both wxDEFAULT and wxNORMAL here - should we?
m_style = style == wxDEFAULT ? wxFONTSTYLE_NORMAL : style;
m_weight = weight == wxDEFAULT ? wxFONTWEIGHT_NORMAL : weight;
if (weight == wxDEFAULT)
m_weight = wxNORMAL;
else
m_weight = weight;
if (pointSize == wxDEFAULT)
m_pointSize = 12;
else
m_pointSize = pointSize;
// and here, do we really want to forbid creation of the font of the size
// 90 (the value of wxDEFAULT)??
m_pointSize = pointSize == wxDEFAULT || pointSize == -1
? wxDEFAULT_FONT_SIZE
: pointSize;
m_underlined = underlined;
m_encoding = encoding;
#if wxUSE_UNICODE
// Create native font info
m_nativeFontInfo.description = pango_font_description_new();
// And set its values
switch (m_family)
{
case wxFONTFAMILY_MODERN:
case wxFONTFAMILY_TELETYPE:
pango_font_description_set_family( m_nativeFontInfo.description, "monospace" );
break;
case wxFONTFAMILY_SWISS:
pango_font_description_set_family( m_nativeFontInfo.description, "serif" );
break;
default:
pango_font_description_set_family( m_nativeFontInfo.description, "sans" );
break;
}
SetStyle( m_style );
SetPointSize( m_pointSize );
SetWeight( m_weight );
#endif
}
wxFontRefData::~wxFontRefData()
void wxFontRefData::InitFromNative()
{
m_noAA = FALSE;
#if wxUSE_UNICODE
// Get native info
PangoFontDescription *desc = m_nativeFontInfo.description;
// init fields
m_faceName = wxGTK_CONV_BACK( pango_font_description_get_family( desc ) );
m_pointSize = pango_font_description_get_size( desc ) / PANGO_SCALE;
switch (pango_font_description_get_style( desc ))
{
case PANGO_STYLE_NORMAL:
m_style = wxFONTSTYLE_NORMAL;
break;
case PANGO_STYLE_ITALIC:
m_style = wxFONTSTYLE_ITALIC;
break;
case PANGO_STYLE_OBLIQUE:
m_style = wxFONTSTYLE_SLANT;
break;
}
switch (pango_font_description_get_weight( desc ))
{
case PANGO_WEIGHT_ULTRALIGHT:
m_weight = wxFONTWEIGHT_LIGHT;
break;
case PANGO_WEIGHT_LIGHT:
m_weight = wxFONTWEIGHT_LIGHT;
break;
case PANGO_WEIGHT_NORMAL:
m_weight = wxFONTWEIGHT_NORMAL;
break;
case PANGO_WEIGHT_BOLD:
m_weight = wxFONTWEIGHT_BOLD;
break;
case PANGO_WEIGHT_ULTRABOLD:
m_weight = wxFONTWEIGHT_BOLD;
break;
case PANGO_WEIGHT_HEAVY:
m_weight = wxFONTWEIGHT_BOLD;
break;
}
if (m_faceName == wxT("monospace"))
{
m_family = wxFONTFAMILY_TELETYPE;
}
else if (m_faceName == wxT("sans"))
{
m_family = wxFONTFAMILY_SWISS;
}
else
{
m_family = wxFONTFAMILY_UNKNOWN;
}
// Pango description are never underlined (?)
m_underlined = FALSE;
// Cannot we choose that
m_encoding = wxFONTENCODING_SYSTEM;
#else // X11
// get the font parameters from the XLFD
// -------------------------------------
m_faceName = m_nativeFontInfo.GetXFontComponent(wxXLFD_FAMILY);
m_weight = wxFONTWEIGHT_NORMAL;
wxString w = m_nativeFontInfo.GetXFontComponent(wxXLFD_WEIGHT).Upper();
if ( !w.empty() && w != _T('*') )
{
// the test below catches all of BOLD, EXTRABOLD, DEMIBOLD, ULTRABOLD
// and BLACK
if ( ((w[0u] == _T('B') && (!wxStrcmp(w.c_str() + 1, wxT("OLD")) ||
!wxStrcmp(w.c_str() + 1, wxT("LACK"))))) ||
wxStrstr(w.c_str() + 1, _T("BOLD")) )
{
m_weight = wxFONTWEIGHT_BOLD;
}
else if ( w == _T("LIGHT") || w == _T("THIN") )
{
m_weight = wxFONTWEIGHT_LIGHT;
}
}
switch ( wxToupper(*m_nativeFontInfo.
GetXFontComponent(wxXLFD_SLANT).c_str()) )
{
case _T('I'): // italique
m_style = wxFONTSTYLE_ITALIC;
break;
case _T('O'): // oblique
m_style = wxFONTSTYLE_SLANT;
break;
default:
m_style = wxFONTSTYLE_NORMAL;
}
long ptSize;
if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_POINTSIZE).ToLong(&ptSize) )
{
// size in XLFD is in 10 point units
m_pointSize = (int)(ptSize / 10);
}
else
{
m_pointSize = wxDEFAULT_FONT_SIZE;
}
// examine the spacing: if the font is monospaced, assume wxTELETYPE
// family for compatibility with the old code which used it instead of
// IsFixedWidth()
if ( m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING).Upper() == _T('M') )
{
m_family = wxFONTFAMILY_TELETYPE;
}
else // not monospaceed
{
// don't even try guessing it, it doesn't work for too many fonts
// anyhow
m_family = wxFONTFAMILY_UNKNOWN;
}
// X fonts are never underlined...
m_underlined = FALSE;
// deal with font encoding
wxString
registry = m_nativeFontInfo.GetXFontComponent(wxXLFD_REGISTRY).Upper(),
encoding = m_nativeFontInfo.GetXFontComponent(wxXLFD_ENCODING).Upper();
if ( registry == _T("ISO8859") )
{
int cp;
if ( wxSscanf(encoding, wxT("%d"), &cp) == 1 )
{
m_encoding = (wxFontEncoding)(wxFONTENCODING_ISO8859_1 + cp - 1);
}
}
else if ( registry == _T("MICROSOFT") )
{
int cp;
if ( wxSscanf(encoding, wxT("cp125%d"), &cp) == 1 )
{
m_encoding = (wxFontEncoding)(wxFONTENCODING_CP1250 + cp);
}
}
else if ( registry == _T("KOI8") )
{
m_encoding = wxFONTENCODING_KOI8;
}
else // unknown encoding
{
// may be give a warning here? or use wxFontMapper?
m_encoding = wxFONTENCODING_SYSTEM;
}
#endif // Pango/X11
}
wxFontRefData::wxFontRefData( const wxFontRefData& data )
: wxObjectRefData()
{
m_pointSize = data.m_pointSize;
m_family = data.m_family;
m_style = data.m_style;
m_weight = data.m_weight;
m_underlined = data.m_underlined;
m_faceName = data.m_faceName;
m_encoding = data.m_encoding;
m_noAA = data.m_noAA;
m_nativeFontInfo = data.m_nativeFontInfo;
}
wxFontRefData::wxFontRefData(int size, int family, int style,
int weight, bool underlined,
const wxString& faceName,
wxFontEncoding encoding)
{
Init(size, family, style, weight, underlined, faceName, encoding);
}
wxFontRefData::wxFontRefData(const wxString& fontname)
{
// VZ: FromString() should really work in both cases, doesn't it?
#if wxUSE_UNICODE
m_nativeFontInfo.FromString( fontname );
#else
m_nativeFontInfo.SetXFontName(fontname);
#endif
InitFromNative();
}
void wxFontRefData::ClearX11Fonts()
{
#if wxUSE_UNICODE
#else
wxNode* node = m_fonts.First();
while (node)
{
@@ -179,21 +432,119 @@ wxFontRefData::~wxFontRefData()
node = node->Next();
}
m_fonts.Clear();
#endif
}
wxFontRefData::~wxFontRefData()
{
ClearX11Fonts();
}
// ----------------------------------------------------------------------------
// wxFontRefData SetXXX()
// ----------------------------------------------------------------------------
void wxFontRefData::SetPointSize(int pointSize)
{
m_pointSize = pointSize;
#if wxUSE_UNICODE
// Get native info
PangoFontDescription *desc = m_nativeFontInfo.description;
pango_font_description_set_size( desc, m_pointSize * PANGO_SCALE );
#endif
}
void wxFontRefData::SetFamily(int family)
{
m_family = family;
// TODO: what are we supposed to do with m_nativeFontInfo here?
}
void wxFontRefData::SetStyle(int style)
{
m_style = style;
#if wxUSE_UNICODE
// Get native info
PangoFontDescription *desc = m_nativeFontInfo.description;
switch ( style )
{
case wxFONTSTYLE_ITALIC:
pango_font_description_set_style( desc, PANGO_STYLE_ITALIC );
break;
case wxFONTSTYLE_SLANT:
pango_font_description_set_style( desc, PANGO_STYLE_OBLIQUE );
break;
default:
wxFAIL_MSG( _T("unknown font style") );
// fall through
case wxFONTSTYLE_NORMAL:
pango_font_description_set_style( desc, PANGO_STYLE_NORMAL );
break;
}
#endif
}
void wxFontRefData::SetWeight(int weight)
{
m_weight = weight;
}
void wxFontRefData::SetUnderlined(bool underlined)
{
m_underlined = underlined;
// the XLFD doesn't have "underlined" field anyhow
}
void wxFontRefData::SetFaceName(const wxString& facename)
{
m_faceName = facename;
}
void wxFontRefData::SetEncoding(wxFontEncoding encoding)
{
m_encoding = encoding;
}
void wxFontRefData::SetNativeFontInfo(const wxNativeFontInfo& info)
{
// previously cached fonts shouldn't be used
ClearX11Fonts();
m_nativeFontInfo = info;
// set all the other font parameters from the native font info
InitFromNative();
}
// ----------------------------------------------------------------------------
// wxFont
// ----------------------------------------------------------------------------
void wxFont::Init()
{
}
wxFont::wxFont(const wxNativeFontInfo& info)
{
Init();
(void)Create(info.GetXFontName());
}
void wxFont::Init()
{
#if wxUSE_UNICODE
Create( info.GetPointSize(),
info.GetFamily(),
info.GetStyle(),
info.GetWeight(),
info.GetUnderlined(),
info.GetFaceName(),
info.GetEncoding() );
#else
(void) Create(info.GetXFontName());
#endif
}
bool wxFont::Create(int pointSize,
@@ -205,14 +556,15 @@ bool wxFont::Create(int pointSize,
wxFontEncoding encoding)
{
UnRef();
m_refData = new wxFontRefData(pointSize, family, style, weight,
underlined, faceName, encoding);
RealizeResource();
return TRUE;
}
#if wxUSE_UNICODE
#else
bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
{
if( !fontname )
@@ -315,6 +667,7 @@ bool wxFont::Create(const wxString& fontname, wxFontEncoding enc)
}
return TRUE;
}
#endif
wxFont::~wxFont()
{
@@ -339,90 +692,14 @@ void wxFont::Unshare()
}
}
void wxFont::SetPointSize(int pointSize)
{
Unshare();
M_FONTDATA->m_pointSize = pointSize;
M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
RealizeResource();
}
void wxFont::SetFamily(int family)
{
Unshare();
M_FONTDATA->m_family = family;
M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
RealizeResource();
}
void wxFont::SetStyle(int style)
{
Unshare();
M_FONTDATA->m_style = style;
M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
RealizeResource();
}
void wxFont::SetWeight(int weight)
{
Unshare();
M_FONTDATA->m_weight = weight;
M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
RealizeResource();
}
void wxFont::SetFaceName(const wxString& faceName)
{
Unshare();
M_FONTDATA->m_faceName = faceName;
M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
RealizeResource();
}
void wxFont::SetUnderlined(bool underlined)
{
Unshare();
M_FONTDATA->m_underlined = underlined;
RealizeResource();
}
void wxFont::SetEncoding(wxFontEncoding encoding)
{
Unshare();
M_FONTDATA->m_encoding = encoding;
M_FONTDATA->m_nativeFontInfo.GetXFontName().Clear(); // invalid now
RealizeResource();
}
void wxFont::SetNativeFontInfo(const wxNativeFontInfo& info)
{
Unshare();
M_FONTDATA->m_nativeFontInfo = info;
}
// ----------------------------------------------------------------------------
// query font attributes
// accessors
// ----------------------------------------------------------------------------
int wxFont::GetPointSize() const
{
wxCHECK_MSG( Ok(), 0, wxT("invalid font") );
return M_FONTDATA->m_pointSize;
}
@@ -430,7 +707,7 @@ wxString wxFont::GetFaceName() const
{
wxCHECK_MSG( Ok(), wxT(""), wxT("invalid font") );
return M_FONTDATA->m_faceName ;
return M_FONTDATA->m_faceName;
}
int wxFont::GetFamily() const
@@ -468,18 +745,119 @@ wxFontEncoding wxFont::GetEncoding() const
return M_FONTDATA->m_encoding;
}
bool wxFont::GetNoAntiAliasing()
{
wxCHECK_MSG( Ok(), wxFONTENCODING_DEFAULT, wxT("invalid font") );
return M_FONTDATA->m_noAA;
}
wxNativeFontInfo *wxFont::GetNativeFontInfo() const
{
wxCHECK_MSG( Ok(), (wxNativeFontInfo *)NULL, wxT("invalid font") );
if(M_FONTDATA->m_nativeFontInfo.GetXFontName().IsEmpty())
#if wxUSE_UNICODE
#else
if ( M_FONTDATA->m_nativeFontInfo.GetXFontName().empty() )
GetInternalFont();
#endif
return new wxNativeFontInfo(M_FONTDATA->m_nativeFontInfo);
}
bool wxFont::IsFixedWidth() const
{
wxCHECK_MSG( Ok(), FALSE, wxT("invalid font") );
#if wxUSE_UNICODE
#else
// Robert, is this right? HasNativeFont doesn't exist.
if ( TRUE )
// if ( M_FONTDATA->HasNativeFont() )
{
// the monospace fonts are supposed to have "M" in the spacing field
wxString spacing = M_FONTDATA->
m_nativeFontInfo.GetXFontComponent(wxXLFD_SPACING);
return spacing.Upper() == _T('M');
}
#endif
return wxFontBase::IsFixedWidth();
}
// ----------------------------------------------------------------------------
// real implementation
// change font attributes
// ----------------------------------------------------------------------------
void wxFont::SetPointSize(int pointSize)
{
Unshare();
M_FONTDATA->SetPointSize(pointSize);
}
void wxFont::SetFamily(int family)
{
Unshare();
M_FONTDATA->SetFamily(family);
}
void wxFont::SetStyle(int style)
{
Unshare();
M_FONTDATA->SetStyle(style);
}
void wxFont::SetWeight(int weight)
{
Unshare();
M_FONTDATA->SetWeight(weight);
}
void wxFont::SetFaceName(const wxString& faceName)
{
Unshare();
M_FONTDATA->SetFaceName(faceName);
}
void wxFont::SetUnderlined(bool underlined)
{
Unshare();
M_FONTDATA->SetUnderlined(underlined);
}
void wxFont::SetEncoding(wxFontEncoding encoding)
{
Unshare();
M_FONTDATA->SetEncoding(encoding);
}
void wxFont::SetNativeFontInfo( const wxNativeFontInfo& info )
{
Unshare();
M_FONTDATA->SetNativeFontInfo( info );
}
void wxFont::SetNoAntiAliasing( bool no )
{
Unshare();
M_FONTDATA->SetNoAntiAliasing( no );
}
#if wxUSE_UNICODE
#else
// ----------------------------------------------------------------------------
// X11 implementation
// ----------------------------------------------------------------------------
// Find an existing, or create a new, XFontStruct
@@ -536,3 +914,4 @@ WXFontStructPtr wxFont::GetFontStruct(double scale, WXDisplay* display) const
return (f ? f->m_fontStruct : (WXFontStructPtr) 0);
}
#endif