/////////////////////////////////////////////////////////////////////////////
// Name: src/unix/fontutil.cpp
-// Purpose: Font helper functions for X11 (GDK/X)
+// Purpose: Font helper functions for wxX11, wxGTK, wxMotif
// Author: Vadim Zeitlin
// Modified by:
// Created: 05.11.99
#ifndef WX_PRECOMP
#include "wx/app.h"
#include "wx/font.h" // wxFont enums
- #include "wx/encinfo.h"
#include "wx/hash.h"
#include "wx/utils.h" // for wxGetDisplay()
+ #include "wx/module.h"
#endif // PCH
+#include "wx/encinfo.h"
#include "wx/fontmap.h"
#include "wx/tokenzr.h"
-#include "wx/module.h"
#include "wx/fontenum.h"
#if wxUSE_PANGO
#include "pango/pango.h"
#ifdef __WXGTK20__
-#include "wx/gtk/private.h"
-extern GtkWidget *wxGetRootWindow();
+ #include "wx/gtk/private.h"
+ extern GtkWidget *wxGetRootWindow();
+
+ #define wxPANGO_CONV wxGTK_CONV_SYS
+ #define wxPANGO_CONV_BACK wxGTK_CONV_BACK_SYS
#else
-#include "wx/x11/private.h"
+ #include "wx/x11/private.h"
+ #include "wx/gtk/private/string.h"
+
+ #define wxPANGO_CONV(s) s.utf8_str()
+ #define wxPANGO_CONV_BACK(s) wxString::FromUTF8Unchecked(s)
#endif
// ----------------------------------------------------------------------------
void wxNativeFontInfo::Init()
{
description = NULL;
+ m_underlined = false;
+ m_strikethrough = false;
}
-void
-wxNativeFontInfo::Init(const wxNativeFontInfo& info)
+void wxNativeFontInfo::Init(const wxNativeFontInfo& info)
{
if (info.description)
+ {
description = pango_font_description_copy(info.description);
+ m_underlined = info.GetUnderlined();
+ m_strikethrough = info.GetStrikethrough();
+ }
else
+ {
description = NULL;
+ m_underlined = false;
+ m_strikethrough = false;
+ }
}
void wxNativeFontInfo::Free()
wxFontWeight wxNativeFontInfo::GetWeight() const
{
-#if 0
// We seem to currently initialize only by string.
// In that case PANGO_FONT_MASK_WEIGHT is always set.
- if (!(pango_font_description_get_set_fields(description) & PANGO_FONT_MASK_WEIGHT))
- return wxFONTWEIGHT_NORMAL;
-#endif
+ // if (!(pango_font_description_get_set_fields(description) & PANGO_FONT_MASK_WEIGHT))
+ // return wxFONTWEIGHT_NORMAL;
PangoWeight pango_weight = pango_font_description_get_weight( description );
bool wxNativeFontInfo::GetUnderlined() const
{
- return false;
+ return m_underlined;
}
-wxString wxNativeFontInfo::GetFaceName() const
+bool wxNativeFontInfo::GetStrikethrough() const
{
- wxString tmp = wxGTK_CONV_BACK( pango_font_description_get_family( description ) );
+ return m_strikethrough;
+}
- return tmp;
+wxString wxNativeFontInfo::GetFaceName() const
+{
+ // the Pango "family" is the wx "face name"
+ return wxPANGO_CONV_BACK(pango_font_description_get_family(description));
}
wxFontFamily wxNativeFontInfo::GetFamily() const
{
- wxFontFamily ret = wxFONTFAMILY_DEFAULT;
+ wxFontFamily ret = wxFONTFAMILY_UNKNOWN;
+
+ const char *family_name = pango_font_description_get_family( description );
+
// note: not passing -1 as the 2nd parameter to g_ascii_strdown to work
// around a bug in the 64-bit glib shipped with solaris 10, -1 causes it
// to try to allocate 2^32 bytes.
- const char *family_name = pango_font_description_get_family( description );
if ( !family_name )
return ret;
-
wxGtkString family_text(g_ascii_strdown(family_name, strlen(family_name)));
- // Check for some common fonts, to salvage what we can from the current win32 centric wxFont API:
- if (strncmp( family_text, "monospace", 9 ) == 0)
- ret = wxFONTFAMILY_TELETYPE; // begins with "Monospace"
- else if (strncmp( family_text, "courier", 7 ) == 0)
- ret = wxFONTFAMILY_TELETYPE; // begins with "Courier"
-#if defined(__WXGTK24__) || defined(HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE)
+ // Check for some common fonts, to salvage what we can from the current
+ // win32 centric wxFont API:
+ if (wxStrnicmp( family_text, "monospace", 9 ) == 0)
+ ret = wxFONTFAMILY_TELETYPE; // begins with "Monospace"
+ else if (wxStrnicmp( family_text, "courier", 7 ) == 0)
+ ret = wxFONTFAMILY_TELETYPE; // begins with "Courier"
+#if defined(__WXGTK20__) || defined(HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE)
else
-#ifdef __WXGTK24__
- if (!gtk_check_version(2,4,0))
-#endif
{
PangoFontFamily **families;
PangoFontFamily *family = NULL;
#endif
&families, &n_families);
- for (int i = 0;i < n_families;++i)
+ for (int i = 0; i < n_families; ++i)
{
- if (g_ascii_strcasecmp(pango_font_family_get_name( families[i] ), pango_font_description_get_family( description )) == 0 )
+ if (g_ascii_strcasecmp(pango_font_family_get_name( families[i] ),
+ pango_font_description_get_family( description )) == 0 )
{
family = families[i];
break;
g_free(families);
- // Some gtk+ systems might query for a non-existing font from wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)
- // on initialization, don't assert until wxSystemSettings::GetFont is checked for this - MR
- // wxASSERT_MSG( family, wxT("wxNativeFontInfo::GetFamily() - No appropriate PangoFontFamily found for ::description") );
-
- //BCI: Cache the wxFontFamily inside the class. Validate cache with
- //BCI: g_ascii_strcasecmp(pango_font_description_get_family(description), pango_font_family_get_name(family)) == 0
+ // Some gtk+ systems might query for a non-existing font from
+ // wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) on initialization,
+ // don't assert until wxSystemSettings::GetFont is checked for this - MR
+ // wxASSERT_MSG( family, "No appropriate PangoFontFamily found for ::description" );
if (family != NULL && pango_font_family_is_monospace( family ))
ret = wxFONTFAMILY_TELETYPE; // is deemed a monospace font by pango
}
-#endif // gtk24 || HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE
+#endif // GTK+ 2 || HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE
- if (ret == wxFONTFAMILY_DEFAULT)
+ if (ret == wxFONTFAMILY_UNKNOWN)
{
- if (strstr( family_text, "sans" ) != NULL) // checked before serif, so that "* Sans Serif" fonts are detected correctly
- ret = wxFONTFAMILY_SWISS; // contains "Sans"
- else if (strstr( family_text, "serif" ) != NULL)
- ret = wxFONTFAMILY_ROMAN; // contains "Serif"
- else if (strncmp( family_text, "times", 5 ) == 0)
- ret = wxFONTFAMILY_ROMAN; // begins with "Times"
- else if (strncmp( family_text, "old", 3 ) == 0)
- ret = wxFONTFAMILY_DECORATIVE; // Begins with "Old" - "Old English", "Old Town"
+ if (strstr( family_text, "sans" ) != NULL || strstr( family_text, "Sans" ) != NULL)
+ // checked before serif, so that "* Sans Serif" fonts are detected correctly
+ ret = wxFONTFAMILY_SWISS; // contains "Sans"
+ else if (strstr( family_text, "serif" ) != NULL || strstr( family_text, "Serif" ) != NULL)
+ ret = wxFONTFAMILY_ROMAN; // contains "Serif"
+ else if (wxStrnicmp( family_text, "times", 5 ) == 0)
+ ret = wxFONTFAMILY_ROMAN; // begins with "Times"
+ else if (wxStrnicmp( family_text, "old", 3 ) == 0)
+ ret = wxFONTFAMILY_DECORATIVE; // begins with "Old" - "Old English", "Old Town"
}
return ret;
return wxFONTENCODING_SYSTEM;
}
-
void wxNativeFontInfo::SetPointSize(int pointsize)
{
pango_font_description_set_size( description, pointsize * PANGO_SCALE );
pango_font_description_set_style( description, PANGO_STYLE_OBLIQUE );
break;
default:
- wxFAIL_MSG( _T("unknown font style") );
+ wxFAIL_MSG( "unknown font style" );
// fall through
case wxFONTSTYLE_NORMAL:
pango_font_description_set_style( description, PANGO_STYLE_NORMAL );
pango_font_description_set_weight(description, PANGO_WEIGHT_LIGHT);
break;
default:
- wxFAIL_MSG( _T("unknown font weight") );
+ wxFAIL_MSG( "unknown font weight" );
// fall through
case wxFONTWEIGHT_NORMAL:
pango_font_description_set_weight(description, PANGO_WEIGHT_NORMAL);
}
}
-void wxNativeFontInfo::SetUnderlined(bool WXUNUSED(underlined))
+void wxNativeFontInfo::SetUnderlined(bool underlined)
+{
+ // Pango doesn't have the underlined attribute so we store it separately
+ // (and handle it specially in wxWindowDCImpl::DoDrawText()).
+ m_underlined = underlined;
+}
+
+void wxNativeFontInfo::SetStrikethrough(bool strikethrough)
{
- wxFAIL_MSG( _T("not implemented") );
+ // As with the underlined attribute above, we handle this one separately as
+ // Pango doesn't support it as part of the font description.
+ m_strikethrough = strikethrough;
}
bool wxNativeFontInfo::SetFaceName(const wxString& facename)
{
- pango_font_description_set_family(description, wxGTK_CONV_SYS(facename));
+ pango_font_description_set_family(description, wxPANGO_CONV(facename));
+
+ // we return true because Pango doesn't tell us if the call failed or not;
+ // instead on wxGTK wxFont::SetFaceName() will call wxFontBase::SetFaceName()
+ // which does the check
return true;
}
-void wxNativeFontInfo::SetFamily(wxFontFamily WXUNUSED(family))
+void wxNativeFontInfo::SetFamily(wxFontFamily family)
{
- wxFAIL_MSG( _T("not implemented") );
+ wxArrayString facename;
+
+ // the list of fonts associated with a family was partially
+ // taken from http://www.codestyle.org/css/font-family
+
+ switch ( family )
+ {
+ case wxFONTFAMILY_SCRIPT:
+ // corresponds to the cursive font family in the page linked above
+ facename.Add(wxS("URW Chancery L"));
+ facename.Add(wxS("Comic Sans MS"));
+ break;
+
+ case wxFONTFAMILY_DECORATIVE:
+ // corresponds to the fantasy font family in the page linked above
+ facename.Add(wxS("Impact"));
+ break;
+
+ case wxFONTFAMILY_ROMAN:
+ // corresponds to the serif font family in the page linked above
+ facename.Add(wxS("Serif"));
+ facename.Add(wxS("DejaVu Serif"));
+ facename.Add(wxS("DejaVu LGC Serif"));
+ facename.Add(wxS("Bitstream Vera Serif"));
+ facename.Add(wxS("Liberation Serif"));
+ facename.Add(wxS("FreeSerif"));
+ facename.Add(wxS("Luxi Serif"));
+ facename.Add(wxS("Times New Roman"));
+ facename.Add(wxS("Century Schoolbook L"));
+ facename.Add(wxS("URW Bookman L"));
+ facename.Add(wxS("URW Palladio L"));
+ facename.Add(wxS("Times"));
+ break;
+
+ case wxFONTFAMILY_TELETYPE:
+ case wxFONTFAMILY_MODERN:
+ // corresponds to the monospace font family in the page linked above
+ facename.Add(wxS("Monospace"));
+ facename.Add(wxS("DejaVu Sans Mono"));
+ facename.Add(wxS("DejaVu LGC Sans Mono"));
+ facename.Add(wxS("Bitstream Vera Sans Mono"));
+ facename.Add(wxS("Liberation Mono"));
+ facename.Add(wxS("FreeMono"));
+ facename.Add(wxS("Luxi Mono"));
+ facename.Add(wxS("Courier New"));
+ facename.Add(wxS("Lucida Sans Typewriter"));
+ facename.Add(wxS("Nimbus Mono L"));
+ facename.Add(wxS("Andale Mono"));
+ facename.Add(wxS("Courier"));
+ break;
+
+ case wxFONTFAMILY_SWISS:
+ case wxFONTFAMILY_DEFAULT:
+ default:
+ // corresponds to the sans-serif font family in the page linked above
+ facename.Add(wxS("Sans"));
+ facename.Add(wxS("DejaVu Sans"));
+ facename.Add(wxS("DejaVu LGC Sans"));
+ facename.Add(wxS("Bitstream Vera Sans"));
+ facename.Add(wxS("Liberation Sans"));
+ facename.Add(wxS("FreeSans"));
+ facename.Add(wxS("Luxi Sans"));
+ facename.Add(wxS("Arial"));
+ facename.Add(wxS("Lucida Sans"));
+ facename.Add(wxS("Nimbus Sans L"));
+ facename.Add(wxS("URW Gothic L"));
+ break;
+ }
+
+ SetFaceName(facename);
}
void wxNativeFontInfo::SetEncoding(wxFontEncoding WXUNUSED(encoding))
{
- wxFAIL_MSG( _T("not implemented") );
+ wxFAIL_MSG( "not implemented: Pango encoding is always UTF8" );
}
-
-
bool wxNativeFontInfo::FromString(const wxString& s)
{
+ wxString str(s);
+
+ // Pango font description doesn't have 'underlined' or 'strikethrough'
+ // attributes, so we handle them specially by extracting them from the
+ // string before passing it to Pango.
+ m_underlined = str.StartsWith(wxS("underlined "), &str);
+ m_strikethrough = str.StartsWith(wxS("strikethrough "), &str);
+
if (description)
pango_font_description_free( description );
// we do the check on the size here using same (arbitrary) limits used by
// pango > 1.13. Note that the segfault could happen also for pointsize
// smaller than this limit !!
- wxString str(s);
- const size_t pos = str.find_last_of(_T(" "));
+ const size_t pos = str.find_last_of(wxS(" "));
double size;
if ( pos != wxString::npos && wxString(str, pos + 1).ToDouble(&size) )
{
wxString sizeStr;
if ( size < 1 )
- sizeStr = _T("1");
+ sizeStr = wxS("1");
else if ( size >= 1E6 )
- sizeStr = _T("1E6");
+ sizeStr = wxS("1E6");
if ( !sizeStr.empty() )
{
}
}
- description = pango_font_description_from_string( wxGTK_CONV_SYS( str ) );
+ description = pango_font_description_from_string(wxPANGO_CONV(str));
+#if wxUSE_FONTENUM
// ensure a valid facename is selected
if (!wxFontEnumerator::IsValidFacename(GetFaceName()))
SetFaceName(wxNORMAL_FONT->GetFaceName());
+#endif // wxUSE_FONTENUM
return true;
}
wxString wxNativeFontInfo::ToString() const
{
wxGtkString str(pango_font_description_to_string( description ));
-
- return wxGTK_CONV_BACK(str);
+ wxString desc = wxPANGO_CONV_BACK(str);
+
+ // Augment the string with the attributes not handled by Pango.
+ //
+ // Notice that we must add them in the same order they are extracted in
+ // FromString() above.
+ if (m_strikethrough)
+ desc.insert(0, wxS("strikethrough "));
+ if (m_underlined)
+ desc.insert(0, wxS("underlined "));
+
+ return desc;
}
bool wxNativeFontInfo::FromUserString(const wxString& s)
return ToString();
}
-// ----------------------------------------------------------------------------
-// wxNativeEncodingInfo
-// ----------------------------------------------------------------------------
-
-bool wxNativeEncodingInfo::FromString(const wxString& WXUNUSED(s))
-{
- return false;
-}
-
-wxString wxNativeEncodingInfo::ToString() const
-{
- return wxEmptyString;
-}
-
-bool wxTestFontEncoding(const wxNativeEncodingInfo& WXUNUSED(info))
-{
- return true;
-}
-
-bool wxGetNativeFontEncoding(wxFontEncoding encoding,
- wxNativeEncodingInfo *info)
-{
- // all encodings are available in GTK+ 2 because we translate text in any
- // encoding to UTF-8 internally anyhow
- info->facename.clear();
- info->encoding = encoding;
-
- return true;
-}
-
#else // GTK+ 1.x
#ifdef __X__
// private data
// ----------------------------------------------------------------------------
-static wxHashTable *g_fontHash = (wxHashTable*) NULL;
+static wxHashTable *g_fontHash = NULL;
// ----------------------------------------------------------------------------
// private functions
bool wxNativeEncodingInfo::FromString(const wxString& s)
{
// use ";", not "-" because it may be part of encoding name
- wxStringTokenizer tokenizer(s, _T(";"));
+ wxStringTokenizer tokenizer(s, wxT(";"));
wxString encid = tokenizer.GetNextToken();
long enc;
wxString wxNativeEncodingInfo::ToString() const
{
wxString s;
- s << (long)encoding << _T(';') << xregistry << _T(';') << xencoding;
+ s << (long)encoding << wxT(';') << xregistry << wxT(';') << xencoding;
if ( !facename.empty() )
{
- s << _T(';') << facename;
+ s << wxT(';') << facename;
}
return s;
bool wxNativeFontInfo::FromString(const wxString& s)
{
- wxStringTokenizer tokenizer(s, _T(";"));
+ wxStringTokenizer tokenizer(s, wxT(";"));
// check the version
wxString token = tokenizer.GetNextToken();
- if ( token != _T('0') )
+ if ( token != wxT('0') )
return false;
xFontName = tokenizer.GetNextToken();
wxString wxNativeFontInfo::ToString() const
{
// 0 is the version
- return wxString::Format(_T("%d;%s"), 0, GetXFontName().c_str());
+ return wxString::Format(wxT("%d;%s"), 0, GetXFontName().c_str());
}
bool wxNativeFontInfo::FromUserString(const wxString& s)
wxString wxNativeFontInfo::GetXFontComponent(wxXLFDField field) const
{
- wxCHECK_MSG( field < wxXLFD_MAX, wxEmptyString, _T("invalid XLFD field") );
+ wxCHECK_MSG( field < wxXLFD_MAX, wxEmptyString, wxT("invalid XLFD field") );
if ( !HasElements() )
{
- // const_cast
- if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
+ if ( !const_cast<wxNativeFontInfo *>(this)->FromXFontName(xFontName) )
return wxEmptyString;
}
bool wxNativeFontInfo::FromXFontName(const wxString& fontname)
{
// TODO: we should be able to handle the font aliases here, but how?
- wxStringTokenizer tokenizer(fontname, _T("-"));
+ wxStringTokenizer tokenizer(fontname, wxT("-"));
// skip the leading, usually empty field (font name registry)
if ( !tokenizer.HasMoreTokens() )
}
wxString field = tokenizer.GetNextToken();
- if ( !field.empty() && field != _T('*') )
+ if ( !field.empty() && field != wxT('*') )
{
// we're really initialized now
m_isDefault = false;
wxString elt = fontElements[n];
if ( elt.empty() && n != wxXLFD_ADDSTYLE )
{
- elt = _T('*');
+ elt = wxT('*');
}
- // const_cast
- ((wxNativeFontInfo *)this)->xFontName << _T('-') << elt;
+ const_cast<wxNativeFontInfo *>(this)->xFontName << wxT('-') << elt;
}
}
void
wxNativeFontInfo::SetXFontComponent(wxXLFDField field, const wxString& value)
{
- wxCHECK_RET( field < wxXLFD_MAX, _T("invalid XLFD field") );
+ wxCHECK_RET( field < wxXLFD_MAX, wxT("invalid XLFD field") );
// this class should be initialized with a valid font spec first and only
// then the fields may be modified!
- wxASSERT_MSG( !IsDefault(), _T("can't modify an uninitialized XLFD") );
+ wxASSERT_MSG( !IsDefault(), wxT("can't modify an uninitialized XLFD") );
if ( !HasElements() )
{
- // const_cast
- if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) )
+ if ( !const_cast<wxNativeFontInfo *>(this)->FromXFontName(xFontName) )
{
- wxFAIL_MSG( _T("can't set font element for invalid XLFD") );
+ wxFAIL_MSG( wxT("can't set font element for invalid XLFD") );
return;
}
return wxFONTSTYLE_NORMAL;
}
- switch ( s[0] )
+ switch ( s[0].GetValue() )
{
default:
// again, unknown but consider normal by default
- case _T('r'):
+ case wxT('r'):
return wxFONTSTYLE_NORMAL;
- case _T('i'):
+ case wxT('i'):
return wxFONTSTYLE_ITALIC;
- case _T('o'):
+ case wxT('o'):
return wxFONTSTYLE_SLANT;
}
}
wxFontWeight wxNativeFontInfo::GetWeight() const
{
const wxString s = GetXFontComponent(wxXLFD_WEIGHT).MakeLower();
- if ( s.find(_T("bold")) != wxString::npos || s == _T("black") )
+ if ( s.find(wxT("bold")) != wxString::npos || s == wxT("black") )
return wxFONTWEIGHT_BOLD;
- else if ( s == _T("light") )
+ else if ( s == wxT("light") )
return wxFONTWEIGHT_LIGHT;
return wxFONTWEIGHT_NORMAL;
{
// and wxWidgets family -- to X foundry, but we have to translate it to
// wxFontFamily somehow...
- wxFAIL_MSG(_T("not implemented")); // GetXFontComponent(wxXLFD_FOUNDRY);
+ wxFAIL_MSG(wxT("not implemented")); // GetXFontComponent(wxXLFD_FOUNDRY);
return wxFONTFAMILY_DEFAULT;
}
wxFontEncoding wxNativeFontInfo::GetEncoding() const
{
// we already have the code for this but need to refactor it first
- wxFAIL_MSG( _T("not implemented") );
+ wxFAIL_MSG( wxT("not implemented") );
return wxFONTENCODING_MAX;
}
void wxNativeFontInfo::SetPointSize(int pointsize)
{
- SetXFontComponent(wxXLFD_POINTSIZE, wxString::Format(_T("%d"), pointsize));
+ SetXFontComponent(wxXLFD_POINTSIZE, wxString::Format(wxT("%d"), pointsize));
}
void wxNativeFontInfo::SetStyle(wxFontStyle style)
switch ( style )
{
case wxFONTSTYLE_ITALIC:
- s = _T('i');
+ s = wxT('i');
break;
case wxFONTSTYLE_SLANT:
- s = _T('o');
+ s = wxT('o');
break;
case wxFONTSTYLE_NORMAL:
- s = _T('r');
+ s = wxT('r');
default:
- wxFAIL_MSG( _T("unknown wxFontStyle in wxNativeFontInfo::SetStyle") );
+ wxFAIL_MSG( wxT("unknown wxFontStyle in wxNativeFontInfo::SetStyle") );
return;
}
switch ( weight )
{
case wxFONTWEIGHT_BOLD:
- s = _T("bold");
+ s = wxT("bold");
break;
case wxFONTWEIGHT_LIGHT:
- s = _T("light");
+ s = wxT("light");
break;
case wxFONTWEIGHT_NORMAL:
- s = _T("medium");
+ s = wxT("medium");
break;
default:
- wxFAIL_MSG( _T("unknown wxFontWeight in wxNativeFontInfo::SetWeight") );
+ wxFAIL_MSG( wxT("unknown wxFontWeight in wxNativeFontInfo::SetWeight") );
return;
}
// can't do this under X
}
+void wxNativeFontInfo::SetStrikethrough(bool WXUNUSED(strikethrough))
+{
+ // this is not supported by Pango fonts neither
+}
+
bool wxNativeFontInfo::SetFaceName(const wxString& facename)
{
SetXFontComponent(wxXLFD_FAMILY, facename);
void wxNativeFontInfo::SetFamily(wxFontFamily WXUNUSED(family))
{
// wxFontFamily -> X foundry, anyone?
- wxFAIL_MSG( _T("not implemented") );
+ wxFAIL_MSG( wxT("not implemented") );
// SetXFontComponent(wxXLFD_FOUNDRY, ...);
}
bool wxGetNativeFontEncoding(wxFontEncoding encoding,
wxNativeEncodingInfo *info)
{
- wxCHECK_MSG( info, false, _T("bad pointer in wxGetNativeFontEncoding") );
+ wxCHECK_MSG( info, false, wxT("bad pointer in wxGetNativeFontEncoding") );
if ( encoding == wxFONTENCODING_DEFAULT )
{
bool wxTestFontEncoding(const wxNativeEncodingInfo& info)
{
wxString fontspec;
- fontspec.Printf(_T("-*-%s-*-*-*-*-*-*-*-*-*-*-%s-%s"),
- !info.facename ? _T("*") : info.facename.c_str(),
- info.xregistry.c_str(),
- info.xencoding.c_str());
+ fontspec.Printf(wxT("-*-%s-*-*-*-*-*-*-*-*-*-*-%s-%s"),
+ info.facename.empty() ? wxString("*") : info.facename,
+ info.xregistry,
+ info.xencoding);
return wxTestFontSpec(fontspec);
}
//
// Make sure point size is correct for scale factor.
//
- wxStringTokenizer tokenizer(*xFontName, _T("-"), wxTOKEN_RET_DELIMS);
+ wxStringTokenizer tokenizer(*xFontName, wxT("-"), wxTOKEN_RET_DELIMS);
wxString newFontName;
for(int i = 0; i < 8; i++)
int i, round; // counters
- // first round: search for equal, then for smaller and for larger size with the given weight and style
+ // first round: search for equal, then for smaller and for larger size
+ // with the given weight and style
int testweight = weight;
int teststyle = style;
// NULL or we'd crash in wxFont code
if ( !font )
{
- wxFAIL_MSG( _T("this encoding should be available!") );
+ wxFAIL_MSG( wxT("this encoding should be available!") );
font = wxLoadQueryFont(-1,
wxDEFAULT, wxNORMAL, wxNORMAL,
false, wxEmptyString,
- _T("*"), _T("*"),
+ wxT("*"), wxT("*"),
xFontName);
}
}
{
// some X servers will fail to load this font because there are too many
// matches so we must test explicitly for this
- if ( fontspec == _T("-*-*-*-*-*-*-*-*-*-*-*-*-*-*") )
+ if ( fontspec == wxT("-*-*-*-*-*-*-*-*-*-*-*-*-*-*") )
{
return true;
}
break;
default:
- wxFAIL_MSG(_T("unknown font style"));
+ wxFAIL_MSG(wxT("unknown font style"));
// fall back to normal
case wxNORMAL:
wxString sizeSpec;
if ( pointSize == -1 )
{
- sizeSpec = _T('*');
+ sizeSpec = wxT('*');
}
else
{
- sizeSpec.Printf(_T("%d"), pointSize);
+ sizeSpec.Printf(wxT("%d"), pointSize);
}
// construct the X font spec from our data
void wxFontModule::OnExit()
{
- delete g_fontHash;
-
- g_fontHash = (wxHashTable *)NULL;
+ wxDELETE(g_fontHash);
}
#endif // GTK 2.0/1.x
projects / wxWidgets.git / blobdiff