Semicolon needed.

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

diff --git a/src/common/fmapbase.cpp b/src/common/fmapbase.cpp
index 83e91e70161ed271d2f13acbce03ee66c8c8130a..85981bc1f1da33208c3216cf6321bb1d576fa5bb 100644 (file)
--- a/src/common/fmapbase.cpp
+++ b/src/common/fmapbase.cpp
@@ -72,6 +72,8 @@ static wxFontEncoding gs_encodings[] =
     wxFONTENCODING_ISO8859_14,
     wxFONTENCODING_ISO8859_15,
     wxFONTENCODING_KOI8,
     wxFONTENCODING_ISO8859_14,
     wxFONTENCODING_ISO8859_15,
     wxFONTENCODING_KOI8,

+    wxFONTENCODING_KOI8_U,
+    wxFONTENCODING_CP874,

     wxFONTENCODING_CP932,
     wxFONTENCODING_CP936,
     wxFONTENCODING_CP949,
     wxFONTENCODING_CP932,
     wxFONTENCODING_CP936,
     wxFONTENCODING_CP949,


@@ -87,7 +89,15 @@ static wxFontEncoding gs_encodings[] =
     wxFONTENCODING_CP437,
     wxFONTENCODING_UTF7,
     wxFONTENCODING_UTF8,
     wxFONTENCODING_CP437,
     wxFONTENCODING_UTF7,
     wxFONTENCODING_UTF8,

+    wxFONTENCODING_UTF16BE,
+    wxFONTENCODING_UTF16LE,
+    wxFONTENCODING_UTF32BE,
+    wxFONTENCODING_UTF32LE,

     wxFONTENCODING_EUC_JP,
     wxFONTENCODING_EUC_JP,

+    wxFONTENCODING_DEFAULT,
+    wxFONTENCODING_BIG5,
+    wxFONTENCODING_SHIFT_JIS,
+    wxFONTENCODING_GB2312,

 };
 
 // the descriptions for them
 };
 
 // the descriptions for them


@@ -109,6 +119,8 @@ static const wxChar* gs_encodingDescs[] =
     wxTRANSLATE( "Celtic (ISO-8859-14)" ),
     wxTRANSLATE( "Western European with Euro (ISO-8859-15)" ),
     wxTRANSLATE( "KOI8-R" ),
     wxTRANSLATE( "Celtic (ISO-8859-14)" ),
     wxTRANSLATE( "Western European with Euro (ISO-8859-15)" ),
     wxTRANSLATE( "KOI8-R" ),

+    wxTRANSLATE( "KOI8-U" ),
+    wxTRANSLATE( "Windows Thai (CP 874)" ),

     wxTRANSLATE( "Windows Japanese (CP 932)" ),
     wxTRANSLATE( "Windows Chinese Simplified (CP 936)" ),
     wxTRANSLATE( "Windows Korean (CP 949)" ),
     wxTRANSLATE( "Windows Japanese (CP 932)" ),
     wxTRANSLATE( "Windows Chinese Simplified (CP 936)" ),
     wxTRANSLATE( "Windows Korean (CP 949)" ),


@@ -124,49 +136,93 @@ static const wxChar* gs_encodingDescs[] =
     wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
     wxTRANSLATE( "Unicode 7 bit (UTF-7)" ),
     wxTRANSLATE( "Unicode 8 bit (UTF-8)" ),
     wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
     wxTRANSLATE( "Unicode 7 bit (UTF-7)" ),
     wxTRANSLATE( "Unicode 8 bit (UTF-8)" ),

+#ifdef WORDS_BIGENDIAN
+    wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
+    wxTRANSLATE( "Unicode 16 bit Little Endian (UTF-16LE)" ),
+    wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
+    wxTRANSLATE( "Unicode 32 bit Little Endian (UTF-32LE)" ),
+#else // WORDS_BIGENDIAN
+    wxTRANSLATE( "Unicode 16 bit Big Endian (UTF-16BE)" ),
+    wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
+    wxTRANSLATE( "Unicode 32 bit Big Endian (UTF-32BE)" ),
+    wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
+#endif // WORDS_BIGENDIAN

     wxTRANSLATE( "Extended Unix Codepage for Japanese (EUC-JP)" ),
     wxTRANSLATE( "Extended Unix Codepage for Japanese (EUC-JP)" ),

+    wxTRANSLATE( "US-ASCII" ),
+    wxTRANSLATE( "BIG5" ),
+    wxTRANSLATE( "SHIFT-JIS" ),
+    wxTRANSLATE( "GB-2312" ),

 };
 
 // and the internal names (these are not translated on purpose!)
 };
 
 // and the internal names (these are not translated on purpose!)

-static const wxChar* gs_encodingNames[] =
+static const wxChar* gs_encodingNames[WXSIZEOF(gs_encodingDescs)][10] =

 {
 {

-    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( "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( "euc-jp" ),
+    // names from the columns correspond to these OS:
+    //      Linux        Solaris and IRIX       HP-UX             AIX
+    { _T("ISO-8859-1"),  _T("ISO8859-1"),  _T("iso88591"),  _T("8859-1"), wxT("iso_8859_1"), NULL },
+    { _T("ISO-8859-2"),  _T("ISO8859-2"),  _T("iso88592"),  _T("8859-2"), NULL },
+    { _T("ISO-8859-3"),  _T("ISO8859-3"),  _T("iso88593"),  _T("8859-3"), NULL },
+    { _T("ISO-8859-4"),  _T("ISO8859-4"),  _T("iso88594"),  _T("8859-4"), NULL },
+    { _T("ISO-8859-5"),  _T("ISO8859-5"),  _T("iso88595"),  _T("8859-5"), NULL },
+    { _T("ISO-8859-6"),  _T("ISO8859-6"),  _T("iso88596"),  _T("8859-6"), NULL },
+    { _T("ISO-8859-7"),  _T("ISO8859-7"),  _T("iso88597"),  _T("8859-7"), NULL },
+    { _T("ISO-8859-8"),  _T("ISO8859-8"),  _T("iso88598"),  _T("8859-8"), NULL },
+    { _T("ISO-8859-9"),  _T("ISO8859-9"),  _T("iso88599"),  _T("8859-9"), NULL },
+    { _T("ISO-8859-10"), _T("ISO8859-10"), _T("iso885910"), _T("8859-10"), NULL },
+    { _T("ISO-8859-11"), _T("ISO8859-11"), _T("iso885911"), _T("8859-11"), NULL },
+    { _T("ISO-8859-12"), _T("ISO8859-12"), _T("iso885912"), _T("8859-12"), NULL },
+    { _T("ISO-8859-13"), _T("ISO8859-13"), _T("iso885913"), _T("8859-13"), NULL },
+    { _T("ISO-8859-14"), _T("ISO8859-14"), _T("iso885914"), _T("8859-14"), NULL },
+    { _T("ISO-8859-15"), _T("ISO8859-15"), _T("iso885915"), _T("8859-15"), NULL },
+
+    // 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
+    { wxT( "KOI8-R" ), wxT( "KOI8-RU" ), NULL },
+    { wxT( "KOI8-U" ), NULL },
+
+    { wxT( "WINDOWS-874" ), wxT( "CP-874" ), NULL },
+    { wxT( "WINDOWS-932" ), wxT( "CP-932" ), NULL },
+    { wxT( "WINDOWS-936" ), wxT( "CP-936" ), NULL },
+    { wxT( "WINDOWS-949" ), wxT( "CP-949" ), wxT( "EUC-KR" ), wxT( "eucKR" ), wxT( "euc_kr" ), NULL },
+    { wxT( "WINDOWS-950" ), wxT( "CP-950" ), NULL },
+    { wxT( "WINDOWS-1250" ),wxT( "CP-1250" ), NULL },
+    { wxT( "WINDOWS-1251" ),wxT( "CP-1251" ), NULL },
+    { wxT( "WINDOWS-1252" ),wxT( "CP-1252" ), wxT("IBM-1252"), NULL },
+    { wxT( "WINDOWS-1253" ),wxT( "CP-1253" ), NULL },
+    { wxT( "WINDOWS-1254" ),wxT( "CP-1254" ), NULL },
+    { wxT( "WINDOWS-1255" ),wxT( "CP-1255" ), NULL },
+    { wxT( "WINDOWS-1256" ),wxT( "CP-1256" ), NULL },
+    { wxT( "WINDOWS-1257" ),wxT( "CP-1257" ), NULL },
+    { wxT( "WINDOWS-437" ), wxT( "CP-437" ), NULL },
+
+    { wxT( "UTF-7" ), wxT("utf7"), NULL },
+    { wxT( "UTF-8" ), wxT("utf8"), NULL },
+#ifdef WORDS_BIGENDIAN
+    { wxT( "UTF-16BE" ), wxT("UCS-2BE"), wxT( "UTF-16" ), wxT("UCS-2"), wxT("UCS2"), NULL },
+    { wxT( "UTF-16LE" ), wxT("UCS-2LE"), NULL },
+    { wxT( "UTF-32BE" ), wxT( "UCS-4BE" ), wxT( "UTF-32" ), wxT( "UCS-4" ), wxT("UCS4"), NULL },
+    { wxT( "UTF-32LE" ), wxT( "UCS-4LE" ), NULL },
+#else // WORDS_BIGENDIAN
+    { wxT( "UTF-16BE" ), wxT("UCS-2BE"), NULL },
+    { wxT( "UTF-16LE" ), wxT("UCS-2LE"), wxT( "UTF-16" ), wxT("UCS-2"), wxT("UCS2"), NULL },
+    { wxT( "UTF-32BE" ), wxT( "UCS-4BE" ), NULL },
+    { wxT( "UTF-32LE" ), wxT( "UCS-4LE" ), wxT( "UTF-32" ), wxT( "UCS-4" ), wxT("UCS4"), NULL },
+#endif // WORDS_BIGENDIAN
+
+    { wxT( "EUC-JP" ), wxT( "eucJP" ), wxT( "euc_jp" ), wxT( "IBM-eucJP" ), NULL },
+
+    // 646 is for Solaris, roman8 -- for HP-UX
+    { wxT( "US-ASCII" ), wxT( "ASCII" ), wxT("C"), wxT("POSIX"), wxT("ANSI_X3.4-1968"),
+      wxT("646"), wxT("roman8"), wxT( "" ), NULL },
+
+    { wxT( "BIG5" ), wxT("big5"), NULL },
+    { wxT( "SJIS" ), wxT( "SHIFT-JIS" ), wxT( "SHIFT_JIS" ), NULL },
+    { wxT( "GB2312" ), NULL },

 };
 
 };
 

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

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


@@ -177,8 +233,8 @@ class wxFontMapperModule : public wxModule
 {
 public:
     wxFontMapperModule() : wxModule() { }
 {
 public:
     wxFontMapperModule() : wxModule() { }

-    virtual bool OnInit() { return TRUE; }
-    virtual void OnExit() { delete wxFontMapper::Set(NULL); }
+    virtual bool OnInit() { return true; }
+    virtual void OnExit() { delete (wxFontMapperBase*)wxFontMapperBase::Set(NULL); }

 
     DECLARE_DYNAMIC_CLASS(wxFontMapperModule)
 };
 
     DECLARE_DYNAMIC_CLASS(wxFontMapperModule)
 };


@@ -199,21 +255,23 @@ wxFontMapper *wxFontMapperBase::sm_instance = NULL;
 wxFontMapperBase::wxFontMapperBase()
 {
 #if wxUSE_CONFIG && wxUSE_FILECONFIG
 wxFontMapperBase::wxFontMapperBase()
 {
 #if wxUSE_CONFIG && wxUSE_FILECONFIG

-    m_config = NULL;
-    m_configIsDummy = FALSE;
+    m_configDummy = NULL;

 #endif // wxUSE_CONFIG
 }
 
 wxFontMapperBase::~wxFontMapperBase()
 {
 #if wxUSE_CONFIG && wxUSE_FILECONFIG
 #endif // wxUSE_CONFIG
 }
 
 wxFontMapperBase::~wxFontMapperBase()
 {
 #if wxUSE_CONFIG && wxUSE_FILECONFIG

-    if ( m_configIsDummy )
-        delete m_config;
+    if ( m_configDummy )
+        delete m_configDummy;

 #endif // wxUSE_CONFIG
 }
 
 #endif // wxUSE_CONFIG
 }
 

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

 /* static */
 /* static */

-wxFontMapper *wxFontMapperBase::Get()
+wxFontMapperBase *wxFontMapperBase::Get()

 {
     if ( !sm_instance )
     {
 {
     if ( !sm_instance )
     {


@@ -234,7 +292,7 @@ wxFontMapper *wxFontMapperBase::Get()
         }
     }
 
         }
     }
 

-    return sm_instance;
+    return (wxFontMapperBase*)sm_instance;

 }
 
 /* static */
 }
 
 /* static */


@@ -271,42 +329,23 @@ void wxFontMapperBase::SetConfigPath(const wxString& prefix)
 
 wxConfigBase *wxFontMapperBase::GetConfig()
 {
 
 wxConfigBase *wxFontMapperBase::GetConfig()
 {

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

 
 

-        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 )
+    // If there is no global configuration, use an internal memory configuration
+    if ( !config )

     {
     {

-        // 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,
+        if ( !m_configDummy )
+            m_configDummy = new wxMemoryConfig;
+        config = m_configDummy;
+
+        // FIXME: ideally, we should add keys from dummy config to a real one later,

         //        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...
     }
 
         //        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;
+    return config;

 }
 
 const wxString& wxFontMapperBase::GetConfigPath()
 }
 
 const wxString& wxFontMapperBase::GetConfigPath()


@@ -328,7 +367,7 @@ bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
 {
     wxConfigBase *config = GetConfig();
     if ( !config )
 {
     wxConfigBase *config = GetConfig();
     if ( !config )

-        return FALSE;
+        return false;

 
     *pathOld = config->GetPath();
 
 
     *pathOld = config->GetPath();
 


@@ -345,7 +384,7 @@ bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
 
     config->SetPath(path);
 
 
     config->SetPath(path);
 

-    return TRUE;
+    return true;

 }
 
 void wxFontMapperBase::RestorePath(const wxString& pathOld)
 }
 
 void wxFontMapperBase::RestorePath(const wxString& pathOld)


@@ -353,6 +392,8 @@ void wxFontMapperBase::RestorePath(const wxString& pathOld)
     GetConfig()->SetPath(pathOld);
 }
 
     GetConfig()->SetPath(pathOld);
 }
 

+#endif
+

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


@@ -360,6 +401,20 @@ void wxFontMapperBase::RestorePath(const wxString& pathOld)
 wxFontEncoding
 wxFontMapperBase::CharsetToEncoding(const wxString& charset,
                                     bool WXUNUSED(interactive))
 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;
 
 {
     wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
 


@@ -380,7 +435,7 @@ wxFontMapperBase::CharsetToEncoding(const wxString& charset,
             if ( value == wxFONTENCODING_UNKNOWN )
             {
                 // don't try to find it, in particular don't ask the user
             if ( value == wxFONTENCODING_UNKNOWN )
             {
                 // don't try to find it, in particular don't ask the user

-                return wxFONTENCODING_SYSTEM;
+                return value;

             }
 
             if ( value >= 0 && value <= wxFONTENCODING_MAX )
             }
 
             if ( value >= 0 && value <= wxFONTENCODING_MAX )


@@ -400,7 +455,7 @@ wxFontMapperBase::CharsetToEncoding(const wxString& charset,
             config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
 
             wxString alias = config->Read(charset);
             config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
 
             wxString alias = config->Read(charset);

-            if ( !!alias )
+            if ( !alias.IsEmpty() )

             {
                 // yes, we do - use it instead
                 cs = alias;
             {
                 // yes, we do - use it instead
                 cs = alias;


@@ -425,63 +480,32 @@ wxFontMapperBase::CharsetToEncoding(const wxString& charset,
             }
         }
 
             }
         }
 

-        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("GB2312") )
-        {
-            encoding = wxFONTENCODING_GB2312;
-        }
-        else if ( cs == wxT("BIG5") )
+        for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); ++i )

         {
         {

-            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("KOI8-R") ||
-                  cs == wxT("KOI8-U") ||
-                  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 reckognizing it at all
-            encoding = wxFONTENCODING_KOI8;
+            for ( const wxChar** encName = gs_encodingNames[i]; *encName; ++encName )
+            {
+                if ( cs.CmpNoCase(*encName) == 0 )
+                    return gs_encodings[i];
+            }

         }
         }

-        else if ( cs.Left(3) == wxT("ISO") )
+
+        cs.MakeUpper();
+
+        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++;
         {
             // 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 );
             // 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) &&
                 // make it 0 based and check that it is strictly positive in
                 // the process (no such thing as iso8859-0 encoding)
                 if ( (value-- > 0) &&


@@ -497,12 +521,12 @@ wxFontMapperBase::CharsetToEncoding(const wxString& charset,
         else if ( cs.Left(4) == wxT("8859") )
         {
             const wxChar *p = cs.c_str();
         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 );
             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) &&
                 // make it 0 based and check that it is strictly positive in
                 // the process (no such thing as iso8859-0 encoding)
                 if ( (value-- > 0) &&


@@ -537,7 +561,7 @@ wxFontMapperBase::CharsetToEncoding(const wxString& charset,
                 if ( *p == wxT('-') )
                     p++;
 
                 if ( *p == wxT('-') )
                     p++;
 

-                int value;
+                unsigned int value;

                 if ( wxSscanf(p, wxT("%u"), &value) == 1 )
                 {
                     if ( value >= 1250 )
                 if ( wxSscanf(p, wxT("%u"), &value) == 1 )
                 {
                     if ( value >= 1250 )


@@ -554,6 +578,10 @@ wxFontMapperBase::CharsetToEncoding(const wxString& charset,
 
                     switch ( value )
                     {
 
                     switch ( value )
                     {

+                        case 874:
+                            encoding = wxFONTENCODING_CP874;
+                            break;
+

                         case 932:
                             encoding = wxFONTENCODING_CP932;
                             break;
                         case 932:
                             encoding = wxFONTENCODING_CP932;
                             break;


@@ -632,7 +660,7 @@ wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
     {
         if ( gs_encodings[i] == encoding )
         {
     {
         if ( gs_encodings[i] == encoding )
         {

-            return gs_encodingNames[i];
+            return gs_encodingNames[i][0];

         }
     }
 
         }
     }
 


@@ -642,7 +670,38 @@ wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
     return str;
 }
 
     return str;
 }
 

-#endif // wxUSE_CONFIG
+/* static */
+const wxChar** wxFontMapperBase::GetAllEncodingNames(wxFontEncoding encoding)
+{
+    static const wxChar* dummy[] = { NULL };
+
+    for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); i++ )
+    {
+        if ( gs_encodings[i] == encoding )
+        {
+            return gs_encodingNames[i];
+        }
+    }
+
+    return dummy;
+}
+
+/* static */
+wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
+{
+    const size_t count = WXSIZEOF(gs_encodingNames);
+
+    for ( size_t i = 0; i < count; i++ )
+    {
+        for ( const wxChar** encName = gs_encodingNames[i]; *encName; ++encName )
+        {
+            if ( name.CmpNoCase(*encName) == 0 )
+                return gs_encodings[i];
+        }
+    }
+
+    return wxFONTENCODING_MAX;
+}

 
 #endif // wxUSE_FONTMAP
 
 
 #endif // wxUSE_FONTMAP