1. wxFontMapper almost finished

2. font helper functions are now in separate files, not utilsunx.cpp


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4376 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

distrib/msw/tmake/filelist.txt

@@ -481,6 +481,7 @@ filedlg.h	W
 filefn.h	W
 filesys.h	W
 font.h	W
+fontdlg.h	W
 fontenum.h	W
 fontmap.h	W
 fontdlg.h	W
@@ -846,6 +847,7 @@ xpmhand.h	9
 # disable.bmp	9
 # wx.rc	9
 
+fontutil.h	S
 execute.h	S
 
 file.h	P

include/wx/app.h

@@ -100,7 +100,7 @@ public:
         // value of this method.
         //
         // Override: often.
-    virtual int OnExit() { return 0; }
+    virtual int OnExit();
 
         // called when a fatal exception occurs, this function should take care
         // not to do anything which might provoke a nested exception! It may be

include/wx/cmndata.h

@@ -18,6 +18,7 @@
 
 #include "wx/window.h"
 #include "wx/font.h"
+#include "wx/fontutil.h"
 #include "wx/colour.h"
 #include "wx/gdicmn.h"
 
@@ -55,7 +56,6 @@ class WXDLLEXPORT wxFontData: public wxObject
     DECLARE_DYNAMIC_CLASS(wxFontData)
 public:
     wxFontData();
-    wxFontData(const wxFontData& fontData);
     ~wxFontData();
 
     void SetAllowSymbols(bool flag) { allowSymbols = flag; }
@@ -78,7 +78,13 @@ public:
 
     void SetRange(int minRange, int maxRange) { minSize = minRange; maxSize = maxRange; }
 
-    void operator=(const wxFontData& data);
+    // encoding info is split into 2 parts: the logical wxWin encoding
+    // (wxFontEncoding) and a structure containing the native parameters for
+    // it (wxNativeEncodingInfo)
+    wxFontEncoding GetEncoding() const { return m_encoding; }
+    void SetEncoding(wxFontEncoding encoding) { m_encoding = encoding; }
+
+    wxNativeEncodingInfo& EncodingInfo() { return m_encodingInfo; }
 
 public:
     wxColour        fontColour;
@@ -89,6 +95,10 @@ public:
     wxFont          chosenFont;
     int             minSize;
     int             maxSize;
+
+private:
+    wxFontEncoding       m_encoding;
+    wxNativeEncodingInfo m_encodingInfo;
 };
 
 #if wxUSE_PRINTING_ARCHITECTURE

include/wx/font.h

@@ -27,6 +27,7 @@
 // forward declarations
 // ----------------------------------------------------------------------------
 
+class WXDLLEXPORT wxFontData;
 class WXDLLEXPORT wxFontBase;
 class WXDLLEXPORT wxFont;
 

include/wx/fontenum.h

@@ -17,6 +17,8 @@
     #pragma interface "fontenum.h"
 #endif
 
+#include "wx/font.h"
+
 // ----------------------------------------------------------------------------
 // wxFontEnumerator enumerates all available fonts on the system or only the
 // fonts with given attributes

include/wx/fontmap.h

@@ -20,9 +20,8 @@
 // headers
 // ----------------------------------------------------------------------------
 
-#include "wx/defs.h"        // for wxDEFAULT &c
+#include "wx/font.h"        // for wxFont and wxFontEncoding
-
+#include "wx/fontutil.h"    // for wxNativeEncodingInfo
-#include "wx/font.h"        // for wxFontEncoding
 
 class WXDLLEXPORT wxConfigBase;
 
@@ -49,14 +48,38 @@ public:
     // virtual dtor for a base class
     virtual ~wxFontMapper();
 
+    // find an alternative for the given encoding (which is supposed to not be
+    // available on this system). If successful, return TRUE and fill info
+    // structure with the parameters required to create the font, otherwise
+    // return FALSE
+    virtual bool GetAltForEncoding(wxFontEncoding encoding,
+                                   wxNativeEncodingInfo *info,
+                                   bool interactive = TRUE);
+
     // returns the encoding for the given charset (in the form of RFC 2046) or
     // wxFONTENCODING_SYSTEM if couldn't decode it
     virtual wxFontEncoding CharsetToEncoding(const wxString& charset,
                                              bool interactive = TRUE);
 
+    // encoding names
+    // --------------
+
+    // return internal string identifier for the encoding (see also
+    // GetEncodingDescription())
+    static wxString GetEncodingName(wxFontEncoding encoding);
+
+    // return user-readable string describing the given encoding
+    //
+    // NB: hard-coded now, but might change later (read it from config?)
+    static wxString GetEncodingDescription(wxFontEncoding encoding);
+
     // configure the appearance of the dialogs we may popup
     // ----------------------------------------------------
 
+    // the parent window for modal dialogs
+    void SetDialogParent(wxWindow *parent) { m_windowParent = parent; }
+
+    // the title for the dialogs (note that default is quite reasonable)
     void SetDialogTitle(const wxString& title) { m_titleDialog = title; }
 
     // functions which allow to configure the config object used: by default,
@@ -94,6 +117,17 @@ protected:
     // restore the config path after use
     void RestorePath(const wxString& pathOld);
 
+    // GetAltForEncoding() helper: tests for the existence of the given
+    // encoding and saves the result in config if ok - this results in the
+    // following (desired) behaviour: when an unknown/unavailable encoding is
+    // requested for the first time, the user is asked about a replacement,
+    // but if he doesn't choose any and the default logic finds one, it will
+    // be saved in the config so that the user won't be asked about it any
+    // more
+    bool TestAltEncoding(const wxString& configEntry,
+                         wxFontEncoding encReplacement,
+                         wxNativeEncodingInfo *info);
+
     // config object and path (in it) to use
     wxConfigBase *m_config;
     wxString  m_configRootPath;
@@ -103,6 +137,15 @@ protected:
 
     // the parent window for our dialogs
     wxWindow *m_windowParent;
+
+    friend class wxFontMapperPathChanger;
 };
 
+// ----------------------------------------------------------------------------
+// global variables
+// ----------------------------------------------------------------------------
+
+// the default font mapper for wxWindows programs
+WXDLLEXPORT_DATA(extern wxFontMapper *) wxTheFontMapper;
+
 #endif // _WX_FONTMAPPER_H_

include/wx/fontutil.h

@@ -0,0 +1,93 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/fontutil.h
+// Purpose:     font-related helper functions
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     05.11.99
+// RCS-ID:      $Id$
+// Copyright:   (c) wxWindows team
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// General note: this header is private to wxWindows and is not supposed to be
+// included by user code. The functions declared here are implemented in
+// msw/fontutil.cpp for Windows, unix/fontutil.cpp for GTK/Motif &c.
+
+#ifndef _WX_FONTUTIL_H_
+#define _WX_FONTUTIL_H_
+
+#ifdef __GNUG__
+    #pragma interface "fontutil.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/font.h"        // for wxFont and wxFontEncoding
+
+// for our purposes here, GDK and X are identical
+#if defined(__WXGTK__) || defined(__X__)
+    #define _WX_X_FONTLIKE
+#endif
+
+// ----------------------------------------------------------------------------
+// types
+// ----------------------------------------------------------------------------
+
+// This private structure specifies all the parameters needed to create a font
+// with the given encoding on this platform.
+//
+// Under X, it contains the last 2 elements of the font specifications
+// (registry and encoding).
+//
+// Under Windows, it contains a number which is one of predefined CHARSET_XXX
+// values.
+//
+// Under all platforms it also contains a facename string which should be
+// used, if not empty, to create fonts in this encoding (this is the only way
+// to create a font of non-standard encoding (like KOI8) under Windows - the
+// facename specifies the encoding then)
+
+struct wxNativeEncodingInfo
+{
+    wxString facename;          // may be empty meaning "any"
+
+#if defined(__WXMSW__)
+    int      charset;
+#elif defined(_WX_X_FONTLIKE)
+    wxString xregistry,
+             xencoding;
+#else
+    #error "Unsupported toolkit"
+#endif
+
+    // this struct is saved in config by wxFontMapper, so it should know to
+    // serialise itself (implemented in platform-specific code)
+    bool FromString(const wxString& s);
+    wxString ToString() const;
+};
+
+// ----------------------------------------------------------------------------
+// font-related functions (common)
+// ----------------------------------------------------------------------------
+
+// translate a wxFontEncoding into native encoding parameter (defined above),
+// returning TRUE if an (exact) macth could be found, FALSE otherwise (without
+// attempting any substitutions)
+extern bool wxGetNativeFontEncoding(wxFontEncoding encoding,
+                                    wxNativeEncodingInfo *info);
+
+// test for the existence of the font described by this facename/encoding,
+// return TRUE if such font(s) exist, FALSE otherwise
+extern bool wxTestFontEncoding(const wxNativeEncodingInfo& info);
+
+// ----------------------------------------------------------------------------
+// font-related functions (X and GTK)
+// ----------------------------------------------------------------------------
+
+#ifdef _WX_X_FONTLIKE
+    #include "wx/unix/fontutil.h"
+#endif // X || GDK
+
+#endif // _WX_FONTUTIL_H_

include/wx/gtk/font.h

@@ -14,11 +14,7 @@
     #pragma interface
 #endif
 
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
 #include "wx/hash.h"
-#include "wx/gdiobj.h"
 
 // ----------------------------------------------------------------------------
 // classes
@@ -30,12 +26,6 @@ class wxWindow;
 
 class wxFont;
 
-// ----------------------------------------------------------------------------
-// global variables
-// ----------------------------------------------------------------------------
-
-extern const wxChar* wxEmptyString;
-
 // ----------------------------------------------------------------------------
 // wxFont
 // ----------------------------------------------------------------------------
@@ -46,6 +36,7 @@ public:
     // ctors and such
     wxFont() { Init(); }
     wxFont(const wxFont& font) { Init(); Ref(font); }
+    wxFont(const wxString& fontname, const wxFontData& fontdata);
 
     // assignment
     wxFont& operator=(const wxFont& font);
@@ -91,7 +82,6 @@ public:
     virtual void SetEncoding(wxFontEncoding encoding);
 
     // implementation from now on
-    wxFont( GdkFont* font, char *xFontName );
     void Unshare();
 
     GdkFont* GetInternalFont(float scale = 1.0) const;

include/wx/gtk/fontdlg.h

@@ -38,7 +38,7 @@ public:
     wxFontDialog( wxWindow *parent, wxFontData *data = (wxFontData *) NULL );
     ~wxFontDialog();
 
-    inline wxFontData& GetFontData() { return m_fontData; }
+    wxFontData& GetFontData() { return m_fontData; }
 
 //protected:
     wxFontData m_fontData;

include/wx/gtk1/font.h

@@ -14,11 +14,7 @@
     #pragma interface
 #endif
 
-#include "wx/defs.h"
-#include "wx/object.h"
-#include "wx/string.h"
 #include "wx/hash.h"
-#include "wx/gdiobj.h"
 
 // ----------------------------------------------------------------------------
 // classes
@@ -30,12 +26,6 @@ class wxWindow;
 
 class wxFont;
 
-// ----------------------------------------------------------------------------
-// global variables
-// ----------------------------------------------------------------------------
-
-extern const wxChar* wxEmptyString;
-
 // ----------------------------------------------------------------------------
 // wxFont
 // ----------------------------------------------------------------------------
@@ -46,6 +36,7 @@ public:
     // ctors and such
     wxFont() { Init(); }
     wxFont(const wxFont& font) { Init(); Ref(font); }
+    wxFont(const wxString& fontname, const wxFontData& fontdata);
 
     // assignment
     wxFont& operator=(const wxFont& font);
@@ -91,7 +82,6 @@ public:
     virtual void SetEncoding(wxFontEncoding encoding);
 
     // implementation from now on
-    wxFont( GdkFont* font, char *xFontName );
     void Unshare();
 
     GdkFont* GetInternalFont(float scale = 1.0) const;

include/wx/gtk1/fontdlg.h

@@ -38,7 +38,7 @@ public:
     wxFontDialog( wxWindow *parent, wxFontData *data = (wxFontData *) NULL );
     ~wxFontDialog();
 
-    inline wxFontData& GetFontData() { return m_fontData; }
+    wxFontData& GetFontData() { return m_fontData; }
 
 //protected:
     wxFontData m_fontData;

include/wx/unix/fontutil.h

@@ -0,0 +1,32 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        wx/unix/fontutil.h
+// Purpose:     font-related helper functions for Unix/X11
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     05.11.99
+// RCS-ID:      $Id$
+// Copyright:   (c) wxWindows team
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_UNIX_FONTUTIL_H_
+#define _WX_UNIX_FONTUTIL_H_
+
+#ifdef __X__
+    typedef XFontStruct *wxNativeFont;
+#elif defined(__WXGTK__)
+    typedef GdkFont *wxNativeFont;
+#else
+    #error "Unsupported toolkit"
+#endif
+
+// returns the handle of the nearest available font or 0
+extern wxNativeFont wxLoadQueryNearestFont(int pointSize,
+                                           int family,
+                                           int style,
+                                           int weight,
+                                           bool underlined,
+                                           const wxString &facename,
+                                           wxFontEncoding encoding);
+
+#endif // _WX_UNIX_FONTUTIL_H_

include/wx/utils.h

@@ -377,38 +377,6 @@ void wxAllocColor(Display *display,Colormap colormap,XColor *xcolor);
 
 #endif //__X__
 
-// ----------------------------------------------------------------------------
-// font-related functions (X and GTK)
-// ----------------------------------------------------------------------------
-
-#if defined(__X__) || defined(__WXGTK__)
-
-#ifdef __X__
-    typedef XFontStruct *wxNativeFont;
-#else // GDK
-    typedef GdkFont *wxNativeFont;
-#endif
-
-#include "wx/font.h"    // for wxFontEncoding
-    
-// returns the handle of the nearest available font or 0
-extern wxNativeFont wxLoadQueryNearestFont(int pointSize,
-                                           int family,
-                                           int style,
-                                           int weight,
-                                           bool underlined,
-                                           const wxString &facename,
-                                           wxFontEncoding encoding);
-
-// fills xencoding and xregistry with the X font spec parts for the given
-// encoding ('*' if encoding == wxFONTENCODING_SYSTEM) and returns TRUE if any
-// fonts with this encoding exist or FALSE if it's unknown (it does *not* mean
-// that they don't exist!)
-extern bool wxGetXFontEncoding(wxFontEncoding encoding,
-                               wxString *xencoding, wxString *xregistry);
-
-#endif // X || GTK
-
 #endif // wxUSE_GUI
 
 #endif

samples/font/font.cpp

@@ -95,8 +95,9 @@ public:
     void OnSize(wxSizeEvent& event);
 
 protected:
-    void DoEnumerateFamilies(bool fixedWidthOnly,
+    bool DoEnumerateFamilies(bool fixedWidthOnly,
-                             wxFontEncoding encoding = wxFONTENCODING_SYSTEM);
+                             wxFontEncoding encoding = wxFONTENCODING_SYSTEM,
+                             bool silent = FALSE);
 
     void DoChangeFont(const wxFont& font, const wxColour& col = wxNullColour);
 
@@ -268,7 +269,9 @@ void MyFrame::OnEnumerateEncodings(wxCommandEvent& WXUNUSED(event))
                  fontEnumerator.GetText().c_str());
 }
 
-void MyFrame::DoEnumerateFamilies(bool fixedWidthOnly, wxFontEncoding encoding)
+bool MyFrame::DoEnumerateFamilies(bool fixedWidthOnly,
+                                  wxFontEncoding encoding,
+                                  bool silent)
 {
     class MyFontEnumerator : public wxFontEnumerator
     {
@@ -301,6 +304,9 @@ void MyFrame::DoEnumerateFamilies(bool fixedWidthOnly, wxFontEncoding encoding)
         for ( n = 0; n < nFacenames; n++ )
             facenames[n] = fontEnumerator.GetFacenames().Item(n);
 
+        if ( silent )
+            n = 1;
+        else
             n = wxGetSingleChoiceIndex("Choose a facename", "Font demo",
                                        nFacenames, facenames, this);
         if ( n != -1 )
@@ -312,11 +318,15 @@ void MyFrame::DoEnumerateFamilies(bool fixedWidthOnly, wxFontEncoding encoding)
         }
 
         delete [] facenames;
+
+        return TRUE;
     }
-    else
+    else if ( !silent )
     {
         wxLogWarning("No such fonts found.");
     }
+
+    return FALSE;
 }
 
 void MyFrame::OnEnumerateFamiliesForEncoding(wxCommandEvent& WXUNUSED(event))
@@ -457,8 +467,7 @@ void MyFrame::OnViewMsg(wxCommandEvent& WXUNUSED(event))
     }
 
     // ok, now get the corresponding encoding
-    wxFontMapper fontMapper;
+    wxFontEncoding fontenc = wxTheFontMapper->CharsetToEncoding(charset);
-    wxFontEncoding fontenc = fontMapper.CharsetToEncoding(charset);
     if ( fontenc == wxFONTENCODING_SYSTEM )
     {
         wxLogError("Charset '%s' is unsupported.", charset.c_str());
@@ -466,9 +475,23 @@ void MyFrame::OnViewMsg(wxCommandEvent& WXUNUSED(event))
     }
 
     // and now create the correct font
-    m_textctrl->LoadFile(filename);
+    if ( !DoEnumerateFamilies(FALSE, fontenc, TRUE /* silent */) )
+    {
+        wxFont font(14, wxFONTFAMILY_DEFAULT, wxFONTSTYLE_NORMAL,
+                    wxFONTWEIGHT_NORMAL, FALSE /* !underlined */,
+                    wxEmptyString /* facename */, fontenc);
+        if ( font.Ok() )
+        {
+            DoChangeFont(font);
+        }
+        else
+        {
+            wxLogWarning("No fonts for encoding '%s' on this system.",
+                         wxFontMapper::GetEncodingDescription(fontenc).c_str());
+        }
+    }
 
-    DoEnumerateFamilies(FALSE, fontenc);
+    m_textctrl->LoadFile(filename);
 }
 
 void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))

src/common/appcmn.cpp

@@ -34,6 +34,7 @@
 #endif
 
 #include "wx/thread.h"
+#include "wx/confbase.h"
 
 // ===========================================================================
 // implementation
@@ -64,3 +65,13 @@ void wxAppBase::ProcessPendingEvents()
     }
 }
 
+int wxAppBase::OnExit()
+{
+#if wxUSE_CONFIG
+    // delete the config object if any (don't use Get() here, but Set()
+    // because Get() could create a new config object)
+    delete wxConfigBase::Set((wxConfigBase *) NULL);
+#endif // wxUSE_CONFIG
+
+    return 0;
+}

src/common/cmndata.cpp

@@ -149,29 +149,14 @@ wxFontData::wxFontData()
     enableEffects = TRUE;
     minSize = 0;
     maxSize = 0;
-}
 
-wxFontData::wxFontData(const wxFontData& data)
+    m_encoding = wxFONTENCODING_SYSTEM;
-{
-    (*this) = data;
 }
 
 wxFontData::~wxFontData()
 {
 }
 
-void wxFontData::operator=(const wxFontData& data)
-{
-    fontColour = data.fontColour;
-    showHelp = data.showHelp;
-    allowSymbols = data.allowSymbols;
-    enableEffects = data.enableEffects;
-    initialFont = data.initialFont;
-    chosenFont = data.chosenFont;
-    minSize = data.minSize;
-    maxSize = data.maxSize;
-}
-
 #if wxUSE_PRINTING_ARCHITECTURE
 // ----------------------------------------------------------------------------
 // Print data

src/common/fileconf.cpp

@@ -324,7 +324,8 @@ wxFileConfig::wxFileConfig(const wxString& appName, const wxString& vendorName,
 
   // if the path is not absolute, prepend the standard directory to it
   // UNLESS wxCONFIG_USE_RELATIVE_PATH style is set
-  if ( !(style & wxCONFIG_USE_RELATIVE_PATH) ){
+  if ( !(style & wxCONFIG_USE_RELATIVE_PATH) )
+  {
       if ( !m_strLocalFile.IsEmpty() && !wxIsAbsolutePath(m_strLocalFile) )
       {
           wxString strLocal = m_strLocalFile;

src/common/fontcmn.cpp

@@ -42,6 +42,7 @@
 
 wxFontEncoding wxFontBase::ms_encodingDefault = wxFONTENCODING_SYSTEM;
 
+/* static */
 wxFont *wxFontBase::New(int size,
                         int family,
                         int style,

src/common/fontmap.cpp

@@ -36,6 +36,9 @@
 
 #include "wx/fontmap.h"
 #include "wx/config.h"
+
+#include "wx/msgdlg.h"
+#include "wx/fontdlg.h"
 #include "wx/choicdlg.h"
 
 // ----------------------------------------------------------------------------
@@ -46,6 +49,132 @@
 static const char* FONTMAPPER_ROOT_PATH = _T("FontMapper");
 static const char* FONTMAPPER_CHARSET_PATH = _T("Charsets");
 static const char* FONTMAPPER_CHARSET_ALIAS_PATH = _T("Aliases");
+static const char* FONTMAPPER_FONT_FROM_ENCODING_PATH = _T("Encodings");
+
+// encodings supported by GetEncodingDescription
+static wxFontEncoding gs_encodings[] =
+{
+    wxFONTENCODING_ISO8859_1,
+    wxFONTENCODING_ISO8859_2,
+    wxFONTENCODING_ISO8859_3,
+    wxFONTENCODING_ISO8859_4,
+    wxFONTENCODING_ISO8859_5,
+    wxFONTENCODING_ISO8859_6,
+    wxFONTENCODING_ISO8859_7,
+    wxFONTENCODING_ISO8859_8,
+    wxFONTENCODING_ISO8859_9,
+    wxFONTENCODING_ISO8859_10,
+    wxFONTENCODING_ISO8859_11,
+    wxFONTENCODING_ISO8859_12,
+    wxFONTENCODING_ISO8859_13,
+    wxFONTENCODING_ISO8859_14,
+    wxFONTENCODING_ISO8859_15,
+    wxFONTENCODING_KOI8,
+    wxFONTENCODING_CP1250,
+    wxFONTENCODING_CP1251,
+    wxFONTENCODING_CP1252,
+    wxFONTENCODING_CP1253,
+    wxFONTENCODING_CP1254,
+    wxFONTENCODING_CP1255,
+    wxFONTENCODING_CP1256,
+    wxFONTENCODING_CP1257,
+};
+
+// the descriptions for them
+static const wxChar* gs_encodingDescs[] =
+{
+    wxTRANSLATE( "West European (ISO-8859-1/Latin 1)" ),
+    wxTRANSLATE( "Central European (ISO-8859-2/Latin 2)" ),
+    wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
+    wxTRANSLATE( "Baltic (ISO-8859-4)" ),
+    wxTRANSLATE( "Cyrillic (Latin 5)" ),
+    wxTRANSLATE( "Arabic (ISO-8859-6)" ),
+    wxTRANSLATE( "Greek (ISO-8859-7)" ),
+    wxTRANSLATE( "Hebrew (ISO-8859-8)" ),
+    wxTRANSLATE( "Turkish (ISO-8859-9)" ),
+    wxTRANSLATE( "Baltic II (ISO-8859-10)" ),
+    wxTRANSLATE( "Thai (ISO-8859-11)" ),
+    wxTRANSLATE( "ISO-8859-12" ),
+    wxTRANSLATE( "ISO-8859-13" ),
+    wxTRANSLATE( "ISO-8859-14" ),
+    wxTRANSLATE( "West European new (ISO-8859-15/Latin 0)" ),
+    wxTRANSLATE( "KOI8-R" ),
+    wxTRANSLATE( "Windows Latin 2 (CP 1250)" ),
+    wxTRANSLATE( "Windows Cyrillic (CP 1251)" ),
+    wxTRANSLATE( "Windows Latin 1 (CP 1252)" ),
+    wxTRANSLATE( "Windows Greek (CP 1253)" ),
+    wxTRANSLATE( "Windows Turkish (CP 1254)" ),
+    wxTRANSLATE( "Windows Hebrew (CP 1255)" ),
+    wxTRANSLATE( "Windows Arabic (CP 1256)" ),
+    wxTRANSLATE( "Windows Baltic (CP 1257)" ),
+};
+
+// and the internal names
+static const wxChar* gs_encodingNames[] =
+{
+    "iso8859-1",
+    "iso8859-2",
+    "iso8859-3",
+    "iso8859-4",
+    "iso8859-5",
+    "iso8859-6",
+    "iso8859-7",
+    "iso8859-8",
+    "iso8859-9",
+    "iso8859-10",
+    "iso8859-11",
+    "iso8859-12",
+    "iso8859-13",
+    "iso8859-14",
+    "iso8859-15",
+    "koi8-r",
+    "windows1250",
+    "windows1251",
+    "windows1252",
+    "windows1253",
+    "windows1254",
+    "windows1255",
+    "windows1256",
+    "windows1257",
+};
+
+// ----------------------------------------------------------------------------
+// global data
+// ----------------------------------------------------------------------------
+
+// private object
+static wxFontMapper gs_fontMapper;
+
+// and public pointer
+wxFontMapper * WXDLLEXPORT wxTheFontMapper = &gs_fontMapper;
+
+// ----------------------------------------------------------------------------
+// private classes
+// ----------------------------------------------------------------------------
+
+// change the config path during the lifetime of this object
+class wxFontMapperPathChanger
+{
+public:
+    wxFontMapperPathChanger(wxFontMapper *fontMapper, const wxString& path)
+    {
+        m_fontMapper = fontMapper;
+        m_ok = m_fontMapper->ChangePath(path, &m_pathOld);
+    }
+
+    bool IsOk() const { return m_ok; }
+
+    ~wxFontMapperPathChanger()
+    {
+        if ( IsOk() )
+            m_fontMapper->RestorePath(m_pathOld);
+    }
+
+private:
+    wxFontMapper *m_fontMapper;
+    bool          m_ok;
+    wxString      m_pathOld;
+};
 
 // ============================================================================
 // implementation
@@ -143,6 +272,52 @@ void wxFontMapper::RestorePath(const wxString& pathOld)
 // charset/encoding correspondence
 // ----------------------------------------------------------------------------
 
+/* static */
+wxString wxFontMapper::GetEncodingDescription(wxFontEncoding encoding)
+{
+    size_t count = WXSIZEOF(gs_encodingDescs);
+
+    wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
+                  _T("inconsitency detected - forgot to update one of "
+                     "the arrays?") );
+
+    for ( size_t i = 0; i < count; i++ )
+    {
+        if ( gs_encodings[i] == encoding )
+        {
+            return wxGetTranslation(gs_encodingDescs[i]);
+        }
+    }
+
+    wxString str;
+    str.Printf(_("Unknown encoding (%d)"), encoding);
+
+    return str;
+}
+
+/* static */
+wxString wxFontMapper::GetEncodingName(wxFontEncoding encoding)
+{
+    size_t count = WXSIZEOF(gs_encodingNames);
+
+    wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
+                  _T("inconsitency detected - forgot to update one of "
+                     "the arrays?") );
+
+    for ( size_t i = 0; i < count; i++ )
+    {
+        if ( gs_encodings[i] == encoding )
+        {
+            return wxGetTranslation(gs_encodingNames[i]);
+        }
+    }
+
+    wxString str;
+    str.Printf(_("unknown-%d"), encoding);
+
+    return str;
+}
+
 wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
                                                bool interactive)
 {
@@ -255,65 +430,9 @@ wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
                      "cannot be replaced"), charset.c_str());
 
         // the list of choices
-        static wxFontEncoding encodings[] =
+        size_t count = WXSIZEOF(gs_encodingDescs);
-        {
-            wxFONTENCODING_ISO8859_1,
-            wxFONTENCODING_ISO8859_2,
-            wxFONTENCODING_ISO8859_3,
-            wxFONTENCODING_ISO8859_4,
-            wxFONTENCODING_ISO8859_5,
-            wxFONTENCODING_ISO8859_6,
-            wxFONTENCODING_ISO8859_7,
-            wxFONTENCODING_ISO8859_8,
-            wxFONTENCODING_ISO8859_9,
-            wxFONTENCODING_ISO8859_10,
-            wxFONTENCODING_ISO8859_11,
-            wxFONTENCODING_ISO8859_12,
-            wxFONTENCODING_ISO8859_13,
-            wxFONTENCODING_ISO8859_14,
-            wxFONTENCODING_ISO8859_15,
-            wxFONTENCODING_KOI8,
-            wxFONTENCODING_CP1250,
-            wxFONTENCODING_CP1251,
-            wxFONTENCODING_CP1252,
-            wxFONTENCODING_CP1253,
-            wxFONTENCODING_CP1254,
-            wxFONTENCODING_CP1255,
-            wxFONTENCODING_CP1256,
-            wxFONTENCODING_CP1257,
-        };
 
-        static const wxChar* encodingNames[] =
+        wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
-        {
-            "West European (ISO-8859-1/Latin 1)",
-            "Central European (ISO-8859-2/Latin 2)",
-            "Esperanto (ISO-8859-3)",
-            "Baltic (ISO-8859-4)",
-            "Cyrillic (Latin 5)",
-            "Arabic (ISO-8859-6)"
-            "Greek (ISO-8859-7)",
-            "Hebrew (ISO-8859-8)",
-            "Turkish (ISO-8859-9)",
-            "Baltic II (ISO-8859-10)",
-            "Thai (ISO-8859-11)",
-            "ISO-8859-12",
-            "ISO-8859-13",
-            "ISO-8859-14",
-            "West European new (ISO-8859-15/Latin 0)",
-            "KOI8-R",
-            "Windows Latin 2 (CP 1250)",
-            "Windows Cyrillic (CP 1251)",
-            "Windows Latin 1 (CP 1252)",
-            "Windows Greek (CP 1253)",
-            "Windows Turkish (CP 1254)",
-            "Windows Hebrew (CP 1255)",
-            "Windows Arabic (CP 1256)",
-            "Windows Baltic (CP 1257)",
-        };
-
-        size_t count = WXSIZEOF(encodingNames);
-
-        wxASSERT_MSG( count == WXSIZEOF(encodings),
                       _T("inconsitency detected - forgot to update one of "
                          "the arrays?") );
 
@@ -321,7 +440,7 @@ wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
 
         for ( size_t n = 0; n < count; n++ )
         {
-            encodingNamesTranslated[n] = wxGetTranslation(encodingNames[n]);
+            encodingNamesTranslated[n] = wxGetTranslation(gs_encodingDescs[n]);
         }
 
         // the parent window
@@ -339,7 +458,9 @@ wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
 
         if ( n != -1 )
         {
-            encoding = encodings[n];
+            // TODO save the result in the config!
+
+            encoding = gs_encodings[n];
         }
         //else: cancelled
     }
@@ -347,3 +468,186 @@ wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
     return encoding;
 }
 
+// ----------------------------------------------------------------------------
+// support for unknown encodings: we maintain a map between the
+// (platform-specific) strings identifying them and our wxFontEncodings they
+// correspond to which is used by GetFontForEncoding() function
+// ----------------------------------------------------------------------------
+
+bool wxFontMapper::TestAltEncoding(const wxString& configEntry,
+                                   wxFontEncoding encReplacement,
+                                   wxNativeEncodingInfo *info)
+{
+    if ( wxGetNativeFontEncoding(encReplacement, info) &&
+         wxTestFontEncoding(*info) )
+    {
+        // remember the mapping in the config
+        wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);
+
+        if ( path.IsOk() )
+        {
+            GetConfig()->Write(configEntry, info->ToString());
+        }
+
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
+                                     wxNativeEncodingInfo *info,
+                                     bool interactive)
+{
+    wxCHECK_MSG( info, FALSE, _T("bad pointer in GetAltForEncoding") );
+
+    wxString configEntry = GetEncodingName(encoding);
+
+    // do we have a font spec for this encoding?
+    wxString pathOld;
+    if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
+    {
+        wxConfigBase *config = GetConfig();
+
+        wxString fontinfo = config->Read(configEntry);
+
+        RestorePath(pathOld);
+
+        if ( !!fontinfo )
+        {
+            if ( info->FromString(fontinfo) )
+            {
+                if ( wxTestFontEncoding(*info) )
+                {
+                    // ok, got something
+                    return TRUE;
+                }
+                //else: no such fonts, look for something else
+            }
+            else
+            {
+                wxLogDebug(_T("corrupted config data: string '%s' is not "
+                              "a valid font encoding info"), fontinfo.c_str());
+            }
+        }
+    }
+
+    // ask the user
+    if ( interactive )
+    {
+        wxString title(m_titleDialog);
+        if ( !title )
+            title << wxTheApp->GetAppName() << _(": unknown encoding");
+
+        // the message
+        wxString msg;
+        msg.Printf(_("The encoding '%s' is unknown.\n"
+                     "Would you like to select a font to be used for this "
+                     "encoding\n"
+                     "(otherwise the text in this encoding will not be "
+                     "shown correctly)?"),
+                     GetEncodingDescription(encoding).c_str());
+
+        wxWindow *parent = m_windowParent;
+        if ( !parent )
+            parent = wxTheApp->GetTopWindow();
+
+        if ( wxMessageBox(msg, title,
+                          wxICON_QUESTION | wxYES_NO, parent) == wxYES )
+        {
+            wxFontData data;
+            data.SetEncoding(encoding);
+            data.EncodingInfo() = *info;
+            wxFontDialog dialog(parent, &data);
+            if ( dialog.ShowModal() == wxID_OK )
+            {
+                wxFontData retData = dialog.GetFontData();
+                wxFont font = retData.GetChosenFont();
+
+                info->xregistry = retData.EncodingInfo().xregistry;
+                info->xencoding = retData.EncodingInfo().xencoding;
+
+                // remember this in the config
+                if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
+                {
+                    GetConfig()->Write(configEntry, info->ToString());
+
+                    RestorePath(pathOld);
+                }
+
+                return TRUE;
+            }
+            //else: the user canceled the font selection dialog
+        }
+        //else: the user doesn't want to select a font
+    }
+    //else: we're in non-interactive mode
+
+    // now try the default mappings
+    switch ( encoding )
+    {
+        case wxFONTENCODING_ISO8859_15:
+            // iso8859-15 is slightly modified iso8859-1
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_ISO8859_1, info) )
+                return TRUE;
+            // fall through
+
+        case wxFONTENCODING_ISO8859_1:
+            // iso8859-1 is identical to CP1252
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_CP1252, info) )
+                return TRUE;
+
+            break;
+
+        case wxFONTENCODING_CP1252:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_ISO8859_1, info) )
+                return TRUE;
+
+            break;
+
+        // iso8859-13 is quite similar to WinBaltic
+        case wxFONTENCODING_ISO8859_13:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_CP1257, info) )
+                return TRUE;
+
+            break;
+
+        case wxFONTENCODING_CP1257:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_ISO8859_13, info) )
+                return TRUE;
+
+            break;
+
+        // iso8859-8 is almost identical to WinHebrew
+        case wxFONTENCODING_ISO8859_8:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_CP1255, info) )
+                return TRUE;
+
+            break;
+
+        case wxFONTENCODING_CP1255:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_ISO8859_8, info) )
+                return TRUE;
+
+            break;
+
+        // and iso8859-7 is not too different from WinGreek
+        case wxFONTENCODING_ISO8859_7:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_CP1253, info) )
+                return TRUE;
+
+            break;
+
+        case wxFONTENCODING_CP1253:
+            if ( TestAltEncoding(configEntry, wxFONTENCODING_ISO8859_7, info) )
+                return TRUE;
+
+            break;
+
+        default:
+           // TODO add other mappings...
+           ;
+    }
+
+    return FALSE;
+}

src/gtk/dcclient.cpp

@@ -813,12 +813,16 @@ void wxWindowDC::DoGetTextExtent(const wxString &string,
 wxCoord wxWindowDC::GetCharWidth() const
 {
     GdkFont *font = m_font.GetInternalFont( m_scaleY );
+    wxCHECK_MSG( font, -1, _T("invalid font") );
+
     return wxCoord(gdk_string_width( font, "H" ) / m_scaleX);
 }
 
 wxCoord wxWindowDC::GetCharHeight() const
 {
     GdkFont *font = m_font.GetInternalFont( m_scaleY );
+    wxCHECK_MSG( font, -1, _T("invalid font") );
+
     return wxCoord((font->ascent + font->descent) / m_scaleY);
 }
 

src/gtk/dialog.cpp

@@ -456,6 +456,7 @@ void wxDialog::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     int old_x = m_x;
     int old_y = m_y;
+
     int old_width = m_width;
     int old_height = m_height;
 

src/gtk/font.cpp

@@ -20,6 +20,8 @@
 #endif
 
 #include "wx/font.h"
+#include "wx/fontutil.h"
+#include "wx/cmndata.h"
 #include "wx/utils.h"
 #include "wx/log.h"
 #include "wx/gdicmn.h"
@@ -150,18 +152,16 @@ void wxFont::Init()
         wxTheFontList->Append( this );
 }
 
-wxFont::wxFont( GdkFont *WXUNUSED(font), char *xFontName )
+wxFont::wxFont( const wxString& fontname, const wxFontData& fontdata )
 {
-    if (!xFontName)
-        return;
-
     Init();
 
+    wxCHECK_RET( !!fontname, _T("invalid font spec") );
+
     m_refData = new wxFontRefData();
 
     wxString tmp;
 
-    wxString fontname( xFontName );
     wxStringTokenizer tn( fontname, wxT("-") );
 
     tn.GetNextToken();                           // foundry
@@ -211,6 +211,9 @@ wxFont::wxFont( GdkFont *WXUNUSED(font), char *xFontName )
     tn.GetNextToken();                           // avg width
 
     // deal with font encoding
+    M_FONTDATA->m_encoding = fontdata.GetEncoding();
+    if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
+    {
         wxString registry = tn.GetNextToken().MakeUpper(),
                  encoding = tn.GetNextToken().MakeUpper();
 
@@ -237,6 +240,7 @@ wxFont::wxFont( GdkFont *WXUNUSED(font), char *xFontName )
             M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
         }
         //else: unknown encoding - may be give a warning here?
+    }
 }
 
 bool wxFont::Create( int pointSize,
@@ -429,10 +433,9 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
         M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
     }
 
-    if (!font)
+    // it's quite useless to make it a wxCHECK because we're going to crash
-    {
+    // anyhow...
-        wxLogError(wxT("could not load any font"));
+    wxASSERT_MSG( font, wxT("could not load any font?") );
-    }
 
     return font;
 }

src/gtk/fontdlg.cpp

@@ -69,15 +69,53 @@ void gtk_fontdialog_ok_callback( GtkWidget *WXUNUSED(widget), wxFontDialog *dial
     }
 
     gchar *fontname = gtk_font_selection_dialog_get_font_name(fontdlg);
-    wxFont font( gfont, fontname );
+
+    // extract the relevant bits from it
+    wxString xregistry, xencoding;
+    char *dash = strrchr(fontname, '-');    // find the last dash
+    if ( dash )
+    {
+        xencoding = dash + 1;
+        *dash = '\0';
+        dash = strrchr(fontname, '-');      // the last before one
+        if ( dash )
+        {
+            xregistry = dash + 1;
+        }
+        else
+        {
+            wxFAIL_MSG(_T("no registry in X font spec?"));
+        }
+
+        // restore the dash we changed to NUL above
+        *(fontname + strlen(fontname)) = '-';
+    }
+    else
+    {
+        wxFAIL_MSG(_T("no encoding in X font spec?"));
+    }
+
+    // transfer the X registry/encoding to wxFontData - they are used by
+    // wxFontMapper after wxFontDialog returns
+    wxFontData& fontdata = dialog->m_fontData;
+
+    // we ignore the facename here - should be enough to choose an arbitrary
+    // one if the registry/encoding are specified
+    //  dialog->m_fontData.EncodingInfo().facename = xfamily;
+    fontdata.EncodingInfo().xregistry = xregistry;
+    fontdata.EncodingInfo().xencoding = xencoding;
+
+    // pass fontdata to wxFont ctor so that it can get the encoding from there
+    // if it is already known (otherwise it will try to deduce it itself)
+    dialog->m_fontData.SetChosenFont( wxFont(fontname, fontdata) );
+
     g_free( fontname );
-    dialog->m_fontData.SetChosenFont( font );
 
     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
     event.SetEventObject( dialog );
     dialog->GetEventHandler()->ProcessEvent( event );
 }
-#endif // GTK+ 1.2 andlater only
+#endif // GTK+ 1.2 and later only
 
 //-----------------------------------------------------------------------------
 // "clicked" for Cancel-button
@@ -100,7 +138,8 @@ void gtk_fontdialog_cancel_callback( GtkWidget *WXUNUSED(w), wxFontDialog *dialo
 
 IMPLEMENT_DYNAMIC_CLASS(wxFontDialog,wxDialog)
 
-wxFontDialog::wxFontDialog( wxWindow *parent, wxFontData *WXUNUSED(data) )
+wxFontDialog::wxFontDialog( wxWindow *parent, wxFontData *fontdata )
+            : m_fontData(*fontdata)
 {
     m_needParent = FALSE;
 

src/gtk/frame.cpp

@@ -530,6 +530,7 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     int old_x = m_x;
     int old_y = m_y;
+
     int old_width = m_width;
     int old_height = m_height;
 

src/gtk1/dcclient.cpp

@@ -813,12 +813,16 @@ void wxWindowDC::DoGetTextExtent(const wxString &string,
 wxCoord wxWindowDC::GetCharWidth() const
 {
     GdkFont *font = m_font.GetInternalFont( m_scaleY );
+    wxCHECK_MSG( font, -1, _T("invalid font") );
+
     return wxCoord(gdk_string_width( font, "H" ) / m_scaleX);
 }
 
 wxCoord wxWindowDC::GetCharHeight() const
 {
     GdkFont *font = m_font.GetInternalFont( m_scaleY );
+    wxCHECK_MSG( font, -1, _T("invalid font") );
+
     return wxCoord((font->ascent + font->descent) / m_scaleY);
 }
 

src/gtk1/dialog.cpp

@@ -456,6 +456,7 @@ void wxDialog::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     int old_x = m_x;
     int old_y = m_y;
+
     int old_width = m_width;
     int old_height = m_height;
 

src/gtk1/font.cpp

@@ -20,6 +20,8 @@
 #endif
 
 #include "wx/font.h"
+#include "wx/fontutil.h"
+#include "wx/cmndata.h"
 #include "wx/utils.h"
 #include "wx/log.h"
 #include "wx/gdicmn.h"
@@ -150,18 +152,16 @@ void wxFont::Init()
         wxTheFontList->Append( this );
 }
 
-wxFont::wxFont( GdkFont *WXUNUSED(font), char *xFontName )
+wxFont::wxFont( const wxString& fontname, const wxFontData& fontdata )
 {
-    if (!xFontName)
-        return;
-
     Init();
 
+    wxCHECK_RET( !!fontname, _T("invalid font spec") );
+
     m_refData = new wxFontRefData();
 
     wxString tmp;
 
-    wxString fontname( xFontName );
     wxStringTokenizer tn( fontname, wxT("-") );
 
     tn.GetNextToken();                           // foundry
@@ -211,6 +211,9 @@ wxFont::wxFont( GdkFont *WXUNUSED(font), char *xFontName )
     tn.GetNextToken();                           // avg width
 
     // deal with font encoding
+    M_FONTDATA->m_encoding = fontdata.GetEncoding();
+    if ( M_FONTDATA->m_encoding == wxFONTENCODING_SYSTEM )
+    {
         wxString registry = tn.GetNextToken().MakeUpper(),
                  encoding = tn.GetNextToken().MakeUpper();
 
@@ -237,6 +240,7 @@ wxFont::wxFont( GdkFont *WXUNUSED(font), char *xFontName )
             M_FONTDATA->m_encoding = wxFONTENCODING_KOI8;
         }
         //else: unknown encoding - may be give a warning here?
+    }
 }
 
 bool wxFont::Create( int pointSize,
@@ -429,10 +433,9 @@ GdkFont *wxFont::GetInternalFont( float scale ) const
         M_FONTDATA->m_scaled_xfonts.Append( int_scale, (wxObject*)font );
     }
 
-    if (!font)
+    // it's quite useless to make it a wxCHECK because we're going to crash
-    {
+    // anyhow...
-        wxLogError(wxT("could not load any font"));
+    wxASSERT_MSG( font, wxT("could not load any font?") );
-    }
 
     return font;
 }

src/gtk1/fontdlg.cpp

@@ -69,15 +69,53 @@ void gtk_fontdialog_ok_callback( GtkWidget *WXUNUSED(widget), wxFontDialog *dial
     }
 
     gchar *fontname = gtk_font_selection_dialog_get_font_name(fontdlg);
-    wxFont font( gfont, fontname );
+
+    // extract the relevant bits from it
+    wxString xregistry, xencoding;
+    char *dash = strrchr(fontname, '-');    // find the last dash
+    if ( dash )
+    {
+        xencoding = dash + 1;
+        *dash = '\0';
+        dash = strrchr(fontname, '-');      // the last before one
+        if ( dash )
+        {
+            xregistry = dash + 1;
+        }
+        else
+        {
+            wxFAIL_MSG(_T("no registry in X font spec?"));
+        }
+
+        // restore the dash we changed to NUL above
+        *(fontname + strlen(fontname)) = '-';
+    }
+    else
+    {
+        wxFAIL_MSG(_T("no encoding in X font spec?"));
+    }
+
+    // transfer the X registry/encoding to wxFontData - they are used by
+    // wxFontMapper after wxFontDialog returns
+    wxFontData& fontdata = dialog->m_fontData;
+
+    // we ignore the facename here - should be enough to choose an arbitrary
+    // one if the registry/encoding are specified
+    //  dialog->m_fontData.EncodingInfo().facename = xfamily;
+    fontdata.EncodingInfo().xregistry = xregistry;
+    fontdata.EncodingInfo().xencoding = xencoding;
+
+    // pass fontdata to wxFont ctor so that it can get the encoding from there
+    // if it is already known (otherwise it will try to deduce it itself)
+    dialog->m_fontData.SetChosenFont( wxFont(fontname, fontdata) );
+
     g_free( fontname );
-    dialog->m_fontData.SetChosenFont( font );
 
     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, wxID_OK);
     event.SetEventObject( dialog );
     dialog->GetEventHandler()->ProcessEvent( event );
 }
-#endif // GTK+ 1.2 andlater only
+#endif // GTK+ 1.2 and later only
 
 //-----------------------------------------------------------------------------
 // "clicked" for Cancel-button
@@ -100,7 +138,8 @@ void gtk_fontdialog_cancel_callback( GtkWidget *WXUNUSED(w), wxFontDialog *dialo
 
 IMPLEMENT_DYNAMIC_CLASS(wxFontDialog,wxDialog)
 
-wxFontDialog::wxFontDialog( wxWindow *parent, wxFontData *WXUNUSED(data) )
+wxFontDialog::wxFontDialog( wxWindow *parent, wxFontData *fontdata )
+            : m_fontData(*fontdata)
 {
     m_needParent = FALSE;
 

src/gtk1/frame.cpp

@@ -530,6 +530,7 @@ void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 
     int old_x = m_x;
     int old_y = m_y;
+
     int old_width = m_width;
     int old_height = m_height;
 

src/unix/fontenum.cpp

@@ -27,6 +27,7 @@
 #include "wx/utils.h"
 
 #include "wx/fontenum.h"
+#include "wx/fontutil.h"
 
 #include <X11/Xlib.h>
 
@@ -61,12 +62,14 @@ static char **CreateFontList(wxChar spacing,
                              wxFontEncoding encoding,
                              int *nFonts)
 {
-    wxString xencoding, xregistry;
+    wxNativeEncodingInfo info;
-    wxGetXFontEncoding(encoding, &xregistry, &xencoding);
+    wxGetNativeFontEncoding(encoding, &info);
 
     wxString pattern;
     pattern.Printf(wxT("-*-*-*-*-*-*-*-*-*-*-%c-*-%s-%s"),
-                   spacing, xregistry.c_str(), xencoding.c_str());
+                   spacing,
+                   info.xregistry.c_str(),
+                   info.xencoding.c_str());
 
     // get the list of all fonts
     return XListFonts((Display *)wxGetDisplay(), pattern.mb_str(), 32767, nFonts);

src/unix/fontutil.cpp

@@ -0,0 +1,454 @@
+/////////////////////////////////////////////////////////////////////////////
+// Name:        unix/fontutil.cpp
+// Purpose:     Font helper functions for X11 (GDK/X)
+// Author:      Vadim Zeitlin
+// Modified by:
+// Created:     05.11.99
+// RCS-ID:      $Id$
+// Copyright:   (c) Vadim Zeitlin
+// Licence:     wxWindows license
+/////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+    #pragma implementation "fontutil.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+#ifndef WX_PRECOMP
+#endif // PCH
+
+#include "wx/fontutil.h"
+#include "wx/fontmap.h"
+#include "wx/tokenzr.h"
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+// define the functions to create and destroy native fonts for this toolkit
+#ifdef __X__
+    static inline wxNativeFont wxLoadFont(const wxString& fontSpec)
+    {
+        return XLoadQueryFont((Display *)wxGetDisplay(), fontSpec);
+    }
+
+    static inline void wxFreeFont(wxNativeFont font)
+    {
+        XFreeFont((Display *)wxGetDisplay(), font);
+    }
+#elif defined(__WXGTK__)
+    #include "gdk/gdk.h"
+
+    static inline wxNativeFont wxLoadFont(const wxString& fontSpec)
+    {
+        return gdk_font_load( wxConvertWX2MB(fontSpec) );
+    }
+
+    static inline void wxFreeFont(wxNativeFont font)
+    {
+        gdk_font_unref(font);
+    }
+#else
+    #error "Unknown GUI toolkit"
+#endif
+
+static bool wxTestFontSpec(const wxString& fontspec);
+
+static wxNativeFont wxLoadQueryFont(int pointSize,
+                                    int family,
+                                    int style,
+                                    int weight,
+                                    bool underlined,
+                                    const wxString& facename,
+                                    const wxString& xregistry,
+                                    const wxString& xencoding);
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxNativeEncodingInfo
+// ----------------------------------------------------------------------------
+
+// convert to/from the string representation: format is
+//      registry-encoding[-facename]
+bool wxNativeEncodingInfo::FromString(const wxString& s)
+{
+    wxStringTokenizer tokenizer(s, _T("-"));
+
+    xregistry = tokenizer.GetNextToken();
+    if ( !xregistry )
+        return FALSE;
+
+    xencoding = tokenizer.GetNextToken();
+    if ( !xencoding )
+        return FALSE;
+
+    // ok even if empty
+    facename = tokenizer.GetNextToken();
+
+    return TRUE;
+}
+
+wxString wxNativeEncodingInfo::ToString() const
+{
+    wxString s;
+    s << xregistry << _T('-') << xencoding;
+    if ( !!facename )
+    {
+        s << _T('-') << facename;
+    }
+
+    return s;
+}
+
+// ----------------------------------------------------------------------------
+// common functions
+// ----------------------------------------------------------------------------
+
+bool wxGetNativeFontEncoding(wxFontEncoding encoding,
+                             wxNativeEncodingInfo *info)
+{
+    wxCHECK_MSG( info, FALSE, _T("bad pointer in wxGetNativeFontEncoding") );
+
+    if ( encoding == wxFONTENCODING_DEFAULT )
+    {
+        encoding = wxFont::GetDefaultEncoding();
+    }
+
+    switch ( encoding )
+    {
+        case wxFONTENCODING_ISO8859_1:
+        case wxFONTENCODING_ISO8859_2:
+        case wxFONTENCODING_ISO8859_3:
+        case wxFONTENCODING_ISO8859_4:
+        case wxFONTENCODING_ISO8859_5:
+        case wxFONTENCODING_ISO8859_6:
+        case wxFONTENCODING_ISO8859_7:
+        case wxFONTENCODING_ISO8859_8:
+        case wxFONTENCODING_ISO8859_9:
+        case wxFONTENCODING_ISO8859_10:
+        case wxFONTENCODING_ISO8859_11:
+        case wxFONTENCODING_ISO8859_13:
+        case wxFONTENCODING_ISO8859_14:
+        case wxFONTENCODING_ISO8859_15:
+            {
+                int cp = encoding - wxFONTENCODING_ISO8859_1 + 1;
+                info->xregistry = wxT("iso8859");
+                info->xencoding.Printf(wxT("%d"), cp);
+            }
+            break;
+
+        case wxFONTENCODING_KOI8:
+            info->xregistry = wxT("koi8");
+
+            // we don't make distinction between koi8-r and koi8-u (so far)
+            info->xencoding = wxT("*");
+            break;
+
+        case wxFONTENCODING_CP1250:
+        case wxFONTENCODING_CP1251:
+        case wxFONTENCODING_CP1252:
+        case wxFONTENCODING_CP1253:
+        case wxFONTENCODING_CP1254:
+        case wxFONTENCODING_CP1255:
+        case wxFONTENCODING_CP1256:
+        case wxFONTENCODING_CP1257:
+            {
+                int cp = encoding - wxFONTENCODING_CP1250 + 1250;
+                info->xregistry = wxT("microsoft");
+                info->xencoding.Printf(wxT("cp%d"), cp);
+            }
+            break;
+
+        case wxFONTENCODING_SYSTEM:
+            info->xregistry =
+            info->xencoding = wxT('*');
+            break;
+
+        default:
+            // don't know how to translate this encoding into X fontspec
+            return FALSE;
+    }
+
+    return TRUE;
+}
+
+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());
+
+    return wxTestFontSpec(fontspec);
+}
+
+// ----------------------------------------------------------------------------
+// X-specific functions
+// ----------------------------------------------------------------------------
+
+wxNativeFont wxLoadQueryNearestFont(int pointSize,
+                                    int family,
+                                    int style,
+                                    int weight,
+                                    bool underlined,
+                                    const wxString &facename,
+                                    wxFontEncoding encoding)
+{
+    // first determine the encoding - if the font doesn't exist at all in this
+    // encoding, it's useless to do all other approximations (i.e. size,
+    // family &c don't matter much)
+    wxNativeEncodingInfo info;
+    if ( !wxGetNativeFontEncoding(encoding, &info) ||
+         !wxTestFontEncoding(info) )
+    {
+        if ( !wxTheFontMapper->GetAltForEncoding(encoding, &info) )
+        {
+            // unspported encoding - replace it with the default
+            //
+            // NB: we can't just return 0 from here because wxGTK code doesn't
+            //     check for it (i.e. it supposes that we'll always succeed),
+            //     so it would provoke a crash
+            wxGetNativeFontEncoding(wxFONTENCODING_SYSTEM, &info);
+        }
+    }
+    //else: we have the correct xregistry/xencoding in info structure
+
+    wxNativeFont font = wxLoadQueryFont( pointSize, family, style, weight,
+                                         underlined, facename,
+                                         info.xregistry, info.xencoding );
+
+    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;
+
+        // Search for smaller size (approx.)
+        for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
+        {
+            font = wxLoadQueryFont(i, family, style, weight, underlined,
+                                   facename, info.xregistry, info.xencoding);
+        }
+
+        // Search for larger size (approx.)
+        for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
+        {
+            font = wxLoadQueryFont(i, family, style, weight, underlined,
+                                   facename, info.xregistry, info.xencoding);
+        }
+
+        // Try default family
+        if ( !font && family != wxDEFAULT )
+        {
+            font = wxLoadQueryFont(pointSize, wxDEFAULT, style, weight,
+                                   underlined, facename,
+                                   info.xregistry, info.xencoding );
+        }
+
+        // Bogus font I
+        if ( !font )
+        {
+            font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
+                                   underlined, facename,
+                                   info.xregistry, info.xencoding);
+        }
+
+        // Bogus font II
+        if ( !font )
+        {
+            font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
+                                   underlined, wxEmptyString,
+                                   info.xregistry, info.xencoding);
+        }
+    }
+
+    return font;
+}
+
+// ----------------------------------------------------------------------------
+// private functions
+// ----------------------------------------------------------------------------
+
+// returns TRUE if there are any fonts matching this font spec
+static bool wxTestFontSpec(const wxString& fontspec)
+{
+    wxNativeFont test = wxLoadFont(fontspec);
+    if ( test )
+    {
+        wxFreeFont(test);
+
+        return TRUE;
+    }
+    else
+    {
+        return FALSE;
+    }
+}
+
+static wxNativeFont wxLoadQueryFont(int pointSize,
+                                    int family,
+                                    int style,
+                                    int weight,
+                                    bool WXUNUSED(underlined),
+                                    const wxString& facename,
+                                    const wxString& xregistry,
+                                    const wxString& xencoding)
+{
+    wxString xfamily;
+    switch (family)
+    {
+        case wxDECORATIVE: xfamily = wxT("lucida"); break;
+        case wxROMAN:      xfamily = wxT("times");  break;
+        case wxMODERN:     xfamily = wxT("courier"); break;
+        case wxSWISS:      xfamily = wxT("helvetica"); break;
+        case wxTELETYPE:   xfamily = wxT("lucidatypewriter"); break;
+        case wxSCRIPT:     xfamily = wxT("utopia"); break;
+        default:           xfamily = wxT("*");
+    }
+
+    wxString fontSpec;
+    if (!facename.IsEmpty())
+    {
+        fontSpec.Printf(wxT("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"),
+                        facename.c_str());
+
+        if ( wxTestFontSpec(fontSpec) )
+        {
+            xfamily = facename;
+        }
+        //else: no such family, use default one instead
+    }
+
+    wxString xstyle;
+    switch (style)
+    {
+        case wxITALIC:     xstyle = wxT("i"); break;
+        case wxSLANT:      xstyle = wxT("o"); break;
+        case wxNORMAL:     xstyle = wxT("r"); break;
+        default:           xstyle = wxT("*"); break;
+    }
+
+    wxString xweight;
+    switch (weight)
+    {
+         case wxBOLD:
+             {
+                  fontSpec.Printf(wxT("-*-%s-bold-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                       xweight = wxT("bold");
+                       break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-heavy-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                       xweight = wxT("heavy");
+                       break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-extrabold-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                      xweight = wxT("extrabold");
+                      break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-demibold-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                      xweight = wxT("demibold");
+                      break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-black-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                      xweight = wxT("black");
+                      break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-ultrablack-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                      xweight = wxT("ultrablack");
+                      break;
+                  }
+              }
+              break;
+        case wxLIGHT:
+             {
+                  fontSpec.Printf(wxT("-*-%s-light-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                       xweight = wxT("light");
+                       break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-thin-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                       xweight = wxT("thin");
+                       break;
+                  }
+             }
+             break;
+         case wxNORMAL:
+             {
+                  fontSpec.Printf(wxT("-*-%s-medium-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                       xweight = wxT("medium");
+                       break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-normal-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                       xweight = wxT("normal");
+                       break;
+                  }
+                  fontSpec.Printf(wxT("-*-%s-regular-*-*-*-*-*-*-*-*-*-*-*"),
+                         xfamily.c_str());
+                  if ( wxTestFontSpec(fontSpec) )
+                  {
+                      xweight = wxT("regular");
+                      break;
+                  }
+                  xweight = wxT("*");
+              }
+              break;
+        default:           xweight = wxT("*"); break;
+    }
+
+    // construct the X font spec from our data
+    fontSpec.Printf(wxT("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"),
+                    xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
+                    pointSize, xregistry.c_str(), xencoding.c_str());
+
+    return wxLoadFont(fontSpec);
+}
+

src/unix/utilsunx.cpp

@@ -560,8 +560,6 @@ bool wxGetUserName(wxChar *buf, int sz)
     return FALSE;
 }
 
-#if wxUSE_GUI
-
 // ----------------------------------------------------------------------------
 // error and debug output routines (deprecated, use wxLog)
 // ----------------------------------------------------------------------------
@@ -592,358 +590,3 @@ void wxFatalError( const wxString &msg, const wxString &title )
   exit(3); // the same exit code as for abort()
 }
 
-// ----------------------------------------------------------------------------
-// font-related functions
-// ----------------------------------------------------------------------------
-
-// define the functions to create and destroy native fonts for this toolkit
-#ifdef __X__
-    static inline wxNativeFont wxLoadFont(const wxString& fontSpec)
-    {
-        return XLoadQueryFont((Display *)wxGetDisplay(), fontSpec);
-    }
-
-    static inline void wxFreeFont(wxNativeFont font)
-    {
-        XFreeFont((Display *)wxGetDisplay(), font);
-    }
-#elif defined(__WXGTK__)
-
-    #include "gdk/gdk.h"
-
-    static inline wxNativeFont wxLoadFont(const wxString& fontSpec)
-    {
-        return gdk_font_load( wxConvertWX2MB(fontSpec) );
-    }
-
-    static inline void wxFreeFont(wxNativeFont font)
-    {
-        gdk_font_unref(font);
-    }
-#else
-    #error "Unknown GUI toolkit"
-#endif
-
-// returns TRUE if there are any fonts matching this font spec
-static bool wxTestFontSpec(const wxString& fontspec)
-{
-    wxNativeFont test = wxLoadFont(fontspec);
-    if ( test )
-    {
-        wxFreeFont(test);
-
-        return TRUE;
-    }
-    else
-    {
-        return FALSE;
-    }
-}
-
-// TODO encoding test logic should be moved to wxLoadQueryNearestFont()
-static wxNativeFont wxLoadQueryFont(int pointSize,
-                                    int family,
-                                    int style,
-                                    int weight,
-                                    bool WXUNUSED(underlined),
-                                    const wxString &facename,
-                                    wxFontEncoding encoding )
-{
-    wxString xfamily;
-    switch (family)
-    {
-        case wxDECORATIVE: xfamily = wxT("lucida"); break;
-        case wxROMAN:      xfamily = wxT("times");  break;
-        case wxMODERN:     xfamily = wxT("courier"); break;
-        case wxSWISS:      xfamily = wxT("helvetica"); break;
-        case wxTELETYPE:   xfamily = wxT("lucidatypewriter"); break;
-        case wxSCRIPT:     xfamily = wxT("utopia"); break;
-        default:           xfamily = wxT("*");
-    }
-
-    wxString fontSpec;
-    if (!facename.IsEmpty())
-    {
-        fontSpec.Printf(wxT("-*-%s-*-*-normal-*-*-*-*-*-*-*-*-*"),
-                        facename.c_str());
-
-        if ( wxTestFontSpec(fontSpec) )
-        {
-            xfamily = facename;
-        }
-        //else: no such family, use default one instead
-    }
-
-    wxString xstyle;
-    switch (style)
-    {
-        case wxITALIC:     xstyle = wxT("i"); break;
-        case wxSLANT:      xstyle = wxT("o"); break;
-        case wxNORMAL:     xstyle = wxT("r"); break;
-        default:           xstyle = wxT("*"); break;
-    }
-
-    wxString xweight;
-    switch (weight)
-    {
-         case wxBOLD:       
-             {
-                  fontSpec.Printf(wxT("-*-%s-bold-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                       xweight = wxT("bold"); 
-                       break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-heavy-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                       xweight = wxT("heavy"); 
-                       break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-extrabold-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                      xweight = wxT("extrabold");
-                      break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-demibold-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                      xweight = wxT("demibold");
-                      break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-black-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                      xweight = wxT("black");
-                      break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-ultrablack-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                      xweight = wxT("ultrablack");
-                      break;
-                  }
-              }   
-              break;
-        case wxLIGHT:
-             {
-                  fontSpec.Printf(wxT("-*-%s-light-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                       xweight = wxT("light");
-                       break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-thin-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                       xweight = wxT("thin"); 
-                       break;
-                  }
-             }
-             break;
-         case wxNORMAL:     
-             {
-                  fontSpec.Printf(wxT("-*-%s-medium-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                       xweight = wxT("medium"); 
-                       break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-normal-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                       xweight = wxT("normal"); 
-                       break;
-                  }
-                  fontSpec.Printf(wxT("-*-%s-regular-*-*-*-*-*-*-*-*-*-*-*"),
-                         xfamily.c_str());
-                  if ( wxTestFontSpec(fontSpec) )
-                  {
-                      xweight = wxT("regular");
-                      break;
-                  }
-                  xweight = wxT("*");
-              }   
-              break;
-        default:           xweight = wxT("*"); break;
-    }
-
-    wxString xregistry, xencoding;
-    if ( !wxGetXFontEncoding(encoding, &xregistry, &xencoding) )
-    {
-        fontSpec.Printf(wxT("-*-*-*-*-*-*-*-*-*-*-*-*-%s-%s"),
-                        xregistry.c_str(), xencoding.c_str());
-        if ( !wxTestFontSpec(fontSpec) )
-        {
-            // this encoding isn't available - what to do?
-            xregistry =
-            xencoding = wxT("*");
-        }
-    }
-
-    // construct the X font spec from our data
-    fontSpec.Printf(wxT("-*-%s-%s-%s-normal-*-*-%d-*-*-*-*-%s-%s"),
-                    xfamily.c_str(), xweight.c_str(), xstyle.c_str(),
-                    pointSize, xregistry.c_str(), xencoding.c_str());
-
-    return wxLoadFont(fontSpec);
-}
-
-bool wxGetXFontEncoding(wxFontEncoding encoding,
-                        wxString *pregistry, wxString *pencoding)
-{
-    wxCHECK_MSG( pencoding && pregistry, FALSE, wxT("bad pointer") );
-
-    wxString& xencoding = *pencoding;
-    wxString& xregistry = *pregistry;
-
-    if ( encoding == wxFONTENCODING_DEFAULT )
-    {
-        // use the apps default
-        encoding = wxFont::GetDefaultEncoding();
-    }
-
-    bool test = TRUE;   // should we test for availability of encoding?
-    switch ( encoding )
-    {
-        case wxFONTENCODING_ISO8859_1:
-        case wxFONTENCODING_ISO8859_2:
-        case wxFONTENCODING_ISO8859_3:
-        case wxFONTENCODING_ISO8859_4:
-        case wxFONTENCODING_ISO8859_5:
-        case wxFONTENCODING_ISO8859_6:
-        case wxFONTENCODING_ISO8859_7:
-        case wxFONTENCODING_ISO8859_8:
-        case wxFONTENCODING_ISO8859_9:
-        case wxFONTENCODING_ISO8859_10:
-        case wxFONTENCODING_ISO8859_11:
-        case wxFONTENCODING_ISO8859_13:
-        case wxFONTENCODING_ISO8859_14:
-        case wxFONTENCODING_ISO8859_15:
-            {
-                int cp = encoding - wxFONTENCODING_ISO8859_1 + 1;
-                xregistry = wxT("iso8859");
-                xencoding.Printf(wxT("%d"), cp);
-            }
-            break;
-
-        case wxFONTENCODING_KOI8:
-            xregistry = wxT("koi8");
-            if ( wxTestFontSpec(wxT("-*-*-*-*-*-*-*-*-*-*-*-*-koi8-1")) )
-            {
-                xencoding = wxT("1");
-
-                // test passed, no need to do it once more
-                test = FALSE;
-            }
-            else
-            {
-                xencoding = wxT("*");
-            }
-            break;
-
-        case wxFONTENCODING_CP1250:
-        case wxFONTENCODING_CP1251:
-        case wxFONTENCODING_CP1252:
-            {
-                int cp = encoding - wxFONTENCODING_CP1250 + 1250;
-                wxString fontSpec;
-                fontSpec.Printf(wxT("-*-*-*-*-*-*-*-*-*-*-*-*-microsoft-cp%d"),
-                                cp);
-                if ( wxTestFontSpec(fontSpec) )
-                {
-                    xregistry = wxT("microsoft");
-                    xencoding.Printf(wxT("cp%d"), cp);
-
-                    // test passed, no need to do it once more
-                    test = FALSE;
-                }
-                else
-                {
-                    // fall back to LatinX
-                    xregistry = wxT("iso8859");
-                    xencoding.Printf(wxT("%d"), cp - 1249);
-                }
-            }
-            break;
-
-        case wxFONTENCODING_SYSTEM:
-        default:
-            test = FALSE;
-            xregistry =
-            xencoding = wxT("*");
-    }
-
-    return !test;
-}
-
-wxNativeFont wxLoadQueryNearestFont(int pointSize,
-                                    int family,
-                                    int style,
-                                    int weight,
-                                    bool underlined,
-                                    const wxString &facename,
-                                    wxFontEncoding encoding)
-{
-    wxNativeFont font = wxLoadQueryFont( pointSize, family, style, weight,
-                                         underlined, facename, encoding );
-
-    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;
-
-        // Search for smaller size (approx.)
-        for ( i = pointSize - 10; !font && i >= 10 && i >= min_size; i -= 10 )
-        {
-            font = wxLoadQueryFont(i, family, style, weight, underlined,
-                                   facename, encoding );
-        }
-
-        // Search for larger size (approx.)
-        for ( i = pointSize + 10; !font && i <= max_size; i += 10 )
-        {
-            font = wxLoadQueryFont( i, family, style, weight, underlined,
-                                    facename, encoding );
-        }
-
-        // Try default family
-        if ( !font && family != wxDEFAULT )
-        {
-            font = wxLoadQueryFont( pointSize, wxDEFAULT, style, weight,
-                                    underlined, facename, encoding );
-        }
-
-        // Bogus font I
-        if ( !font )
-        {
-            font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
-                                   underlined, facename, encoding );
-        }
- 
-        // Bogus font II
- 	if ( !font )
- 	{
- 	    font = wxLoadQueryFont(120, wxDEFAULT, wxNORMAL, wxNORMAL,
- 				   underlined, wxEmptyString, encoding );
- 	}
-    }
-
-    return font;
-}
-
-#endif // wxUSE_GUI