]> git.saurik.com Git - wxWidgets.git/blob - src/common/fmapbase.cpp
Supress SetFocus() warning in wxVListBoxComboPopup
[wxWidgets.git] / src / common / fmapbase.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: src/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 #include "wx/module.h"
34 #include "wx/wxcrtvararg.h"
35 #endif //WX_PRECOMP
36
37 #if defined(__WXMSW__)
38 #include "wx/msw/private.h" // includes windows.h for LOGFONT
39 #include "wx/msw/winundef.h"
40 #endif
41
42 #include "wx/fontmap.h"
43 #include "wx/fmappriv.h"
44
45 #include "wx/apptrait.h"
46
47 // wxMemoryConfig uses wxFileConfig
48 #if wxUSE_CONFIG && wxUSE_FILECONFIG
49 #include "wx/config.h"
50 #include "wx/memconf.h"
51 #endif
52
53 // ----------------------------------------------------------------------------
54 // constants
55 // ----------------------------------------------------------------------------
56
57 // encodings supported by GetEncodingDescription
58 static const wxFontEncoding gs_encodings[] =
59 {
60 wxFONTENCODING_ISO8859_1,
61 wxFONTENCODING_ISO8859_2,
62 wxFONTENCODING_ISO8859_3,
63 wxFONTENCODING_ISO8859_4,
64 wxFONTENCODING_ISO8859_5,
65 wxFONTENCODING_ISO8859_6,
66 wxFONTENCODING_ISO8859_7,
67 wxFONTENCODING_ISO8859_8,
68 wxFONTENCODING_ISO8859_9,
69 wxFONTENCODING_ISO8859_10,
70 wxFONTENCODING_ISO8859_11,
71 wxFONTENCODING_ISO8859_12,
72 wxFONTENCODING_ISO8859_13,
73 wxFONTENCODING_ISO8859_14,
74 wxFONTENCODING_ISO8859_15,
75 wxFONTENCODING_KOI8,
76 wxFONTENCODING_KOI8_U,
77 wxFONTENCODING_CP874,
78 wxFONTENCODING_CP932,
79 wxFONTENCODING_CP936,
80 wxFONTENCODING_CP949,
81 wxFONTENCODING_CP950,
82 wxFONTENCODING_CP1250,
83 wxFONTENCODING_CP1251,
84 wxFONTENCODING_CP1252,
85 wxFONTENCODING_CP1253,
86 wxFONTENCODING_CP1254,
87 wxFONTENCODING_CP1255,
88 wxFONTENCODING_CP1256,
89 wxFONTENCODING_CP1257,
90 wxFONTENCODING_CP437,
91 wxFONTENCODING_UTF7,
92 wxFONTENCODING_UTF8,
93 wxFONTENCODING_UTF16BE,
94 wxFONTENCODING_UTF16LE,
95 wxFONTENCODING_UTF32BE,
96 wxFONTENCODING_UTF32LE,
97 wxFONTENCODING_EUC_JP,
98 wxFONTENCODING_DEFAULT,
99 wxFONTENCODING_BIG5,
100 wxFONTENCODING_SHIFT_JIS,
101 wxFONTENCODING_GB2312,
102 wxFONTENCODING_ISO2022_JP,
103
104 wxFONTENCODING_MACROMAN,
105 wxFONTENCODING_MACJAPANESE,
106 wxFONTENCODING_MACCHINESETRAD,
107 wxFONTENCODING_MACKOREAN,
108 wxFONTENCODING_MACARABIC,
109 wxFONTENCODING_MACHEBREW,
110 wxFONTENCODING_MACGREEK,
111 wxFONTENCODING_MACCYRILLIC,
112 wxFONTENCODING_MACDEVANAGARI,
113 wxFONTENCODING_MACGURMUKHI,
114 wxFONTENCODING_MACGUJARATI,
115 wxFONTENCODING_MACORIYA,
116 wxFONTENCODING_MACBENGALI,
117 wxFONTENCODING_MACTAMIL,
118 wxFONTENCODING_MACTELUGU,
119 wxFONTENCODING_MACKANNADA,
120 wxFONTENCODING_MACMALAJALAM,
121 wxFONTENCODING_MACSINHALESE,
122 wxFONTENCODING_MACBURMESE,
123 wxFONTENCODING_MACKHMER,
124 wxFONTENCODING_MACTHAI,
125 wxFONTENCODING_MACLAOTIAN,
126 wxFONTENCODING_MACGEORGIAN,
127 wxFONTENCODING_MACARMENIAN,
128 wxFONTENCODING_MACCHINESESIMP,
129 wxFONTENCODING_MACTIBETAN,
130 wxFONTENCODING_MACMONGOLIAN,
131 wxFONTENCODING_MACETHIOPIC,
132 wxFONTENCODING_MACCENTRALEUR,
133 wxFONTENCODING_MACVIATNAMESE,
134 wxFONTENCODING_MACARABICEXT,
135 wxFONTENCODING_MACSYMBOL,
136 wxFONTENCODING_MACDINGBATS,
137 wxFONTENCODING_MACTURKISH,
138 wxFONTENCODING_MACCROATIAN,
139 wxFONTENCODING_MACICELANDIC,
140 wxFONTENCODING_MACROMANIAN,
141 wxFONTENCODING_MACCELTIC,
142 wxFONTENCODING_MACGAELIC,
143 wxFONTENCODING_MACKEYBOARD
144 };
145
146 // the descriptions for them
147 static const char* const gs_encodingDescs[] =
148 {
149 wxTRANSLATE( "Western European (ISO-8859-1)" ),
150 wxTRANSLATE( "Central European (ISO-8859-2)" ),
151 wxTRANSLATE( "Esperanto (ISO-8859-3)" ),
152 wxTRANSLATE( "Baltic (old) (ISO-8859-4)" ),
153 wxTRANSLATE( "Cyrillic (ISO-8859-5)" ),
154 wxTRANSLATE( "Arabic (ISO-8859-6)" ),
155 wxTRANSLATE( "Greek (ISO-8859-7)" ),
156 wxTRANSLATE( "Hebrew (ISO-8859-8)" ),
157 wxTRANSLATE( "Turkish (ISO-8859-9)" ),
158 wxTRANSLATE( "Nordic (ISO-8859-10)" ),
159 wxTRANSLATE( "Thai (ISO-8859-11)" ),
160 wxTRANSLATE( "Indian (ISO-8859-12)" ),
161 wxTRANSLATE( "Baltic (ISO-8859-13)" ),
162 wxTRANSLATE( "Celtic (ISO-8859-14)" ),
163 wxTRANSLATE( "Western European with Euro (ISO-8859-15)" ),
164 wxTRANSLATE( "KOI8-R" ),
165 wxTRANSLATE( "KOI8-U" ),
166 wxTRANSLATE( "Windows Thai (CP 874)" ),
167 wxTRANSLATE( "Windows Japanese (CP 932)" ),
168 wxTRANSLATE( "Windows Chinese Simplified (CP 936)" ),
169 wxTRANSLATE( "Windows Korean (CP 949)" ),
170 wxTRANSLATE( "Windows Chinese Traditional (CP 950)" ),
171 wxTRANSLATE( "Windows Central European (CP 1250)" ),
172 wxTRANSLATE( "Windows Cyrillic (CP 1251)" ),
173 wxTRANSLATE( "Windows Western European (CP 1252)" ),
174 wxTRANSLATE( "Windows Greek (CP 1253)" ),
175 wxTRANSLATE( "Windows Turkish (CP 1254)" ),
176 wxTRANSLATE( "Windows Hebrew (CP 1255)" ),
177 wxTRANSLATE( "Windows Arabic (CP 1256)" ),
178 wxTRANSLATE( "Windows Baltic (CP 1257)" ),
179 wxTRANSLATE( "Windows/DOS OEM (CP 437)" ),
180 wxTRANSLATE( "Unicode 7 bit (UTF-7)" ),
181 wxTRANSLATE( "Unicode 8 bit (UTF-8)" ),
182 #ifdef WORDS_BIGENDIAN
183 wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
184 wxTRANSLATE( "Unicode 16 bit Little Endian (UTF-16LE)" ),
185 wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
186 wxTRANSLATE( "Unicode 32 bit Little Endian (UTF-32LE)" ),
187 #else // WORDS_BIGENDIAN
188 wxTRANSLATE( "Unicode 16 bit Big Endian (UTF-16BE)" ),
189 wxTRANSLATE( "Unicode 16 bit (UTF-16)" ),
190 wxTRANSLATE( "Unicode 32 bit Big Endian (UTF-32BE)" ),
191 wxTRANSLATE( "Unicode 32 bit (UTF-32)" ),
192 #endif // WORDS_BIGENDIAN
193 wxTRANSLATE( "Extended Unix Codepage for Japanese (EUC-JP)" ),
194 wxTRANSLATE( "US-ASCII" ),
195 wxTRANSLATE( "BIG5" ),
196 wxTRANSLATE( "SHIFT-JIS" ),
197 wxTRANSLATE( "GB-2312" ),
198 wxTRANSLATE( "ISO-2022-JP" ),
199
200 wxTRANSLATE( "MacRoman" ),
201 wxTRANSLATE( "MacJapanese" ),
202 wxTRANSLATE( "MacChineseTrad" ),
203 wxTRANSLATE( "MacKorean" ),
204 wxTRANSLATE( "MacArabic" ),
205 wxTRANSLATE( "MacHebrew" ),
206 wxTRANSLATE( "MacGreek" ),
207 wxTRANSLATE( "MacCyrillic" ),
208 wxTRANSLATE( "MacDevanagari" ),
209 wxTRANSLATE( "MacGurmukhi" ),
210 wxTRANSLATE( "MacGujarati" ),
211 wxTRANSLATE( "MacOriya" ),
212 wxTRANSLATE( "MacBengali" ),
213 wxTRANSLATE( "MacTamil" ),
214 wxTRANSLATE( "MacTelugu" ),
215 wxTRANSLATE( "MacKannada" ),
216 wxTRANSLATE( "MacMalayalam" ),
217 wxTRANSLATE( "MacSinhalese" ),
218 wxTRANSLATE( "MacBurmese" ),
219 wxTRANSLATE( "MacKhmer" ),
220 wxTRANSLATE( "MacThai" ),
221 wxTRANSLATE( "MacLaotian" ),
222 wxTRANSLATE( "MacGeorgian" ),
223 wxTRANSLATE( "MacArmenian" ),
224 wxTRANSLATE( "MacChineseSimp" ),
225 wxTRANSLATE( "MacTibetan" ),
226 wxTRANSLATE( "MacMongolian" ),
227 wxTRANSLATE( "MacEthiopic" ),
228 wxTRANSLATE( "MacCentralEurRoman" ),
229 wxTRANSLATE( "MacVietnamese" ),
230 wxTRANSLATE( "MacExtArabic" ),
231 wxTRANSLATE( "MacSymbol" ),
232 wxTRANSLATE( "MacDingbats" ),
233 wxTRANSLATE( "MacTurkish" ),
234 wxTRANSLATE( "MacCroatian" ),
235 wxTRANSLATE( "MacIcelandic" ),
236 wxTRANSLATE( "MacRomanian" ),
237 wxTRANSLATE( "MacCeltic" ),
238 wxTRANSLATE( "MacGaelic" ),
239 wxTRANSLATE( "MacKeyboardGlyphs" )
240 };
241
242 // and the internal names (these are not translated on purpose!)
243 static const wxChar* const gs_encodingNames[WXSIZEOF(gs_encodingDescs)][9] =
244 {
245 // names from the columns correspond to these OS:
246 // Linux Solaris and IRIX HP-UX AIX
247 { wxT("ISO-8859-1"), wxT("ISO8859-1"), wxT("iso88591"), wxT("8859-1"), wxT("iso_8859_1"), NULL },
248 { wxT("ISO-8859-2"), wxT("ISO8859-2"), wxT("iso88592"), wxT("8859-2"), NULL },
249 { wxT("ISO-8859-3"), wxT("ISO8859-3"), wxT("iso88593"), wxT("8859-3"), NULL },
250 { wxT("ISO-8859-4"), wxT("ISO8859-4"), wxT("iso88594"), wxT("8859-4"), NULL },
251 { wxT("ISO-8859-5"), wxT("ISO8859-5"), wxT("iso88595"), wxT("8859-5"), NULL },
252 { wxT("ISO-8859-6"), wxT("ISO8859-6"), wxT("iso88596"), wxT("8859-6"), NULL },
253 { wxT("ISO-8859-7"), wxT("ISO8859-7"), wxT("iso88597"), wxT("8859-7"), NULL },
254 { wxT("ISO-8859-8"), wxT("ISO8859-8"), wxT("iso88598"), wxT("8859-8"), NULL },
255 { wxT("ISO-8859-9"), wxT("ISO8859-9"), wxT("iso88599"), wxT("8859-9"), NULL },
256 { wxT("ISO-8859-10"), wxT("ISO8859-10"), wxT("iso885910"), wxT("8859-10"), NULL },
257 { wxT("ISO-8859-11"), wxT("ISO8859-11"), wxT("iso885911"), wxT("8859-11"), NULL },
258 { wxT("ISO-8859-12"), wxT("ISO8859-12"), wxT("iso885912"), wxT("8859-12"), NULL },
259 { wxT("ISO-8859-13"), wxT("ISO8859-13"), wxT("iso885913"), wxT("8859-13"), NULL },
260 { wxT("ISO-8859-14"), wxT("ISO8859-14"), wxT("iso885914"), wxT("8859-14"), NULL },
261 { wxT("ISO-8859-15"), wxT("ISO8859-15"), wxT("iso885915"), wxT("8859-15"), NULL },
262
263 // although koi8-ru is not strictly speaking the same as koi8-r,
264 // they are similar enough to make mapping it to koi8 better than
265 // not recognizing it at all
266 { wxT( "KOI8-R" ), wxT( "KOI8-RU" ), NULL },
267 { wxT( "KOI8-U" ), NULL },
268
269 { wxT( "WINDOWS-874" ), wxT( "CP874" ), wxT( "MS874" ), wxT( "IBM-874" ), NULL },
270 { wxT( "WINDOWS-932" ), wxT( "CP932" ), wxT( "MS932" ), wxT( "IBM-932" ), NULL },
271 { wxT( "WINDOWS-936" ), wxT( "CP936" ), wxT( "MS936" ), wxT( "IBM-936" ), NULL },
272 { wxT( "WINDOWS-949" ), wxT( "CP949" ), wxT( "MS949" ), wxT( "IBM-949" ), wxT( "EUC-KR" ), wxT( "eucKR" ), wxT( "euc_kr" ), NULL },
273 { wxT( "WINDOWS-950" ), wxT( "CP950" ), wxT( "MS950" ), wxT( "IBM-950" ), NULL },
274 { wxT( "WINDOWS-1250" ),wxT( "CP1250" ),wxT( "MS1250" ),wxT( "IBM-1250" ),NULL },
275 { wxT( "WINDOWS-1251" ),wxT( "CP1251" ),wxT( "MS1251" ),wxT( "IBM-1251" ),NULL },
276 { wxT( "WINDOWS-1252" ),wxT( "CP1252" ),wxT( "MS1252" ),wxT( "IBM-1252" ),NULL },
277 { wxT( "WINDOWS-1253" ),wxT( "CP1253" ),wxT( "MS1253" ),wxT( "IBM-1253" ),NULL },
278 { wxT( "WINDOWS-1254" ),wxT( "CP1254" ),wxT( "MS1254" ),wxT( "IBM-1254" ),NULL },
279 { wxT( "WINDOWS-1255" ),wxT( "CP1255" ),wxT( "MS1255" ),wxT( "IBM-1255" ),NULL },
280 { wxT( "WINDOWS-1256" ),wxT( "CP1256" ),wxT( "MS1256" ),wxT( "IBM-1256" ),NULL },
281 { wxT( "WINDOWS-1257" ),wxT( "CP1257" ),wxT( "MS1257" ),wxT( "IBM-1257" ),NULL },
282 { wxT( "WINDOWS-437" ), wxT( "CP437" ), wxT( "MS437" ), wxT( "IBM-437" ), NULL },
283
284 { wxT( "UTF-7" ), wxT("UTF7"), NULL },
285 { wxT( "UTF-8" ), wxT("UTF8"), NULL },
286 #ifdef WORDS_BIGENDIAN
287 { wxT( "UTF-16BE" ), wxT("UTF16BE"), wxT("UCS-2BE"), wxT("UCS2BE"), wxT("UTF-16"), wxT("UTF16"), wxT("UCS-2"), wxT("UCS2"), NULL },
288 { wxT( "UTF-16LE" ), wxT("UTF16LE"), wxT("UCS-2LE"), wxT("UCS2LE"), NULL },
289 { wxT( "UTF-32BE" ), wxT("UTF32BE"), wxT("UCS-4BE" ), wxT("UTF-32"), wxT("UTF32"), wxT("UCS-4"), wxT("UCS4"), NULL },
290 { wxT( "UTF-32LE" ), wxT("UTF32LE"), wxT("UCS-4LE"), wxT("UCS4LE"), NULL },
291 #else // WORDS_BIGENDIAN
292 { wxT("UTF-16BE"), wxT("UTF16BE"), wxT("UCS-2BE"), wxT("UCS2BE"), NULL },
293 { wxT("UTF-16LE"), wxT("UTF16LE"), wxT("UCS-2LE"), wxT("UTF-16"), wxT("UTF16"), wxT("UCS-2"), wxT("UCS2"), NULL },
294 { wxT("UTF-32BE"), wxT("UTF32BE"), wxT("UCS-4BE"), wxT("UCS4BE"), NULL },
295 { wxT("UTF-32LE"), wxT("UTF32LE"), wxT("UCS-4LE"), wxT("UCS4LE"), wxT("UTF-32"), wxT("UTF32"), wxT("UCS-4"), wxT("UCS4"), NULL },
296 #endif // WORDS_BIGENDIAN
297
298 { wxT( "EUC-JP" ), wxT( "eucJP" ), wxT( "euc_jp" ), wxT( "IBM-eucJP" ), NULL },
299
300 // 646 is for Solaris, roman8 -- for HP-UX
301 { wxT( "US-ASCII" ), wxT( "ASCII" ), wxT("C"), wxT("POSIX"), wxT("ANSI_X3.4-1968"),
302 wxT("646"), wxT("roman8"), wxT( "" ), NULL },
303
304 { wxT( "BIG5" ), wxT("big5"), NULL },
305 { wxT( "SJIS" ), wxT( "SHIFT-JIS" ), wxT( "SHIFT_JIS" ), NULL },
306 { wxT( "GB2312" ), NULL },
307 { wxT( "ISO-2022-JP" ), NULL },
308
309
310 { wxT( "MacRoman" ), NULL },
311 { wxT( "MacJapanese" ), NULL },
312 { wxT( "MacChineseTrad" ), NULL },
313 { wxT( "MacKorean" ), NULL },
314 { wxT( "MacArabic" ), NULL },
315 { wxT( "MacHebrew" ), NULL },
316 { wxT( "MacGreek" ), NULL },
317 { wxT( "MacCyrillic" ), NULL },
318 { wxT( "MacDevanagari" ), NULL },
319 { wxT( "MacGurmukhi" ), NULL },
320 { wxT( "MacGujarati" ), NULL },
321 { wxT( "MacOriya" ), NULL },
322 { wxT( "MacBengali" ), NULL },
323 { wxT( "MacTamil" ), NULL },
324 { wxT( "MacTelugu" ), NULL },
325 { wxT( "MacKannada" ), NULL },
326 { wxT( "MacMalayalam" ), NULL },
327 { wxT( "MacSinhalese" ), NULL },
328 { wxT( "MacBurmese" ), NULL },
329 { wxT( "MacKhmer" ), NULL },
330 { wxT( "MacThai" ), NULL },
331 { wxT( "MacLaotian" ), NULL },
332 { wxT( "MacGeorgian" ), NULL },
333 { wxT( "MacArmenian" ), NULL },
334 { wxT( "MacChineseSimp" ), NULL },
335 { wxT( "MacTibetan" ), NULL },
336 { wxT( "MacMongolian" ), NULL },
337 { wxT( "MacEthiopic" ), NULL },
338 { wxT( "MacCentralEurRoman" ), NULL },
339 { wxT( "MacVietnamese" ), NULL },
340 { wxT( "MacExtArabic" ), NULL },
341 { wxT( "MacSymbol" ), NULL },
342 { wxT( "MacDingbats" ), NULL },
343 { wxT( "MacTurkish" ), NULL },
344 { wxT( "MacCroatian" ), NULL },
345 { wxT( "MacIcelandic" ), NULL },
346 { wxT( "MacRomanian" ), NULL },
347 { wxT( "MacCeltic" ), NULL },
348 { wxT( "MacGaelic" ), NULL },
349 { wxT( "MacKeyboardGlyphs" ), NULL }
350 };
351
352 wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingDescs) == WXSIZEOF(gs_encodings), EncodingsArraysNotInSync );
353 wxCOMPILE_TIME_ASSERT( WXSIZEOF(gs_encodingNames) == WXSIZEOF(gs_encodings), EncodingsArraysNotInSync );
354
355 // ----------------------------------------------------------------------------
356 // private classes
357 // ----------------------------------------------------------------------------
358
359 // clean up the font mapper object
360 class wxFontMapperModule : public wxModule
361 {
362 public:
363 wxFontMapperModule() : wxModule() { }
364
365 virtual bool OnInit()
366 {
367 // a dummy wxFontMapperBase object could have been created during the
368 // program startup before wxApp was created, we have to delete it to
369 // allow creating the real font mapper next time it is needed now that
370 // we can create it (when the modules are initialized, wxApp object
371 // already exists)
372 wxFontMapperBase *fm = wxFontMapperBase::Get();
373 if ( fm && fm->IsDummy() )
374 wxFontMapperBase::Reset();
375
376 return true;
377 }
378
379 virtual void OnExit()
380 {
381 wxFontMapperBase::Reset();
382 }
383
384 DECLARE_DYNAMIC_CLASS(wxFontMapperModule)
385 };
386
387 IMPLEMENT_DYNAMIC_CLASS(wxFontMapperModule, wxModule)
388
389
390 // ============================================================================
391 // wxFontMapperBase implementation
392 // ============================================================================
393
394 wxFontMapper *wxFontMapperBase::sm_instance = NULL;
395
396 // ----------------------------------------------------------------------------
397 // ctor and dtor
398 // ----------------------------------------------------------------------------
399
400 wxFontMapperBase::wxFontMapperBase()
401 {
402 #if wxUSE_CONFIG && wxUSE_FILECONFIG
403 m_configDummy = NULL;
404 #endif // wxUSE_CONFIG
405 }
406
407 wxFontMapperBase::~wxFontMapperBase()
408 {
409 #if wxUSE_CONFIG && wxUSE_FILECONFIG
410 if ( m_configDummy )
411 delete m_configDummy;
412 #endif // wxUSE_CONFIG
413 }
414
415 /* static */
416 wxFontMapperBase *wxFontMapperBase::Get()
417 {
418 if ( !sm_instance )
419 {
420 wxAppTraits *traits = wxTheApp ? wxTheApp->GetTraits() : NULL;
421 if ( traits )
422 {
423 sm_instance = traits->CreateFontMapper();
424
425 wxASSERT_MSG( sm_instance,
426 wxT("wxAppTraits::CreateFontMapper() failed") );
427 }
428
429 if ( !sm_instance )
430 {
431 // last resort: we must create something because the existing code
432 // relies on always having a valid font mapper object
433 sm_instance = (wxFontMapper *)new wxFontMapperBase;
434 }
435 }
436
437 return (wxFontMapperBase*)sm_instance;
438 }
439
440 /* static */
441 wxFontMapper *wxFontMapperBase::Set(wxFontMapper *mapper)
442 {
443 wxFontMapper *old = sm_instance;
444 sm_instance = mapper;
445 return old;
446 }
447
448 /* static */
449 void wxFontMapperBase::Reset()
450 {
451 if ( sm_instance )
452 {
453 // we need a cast as wxFontMapper is not fully declared here and so the
454 // compiler can't know that it derives from wxFontMapperBase (but
455 // run-time behaviour will be correct because the dtor is virtual)
456 delete (wxFontMapperBase *)sm_instance;
457 sm_instance = NULL;
458 }
459 }
460
461 #if wxUSE_CONFIG && wxUSE_FILECONFIG
462
463 // ----------------------------------------------------------------------------
464 // config usage customisation
465 // ----------------------------------------------------------------------------
466
467
468 static wxString gs_defaultConfigPath(FONTMAPPER_ROOT_PATH);
469
470 /* static */
471 const wxString& wxFontMapperBase::GetDefaultConfigPath()
472 {
473 // NB: we return const wxString& and not wxString for compatibility
474 // with 2.8 that returned const wxChar*
475 return gs_defaultConfigPath;
476 }
477
478 void wxFontMapperBase::SetConfigPath(const wxString& prefix)
479 {
480 wxCHECK_RET( !prefix.empty() && prefix[0] == wxCONFIG_PATH_SEPARATOR,
481 wxT("an absolute path should be given to wxFontMapper::SetConfigPath()") );
482
483 m_configRootPath = prefix;
484 }
485
486 // ----------------------------------------------------------------------------
487 // get config object and path for it
488 // ----------------------------------------------------------------------------
489
490 wxConfigBase *wxFontMapperBase::GetConfig()
491 {
492 wxConfigBase *config = wxConfig::Get(false);
493
494 // If there is no global configuration, use an internal memory configuration
495 if ( !config )
496 {
497 if ( !m_configDummy )
498 m_configDummy = new wxMemoryConfig;
499 config = m_configDummy;
500
501 // FIXME: ideally, we should add keys from dummy config to a real one later,
502 // but it is a low-priority task because typical wxWin application
503 // either doesn't use wxConfig at all or creates wxConfig object in
504 // wxApp::OnInit(), before any real interaction with the user takes
505 // place...
506 }
507
508 return config;
509 }
510
511 const wxString& wxFontMapperBase::GetConfigPath()
512 {
513 if ( !m_configRootPath )
514 {
515 // use the default
516 m_configRootPath = GetDefaultConfigPath();
517 }
518
519 return m_configRootPath;
520 }
521
522 // ----------------------------------------------------------------------------
523 // config helpers
524 // ----------------------------------------------------------------------------
525
526 bool wxFontMapperBase::ChangePath(const wxString& pathNew, wxString *pathOld)
527 {
528 wxConfigBase *config = GetConfig();
529 if ( !config )
530 return false;
531
532 *pathOld = config->GetPath();
533
534 wxString path = GetConfigPath();
535 if ( path.empty() || path.Last() != wxCONFIG_PATH_SEPARATOR )
536 {
537 path += wxCONFIG_PATH_SEPARATOR;
538 }
539
540 wxASSERT_MSG( !pathNew || (pathNew[0] != wxCONFIG_PATH_SEPARATOR),
541 wxT("should be a relative path") );
542
543 path += pathNew;
544
545 config->SetPath(path);
546
547 return true;
548 }
549
550 void wxFontMapperBase::RestorePath(const wxString& pathOld)
551 {
552 GetConfig()->SetPath(pathOld);
553 }
554
555 #endif
556
557 // ----------------------------------------------------------------------------
558 // charset/encoding correspondence
559 // ----------------------------------------------------------------------------
560
561 wxFontEncoding
562 wxFontMapperBase::CharsetToEncoding(const wxString& charset,
563 bool WXUNUSED(interactive))
564 {
565 int enc = NonInteractiveCharsetToEncoding(charset);
566 if ( enc == wxFONTENCODING_UNKNOWN )
567 {
568 // we should return wxFONTENCODING_SYSTEM from here for unknown
569 // encodings
570 enc = wxFONTENCODING_SYSTEM;
571 }
572
573 return (wxFontEncoding)enc;
574 }
575
576 int
577 wxFontMapperBase::NonInteractiveCharsetToEncoding(const wxString& charset)
578 {
579 wxFontEncoding encoding = wxFONTENCODING_SYSTEM;
580
581 // we're going to modify it, make a copy
582 wxString cs = charset;
583
584 #if wxUSE_CONFIG && wxUSE_FILECONFIG
585 // first try the user-defined settings
586 wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
587 if ( path.IsOk() )
588 {
589 wxConfigBase *config = GetConfig();
590
591 // do we have an encoding for this charset?
592 long value = config->Read(charset, -1l);
593 if ( value != -1 )
594 {
595 if ( value == wxFONTENCODING_UNKNOWN )
596 {
597 // don't try to find it, in particular don't ask the user
598 return value;
599 }
600
601 if ( value >= 0 && value <= wxFONTENCODING_MAX )
602 {
603 encoding = (wxFontEncoding)value;
604 }
605 else
606 {
607 wxLogDebug(wxT("corrupted config data: invalid encoding %ld for charset '%s' ignored"),
608 value, charset.c_str());
609 }
610 }
611
612 if ( encoding == wxFONTENCODING_SYSTEM )
613 {
614 // may be we have an alias?
615 config->SetPath(FONTMAPPER_CHARSET_ALIAS_PATH);
616
617 wxString alias = config->Read(charset);
618 if ( !alias.empty() )
619 {
620 // yes, we do - use it instead
621 cs = alias;
622 }
623 }
624 }
625 #endif // wxUSE_CONFIG
626
627 // if didn't find it there, try to recognize it ourselves
628 if ( encoding == wxFONTENCODING_SYSTEM )
629 {
630 // trim any spaces
631 cs.Trim(true);
632 cs.Trim(false);
633
634 // discard the optional quotes
635 if ( !cs.empty() )
636 {
637 if ( cs[0u] == wxT('"') && cs.Last() == wxT('"') )
638 {
639 cs = wxString(cs.c_str(), cs.length() - 1);
640 }
641 }
642
643 for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); ++i )
644 {
645 for ( const wxChar* const* encName = gs_encodingNames[i]; *encName; ++encName )
646 {
647 if ( cs.CmpNoCase(*encName) == 0 )
648 return gs_encodings[i];
649 }
650 }
651
652 cs.MakeUpper();
653
654 if ( cs.Left(3) == wxT("ISO") )
655 {
656 // the dash is optional (or, to be exact, it is not, but
657 // several broken programs "forget" it)
658 const wxChar *p = cs.c_str() + 3;
659 if ( *p == wxT('-') )
660 p++;
661
662 unsigned int value;
663 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
664 {
665 // make it 0 based and check that it is strictly positive in
666 // the process (no such thing as iso8859-0 encoding)
667 if ( (value-- > 0) &&
668 (value < wxFONTENCODING_ISO8859_MAX -
669 wxFONTENCODING_ISO8859_1) )
670 {
671 // it's a valid ISO8859 encoding
672 value += wxFONTENCODING_ISO8859_1;
673 encoding = (wxFontEncoding)value;
674 }
675 }
676 }
677 else if ( cs.Left(4) == wxT("8859") )
678 {
679 const wxChar *p = cs.c_str();
680
681 unsigned int value;
682 if ( wxSscanf(p, wxT("8859-%u"), &value) == 1 )
683 {
684 // make it 0 based and check that it is strictly positive in
685 // the process (no such thing as iso8859-0 encoding)
686 if ( (value-- > 0) &&
687 (value < wxFONTENCODING_ISO8859_MAX -
688 wxFONTENCODING_ISO8859_1) )
689 {
690 // it's a valid ISO8859 encoding
691 value += wxFONTENCODING_ISO8859_1;
692 encoding = (wxFontEncoding)value;
693 }
694 }
695 }
696 else // check for Windows charsets
697 {
698 size_t len;
699 if ( cs.Left(7) == wxT("WINDOWS") )
700 {
701 len = 7;
702 }
703 else if ( cs.Left(2) == wxT("CP") )
704 {
705 len = 2;
706 }
707 else // not a Windows encoding
708 {
709 len = 0;
710 }
711
712 if ( len )
713 {
714 const wxChar *p = cs.c_str() + len;
715 if ( *p == wxT('-') )
716 p++;
717
718 unsigned int value;
719 if ( wxSscanf(p, wxT("%u"), &value) == 1 )
720 {
721 if ( value >= 1250 )
722 {
723 value -= 1250;
724 if ( value < wxFONTENCODING_CP12_MAX -
725 wxFONTENCODING_CP1250 )
726 {
727 // a valid Windows code page
728 value += wxFONTENCODING_CP1250;
729 encoding = (wxFontEncoding)value;
730 }
731 }
732
733 switch ( value )
734 {
735 case 866:
736 encoding = wxFONTENCODING_CP866;
737 break;
738
739 case 874:
740 encoding = wxFONTENCODING_CP874;
741 break;
742
743 case 932:
744 encoding = wxFONTENCODING_CP932;
745 break;
746
747 case 936:
748 encoding = wxFONTENCODING_CP936;
749 break;
750
751 case 949:
752 encoding = wxFONTENCODING_CP949;
753 break;
754
755 case 950:
756 encoding = wxFONTENCODING_CP950;
757 break;
758 }
759 }
760 }
761 }
762 //else: unknown
763 }
764
765 return encoding;
766 }
767
768 /* static */
769 size_t wxFontMapperBase::GetSupportedEncodingsCount()
770 {
771 return WXSIZEOF(gs_encodings);
772 }
773
774 /* static */
775 wxFontEncoding wxFontMapperBase::GetEncoding(size_t n)
776 {
777 wxCHECK_MSG( n < WXSIZEOF(gs_encodings), wxFONTENCODING_SYSTEM,
778 wxT("wxFontMapper::GetEncoding(): invalid index") );
779
780 return gs_encodings[n];
781 }
782
783 /* static */
784 wxString wxFontMapperBase::GetEncodingDescription(wxFontEncoding encoding)
785 {
786 if ( encoding == wxFONTENCODING_DEFAULT )
787 {
788 return _("Default encoding");
789 }
790
791 const size_t count = WXSIZEOF(gs_encodingDescs);
792
793 for ( size_t i = 0; i < count; i++ )
794 {
795 if ( gs_encodings[i] == encoding )
796 {
797 return wxGetTranslation(gs_encodingDescs[i]);
798 }
799 }
800
801 wxString str;
802 str.Printf(_("Unknown encoding (%d)"), encoding);
803
804 return str;
805 }
806
807 /* static */
808 wxString wxFontMapperBase::GetEncodingName(wxFontEncoding encoding)
809 {
810 if ( encoding == wxFONTENCODING_DEFAULT )
811 {
812 return _("default");
813 }
814
815 const size_t count = WXSIZEOF(gs_encodingNames);
816
817 for ( size_t i = 0; i < count; i++ )
818 {
819 if ( gs_encodings[i] == encoding )
820 {
821 return gs_encodingNames[i][0];
822 }
823 }
824
825 wxString str;
826 str.Printf(_("unknown-%d"), encoding);
827
828 return str;
829 }
830
831 /* static */
832 const wxChar** wxFontMapperBase::GetAllEncodingNames(wxFontEncoding encoding)
833 {
834 static const wxChar* const dummy[] = { NULL };
835
836 for ( size_t i = 0; i < WXSIZEOF(gs_encodingNames); i++ )
837 {
838 if ( gs_encodings[i] == encoding )
839 {
840 return const_cast<const wxChar**>(gs_encodingNames[i]);
841 }
842 }
843
844 return const_cast<const wxChar**>(dummy);
845 }
846
847 /* static */
848 wxFontEncoding wxFontMapperBase::GetEncodingFromName(const wxString& name)
849 {
850 const size_t count = WXSIZEOF(gs_encodingNames);
851
852 for ( size_t i = 0; i < count; i++ )
853 {
854 for ( const wxChar* const* encName = gs_encodingNames[i]; *encName; ++encName )
855 {
856 if ( name.CmpNoCase(*encName) == 0 )
857 return gs_encodings[i];
858 }
859 }
860
861 return wxFONTENCODING_MAX;
862 }
863
864 #endif // wxUSE_FONTMAP