src/common/fontmap.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        common/fontmap.cpp
// Purpose:     wxFontMapper class
// Author:      Vadim Zeitlin
// Modified by:
// Created:     04.11.99
// RCS-ID:      $Id$
// Copyright:   (c) Vadim Zeitlin
// Licence:     wxWindows license
/////////////////////////////////////////////////////////////////////////////

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

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

#ifdef __GNUG__
    #pragma implementation "fontmap.h"
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

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

#include "wx/fontmap.h"

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

#if wxUSE_GUI
    #include "wx/msgdlg.h"
    #include "wx/fontdlg.h"
    #include "wx/choicdlg.h"
#endif // wxUSE_GUI

#include "wx/encconv.h"

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

// the config paths we use
static const wxChar* FONTMAPPER_ROOT_PATH = wxT("/wxWindows/FontMapper");
static const wxChar* FONTMAPPER_CHARSET_PATH = wxT("Charsets");
static const wxChar* FONTMAPPER_CHARSET_ALIAS_PATH = wxT("Aliases");
#if wxUSE_GUI
    static const wxChar* FONTMAPPER_FONT_FROM_ENCODING_PATH = wxT("Encodings");
#endif // wxUSE_GUI

// 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,
    wxFONTENCODING_CP437,
};

// the descriptions for them
static const wxChar* gs_encodingDescs[] =
{
    wxTRANSLATE( "Western European (ISO-8859-1/Latin 1)" ),
    wxTRANSLATE( "Central European (ISO-8859-2/Latin 2)" ),
    wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
    wxTRANSLATE( "Baltic (old) (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( "Nordic (ISO-8859-10)" ),
    wxTRANSLATE( "Thai (ISO-8859-11)" ),
    wxTRANSLATE( "Indian (ISO-8859-12)" ),
    wxTRANSLATE( "Baltic (ISO-8859-13)" ),
    wxTRANSLATE( "Celtic (ISO-8859-14)" ),
    wxTRANSLATE( "Western European with Euro (ISO-8859-15/Latin 0)" ),
    wxTRANSLATE( "KOI8-R" ),
    wxTRANSLATE( "Windows Central European (CP 1250)" ),
    wxTRANSLATE( "Windows Cyrillic (CP 1251)" ),
    wxTRANSLATE( "Windows Western European (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)" ),
    wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
};

// and the internal names
static const wxChar* gs_encodingNames[] =
{
    wxT( "iso8859-1" ),
    wxT( "iso8859-2" ),
    wxT( "iso8859-3" ),
    wxT( "iso8859-4" ),
    wxT( "iso8859-5" ),
    wxT( "iso8859-6" ),
    wxT( "iso8859-7" ),
    wxT( "iso8859-8" ),
    wxT( "iso8859-9" ),
    wxT( "iso8859-10" ),
    wxT( "iso8859-11" ),
    wxT( "iso8859-12" ),
    wxT( "iso8859-13" ),
    wxT( "iso8859-14" ),
    wxT( "iso8859-15" ),
    wxT( "koi8-r" ),
    wxT( "windows1250" ),
    wxT( "windows1251" ),
    wxT( "windows1252" ),
    wxT( "windows1253" ),
    wxT( "windows1254" ),
    wxT( "windows1255" ),
    wxT( "windows1256" ),
    wxT( "windows1257" ),
    wxT( "windows437" ),
};

// ----------------------------------------------------------------------------
// global data
// ----------------------------------------------------------------------------

// private object
static wxFontMapper gs_fontMapper;

// and public pointer
wxFontMapper * 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
// ============================================================================

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

wxFontMapper::wxFontMapper()
{
#if wxUSE_CONFIG
    m_config = NULL;
#endif // wxUSE_CONFIG

#if wxUSE_GUI
    m_windowParent = NULL;
#endif // wxUSE_GUI
}

wxFontMapper::~wxFontMapper()
{
}

// ----------------------------------------------------------------------------
// customisation
// ----------------------------------------------------------------------------

#if wxUSE_CONFIG

/* static */ const wxChar *wxFontMapper::GetDefaultConfigPath()
{
    return FONTMAPPER_ROOT_PATH;
}

void wxFontMapper::SetConfigPath(const wxString& prefix)
{
    wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
                 wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );

    m_configRootPath = prefix;
}

// ----------------------------------------------------------------------------
// get config object and path for it
// ----------------------------------------------------------------------------

wxConfigBase *wxFontMapper::GetConfig()
{
    if ( !m_config )
    {
        // try the default
        m_config = wxConfig::Get(FALSE /*don't create on demand*/ );

        if ( !m_config )
        {
            // we still want to have a config object because otherwise we would
            // keep asking the user the same questions in the interactive mode,
            // so create a dummy config which won't write to any files/registry
            // but will allow us to remember the results of the questions at
            // least during this run
            m_config = new wxMemoryConfig;
            wxConfig::Set(m_config);
        }
    }

    return m_config;
}

const wxString& wxFontMapper::GetConfigPath()
{
    if ( !m_configRootPath )
    {
        // use the default
        m_configRootPath = GetDefaultConfigPath();
    }

    return m_configRootPath;
}
#endif

bool wxFontMapper::ChangePath(const wxString& pathNew, wxString *pathOld)
{
#if wxUSE_CONFIG
    wxConfigBase *config = GetConfig();
    if ( !config )
        return FALSE;

    *pathOld = config->GetPath();

    wxString path = GetConfigPath();
    if ( path.IsEmpty() || path.Last() != wxCONFIG_PATH_SEPARATOR )
    {
        path += wxCONFIG_PATH_SEPARATOR;
    }

    wxASSERT_MSG( !pathNew || (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
                  wxT("should be a relative path") );

    path += pathNew;

    config->SetPath(path);

    return TRUE;
#else
    return FALSE;
#endif
}

void wxFontMapper::RestorePath(const wxString& pathOld)
{
#if wxUSE_CONFIG
    GetConfig()->SetPath(pathOld);
#else
#endif
}

// ----------------------------------------------------------------------------
// charset/encoding correspondence
// ----------------------------------------------------------------------------

/* static */
wxString wxFontMapper::GetEncodingDescription(wxFontEncoding encoding)
{
    size_t count = WXSIZEOF(gs_encodingDescs);

    wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
                  wxT("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),
                  wxT("inconsistency 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)
{
    wxFontEncoding encoding = wxFONTENCODING_SYSTEM;

    // we're going to modify it, make a copy
    wxString cs = charset;

#if wxUSE_CONFIG
    // first try the user-defined settings
    wxString pathOld;
    if ( ChangePath(FONTMAPPER_CHARSET_PATH, &pathOld) )
    {
        wxConfigBase *config = GetConfig();

        // do we have an encoding for this charset?
        long value = config->Read(charset, -1l);
        if ( value != -1 )
        {
            if ( value >= 0 && value <= wxFONTENCODING_MAX )
            {
                encoding = (wxFontEncoding)value;
            }
            else
            {
                wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
                           value, charset.c_str());
            }
        }

        if ( encoding == wxFONTENCODING_SYSTEM )
        {
            // may be we have an alias?
            config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);

            wxString alias = config->Read(charset);
            if ( !!alias )
            {
                // yes, we do - use it instead
                cs = alias;
            }
        }

        RestorePath(pathOld);
    }
#endif

    // if didn't find it there, try to reckognise it ourselves
    if ( encoding == wxFONTENCODING_SYSTEM )
    {
        // discard the optional quotes
        if ( !!cs )
        {
            if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
            {
                cs = wxString(cs.c_str(), cs.length() - 1);
            }
        }

        cs.MakeUpper();

        if ( !cs || cs == wxT("US-ASCII") )
            encoding = wxFONTENCODING_DEFAULT;
        else if ( cs == wxT("KOI8-R") || cs == wxT("KOI8-U") )
            encoding = wxFONTENCODING_KOI8;
        else if ( cs.Left(3) == wxT("ISO") )
        {
            // the dash is optional (or, to be exact, it is not, but
            // several brokenmails "forget" it)
            const wxChar *p = cs.c_str() + 3;
            if ( *p == wxT('-') )
                p++;

            unsigned int value;
            if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
            {
                if ( value < wxFONTENCODING_ISO8859_MAX -
                             wxFONTENCODING_ISO8859_1 )
                {
                    // it's a valid ISO8859 encoding
                    value += wxFONTENCODING_ISO8859_1 - 1;
                    encoding = (wxFontEncoding)value;
                }
            }
        }
        else if ( cs.Left(8) == wxT("WINDOWS-") )
        {
            int value;
            if ( wxSscanf(cs.c_str() + 8, wxT("%u"), &value) == 1 )
            {
                if ( value >= 1250 )
                {
                    value -= 1250;
                    if ( value < wxFONTENCODING_CP12_MAX -
                                 wxFONTENCODING_CP1250 )
                    {
                        // a valid Windows code page
                        value += wxFONTENCODING_CP1250;
                        encoding = (wxFontEncoding)value;
                    }
                }
            }
        }
        //else: unknown
    }

#if wxUSE_GUI
    // if still no luck, ask the user - unless disabled
    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
        size_t count = WXSIZEOF(gs_encodingDescs);

        wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
                      wxT("inconsitency detected - forgot to update one of the arrays?") );

        wxString *encodingNamesTranslated = new wxString[count];

        for ( size_t i = 0; i < count; i++ )
        {
            encodingNamesTranslated[i] = wxGetTranslation(gs_encodingDescs[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 = gs_encodings[n];

#if wxUSE_CONFIG
        // save the result in the config now
            if ( ChangePath(FONTMAPPER_CHARSET_PATH, &pathOld) )
            {
                wxConfigBase *config = GetConfig();

                // remember the alt encoding for this charset
                if ( !config->Write(charset, (long)encoding) )
                {
                    wxLogError(_("Failed to remember the encoding for the charset '%s'."), charset.c_str());
                }

                RestorePath(pathOld);
            }
#endif // wxUSE_CONFIG
        }
        //else: cancelled
    }
#endif // wxUSE_GUI

    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
// ----------------------------------------------------------------------------

#if wxUSE_GUI

bool wxFontMapper::TestAltEncoding(const wxString& configEntry,
                                   wxFontEncoding encReplacement,
                                   wxNativeEncodingInfo *info)
{
    if ( wxGetNativeFontEncoding(encReplacement, info) &&
         wxTestFontEncoding(*info) )
    {
#if wxUSE_CONFIG
        // remember the mapping in the config
        wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);

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

    return FALSE;
}

#if wxUSE_GUI
class ReentrancyBlocker
{
public:
    ReentrancyBlocker(bool& b) : m_b(b) { m_b = TRUE; }
    ~ReentrancyBlocker() { m_b = FALSE; }

private:
    bool& m_b;
};
#endif

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 )
    {
        wxFatalError(_("can't load any font, aborting"));

        // wxFatalError doesn't return
    }

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

#if wxUSE_CONFIG
    // 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 && !!facename )
        {
            // we tried to find a match with facename - now try without it
            fontinfo = config->Read(encName);
        }

        if ( !!fontinfo )
        {
            if ( info->FromString(fontinfo) )
            {
                if ( wxTestFontEncoding(*info) )
                {
                    // ok, got something
                    return TRUE;
                }
                //else: no such fonts, look for something else
            }
            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

    // 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.\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)?"),
                     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 = retData.EncodingInfo();
                info -> encoding = retData.GetEncoding();

#if wxUSE_CONFIG
            // remember this in the config
                if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
                {
                    GetConfig()->Write(configEntry, info->ToString());

                    RestorePath(pathOld);
                }
#endif

                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:
    wxFontEncodingArray equiv = wxEncodingConverter::GetAllEquivalents(encoding);
    size_t count = equiv.GetCount();
    if ( count )
    {
        for ( size_t i = (equiv[0] == encoding) ? 1 : 0; i < count; i++ )
        {
            if ( TestAltEncoding(configEntry, equiv[i], info) )
                return TRUE;
        }
    }

    return FALSE;
}

bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
                                     wxFontEncoding *alt_encoding,
                                     const wxString& facename,
                                     bool interactive)
{
    wxNativeEncodingInfo info;
    bool r = GetAltForEncoding(encoding, &info, facename, interactive);
    *alt_encoding = info.encoding;
    return r;
}

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

    if (wxGetNativeFontEncoding(encoding, &info))
    {
        info.facename = facename;
        return wxTestFontEncoding(info);
    }

    return FALSE;
}

#endif // wxUSE_GUI
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: common/fontmap.cpp
	3	// Purpose: wxFontMapper class
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 04.11.99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Vadim Zeitlin
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "fontmap.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#ifdef __BORLANDC__
	28	#pragma hdrstop
	29	#endif
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/app.h"
	33	#include "wx/log.h"
	34	#include "wx/intl.h"
	35	#endif // PCH
	36
	37	#include "wx/fontmap.h"
	38
	39	#if wxUSE_CONFIG
	40	#include "wx/config.h"
	41	#include "wx/memconf.h"
	42	#endif
	43
	44	#if wxUSE_GUI
	45	#include "wx/msgdlg.h"
	46	#include "wx/fontdlg.h"
	47	#include "wx/choicdlg.h"
	48	#endif // wxUSE_GUI
	49
	50	#include "wx/encconv.h"
	51
	52	// ----------------------------------------------------------------------------
	53	// constants
	54	// ----------------------------------------------------------------------------
	55
	56	// the config paths we use
	57	static const wxChar* FONTMAPPER_ROOT_PATH = wxT("/wxWindows/FontMapper");
	58	static const wxChar* FONTMAPPER_CHARSET_PATH = wxT("Charsets");
	59	static const wxChar* FONTMAPPER_CHARSET_ALIAS_PATH = wxT("Aliases");
	60	#if wxUSE_GUI
	61	static const wxChar* FONTMAPPER_FONT_FROM_ENCODING_PATH = wxT("Encodings");
	62	#endif // wxUSE_GUI
	63
	64	// encodings supported by GetEncodingDescription
	65	static wxFontEncoding gs_encodings[] =
	66	{
	67	wxFONTENCODING_ISO8859_1,
	68	wxFONTENCODING_ISO8859_2,
	69	wxFONTENCODING_ISO8859_3,
	70	wxFONTENCODING_ISO8859_4,
	71	wxFONTENCODING_ISO8859_5,
	72	wxFONTENCODING_ISO8859_6,
	73	wxFONTENCODING_ISO8859_7,
	74	wxFONTENCODING_ISO8859_8,
	75	wxFONTENCODING_ISO8859_9,
	76	wxFONTENCODING_ISO8859_10,
	77	wxFONTENCODING_ISO8859_11,
	78	wxFONTENCODING_ISO8859_12,
	79	wxFONTENCODING_ISO8859_13,
	80	wxFONTENCODING_ISO8859_14,
	81	wxFONTENCODING_ISO8859_15,
	82	wxFONTENCODING_KOI8,
	83	wxFONTENCODING_CP1250,
	84	wxFONTENCODING_CP1251,
	85	wxFONTENCODING_CP1252,
	86	wxFONTENCODING_CP1253,
	87	wxFONTENCODING_CP1254,
	88	wxFONTENCODING_CP1255,
	89	wxFONTENCODING_CP1256,
	90	wxFONTENCODING_CP1257,
	91	wxFONTENCODING_CP437,
	92	};
	93
	94	// the descriptions for them
	95	static const wxChar* gs_encodingDescs[] =
	96	{
	97	wxTRANSLATE( "Western European (ISO-8859-1/Latin 1)" ),
	98	wxTRANSLATE( "Central European (ISO-8859-2/Latin 2)" ),
	99	wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
	100	wxTRANSLATE( "Baltic (old) (ISO-8859-4)" ),
	101	wxTRANSLATE( "Cyrillic (Latin 5)" ),
	102	wxTRANSLATE( "Arabic (ISO-8859-6)" ),
	103	wxTRANSLATE( "Greek (ISO-8859-7)" ),
	104	wxTRANSLATE( "Hebrew (ISO-8859-8)" ),
	105	wxTRANSLATE( "Turkish (ISO-8859-9)" ),
	106	wxTRANSLATE( "Nordic (ISO-8859-10)" ),
	107	wxTRANSLATE( "Thai (ISO-8859-11)" ),
	108	wxTRANSLATE( "Indian (ISO-8859-12)" ),
	109	wxTRANSLATE( "Baltic (ISO-8859-13)" ),
	110	wxTRANSLATE( "Celtic (ISO-8859-14)" ),
	111	wxTRANSLATE( "Western European with Euro (ISO-8859-15/Latin 0)" ),
	112	wxTRANSLATE( "KOI8-R" ),
	113	wxTRANSLATE( "Windows Central European (CP 1250)" ),
	114	wxTRANSLATE( "Windows Cyrillic (CP 1251)" ),
	115	wxTRANSLATE( "Windows Western European (CP 1252)" ),
	116	wxTRANSLATE( "Windows Greek (CP 1253)" ),
	117	wxTRANSLATE( "Windows Turkish (CP 1254)" ),
	118	wxTRANSLATE( "Windows Hebrew (CP 1255)" ),
	119	wxTRANSLATE( "Windows Arabic (CP 1256)" ),
	120	wxTRANSLATE( "Windows Baltic (CP 1257)" ),
	121	wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
	122	};
	123
	124	// and the internal names
	125	static const wxChar* gs_encodingNames[] =
	126	{
	127	wxT( "iso8859-1" ),
	128	wxT( "iso8859-2" ),
	129	wxT( "iso8859-3" ),
	130	wxT( "iso8859-4" ),
	131	wxT( "iso8859-5" ),
	132	wxT( "iso8859-6" ),
	133	wxT( "iso8859-7" ),
	134	wxT( "iso8859-8" ),
	135	wxT( "iso8859-9" ),
	136	wxT( "iso8859-10" ),
	137	wxT( "iso8859-11" ),
	138	wxT( "iso8859-12" ),
	139	wxT( "iso8859-13" ),
	140	wxT( "iso8859-14" ),
	141	wxT( "iso8859-15" ),
	142	wxT( "koi8-r" ),
	143	wxT( "windows1250" ),
	144	wxT( "windows1251" ),
	145	wxT( "windows1252" ),
	146	wxT( "windows1253" ),
	147	wxT( "windows1254" ),
	148	wxT( "windows1255" ),
	149	wxT( "windows1256" ),
	150	wxT( "windows1257" ),
	151	wxT( "windows437" ),
	152	};
	153
	154	// ----------------------------------------------------------------------------
	155	// global data
	156	// ----------------------------------------------------------------------------
	157
	158	// private object
	159	static wxFontMapper gs_fontMapper;
	160
	161	// and public pointer
	162	wxFontMapper * wxTheFontMapper = &gs_fontMapper;
	163
	164	// ----------------------------------------------------------------------------
	165	// private classes
	166	// ----------------------------------------------------------------------------
	167
	168	// change the config path during the lifetime of this object
	169	class wxFontMapperPathChanger
	170	{
	171	public:
	172	wxFontMapperPathChanger(wxFontMapper *fontMapper, const wxString& path)
	173	{
	174	m_fontMapper = fontMapper;
	175	m_ok = m_fontMapper->ChangePath(path, &m_pathOld);
	176	}
	177
	178	bool IsOk() const { return m_ok; }
	179
	180	~wxFontMapperPathChanger()
	181	{
	182	if ( IsOk() )
	183	m_fontMapper->RestorePath(m_pathOld);
	184	}
	185
	186	private:
	187	wxFontMapper *m_fontMapper;
	188	bool m_ok;
	189	wxString m_pathOld;
	190	};
	191
	192	// ============================================================================
	193	// implementation
	194	// ============================================================================
	195
	196	// ----------------------------------------------------------------------------
	197	// ctor and dtor
	198	// ----------------------------------------------------------------------------
	199
	200	wxFontMapper::wxFontMapper()
	201	{
	202	#if wxUSE_CONFIG
	203	m_config = NULL;
	204	#endif // wxUSE_CONFIG
	205
	206	#if wxUSE_GUI
	207	m_windowParent = NULL;
	208	#endif // wxUSE_GUI
	209	}
	210
	211	wxFontMapper::~wxFontMapper()
	212	{
	213	}
	214
	215	// ----------------------------------------------------------------------------
	216	// customisation
	217	// ----------------------------------------------------------------------------
	218
	219	#if wxUSE_CONFIG
	220
	221	/* static / const wxChar wxFontMapper::GetDefaultConfigPath()
	222	{
	223	return FONTMAPPER_ROOT_PATH;
	224	}
	225
	226	void wxFontMapper::SetConfigPath(const wxString& prefix)
	227	{
	228	wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
	229	wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
	230
	231	m_configRootPath = prefix;
	232	}
	233
	234	// ----------------------------------------------------------------------------
	235	// get config object and path for it
	236	// ----------------------------------------------------------------------------
	237
	238	wxConfigBase *wxFontMapper::GetConfig()
	239	{
	240	if ( !m_config )
	241	{
	242	// try the default
	243	m_config = wxConfig::Get(FALSE /don't create on demand/ );
	244
	245	if ( !m_config )
	246	{
	247	// we still want to have a config object because otherwise we would
	248	// keep asking the user the same questions in the interactive mode,
	249	// so create a dummy config which won't write to any files/registry
	250	// but will allow us to remember the results of the questions at
	251	// least during this run
	252	m_config = new wxMemoryConfig;
	253	wxConfig::Set(m_config);
	254	}
	255	}
	256
	257	return m_config;
	258	}
	259
	260	const wxString& wxFontMapper::GetConfigPath()
	261	{
	262	if ( !m_configRootPath )
	263	{
	264	// use the default
	265	m_configRootPath = GetDefaultConfigPath();
	266	}
	267
	268	return m_configRootPath;
	269	}
	270	#endif
	271
	272	bool wxFontMapper::ChangePath(const wxString& pathNew, wxString *pathOld)
	273	{
	274	#if wxUSE_CONFIG
	275	wxConfigBase *config = GetConfig();
	276	if ( !config )
	277	return FALSE;
	278
	279	*pathOld = config->GetPath();
	280
	281	wxString path = GetConfigPath();
	282	if ( path.IsEmpty() \|\| path.Last() != wxCONFIG_PATH_SEPARATOR )
	283	{
	284	path += wxCONFIG_PATH_SEPARATOR;
	285	}
	286
	287	wxASSERT_MSG( !pathNew \|\| (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
	288	wxT("should be a relative path") );
	289
	290	path += pathNew;
	291
	292	config->SetPath(path);
	293
	294	return TRUE;
	295	#else
	296	return FALSE;
	297	#endif
	298	}
	299
	300	void wxFontMapper::RestorePath(const wxString& pathOld)
	301	{
	302	#if wxUSE_CONFIG
	303	GetConfig()->SetPath(pathOld);
	304	#else
	305	#endif
	306	}
	307
	308	// ----------------------------------------------------------------------------
	309	// charset/encoding correspondence
	310	// ----------------------------------------------------------------------------
	311
	312	/* static */
	313	wxString wxFontMapper::GetEncodingDescription(wxFontEncoding encoding)
	314	{
	315	size_t count = WXSIZEOF(gs_encodingDescs);
	316
	317	wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
	318	wxT("inconsitency detected - forgot to update one of the arrays?") );
	319
	320	for ( size_t i = 0; i < count; i++ )
	321	{
	322	if ( gs_encodings[i] == encoding )
	323	{
	324	return wxGetTranslation(gs_encodingDescs[i]);
	325	}
	326	}
	327
	328	wxString str;
	329	str.Printf(_("Unknown encoding (%d)"), encoding);
	330
	331	return str;
	332	}
	333
	334	/* static */
	335	wxString wxFontMapper::GetEncodingName(wxFontEncoding encoding)
	336	{
	337	size_t count = WXSIZEOF(gs_encodingNames);
	338
	339	wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
	340	wxT("inconsistency detected - forgot to update one of the arrays?") );
	341
	342	for ( size_t i = 0; i < count; i++ )
	343	{
	344	if ( gs_encodings[i] == encoding )
	345	{
	346	return wxGetTranslation(gs_encodingNames[i]);
	347	}
	348	}
	349
	350	wxString str;
	351	str.Printf(_("unknown-%d"), encoding);
	352
	353	return str;
	354	}
	355
	356	wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
	357	bool interactive)
	358	{
	359	wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
	360
	361	// we're going to modify it, make a copy
	362	wxString cs = charset;
	363
	364	#if wxUSE_CONFIG
	365	// first try the user-defined settings
	366	wxString pathOld;
	367	if ( ChangePath(FONTMAPPER_CHARSET_PATH, &pathOld) )
	368	{
	369	wxConfigBase *config = GetConfig();
	370
	371	// do we have an encoding for this charset?
	372	long value = config->Read(charset, -1l);
	373	if ( value != -1 )
	374	{
	375	if ( value >= 0 && value <= wxFONTENCODING_MAX )
	376	{
	377	encoding = (wxFontEncoding)value;
	378	}
	379	else
	380	{
	381	wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
	382	value, charset.c_str());
	383	}
	384	}
	385
	386	if ( encoding == wxFONTENCODING_SYSTEM )
	387	{
	388	// may be we have an alias?
	389	config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
	390
	391	wxString alias = config->Read(charset);
	392	if ( !!alias )
	393	{
	394	// yes, we do - use it instead
	395	cs = alias;
	396	}
	397	}
	398
	399	RestorePath(pathOld);
	400	}
	401	#endif
	402
	403	// if didn't find it there, try to reckognise it ourselves
	404	if ( encoding == wxFONTENCODING_SYSTEM )
	405	{
	406	// discard the optional quotes
	407	if ( !!cs )
	408	{
	409	if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
	410	{
	411	cs = wxString(cs.c_str(), cs.length() - 1);
	412	}
	413	}
	414
	415	cs.MakeUpper();
	416
	417	if ( !cs \|\| cs == wxT("US-ASCII") )
	418	encoding = wxFONTENCODING_DEFAULT;
	419	else if ( cs == wxT("KOI8-R") \|\| cs == wxT("KOI8-U") )
	420	encoding = wxFONTENCODING_KOI8;
	421	else if ( cs.Left(3) == wxT("ISO") )
	422	{
	423	// the dash is optional (or, to be exact, it is not, but
	424	// several brokenmails "forget" it)
	425	const wxChar *p = cs.c_str() + 3;
	426	if ( *p == wxT('-') )
	427	p++;
	428
	429	unsigned int value;
	430	if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
	431	{
	432	if ( value < wxFONTENCODING_ISO8859_MAX -
	433	wxFONTENCODING_ISO8859_1 )
	434	{
	435	// it's a valid ISO8859 encoding
	436	value += wxFONTENCODING_ISO8859_1 - 1;
	437	encoding = (wxFontEncoding)value;
	438	}
	439	}
	440	}
	441	else if ( cs.Left(8) == wxT("WINDOWS-") )
	442	{
	443	int value;
	444	if ( wxSscanf(cs.c_str() + 8, wxT("%u"), &value) == 1 )
	445	{
	446	if ( value >= 1250 )
	447	{
	448	value -= 1250;
	449	if ( value < wxFONTENCODING_CP12_MAX -
	450	wxFONTENCODING_CP1250 )
	451	{
	452	// a valid Windows code page
	453	value += wxFONTENCODING_CP1250;
	454	encoding = (wxFontEncoding)value;
	455	}
	456	}
	457	}
	458	}
	459	//else: unknown
	460	}
	461
	462	#if wxUSE_GUI
	463	// if still no luck, ask the user - unless disabled
	464	if ( (encoding == wxFONTENCODING_SYSTEM) && interactive )
	465	{
	466	// prepare the dialog data
	467
	468	// the dialog title
	469	wxString title(m_titleDialog);
	470	if ( !title )
	471	title << wxTheApp->GetAppName() << _(": unknown charset");
	472
	473	// the message
	474	wxString msg;
	475	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());
	476
	477	// the list of choices
	478	size_t count = WXSIZEOF(gs_encodingDescs);
	479
	480	wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
	481	wxT("inconsitency detected - forgot to update one of the arrays?") );
	482
	483	wxString *encodingNamesTranslated = new wxString[count];
	484
	485	for ( size_t i = 0; i < count; i++ )
	486	{
	487	encodingNamesTranslated[i] = wxGetTranslation(gs_encodingDescs[i]);
	488	}
	489
	490	// the parent window
	491	wxWindow *parent = m_windowParent;
	492	if ( !parent )
	493	parent = wxTheApp->GetTopWindow();
	494
	495	// do ask the user and get back the index in encodings table
	496	int n = wxGetSingleChoiceIndex(msg, title,
	497	count,
	498	encodingNamesTranslated,
	499	parent);
	500
	501	delete [] encodingNamesTranslated;
	502
	503	if ( n != -1 )
	504	{
	505	encoding = gs_encodings[n];
	506
	507	#if wxUSE_CONFIG
	508	// save the result in the config now
	509	if ( ChangePath(FONTMAPPER_CHARSET_PATH, &pathOld) )
	510	{
	511	wxConfigBase *config = GetConfig();
	512
	513	// remember the alt encoding for this charset
	514	if ( !config->Write(charset, (long)encoding) )
	515	{
	516	wxLogError(_("Failed to remember the encoding for the charset '%s'."), charset.c_str());
	517	}
	518
	519	RestorePath(pathOld);
	520	}
	521	#endif // wxUSE_CONFIG
	522	}
	523	//else: cancelled
	524	}
	525	#endif // wxUSE_GUI
	526
	527	return encoding;
	528	}
	529
	530	// ----------------------------------------------------------------------------
	531	// support for unknown encodings: we maintain a map between the
	532	// (platform-specific) strings identifying them and our wxFontEncodings they
	533	// correspond to which is used by GetFontForEncoding() function
	534	// ----------------------------------------------------------------------------
	535
	536	#if wxUSE_GUI
	537
	538	bool wxFontMapper::TestAltEncoding(const wxString& configEntry,
	539	wxFontEncoding encReplacement,
	540	wxNativeEncodingInfo *info)
	541	{
	542	if ( wxGetNativeFontEncoding(encReplacement, info) &&
	543	wxTestFontEncoding(*info) )
	544	{
	545	#if wxUSE_CONFIG
	546	// remember the mapping in the config
	547	wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);
	548
	549	if ( path.IsOk() )
	550	{
	551	GetConfig()->Write(configEntry, info->ToString());
	552	}
	553	#endif // wxUSE_CONFIG
	554	return TRUE;
	555	}
	556
	557	return FALSE;
	558	}
	559
	560	#if wxUSE_GUI
	561	class ReentrancyBlocker
	562	{
	563	public:
	564	ReentrancyBlocker(bool& b) : m_b(b) { m_b = TRUE; }
	565	~ReentrancyBlocker() { m_b = FALSE; }
	566
	567	private:
	568	bool& m_b;
	569	};
	570	#endif
	571
	572	bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
	573	wxNativeEncodingInfo *info,
	574	const wxString& facename,
	575	bool interactive)
	576	{
	577	#if wxUSE_GUI
	578	// we need a flag to prevent infinite recursion which happens, for
	579	// example, when GetAltForEncoding() is called from an OnPaint() handler:
	580	// in this case, wxYield() which is called from wxMessageBox() we use here
	581	// will lead to another call of OnPaint() and hence to another call of
	582	// GetAltForEncoding() - and it is impossible to catch this from the user
	583	// code because we are called from wxFont ctor implicitly.
	584
	585	// assume we're always called from the main thread, so that it is safe to
	586	// use a static var
	587	static bool s_inGetAltForEncoding = FALSE;
	588
	589	if ( interactive && s_inGetAltForEncoding )
	590	return FALSE;
	591
	592	ReentrancyBlocker blocker(s_inGetAltForEncoding);
	593	#endif // wxUSE_GUI
	594
	595	wxCHECK_MSG( info, FALSE, wxT("bad pointer in GetAltForEncoding") );
	596
	597	info->facename = facename;
	598
	599	if ( encoding == wxFONTENCODING_DEFAULT )
	600	{
	601	encoding = wxFont::GetDefaultEncoding();
	602	}
	603
	604	// if we failed to load the system default encoding, something is really
	605	// wrong and we'd better stop now - otherwise we will go into endless
	606	// recursion trying to create the font in the msg box with the error
	607	// message
	608	if ( encoding == wxFONTENCODING_SYSTEM )
	609	{
	610	wxFatalError(_("can't load any font, aborting"));
	611
	612	// wxFatalError doesn't return
	613	}
	614
	615	wxString configEntry, encName = GetEncodingName(encoding);
	616	if ( !!facename )
	617	{
	618	configEntry = facename + _T("_");
	619	}
	620	configEntry += encName;
	621
	622	#if wxUSE_CONFIG
	623	// do we have a font spec for this encoding?
	624	wxString pathOld;
	625	if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
	626	{
	627	wxConfigBase *config = GetConfig();
	628
	629	wxString fontinfo = config->Read(configEntry);
	630
	631	RestorePath(pathOld);
	632
	633	if ( !!fontinfo && !!facename )
	634	{
	635	// we tried to find a match with facename - now try without it
	636	fontinfo = config->Read(encName);
	637	}
	638
	639	if ( !!fontinfo )
	640	{
	641	if ( info->FromString(fontinfo) )
	642	{
	643	if ( wxTestFontEncoding(*info) )
	644	{
	645	// ok, got something
	646	return TRUE;
	647	}
	648	//else: no such fonts, look for something else
	649	}
	650	else
	651	{
	652	wxLogDebug(wxT("corrupted config data: string '%s' is not a valid font encoding info"), fontinfo.c_str());
	653	}
	654	}
	655	//else: there is no information in config about this encoding
	656	}
	657	#endif // wxUSE_CONFIG
	658
	659	// ask the user
	660	if ( interactive )
	661	{
	662	wxString title(m_titleDialog);
	663	if ( !title )
	664	title << wxTheApp->GetAppName() << _(": unknown encoding");
	665
	666	// the message
	667	wxString msg;
	668	msg.Printf(_("The encoding '%s' is unknown.\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)?"),
	669	GetEncodingDescription(encoding).c_str());
	670
	671	wxWindow *parent = m_windowParent;
	672	if ( !parent )
	673	parent = wxTheApp->GetTopWindow();
	674
	675	if ( wxMessageBox(msg, title,
	676	wxICON_QUESTION \| wxYES_NO, parent) == wxYES )
	677	{
	678	wxFontData data;
	679	data.SetEncoding(encoding);
	680	data.EncodingInfo() = *info;
	681	wxFontDialog dialog(parent, &data);
	682	if ( dialog.ShowModal() == wxID_OK )
	683	{
	684	wxFontData retData = dialog.GetFontData();
	685	wxFont font = retData.GetChosenFont();
	686
	687	*info = retData.EncodingInfo();
	688	info -> encoding = retData.GetEncoding();
	689
	690	#if wxUSE_CONFIG
	691	// remember this in the config
	692	if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
	693	{
	694	GetConfig()->Write(configEntry, info->ToString());
	695
	696	RestorePath(pathOld);
	697	}
	698	#endif
	699
	700	return TRUE;
	701	}
	702	//else: the user canceled the font selection dialog
	703	}
	704	//else: the user doesn't want to select a font
	705	}
	706	//else: we're in non-interactive mode
	707
	708	// now try the default mappings:
	709	wxFontEncodingArray equiv = wxEncodingConverter::GetAllEquivalents(encoding);
	710	size_t count = equiv.GetCount();
	711	if ( count )
	712	{
	713	for ( size_t i = (equiv[0] == encoding) ? 1 : 0; i < count; i++ )
	714	{
	715	if ( TestAltEncoding(configEntry, equiv[i], info) )
	716	return TRUE;
	717	}
	718	}
	719
	720	return FALSE;
	721	}
	722
	723	bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
	724	wxFontEncoding *alt_encoding,
	725	const wxString& facename,
	726	bool interactive)
	727	{
	728	wxNativeEncodingInfo info;
	729	bool r = GetAltForEncoding(encoding, &info, facename, interactive);
	730	*alt_encoding = info.encoding;
	731	return r;
	732	}
	733
	734	bool wxFontMapper::IsEncodingAvailable(wxFontEncoding encoding,
	735	const wxString& facename)
	736	{
	737	wxNativeEncodingInfo info;
	738
	739	if (wxGetNativeFontEncoding(encoding, &info))
	740	{
	741	info.facename = facename;
	742	return wxTestFontEncoding(info);
	743	}
	744
	745	return FALSE;
	746	}
	747
	748	#endif // wxUSE_GUI