]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/fmapbase.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
fixing focus handling for generic controls in carbon-cfm
[wxWidgets.git] / src / common / fmapbase.cpp
... / ...
CommitLineData
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
57static 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
106static 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!)
155static const wxChar* gs_encodingNames[WXSIZEOF(gs_encodingDescs)][10] =
156{
157 // names from the first column are used under Linux, from the second one
158 // under Solaris and IRIX and from the third one -- under AIX
159 { wxT( "ISO-8859-1" ), wxT( "ISO8859-1" ), wxT( "8859-1" ), wxT("iso_8859_1"), NULL },
160 { wxT( "ISO-8859-2" ), wxT( "ISO8859-2" ), wxT( "8859-2" ), NULL },
161 { wxT( "ISO-8859-3" ), wxT( "ISO8859-3" ), wxT( "8859-3" ), NULL },
162 { wxT( "ISO-8859-4" ), wxT( "ISO8859-4" ), wxT( "8859-4" ), NULL },
163 { wxT( "ISO-8859-5" ), wxT( "ISO8859-5" ), wxT( "8859-5" ), NULL },
164 { wxT( "ISO-8859-6" ), wxT( "ISO8859-6" ), wxT( "8859-6" ), NULL },
165 { wxT( "ISO-8859-7" ), wxT( "ISO8859-7" ), wxT( "8859-7" ), NULL },
166 { wxT( "ISO-8859-8" ), wxT( "ISO8859-8" ), wxT( "8859-8" ), NULL },
167 { wxT( "ISO-8859-9" ), wxT( "ISO8859-9" ), wxT( "8859-9" ), NULL },
168 { wxT( "ISO-8859-10" ), wxT( "ISO8859-10" ), wxT( "8859-10" ), NULL },
169 { wxT( "ISO-8859-11" ), wxT( "ISO8859-11" ), wxT( "8859-11" ), NULL },
170 { wxT( "ISO-8859-12" ), wxT( "ISO8859-12" ), wxT( "8859-12" ), NULL },
171 { wxT( "ISO-8859-13" ), wxT( "ISO8859-13" ), wxT( "8859-13" ), NULL },
172 { wxT( "ISO-8859-14" ), wxT( "ISO8859-14" ), wxT( "8859-14" ), NULL },
173 { wxT( "ISO-8859-15" ), wxT( "ISO8859-15" ), wxT( "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" ), NULL },
197 { wxT( "UTF-8" ), 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" ), NULL },
212 { wxT( "shift-jis" ), wxT( "shift_jis" ), wxT( "sjis" ), NULL },
213 { wxT( "GB2312" ), NULL },
214};
215
216wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingDescs) == WXSIZEOF(gs_encodings), EncodingsArraysNotInSync );
217wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingNames) == WXSIZEOF(gs_encodings), EncodingsArraysNotInSync );
218
219// ----------------------------------------------------------------------------
220// private classes
221// ----------------------------------------------------------------------------
222
223// clean up the font mapper object
224class wxFontMapperModule : public wxModule
225{
226public:
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
234IMPLEMENT_DYNAMIC_CLASS(wxFontMapperModule, wxModule)
235
236
237// ============================================================================
238// wxFontMapperBase implementation
239// ============================================================================
240
241wxFontMapper *wxFontMapperBase::sm_instance = NULL;
242
243// ----------------------------------------------------------------------------
244// ctor and dtor
245// ----------------------------------------------------------------------------
246
247wxFontMapperBase::wxFontMapperBase()
248{
249#if wxUSE_CONFIG && wxUSE_FILECONFIG
250 m_config = NULL;
251 m_configIsDummy = false;
252#endif // wxUSE_CONFIG
253}
254
255wxFontMapperBase::~wxFontMapperBase()
256{
257#if wxUSE_CONFIG && wxUSE_FILECONFIG
258 if ( m_configIsDummy )
259 delete m_config;
260#endif // wxUSE_CONFIG
261}
262
263bool wxFontMapperBase::IsWxFontMapper()
264{ return false; }
265
266/* static */
267wxFontMapperBase *wxFontMapperBase::Get()
268{
269 if ( !sm_instance )
270 {
271 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
272 if ( traits )
273 {
274 sm_instance = traits->CreateFontMapper();
275
276 wxASSERT_MSG( sm_instance,
277 _T("wxAppTraits::CreateFontMapper() failed") );
278 }
279
280 if ( !sm_instance )
281 {
282 // last resort: we must create something because the existing code
283 // relies on always having a valid font mapper object
284 sm_instance = (wxFontMapper *)new wxFontMapperBase;
285 }
286 }
287
288 return (wxFontMapperBase*)sm_instance;
289}
290
291/* static */
292wxFontMapper *wxFontMapperBase::Set(wxFontMapper *mapper)
293{
294 wxFontMapper *old = sm_instance;
295 sm_instance = mapper;
296 return old;
297}
298
299#if wxUSE_CONFIG && wxUSE_FILECONFIG
300
301// ----------------------------------------------------------------------------
302// config usage customisation
303// ----------------------------------------------------------------------------
304
305/* static */
306const wxChar *wxFontMapperBase::GetDefaultConfigPath()
307{
308 return FONTMAPPER_ROOT_PATH;
309}
310
311void wxFontMapperBase::SetConfigPath(const wxString& prefix)
312{
313 wxCHECK_RET( !prefix.IsEmpty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
314 wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
315
316 m_configRootPath = prefix;
317}
318
319// ----------------------------------------------------------------------------
320// get config object and path for it
321// ----------------------------------------------------------------------------
322
323wxConfigBase *wxFontMapperBase::GetConfig()
324{
325 if ( !m_config )
326 {
327 // try the default
328 m_config = wxConfig::Get(false /*don't create on demand*/ );
329
330 if ( !m_config )
331 {
332 // we still want to have a config object because otherwise we would
333 // keep asking the user the same questions in the interactive mode,
334 // so create a dummy config which won't write to any files/registry
335 // but will allow us to remember the results of the questions at
336 // least during this run
337 m_config = new wxMemoryConfig;
338 m_configIsDummy = true;
339 // VS: we can't call wxConfig::Set(m_config) here because that would
340 // disable automatic wxConfig instance creation if this code was
341 // called before wxApp::OnInit (this happens in wxGTK -- it sets
342 // default wxFont encoding in wxApp::Initialize())
343 }
344 }
345
346 if ( m_configIsDummy && wxConfig::Get(false) != NULL )
347 {
348 // VS: in case we created dummy m_config (see above), we want to switch back
349 // to the real one as soon as one becomes available.
350 delete m_config;
351 m_config = wxConfig::Get(false);
352 m_configIsDummy = false;
353 // FIXME: ideally, we should add keys from dummy config to the real one now,
354 // but it is a low-priority task because typical wxWin application
355 // either doesn't use wxConfig at all or creates wxConfig object in
356 // wxApp::OnInit(), before any real interaction with the user takes
357 // place...
358 }
359
360 return m_config;
361}
362
363const wxString& wxFontMapperBase::GetConfigPath()
364{
365 if ( !m_configRootPath )
366 {
367 // use the default
368 m_configRootPath = GetDefaultConfigPath();
369 }
370
371 return m_configRootPath;
372}
373
374// ----------------------------------------------------------------------------
375// config helpers
376// ----------------------------------------------------------------------------
377
378bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
379{
380 wxConfigBase *config = GetConfig();
381 if ( !config )
382 return false;
383
384 *pathOld = config->GetPath();
385
386 wxString path = GetConfigPath();
387 if ( path.IsEmpty() || path.Last() != wxCONFIG_PATH_SEPARATOR )
388 {
389 path += wxCONFIG_PATH_SEPARATOR;
390 }
391
392 wxASSERT_MSG( !pathNew || (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
393 wxT("should be a relative path") );
394
395 path += pathNew;
396
397 config->SetPath(path);
398
399 return true;
400}
401
402void wxFontMapperBase::RestorePath(const wxString& pathOld)
403{
404 GetConfig()->SetPath(pathOld);
405}
406
407#endif
408
409// ----------------------------------------------------------------------------
410// charset/encoding correspondence
411// ----------------------------------------------------------------------------
412
413wxFontEncoding
414wxFontMapperBase::CharsetToEncoding(const wxString& charset,
415 bool WXUNUSED(interactive))
416{
417 int enc = NonInteractiveCharsetToEncoding(charset);
418 if ( enc == wxFONTENCODING_UNKNOWN )
419 {
420 // we should return wxFONTENCODING_SYSTEM from here for unknown
421 // encodings
422 enc = wxFONTENCODING_SYSTEM;
423 }
424
425 return (wxFontEncoding)enc;
426}
427
428int
429wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
430{
431 wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
432
433 // we're going to modify it, make a copy
434 wxString cs = charset;
435
436#if wxUSE_CONFIG && wxUSE_FILECONFIG
437 // first try the user-defined settings
438 wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
439 if ( path.IsOk() )
440 {
441 wxConfigBase *config = GetConfig();
442
443 // do we have an encoding for this charset?
444 long value = config->Read(charset, -1l);
445 if ( value != -1 )
446 {
447 if ( value == wxFONTENCODING_UNKNOWN )
448 {
449 // don't try to find it, in particular don't ask the user
450 return value;
451 }
452
453 if ( value >= 0 && value <= wxFONTENCODING_MAX )
454 {
455 encoding = (wxFontEncoding)value;
456 }
457 else
458 {
459 wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
460 value, charset.c_str());
461 }
462 }
463
464 if ( encoding == wxFONTENCODING_SYSTEM )
465 {
466 // may be we have an alias?
467 config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
468
469 wxString alias = config->Read(charset);
470 if ( !alias.IsEmpty() )
471 {
472 // yes, we do - use it instead
473 cs = alias;
474 }
475 }
476 }
477#endif // wxUSE_CONFIG
478
479 // if didn't find it there, try to recognize it ourselves
480 if ( encoding == wxFONTENCODING_SYSTEM )
481 {
482 // trim any spaces
483 cs.Trim(true);
484 cs.Trim(false);
485
486 // discard the optional quotes
487 if ( !cs.empty() )
488 {
489 if ( cs[0u] == _T('"') && cs.Last() == _T('"') )
490 {
491 cs = wxString(cs.c_str(), cs.length() - 1);
492 }
493 }
494
495 for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); ++i )
496 {
497 for ( const wxChar** encName = gs_encodingNames[i]; *encName; ++encName )
498 {
499 if ( cs.CmpNoCase(*encName) == 0 )
500 return gs_encodings[i];
501 }
502 }
503
504 cs.MakeUpper();
505
506 if ( cs.Left(3) == wxT("ISO") )
507 {
508 // the dash is optional (or, to be exact, it is not, but
509 // several brokenmails "forget" it)
510 const wxChar *p = cs.c_str() + 3;
511 if ( *p == wxT('-') )
512 p++;
513
514 // printf( "iso %s\n", (const char*) cs.ToAscii() );
515
516 unsigned int value;
517 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
518 {
519 // printf( "value %d\n", (int)value );
520
521 // make it 0 based and check that it is strictly positive in
522 // the process (no such thing as iso8859-0 encoding)
523 if ( (value-- > 0) &&
524 (value < wxFONTENCODING_ISO8859_MAX -
525 wxFONTENCODING_ISO8859_1) )
526 {
527 // it's a valid ISO8859 encoding
528 value += wxFONTENCODING_ISO8859_1;
529 encoding = (wxFontEncoding)value;
530 }
531 }
532 }
533 else if ( cs.Left(4) == wxT("8859") )
534 {
535 const wxChar *p = cs.c_str();
536
537 unsigned int value;
538 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
539 {
540 // printf( "value %d\n", (int)value );
541
542 // make it 0 based and check that it is strictly positive in
543 // the process (no such thing as iso8859-0 encoding)
544 if ( (value-- > 0) &&
545 (value < wxFONTENCODING_ISO8859_MAX -
546 wxFONTENCODING_ISO8859_1) )
547 {
548 // it's a valid ISO8859 encoding
549 value += wxFONTENCODING_ISO8859_1;
550 encoding = (wxFontEncoding)value;
551 }
552 }
553 }
554 else // check for Windows charsets
555 {
556 size_t len;
557 if ( cs.Left(7) == wxT("WINDOWS") )
558 {
559 len = 7;
560 }
561 else if ( cs.Left(2) == wxT("CP") )
562 {
563 len = 2;
564 }
565 else // not a Windows encoding
566 {
567 len = 0;
568 }
569
570 if ( len )
571 {
572 const wxChar *p = cs.c_str() + len;
573 if ( *p == wxT('-') )
574 p++;
575
576 unsigned int value;
577 if ( wxSscanf(p, wxT("%u"), &value) == 1 )
578 {
579 if ( value >= 1250 )
580 {
581 value -= 1250;
582 if ( value < wxFONTENCODING_CP12_MAX -
583 wxFONTENCODING_CP1250 )
584 {
585 // a valid Windows code page
586 value += wxFONTENCODING_CP1250;
587 encoding = (wxFontEncoding)value;
588 }
589 }
590
591 switch ( value )
592 {
593 case 874:
594 encoding = wxFONTENCODING_CP874;
595 break;
596
597 case 932:
598 encoding = wxFONTENCODING_CP932;
599 break;
600
601 case 936:
602 encoding = wxFONTENCODING_CP936;
603 break;
604
605 case 949:
606 encoding = wxFONTENCODING_CP949;
607 break;
608
609 case 950:
610 encoding = wxFONTENCODING_CP950;
611 break;
612 }
613 }
614 }
615 }
616 //else: unknown
617 }
618
619 return encoding;
620}
621
622/* static */
623size_t wxFontMapperBase::GetSupportedEncodingsCount()
624{
625 return WXSIZEOF(gs_encodings);
626}
627
628/* static */
629wxFontEncoding wxFontMapperBase::GetEncoding(size_t n)
630{
631 wxCHECK_MSG( n < WXSIZEOF(gs_encodings), wxFONTENCODING_SYSTEM,
632 _T("wxFontMapper::GetEncoding(): invalid index") );
633
634 return gs_encodings[n];
635}
636
637/* static */
638wxString wxFontMapperBase::GetEncodingDescription(wxFontEncoding encoding)
639{
640 if ( encoding == wxFONTENCODING_DEFAULT )
641 {
642 return _("Default encoding");
643 }
644
645 const size_t count = WXSIZEOF(gs_encodingDescs);
646
647 for ( size_t i = 0; i < count; i++ )
648 {
649 if ( gs_encodings[i] == encoding )
650 {
651 return wxGetTranslation(gs_encodingDescs[i]);
652 }
653 }
654
655 wxString str;
656 str.Printf(_("Unknown encoding (%d)"), encoding);
657
658 return str;
659}
660
661/* static */
662wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
663{
664 if ( encoding == wxFONTENCODING_DEFAULT )
665 {
666 return _("default");
667 }
668
669 const size_t count = WXSIZEOF(gs_encodingNames);
670
671 for ( size_t i = 0; i < count; i++ )
672 {
673 if ( gs_encodings[i] == encoding )
674 {
675 return gs_encodingNames[i][0];
676 }
677 }
678
679 wxString str;
680 str.Printf(_("unknown-%d"), encoding);
681
682 return str;
683}
684
685/* static */
686const wxChar** wxFontMapperBase::GetAllEncodingNames(wxFontEncoding encoding)
687{
688 static const wxChar* dummy[] = { NULL };
689
690 for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); i++ )
691 {
692 if ( gs_encodings[i] == encoding )
693 {
694 return gs_encodingNames[i];
695 }
696 }
697
698 return dummy;
699}
700
701/* static */
702wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
703{
704 const size_t count = WXSIZEOF(gs_encodingNames);
705
706 for ( size_t i = 0; i < count; i++ )
707 {
708 for ( const wxChar** encName = gs_encodingNames[i]; *encName; ++encName )
709 {
710 if ( name.CmpNoCase(*encName) == 0 )
711 return gs_encodings[i];
712 }
713 }
714
715 return wxFONTENCODING_MAX;
716}
717
718#endif // wxUSE_FONTMAP
719
wxWidgets (Impactor)