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