]> 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
More tests in erase sample.
[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#if wxUSE_CONFIG
241 if ( m_configIsDummy )
242 delete m_config;
243#endif // wxUSE_CONFIG
244}
245
246// ----------------------------------------------------------------------------
247// customisation
248// ----------------------------------------------------------------------------
249
250#if wxUSE_CONFIG
251
252/* static */ const wxChar *wxFontMapper::GetDefaultConfigPath()
253{
254 return FONTMAPPER_ROOT_PATH;
255}
256
257void wxFontMapper::SetConfigPath(const wxString& prefix)
258{
259 wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
260 wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
261
262 m_configRootPath = prefix;
263}
264
265// ----------------------------------------------------------------------------
266// get config object and path for it
267// ----------------------------------------------------------------------------
268
269wxConfigBase *wxFontMapper::GetConfig()
270{
271 if ( !m_config )
272 {
273 // try the default
274 m_config = wxConfig::Get(FALSE /*don't create on demand*/ );
275
276 if ( !m_config )
277 {
278 // we still want to have a config object because otherwise we would
279 // keep asking the user the same questions in the interactive mode,
280 // so create a dummy config which won't write to any files/registry
281 // but will allow us to remember the results of the questions at
282 // least during this run
283 m_config = new wxMemoryConfig;
284 m_configIsDummy = TRUE;
285 // VS: we can't call wxConfig::Set(m_config) here because that would
286 // disable automatic wxConfig instance creation if this code was
287 // called before wxApp::OnInit (this happens in wxGTK -- it sets
288 // default wxFont encoding in wxApp::Initialize())
289 }
290 }
291
292 if ( m_configIsDummy && wxConfig::Get(FALSE) != NULL )
293 {
294 // VS: in case we created dummy m_config (see above), we want to switch back
295 // to the real one as soon as one becomes available.
296 delete m_config;
297 m_config = wxConfig::Get(FALSE);
298 m_configIsDummy = FALSE;
299 // FIXME: ideally, we should add keys from dummy config to the real one now,
300 // but it is a low-priority task because typical wxWin application
301 // either doesn't use wxConfig at all or creates wxConfig object in
302 // wxApp::OnInit(), before any real interaction with the user takes
303 // place...
304 }
305
306 return m_config;
307}
308
309const wxString& wxFontMapper::GetConfigPath()
310{
311 if ( !m_configRootPath )
312 {
313 // use the default
314 m_configRootPath = GetDefaultConfigPath();
315 }
316
317 return m_configRootPath;
318}
319#endif
320
321bool wxFontMapper::ChangePath(const wxString& pathNew, wxString *pathOld)
322{
323#if wxUSE_CONFIG
324 wxConfigBase *config = GetConfig();
325 if ( !config )
326 return FALSE;
327
328 *pathOld = config->GetPath();
329
330 wxString path = GetConfigPath();
331 if ( path.IsEmpty() || path.Last() != wxCONFIG_PATH_SEPARATOR )
332 {
333 path += wxCONFIG_PATH_SEPARATOR;
334 }
335
336 wxASSERT_MSG( !pathNew || (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
337 wxT("should be a relative path") );
338
339 path += pathNew;
340
341 config->SetPath(path);
342
343 return TRUE;
344#else
345 return FALSE;
346#endif
347}
348
349void wxFontMapper::RestorePath(const wxString& pathOld)
350{
351#if wxUSE_CONFIG
352 GetConfig()->SetPath(pathOld);
353#else
354#endif
355}
356
357// ----------------------------------------------------------------------------
358// charset/encoding correspondence
359// ----------------------------------------------------------------------------
360
361/* static */
362wxString wxFontMapper::GetEncodingDescription(wxFontEncoding encoding)
363{
364 if ( encoding == wxFONTENCODING_DEFAULT )
365 {
366 return _("Default encoding");
367 }
368
369 size_t count = WXSIZEOF(gs_encodingDescs);
370
371 wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
372 wxT("inconsitency detected - forgot to update one of the arrays?") );
373
374 for ( size_t i = 0; i < count; i++ )
375 {
376 if ( gs_encodings[i] == encoding )
377 {
378 return wxGetTranslation(gs_encodingDescs[i]);
379 }
380 }
381
382 wxString str;
383 str.Printf(_("Unknown encoding (%d)"), encoding);
384
385 return str;
386}
387
388/* static */
389wxString wxFontMapper::GetEncodingName(wxFontEncoding encoding)
390{
391 if ( encoding == wxFONTENCODING_DEFAULT )
392 {
393 return _("default");
394 }
395
396 size_t count = WXSIZEOF(gs_encodingNames);
397
398 wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
399 wxT("inconsistency detected - forgot to update one of the arrays?") );
400
401 for ( size_t i = 0; i < count; i++ )
402 {
403 if ( gs_encodings[i] == encoding )
404 {
405 return gs_encodingNames[i];
406 }
407 }
408
409 wxString str;
410 str.Printf(_("unknown-%d"), encoding);
411
412 return str;
413}
414
415wxFontEncoding wxFontMapper::CharsetToEncoding(const wxString& charset,
416 bool interactive)
417{
418 // a special pseudo encoding which means "don't ask me about this charset
419 // any more" - we need it to avoid driving the user crazy with asking him
420 // time after time about the same charset which he [presumably] doesn't
421 // have the fonts fot
422 static const int wxFONTENCODING_UNKNOWN = -2;
423
424 wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
425
426 // we're going to modify it, make a copy
427 wxString cs = charset;
428
429#if wxUSE_CONFIG
430 // first try the user-defined settings
431 wxString pathOld;
432 if ( ChangePath(FONTMAPPER_CHARSET_PATH, &pathOld) )
433 {
434 wxConfigBase *config = GetConfig();
435
436 // do we have an encoding for this charset?
437 long value = config->Read(charset, -1l);
438 if ( value != -1 )
439 {
440 if ( value == wxFONTENCODING_UNKNOWN )
441 {
442 // don't try to find it, in particular don't ask the user
443 return wxFONTENCODING_SYSTEM;
444 }
445
446 if ( value >= 0 && value <= wxFONTENCODING_MAX )
447 {
448 encoding = (wxFontEncoding)value;
449 }
450 else
451 {
452 wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
453 value, charset.c_str());
454 }
455 }
456
457 if ( encoding == wxFONTENCODING_SYSTEM )
458 {
459 // may be we have an alias?
460 config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
461
462 wxString alias = config->Read(charset);
463 if ( !!alias )
464 {
465 // yes, we do - use it instead
466 cs = alias;
467 }
468 }
469
470 RestorePath(pathOld);
471 }
472#endif // wxUSE_CONFIG
473
474 // if didn't find it there, try to recognize it ourselves
475 if ( encoding == wxFONTENCODING_SYSTEM )
476 {
477 // trim any spaces
478 cs.Trim(TRUE);
479 cs.Trim(FALSE);
480
481 // discard the optional quotes
482 if ( !cs.empty() )
483 {
484 if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
485 {
486 cs = wxString(cs.c_str(), cs.length() - 1);
487 }
488 }
489
490 cs.MakeUpper();
491
492 if ( cs.empty() || cs == _T("US-ASCII") )
493 {
494 encoding = wxFONTENCODING_DEFAULT;
495 }
496 else if ( cs == wxT("UTF-7") )
497 {
498 encoding = wxFONTENCODING_UTF7;
499 }
500 else if ( cs == wxT("UTF-8") )
501 {
502 encoding = wxFONTENCODING_UTF8;
503 }
504 else if ( cs == wxT("KOI8-R") ||
505 cs == wxT("KOI8-U") ||
506 cs == wxT("KOI8-RU") )
507 {
508 // although koi8-ru is not strictly speaking the same as koi8-r,
509 // they are similar enough to make mapping it to koi8 better than
510 // not reckognizing it at all
511 encoding = wxFONTENCODING_KOI8;
512 }
513 else if ( cs.Left(3) == wxT("ISO") )
514 {
515 // the dash is optional (or, to be exact, it is not, but
516 // several brokenmails "forget" it)
517 const wxChar *p = cs.c_str() + 3;
518 if ( *p == wxT('-') )
519 p++;
520
521 unsigned int value;
522 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
523 {
524 // make it 0 based and check that it is strictly positive in
525 // the process (no such thing as iso8859-0 encoding)
526 if ( (value-- > 0) &&
527 (value < wxFONTENCODING_ISO8859_MAX -
528 wxFONTENCODING_ISO8859_1) )
529 {
530 // it's a valid ISO8859 encoding
531 value += wxFONTENCODING_ISO8859_1;
532 encoding = (wxFontEncoding)value;
533 }
534 }
535 }
536 else // check for Windows charsets
537 {
538 size_t len;
539 if ( cs.Left(7) == wxT("WINDOWS") )
540 {
541 len = 7;
542 }
543 else if ( cs.Left(2) == wxT("CP") )
544 {
545 len = 2;
546 }
547 else // not a Windows encoding
548 {
549 len = 0;
550 }
551
552 if ( len )
553 {
554 const wxChar *p = cs.c_str() + len;
555 if ( *p == wxT('-') )
556 p++;
557
558 int value;
559 if ( wxSscanf(p, wxT("%u"), &value) == 1 )
560 {
561 if ( value >= 1250 )
562 {
563 value -= 1250;
564 if ( value < wxFONTENCODING_CP12_MAX -
565 wxFONTENCODING_CP1250 )
566 {
567 // a valid Windows code page
568 value += wxFONTENCODING_CP1250;
569 encoding = (wxFontEncoding)value;
570 }
571 }
572
573 switch ( value )
574 {
575 case 932:
576 encoding = wxFONTENCODING_CP932;
577 break;
578
579 case 936:
580 encoding = wxFONTENCODING_CP936;
581 break;
582
583 case 949:
584 encoding = wxFONTENCODING_CP949;
585 break;
586
587 case 950:
588 encoding = wxFONTENCODING_CP950;
589 break;
590 }
591 }
592 }
593 }
594 //else: unknown
595 }
596
597#if wxUSE_GUI
598 // if still no luck, ask the user - unless disabled
599 if ( (encoding == wxFONTENCODING_SYSTEM) && interactive )
600 {
601 // prepare the dialog data
602
603 // the dialog title
604 wxString title(m_titleDialog);
605 if ( !title )
606 title << wxTheApp->GetAppName() << _(": unknown charset");
607
608 // the message
609 wxString msg;
610 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());
611
612 // the list of choices
613 size_t count = WXSIZEOF(gs_encodingDescs);
614
615 wxASSERT_MSG( count == WXSIZEOF(gs_encodings),
616 wxT("inconsitency detected - forgot to update one of the arrays?") );
617
618 wxString *encodingNamesTranslated = new wxString[count];
619
620 for ( size_t i = 0; i < count; i++ )
621 {
622 encodingNamesTranslated[i] = wxGetTranslation(gs_encodingDescs[i]);
623 }
624
625 // the parent window
626 wxWindow *parent = m_windowParent;
627 if ( !parent )
628 parent = wxTheApp->GetTopWindow();
629
630 // do ask the user and get back the index in encodings table
631 int n = wxGetSingleChoiceIndex(msg, title,
632 count,
633 encodingNamesTranslated,
634 parent);
635
636 delete [] encodingNamesTranslated;
637
638 if ( n != -1 )
639 {
640 encoding = gs_encodings[n];
641 }
642
643#if wxUSE_CONFIG
644 // save the result in the config now
645 if ( ChangePath(FONTMAPPER_CHARSET_PATH, &pathOld) )
646 {
647 wxConfigBase *config = GetConfig();
648
649 // remember the alt encoding for this charset - or remember that
650 // we don't know it
651 long value = n == -1 ? wxFONTENCODING_UNKNOWN : (long)encoding;
652 if ( !config->Write(charset, value) )
653 {
654 wxLogError(_("Failed to remember the encoding for the charset '%s'."), charset.c_str());
655 }
656
657 RestorePath(pathOld);
658 }
659#endif // wxUSE_CONFIG
660 }
661#endif // wxUSE_GUI
662
663 return encoding;
664}
665
666// ----------------------------------------------------------------------------
667// support for unknown encodings: we maintain a map between the
668// (platform-specific) strings identifying them and our wxFontEncodings they
669// correspond to which is used by GetFontForEncoding() function
670// ----------------------------------------------------------------------------
671
672#if wxUSE_GUI
673
674bool wxFontMapper::TestAltEncoding(const wxString& configEntry,
675 wxFontEncoding encReplacement,
676 wxNativeEncodingInfo *info)
677{
678 if ( wxGetNativeFontEncoding(encReplacement, info) &&
679 wxTestFontEncoding(*info) )
680 {
681#if wxUSE_CONFIG
682 // remember the mapping in the config
683 wxFontMapperPathChanger path(this, FONTMAPPER_FONT_FROM_ENCODING_PATH);
684
685 if ( path.IsOk() )
686 {
687 GetConfig()->Write(configEntry, info->ToString());
688 }
689#endif // wxUSE_CONFIG
690 return TRUE;
691 }
692
693 return FALSE;
694}
695
696#if wxUSE_GUI
697class ReentrancyBlocker
698{
699public:
700 ReentrancyBlocker(bool& b) : m_b(b) { m_b = TRUE; }
701 ~ReentrancyBlocker() { m_b = FALSE; }
702
703private:
704 bool& m_b;
705};
706#endif
707
708bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
709 wxNativeEncodingInfo *info,
710 const wxString& facename,
711 bool interactive)
712{
713#if wxUSE_GUI
714 // we need a flag to prevent infinite recursion which happens, for
715 // example, when GetAltForEncoding() is called from an OnPaint() handler:
716 // in this case, wxYield() which is called from wxMessageBox() we use here
717 // will lead to another call of OnPaint() and hence to another call of
718 // GetAltForEncoding() - and it is impossible to catch this from the user
719 // code because we are called from wxFont ctor implicitly.
720
721 // assume we're always called from the main thread, so that it is safe to
722 // use a static var
723 static bool s_inGetAltForEncoding = FALSE;
724
725 if ( interactive && s_inGetAltForEncoding )
726 return FALSE;
727
728 ReentrancyBlocker blocker(s_inGetAltForEncoding);
729#endif // wxUSE_GUI
730
731 wxCHECK_MSG( info, FALSE, wxT("bad pointer in GetAltForEncoding") );
732
733 info->facename = facename;
734
735 if ( encoding == wxFONTENCODING_DEFAULT )
736 {
737 encoding = wxFont::GetDefaultEncoding();
738 }
739
740 // if we failed to load the system default encoding, something is really
741 // wrong and we'd better stop now - otherwise we will go into endless
742 // recursion trying to create the font in the msg box with the error
743 // message
744 if ( encoding == wxFONTENCODING_SYSTEM )
745 {
746 wxLogFatalError(_("can't load any font, aborting"));
747
748 // wxLogFatalError doesn't return
749 }
750
751 wxString configEntry,
752 encName = GetEncodingName(encoding);
753 if ( !!facename )
754 {
755 configEntry = facename + _T("_");
756 }
757 configEntry += encName;
758
759#if wxUSE_CONFIG
760 // do we have a font spec for this encoding?
761 wxString pathOld;
762 if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
763 {
764 wxConfigBase *config = GetConfig();
765
766 wxString fontinfo = config->Read(configEntry);
767
768 RestorePath(pathOld);
769
770 // this special value means that we don't know of fonts for this
771 // encoding but, moreover, have already asked the user as well and he
772 // didn't specify any font neither
773 if ( fontinfo == FONTMAPPER_FONT_DONT_ASK )
774 {
775 interactive = FALSE;
776 }
777 else // use the info entered the last time
778 {
779 if ( !!fontinfo && !!facename )
780 {
781 // we tried to find a match with facename - now try without it
782 fontinfo = config->Read(encName);
783 }
784
785 if ( !!fontinfo )
786 {
787 if ( info->FromString(fontinfo) )
788 {
789 if ( wxTestFontEncoding(*info) )
790 {
791 // ok, got something
792 return TRUE;
793 }
794 //else: no such fonts, look for something else
795 // (should we erase the outdated value?)
796 }
797 else
798 {
799 wxLogDebug(wxT("corrupted config data: string '%s' is not a valid font encoding info"),
800 fontinfo.c_str());
801 }
802 }
803 //else: there is no information in config about this encoding
804 }
805 }
806#endif // wxUSE_CONFIG
807
808 // now try to map this encoding to a compatible one which we have on this
809 // system
810 wxFontEncodingArray equiv = wxEncodingConverter::GetAllEquivalents(encoding);
811 size_t count = equiv.GetCount();
812 bool foundEquivEncoding = FALSE;
813 wxFontEncoding equivEncoding = wxFONTENCODING_SYSTEM;
814 if ( count )
815 {
816 for ( size_t i = 0; i < count && !foundEquivEncoding; i++ )
817 {
818 // don't test for encoding itself, we already know we don't have it
819 if ( equiv[i] == encoding )
820 continue;
821
822 if ( TestAltEncoding(configEntry, equiv[i], info) )
823 {
824 equivEncoding = equiv[i];
825
826 foundEquivEncoding = TRUE;
827 }
828 }
829 }
830
831 // ask the user
832#if wxUSE_FONTDLG
833 if ( interactive )
834 {
835 wxString title(m_titleDialog);
836 if ( !title )
837 title << wxTheApp->GetAppName() << _(": unknown encoding");
838
839 // built the message
840 wxString encDesc = GetEncodingDescription(encoding),
841 msg;
842 if ( foundEquivEncoding )
843 {
844 // ask the user if he wants to override found alternative encoding
845 msg.Printf(_("No font for displaying text in encoding '%s' found,\nbut an alternative encoding '%s' is available.\nDo you want to use this encoding (otherwise you will have to choose another one)?"),
846 encDesc.c_str(), GetEncodingDescription(equivEncoding).c_str());
847 }
848 else
849 {
850 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)?"),
851 encDesc.c_str());
852 }
853
854 // the question is different in 2 cases so the answer has to be
855 // interpreted differently as well
856 int answer = foundEquivEncoding ? wxNO : wxYES;
857
858 if ( wxMessageBox(msg, title,
859 wxICON_QUESTION | wxYES_NO,
860 m_windowParent) == answer )
861 {
862 wxFontData data;
863 data.SetEncoding(encoding);
864 data.EncodingInfo() = *info;
865 wxFontDialog dialog(m_windowParent, &data);
866 if ( dialog.ShowModal() == wxID_OK )
867 {
868 wxFontData retData = dialog.GetFontData();
869 wxFont font = retData.GetChosenFont();
870
871 *info = retData.EncodingInfo();
872 info->encoding = retData.GetEncoding();
873
874#if wxUSE_CONFIG
875 // remember this in the config
876 if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
877 {
878 GetConfig()->Write(configEntry, info->ToString());
879
880 RestorePath(pathOld);
881 }
882#endif // wxUSE_CONFIG
883
884 return TRUE;
885 }
886 //else: the user canceled the font selection dialog
887 }
888 else
889 {
890 // the user doesn't want to select a font for this encoding
891 // or selected to use equivalent encoding
892 //
893 // remember it to avoid asking the same question again later
894#if wxUSE_CONFIG
895 if ( ChangePath(FONTMAPPER_FONT_FROM_ENCODING_PATH, &pathOld) )
896 {
897 GetConfig()->Write
898 (
899 configEntry,
900 foundEquivEncoding ? info->ToString().c_str()
901 : FONTMAPPER_FONT_DONT_ASK
902 );
903
904 RestorePath(pathOld);
905 }
906#endif // wxUSE_CONFIG
907 }
908 }
909 //else: we're in non-interactive mode
910#endif // wxUSE_FONTDLG
911
912 return foundEquivEncoding;
913}
914
915bool wxFontMapper::GetAltForEncoding(wxFontEncoding encoding,
916 wxFontEncoding *alt_encoding,
917 const wxString& facename,
918 bool interactive)
919{
920 wxNativeEncodingInfo info;
921 bool r = GetAltForEncoding(encoding, &info, facename, interactive);
922 *alt_encoding = info.encoding;
923 return r;
924}
925
926bool wxFontMapper::IsEncodingAvailable(wxFontEncoding encoding,
927 const wxString& facename)
928{
929 wxNativeEncodingInfo info;
930
931 if (wxGetNativeFontEncoding(encoding, &info))
932 {
933 info.facename = facename;
934 return wxTestFontEncoding(info);
935 }
936
937 return FALSE;
938}
939
940#endif // wxUSE_GUI
941
942#endif // wxUSE_FONTMAP
wxWidgets (Impactor)