src/common/fontmap.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/fontmap.cpp
// Purpose:     wxFontMapper class
// Author:      Vadim Zeitlin
// Modified by:
// Created:     04.11.99
// RCS-ID:      $Id: fontmap.cpp 39651 2006-06-09 17:50:46Z ABX $
// Copyright:   (c) 1999-2003 Vadim Zeitlin <vadim@wxwindows.org>
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_FONTMAP

#include "wx/fontmap.h"

#ifndef WX_PRECOMP
    #include "wx/app.h"
    #include "wx/log.h"
    #include "wx/intl.h"
    #include "wx/msgdlg.h"
    #include "wx/choicdlg.h"
#endif // PCH

#if wxUSE_CONFIG
    #include "wx/config.h"
#endif // wxUSE_CONFIG

#if defined(__WXMSW__)
  #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
  #include  "wx/msw/winundef.h"
#endif

#include "wx/fmappriv.h"
#include "wx/fontutil.h"
#include "wx/fontdlg.h"
#include "wx/encinfo.h"

#include "wx/encconv.h"

#if wxUSE_EXTENDED_RTTI

wxBEGIN_ENUM( wxFontEncoding )
    wxENUM_MEMBER( wxFONTENCODING_SYSTEM )
    wxENUM_MEMBER( wxFONTENCODING_DEFAULT )

    wxENUM_MEMBER( wxFONTENCODING_ISO8859_1 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_2 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_3 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_4 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_5 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_6 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_7 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_8 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_9 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_10 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_11 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_12 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_13 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_14 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_15 )
    wxENUM_MEMBER( wxFONTENCODING_ISO8859_MAX )
    wxENUM_MEMBER( wxFONTENCODING_KOI8 )
    wxENUM_MEMBER( wxFONTENCODING_KOI8_U )
    wxENUM_MEMBER( wxFONTENCODING_ALTERNATIVE )
    wxENUM_MEMBER( wxFONTENCODING_BULGARIAN )
    wxENUM_MEMBER( wxFONTENCODING_CP437 )
    wxENUM_MEMBER( wxFONTENCODING_CP850 )
    wxENUM_MEMBER( wxFONTENCODING_CP852 )
    wxENUM_MEMBER( wxFONTENCODING_CP855 )
    wxENUM_MEMBER( wxFONTENCODING_CP866 )

    wxENUM_MEMBER( wxFONTENCODING_CP874 )
    wxENUM_MEMBER( wxFONTENCODING_CP932 )
    wxENUM_MEMBER( wxFONTENCODING_CP936 )
    wxENUM_MEMBER( wxFONTENCODING_CP949 )
    wxENUM_MEMBER( wxFONTENCODING_CP950 )
    wxENUM_MEMBER( wxFONTENCODING_CP1250 )
    wxENUM_MEMBER( wxFONTENCODING_CP1251 )
    wxENUM_MEMBER( wxFONTENCODING_CP1252 )
    wxENUM_MEMBER( wxFONTENCODING_CP1253 )
    wxENUM_MEMBER( wxFONTENCODING_CP1254 )
    wxENUM_MEMBER( wxFONTENCODING_CP1255 )
    wxENUM_MEMBER( wxFONTENCODING_CP1256 )
    wxENUM_MEMBER( wxFONTENCODING_CP1257 )
    wxENUM_MEMBER( wxFONTENCODING_CP12_MAX )
    wxENUM_MEMBER( wxFONTENCODING_UTF7 )
    wxENUM_MEMBER( wxFONTENCODING_UTF8 )
    wxENUM_MEMBER( wxFONTENCODING_GB2312 )
    wxENUM_MEMBER( wxFONTENCODING_BIG5 )
    wxENUM_MEMBER( wxFONTENCODING_SHIFT_JIS )
    wxENUM_MEMBER( wxFONTENCODING_EUC_JP )
    wxENUM_MEMBER( wxFONTENCODING_UNICODE )
wxEND_ENUM( wxFontEncoding )
#endif

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// the config paths we use
#if wxUSE_CONFIG

static const wxChar* FONTMAPPER_FONT_FROM_ENCODING_PATH = wxT("Encodings");
static const wxChar* FONTMAPPER_FONT_DONT_ASK = wxT("none");

#endif // wxUSE_CONFIG

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// it may happen that while we're showing a dialog asking the user about
// something, another request for an encoding mapping arrives: in this case it
// is best to not do anything because otherwise we risk to enter an infinite
// loop so we create an object of this class on stack to test for this in all
// interactive functions
class ReentrancyBlocker
{
public:
    ReentrancyBlocker(bool& flag) : m_flagOld(flag), m_flag(flag)
        { m_flag = true; }
    ~ReentrancyBlocker() { m_flag = m_flagOld; }

private:
    bool m_flagOld;
    bool& m_flag;

    DECLARE_NO_COPY_CLASS(ReentrancyBlocker)
};

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// ctor and dtor
// ----------------------------------------------------------------------------

wxFontMapper::wxFontMapper()
{
    m_windowParent = NULL;
}

wxFontMapper::~wxFontMapper()
{
}

/* static */
wxFontMapper *wxFontMapper::Get()
{
    wxFontMapperBase *fontmapper = wxFontMapperBase::Get();
    wxASSERT_MSG( !fontmapper->IsDummy(),
                 wxT("GUI code requested a wxFontMapper but we only have a wxFontMapperBase.") );

    // Now return it anyway because there's a chance the GUI code might just
    // only want to call wxFontMapperBase functions and it's better than
    // crashing by returning NULL
    return (wxFontMapper *)fontmapper;
}

wxFontEncoding
wxFontMapper::CharsetToEncoding(const wxString& charset, bool interactive)
{
    // try the ways not needing the users intervention first
    int encoding = wxFontMapperBase::NonInteractiveCharsetToEncoding(charset);

    // if we failed to find the encoding, ask the user -- unless disabled
    if ( encoding == wxFONTENCODING_UNKNOWN )
    {
        // this is the special value which disables asking the user (he had
        // chosen to suppress this the last time)
        encoding = wxFONTENCODING_SYSTEM;
    }
#if wxUSE_CHOICEDLG
    else if ( (encoding == wxFONTENCODING_SYSTEM) && interactive )
    {
        // prepare the dialog data

        // the dialog title
        wxString title(m_titleDialog);
        if ( !title )
            title << wxTheApp->GetAppName() << _(": unknown charset");

        // the message
        wxString msg;
        msg.Printf(_("The charset '%s' is unknown. You may select\nanother charset to replace it with or choose\n[Cancel] if it cannot be replaced"), charset.c_str());

        // the list of choices
        const size_t count = GetSupportedEncodingsCount();

        wxString *encodingNamesTranslated = new wxString[count];

        for ( size_t i = 0; i < count; i++ )
        {
            encodingNamesTranslated[i] = GetEncodingDescription(GetEncoding(i));
        }

        // the parent window
        wxWindow *parent = m_windowParent;
        if ( !parent )
            parent = wxTheApp->GetTopWindow();

        // do ask the user and get back the index in encodings table
        int n = wxGetSingleChoiceIndex(msg, title,
                                       count,
                                       encodingNamesTranslated,
                                       parent);

        delete [] encodingNamesTranslated;

        if ( n != -1 )
        {
            encoding = GetEncoding(n);
        }

#if wxUSE_CONFIG && wxUSE_FILECONFIG
        // save the result in the config now
        wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
        if ( path.IsOk() )
        {
            wxConfigBase *config = GetConfig();

            // remember the alt encoding for this charset -- or remember that
            // we don't know it
            long value = n == -1 ? (long)wxFONTENCODING_UNKNOWN : (long)encoding;
            if ( !config->Write(charset, value) )
            {
                wxLogError(_("Failed to remember the encoding for the charset '%s'."), charset.c_str());
            }
        }
#endif // wxUSE_CONFIG
    }
#else
    wxUnusedVar(interactive);
#endif // wxUSE_CHOICEDLG

    return (wxFontEncoding)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) )
    {
#if wxUSE_CONFIG && wxUSE_FILECONFIG
        // remember the mapping in the config
        wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);

        if ( path.IsOk() )
        {
            GetConfig()->Write(configEntry, info->ToString());
        }
#else
        wxUnusedVar(configEntry);
#endif // wxUSE_CONFIG
        return true;
    }

    return false;
}

bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
                                     wxNativeEncodingInfo *info,
                                     const wxString& facename,
                                     bool interactive)
{
#if wxUSE_GUI
    // we need a flag to prevent infinite recursion which happens, for
    // example, when GetAltForEncoding() is called from an OnPaint() handler:
    // in this case, wxYield() which is called from wxMessageBox() we use here
    // will lead to another call of OnPaint() and hence to another call of
    // GetAltForEncoding() -- and it is impossible to catch this from the user
    // code because we are called from wxFont ctor implicitly.

    // assume we're always called from the main thread, so that it is safe to
    // use a static var
    static bool s_inGetAltForEncoding = false;

    if ( interactive && s_inGetAltForEncoding )
        return false;

    ReentrancyBlocker blocker(s_inGetAltForEncoding);
#endif // wxUSE_GUI

    wxCHECK_MSG( info, false, wxT("bad pointer in GetAltForEncoding") );

    info->facename = facename;

    if ( encoding == wxFONTENCODING_DEFAULT )
    {
        encoding = wxFont::GetDefaultEncoding();
    }

    // if we failed to load the system default encoding, something is really
    // wrong and we'd better stop now -- otherwise we will go into endless
    // recursion trying to create the font in the msg box with the error
    // message
    if ( encoding == wxFONTENCODING_SYSTEM )
    {
        wxLogFatalError(_("can't load any font, aborting"));

        // wxLogFatalError doesn't return
    }

    wxString configEntry,
             encName = GetEncodingName(encoding);
    if ( !facename.empty() )
    {
        configEntry = facename + _T("_");
    }
    configEntry += encName;

#if wxUSE_CONFIG && wxUSE_FILECONFIG
    // do we have a font spec for this encoding?
    wxString fontinfo;
    wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);
    if ( path.IsOk() )
    {
        fontinfo = GetConfig()->Read(configEntry);
    }

    // this special value means that we don't know of fonts for this
    // encoding but, moreover, have already asked the user as well and he
    // didn't specify any font neither
    if ( fontinfo == FONTMAPPER_FONT_DONT_ASK )
    {
        interactive = false;
    }
    else // use the info entered the last time
    {
        if ( !fontinfo.empty() && !facename.empty() )
        {
            // we tried to find a match with facename -- now try without it
            fontinfo = GetConfig()->Read(encName);
        }

        if ( !fontinfo.empty() )
        {
            if ( info->FromString(fontinfo) )
            {
                if ( wxTestFontEncoding(*info) )
                {
                    // ok, got something
                    return true;
                }
                //else: no such fonts, look for something else
                //      (should we erase the outdated value?)
            }
            else
            {
                wxLogDebug(wxT("corrupted config data: string '%s' is not a valid font encoding info"),
                           fontinfo.c_str());
            }
        }
        //else: there is no information in config about this encoding
    }
#endif // wxUSE_CONFIG

    // now try to map this encoding to a compatible one which we have on this
    // system
    wxFontEncodingArray equiv = wxEncodingConverter::GetAllEquivalents(encoding);
    size_t count = equiv.GetCount();
    bool foundEquivEncoding = false;
    wxFontEncoding equivEncoding = wxFONTENCODING_SYSTEM;
    if ( count )
    {
        for ( size_t i = 0; i < count && !foundEquivEncoding; i++ )
        {
            // don't test for encoding itself, we already know we don't have it
            if ( equiv[i] == encoding )
                continue;

            if ( TestAltEncoding(configEntry, equiv[i], info) )
            {
                equivEncoding = equiv[i];

                foundEquivEncoding = true;
            }
        }
    }

    // ask the user
#if wxUSE_FONTDLG
    if ( interactive )
    {
        wxString title(m_titleDialog);
        if ( !title )
            title << wxTheApp->GetAppName() << _(": unknown encoding");

        // built the message
        wxString encDesc = GetEncodingDescription(encoding),
                 msg;
        if ( foundEquivEncoding )
        {
            // ask the user if he wants to override found alternative encoding
            msg.Printf(_("No font for displaying text in encoding '%s' found,\nbut an alternative encoding '%s' is available.\nDo you want to use this encoding (otherwise you will have to choose another one)?"),
                       encDesc.c_str(), GetEncodingDescription(equivEncoding).c_str());
        }
        else
        {
            msg.Printf(_("No font for displaying text in encoding '%s' found.\nWould you like to select a font to be used for this encoding\n(otherwise the text in this encoding will not be shown correctly)?"),
                       encDesc.c_str());
        }

        // the question is different in 2 cases so the answer has to be
        // interpreted differently as well
        int answer = foundEquivEncoding ? wxNO : wxYES;

        if ( wxMessageBox(msg, title,
                          wxICON_QUESTION | wxYES_NO,
                          m_windowParent) == answer )
        {
            wxFontData data;
            data.SetEncoding(encoding);
            data.EncodingInfo() = *info;
            wxFontDialog dialog(m_windowParent, data);
            if ( dialog.ShowModal() == wxID_OK )
            {
                wxFontData retData = dialog.GetFontData();

                *info = retData.EncodingInfo();
                info->encoding = retData.GetEncoding();

#if wxUSE_CONFIG && wxUSE_FILECONFIG
                // remember this in the config
                wxFontMapperPathChanger path2(this,
                                              FONTMAPPER_FONT_FROM_ENCODING_PATH);
                if ( path2.IsOk() )
                {
                    GetConfig()->Write(configEntry, info->ToString());
                }
#endif // wxUSE_CONFIG

                return true;
            }
            //else: the user canceled the font selection dialog
        }
        else
        {
            // the user doesn't want to select a font for this encoding
            // or selected to use equivalent encoding
            //
            // remember it to avoid asking the same question again later
#if wxUSE_CONFIG && wxUSE_FILECONFIG
            wxFontMapperPathChanger path2(this,
                                          FONTMAPPER_FONT_FROM_ENCODING_PATH);
            if ( path2.IsOk() )
            {
                GetConfig()->Write
                             (
                                configEntry,
                                foundEquivEncoding ? info->ToString().c_str()
                                                   : FONTMAPPER_FONT_DONT_ASK
                             );
            }
#endif // wxUSE_CONFIG
        }
    }
    //else: we're in non-interactive mode
#else
    wxUnusedVar(equivEncoding);
#endif // wxUSE_FONTDLG

    return foundEquivEncoding;
}

bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
                                     wxFontEncoding *encodingAlt,
                                     const wxString& facename,
                                     bool interactive)
{
    wxCHECK_MSG( encodingAlt, false,
                    _T("wxFontEncoding::GetAltForEncoding(): NULL pointer") );

    wxNativeEncodingInfo info;
    if ( !GetAltForEncoding(encoding, &info, facename, interactive) )
        return false;

    *encodingAlt = info.encoding;

    return true;
}

bool wxFontMapper::IsEncodingAvailable(wxFontEncoding encoding,
                                       const wxString& facename)
{
    wxNativeEncodingInfo info;

    if ( !wxGetNativeFontEncoding(encoding, &info) )
        return false;

    info.facename = facename;
    return wxTestFontEncoding(info);
}

#endif // wxUSE_FONTMAP
1	william	31	/////////////////////////////////////////////////////////////////////////////
2			// Name: src/common/fontmap.cpp
3			// Purpose: wxFontMapper class
4			// Author: Vadim Zeitlin
5			// Modified by:
6			// Created: 04.11.99
7			// RCS-ID: $Id: fontmap.cpp 39651 2006-06-09 17:50:46Z ABX $
8			// Copyright: (c) 1999-2003 Vadim Zeitlin <vadim@wxwindows.org>
9			// Licence: wxWindows licence
10			/////////////////////////////////////////////////////////////////////////////
11
12			// ============================================================================
13			// declarations
14			// ============================================================================
15
16			// ----------------------------------------------------------------------------
17			// headers
18			// ----------------------------------------------------------------------------
19
20			// For compilers that support precompilation, includes "wx.h".
21			#include "wx/wxprec.h"
22
23			#ifdef __BORLANDC__
24			#pragma hdrstop
25			#endif
26
27			#if wxUSE_FONTMAP
28
29			#include "wx/fontmap.h"
30
31			#ifndef WX_PRECOMP
32			#include "wx/app.h"
33			#include "wx/log.h"
34			#include "wx/intl.h"
35			#include "wx/msgdlg.h"
36			#include "wx/choicdlg.h"
37			#endif // PCH
38
39			#if wxUSE_CONFIG
40			#include "wx/config.h"
41			#endif // wxUSE_CONFIG
42
43			#if defined(__WXMSW__)
44			#include "wx/msw/private.h" // includes windows.h for LOGFONT
45			#include "wx/msw/winundef.h"
46			#endif
47
48			#include "wx/fmappriv.h"
49			#include "wx/fontutil.h"
50			#include "wx/fontdlg.h"
51			#include "wx/encinfo.h"
52
53			#include "wx/encconv.h"
54
55			#if wxUSE_EXTENDED_RTTI
56
57			wxBEGIN_ENUM( wxFontEncoding )
58			wxENUM_MEMBER( wxFONTENCODING_SYSTEM )
59			wxENUM_MEMBER( wxFONTENCODING_DEFAULT )
60
61			wxENUM_MEMBER( wxFONTENCODING_ISO8859_1 )
62			wxENUM_MEMBER( wxFONTENCODING_ISO8859_2 )
63			wxENUM_MEMBER( wxFONTENCODING_ISO8859_3 )
64			wxENUM_MEMBER( wxFONTENCODING_ISO8859_4 )
65			wxENUM_MEMBER( wxFONTENCODING_ISO8859_5 )
66			wxENUM_MEMBER( wxFONTENCODING_ISO8859_6 )
67			wxENUM_MEMBER( wxFONTENCODING_ISO8859_7 )
68			wxENUM_MEMBER( wxFONTENCODING_ISO8859_8 )
69			wxENUM_MEMBER( wxFONTENCODING_ISO8859_9 )
70			wxENUM_MEMBER( wxFONTENCODING_ISO8859_10 )
71			wxENUM_MEMBER( wxFONTENCODING_ISO8859_11 )
72			wxENUM_MEMBER( wxFONTENCODING_ISO8859_12 )
73			wxENUM_MEMBER( wxFONTENCODING_ISO8859_13 )
74			wxENUM_MEMBER( wxFONTENCODING_ISO8859_14 )
75			wxENUM_MEMBER( wxFONTENCODING_ISO8859_15 )
76			wxENUM_MEMBER( wxFONTENCODING_ISO8859_MAX )
77			wxENUM_MEMBER( wxFONTENCODING_KOI8 )
78			wxENUM_MEMBER( wxFONTENCODING_KOI8_U )
79			wxENUM_MEMBER( wxFONTENCODING_ALTERNATIVE )
80			wxENUM_MEMBER( wxFONTENCODING_BULGARIAN )
81			wxENUM_MEMBER( wxFONTENCODING_CP437 )
82			wxENUM_MEMBER( wxFONTENCODING_CP850 )
83			wxENUM_MEMBER( wxFONTENCODING_CP852 )
84			wxENUM_MEMBER( wxFONTENCODING_CP855 )
85			wxENUM_MEMBER( wxFONTENCODING_CP866 )
86
87			wxENUM_MEMBER( wxFONTENCODING_CP874 )
88			wxENUM_MEMBER( wxFONTENCODING_CP932 )
89			wxENUM_MEMBER( wxFONTENCODING_CP936 )
90			wxENUM_MEMBER( wxFONTENCODING_CP949 )
91			wxENUM_MEMBER( wxFONTENCODING_CP950 )
92			wxENUM_MEMBER( wxFONTENCODING_CP1250 )
93			wxENUM_MEMBER( wxFONTENCODING_CP1251 )
94			wxENUM_MEMBER( wxFONTENCODING_CP1252 )
95			wxENUM_MEMBER( wxFONTENCODING_CP1253 )
96			wxENUM_MEMBER( wxFONTENCODING_CP1254 )
97			wxENUM_MEMBER( wxFONTENCODING_CP1255 )
98			wxENUM_MEMBER( wxFONTENCODING_CP1256 )
99			wxENUM_MEMBER( wxFONTENCODING_CP1257 )
100			wxENUM_MEMBER( wxFONTENCODING_CP12_MAX )
101			wxENUM_MEMBER( wxFONTENCODING_UTF7 )
102			wxENUM_MEMBER( wxFONTENCODING_UTF8 )
103			wxENUM_MEMBER( wxFONTENCODING_GB2312 )
104			wxENUM_MEMBER( wxFONTENCODING_BIG5 )
105			wxENUM_MEMBER( wxFONTENCODING_SHIFT_JIS )
106			wxENUM_MEMBER( wxFONTENCODING_EUC_JP )
107			wxENUM_MEMBER( wxFONTENCODING_UNICODE )
108			wxEND_ENUM( wxFontEncoding )
109			#endif
110
111			// ----------------------------------------------------------------------------
112			// constants
113			// ----------------------------------------------------------------------------
114
115			// the config paths we use
116			#if wxUSE_CONFIG
117
118			static const wxChar* FONTMAPPER_FONT_FROM_ENCODING_PATH = wxT("Encodings");
119			static const wxChar* FONTMAPPER_FONT_DONT_ASK = wxT("none");
120
121			#endif // wxUSE_CONFIG
122
123			// ----------------------------------------------------------------------------
124			// private classes
125			// ----------------------------------------------------------------------------
126
127			// it may happen that while we're showing a dialog asking the user about
128			// something, another request for an encoding mapping arrives: in this case it
129			// is best to not do anything because otherwise we risk to enter an infinite
130			// loop so we create an object of this class on stack to test for this in all
131			// interactive functions
132			class ReentrancyBlocker
133			{
134			public:
135			ReentrancyBlocker(bool& flag) : m_flagOld(flag), m_flag(flag)
136			{ m_flag = true; }
137			~ReentrancyBlocker() { m_flag = m_flagOld; }
138
139			private:
140			bool m_flagOld;
141			bool& m_flag;
142
143			DECLARE_NO_COPY_CLASS(ReentrancyBlocker)
144			};
145
146			// ============================================================================
147			// implementation
148			// ============================================================================
149
150			// ----------------------------------------------------------------------------
151			// ctor and dtor
152			// ----------------------------------------------------------------------------
153
154			wxFontMapper::wxFontMapper()
155			{
156			m_windowParent = NULL;
157			}
158
159			wxFontMapper::~wxFontMapper()
160			{
161			}
162
163			/* static */
164			wxFontMapper *wxFontMapper::Get()
165			{
166			wxFontMapperBase *fontmapper = wxFontMapperBase::Get();
167			wxASSERT_MSG( !fontmapper->IsDummy(),
168			wxT("GUI code requested a wxFontMapper but we only have a wxFontMapperBase.") );
169
170			// Now return it anyway because there's a chance the GUI code might just
171			// only want to call wxFontMapperBase functions and it's better than
172			// crashing by returning NULL
173			return (wxFontMapper *)fontmapper;
174			}
175
176			wxFontEncoding
177			wxFontMapper::CharsetToEncoding(const wxString& charset, bool interactive)
178			{
179			// try the ways not needing the users intervention first
180			int encoding = wxFontMapperBase::NonInteractiveCharsetToEncoding(charset);
181
182			// if we failed to find the encoding, ask the user -- unless disabled
183			if ( encoding == wxFONTENCODING_UNKNOWN )
184			{
185			// this is the special value which disables asking the user (he had
186			// chosen to suppress this the last time)
187			encoding = wxFONTENCODING_SYSTEM;
188			}
189			#if wxUSE_CHOICEDLG
190			else if ( (encoding == wxFONTENCODING_SYSTEM) && interactive )
191			{
192			// prepare the dialog data
193
194			// the dialog title
195			wxString title(m_titleDialog);
196			if ( !title )
197			title << wxTheApp->GetAppName() << _(": unknown charset");
198
199			// the message
200			wxString msg;
201			msg.Printf(_("The charset '%s' is unknown. You may select\nanother charset to replace it with or choose\n[Cancel] if it cannot be replaced"), charset.c_str());
202
203			// the list of choices
204			const size_t count = GetSupportedEncodingsCount();
205
206			wxString *encodingNamesTranslated = new wxString[count];
207
208			for ( size_t i = 0; i < count; i++ )
209			{
210			encodingNamesTranslated[i] = GetEncodingDescription(GetEncoding(i));
211			}
212
213			// the parent window
214			wxWindow *parent = m_windowParent;
215			if ( !parent )
216			parent = wxTheApp->GetTopWindow();
217
218			// do ask the user and get back the index in encodings table
219			int n = wxGetSingleChoiceIndex(msg, title,
220			count,
221			encodingNamesTranslated,
222			parent);
223
224			delete [] encodingNamesTranslated;
225
226			if ( n != -1 )
227			{
228			encoding = GetEncoding(n);
229			}
230
231			#if wxUSE_CONFIG && wxUSE_FILECONFIG
232			// save the result in the config now
233			wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
234			if ( path.IsOk() )
235			{
236			wxConfigBase *config = GetConfig();
237
238			// remember the alt encoding for this charset -- or remember that
239			// we don't know it
240			long value = n == -1 ? (long)wxFONTENCODING_UNKNOWN : (long)encoding;
241			if ( !config->Write(charset, value) )
242			{
243			wxLogError(_("Failed to remember the encoding for the charset '%s'."), charset.c_str());
244			}
245			}
246			#endif // wxUSE_CONFIG
247			}
248			#else
249			wxUnusedVar(interactive);
250			#endif // wxUSE_CHOICEDLG
251
252			return (wxFontEncoding)encoding;
253			}
254
255			// ----------------------------------------------------------------------------
256			// support for unknown encodings: we maintain a map between the
257			// (platform-specific) strings identifying them and our wxFontEncodings they
258			// correspond to which is used by GetFontForEncoding() function
259			// ----------------------------------------------------------------------------
260
261			bool wxFontMapper::TestAltEncoding(const wxString& configEntry,
262			wxFontEncoding encReplacement,
263			wxNativeEncodingInfo *info)
264			{
265			if ( wxGetNativeFontEncoding(encReplacement, info) &&
266			wxTestFontEncoding(*info) )
267			{
268			#if wxUSE_CONFIG && wxUSE_FILECONFIG
269			// remember the mapping in the config
270			wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);
271
272			if ( path.IsOk() )
273			{
274			GetConfig()->Write(configEntry, info->ToString());
275			}
276			#else
277			wxUnusedVar(configEntry);
278			#endif // wxUSE_CONFIG
279			return true;
280			}
281
282			return false;
283			}
284
285			bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
286			wxNativeEncodingInfo *info,
287			const wxString& facename,
288			bool interactive)
289			{
290			#if wxUSE_GUI
291			// we need a flag to prevent infinite recursion which happens, for
292			// example, when GetAltForEncoding() is called from an OnPaint() handler:
293			// in this case, wxYield() which is called from wxMessageBox() we use here
294			// will lead to another call of OnPaint() and hence to another call of
295			// GetAltForEncoding() -- and it is impossible to catch this from the user
296			// code because we are called from wxFont ctor implicitly.
297
298			// assume we're always called from the main thread, so that it is safe to
299			// use a static var
300			static bool s_inGetAltForEncoding = false;
301
302			if ( interactive && s_inGetAltForEncoding )
303			return false;
304
305			ReentrancyBlocker blocker(s_inGetAltForEncoding);
306			#endif // wxUSE_GUI
307
308			wxCHECK_MSG( info, false, wxT("bad pointer in GetAltForEncoding") );
309
310			info->facename = facename;
311
312			if ( encoding == wxFONTENCODING_DEFAULT )
313			{
314			encoding = wxFont::GetDefaultEncoding();
315			}
316
317			// if we failed to load the system default encoding, something is really
318			// wrong and we'd better stop now -- otherwise we will go into endless
319			// recursion trying to create the font in the msg box with the error
320			// message
321			if ( encoding == wxFONTENCODING_SYSTEM )
322			{
323			wxLogFatalError(_("can't load any font, aborting"));
324
325			// wxLogFatalError doesn't return
326			}
327
328			wxString configEntry,
329			encName = GetEncodingName(encoding);
330			if ( !facename.empty() )
331			{
332			configEntry = facename + _T("_");
333			}
334			configEntry += encName;
335
336			#if wxUSE_CONFIG && wxUSE_FILECONFIG
337			// do we have a font spec for this encoding?
338			wxString fontinfo;
339			wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);
340			if ( path.IsOk() )
341			{
342			fontinfo = GetConfig()->Read(configEntry);
343			}
344
345			// this special value means that we don't know of fonts for this
346			// encoding but, moreover, have already asked the user as well and he
347			// didn't specify any font neither
348			if ( fontinfo == FONTMAPPER_FONT_DONT_ASK )
349			{
350			interactive = false;
351			}
352			else // use the info entered the last time
353			{
354			if ( !fontinfo.empty() && !facename.empty() )
355			{
356			// we tried to find a match with facename -- now try without it
357			fontinfo = GetConfig()->Read(encName);
358			}
359
360			if ( !fontinfo.empty() )
361			{
362			if ( info->FromString(fontinfo) )
363			{
364			if ( wxTestFontEncoding(*info) )
365			{
366			// ok, got something
367			return true;
368			}
369			//else: no such fonts, look for something else
370			// (should we erase the outdated value?)
371			}
372			else
373			{
374			wxLogDebug(wxT("corrupted config data: string '%s' is not a valid font encoding info"),
375			fontinfo.c_str());
376			}
377			}
378			//else: there is no information in config about this encoding
379			}
380			#endif // wxUSE_CONFIG
381
382			// now try to map this encoding to a compatible one which we have on this
383			// system
384			wxFontEncodingArray equiv = wxEncodingConverter::GetAllEquivalents(encoding);
385			size_t count = equiv.GetCount();
386			bool foundEquivEncoding = false;
387			wxFontEncoding equivEncoding = wxFONTENCODING_SYSTEM;
388			if ( count )
389			{
390			for ( size_t i = 0; i < count && !foundEquivEncoding; i++ )
391			{
392			// don't test for encoding itself, we already know we don't have it
393			if ( equiv[i] == encoding )
394			continue;
395
396			if ( TestAltEncoding(configEntry, equiv[i], info) )
397			{
398			equivEncoding = equiv[i];
399
400			foundEquivEncoding = true;
401			}
402			}
403			}
404
405			// ask the user
406			#if wxUSE_FONTDLG
407			if ( interactive )
408			{
409			wxString title(m_titleDialog);
410			if ( !title )
411			title << wxTheApp->GetAppName() << _(": unknown encoding");
412
413			// built the message
414			wxString encDesc = GetEncodingDescription(encoding),
415			msg;
416			if ( foundEquivEncoding )
417			{
418			// ask the user if he wants to override found alternative encoding
419			msg.Printf(_("No font for displaying text in encoding '%s' found,\nbut an alternative encoding '%s' is available.\nDo you want to use this encoding (otherwise you will have to choose another one)?"),
420			encDesc.c_str(), GetEncodingDescription(equivEncoding).c_str());
421			}
422			else
423			{
424			msg.Printf(_("No font for displaying text in encoding '%s' found.\nWould you like to select a font to be used for this encoding\n(otherwise the text in this encoding will not be shown correctly)?"),
425			encDesc.c_str());
426			}
427
428			// the question is different in 2 cases so the answer has to be
429			// interpreted differently as well
430			int answer = foundEquivEncoding ? wxNO : wxYES;
431
432			if ( wxMessageBox(msg, title,
433			wxICON_QUESTION \| wxYES_NO,
434			m_windowParent) == answer )
435			{
436			wxFontData data;
437			data.SetEncoding(encoding);
438			data.EncodingInfo() = *info;
439			wxFontDialog dialog(m_windowParent, data);
440			if ( dialog.ShowModal() == wxID_OK )
441			{
442			wxFontData retData = dialog.GetFontData();
443
444			*info = retData.EncodingInfo();
445			info->encoding = retData.GetEncoding();
446
447			#if wxUSE_CONFIG && wxUSE_FILECONFIG
448			// remember this in the config
449			wxFontMapperPathChanger path2(this,
450			FONTMAPPER_FONT_FROM_ENCODING_PATH);
451			if ( path2.IsOk() )
452			{
453			GetConfig()->Write(configEntry, info->ToString());
454			}
455			#endif // wxUSE_CONFIG
456
457			return true;
458			}
459			//else: the user canceled the font selection dialog
460			}
461			else
462			{
463			// the user doesn't want to select a font for this encoding
464			// or selected to use equivalent encoding
465			//
466			// remember it to avoid asking the same question again later
467			#if wxUSE_CONFIG && wxUSE_FILECONFIG
468			wxFontMapperPathChanger path2(this,
469			FONTMAPPER_FONT_FROM_ENCODING_PATH);
470			if ( path2.IsOk() )
471			{
472			GetConfig()->Write
473			(
474			configEntry,
475			foundEquivEncoding ? info->ToString().c_str()
476			: FONTMAPPER_FONT_DONT_ASK
477			);
478			}
479			#endif // wxUSE_CONFIG
480			}
481			}
482			//else: we're in non-interactive mode
483			#else
484			wxUnusedVar(equivEncoding);
485			#endif // wxUSE_FONTDLG
486
487			return foundEquivEncoding;
488			}
489
490			bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
491			wxFontEncoding *encodingAlt,
492			const wxString& facename,
493			bool interactive)
494			{
495			wxCHECK_MSG( encodingAlt, false,
496			_T("wxFontEncoding::GetAltForEncoding(): NULL pointer") );
497
498			wxNativeEncodingInfo info;
499			if ( !GetAltForEncoding(encoding, &info, facename, interactive) )
500			return false;
501
502			*encodingAlt = info.encoding;
503
504			return true;
505			}
506
507			bool wxFontMapper::IsEncodingAvailable(wxFontEncoding encoding,
508			const wxString& facename)
509			{
510			wxNativeEncodingInfo info;
511
512			if ( !wxGetNativeFontEncoding(encoding, &info) )
513			return false;
514
515			info.facename = facename;
516			return wxTestFontEncoding(info);
517			}
518
519			#endif // wxUSE_FONTMAP