X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5707316c9cbc2b44bb6b0246d766e5bb0cfdc2e7..2028c33ab5a39a12bd410ac953731a56ad6377ba:/src/unix/fontutil.cpp diff --git a/src/unix/fontutil.cpp b/src/unix/fontutil.cpp index f190de22b6..aa47c514c4 100644 --- a/src/unix/fontutil.cpp +++ b/src/unix/fontutil.cpp @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: unix/fontutil.cpp -// Purpose: Font helper functions for X11 (GDK/X) +// Name: src/unix/fontutil.cpp +// Purpose: Font helper functions for wxX11, wxGTK, wxMotif // Author: Vadim Zeitlin // Modified by: // Created: 05.11.99 // RCS-ID: $Id$ // Copyright: (c) Vadim Zeitlin -// Licence: wxWindows license +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "fontutil.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -28,9 +24,385 @@ #pragma hdrstop #endif +#include "wx/fontutil.h" + #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/fontmap.h" +#include "wx/tokenzr.h" +#include "wx/fontenum.h" + +#if wxUSE_PANGO + +#include "pango/pango.h" + +#ifdef __WXGTK20__ + #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/gtk/private/string.h" + + #define wxPANGO_CONV(s) (wxConvUTF8.cWX2MB((s))) + #define wxPANGO_CONV_BACK(s) (wxConvUTF8.cMB2WX((s))) +#endif + +// ---------------------------------------------------------------------------- +// wxNativeFontInfo +// ---------------------------------------------------------------------------- + +void wxNativeFontInfo::Init() +{ + description = NULL; +} + +void wxNativeFontInfo::Init(const wxNativeFontInfo& info) +{ + if (info.description) + description = pango_font_description_copy(info.description); + else + description = NULL; +} + +void wxNativeFontInfo::Free() +{ + if (description) + pango_font_description_free(description); +} + +int wxNativeFontInfo::GetPointSize() const +{ + return pango_font_description_get_size( description ) / PANGO_SCALE; +} + +wxFontStyle wxNativeFontInfo::GetStyle() const +{ + wxFontStyle m_style = wxFONTSTYLE_NORMAL; + + switch (pango_font_description_get_style( description )) + { + 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; + } + + return m_style; +} + +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + // 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; + + PangoWeight pango_weight = pango_font_description_get_weight( description ); + + // Until the API can be changed the following ranges of weight values are used: + // wxFONTWEIGHT_LIGHT: 100 .. 349 - range of 250 + // wxFONTWEIGHT_NORMAL: 350 .. 599 - range of 250 + // wxFONTWEIGHT_BOLD: 600 .. 900 - range of 301 (600 is "semibold" already) + + if (pango_weight >= 600) + return wxFONTWEIGHT_BOLD; + + if (pango_weight < 350) + return wxFONTWEIGHT_LIGHT; + + return wxFONTWEIGHT_NORMAL; +} + +bool wxNativeFontInfo::GetUnderlined() const +{ + return false; +} + +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_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. + 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 (strncasecmp( family_text, "monospace", 9 ) == 0) + ret = wxFONTFAMILY_TELETYPE; // begins with "Monospace" + else if (strncasecmp( family_text, "courier", 7 ) == 0) + ret = wxFONTFAMILY_TELETYPE; // begins with "Courier" +#if defined(__WXGTK20__) || defined(HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE) + else +#ifdef __WXGTK20__ + if (!gtk_check_version(2,4,0)) +#endif + { + PangoFontFamily **families; + PangoFontFamily *family = NULL; + int n_families; + pango_context_list_families( +#ifdef __WXGTK20__ + gtk_widget_get_pango_context( wxGetRootWindow() ), +#else + wxTheApp->GetPangoContext(), +#endif + &families, &n_families); + + 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 ) + { + 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, "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 // GTK+ 2 || HAVE_PANGO_FONT_FAMILY_IS_MONOSPACE + + if (ret == wxFONTFAMILY_UNKNOWN) + { + 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 (strncasecmp( family_text, "times", 5 ) == 0) + ret = wxFONTFAMILY_ROMAN; // begins with "Times" + else if (strncasecmp( family_text, "old", 3 ) == 0) + ret = wxFONTFAMILY_DECORATIVE; // begins with "Old" - "Old English", "Old Town" + } + + return ret; +} + +wxFontEncoding wxNativeFontInfo::GetEncoding() const +{ + return wxFONTENCODING_SYSTEM; +} + +void wxNativeFontInfo::SetPointSize(int pointsize) +{ + pango_font_description_set_size( description, pointsize * PANGO_SCALE ); +} + +void wxNativeFontInfo::SetStyle(wxFontStyle style) +{ + switch (style) + { + case wxFONTSTYLE_ITALIC: + pango_font_description_set_style( description, PANGO_STYLE_ITALIC ); + break; + case wxFONTSTYLE_SLANT: + pango_font_description_set_style( description, PANGO_STYLE_OBLIQUE ); + break; + default: + wxFAIL_MSG( "unknown font style" ); + // fall through + case wxFONTSTYLE_NORMAL: + pango_font_description_set_style( description, PANGO_STYLE_NORMAL ); + break; + } +} + +void wxNativeFontInfo::SetWeight(wxFontWeight weight) +{ + switch (weight) + { + case wxFONTWEIGHT_BOLD: + pango_font_description_set_weight(description, PANGO_WEIGHT_BOLD); + break; + case wxFONTWEIGHT_LIGHT: + pango_font_description_set_weight(description, PANGO_WEIGHT_LIGHT); + break; + default: + 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)) +{ + // wxWindowDCImpl::DoDrawText will take care of rendering font with + // the underline attribute! + wxFAIL_MSG( "not implemented" ); +} + +bool wxNativeFontInfo::SetFaceName(const wxString& 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 family) +{ + 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("Century Schoolbook L")); + facename.Add(wxS("URW Bookman L")); + facename.Add(wxS("URW Palladio L")); + facename.Add(wxS("DejaVu Serif")); + facename.Add(wxS("FreeSerif")); + facename.Add(wxS("Times New Roman")); + 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("DejaVu Sans Mono")); + facename.Add(wxS("Nimbus Mono L")); + facename.Add(wxS("Bitstream Vera Sans Mono")); + facename.Add(wxS("Andale Mono")); + facename.Add(wxS("Lucida Sans Typewriter")); + facename.Add(wxS("FreeMono")); + facename.Add(wxS("Courier New")); + 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("DejaVu Sans")); + facename.Add(wxS("URW Gothic L")); + facename.Add(wxS("Nimbus Sans L")); + facename.Add(wxS("Bitstream Vera Sans")); + facename.Add(wxS("Lucida Sans")); + facename.Add(wxS("Arial")); + facename.Add(wxS("FreeSans")); + break; + } + + SetFaceName(facename); +} + +void wxNativeFontInfo::SetEncoding(wxFontEncoding WXUNUSED(encoding)) +{ + wxFAIL_MSG( "not implemented: Pango encoding is always UTF8" ); +} + +bool wxNativeFontInfo::FromString(const wxString& s) +{ + if (description) + pango_font_description_free( description ); + + // there is a bug in at least pango <= 1.13 which makes it (or its backends) + // segfault for very big point sizes and for negative point sizes. + // To workaround that bug for pango <= 1.13 + // (see http://bugzilla.gnome.org/show_bug.cgi?id=340229) + // 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(wxS(" ")); + double size; + if ( pos != wxString::npos && wxString(str, pos + 1).ToDouble(&size) ) + { + wxString sizeStr; + if ( size < 1 ) + sizeStr = wxS("1"); + else if ( size >= 1E6 ) + sizeStr = wxS("1E6"); + + if ( !sizeStr.empty() ) + { + // replace the old size with the adjusted one + str = wxString(s, 0, pos) + sizeStr; + } + } + + 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 wxPANGO_CONV_BACK(str); +} + +bool wxNativeFontInfo::FromUserString(const wxString& s) +{ + return FromString( s ); +} + +wxString wxNativeFontInfo::ToUserString() const +{ + return ToString(); +} + +#else // GTK+ 1.x + #ifdef __X__ #ifdef __VMS__ #pragma message disable nosimpint @@ -42,7 +414,6 @@ #pragma message enable nosimpint #endif - #include "wx/utils.h" // for wxGetDisplay() #elif defined(__WXGTK__) // we have to declare struct tm to avoid problems with first forward // declaring it in C code (glib.h included from gdk.h does it) and then @@ -53,17 +424,12 @@ #include #endif -#include "wx/fontutil.h" -#include "wx/fontmap.h" -#include "wx/tokenzr.h" -#include "wx/hash.h" -#include "wx/module.h" // ---------------------------------------------------------------------------- // private data // ---------------------------------------------------------------------------- -static wxHashTable *g_fontHash = (wxHashTable*) NULL; +static wxHashTable *g_fontHash = NULL; // ---------------------------------------------------------------------------- // private functions @@ -71,22 +437,28 @@ static wxHashTable *g_fontHash = (wxHashTable*) NULL; // define the functions to create and destroy native fonts for this toolkit #ifdef __X__ - static inline wxNativeFont wxLoadFont(const wxString& fontSpec) + wxNativeFont wxLoadFont(const wxString& fontSpec) { return XLoadQueryFont((Display *)wxGetDisplay(), fontSpec); } - static inline void wxFreeFont(wxNativeFont font) + inline void wxFreeFont(wxNativeFont font) { XFreeFont((Display *)wxGetDisplay(), (XFontStruct *)font); } #elif defined(__WXGTK__) - static inline wxNativeFont wxLoadFont(const wxString& fontSpec) + wxNativeFont wxLoadFont(const wxString& fontSpec) { - return gdk_font_load( wxConvertWX2MB(fontSpec) ); + // VZ: we should use gdk_fontset_load() instead of gdk_font_load() + // here to be able to display Japanese fonts correctly (at least + // this is what people report) but unfortunately doing it results + // in tons of warnings when using GTK with "normal" European + // languages and so we can't always do it and I don't know enough + // to determine when should this be done... (FIXME) + return gdk_font_load( wxConvertWX2MB(fontSpec) ); } - static inline void wxFreeFont(wxNativeFont font) + inline void wxFreeFont(wxNativeFont font) { gdk_font_unref(font); } @@ -119,40 +491,357 @@ static wxNativeFont wxLoadQueryFont(int pointSize, 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; if ( !encid.ToLong(&enc) ) - return FALSE; + return false; encoding = (wxFontEncoding)enc; xregistry = tokenizer.GetNextToken(); if ( !xregistry ) - return FALSE; + return false; xencoding = tokenizer.GetNextToken(); if ( !xencoding ) - return FALSE; + return false; // ok even if empty facename = tokenizer.GetNextToken(); - return TRUE; + return true; } wxString wxNativeEncodingInfo::ToString() const { wxString s; - s << (long)encoding << _T(';') << xregistry << _T(';') << xencoding; - if ( !!facename ) + s << (long)encoding << wxT(';') << xregistry << wxT(';') << xencoding; + if ( !facename.empty() ) { - s << _T(';') << facename; + s << wxT(';') << facename; } return s; } +// ---------------------------------------------------------------------------- +// wxNativeFontInfo +// ---------------------------------------------------------------------------- + +void wxNativeFontInfo::Init() +{ + m_isDefault = true; +} + +bool wxNativeFontInfo::FromString(const wxString& s) +{ + wxStringTokenizer tokenizer(s, wxT(";")); + + // check the version + wxString token = tokenizer.GetNextToken(); + if ( token != wxT('0') ) + return false; + + xFontName = tokenizer.GetNextToken(); + + // this should be the end + if ( tokenizer.HasMoreTokens() ) + return false; + + return FromXFontName(xFontName); +} + +wxString wxNativeFontInfo::ToString() const +{ + // 0 is the version + return wxString::Format(wxT("%d;%s"), 0, GetXFontName().c_str()); +} + +bool wxNativeFontInfo::FromUserString(const wxString& s) +{ + return FromXFontName(s); +} + +wxString wxNativeFontInfo::ToUserString() const +{ + return GetXFontName(); +} + +bool wxNativeFontInfo::HasElements() const +{ + // we suppose that the foundry is never empty, so if it is it means that we + // had never parsed the XLFD + return !fontElements[0].empty(); +} + +wxString wxNativeFontInfo::GetXFontComponent(wxXLFDField field) const +{ + wxCHECK_MSG( field < wxXLFD_MAX, wxEmptyString, wxT("invalid XLFD field") ); + + if ( !HasElements() ) + { + // const_cast + if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) ) + return wxEmptyString; + } + + return fontElements[field]; +} + +bool wxNativeFontInfo::FromXFontName(const wxString& fontname) +{ + // TODO: we should be able to handle the font aliases here, but how? + wxStringTokenizer tokenizer(fontname, wxT("-")); + + // skip the leading, usually empty field (font name registry) + if ( !tokenizer.HasMoreTokens() ) + return false; + + (void)tokenizer.GetNextToken(); + + for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ ) + { + if ( !tokenizer.HasMoreTokens() ) + { + // not enough elements in the XLFD - or maybe an alias + return false; + } + + wxString field = tokenizer.GetNextToken(); + if ( !field.empty() && field != wxT('*') ) + { + // we're really initialized now + m_isDefault = false; + } + + fontElements[n] = field; + } + + // this should be all + if ( tokenizer.HasMoreTokens() ) + return false; + + return true; +} + +wxString wxNativeFontInfo::GetXFontName() const +{ + if ( xFontName.empty() ) + { + for ( size_t n = 0; n < WXSIZEOF(fontElements); n++ ) + { + // replace the non specified elements with '*' except for the + // additional style which is usually just omitted + wxString elt = fontElements[n]; + if ( elt.empty() && n != wxXLFD_ADDSTYLE ) + { + elt = wxT('*'); + } + + // const_cast + ((wxNativeFontInfo *)this)->xFontName << wxT('-') << elt; + } + } + + return xFontName; +} + +void +wxNativeFontInfo::SetXFontComponent(wxXLFDField field, const wxString& value) +{ + 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(), wxT("can't modify an uninitialized XLFD") ); + + if ( !HasElements() ) + { + // const_cast + if ( !((wxNativeFontInfo *)this)->FromXFontName(xFontName) ) + { + wxFAIL_MSG( wxT("can't set font element for invalid XLFD") ); + + return; + } + } + + fontElements[field] = value; + + // invalidate the XFLD, it doesn't correspond to the font elements any more + xFontName.clear(); +} + +void wxNativeFontInfo::SetXFontName(const wxString& xFontName_) +{ + // invalidate the font elements, GetXFontComponent() will reparse the XLFD + fontElements[0].clear(); + + xFontName = xFontName_; + + m_isDefault = false; +} + +int wxNativeFontInfo::GetPointSize() const +{ + const wxString s = GetXFontComponent(wxXLFD_POINTSIZE); + + // return -1 to indicate that the size is unknown + long l; + return s.ToLong(&l) ? l : -1; +} + +wxFontStyle wxNativeFontInfo::GetStyle() const +{ + const wxString s = GetXFontComponent(wxXLFD_SLANT); + + if ( s.length() != 1 ) + { + // it is really unknown but we don't have any way to return it from + // here + return wxFONTSTYLE_NORMAL; + } + + switch ( s[0].GetValue() ) + { + default: + // again, unknown but consider normal by default + + case wxT('r'): + return wxFONTSTYLE_NORMAL; + + case wxT('i'): + return wxFONTSTYLE_ITALIC; + + case wxT('o'): + return wxFONTSTYLE_SLANT; + } +} + +wxFontWeight wxNativeFontInfo::GetWeight() const +{ + const wxString s = GetXFontComponent(wxXLFD_WEIGHT).MakeLower(); + if ( s.find(wxT("bold")) != wxString::npos || s == wxT("black") ) + return wxFONTWEIGHT_BOLD; + else if ( s == wxT("light") ) + return wxFONTWEIGHT_LIGHT; + + return wxFONTWEIGHT_NORMAL; +} + +bool wxNativeFontInfo::GetUnderlined() const +{ + // X fonts are never underlined + return false; +} + +wxString wxNativeFontInfo::GetFaceName() const +{ + // wxWidgets facename probably more accurately corresponds to X family + return GetXFontComponent(wxXLFD_FAMILY); +} + +wxFontFamily wxNativeFontInfo::GetFamily() const +{ + // and wxWidgets family -- to X foundry, but we have to translate it to + // wxFontFamily somehow... + 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( wxT("not implemented") ); + + return wxFONTENCODING_MAX; +} + +void wxNativeFontInfo::SetPointSize(int pointsize) +{ + SetXFontComponent(wxXLFD_POINTSIZE, wxString::Format(wxT("%d"), pointsize)); +} + +void wxNativeFontInfo::SetStyle(wxFontStyle style) +{ + wxString s; + switch ( style ) + { + case wxFONTSTYLE_ITALIC: + s = wxT('i'); + break; + + case wxFONTSTYLE_SLANT: + s = wxT('o'); + break; + + case wxFONTSTYLE_NORMAL: + s = wxT('r'); + + default: + wxFAIL_MSG( wxT("unknown wxFontStyle in wxNativeFontInfo::SetStyle") ); + return; + } + + SetXFontComponent(wxXLFD_SLANT, s); +} + +void wxNativeFontInfo::SetWeight(wxFontWeight weight) +{ + wxString s; + switch ( weight ) + { + case wxFONTWEIGHT_BOLD: + s = wxT("bold"); + break; + + case wxFONTWEIGHT_LIGHT: + s = wxT("light"); + break; + + case wxFONTWEIGHT_NORMAL: + s = wxT("medium"); + break; + + default: + wxFAIL_MSG( wxT("unknown wxFontWeight in wxNativeFontInfo::SetWeight") ); + return; + } + + SetXFontComponent(wxXLFD_WEIGHT, s); +} + +void wxNativeFontInfo::SetUnderlined(bool WXUNUSED(underlined)) +{ + // can't do this under X +} + +bool wxNativeFontInfo::SetFaceName(const wxString& facename) +{ + SetXFontComponent(wxXLFD_FAMILY, facename); + return true; +} + +void wxNativeFontInfo::SetFamily(wxFontFamily WXUNUSED(family)) +{ + // wxFontFamily -> X foundry, anyone? + wxFAIL_MSG( wxT("not implemented") ); + + // SetXFontComponent(wxXLFD_FOUNDRY, ...); +} + +void wxNativeFontInfo::SetEncoding(wxFontEncoding encoding) +{ + wxNativeEncodingInfo info; + if ( wxGetNativeFontEncoding(encoding, &info) ) + { + SetXFontComponent(wxXLFD_ENCODING, info.xencoding); + SetXFontComponent(wxXLFD_REGISTRY, info.xregistry); + } +} + // ---------------------------------------------------------------------------- // common functions // ---------------------------------------------------------------------------- @@ -160,7 +849,7 @@ wxString wxNativeEncodingInfo::ToString() const 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 ) { @@ -196,7 +885,13 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding, info->xencoding = wxT("*"); break; + case wxFONTENCODING_GB2312: + info->xregistry = wxT("GB2312"); // or the otherway round? + info->xencoding = wxT("*"); + break; + case wxFONTENCODING_KOI8: + case wxFONTENCODING_KOI8_U: info->xregistry = wxT("koi8"); // we don't make distinction between koi8-r, koi8-u and koi8-ru (so far) @@ -218,6 +913,12 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding, } break; + case wxFONTENCODING_EUC_JP: + case wxFONTENCODING_SHIFT_JIS: + info->xregistry = "jis*"; + info->xencoding = "*"; + break; + case wxFONTENCODING_SYSTEM: info->xregistry = info->xencoding = wxT("*"); @@ -225,19 +926,19 @@ bool wxGetNativeFontEncoding(wxFontEncoding encoding, default: // don't know how to translate this encoding into X fontspec - return FALSE; + return false; } - info->encoding = encoding; + info->encoding = encoding; - return TRUE; + return true; } bool wxTestFontEncoding(const wxNativeEncodingInfo& info) { wxString fontspec; - fontspec.Printf(_T("-*-%s-*-*-*-*-*-*-*-*-*-*-%s-%s"), - !info.facename ? _T("*") : info.facename.c_str(), + fontspec.Printf(wxT("-*-%s-*-*-*-*-*-*-*-*-*-*-%s-%s"), + !info.facename ? wxT("*") : info.facename.c_str(), info.xregistry.c_str(), info.xencoding.c_str()); @@ -277,7 +978,7 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, !wxTestFontEncoding(info) ) { #if wxUSE_FONTMAP - if ( !wxTheFontMapper->GetAltForEncoding(encoding, &info) ) + if ( !wxFontMapper::Get()->GetAltForEncoding(encoding, &info) ) #endif // wxUSE_FONTMAP { // unspported encoding - replace it with the default @@ -294,12 +995,12 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, wxNativeFont font = 0; // if we already have the X font name, try to use it - if( xFontName && !xFontName->IsEmpty() ) + if( xFontName && !xFontName->empty() ) { // // 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++) @@ -307,7 +1008,7 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, (void) tokenizer.NextToken(); - newFontName += wxString::Format("%d-", pointSize); + newFontName += wxString::Format(wxT("%d-"), pointSize); while(tokenizer.HasMoreTokens()) newFontName += tokenizer.GetNextToken(); @@ -318,37 +1019,61 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, *xFontName = newFontName; } - // try to load exactly the font requested first - if( !font ) - { - font = wxLoadQueryFont( pointSize, family, style, weight, - underlined, facename, - info.xregistry, info.xencoding, - xFontName ); - } - if ( !font ) { // search up and down by stepsize 10 int max_size = pointSize + 20 * (1 + (pointSize/180)); int min_size = pointSize - 20 * (1 + (pointSize/180)); - int i; + int i, round; // counters + + // first round: search for equal, then for smaller and for larger size + // with the given weight and style + int testweight = weight; + int teststyle = style; - // Search for smaller size (approx.) - for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 ) + for ( round = 0; round < 3; round++ ) { - font = wxLoadQueryFont(i, family, style, weight, underlined, + // second round: use normal weight + if ( round == 1 ) + { + if ( testweight != wxNORMAL ) + { + testweight = wxNORMAL; + } + else + { + ++round; // fall through to third round + } + } + + // third round: ... and use normal style + if ( round == 2 ) + { + if ( teststyle != wxNORMAL ) + { + teststyle = wxNORMAL; + } + else + { + break; + } + } + // Search for equal or smaller size (approx.) + for ( i = pointSize; !font && i >= 10 && i >= min_size; i -= 10 ) + { + font = wxLoadQueryFont(i, family, teststyle, testweight, underlined, facename, info.xregistry, info.xencoding, xFontName); - } + } - // Search for larger size (approx.) - for ( i = pointSize + 10; !font && i <= max_size; i += 10 ) - { - font = wxLoadQueryFont(i, family, style, weight, underlined, + // Search for larger size (approx.) + for ( i = pointSize + 10; !font && i <= max_size; i += 10 ) + { + font = wxLoadQueryFont(i, family, teststyle, testweight, underlined, facename, info.xregistry, info.xencoding, xFontName); + } } // Try default family @@ -384,7 +1109,7 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, if ( !font ) { font = wxLoadQueryFont(-1, wxDEFAULT, wxNORMAL, wxNORMAL, - FALSE, wxEmptyString, + false, wxEmptyString, info.xregistry, info.xencoding, xFontName); @@ -393,12 +1118,12 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, // 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("*"), + false, wxEmptyString, + wxT("*"), wxT("*"), xFontName); } } @@ -413,20 +1138,20 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize, // private functions // ---------------------------------------------------------------------------- -// returns TRUE if there are any fonts matching this font spec +// returns true if there are any fonts matching this font spec static bool wxTestFontSpec(const wxString& fontspec) { // 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; + return true; } wxNativeFont test = (wxNativeFont) g_fontHash->Get( fontspec ); if (test) { - return TRUE; + return true; } test = wxLoadFont(fontspec); @@ -436,11 +1161,11 @@ static bool wxTestFontSpec(const wxString& fontspec) { wxFreeFont(test); - return TRUE; + return true; } else { - return FALSE; + return false; } } @@ -465,9 +1190,79 @@ static wxNativeFont wxLoadQueryFont(int pointSize, case wxSCRIPT: xfamily = wxT("utopia"); break; default: xfamily = wxT("*"); } +#if wxUSE_NANOX + int xweight; + switch (weight) + { + case wxBOLD: + { + xweight = MWLF_WEIGHT_BOLD; + break; + } + case wxLIGHT: + { + xweight = MWLF_WEIGHT_LIGHT; + break; + } + case wxNORMAL: + { + xweight = MWLF_WEIGHT_NORMAL; + break; + } + + default: + { + xweight = MWLF_WEIGHT_DEFAULT; + break; + } + } + GR_SCREEN_INFO screenInfo; + GrGetScreenInfo(& screenInfo); + + int yPixelsPerCM = screenInfo.ydpcm; + + // A point is 1/72 of an inch. + // An inch is 2.541 cm. + // So pixelHeight = (pointSize / 72) (inches) * 2.541 (for cm) * yPixelsPerCM (for pixels) + // In fact pointSize is 10 * the normal point size so + // divide by 10. + + int pixelHeight = (int) ( (((float)pointSize) / 720.0) * 2.541 * (float) yPixelsPerCM) ; + + // An alternative: assume that the screen is 72 dpi. + //int pixelHeight = (int) (((float)pointSize / 720.0) * 72.0) ; + //int pixelHeight = (int) ((float)pointSize / 10.0) ; + + GR_LOGFONT logFont; + logFont.lfHeight = pixelHeight; + logFont.lfWidth = 0; + logFont.lfEscapement = 0; + logFont.lfOrientation = 0; + logFont.lfWeight = xweight; + logFont.lfItalic = (style == wxNORMAL ? 0 : 1) ; + logFont.lfUnderline = 0; + logFont.lfStrikeOut = 0; + logFont.lfCharSet = MWLF_CHARSET_DEFAULT; // TODO: select appropriate one + logFont.lfOutPrecision = MWLF_TYPE_DEFAULT; + logFont.lfClipPrecision = 0; // Not used + logFont.lfRoman = (family == wxROMAN ? 1 : 0) ; + logFont.lfSerif = (family == wxSWISS ? 0 : 1) ; + logFont.lfSansSerif = !logFont.lfSerif ; + logFont.lfModern = (family == wxMODERN ? 1 : 0) ; + logFont.lfProportional = (family == wxTELETYPE ? 0 : 1) ; + logFont.lfOblique = 0; + logFont.lfSmallCaps = 0; + logFont.lfPitch = 0; // 0 = default + strcpy(logFont.lfFaceName, facename.c_str()); + + XFontStruct* fontInfo = (XFontStruct*) malloc(sizeof(XFontStruct)); + fontInfo->fid = GrCreateFont((GR_CHAR*) facename.c_str(), pixelHeight, & logFont); + GrGetFontInfo(fontInfo->fid, & fontInfo->info); + return (wxNativeFont) fontInfo; +#else wxString fontSpec; - if (!facename.IsEmpty()) + if (!facename.empty()) { fontSpec.Printf(wxT("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"), facename.c_str()); @@ -517,7 +1312,7 @@ static wxNativeFont wxLoadQueryFont(int pointSize, break; default: - wxFAIL_MSG(_T("unknown font style")); + wxFAIL_MSG(wxT("unknown font style")); // fall back to normal case wxNORMAL: @@ -623,13 +1418,13 @@ static wxNativeFont wxLoadQueryFont(int pointSize, // if pointSize is -1, don't specify any wxString sizeSpec; - if ( fontSpec == -1 ) + 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 @@ -641,6 +1436,8 @@ static wxNativeFont wxLoadQueryFont(int pointSize, *xFontName = fontSpec; return wxLoadFont(fontSpec); +#endif + // wxUSE_NANOX } // ---------------------------------------------------------------------------- @@ -663,12 +1460,14 @@ bool wxFontModule::OnInit() { g_fontHash = new wxHashTable( wxKEY_STRING ); - return TRUE; + return true; } void wxFontModule::OnExit() { delete g_fontHash; - g_fontHash = (wxHashTable *)NULL; + g_fontHash = NULL; } + +#endif // GTK 2.0/1.x