src/common/fmapbase.cpp

   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>
   9 // License:     wxWindows license
  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
  35 #if defined(__WXMSW__)
  36   #include  "wx/msw/private.h"  // includes windows.h for LOGFONT
  37   #include  "wx/msw/winundef.h"
  38 #endif
  39
  40 #include "wx/fontmap.h"
  41 #include "wx/fmappriv.h"
  42
  43 #include "wx/apptrait.h"
  44 #include "wx/module.h"
  45
  46 // wxMemoryConfig uses wxFileConfig
  47 #if wxUSE_CONFIG && wxUSE_FILECONFIG
  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,
  75     wxFONTENCODING_KOI8_U,
  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,
  91     wxFONTENCODING_UTF16,
  92     wxFONTENCODING_UTF16BE,
  93     wxFONTENCODING_UTF16LE,
  94     wxFONTENCODING_UTF32,
  95     wxFONTENCODING_UTF32BE,
  96     wxFONTENCODING_UTF32LE,
  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" ),
 119     wxTRANSLATE( "KOI8-U" ),
 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)" ),
 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)" ),
 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" ),
 163     wxT( "koi8-u" ),
 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" ),
 179     wxT( "utf-16" ),
 180     wxT( "utf-16be" ),
 181     wxT( "utf-16le" ),
 182     wxT( "utf-32" ),
 183     wxT( "utf-32be" ),
 184     wxT( "utf-32le" ),
 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 (wxFontMapperBase*)wxFontMapperBase::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 {
 222 #if wxUSE_CONFIG && wxUSE_FILECONFIG
 223     m_config = NULL;
 224     m_configIsDummy = false;
 225 #endif // wxUSE_CONFIG
 226 }
 227
 228 wxFontMapperBase::~wxFontMapperBase()
 229 {
 230 #if wxUSE_CONFIG && wxUSE_FILECONFIG
 231     if ( m_configIsDummy )
 232         delete m_config;
 233 #endif // wxUSE_CONFIG
 234 }
 235
 236 bool wxFontMapperBase::IsWxFontMapper()
 237 {   return false; }
 238
 239 /* static */
 240 wxFontMapperBase *wxFontMapperBase::Get()
 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
 261     return (wxFontMapperBase*)sm_instance;
 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
 272 #if wxUSE_CONFIG && wxUSE_FILECONFIG
 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
 301         m_config = wxConfig::Get(false /*don't create on demand*/ );
 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;
 311             m_configIsDummy = true;
 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
 319     if ( m_configIsDummy && wxConfig::Get(false) != NULL )
 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;
 324         m_config = wxConfig::Get(false);
 325         m_configIsDummy = false;
 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 )
 355         return false;
 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
 372     return true;
 373 }
 374
 375 void wxFontMapperBase::RestorePath(const wxString& pathOld)
 376 {
 377     GetConfig()->SetPath(pathOld);
 378 }
 379
 380 #endif
 381
 382 // ----------------------------------------------------------------------------
 383 // charset/encoding correspondence
 384 // ----------------------------------------------------------------------------
 385
 386 wxFontEncoding
 387 wxFontMapperBase::CharsetToEncoding(const wxString& charset,
 388                                     bool WXUNUSED(interactive))
 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)
 403 {
 404     wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
 405
 406     // we're going to modify it, make a copy
 407     wxString cs = charset;
 408
 409 #if wxUSE_CONFIG && wxUSE_FILECONFIG
 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
 423                 return value;
 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);
 443             if ( !alias.IsEmpty() )
 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         }
 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         }
 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         }
 525         else if ( cs == wxT("EUC-KR") ||
 526                   cs == wxT("EUC_KR") )
 527         {
 528             encoding = wxFONTENCODING_CP949;
 529         }
 530         else if ( cs == wxT("KOI8-R") ||
 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
 535             // not recognizing it at all
 536             encoding = wxFONTENCODING_KOI8;
 537         }
 538         else if ( cs == wxT("KOI8-U") )
 539         {
 540             encoding = wxFONTENCODING_KOI8_U;
 541         }
 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++;
 549
 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 );
 556
 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();
 572
 573             unsigned int value;
 574             if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
 575             {
 576                 // printf( "value %d\n", (int)value );
 577
 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
 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
 738 #endif // wxUSE_FONTMAP
 739