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