X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ab5fe83396c13f9fbf01630c52adf4df7607cbfe..b50e6e416e2b4cdc849ea6f24181094c0957d904:/src/unix/fontutil.cpp?ds=sidebyside

diff --git a/src/unix/fontutil.cpp b/src/unix/fontutil.cpp
index 841e90bf64..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 <gdk/gdk.h>
 #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,35 +491,35 @@ 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;
@@ -159,23 +531,23 @@ wxString wxNativeEncodingInfo::ToString() const
 
 void wxNativeFontInfo::Init()
 {
-    xFontName.clear();
+    m_isDefault = true;
 }
 
 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') )
-        return FALSE;
+    if ( token != wxT('0') )
+        return false;
 
     xFontName = tokenizer.GetNextToken();
 
     // this should be the end
     if ( tokenizer.HasMoreTokens() )
-        return FALSE;
+        return false;
 
     return FromXFontName(xFontName);
 }
@@ -183,7 +555,7 @@ bool wxNativeFontInfo::FromString(const wxString& s)
 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)
@@ -196,24 +568,61 @@ wxString wxNativeFontInfo::ToUserString() const
     return GetXFontName();
 }
 
-bool wxNativeFontInfo::FromXFontName(const wxString& xFontName)
+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(xFontName, _T("-"), wxTOKEN_STRTOK);
+    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;
+            return false;
         }
 
-        fontElements[n] = tokenizer.GetNextToken();
+        wxString field = tokenizer.GetNextToken();
+        if ( !field.empty() && field != wxT('*') )
+        {
+            // we're really initialized now
+            m_isDefault = false;
+        }
+
+        fontElements[n] = field;
     }
 
     // this should be all
-    return !tokenizer.HasMoreTokens();
+    if ( tokenizer.HasMoreTokens() )
+        return false;
+
+    return true;
 }
 
 wxString wxNativeFontInfo::GetXFontName() const
@@ -225,19 +634,214 @@ wxString wxNativeFontInfo::GetXFontName() const
             // replace the non specified elements with '*' except for the
             // additional style which is usually just omitted
             wxString elt = fontElements[n];
-            if ( elt.empty() && n != 5 )
+            if ( elt.empty() && n != wxXLFD_ADDSTYLE )
             {
-                elt = _T('*');
+                elt = wxT('*');
             }
 
             // const_cast
-            ((wxNativeFontInfo *)this)->xFontName << _T('-') << elt;
+            ((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
 // ----------------------------------------------------------------------------
@@ -245,7 +849,7 @@ wxString wxNativeFontInfo::GetXFontName() 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 )
     {
@@ -281,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)
@@ -303,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("*");
@@ -310,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;
 
-    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());
 
@@ -362,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
@@ -379,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++)
@@ -392,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();
@@ -403,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
 
-        // Search for smaller size (approx.)
-        for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
+        // first round: search for equal, then for smaller and for larger size
+        // with the given weight and style
+        int testweight = weight;
+        int teststyle = style;
+
+        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
@@ -469,7 +1109,7 @@ wxNativeFont wxLoadQueryNearestFont(int pointSize,
                 if ( !font )
                 {
                     font = wxLoadQueryFont(-1, wxDEFAULT, wxNORMAL, wxNORMAL,
-                                           FALSE, wxEmptyString,
+                                           false, wxEmptyString,
                                            info.xregistry, info.xencoding,
                                            xFontName);
 
@@ -478,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);
                     }
                 }
@@ -498,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);
@@ -521,11 +1161,11 @@ static bool wxTestFontSpec(const wxString& fontspec)
     {
         wxFreeFont(test);
 
-        return TRUE;
+        return true;
     }
     else
     {
-        return FALSE;
+        return false;
     }
 }
 
@@ -550,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());
@@ -602,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:
@@ -708,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
@@ -726,6 +1436,8 @@ static wxNativeFont wxLoadQueryFont(int pointSize,
         *xFontName = fontSpec;
 
     return wxLoadFont(fontSpec);
+#endif
+    // wxUSE_NANOX
 }
 
 // ----------------------------------------------------------------------------
@@ -748,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