]> git.saurik.com Git - wxWidgets.git/blob - src/common/fmapbase.cpp
Tweaks for demos on MacOSX
[wxWidgets.git] / src / common / fmapbase.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: common/fmapbase.cpp
3 // Purpose: wxFontMapperBase class implementation
4 // Author: Vadim Zeitlin
5 // Modified by:
6 // Created: 21.06.2003 (extracted from common/fontmap.cpp)
7 // RCS-ID: $Id$
8 // Copyright: (c) 1999-2003 Vadim Zeitlin <vadim@wxwindows.org>
9 // License: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 // for compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
22
23 #ifdef __BORLANDC__
24 #pragma hdrstop
25 #endif
26
27 #if wxUSE_FONTMAP
28
29 #ifndef WX_PRECOMP
30 #include "wx/app.h"
31 #include "wx/log.h"
32 #include "wx/intl.h"
33 #endif //WX_PRECOMP
34
35 #if defined(__WXMSW__)
36 #include "wx/msw/private.h" // includes windows.h for LOGFONT
37 #include "wx/msw/winundef.h"
38 #endif
39
40 #include "wx/fontmap.h"
41 #include "wx/fmappriv.h"
42
43 #include "wx/apptrait.h"
44 #include "wx/module.h"
45
46 // wxMemoryConfig uses wxFileConfig
47 #if wxUSE_CONFIG && wxUSE_FILECONFIG
48 #include "wx/config.h"
49 #include "wx/memconf.h"
50 #endif
51
52 // ----------------------------------------------------------------------------
53 // constants
54 // ----------------------------------------------------------------------------
55
56 // encodings supported by GetEncodingDescription
57 static wxFontEncoding gs_encodings[] =
58 {
59 wxFONTENCODING_ISO8859_1,
60 wxFONTENCODING_ISO8859_2,
61 wxFONTENCODING_ISO8859_3,
62 wxFONTENCODING_ISO8859_4,
63 wxFONTENCODING_ISO8859_5,
64 wxFONTENCODING_ISO8859_6,
65 wxFONTENCODING_ISO8859_7,
66 wxFONTENCODING_ISO8859_8,
67 wxFONTENCODING_ISO8859_9,
68 wxFONTENCODING_ISO8859_10,
69 wxFONTENCODING_ISO8859_11,
70 wxFONTENCODING_ISO8859_12,
71 wxFONTENCODING_ISO8859_13,
72 wxFONTENCODING_ISO8859_14,
73 wxFONTENCODING_ISO8859_15,
74 wxFONTENCODING_KOI8,
75 wxFONTENCODING_KOI8_U,
76 wxFONTENCODING_CP874,
77 wxFONTENCODING_CP932,
78 wxFONTENCODING_CP936,
79 wxFONTENCODING_CP949,
80 wxFONTENCODING_CP950,
81 wxFONTENCODING_CP1250,
82 wxFONTENCODING_CP1251,
83 wxFONTENCODING_CP1252,
84 wxFONTENCODING_CP1253,
85 wxFONTENCODING_CP1254,
86 wxFONTENCODING_CP1255,
87 wxFONTENCODING_CP1256,
88 wxFONTENCODING_CP1257,
89 wxFONTENCODING_CP437,
90 wxFONTENCODING_UTF7,
91 wxFONTENCODING_UTF8,
92 wxFONTENCODING_UTF16BE,
93 wxFONTENCODING_UTF16LE,
94 wxFONTENCODING_UTF32BE,
95 wxFONTENCODING_UTF32LE,
96 wxFONTENCODING_EUC_JP,
97 wxFONTENCODING_DEFAULT,
98 wxFONTENCODING_BIG5,
99 wxFONTENCODING_SHIFT_JIS,
100 wxFONTENCODING_GB2312,
101 };
102
103 // the descriptions for them
104 static const wxChar* gs_encodingDescs[] =
105 {
106 wxTRANSLATE( "Western European (ISO-8859-1)" ),
107 wxTRANSLATE( "Central European (ISO-8859-2)" ),
108 wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
109 wxTRANSLATE( "Baltic (old) (ISO-8859-4)" ),
110 wxTRANSLATE( "Cyrillic (ISO-8859-5)" ),
111 wxTRANSLATE( "Arabic (ISO-8859-6)" ),
112 wxTRANSLATE( "Greek (ISO-8859-7)" ),
113 wxTRANSLATE( "Hebrew (ISO-8859-8)" ),
114 wxTRANSLATE( "Turkish (ISO-8859-9)" ),
115 wxTRANSLATE( "Nordic (ISO-8859-10)" ),
116 wxTRANSLATE( "Thai (ISO-8859-11)" ),
117 wxTRANSLATE( "Indian (ISO-8859-12)" ),
118 wxTRANSLATE( "Baltic (ISO-8859-13)" ),
119 wxTRANSLATE( "Celtic (ISO-8859-14)" ),
120 wxTRANSLATE( "Western European with Euro (ISO-8859-15)" ),
121 wxTRANSLATE( "KOI8-R" ),
122 wxTRANSLATE( "KOI8-U" ),
123 wxTRANSLATE( "Windows Thai (CP 874)" ),
124 wxTRANSLATE( "Windows Japanese (CP 932)" ),
125 wxTRANSLATE( "Windows Chinese Simplified (CP 936)" ),
126 wxTRANSLATE( "Windows Korean (CP 949)" ),
127 wxTRANSLATE( "Windows Chinese Traditional (CP 950)" ),
128 wxTRANSLATE( "Windows Central European (CP 1250)" ),
129 wxTRANSLATE( "Windows Cyrillic (CP 1251)" ),
130 wxTRANSLATE( "Windows Western European (CP 1252)" ),
131 wxTRANSLATE( "Windows Greek (CP 1253)" ),
132 wxTRANSLATE( "Windows Turkish (CP 1254)" ),
133 wxTRANSLATE( "Windows Hebrew (CP 1255)" ),
134 wxTRANSLATE( "Windows Arabic (CP 1256)" ),
135 wxTRANSLATE( "Windows Baltic (CP 1257)" ),
136 wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
137 wxTRANSLATE( "Unicode 7 bit (UTF-7)" ),
138 wxTRANSLATE( "Unicode 8 bit (UTF-8)" ),
139 #ifdef WORDS_BIGENDIAN
140 wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
141 wxTRANSLATE( "Unicode 16 bit Little Endian (UTF-16LE)" ),
142 wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
143 wxTRANSLATE( "Unicode 32 bit Little Endian (UTF-32LE)" ),
144 #else // WORDS_BIGENDIAN
145 wxTRANSLATE( "Unicode 16 bit Big Endian (UTF-16BE)" ),
146 wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
147 wxTRANSLATE( "Unicode 32 bit Big Endian (UTF-32BE)" ),
148 wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
149 #endif // WORDS_BIGENDIAN
150 wxTRANSLATE( "Extended Unix Codepage for Japanese (EUC-JP)" ),
151 wxTRANSLATE( "US-ASCII" ),
152 wxTRANSLATE( "BIG5" ),
153 wxTRANSLATE( "SHIFT-JIS" ),
154 wxTRANSLATE( "GB-2312" ),
155 };
156
157 // and the internal names (these are not translated on purpose!)
158 static const wxChar* gs_encodingNames[WXSIZEOF(gs_encodingDescs)][10] =
159 {
160 // names from the columns correspond to these OS:
161 // Linux Solaris and IRIX HP-UX AIX
162 { _T("ISO-8859-1"), _T("ISO8859-1"), _T("iso88591"), _T("8859-1"), wxT("iso_8859_1"), NULL },
163 { _T("ISO-8859-2"), _T("ISO8859-2"), _T("iso88592"), _T("8859-2"), NULL },
164 { _T("ISO-8859-3"), _T("ISO8859-3"), _T("iso88593"), _T("8859-3"), NULL },
165 { _T("ISO-8859-4"), _T("ISO8859-4"), _T("iso88594"), _T("8859-4"), NULL },
166 { _T("ISO-8859-5"), _T("ISO8859-5"), _T("iso88595"), _T("8859-5"), NULL },
167 { _T("ISO-8859-6"), _T("ISO8859-6"), _T("iso88596"), _T("8859-6"), NULL },
168 { _T("ISO-8859-7"), _T("ISO8859-7"), _T("iso88597"), _T("8859-7"), NULL },
169 { _T("ISO-8859-8"), _T("ISO8859-8"), _T("iso88598"), _T("8859-8"), NULL },
170 { _T("ISO-8859-9"), _T("ISO8859-9"), _T("iso88599"), _T("8859-9"), NULL },
171 { _T("ISO-8859-10"), _T("ISO8859-10"), _T("iso885910"), _T("8859-10"), NULL },
172 { _T("ISO-8859-11"), _T("ISO8859-11"), _T("iso885911"), _T("8859-11"), NULL },
173 { _T("ISO-8859-12"), _T("ISO8859-12"), _T("iso885912"), _T("8859-12"), NULL },
174 { _T("ISO-8859-13"), _T("ISO8859-13"), _T("iso885913"), _T("8859-13"), NULL },
175 { _T("ISO-8859-14"), _T("ISO8859-14"), _T("iso885914"), _T("8859-14"), NULL },
176 { _T("ISO-8859-15"), _T("ISO8859-15"), _T("iso885915"), _T("8859-15"), NULL },
177
178 // although koi8-ru is not strictly speaking the same as koi8-r,
179 // they are similar enough to make mapping it to koi8 better than
180 // not recognizing it at all
181 { wxT( "KOI8-R" ), wxT( "KOI8-RU" ), NULL },
182 { wxT( "KOI8-U" ), NULL },
183
184 { wxT( "WINDOWS-874" ), wxT( "CP-874" ), NULL },
185 { wxT( "WINDOWS-932" ), wxT( "CP-932" ), NULL },
186 { wxT( "WINDOWS-936" ), wxT( "CP-936" ), NULL },
187 { wxT( "WINDOWS-949" ), wxT( "CP-949" ), wxT( "EUC-KR" ), wxT( "eucKR" ), wxT( "euc_kr" ), NULL },
188 { wxT( "WINDOWS-950" ), wxT( "CP-950" ), NULL },
189 { wxT( "WINDOWS-1250" ),wxT( "CP-1250" ), NULL },
190 { wxT( "WINDOWS-1251" ),wxT( "CP-1251" ), NULL },
191 { wxT( "WINDOWS-1252" ),wxT( "CP-1252" ), wxT("IBM-1252"), NULL },
192 { wxT( "WINDOWS-1253" ),wxT( "CP-1253" ), NULL },
193 { wxT( "WINDOWS-1254" ),wxT( "CP-1254" ), NULL },
194 { wxT( "WINDOWS-1255" ),wxT( "CP-1255" ), NULL },
195 { wxT( "WINDOWS-1256" ),wxT( "CP-1256" ), NULL },
196 { wxT( "WINDOWS-1257" ),wxT( "CP-1257" ), NULL },
197 { wxT( "WINDOWS-437" ), wxT( "CP-437" ), NULL },
198
199 { wxT( "UTF-7" ), wxT("utf7"), NULL },
200 { wxT( "UTF-8" ), wxT("utf8"), NULL },
201 #ifdef WORDS_BIGENDIAN
202 { wxT( "UTF-16BE" ), wxT("UCS-2BE"), wxT( "UTF-16" ), wxT("UCS-2"), wxT("UCS2"), NULL },
203 { wxT( "UTF-16LE" ), wxT("UCS-2LE"), NULL },
204 { wxT( "UTF-32BE" ), wxT( "UCS-4BE" ), wxT( "UTF-32" ), wxT( "UCS-4" ), wxT("UCS4"), NULL },
205 { wxT( "UTF-32LE" ), wxT( "UCS-4LE" ), NULL },
206 #else // WORDS_BIGENDIAN
207 { wxT( "UTF-16BE" ), wxT("UCS-2BE"), NULL },
208 { wxT( "UTF-16LE" ), wxT("UCS-2LE"), wxT( "UTF-16" ), wxT("UCS-2"), wxT("UCS2"), NULL },
209 { wxT( "UTF-32BE" ), wxT( "UCS-4BE" ), NULL },
210 { wxT( "UTF-32LE" ), wxT( "UCS-4LE" ), wxT( "UTF-32" ), wxT( "UCS-4" ), wxT("UCS4"), NULL },
211 #endif // WORDS_BIGENDIAN
212
213 { wxT( "EUC-JP" ), wxT( "eucJP" ), wxT( "euc_jp" ), wxT( "IBM-eucJP" ), NULL },
214
215 // 646 is for Solaris, roman8 -- for HP-UX
216 { wxT( "US-ASCII" ), wxT( "ASCII" ), wxT("C"), wxT("POSIX"), wxT("ANSI_X3.4-1968"),
217 wxT("646"), wxT("roman8"), wxT( "" ), NULL },
218
219 { wxT( "BIG5" ), wxT("big5"), NULL },
220 { wxT( "SJIS" ), wxT( "SHIFT-JIS" ), wxT( "SHIFT_JIS" ), NULL },
221 { wxT( "GB2312" ), NULL },
222 };
223
224 wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingDescs) == WXSIZEOF(gs_encodings), EncodingsArraysNotInSync );
225 wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingNames) == WXSIZEOF(gs_encodings), EncodingsArraysNotInSync );
226
227 // ----------------------------------------------------------------------------
228 // private classes
229 // ----------------------------------------------------------------------------
230
231 // clean up the font mapper object
232 class wxFontMapperModule : public wxModule
233 {
234 public:
235 wxFontMapperModule() : wxModule() { }
236 virtual bool OnInit() { return true; }
237 virtual void OnExit() { delete (wxFontMapperBase*)wxFontMapperBase::Set(NULL); }
238
239 DECLARE_DYNAMIC_CLASS(wxFontMapperModule)
240 };
241
242 IMPLEMENT_DYNAMIC_CLASS(wxFontMapperModule, wxModule)
243
244
245 // ============================================================================
246 // wxFontMapperBase implementation
247 // ============================================================================
248
249 wxFontMapper *wxFontMapperBase::sm_instance = NULL;
250
251 // ----------------------------------------------------------------------------
252 // ctor and dtor
253 // ----------------------------------------------------------------------------
254
255 wxFontMapperBase::wxFontMapperBase()
256 {
257 #if wxUSE_CONFIG && wxUSE_FILECONFIG
258 m_configDummy = NULL;
259 #endif // wxUSE_CONFIG
260 }
261
262 wxFontMapperBase::~wxFontMapperBase()
263 {
264 #if wxUSE_CONFIG && wxUSE_FILECONFIG
265 if ( m_configDummy )
266 delete m_configDummy;
267 #endif // wxUSE_CONFIG
268 }
269
270 bool wxFontMapperBase::IsWxFontMapper()
271 { return false; }
272
273 /* static */
274 wxFontMapperBase *wxFontMapperBase::Get()
275 {
276 if ( !sm_instance )
277 {
278 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
279 if ( traits )
280 {
281 sm_instance = traits->CreateFontMapper();
282
283 wxASSERT_MSG( sm_instance,
284 _T("wxAppTraits::CreateFontMapper() failed") );
285 }
286
287 if ( !sm_instance )
288 {
289 // last resort: we must create something because the existing code
290 // relies on always having a valid font mapper object
291 sm_instance = (wxFontMapper *)new wxFontMapperBase;
292 }
293 }
294
295 return (wxFontMapperBase*)sm_instance;
296 }
297
298 /* static */
299 wxFontMapper *wxFontMapperBase::Set(wxFontMapper *mapper)
300 {
301 wxFontMapper *old = sm_instance;
302 sm_instance = mapper;
303 return old;
304 }
305
306 #if wxUSE_CONFIG && wxUSE_FILECONFIG
307
308 // ----------------------------------------------------------------------------
309 // config usage customisation
310 // ----------------------------------------------------------------------------
311
312 /* static */
313 const wxChar *wxFontMapperBase::GetDefaultConfigPath()
314 {
315 return FONTMAPPER_ROOT_PATH;
316 }
317
318 void wxFontMapperBase::SetConfigPath(const wxString& prefix)
319 {
320 wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
321 wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
322
323 m_configRootPath = prefix;
324 }
325
326 // ----------------------------------------------------------------------------
327 // get config object and path for it
328 // ----------------------------------------------------------------------------
329
330 wxConfigBase *wxFontMapperBase::GetConfig()
331 {
332 wxConfigBase *config = wxConfig::Get(false);
333
334 // If there is no global configuration, use an internal memory configuration
335 if ( !config )
336 {
337 if ( !m_configDummy )
338 m_configDummy = new wxMemoryConfig;
339 config = m_configDummy;
340
341 // FIXME: ideally, we should add keys from dummy config to a real one later,
342 // but it is a low-priority task because typical wxWin application
343 // either doesn't use wxConfig at all or creates wxConfig object in
344 // wxApp::OnInit(), before any real interaction with the user takes
345 // place...
346 }
347
348 return config;
349 }
350
351 const wxString& wxFontMapperBase::GetConfigPath()
352 {
353 if ( !m_configRootPath )
354 {
355 // use the default
356 m_configRootPath = GetDefaultConfigPath();
357 }
358
359 return m_configRootPath;
360 }
361
362 // ----------------------------------------------------------------------------
363 // config helpers
364 // ----------------------------------------------------------------------------
365
366 bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
367 {
368 wxConfigBase *config = GetConfig();
369 if ( !config )
370 return false;
371
372 *pathOld = config->GetPath();
373
374 wxString path = GetConfigPath();
375 if ( path.IsEmpty() || path.Last() != wxCONFIG_PATH_SEPARATOR )
376 {
377 path += wxCONFIG_PATH_SEPARATOR;
378 }
379
380 wxASSERT_MSG( !pathNew || (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
381 wxT("should be a relative path") );
382
383 path += pathNew;
384
385 config->SetPath(path);
386
387 return true;
388 }
389
390 void wxFontMapperBase::RestorePath(const wxString& pathOld)
391 {
392 GetConfig()->SetPath(pathOld);
393 }
394
395 #endif
396
397 // ----------------------------------------------------------------------------
398 // charset/encoding correspondence
399 // ----------------------------------------------------------------------------
400
401 wxFontEncoding
402 wxFontMapperBase::CharsetToEncoding(const wxString& charset,
403 bool WXUNUSED(interactive))
404 {
405 int enc = NonInteractiveCharsetToEncoding(charset);
406 if ( enc == wxFONTENCODING_UNKNOWN )
407 {
408 // we should return wxFONTENCODING_SYSTEM from here for unknown
409 // encodings
410 enc = wxFONTENCODING_SYSTEM;
411 }
412
413 return (wxFontEncoding)enc;
414 }
415
416 int
417 wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
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 && wxUSE_FILECONFIG
425 // first try the user-defined settings
426 wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
427 if ( path.IsOk() )
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 value;
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.IsEmpty() )
459 {
460 // yes, we do - use it instead
461 cs = alias;
462 }
463 }
464 }
465 #endif // wxUSE_CONFIG
466
467 // if didn't find it there, try to recognize it ourselves
468 if ( encoding == wxFONTENCODING_SYSTEM )
469 {
470 // trim any spaces
471 cs.Trim(true);
472 cs.Trim(false);
473
474 // discard the optional quotes
475 if ( !cs.empty() )
476 {
477 if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
478 {
479 cs = wxString(cs.c_str(), cs.length() - 1);
480 }
481 }
482
483 for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); ++i )
484 {
485 for ( const wxChar** encName = gs_encodingNames[i]; *encName; ++encName )
486 {
487 if ( cs.CmpNoCase(*encName) == 0 )
488 return gs_encodings[i];
489 }
490 }
491
492 cs.MakeUpper();
493
494 if ( cs.Left(3) == wxT("ISO") )
495 {
496 // the dash is optional (or, to be exact, it is not, but
497 // several brokenmails "forget" it)
498 const wxChar *p = cs.c_str() + 3;
499 if ( *p == wxT('-') )
500 p++;
501
502 // printf( "iso %s\n", (const char*) cs.ToAscii() );
503
504 unsigned int value;
505 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
506 {
507 // printf( "value %d\n", (int)value );
508
509 // make it 0 based and check that it is strictly positive in
510 // the process (no such thing as iso8859-0 encoding)
511 if ( (value-- > 0) &&
512 (value < wxFONTENCODING_ISO8859_MAX -
513 wxFONTENCODING_ISO8859_1) )
514 {
515 // it's a valid ISO8859 encoding
516 value += wxFONTENCODING_ISO8859_1;
517 encoding = (wxFontEncoding)value;
518 }
519 }
520 }
521 else if ( cs.Left(4) == wxT("8859") )
522 {
523 const wxChar *p = cs.c_str();
524
525 unsigned int value;
526 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
527 {
528 // printf( "value %d\n", (int)value );
529
530 // make it 0 based and check that it is strictly positive in
531 // the process (no such thing as iso8859-0 encoding)
532 if ( (value-- > 0) &&
533 (value < wxFONTENCODING_ISO8859_MAX -
534 wxFONTENCODING_ISO8859_1) )
535 {
536 // it's a valid ISO8859 encoding
537 value += wxFONTENCODING_ISO8859_1;
538 encoding = (wxFontEncoding)value;
539 }
540 }
541 }
542 else // check for Windows charsets
543 {
544 size_t len;
545 if ( cs.Left(7) == wxT("WINDOWS") )
546 {
547 len = 7;
548 }
549 else if ( cs.Left(2) == wxT("CP") )
550 {
551 len = 2;
552 }
553 else // not a Windows encoding
554 {
555 len = 0;
556 }
557
558 if ( len )
559 {
560 const wxChar *p = cs.c_str() + len;
561 if ( *p == wxT('-') )
562 p++;
563
564 unsigned int value;
565 if ( wxSscanf(p, wxT("%u"), &value) == 1 )
566 {
567 if ( value >= 1250 )
568 {
569 value -= 1250;
570 if ( value < wxFONTENCODING_CP12_MAX -
571 wxFONTENCODING_CP1250 )
572 {
573 // a valid Windows code page
574 value += wxFONTENCODING_CP1250;
575 encoding = (wxFontEncoding)value;
576 }
577 }
578
579 switch ( value )
580 {
581 case 874:
582 encoding = wxFONTENCODING_CP874;
583 break;
584
585 case 932:
586 encoding = wxFONTENCODING_CP932;
587 break;
588
589 case 936:
590 encoding = wxFONTENCODING_CP936;
591 break;
592
593 case 949:
594 encoding = wxFONTENCODING_CP949;
595 break;
596
597 case 950:
598 encoding = wxFONTENCODING_CP950;
599 break;
600 }
601 }
602 }
603 }
604 //else: unknown
605 }
606
607 return encoding;
608 }
609
610 /* static */
611 size_t wxFontMapperBase::GetSupportedEncodingsCount()
612 {
613 return WXSIZEOF(gs_encodings);
614 }
615
616 /* static */
617 wxFontEncoding wxFontMapperBase::GetEncoding(size_t n)
618 {
619 wxCHECK_MSG( n < WXSIZEOF(gs_encodings), wxFONTENCODING_SYSTEM,
620 _T("wxFontMapper::GetEncoding(): invalid index") );
621
622 return gs_encodings[n];
623 }
624
625 /* static */
626 wxString wxFontMapperBase::GetEncodingDescription(wxFontEncoding encoding)
627 {
628 if ( encoding == wxFONTENCODING_DEFAULT )
629 {
630 return _("Default encoding");
631 }
632
633 const size_t count = WXSIZEOF(gs_encodingDescs);
634
635 for ( size_t i = 0; i < count; i++ )
636 {
637 if ( gs_encodings[i] == encoding )
638 {
639 return wxGetTranslation(gs_encodingDescs[i]);
640 }
641 }
642
643 wxString str;
644 str.Printf(_("Unknown encoding (%d)"), encoding);
645
646 return str;
647 }
648
649 /* static */
650 wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
651 {
652 if ( encoding == wxFONTENCODING_DEFAULT )
653 {
654 return _("default");
655 }
656
657 const size_t count = WXSIZEOF(gs_encodingNames);
658
659 for ( size_t i = 0; i < count; i++ )
660 {
661 if ( gs_encodings[i] == encoding )
662 {
663 return gs_encodingNames[i][0];
664 }
665 }
666
667 wxString str;
668 str.Printf(_("unknown-%d"), encoding);
669
670 return str;
671 }
672
673 /* static */
674 const wxChar** wxFontMapperBase::GetAllEncodingNames(wxFontEncoding encoding)
675 {
676 static const wxChar* dummy[] = { NULL };
677
678 for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); i++ )
679 {
680 if ( gs_encodings[i] == encoding )
681 {
682 return gs_encodingNames[i];
683 }
684 }
685
686 return dummy;
687 }
688
689 /* static */
690 wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
691 {
692 const size_t count = WXSIZEOF(gs_encodingNames);
693
694 for ( size_t i = 0; i < count; i++ )
695 {
696 for ( const wxChar** encName = gs_encodingNames[i]; *encName; ++encName )
697 {
698 if ( name.CmpNoCase(*encName) == 0 )
699 return gs_encodings[i];
700 }
701 }
702
703 return wxFONTENCODING_MAX;
704 }
705
706 #endif // wxUSE_FONTMAP
707