[wxWidgets.git] / src / common / fmapbase.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        common/fmapbase.cpp
// Purpose:     wxFontMapperBase class implementation
// Author:      Vadim Zeitlin
// Modified by:
// Created:     21.06.2003 (extracted from common/fontmap.cpp)
// RCS-ID:      $Id$
// Copyright:   (c) 1999-2003 Vadim Zeitlin <vadim@wxwindows.org>
// License:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

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

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

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_FONTMAP

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

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

#include "wx/fontmap.h"
#include "wx/fmappriv.h"

#include "wx/apptrait.h"
#include "wx/module.h"

// wxMemoryConfig uses wxFileConfig
#if wxUSE_CONFIG && wxUSE_FILECONFIG
    #include "wx/config.h"
    #include "wx/memconf.h"
#endif

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

// 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_KOI8_U,
    wxFONTENCODING_CP932,
    wxFONTENCODING_CP936,
    wxFONTENCODING_CP949,
    wxFONTENCODING_CP950,
    wxFONTENCODING_CP1250,
    wxFONTENCODING_CP1251,
    wxFONTENCODING_CP1252,
    wxFONTENCODING_CP1253,
    wxFONTENCODING_CP1254,
    wxFONTENCODING_CP1255,
    wxFONTENCODING_CP1256,
    wxFONTENCODING_CP1257,
    wxFONTENCODING_CP437,
    wxFONTENCODING_UTF7,
    wxFONTENCODING_UTF8,
    wxFONTENCODING_UTF16,
    wxFONTENCODING_UTF16BE,
    wxFONTENCODING_UTF16LE,
    wxFONTENCODING_UTF32,
    wxFONTENCODING_UTF32BE,
    wxFONTENCODING_UTF32LE,
    wxFONTENCODING_EUC_JP,
};

// the descriptions for them
static const wxChar* gs_encodingDescs[] =
{
    wxTRANSLATE( "Western European (ISO-8859-1)" ),
    wxTRANSLATE( "Central European (ISO-8859-2)" ),
    wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
    wxTRANSLATE( "Baltic (old) (ISO-8859-4)" ),
    wxTRANSLATE( "Cyrillic (ISO-8859-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)" ),
    wxTRANSLATE( "KOI8-R" ),
    wxTRANSLATE( "KOI8-U" ),
    wxTRANSLATE( "Windows Japanese (CP 932)" ),
    wxTRANSLATE( "Windows Chinese Simplified (CP 936)" ),
    wxTRANSLATE( "Windows Korean (CP 949)" ),
    wxTRANSLATE( "Windows Chinese Traditional (CP 950)" ),
    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)" ),
    wxTRANSLATE( "Unicode 7 bit (UTF-7)" ),
    wxTRANSLATE( "Unicode 8 bit (UTF-8)" ),
    wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
    wxTRANSLATE( "Unicode 16 bit Big Endian (UTF-16BE)" ),
    wxTRANSLATE( "Unicode 16 bit Little Endian (UTF-16LE)" ),
    wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
    wxTRANSLATE( "Unicode 32 bit Big Endian (UTF-32BE)" ),
    wxTRANSLATE( "Unicode 32 bit Little Endian (UTF-32LE)" ),
    wxTRANSLATE( "Extended Unix Codepage for Japanese (EUC-JP)" ),
};

// and the internal names (these are not translated on purpose!)
static const wxChar* gs_encodingNames[] =
{
    wxT( "iso-8859-1" ),
    wxT( "iso-8859-2" ),
    wxT( "iso-8859-3" ),
    wxT( "iso-8859-4" ),
    wxT( "iso-8859-5" ),
    wxT( "iso-8859-6" ),
    wxT( "iso-8859-7" ),
    wxT( "iso-8859-8" ),
    wxT( "iso-8859-9" ),
    wxT( "iso-8859-10" ),
    wxT( "iso-8859-11" ),
    wxT( "iso-8859-12" ),
    wxT( "iso-8859-13" ),
    wxT( "iso-8859-14" ),
    wxT( "iso-8859-15" ),
    wxT( "koi8-r" ),
    wxT( "koi8-u" ),
    wxT( "windows-932" ),
    wxT( "windows-936" ),
    wxT( "windows-949" ),
    wxT( "windows-950" ),
    wxT( "windows-1250" ),
    wxT( "windows-1251" ),
    wxT( "windows-1252" ),
    wxT( "windows-1253" ),
    wxT( "windows-1254" ),
    wxT( "windows-1255" ),
    wxT( "windows-1256" ),
    wxT( "windows-1257" ),
    wxT( "windows-437" ),
    wxT( "utf-7" ),
    wxT( "utf-8" ),
    wxT( "utf-16" ),
    wxT( "utf-16be" ),
    wxT( "utf-16le" ),
    wxT( "utf-32" ),
    wxT( "utf-32be" ),
    wxT( "utf-32le" ),
    wxT( "euc-jp" ),
};

wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingDescs) == WXSIZEOF(gs_encodings) &&
                       WXSIZEOF(gs_encodingNames) == WXSIZEOF(gs_encodings),
                       EncodingsArraysNotInSync );

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

// clean up the font mapper object
class wxFontMapperModule : public wxModule
{
public:
    wxFontMapperModule() : wxModule() { }
    virtual bool OnInit() { return true; }
    virtual void OnExit() { delete (wxFontMapperBase*)wxFontMapperBase::Set(NULL); }

    DECLARE_DYNAMIC_CLASS(wxFontMapperModule)
};

IMPLEMENT_DYNAMIC_CLASS(wxFontMapperModule, wxModule)


// ============================================================================
// wxFontMapperBase implementation
// ============================================================================

wxFontMapper *wxFontMapperBase::sm_instance = NULL;

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

wxFontMapperBase::wxFontMapperBase()
{
#if wxUSE_CONFIG && wxUSE_FILECONFIG
    m_config = NULL;
    m_configIsDummy = false;
#endif // wxUSE_CONFIG
}

wxFontMapperBase::~wxFontMapperBase()
{
#if wxUSE_CONFIG && wxUSE_FILECONFIG
    if ( m_configIsDummy )
        delete m_config;
#endif // wxUSE_CONFIG
}

bool wxFontMapperBase::IsWxFontMapper()
{   return false; }

/* static */
wxFontMapperBase *wxFontMapperBase::Get()
{
    if ( !sm_instance )
    {
        wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
        if ( traits )
        {
            sm_instance = traits->CreateFontMapper();

            wxASSERT_MSG( sm_instance,
                            _T("wxAppTraits::CreateFontMapper() failed") );
        }

        if ( !sm_instance )
        {
            // last resort: we must create something because the existing code
            // relies on always having a valid font mapper object
            sm_instance = (wxFontMapper *)new wxFontMapperBase;
        }
    }

    return (wxFontMapperBase*)sm_instance;
}

/* static */
wxFontMapper *wxFontMapperBase::Set(wxFontMapper *mapper)
{
    wxFontMapper *old = sm_instance;
    sm_instance = mapper;
    return old;
}

#if wxUSE_CONFIG && wxUSE_FILECONFIG

// ----------------------------------------------------------------------------
// config usage customisation
// ----------------------------------------------------------------------------

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

void wxFontMapperBase::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 *wxFontMapperBase::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;
            m_configIsDummy = true;
            // VS: we can't call wxConfig::Set(m_config) here because that would
            //     disable automatic wxConfig instance creation if this code was
            //     called before wxApp::OnInit (this happens in wxGTK -- it sets
            //     default wxFont encoding in wxApp::Initialize())
        }
    }

    if ( m_configIsDummy && wxConfig::Get(false) != NULL )
    {
        // VS: in case we created dummy m_config (see above), we want to switch back
        //     to the real one as soon as one becomes available.
        delete m_config;
        m_config = wxConfig::Get(false);
        m_configIsDummy = false;
        // FIXME: ideally, we should add keys from dummy config to the real one now,
        //        but it is a low-priority task because typical wxWin application
        //        either doesn't use wxConfig at all or creates wxConfig object in
        //        wxApp::OnInit(), before any real interaction with the user takes
        //        place...
    }

    return m_config;
}

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

    return m_configRootPath;
}

// ----------------------------------------------------------------------------
// config helpers
// ----------------------------------------------------------------------------

bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
{
    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;
}

void wxFontMapperBase::RestorePath(const wxString& pathOld)
{
    GetConfig()->SetPath(pathOld);
}

#endif

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

wxFontEncoding
wxFontMapperBase::CharsetToEncoding(const wxString& charset,
                                    bool WXUNUSED(interactive))
{
    int enc = NonInteractiveCharsetToEncoding(charset);
    if ( enc == wxFONTENCODING_UNKNOWN )
    {
        // we should return wxFONTENCODING_SYSTEM from here for unknown
        // encodings
        enc = wxFONTENCODING_SYSTEM;
    }

    return (wxFontEncoding)enc;
}

int
wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
{
    wxFontEncoding encoding = wxFONTENCODING_SYSTEM;

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

#if wxUSE_CONFIG && wxUSE_FILECONFIG
    // first try the user-defined settings
    wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
    if ( path.IsOk() )
    {
        wxConfigBase *config = GetConfig();

        // do we have an encoding for this charset?
        long value = config->Read(charset, -1l);
        if ( value != -1 )
        {
            if ( value == wxFONTENCODING_UNKNOWN )
            {
                // don't try to find it, in particular don't ask the user
                return value;
            }

            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.IsEmpty() )
            {
                // yes, we do - use it instead
                cs = alias;
            }
        }
    }
#endif // wxUSE_CONFIG

    // if didn't find it there, try to recognize it ourselves
    if ( encoding == wxFONTENCODING_SYSTEM )
    {
        // trim any spaces
        cs.Trim(true);
        cs.Trim(false);

        // discard the optional quotes
        if ( !cs.empty() )
        {
            if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
            {
                cs = wxString(cs.c_str(), cs.length() - 1);
            }
        }

        cs.MakeUpper();

        if ( cs.empty() || cs == _T("US-ASCII") )
        {
            encoding = wxFONTENCODING_DEFAULT;
        }
        else if ( cs == wxT("UTF-7") )
        {
            encoding = wxFONTENCODING_UTF7;
        }
        else if ( cs == wxT("UTF-8") )
        {
            encoding = wxFONTENCODING_UTF8;
        }
        else if ( cs == wxT("UTF-16") )
        {
            encoding = wxFONTENCODING_UTF16;
        }
        else if ( cs == wxT("UTF-16BE") )
        {
            encoding = wxFONTENCODING_UTF16BE;
        }
        else if ( cs == wxT("UTF-16LE") )
        {
            encoding = wxFONTENCODING_UTF16LE;
        }
        else if ( cs == wxT("UTF-32") || cs == wxT("UCS-4") )
        {
            encoding = wxFONTENCODING_UTF32;
        }
        else if ( cs == wxT("UTF-32BE") || cs == wxT("UCS-4BE") )
        {
            encoding = wxFONTENCODING_UTF32BE;
        }
        else if ( cs == wxT("UTF-32LE") || cs == wxT("UCS-4LE") )
        {
            encoding = wxFONTENCODING_UTF32LE;
        }
        else if ( cs == wxT("GB2312") )
        {
            encoding = wxFONTENCODING_GB2312;
        }
        else if ( cs == wxT("BIG5") )
        {
            encoding = wxFONTENCODING_BIG5;
        }
        else if ( cs == wxT("SJIS") ||
                  cs == wxT("SHIFT_JIS") ||
                  cs == wxT("SHIFT-JIS") )
        {
            encoding = wxFONTENCODING_SHIFT_JIS;
        }
        else if ( cs == wxT("EUC-JP") ||
                  cs == wxT("EUC_JP") )
        {
            encoding = wxFONTENCODING_EUC_JP;
        }
        else if ( cs == wxT("EUC-KR") ||
                  cs == wxT("EUC_KR") )
        {
            encoding = wxFONTENCODING_CP949;
        }
        else if ( cs == wxT("KOI8-R") ||
                  cs == wxT("KOI8-RU") )
        {
            // although koi8-ru is not strictly speaking the same as koi8-r,
            // they are similar enough to make mapping it to koi8 better than
            // not recognizing it at all
            encoding = wxFONTENCODING_KOI8;
        }
        else if ( cs == wxT("KOI8-U") )
        {
            encoding = wxFONTENCODING_KOI8_U;
        }
        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++;

            // printf( "iso %s\n", (const char*) cs.ToAscii() );

            unsigned int value;
            if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
            {
                // printf( "value %d\n", (int)value );

                // make it 0 based and check that it is strictly positive in
                // the process (no such thing as iso8859-0 encoding)
                if ( (value-- > 0) &&
                     (value < wxFONTENCODING_ISO8859_MAX -
                              wxFONTENCODING_ISO8859_1) )
                {
                    // it's a valid ISO8859 encoding
                    value += wxFONTENCODING_ISO8859_1;
                    encoding = (wxFontEncoding)value;
                }
            }
        }
        else if ( cs.Left(4) == wxT("8859") )
        {
            const wxChar *p = cs.c_str();

            unsigned int value;
            if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
            {
                // printf( "value %d\n", (int)value );

                // make it 0 based and check that it is strictly positive in
                // the process (no such thing as iso8859-0 encoding)
                if ( (value-- > 0) &&
                     (value < wxFONTENCODING_ISO8859_MAX -
                              wxFONTENCODING_ISO8859_1) )
                {
                    // it's a valid ISO8859 encoding
                    value += wxFONTENCODING_ISO8859_1;
                    encoding = (wxFontEncoding)value;
                }
            }
        }
        else // check for Windows charsets
        {
            size_t len;
            if ( cs.Left(7) == wxT("WINDOWS") )
            {
                len = 7;
            }
            else if ( cs.Left(2) == wxT("CP") )
            {
                len = 2;
            }
            else // not a Windows encoding
            {
                len = 0;
            }

            if ( len )
            {
                const wxChar *p = cs.c_str() + len;
                if ( *p == wxT('-') )
                    p++;

                int value;
                if ( wxSscanf(p, 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;
                        }
                    }

                    switch ( value )
                    {
                        case 932:
                            encoding = wxFONTENCODING_CP932;
                            break;

                        case 936:
                            encoding = wxFONTENCODING_CP936;
                            break;

                        case 949:
                            encoding = wxFONTENCODING_CP949;
                            break;

                        case 950:
                            encoding = wxFONTENCODING_CP950;
                            break;
                    }
                }
            }
        }
        //else: unknown
    }

    return encoding;
}

/* static */
size_t wxFontMapperBase::GetSupportedEncodingsCount()
{
    return WXSIZEOF(gs_encodings);
}

/* static */
wxFontEncoding wxFontMapperBase::GetEncoding(size_t n)
{
    wxCHECK_MSG( n < WXSIZEOF(gs_encodings), wxFONTENCODING_SYSTEM,
                    _T("wxFontMapper::GetEncoding(): invalid index") );

    return gs_encodings[n];
}

/* static */
wxString wxFontMapperBase::GetEncodingDescription(wxFontEncoding encoding)
{
    if ( encoding == wxFONTENCODING_DEFAULT )
    {
        return _("Default encoding");
    }

    const size_t count = WXSIZEOF(gs_encodingDescs);

    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 wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
{
    if ( encoding == wxFONTENCODING_DEFAULT )
    {
        return _("default");
    }

    const size_t count = WXSIZEOF(gs_encodingNames);

    for ( size_t i = 0; i < count; i++ )
    {
        if ( gs_encodings[i] == encoding )
        {
            return gs_encodingNames[i];
        }
    }

    wxString str;
    str.Printf(_("unknown-%d"), encoding);

    return str;
}

/* static */
wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
{
    const size_t count = WXSIZEOF(gs_encodingNames);

    for ( size_t i = 0; i < count; i++ )
    {
        if ( gs_encodingNames[i] == name )
        {
            return gs_encodings[i];
        }
    }

    if ( name == _("default") )
    {
        return wxFONTENCODING_DEFAULT;
    }

    return wxFONTENCODING_MAX;
}

#endif // wxUSE_FONTMAP
Commit	Line	Data
e2478fde VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: common/fmapbase.cpp
	3	// Purpose: wxFontMapperBase class implementation
	4	// Author: Vadim Zeitlin
	5	// Modified by:
	6	// Created: 21.06.2003 (extracted from common/fontmap.cpp)
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1999-2003 Vadim Zeitlin <vadim@wxwindows.org>
0a53b9b8	9	// License: wxWindows license
e2478fde VZ	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	#ifndef WX_PRECOMP
	30	#include "wx/app.h"
	31	#include "wx/log.h"
	32	#include "wx/intl.h"
	33	#endif //WX_PRECOMP
	34
1c193821 JS	35	#if defined(__WXMSW__)
	36	#include "wx/msw/private.h" // includes windows.h for LOGFONT
	37	#include "wx/msw/winundef.h"
	38	#endif
	39
e2478fde VZ	40	#include "wx/fontmap.h"
	41	#include "wx/fmappriv.h"
	42
	43	#include "wx/apptrait.h"
	44	#include "wx/module.h"
	45
4676948b JS	46	// wxMemoryConfig uses wxFileConfig
4676948b JS	47	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde VZ	48	#include "wx/config.h"
	49	#include "wx/memconf.h"
	50	#endif
	51
	52	// ----------------------------------------------------------------------------
	53	// constants
	54	// ----------------------------------------------------------------------------
	55
	56	// encodings supported by GetEncodingDescription
	57	static wxFontEncoding gs_encodings[] =
	58	{
	59	wxFONTENCODING_ISO8859_1,
	60	wxFONTENCODING_ISO8859_2,
	61	wxFONTENCODING_ISO8859_3,
	62	wxFONTENCODING_ISO8859_4,
	63	wxFONTENCODING_ISO8859_5,
	64	wxFONTENCODING_ISO8859_6,
	65	wxFONTENCODING_ISO8859_7,
	66	wxFONTENCODING_ISO8859_8,
	67	wxFONTENCODING_ISO8859_9,
	68	wxFONTENCODING_ISO8859_10,
	69	wxFONTENCODING_ISO8859_11,
	70	wxFONTENCODING_ISO8859_12,
	71	wxFONTENCODING_ISO8859_13,
	72	wxFONTENCODING_ISO8859_14,
	73	wxFONTENCODING_ISO8859_15,
	74	wxFONTENCODING_KOI8,
15ad38c3	75	wxFONTENCODING_KOI8_U,
e2478fde VZ	76	wxFONTENCODING_CP932,
	77	wxFONTENCODING_CP936,
	78	wxFONTENCODING_CP949,
	79	wxFONTENCODING_CP950,
	80	wxFONTENCODING_CP1250,
	81	wxFONTENCODING_CP1251,
	82	wxFONTENCODING_CP1252,
	83	wxFONTENCODING_CP1253,
	84	wxFONTENCODING_CP1254,
	85	wxFONTENCODING_CP1255,
	86	wxFONTENCODING_CP1256,
	87	wxFONTENCODING_CP1257,
	88	wxFONTENCODING_CP437,
	89	wxFONTENCODING_UTF7,
	90	wxFONTENCODING_UTF8,
c91830cb VZ	91	wxFONTENCODING_UTF16,
	92	wxFONTENCODING_UTF16BE,
	93	wxFONTENCODING_UTF16LE,
	94	wxFONTENCODING_UTF32,
	95	wxFONTENCODING_UTF32BE,
	96	wxFONTENCODING_UTF32LE,
e2478fde VZ	97	wxFONTENCODING_EUC_JP,
	98	};
	99
	100	// the descriptions for them
	101	static const wxChar* gs_encodingDescs[] =
	102	{
	103	wxTRANSLATE( "Western European (ISO-8859-1)" ),
	104	wxTRANSLATE( "Central European (ISO-8859-2)" ),
	105	wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
	106	wxTRANSLATE( "Baltic (old) (ISO-8859-4)" ),
	107	wxTRANSLATE( "Cyrillic (ISO-8859-5)" ),
	108	wxTRANSLATE( "Arabic (ISO-8859-6)" ),
	109	wxTRANSLATE( "Greek (ISO-8859-7)" ),
	110	wxTRANSLATE( "Hebrew (ISO-8859-8)" ),
	111	wxTRANSLATE( "Turkish (ISO-8859-9)" ),
	112	wxTRANSLATE( "Nordic (ISO-8859-10)" ),
	113	wxTRANSLATE( "Thai (ISO-8859-11)" ),
	114	wxTRANSLATE( "Indian (ISO-8859-12)" ),
	115	wxTRANSLATE( "Baltic (ISO-8859-13)" ),
	116	wxTRANSLATE( "Celtic (ISO-8859-14)" ),
	117	wxTRANSLATE( "Western European with Euro (ISO-8859-15)" ),
	118	wxTRANSLATE( "KOI8-R" ),
15ad38c3	119	wxTRANSLATE( "KOI8-U" ),
e2478fde VZ	120	wxTRANSLATE( "Windows Japanese (CP 932)" ),
	121	wxTRANSLATE( "Windows Chinese Simplified (CP 936)" ),
	122	wxTRANSLATE( "Windows Korean (CP 949)" ),
	123	wxTRANSLATE( "Windows Chinese Traditional (CP 950)" ),
	124	wxTRANSLATE( "Windows Central European (CP 1250)" ),
	125	wxTRANSLATE( "Windows Cyrillic (CP 1251)" ),
	126	wxTRANSLATE( "Windows Western European (CP 1252)" ),
	127	wxTRANSLATE( "Windows Greek (CP 1253)" ),
	128	wxTRANSLATE( "Windows Turkish (CP 1254)" ),
	129	wxTRANSLATE( "Windows Hebrew (CP 1255)" ),
	130	wxTRANSLATE( "Windows Arabic (CP 1256)" ),
	131	wxTRANSLATE( "Windows Baltic (CP 1257)" ),
	132	wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
	133	wxTRANSLATE( "Unicode 7 bit (UTF-7)" ),
	134	wxTRANSLATE( "Unicode 8 bit (UTF-8)" ),
c91830cb VZ	135	wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
	136	wxTRANSLATE( "Unicode 16 bit Big Endian (UTF-16BE)" ),
	137	wxTRANSLATE( "Unicode 16 bit Little Endian (UTF-16LE)" ),
	138	wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
	139	wxTRANSLATE( "Unicode 32 bit Big Endian (UTF-32BE)" ),
	140	wxTRANSLATE( "Unicode 32 bit Little Endian (UTF-32LE)" ),
e2478fde VZ	141	wxTRANSLATE( "Extended Unix Codepage for Japanese (EUC-JP)" ),
	142	};
	143
	144	// and the internal names (these are not translated on purpose!)
	145	static const wxChar* gs_encodingNames[] =
	146	{
	147	wxT( "iso-8859-1" ),
	148	wxT( "iso-8859-2" ),
	149	wxT( "iso-8859-3" ),
	150	wxT( "iso-8859-4" ),
	151	wxT( "iso-8859-5" ),
	152	wxT( "iso-8859-6" ),
	153	wxT( "iso-8859-7" ),
	154	wxT( "iso-8859-8" ),
	155	wxT( "iso-8859-9" ),
	156	wxT( "iso-8859-10" ),
	157	wxT( "iso-8859-11" ),
	158	wxT( "iso-8859-12" ),
	159	wxT( "iso-8859-13" ),
	160	wxT( "iso-8859-14" ),
	161	wxT( "iso-8859-15" ),
	162	wxT( "koi8-r" ),
15ad38c3	163	wxT( "koi8-u" ),
e2478fde VZ	164	wxT( "windows-932" ),
	165	wxT( "windows-936" ),
	166	wxT( "windows-949" ),
	167	wxT( "windows-950" ),
	168	wxT( "windows-1250" ),
	169	wxT( "windows-1251" ),
	170	wxT( "windows-1252" ),
	171	wxT( "windows-1253" ),
	172	wxT( "windows-1254" ),
	173	wxT( "windows-1255" ),
	174	wxT( "windows-1256" ),
	175	wxT( "windows-1257" ),
	176	wxT( "windows-437" ),
	177	wxT( "utf-7" ),
	178	wxT( "utf-8" ),
c91830cb VZ	179	wxT( "utf-16" ),
	180	wxT( "utf-16be" ),
	181	wxT( "utf-16le" ),
	182	wxT( "utf-32" ),
	183	wxT( "utf-32be" ),
	184	wxT( "utf-32le" ),
e2478fde VZ	185	wxT( "euc-jp" ),
	186	};
	187
	188	wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingDescs) == WXSIZEOF(gs_encodings) &&
	189	WXSIZEOF(gs_encodingNames) == WXSIZEOF(gs_encodings),
	190	EncodingsArraysNotInSync );
	191
	192	// ----------------------------------------------------------------------------
	193	// private classes
	194	// ----------------------------------------------------------------------------
	195
	196	// clean up the font mapper object
	197	class wxFontMapperModule : public wxModule
	198	{
	199	public:
	200	wxFontMapperModule() : wxModule() { }
a62848fd	201	virtual bool OnInit() { return true; }
2a12cc65	202	virtual void OnExit() { delete (wxFontMapperBase*)wxFontMapperBase::Set(NULL); }
e2478fde VZ	203
	204	DECLARE_DYNAMIC_CLASS(wxFontMapperModule)
	205	};
	206
	207	IMPLEMENT_DYNAMIC_CLASS(wxFontMapperModule, wxModule)
	208
	209
	210	// ============================================================================
	211	// wxFontMapperBase implementation
	212	// ============================================================================
	213
	214	wxFontMapper *wxFontMapperBase::sm_instance = NULL;
	215
	216	// ----------------------------------------------------------------------------
	217	// ctor and dtor
	218	// ----------------------------------------------------------------------------
	219
	220	wxFontMapperBase::wxFontMapperBase()
	221	{
4676948b	222	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde	223	m_config = NULL;
a62848fd	224	m_configIsDummy = false;
e2478fde VZ	225	#endif // wxUSE_CONFIG
	226	}
	227
	228	wxFontMapperBase::~wxFontMapperBase()
	229	{
4676948b	230	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde VZ	231	if ( m_configIsDummy )
	232	delete m_config;
	233	#endif // wxUSE_CONFIG
	234	}
	235
2a12cc65 DE	236	bool wxFontMapperBase::IsWxFontMapper()
	237	{ return false; }
	238
e2478fde	239	/* static */
73302af6	240	wxFontMapperBase *wxFontMapperBase::Get()
e2478fde VZ	241	{
	242	if ( !sm_instance )
	243	{
	244	wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
	245	if ( traits )
	246	{
	247	sm_instance = traits->CreateFontMapper();
	248
	249	wxASSERT_MSG( sm_instance,
	250	_T("wxAppTraits::CreateFontMapper() failed") );
	251	}
	252
	253	if ( !sm_instance )
	254	{
	255	// last resort: we must create something because the existing code
	256	// relies on always having a valid font mapper object
	257	sm_instance = (wxFontMapper *)new wxFontMapperBase;
	258	}
	259	}
	260
73302af6	261	return (wxFontMapperBase*)sm_instance;
e2478fde VZ	262	}
	263
	264	/* static */
	265	wxFontMapper wxFontMapperBase::Set(wxFontMapper mapper)
	266	{
	267	wxFontMapper *old = sm_instance;
	268	sm_instance = mapper;
	269	return old;
	270	}
	271
4676948b	272	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde VZ	273
	274	// ----------------------------------------------------------------------------
	275	// config usage customisation
	276	// ----------------------------------------------------------------------------
	277
	278	/* static */
	279	const wxChar *wxFontMapperBase::GetDefaultConfigPath()
	280	{
	281	return FONTMAPPER_ROOT_PATH;
	282	}
	283
	284	void wxFontMapperBase::SetConfigPath(const wxString& prefix)
	285	{
	286	wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
	287	wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
	288
	289	m_configRootPath = prefix;
	290	}
	291
	292	// ----------------------------------------------------------------------------
	293	// get config object and path for it
	294	// ----------------------------------------------------------------------------
	295
	296	wxConfigBase *wxFontMapperBase::GetConfig()
	297	{
	298	if ( !m_config )
	299	{
	300	// try the default
a62848fd	301	m_config = wxConfig::Get(false /don't create on demand/ );
e2478fde VZ	302
	303	if ( !m_config )
	304	{
	305	// we still want to have a config object because otherwise we would
	306	// keep asking the user the same questions in the interactive mode,
	307	// so create a dummy config which won't write to any files/registry
	308	// but will allow us to remember the results of the questions at
	309	// least during this run
	310	m_config = new wxMemoryConfig;
a62848fd	311	m_configIsDummy = true;
e2478fde VZ	312	// VS: we can't call wxConfig::Set(m_config) here because that would
	313	// disable automatic wxConfig instance creation if this code was
	314	// called before wxApp::OnInit (this happens in wxGTK -- it sets
	315	// default wxFont encoding in wxApp::Initialize())
	316	}
	317	}
	318
a62848fd	319	if ( m_configIsDummy && wxConfig::Get(false) != NULL )
e2478fde VZ	320	{
	321	// VS: in case we created dummy m_config (see above), we want to switch back
	322	// to the real one as soon as one becomes available.
	323	delete m_config;
a62848fd WS	324	m_config = wxConfig::Get(false);
a62848fd WS	325	m_configIsDummy = false;
e2478fde VZ	326	// FIXME: ideally, we should add keys from dummy config to the real one now,
	327	// but it is a low-priority task because typical wxWin application
	328	// either doesn't use wxConfig at all or creates wxConfig object in
	329	// wxApp::OnInit(), before any real interaction with the user takes
	330	// place...
	331	}
	332
	333	return m_config;
	334	}
	335
	336	const wxString& wxFontMapperBase::GetConfigPath()
	337	{
	338	if ( !m_configRootPath )
	339	{
	340	// use the default
	341	m_configRootPath = GetDefaultConfigPath();
	342	}
	343
	344	return m_configRootPath;
	345	}
	346
	347	// ----------------------------------------------------------------------------
	348	// config helpers
	349	// ----------------------------------------------------------------------------
	350
	351	bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
	352	{
	353	wxConfigBase *config = GetConfig();
	354	if ( !config )
a62848fd	355	return false;
e2478fde VZ	356
	357	*pathOld = config->GetPath();
	358
	359	wxString path = GetConfigPath();
	360	if ( path.IsEmpty() \|\| path.Last() != wxCONFIG_PATH_SEPARATOR )
	361	{
	362	path += wxCONFIG_PATH_SEPARATOR;
	363	}
	364
	365	wxASSERT_MSG( !pathNew \|\| (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
	366	wxT("should be a relative path") );
	367
	368	path += pathNew;
	369
	370	config->SetPath(path);
	371
a62848fd	372	return true;
e2478fde VZ	373	}
	374
	375	void wxFontMapperBase::RestorePath(const wxString& pathOld)
	376	{
	377	GetConfig()->SetPath(pathOld);
	378	}
	379
f1c75e0f JS	380	#endif
f1c75e0f JS	381
e2478fde VZ	382	// ----------------------------------------------------------------------------
	383	// charset/encoding correspondence
	384	// ----------------------------------------------------------------------------
	385
	386	wxFontEncoding
	387	wxFontMapperBase::CharsetToEncoding(const wxString& charset,
	388	bool WXUNUSED(interactive))
4dc55027 VZ	389	{
	390	int enc = NonInteractiveCharsetToEncoding(charset);
	391	if ( enc == wxFONTENCODING_UNKNOWN )
	392	{
	393	// we should return wxFONTENCODING_SYSTEM from here for unknown
	394	// encodings
	395	enc = wxFONTENCODING_SYSTEM;
	396	}
	397
	398	return (wxFontEncoding)enc;
	399	}
	400
	401	int
	402	wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
e2478fde VZ	403	{
	404	wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
	405
	406	// we're going to modify it, make a copy
	407	wxString cs = charset;
	408
4676948b	409	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde VZ	410	// first try the user-defined settings
	411	wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
	412	if ( path.IsOk() )
	413	{
	414	wxConfigBase *config = GetConfig();
	415
	416	// do we have an encoding for this charset?
	417	long value = config->Read(charset, -1l);
	418	if ( value != -1 )
	419	{
	420	if ( value == wxFONTENCODING_UNKNOWN )
	421	{
	422	// don't try to find it, in particular don't ask the user
4dc55027	423	return value;
e2478fde VZ	424	}
	425
	426	if ( value >= 0 && value <= wxFONTENCODING_MAX )
	427	{
	428	encoding = (wxFontEncoding)value;
	429	}
	430	else
	431	{
	432	wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
	433	value, charset.c_str());
	434	}
	435	}
	436
	437	if ( encoding == wxFONTENCODING_SYSTEM )
	438	{
	439	// may be we have an alias?
	440	config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
	441
	442	wxString alias = config->Read(charset);
a62848fd	443	if ( !alias.IsEmpty() )
e2478fde VZ	444	{
	445	// yes, we do - use it instead
	446	cs = alias;
	447	}
	448	}
	449	}
	450	#endif // wxUSE_CONFIG
	451
	452	// if didn't find it there, try to recognize it ourselves
	453	if ( encoding == wxFONTENCODING_SYSTEM )
	454	{
	455	// trim any spaces
	456	cs.Trim(true);
	457	cs.Trim(false);
	458
	459	// discard the optional quotes
	460	if ( !cs.empty() )
	461	{
	462	if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
	463	{
	464	cs = wxString(cs.c_str(), cs.length() - 1);
	465	}
	466	}
	467
	468	cs.MakeUpper();
	469
	470	if ( cs.empty() \|\| cs == _T("US-ASCII") )
	471	{
	472	encoding = wxFONTENCODING_DEFAULT;
	473	}
	474	else if ( cs == wxT("UTF-7") )
	475	{
	476	encoding = wxFONTENCODING_UTF7;
	477	}
	478	else if ( cs == wxT("UTF-8") )
	479	{
	480	encoding = wxFONTENCODING_UTF8;
	481	}
c91830cb VZ	482	else if ( cs == wxT("UTF-16") )
	483	{
	484	encoding = wxFONTENCODING_UTF16;
	485	}
	486	else if ( cs == wxT("UTF-16BE") )
	487	{
	488	encoding = wxFONTENCODING_UTF16BE;
	489	}
	490	else if ( cs == wxT("UTF-16LE") )
	491	{
	492	encoding = wxFONTENCODING_UTF16LE;
	493	}
	494	else if ( cs == wxT("UTF-32") \|\| cs == wxT("UCS-4") )
	495	{
	496	encoding = wxFONTENCODING_UTF32;
	497	}
	498	else if ( cs == wxT("UTF-32BE") \|\| cs == wxT("UCS-4BE") )
	499	{
	500	encoding = wxFONTENCODING_UTF32BE;
	501	}
	502	else if ( cs == wxT("UTF-32LE") \|\| cs == wxT("UCS-4LE") )
	503	{
	504	encoding = wxFONTENCODING_UTF32LE;
	505	}
e2478fde VZ	506	else if ( cs == wxT("GB2312") )
	507	{
	508	encoding = wxFONTENCODING_GB2312;
	509	}
	510	else if ( cs == wxT("BIG5") )
	511	{
	512	encoding = wxFONTENCODING_BIG5;
	513	}
	514	else if ( cs == wxT("SJIS") \|\|
	515	cs == wxT("SHIFT_JIS") \|\|
	516	cs == wxT("SHIFT-JIS") )
	517	{
	518	encoding = wxFONTENCODING_SHIFT_JIS;
	519	}
	520	else if ( cs == wxT("EUC-JP") \|\|
	521	cs == wxT("EUC_JP") )
	522	{
	523	encoding = wxFONTENCODING_EUC_JP;
	524	}
51a4142c VZ	525	else if ( cs == wxT("EUC-KR") \|\|
	526	cs == wxT("EUC_KR") )
	527	{
	528	encoding = wxFONTENCODING_CP949;
a62848fd	529	}
e2478fde	530	else if ( cs == wxT("KOI8-R") \|\|
e2478fde VZ	531	cs == wxT("KOI8-RU") )
	532	{
	533	// although koi8-ru is not strictly speaking the same as koi8-r,
	534	// they are similar enough to make mapping it to koi8 better than
15ad38c3	535	// not recognizing it at all
e2478fde VZ	536	encoding = wxFONTENCODING_KOI8;
e2478fde VZ	537	}
15ad38c3 VZ	538	else if ( cs == wxT("KOI8-U") )
	539	{
	540	encoding = wxFONTENCODING_KOI8_U;
	541	}
e2478fde VZ	542	else if ( cs.Left(3) == wxT("ISO") )
	543	{
	544	// the dash is optional (or, to be exact, it is not, but
	545	// several brokenmails "forget" it)
	546	const wxChar *p = cs.c_str() + 3;
	547	if ( *p == wxT('-') )
	548	p++;
a62848fd	549
e2478fde VZ	550	// printf( "iso %s\n", (const char*) cs.ToAscii() );
	551
	552	unsigned int value;
	553	if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
	554	{
	555	// printf( "value %d\n", (int)value );
a62848fd	556
e2478fde VZ	557	// make it 0 based and check that it is strictly positive in
	558	// the process (no such thing as iso8859-0 encoding)
	559	if ( (value-- > 0) &&
	560	(value < wxFONTENCODING_ISO8859_MAX -
	561	wxFONTENCODING_ISO8859_1) )
	562	{
	563	// it's a valid ISO8859 encoding
	564	value += wxFONTENCODING_ISO8859_1;
	565	encoding = (wxFontEncoding)value;
	566	}
	567	}
	568	}
	569	else if ( cs.Left(4) == wxT("8859") )
	570	{
	571	const wxChar *p = cs.c_str();
a62848fd	572
e2478fde VZ	573	unsigned int value;
	574	if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
	575	{
	576	// printf( "value %d\n", (int)value );
a62848fd	577
e2478fde VZ	578	// make it 0 based and check that it is strictly positive in
	579	// the process (no such thing as iso8859-0 encoding)
	580	if ( (value-- > 0) &&
	581	(value < wxFONTENCODING_ISO8859_MAX -
	582	wxFONTENCODING_ISO8859_1) )
	583	{
	584	// it's a valid ISO8859 encoding
	585	value += wxFONTENCODING_ISO8859_1;
	586	encoding = (wxFontEncoding)value;
	587	}
	588	}
	589	}
	590	else // check for Windows charsets
	591	{
	592	size_t len;
	593	if ( cs.Left(7) == wxT("WINDOWS") )
	594	{
	595	len = 7;
	596	}
	597	else if ( cs.Left(2) == wxT("CP") )
	598	{
	599	len = 2;
	600	}
	601	else // not a Windows encoding
	602	{
	603	len = 0;
	604	}
	605
	606	if ( len )
	607	{
	608	const wxChar *p = cs.c_str() + len;
	609	if ( *p == wxT('-') )
	610	p++;
	611
	612	int value;
	613	if ( wxSscanf(p, wxT("%u"), &value) == 1 )
	614	{
	615	if ( value >= 1250 )
	616	{
	617	value -= 1250;
	618	if ( value < wxFONTENCODING_CP12_MAX -
	619	wxFONTENCODING_CP1250 )
	620	{
	621	// a valid Windows code page
	622	value += wxFONTENCODING_CP1250;
	623	encoding = (wxFontEncoding)value;
	624	}
	625	}
	626
	627	switch ( value )
	628	{
	629	case 932:
	630	encoding = wxFONTENCODING_CP932;
	631	break;
	632
	633	case 936:
	634	encoding = wxFONTENCODING_CP936;
	635	break;
	636
	637	case 949:
	638	encoding = wxFONTENCODING_CP949;
	639	break;
	640
	641	case 950:
642	encoding = wxFONTENCODING_CP950;
643	break;
644	}
645	}
646	}
647	}
648	//else: unknown
649	}
650
651	return encoding;
652	}
653
654	/* static */
655	size_t wxFontMapperBase::GetSupportedEncodingsCount()
656	{
657	return WXSIZEOF(gs_encodings);
658	}
659
660	/* static */
661	wxFontEncoding wxFontMapperBase::GetEncoding(size_t n)
662	{
663	wxCHECK_MSG( n < WXSIZEOF(gs_encodings), wxFONTENCODING_SYSTEM,
664	_T("wxFontMapper::GetEncoding(): invalid index") );
665
666	return gs_encodings[n];
667	}
668
669	/* static */
670	wxString wxFontMapperBase::GetEncodingDescription(wxFontEncoding encoding)
671	{
672	if ( encoding == wxFONTENCODING_DEFAULT )
673	{
674	return _("Default encoding");
675	}
676
677	const size_t count = WXSIZEOF(gs_encodingDescs);
678
679	for ( size_t i = 0; i < count; i++ )
680	{
681	if ( gs_encodings[i] == encoding )
682	{
683	return wxGetTranslation(gs_encodingDescs[i]);
684	}
685	}
686
687	wxString str;
688	str.Printf(_("Unknown encoding (%d)"), encoding);
689
690	return str;
691	}
692
693	/* static */
694	wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
695	{
696	if ( encoding == wxFONTENCODING_DEFAULT )
697	{
698	return _("default");
699	}
700
701	const size_t count = WXSIZEOF(gs_encodingNames);
702
703	for ( size_t i = 0; i < count; i++ )
704	{
705	if ( gs_encodings[i] == encoding )
706	{
707	return gs_encodingNames[i];
708	}
709	}
710
711	wxString str;
712	str.Printf(_("unknown-%d"), encoding);
713
714	return str;
715	}
716
910b9fc5 VZ	717	/* static */
	718	wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
	719	{
	720	const size_t count = WXSIZEOF(gs_encodingNames);
	721
	722	for ( size_t i = 0; i < count; i++ )
	723	{
	724	if ( gs_encodingNames[i] == name )
	725	{
	726	return gs_encodings[i];
	727	}
	728	}
	729
	730	if ( name == _("default") )
	731	{
	732	return wxFONTENCODING_DEFAULT;
	733	}
	734
	735	return wxFONTENCODING_MAX;
	736	}
	737
e2478fde VZ	738	#endif // wxUSE_FONTMAP
e2478fde VZ	739