src/common/fontmap.cpp

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