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