[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 wxFontMapper::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
}

/* static */
wxFontMapper *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 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 )
            {
                // 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() { }
	201	virtual bool OnInit() { return TRUE; }
	202	virtual void OnExit() { delete wxFontMapper::Set(NULL); }
	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 VZ	223	m_config = NULL;
	224	m_configIsDummy = FALSE;
	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
	236	/* static */
	237	wxFontMapper *wxFontMapperBase::Get()
	238	{
	239	if ( !sm_instance )
	240	{
	241	wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
	242	if ( traits )
	243	{
	244	sm_instance = traits->CreateFontMapper();
	245
	246	wxASSERT_MSG( sm_instance,
	247	_T("wxAppTraits::CreateFontMapper() failed") );
	248	}
	249
	250	if ( !sm_instance )
	251	{
	252	// last resort: we must create something because the existing code
	253	// relies on always having a valid font mapper object
	254	sm_instance = (wxFontMapper *)new wxFontMapperBase;
	255	}
	256	}
	257
	258	return sm_instance;
	259	}
	260
	261	/* static */
	262	wxFontMapper wxFontMapperBase::Set(wxFontMapper mapper)
	263	{
	264	wxFontMapper *old = sm_instance;
	265	sm_instance = mapper;
	266	return old;
	267	}
	268
4676948b	269	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde VZ	270
	271	// ----------------------------------------------------------------------------
	272	// config usage customisation
	273	// ----------------------------------------------------------------------------
	274
	275	/* static */
	276	const wxChar *wxFontMapperBase::GetDefaultConfigPath()
	277	{
	278	return FONTMAPPER_ROOT_PATH;
	279	}
	280
	281	void wxFontMapperBase::SetConfigPath(const wxString& prefix)
	282	{
	283	wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
	284	wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
	285
	286	m_configRootPath = prefix;
	287	}
	288
	289	// ----------------------------------------------------------------------------
	290	// get config object and path for it
	291	// ----------------------------------------------------------------------------
	292
	293	wxConfigBase *wxFontMapperBase::GetConfig()
	294	{
	295	if ( !m_config )
	296	{
	297	// try the default
	298	m_config = wxConfig::Get(FALSE /don't create on demand/ );
	299
	300	if ( !m_config )
	301	{
	302	// we still want to have a config object because otherwise we would
	303	// keep asking the user the same questions in the interactive mode,
	304	// so create a dummy config which won't write to any files/registry
	305	// but will allow us to remember the results of the questions at
	306	// least during this run
	307	m_config = new wxMemoryConfig;
	308	m_configIsDummy = TRUE;
	309	// VS: we can't call wxConfig::Set(m_config) here because that would
	310	// disable automatic wxConfig instance creation if this code was
	311	// called before wxApp::OnInit (this happens in wxGTK -- it sets
	312	// default wxFont encoding in wxApp::Initialize())
	313	}
	314	}
	315
	316	if ( m_configIsDummy && wxConfig::Get(FALSE) != NULL )
	317	{
	318	// VS: in case we created dummy m_config (see above), we want to switch back
	319	// to the real one as soon as one becomes available.
	320	delete m_config;
	321	m_config = wxConfig::Get(FALSE);
	322	m_configIsDummy = FALSE;
	323	// FIXME: ideally, we should add keys from dummy config to the real one now,
	324	// but it is a low-priority task because typical wxWin application
	325	// either doesn't use wxConfig at all or creates wxConfig object in
	326	// wxApp::OnInit(), before any real interaction with the user takes
	327	// place...
	328	}
	329
	330	return m_config;
	331	}
	332
	333	const wxString& wxFontMapperBase::GetConfigPath()
334	{
335	if ( !m_configRootPath )
336	{
337	// use the default
338	m_configRootPath = GetDefaultConfigPath();
339	}
340
341	return m_configRootPath;
342	}
343
344	// ----------------------------------------------------------------------------
345	// config helpers
346	// ----------------------------------------------------------------------------
347
348	bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
349	{
350	wxConfigBase *config = GetConfig();
351	if ( !config )
352	return FALSE;
353
354	*pathOld = config->GetPath();
355
356	wxString path = GetConfigPath();
357	if ( path.IsEmpty() \|\| path.Last() != wxCONFIG_PATH_SEPARATOR )
358	{
359	path += wxCONFIG_PATH_SEPARATOR;
360	}
361
362	wxASSERT_MSG( !pathNew \|\| (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
363	wxT("should be a relative path") );
364
365	path += pathNew;
366
367	config->SetPath(path);
368
369	return TRUE;
370	}
371
372	void wxFontMapperBase::RestorePath(const wxString& pathOld)
373	{
374	GetConfig()->SetPath(pathOld);
375	}
376
f1c75e0f JS	377	#endif
f1c75e0f JS	378
e2478fde VZ	379	// ----------------------------------------------------------------------------
	380	// charset/encoding correspondence
	381	// ----------------------------------------------------------------------------
	382
	383	wxFontEncoding
	384	wxFontMapperBase::CharsetToEncoding(const wxString& charset,
	385	bool WXUNUSED(interactive))
4dc55027 VZ	386	{
	387	int enc = NonInteractiveCharsetToEncoding(charset);
	388	if ( enc == wxFONTENCODING_UNKNOWN )
	389	{
	390	// we should return wxFONTENCODING_SYSTEM from here for unknown
	391	// encodings
	392	enc = wxFONTENCODING_SYSTEM;
	393	}
	394
	395	return (wxFontEncoding)enc;
	396	}
	397
	398	int
	399	wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
e2478fde VZ	400	{
	401	wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
	402
	403	// we're going to modify it, make a copy
	404	wxString cs = charset;
	405
4676948b	406	#if wxUSE_CONFIG && wxUSE_FILECONFIG
e2478fde VZ	407	// first try the user-defined settings
	408	wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
	409	if ( path.IsOk() )
	410	{
	411	wxConfigBase *config = GetConfig();
	412
	413	// do we have an encoding for this charset?
	414	long value = config->Read(charset, -1l);
	415	if ( value != -1 )
	416	{
	417	if ( value == wxFONTENCODING_UNKNOWN )
	418	{
	419	// don't try to find it, in particular don't ask the user
4dc55027	420	return value;
e2478fde VZ	421	}
	422
	423	if ( value >= 0 && value <= wxFONTENCODING_MAX )
	424	{
	425	encoding = (wxFontEncoding)value;
	426	}
	427	else
	428	{
	429	wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
	430	value, charset.c_str());
	431	}
	432	}
	433
	434	if ( encoding == wxFONTENCODING_SYSTEM )
	435	{
	436	// may be we have an alias?
	437	config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
	438
	439	wxString alias = config->Read(charset);
	440	if ( !!alias )
	441	{
	442	// yes, we do - use it instead
	443	cs = alias;
	444	}
	445	}
	446	}
	447	#endif // wxUSE_CONFIG
	448
	449	// if didn't find it there, try to recognize it ourselves
	450	if ( encoding == wxFONTENCODING_SYSTEM )
	451	{
	452	// trim any spaces
	453	cs.Trim(true);
	454	cs.Trim(false);
	455
	456	// discard the optional quotes
	457	if ( !cs.empty() )
	458	{
	459	if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
	460	{
	461	cs = wxString(cs.c_str(), cs.length() - 1);
	462	}
	463	}
	464
	465	cs.MakeUpper();
	466
	467	if ( cs.empty() \|\| cs == _T("US-ASCII") )
	468	{
	469	encoding = wxFONTENCODING_DEFAULT;
	470	}
	471	else if ( cs == wxT("UTF-7") )
	472	{
	473	encoding = wxFONTENCODING_UTF7;
	474	}
	475	else if ( cs == wxT("UTF-8") )
	476	{
	477	encoding = wxFONTENCODING_UTF8;
	478	}
c91830cb VZ	479	else if ( cs == wxT("UTF-16") )
	480	{
	481	encoding = wxFONTENCODING_UTF16;
	482	}
	483	else if ( cs == wxT("UTF-16BE") )
	484	{
	485	encoding = wxFONTENCODING_UTF16BE;
	486	}
	487	else if ( cs == wxT("UTF-16LE") )
	488	{
	489	encoding = wxFONTENCODING_UTF16LE;
	490	}
	491	else if ( cs == wxT("UTF-32") \|\| cs == wxT("UCS-4") )
	492	{
	493	encoding = wxFONTENCODING_UTF32;
	494	}
	495	else if ( cs == wxT("UTF-32BE") \|\| cs == wxT("UCS-4BE") )
	496	{
	497	encoding = wxFONTENCODING_UTF32BE;
	498	}
	499	else if ( cs == wxT("UTF-32LE") \|\| cs == wxT("UCS-4LE") )
	500	{
	501	encoding = wxFONTENCODING_UTF32LE;
	502	}
e2478fde VZ	503	else if ( cs == wxT("GB2312") )
	504	{
	505	encoding = wxFONTENCODING_GB2312;
	506	}
	507	else if ( cs == wxT("BIG5") )
	508	{
	509	encoding = wxFONTENCODING_BIG5;
	510	}
	511	else if ( cs == wxT("SJIS") \|\|
	512	cs == wxT("SHIFT_JIS") \|\|
	513	cs == wxT("SHIFT-JIS") )
	514	{
	515	encoding = wxFONTENCODING_SHIFT_JIS;
	516	}
	517	else if ( cs == wxT("EUC-JP") \|\|
	518	cs == wxT("EUC_JP") )
	519	{
	520	encoding = wxFONTENCODING_EUC_JP;
	521	}
51a4142c VZ	522	else if ( cs == wxT("EUC-KR") \|\|
	523	cs == wxT("EUC_KR") )
	524	{
	525	encoding = wxFONTENCODING_CP949;
	526	}
e2478fde	527	else if ( cs == wxT("KOI8-R") \|\|
e2478fde VZ	528	cs == wxT("KOI8-RU") )
	529	{
	530	// although koi8-ru is not strictly speaking the same as koi8-r,
	531	// they are similar enough to make mapping it to koi8 better than
15ad38c3	532	// not recognizing it at all
e2478fde VZ	533	encoding = wxFONTENCODING_KOI8;
e2478fde VZ	534	}
15ad38c3 VZ	535	else if ( cs == wxT("KOI8-U") )
	536	{
	537	encoding = wxFONTENCODING_KOI8_U;
	538	}
e2478fde VZ	539	else if ( cs.Left(3) == wxT("ISO") )
	540	{
	541	// the dash is optional (or, to be exact, it is not, but
	542	// several brokenmails "forget" it)
	543	const wxChar *p = cs.c_str() + 3;
	544	if ( *p == wxT('-') )
	545	p++;
	546
	547	// printf( "iso %s\n", (const char*) cs.ToAscii() );
	548
	549	unsigned int value;
	550	if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
	551	{
	552	// printf( "value %d\n", (int)value );
	553
	554	// make it 0 based and check that it is strictly positive in
	555	// the process (no such thing as iso8859-0 encoding)
	556	if ( (value-- > 0) &&
	557	(value < wxFONTENCODING_ISO8859_MAX -
	558	wxFONTENCODING_ISO8859_1) )
	559	{
	560	// it's a valid ISO8859 encoding
	561	value += wxFONTENCODING_ISO8859_1;
	562	encoding = (wxFontEncoding)value;
	563	}
	564	}
	565	}
	566	else if ( cs.Left(4) == wxT("8859") )
	567	{
	568	const wxChar *p = cs.c_str();
	569
	570	unsigned int value;
	571	if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
	572	{
	573	// printf( "value %d\n", (int)value );
	574
	575	// make it 0 based and check that it is strictly positive in
	576	// the process (no such thing as iso8859-0 encoding)
	577	if ( (value-- > 0) &&
	578	(value < wxFONTENCODING_ISO8859_MAX -
	579	wxFONTENCODING_ISO8859_1) )
	580	{
	581	// it's a valid ISO8859 encoding
	582	value += wxFONTENCODING_ISO8859_1;
	583	encoding = (wxFontEncoding)value;
	584	}
	585	}
	586	}
	587	else // check for Windows charsets
	588	{
	589	size_t len;
	590	if ( cs.Left(7) == wxT("WINDOWS") )
	591	{
	592	len = 7;
	593	}
	594	else if ( cs.Left(2) == wxT("CP") )
	595	{
	596	len = 2;
	597	}
	598	else // not a Windows encoding
	599	{
	600	len = 0;
	601	}
	602
603	if ( len )
604	{
605	const wxChar *p = cs.c_str() + len;
606	if ( *p == wxT('-') )
607	p++;
608
609	int value;
610	if ( wxSscanf(p, wxT("%u"), &value) == 1 )
611	{
612	if ( value >= 1250 )
613	{
614	value -= 1250;
615	if ( value < wxFONTENCODING_CP12_MAX -
616	wxFONTENCODING_CP1250 )
617	{
618	// a valid Windows code page
619	value += wxFONTENCODING_CP1250;
620	encoding = (wxFontEncoding)value;
621	}
622	}
623
624	switch ( value )
625	{
626	case 932:
627	encoding = wxFONTENCODING_CP932;
628	break;
629
630	case 936:
631	encoding = wxFONTENCODING_CP936;
632	break;
633
634	case 949:
635	encoding = wxFONTENCODING_CP949;
636	break;
637
638	case 950:
639	encoding = wxFONTENCODING_CP950;
640	break;
641	}
642	}
643	}
644	}
645	//else: unknown
646	}
647
648	return encoding;
649	}
650
651	/* static */
652	size_t wxFontMapperBase::GetSupportedEncodingsCount()
653	{
654	return WXSIZEOF(gs_encodings);
655	}
656
657	/* static */
658	wxFontEncoding wxFontMapperBase::GetEncoding(size_t n)
659	{
660	wxCHECK_MSG( n < WXSIZEOF(gs_encodings), wxFONTENCODING_SYSTEM,
661	_T("wxFontMapper::GetEncoding(): invalid index") );
662
663	return gs_encodings[n];
664	}
665
666	/* static */
667	wxString wxFontMapperBase::GetEncodingDescription(wxFontEncoding encoding)
668	{
669	if ( encoding == wxFONTENCODING_DEFAULT )
670	{
671	return _("Default encoding");
672	}
673
674	const size_t count = WXSIZEOF(gs_encodingDescs);
675
676	for ( size_t i = 0; i < count; i++ )
677	{
678	if ( gs_encodings[i] == encoding )
679	{
680	return wxGetTranslation(gs_encodingDescs[i]);
681	}
682	}
683
684	wxString str;
685	str.Printf(_("Unknown encoding (%d)"), encoding);
686
687	return str;
688	}
689
690	/* static */
691	wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
692	{
693	if ( encoding == wxFONTENCODING_DEFAULT )
694	{
695	return _("default");
696	}
697
698	const size_t count = WXSIZEOF(gs_encodingNames);
699
700	for ( size_t i = 0; i < count; i++ )
701	{
702	if ( gs_encodings[i] == encoding )
703	{
704	return gs_encodingNames[i];
705	}
706	}
707
708	wxString str;
709	str.Printf(_("unknown-%d"), encoding);
710
711	return str;
712	}
713
910b9fc5 VZ	714	/* static */
	715	wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
	716	{
	717	const size_t count = WXSIZEOF(gs_encodingNames);
	718
	719	for ( size_t i = 0; i < count; i++ )
	720	{
	721	if ( gs_encodingNames[i] == name )
	722	{
	723	return gs_encodings[i];
	724	}
	725	}
	726
	727	if ( name == _("default") )
	728	{
	729	return wxFONTENCODING_DEFAULT;
	730	}
	731
	732	return wxFONTENCODING_MAX;
	733	}
	734
e2478fde VZ	735	#endif // wxUSE_FONTMAP
e2478fde VZ	736