]>
Commit | Line | Data |
---|---|---|
c801d85f | 1 | ///////////////////////////////////////////////////////////////////////////// |
dccce9ea | 2 | // Name: src/common/intl.cpp |
77ffb593 | 3 | // Purpose: Internationalization and localisation for wxWidgets |
c801d85f | 4 | // Author: Vadim Zeitlin |
849a28d0 VS |
5 | // Modified by: Michael N. Filippov <michael@idisys.iae.nsk.su> |
6 | // (2003/09/30 - PluralForms support) | |
c801d85f KB |
7 | // Created: 29/01/98 |
8 | // RCS-ID: $Id$ | |
9 | // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr> | |
65571936 | 10 | // Licence: wxWindows licence |
c801d85f KB |
11 | ///////////////////////////////////////////////////////////////////////////// |
12 | ||
13 | // ============================================================================ | |
1678ad78 | 14 | // declaration |
c801d85f KB |
15 | // ============================================================================ |
16 | ||
17 | // ---------------------------------------------------------------------------- | |
18 | // headers | |
19 | // ---------------------------------------------------------------------------- | |
20 | ||
14f355c2 | 21 | #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) |
84c18814 | 22 | #pragma implementation "intl.h" |
c801d85f KB |
23 | #endif |
24 | ||
8bcf4c86 VS |
25 | #if defined(__BORLAND__) && !defined(__WXDEBUG__) |
26 | // There's a bug in Borland's compiler that breaks wxLocale with -O2, | |
27 | // so make sure that flag is not used for this file: | |
28 | #pragma option -O1 | |
29 | #endif | |
30 | ||
3c221c50 SN |
31 | #ifdef __EMX__ |
32 | // The following define is needed by Innotek's libc to | |
33 | // make the definition of struct localeconv available. | |
34 | #define __INTERNAL_DEFS | |
35 | #endif | |
36 | ||
c801d85f KB |
37 | // For compilers that support precompilation, includes "wx.h". |
38 | #include "wx/wxprec.h" | |
39 | ||
40 | #ifdef __BORLANDC__ | |
84c18814 | 41 | #pragma hdrstop |
c801d85f KB |
42 | #endif |
43 | ||
d427503c VZ |
44 | #if wxUSE_INTL |
45 | ||
1678ad78 | 46 | // standard headers |
1c193821 JS |
47 | |
48 | #ifndef __WXWINCE__ | |
dccce9ea | 49 | #include <locale.h> |
1c193821 JS |
50 | #endif |
51 | ||
dccce9ea VZ |
52 | #include <ctype.h> |
53 | #include <stdlib.h> | |
2ec6905c VS |
54 | #ifdef HAVE_LANGINFO_H |
55 | #include <langinfo.h> | |
56 | #endif | |
7502ba29 | 57 | |
77ffb593 | 58 | // wxWidgets |
dccce9ea VZ |
59 | #ifndef WX_PRECOMP |
60 | #include "wx/string.h" | |
61 | #include "wx/intl.h" | |
62 | #include "wx/log.h" | |
63 | #include "wx/debug.h" | |
64 | #include "wx/utils.h" | |
65 | #include "wx/dynarray.h" | |
66 | #endif // WX_PRECOMP | |
67 | ||
1c193821 JS |
68 | #ifdef __WIN32__ |
69 | #include "wx/msw/private.h" | |
70 | #elif defined(__UNIX_LIKE__) | |
71 | #include "wx/fontmap.h" // for CharsetToEncoding() | |
72 | #endif | |
73 | ||
c801d85f | 74 | #include "wx/file.h" |
dccce9ea | 75 | #include "wx/tokenzr.h" |
41780009 | 76 | #include "wx/module.h" |
030c0bea VS |
77 | #include "wx/fontmap.h" |
78 | #include "wx/encconv.h" | |
563d535e | 79 | #include "wx/hashmap.h" |
849a28d0 | 80 | #include "wx/ptr_scpd.h" |
dccce9ea | 81 | |
76a5e5d2 SC |
82 | #if defined(__WXMAC__) |
83 | #include "wx/mac/private.h" // includes mac headers | |
84 | #endif | |
85 | ||
84c18814 VZ |
86 | // ---------------------------------------------------------------------------- |
87 | // simple types | |
88 | // ---------------------------------------------------------------------------- | |
89 | ||
e939abfd | 90 | // this should *not* be wxChar, this type must have exactly 8 bits! |
563d535e VS |
91 | typedef wxUint8 size_t8; |
92 | typedef wxUint32 size_t32; | |
84c18814 | 93 | |
c801d85f KB |
94 | // ---------------------------------------------------------------------------- |
95 | // constants | |
96 | // ---------------------------------------------------------------------------- | |
97 | ||
98 | // magic number identifying the .mo format file | |
c86f1403 VZ |
99 | const size_t32 MSGCATALOG_MAGIC = 0x950412de; |
100 | const size_t32 MSGCATALOG_MAGIC_SW = 0xde120495; | |
c801d85f KB |
101 | |
102 | // extension of ".mo" files | |
5f170f33 | 103 | #define MSGCATALOG_EXTENSION _T(".mo") |
c801d85f | 104 | |
ec37df57 VZ |
105 | // the constants describing the format of lang_LANG locale string |
106 | static const size_t LEN_LANG = 2; | |
107 | static const size_t LEN_SUBLANG = 2; | |
108 | static const size_t LEN_FULL = LEN_LANG + 1 + LEN_SUBLANG; // 1 for '_' | |
109 | ||
c801d85f | 110 | // ---------------------------------------------------------------------------- |
1678ad78 | 111 | // global functions |
c801d85f KB |
112 | // ---------------------------------------------------------------------------- |
113 | ||
f6bcfd97 | 114 | #ifdef __WXDEBUG__ |
c801d85f | 115 | |
f6bcfd97 BP |
116 | // small class to suppress the translation erros until exit from current scope |
117 | class NoTransErr | |
118 | { | |
119 | public: | |
120 | NoTransErr() { ms_suppressCount++; } | |
121 | ~NoTransErr() { ms_suppressCount--; } | |
122 | ||
123 | static bool Suppress() { return ms_suppressCount > 0; } | |
124 | ||
125 | private: | |
126 | static size_t ms_suppressCount; | |
127 | }; | |
c801d85f | 128 | |
f6bcfd97 BP |
129 | size_t NoTransErr::ms_suppressCount = 0; |
130 | ||
131 | #else // !Debug | |
132 | ||
133 | class NoTransErr | |
134 | { | |
135 | public: | |
136 | NoTransErr() { } | |
137 | ~NoTransErr() { } | |
138 | }; | |
139 | ||
140 | #endif // Debug/!Debug | |
c801d85f | 141 | |
84c18814 | 142 | static wxLocale *wxSetLocale(wxLocale *pLocale); |
c801d85f | 143 | |
ec37df57 VZ |
144 | // helper functions of GetSystemLanguage() |
145 | #ifdef __UNIX__ | |
146 | ||
147 | // get just the language part | |
148 | static inline wxString ExtractLang(const wxString& langFull) | |
149 | { | |
150 | return langFull.Left(LEN_LANG); | |
151 | } | |
152 | ||
153 | // get everything else (including the leading '_') | |
154 | static inline wxString ExtractNotLang(const wxString& langFull) | |
155 | { | |
156 | return langFull.Mid(LEN_LANG); | |
157 | } | |
158 | ||
159 | #endif // __UNIX__ | |
160 | ||
563d535e | 161 | |
849a28d0 VS |
162 | // ---------------------------------------------------------------------------- |
163 | // Plural forms parser | |
164 | // ---------------------------------------------------------------------------- | |
165 | ||
b7b97e77 | 166 | /* |
849a28d0 VS |
167 | Simplified Grammar |
168 | ||
169 | Expression: | |
170 | LogicalOrExpression '?' Expression ':' Expression | |
171 | LogicalOrExpression | |
172 | ||
173 | LogicalOrExpression: | |
174 | LogicalAndExpression "||" LogicalOrExpression // to (a || b) || c | |
175 | LogicalAndExpression | |
176 | ||
177 | LogicalAndExpression: | |
178 | EqualityExpression "&&" LogicalAndExpression // to (a && b) && c | |
179 | EqualityExpression | |
180 | ||
181 | EqualityExpression: | |
182 | RelationalExpression "==" RelationalExperession | |
183 | RelationalExpression "!=" RelationalExperession | |
184 | RelationalExpression | |
185 | ||
186 | RelationalExpression: | |
187 | MultiplicativeExpression '>' MultiplicativeExpression | |
188 | MultiplicativeExpression '<' MultiplicativeExpression | |
189 | MultiplicativeExpression ">=" MultiplicativeExpression | |
190 | MultiplicativeExpression "<=" MultiplicativeExpression | |
191 | MultiplicativeExpression | |
b7b97e77 | 192 | |
849a28d0 VS |
193 | MultiplicativeExpression: |
194 | PmExpression '%' PmExpression | |
195 | PmExpression | |
196 | ||
197 | PmExpression: | |
198 | N | |
199 | Number | |
200 | '(' Expression ')' | |
201 | */ | |
202 | ||
203 | class wxPluralFormsToken | |
204 | { | |
205 | public: | |
206 | enum Type | |
207 | { | |
208 | T_ERROR, T_EOF, T_NUMBER, T_N, T_PLURAL, T_NPLURALS, T_EQUAL, T_ASSIGN, | |
209 | T_GREATER, T_GREATER_OR_EQUAL, T_LESS, T_LESS_OR_EQUAL, | |
210 | T_REMINDER, T_NOT_EQUAL, | |
211 | T_LOGICAL_AND, T_LOGICAL_OR, T_QUESTION, T_COLON, T_SEMICOLON, | |
212 | T_LEFT_BRACKET, T_RIGHT_BRACKET | |
213 | }; | |
214 | Type type() const { return m_type; } | |
215 | void setType(Type type) { m_type = type; } | |
216 | // for T_NUMBER only | |
217 | typedef int Number; | |
218 | Number number() const { return m_number; } | |
219 | void setNumber(Number num) { m_number = num; } | |
220 | private: | |
221 | Type m_type; | |
222 | Number m_number; | |
223 | }; | |
224 | ||
225 | ||
226 | class wxPluralFormsScanner | |
227 | { | |
228 | public: | |
229 | wxPluralFormsScanner(const char* s); | |
230 | const wxPluralFormsToken& token() const { return m_token; } | |
231 | bool nextToken(); // returns false if error | |
232 | private: | |
233 | const char* m_s; | |
234 | wxPluralFormsToken m_token; | |
235 | }; | |
236 | ||
237 | wxPluralFormsScanner::wxPluralFormsScanner(const char* s) : m_s(s) | |
238 | { | |
239 | nextToken(); | |
240 | } | |
241 | ||
242 | bool wxPluralFormsScanner::nextToken() | |
243 | { | |
244 | wxPluralFormsToken::Type type = wxPluralFormsToken::T_ERROR; | |
245 | while (isspace(*m_s)) | |
246 | { | |
247 | ++m_s; | |
248 | } | |
249 | if (*m_s == 0) | |
250 | { | |
251 | type = wxPluralFormsToken::T_EOF; | |
252 | } | |
253 | else if (isdigit(*m_s)) | |
254 | { | |
255 | wxPluralFormsToken::Number number = *m_s++ - '0'; | |
256 | while (isdigit(*m_s)) | |
257 | { | |
258 | number = number * 10 + (*m_s++ - '0'); | |
259 | } | |
260 | m_token.setNumber(number); | |
261 | type = wxPluralFormsToken::T_NUMBER; | |
262 | } | |
263 | else if (isalpha(*m_s)) | |
264 | { | |
265 | const char* begin = m_s++; | |
266 | while (isalnum(*m_s)) | |
267 | { | |
268 | ++m_s; | |
269 | } | |
270 | size_t size = m_s - begin; | |
271 | if (size == 1 && memcmp(begin, "n", size) == 0) | |
272 | { | |
273 | type = wxPluralFormsToken::T_N; | |
274 | } | |
275 | else if (size == 6 && memcmp(begin, "plural", size) == 0) | |
276 | { | |
277 | type = wxPluralFormsToken::T_PLURAL; | |
278 | } | |
279 | else if (size == 8 && memcmp(begin, "nplurals", size) == 0) | |
280 | { | |
281 | type = wxPluralFormsToken::T_NPLURALS; | |
282 | } | |
283 | } | |
284 | else if (*m_s == '=') | |
285 | { | |
286 | ++m_s; | |
287 | if (*m_s == '=') | |
288 | { | |
289 | ++m_s; | |
290 | type = wxPluralFormsToken::T_EQUAL; | |
291 | } | |
292 | else | |
293 | { | |
294 | type = wxPluralFormsToken::T_ASSIGN; | |
295 | } | |
296 | } | |
297 | else if (*m_s == '>') | |
298 | { | |
299 | ++m_s; | |
300 | if (*m_s == '=') | |
301 | { | |
302 | ++m_s; | |
303 | type = wxPluralFormsToken::T_GREATER_OR_EQUAL; | |
304 | } | |
305 | else | |
306 | { | |
307 | type = wxPluralFormsToken::T_GREATER; | |
308 | } | |
309 | } | |
310 | else if (*m_s == '<') | |
311 | { | |
312 | ++m_s; | |
313 | if (*m_s == '=') | |
314 | { | |
315 | ++m_s; | |
316 | type = wxPluralFormsToken::T_LESS_OR_EQUAL; | |
317 | } | |
318 | else | |
319 | { | |
320 | type = wxPluralFormsToken::T_LESS; | |
321 | } | |
322 | } | |
323 | else if (*m_s == '%') | |
324 | { | |
325 | ++m_s; | |
326 | type = wxPluralFormsToken::T_REMINDER; | |
327 | } | |
328 | else if (*m_s == '!' && m_s[1] == '=') | |
329 | { | |
330 | m_s += 2; | |
331 | type = wxPluralFormsToken::T_NOT_EQUAL; | |
332 | } | |
333 | else if (*m_s == '&' && m_s[1] == '&') | |
334 | { | |
335 | m_s += 2; | |
336 | type = wxPluralFormsToken::T_LOGICAL_AND; | |
337 | } | |
338 | else if (*m_s == '|' && m_s[1] == '|') | |
339 | { | |
340 | m_s += 2; | |
341 | type = wxPluralFormsToken::T_LOGICAL_OR; | |
342 | } | |
343 | else if (*m_s == '?') | |
344 | { | |
345 | ++m_s; | |
346 | type = wxPluralFormsToken::T_QUESTION; | |
347 | } | |
348 | else if (*m_s == ':') | |
349 | { | |
350 | ++m_s; | |
351 | type = wxPluralFormsToken::T_COLON; | |
352 | } else if (*m_s == ';') { | |
353 | ++m_s; | |
354 | type = wxPluralFormsToken::T_SEMICOLON; | |
355 | } | |
356 | else if (*m_s == '(') | |
357 | { | |
358 | ++m_s; | |
359 | type = wxPluralFormsToken::T_LEFT_BRACKET; | |
360 | } | |
361 | else if (*m_s == ')') | |
362 | { | |
363 | ++m_s; | |
364 | type = wxPluralFormsToken::T_RIGHT_BRACKET; | |
365 | } | |
366 | m_token.setType(type); | |
367 | return type != wxPluralFormsToken::T_ERROR; | |
368 | } | |
369 | ||
370 | class wxPluralFormsNode; | |
371 | ||
372 | // NB: Can't use wxDEFINE_SCOPED_PTR_TYPE because wxPluralFormsNode is not | |
373 | // fully defined yet: | |
374 | class wxPluralFormsNodePtr | |
375 | { | |
376 | public: | |
377 | wxPluralFormsNodePtr(wxPluralFormsNode *p = NULL) : m_p(p) {} | |
378 | ~wxPluralFormsNodePtr(); | |
379 | wxPluralFormsNode& operator*() const { return *m_p; } | |
380 | wxPluralFormsNode* operator->() const { return m_p; } | |
381 | wxPluralFormsNode* get() const { return m_p; } | |
382 | wxPluralFormsNode* release(); | |
383 | void reset(wxPluralFormsNode *p); | |
384 | ||
385 | private: | |
386 | wxPluralFormsNode *m_p; | |
387 | }; | |
388 | ||
389 | class wxPluralFormsNode | |
390 | { | |
391 | public: | |
392 | wxPluralFormsNode(const wxPluralFormsToken& token) : m_token(token) {} | |
393 | const wxPluralFormsToken& token() const { return m_token; } | |
394 | const wxPluralFormsNode* node(size_t i) const | |
395 | { return m_nodes[i].get(); } | |
396 | void setNode(size_t i, wxPluralFormsNode* n); | |
397 | wxPluralFormsNode* releaseNode(size_t i); | |
398 | wxPluralFormsToken::Number evaluate(wxPluralFormsToken::Number n) const; | |
399 | ||
400 | private: | |
401 | wxPluralFormsToken m_token; | |
402 | wxPluralFormsNodePtr m_nodes[3]; | |
403 | }; | |
b7b97e77 | 404 | |
849a28d0 VS |
405 | wxPluralFormsNodePtr::~wxPluralFormsNodePtr() |
406 | { | |
407 | delete m_p; | |
408 | } | |
409 | wxPluralFormsNode* wxPluralFormsNodePtr::release() | |
410 | { | |
411 | wxPluralFormsNode *p = m_p; | |
412 | m_p = NULL; | |
413 | return p; | |
414 | } | |
415 | void wxPluralFormsNodePtr::reset(wxPluralFormsNode *p) | |
416 | { | |
417 | if (p != m_p) | |
418 | { | |
419 | delete m_p; | |
420 | m_p = p; | |
421 | } | |
422 | } | |
423 | ||
424 | ||
425 | void wxPluralFormsNode::setNode(size_t i, wxPluralFormsNode* n) | |
426 | { | |
427 | m_nodes[i].reset(n); | |
428 | } | |
429 | ||
430 | wxPluralFormsNode* wxPluralFormsNode::releaseNode(size_t i) | |
431 | { | |
432 | return m_nodes[i].release(); | |
433 | } | |
434 | ||
435 | wxPluralFormsToken::Number | |
436 | wxPluralFormsNode::evaluate(wxPluralFormsToken::Number n) const | |
437 | { | |
438 | switch (token().type()) | |
439 | { | |
440 | // leaf | |
441 | case wxPluralFormsToken::T_NUMBER: | |
442 | return token().number(); | |
443 | case wxPluralFormsToken::T_N: | |
444 | return n; | |
445 | // 2 args | |
446 | case wxPluralFormsToken::T_EQUAL: | |
447 | return node(0)->evaluate(n) == node(1)->evaluate(n); | |
448 | case wxPluralFormsToken::T_NOT_EQUAL: | |
449 | return node(0)->evaluate(n) != node(1)->evaluate(n); | |
450 | case wxPluralFormsToken::T_GREATER: | |
451 | return node(0)->evaluate(n) > node(1)->evaluate(n); | |
452 | case wxPluralFormsToken::T_GREATER_OR_EQUAL: | |
453 | return node(0)->evaluate(n) >= node(1)->evaluate(n); | |
454 | case wxPluralFormsToken::T_LESS: | |
455 | return node(0)->evaluate(n) < node(1)->evaluate(n); | |
456 | case wxPluralFormsToken::T_LESS_OR_EQUAL: | |
457 | return node(0)->evaluate(n) <= node(1)->evaluate(n); | |
458 | case wxPluralFormsToken::T_REMINDER: | |
459 | { | |
460 | wxPluralFormsToken::Number number = node(1)->evaluate(n); | |
461 | if (number != 0) | |
462 | { | |
463 | return node(0)->evaluate(n) % number; | |
464 | } | |
465 | else | |
466 | { | |
467 | return 0; | |
468 | } | |
469 | } | |
470 | case wxPluralFormsToken::T_LOGICAL_AND: | |
471 | return node(0)->evaluate(n) && node(1)->evaluate(n); | |
472 | case wxPluralFormsToken::T_LOGICAL_OR: | |
473 | return node(0)->evaluate(n) || node(1)->evaluate(n); | |
474 | // 3 args | |
475 | case wxPluralFormsToken::T_QUESTION: | |
476 | return node(0)->evaluate(n) | |
477 | ? node(1)->evaluate(n) | |
478 | : node(2)->evaluate(n); | |
479 | default: | |
480 | return 0; | |
481 | } | |
482 | } | |
483 | ||
484 | ||
485 | class wxPluralFormsCalculator | |
486 | { | |
487 | public: | |
488 | wxPluralFormsCalculator() : m_nplurals(0), m_plural(0) {} | |
b7b97e77 | 489 | |
849a28d0 VS |
490 | // input: number, returns msgstr index |
491 | int evaluate(int n) const; | |
492 | ||
493 | // input: text after "Plural-Forms:" (e.g. "nplurals=2; plural=(n != 1);"), | |
494 | // if s == 0, creates default handler | |
495 | // returns 0 if error | |
496 | static wxPluralFormsCalculator* make(const char* s = 0); | |
497 | ||
498 | ~wxPluralFormsCalculator() {} | |
499 | ||
500 | void init(wxPluralFormsToken::Number nplurals, wxPluralFormsNode* plural); | |
501 | wxString getString() const; | |
b7b97e77 | 502 | |
849a28d0 VS |
503 | private: |
504 | wxPluralFormsToken::Number m_nplurals; | |
505 | wxPluralFormsNodePtr m_plural; | |
506 | }; | |
507 | ||
508 | wxDEFINE_SCOPED_PTR_TYPE(wxPluralFormsCalculator); | |
509 | ||
510 | void wxPluralFormsCalculator::init(wxPluralFormsToken::Number nplurals, | |
511 | wxPluralFormsNode* plural) | |
512 | { | |
513 | m_nplurals = nplurals; | |
514 | m_plural.reset(plural); | |
515 | } | |
516 | ||
517 | int wxPluralFormsCalculator::evaluate(int n) const | |
518 | { | |
519 | if (m_plural.get() == 0) | |
520 | { | |
521 | return 0; | |
522 | } | |
523 | wxPluralFormsToken::Number number = m_plural->evaluate(n); | |
524 | if (number < 0 || number > m_nplurals) | |
525 | { | |
526 | return 0; | |
527 | } | |
528 | return number; | |
529 | } | |
530 | ||
531 | ||
532 | class wxPluralFormsParser | |
533 | { | |
534 | public: | |
535 | wxPluralFormsParser(wxPluralFormsScanner& scanner) : m_scanner(scanner) {} | |
536 | bool parse(wxPluralFormsCalculator& rCalculator); | |
537 | ||
538 | private: | |
539 | wxPluralFormsNode* parsePlural(); | |
540 | // stops at T_SEMICOLON, returns 0 if error | |
541 | wxPluralFormsScanner& m_scanner; | |
542 | const wxPluralFormsToken& token() const; | |
543 | bool nextToken(); | |
b7b97e77 | 544 | |
849a28d0 VS |
545 | wxPluralFormsNode* expression(); |
546 | wxPluralFormsNode* logicalOrExpression(); | |
547 | wxPluralFormsNode* logicalAndExpression(); | |
548 | wxPluralFormsNode* equalityExpression(); | |
549 | wxPluralFormsNode* multiplicativeExpression(); | |
550 | wxPluralFormsNode* relationalExpression(); | |
551 | wxPluralFormsNode* pmExpression(); | |
552 | }; | |
553 | ||
554 | bool wxPluralFormsParser::parse(wxPluralFormsCalculator& rCalculator) | |
555 | { | |
556 | if (token().type() != wxPluralFormsToken::T_NPLURALS) | |
557 | return false; | |
558 | if (!nextToken()) | |
559 | return false; | |
560 | if (token().type() != wxPluralFormsToken::T_ASSIGN) | |
561 | return false; | |
562 | if (!nextToken()) | |
563 | return false; | |
564 | if (token().type() != wxPluralFormsToken::T_NUMBER) | |
565 | return false; | |
566 | wxPluralFormsToken::Number nplurals = token().number(); | |
567 | if (!nextToken()) | |
568 | return false; | |
569 | if (token().type() != wxPluralFormsToken::T_SEMICOLON) | |
570 | return false; | |
571 | if (!nextToken()) | |
572 | return false; | |
573 | if (token().type() != wxPluralFormsToken::T_PLURAL) | |
574 | return false; | |
575 | if (!nextToken()) | |
576 | return false; | |
577 | if (token().type() != wxPluralFormsToken::T_ASSIGN) | |
578 | return false; | |
579 | if (!nextToken()) | |
580 | return false; | |
581 | wxPluralFormsNode* plural = parsePlural(); | |
582 | if (plural == 0) | |
583 | return false; | |
584 | if (token().type() != wxPluralFormsToken::T_SEMICOLON) | |
585 | return false; | |
586 | if (!nextToken()) | |
587 | return false; | |
588 | if (token().type() != wxPluralFormsToken::T_EOF) | |
589 | return false; | |
590 | rCalculator.init(nplurals, plural); | |
591 | return true; | |
592 | } | |
593 | ||
594 | wxPluralFormsNode* wxPluralFormsParser::parsePlural() | |
595 | { | |
596 | wxPluralFormsNode* p = expression(); | |
597 | if (p == NULL) | |
598 | { | |
599 | return NULL; | |
600 | } | |
601 | wxPluralFormsNodePtr n(p); | |
602 | if (token().type() != wxPluralFormsToken::T_SEMICOLON) | |
603 | { | |
604 | return NULL; | |
605 | } | |
606 | return n.release(); | |
607 | } | |
608 | ||
609 | const wxPluralFormsToken& wxPluralFormsParser::token() const | |
610 | { | |
611 | return m_scanner.token(); | |
612 | } | |
613 | ||
614 | bool wxPluralFormsParser::nextToken() | |
615 | { | |
616 | if (!m_scanner.nextToken()) | |
617 | return false; | |
618 | return true; | |
619 | } | |
620 | ||
621 | wxPluralFormsNode* wxPluralFormsParser::expression() | |
622 | { | |
623 | wxPluralFormsNode* p = logicalOrExpression(); | |
624 | if (p == NULL) | |
625 | return NULL; | |
626 | wxPluralFormsNodePtr n(p); | |
627 | if (token().type() == wxPluralFormsToken::T_QUESTION) | |
628 | { | |
629 | wxPluralFormsNodePtr qn(new wxPluralFormsNode(token())); | |
630 | if (!nextToken()) | |
631 | { | |
632 | return 0; | |
633 | } | |
634 | p = expression(); | |
635 | if (p == 0) | |
636 | { | |
637 | return 0; | |
638 | } | |
639 | qn->setNode(1, p); | |
640 | if (token().type() != wxPluralFormsToken::T_COLON) | |
641 | { | |
642 | return 0; | |
643 | } | |
644 | if (!nextToken()) | |
645 | { | |
646 | return 0; | |
647 | } | |
648 | p = expression(); | |
649 | if (p == 0) | |
650 | { | |
651 | return 0; | |
652 | } | |
653 | qn->setNode(2, p); | |
654 | qn->setNode(0, n.release()); | |
655 | return qn.release(); | |
656 | } | |
657 | return n.release(); | |
658 | } | |
659 | ||
660 | wxPluralFormsNode*wxPluralFormsParser::logicalOrExpression() | |
661 | { | |
662 | wxPluralFormsNode* p = logicalAndExpression(); | |
663 | if (p == NULL) | |
664 | return NULL; | |
665 | wxPluralFormsNodePtr ln(p); | |
666 | if (token().type() == wxPluralFormsToken::T_LOGICAL_OR) | |
667 | { | |
668 | wxPluralFormsNodePtr un(new wxPluralFormsNode(token())); | |
669 | if (!nextToken()) | |
670 | { | |
671 | return 0; | |
672 | } | |
673 | p = logicalOrExpression(); | |
674 | if (p == 0) | |
675 | { | |
676 | return 0; | |
677 | } | |
678 | wxPluralFormsNodePtr rn(p); // right | |
679 | if (rn->token().type() == wxPluralFormsToken::T_LOGICAL_OR) | |
680 | { | |
681 | // see logicalAndExpression comment | |
682 | un->setNode(0, ln.release()); | |
683 | un->setNode(1, rn->releaseNode(0)); | |
684 | rn->setNode(0, un.release()); | |
685 | return rn.release(); | |
686 | } | |
a509f830 VZ |
687 | |
688 | ||
689 | un->setNode(0, ln.release()); | |
690 | un->setNode(1, rn.release()); | |
691 | return un.release(); | |
849a28d0 VS |
692 | } |
693 | return ln.release(); | |
694 | } | |
695 | ||
696 | wxPluralFormsNode* wxPluralFormsParser::logicalAndExpression() | |
697 | { | |
698 | wxPluralFormsNode* p = equalityExpression(); | |
699 | if (p == NULL) | |
700 | return NULL; | |
701 | wxPluralFormsNodePtr ln(p); // left | |
702 | if (token().type() == wxPluralFormsToken::T_LOGICAL_AND) | |
703 | { | |
704 | wxPluralFormsNodePtr un(new wxPluralFormsNode(token())); // up | |
705 | if (!nextToken()) | |
706 | { | |
707 | return NULL; | |
708 | } | |
709 | p = logicalAndExpression(); | |
710 | if (p == 0) | |
711 | { | |
712 | return NULL; | |
713 | } | |
714 | wxPluralFormsNodePtr rn(p); // right | |
715 | if (rn->token().type() == wxPluralFormsToken::T_LOGICAL_AND) | |
716 | { | |
717 | // transform 1 && (2 && 3) -> (1 && 2) && 3 | |
718 | // u r | |
719 | // l r -> u 3 | |
720 | // 2 3 l 2 | |
721 | un->setNode(0, ln.release()); | |
722 | un->setNode(1, rn->releaseNode(0)); | |
723 | rn->setNode(0, un.release()); | |
724 | return rn.release(); | |
725 | } | |
a509f830 VZ |
726 | |
727 | un->setNode(0, ln.release()); | |
728 | un->setNode(1, rn.release()); | |
729 | return un.release(); | |
849a28d0 VS |
730 | } |
731 | return ln.release(); | |
732 | } | |
733 | ||
734 | wxPluralFormsNode* wxPluralFormsParser::equalityExpression() | |
735 | { | |
736 | wxPluralFormsNode* p = relationalExpression(); | |
737 | if (p == NULL) | |
738 | return NULL; | |
739 | wxPluralFormsNodePtr n(p); | |
740 | if (token().type() == wxPluralFormsToken::T_EQUAL | |
741 | || token().type() == wxPluralFormsToken::T_NOT_EQUAL) | |
742 | { | |
743 | wxPluralFormsNodePtr qn(new wxPluralFormsNode(token())); | |
744 | if (!nextToken()) | |
745 | { | |
746 | return NULL; | |
747 | } | |
748 | p = relationalExpression(); | |
749 | if (p == NULL) | |
750 | { | |
751 | return NULL; | |
752 | } | |
753 | qn->setNode(1, p); | |
754 | qn->setNode(0, n.release()); | |
755 | return qn.release(); | |
756 | } | |
757 | return n.release(); | |
758 | } | |
759 | ||
760 | wxPluralFormsNode* wxPluralFormsParser::relationalExpression() | |
761 | { | |
762 | wxPluralFormsNode* p = multiplicativeExpression(); | |
763 | if (p == NULL) | |
764 | return NULL; | |
765 | wxPluralFormsNodePtr n(p); | |
766 | if (token().type() == wxPluralFormsToken::T_GREATER | |
767 | || token().type() == wxPluralFormsToken::T_LESS | |
768 | || token().type() == wxPluralFormsToken::T_GREATER_OR_EQUAL | |
769 | || token().type() == wxPluralFormsToken::T_LESS_OR_EQUAL) | |
770 | { | |
771 | wxPluralFormsNodePtr qn(new wxPluralFormsNode(token())); | |
772 | if (!nextToken()) | |
773 | { | |
774 | return NULL; | |
775 | } | |
776 | p = multiplicativeExpression(); | |
777 | if (p == NULL) | |
778 | { | |
779 | return NULL; | |
780 | } | |
781 | qn->setNode(1, p); | |
782 | qn->setNode(0, n.release()); | |
783 | return qn.release(); | |
784 | } | |
785 | return n.release(); | |
786 | } | |
787 | ||
788 | wxPluralFormsNode* wxPluralFormsParser::multiplicativeExpression() | |
789 | { | |
790 | wxPluralFormsNode* p = pmExpression(); | |
791 | if (p == NULL) | |
792 | return NULL; | |
793 | wxPluralFormsNodePtr n(p); | |
794 | if (token().type() == wxPluralFormsToken::T_REMINDER) | |
795 | { | |
796 | wxPluralFormsNodePtr qn(new wxPluralFormsNode(token())); | |
797 | if (!nextToken()) | |
798 | { | |
799 | return NULL; | |
800 | } | |
801 | p = pmExpression(); | |
802 | if (p == NULL) | |
803 | { | |
804 | return NULL; | |
805 | } | |
806 | qn->setNode(1, p); | |
807 | qn->setNode(0, n.release()); | |
808 | return qn.release(); | |
809 | } | |
810 | return n.release(); | |
811 | } | |
812 | ||
813 | wxPluralFormsNode* wxPluralFormsParser::pmExpression() | |
814 | { | |
815 | wxPluralFormsNodePtr n; | |
816 | if (token().type() == wxPluralFormsToken::T_N | |
817 | || token().type() == wxPluralFormsToken::T_NUMBER) | |
818 | { | |
819 | n.reset(new wxPluralFormsNode(token())); | |
820 | if (!nextToken()) | |
821 | { | |
822 | return NULL; | |
823 | } | |
824 | } | |
825 | else if (token().type() == wxPluralFormsToken::T_LEFT_BRACKET) { | |
826 | if (!nextToken()) | |
827 | { | |
828 | return NULL; | |
829 | } | |
830 | wxPluralFormsNode* p = expression(); | |
831 | if (p == NULL) | |
832 | { | |
833 | return NULL; | |
834 | } | |
835 | n.reset(p); | |
836 | if (token().type() != wxPluralFormsToken::T_RIGHT_BRACKET) | |
837 | { | |
838 | return NULL; | |
839 | } | |
840 | if (!nextToken()) | |
841 | { | |
842 | return NULL; | |
843 | } | |
844 | } | |
845 | else | |
846 | { | |
847 | return NULL; | |
848 | } | |
849 | return n.release(); | |
850 | } | |
851 | ||
852 | wxPluralFormsCalculator* wxPluralFormsCalculator::make(const char* s) | |
853 | { | |
854 | wxPluralFormsCalculatorPtr calculator(new wxPluralFormsCalculator); | |
855 | if (s != NULL) | |
856 | { | |
857 | wxPluralFormsScanner scanner(s); | |
858 | wxPluralFormsParser p(scanner); | |
859 | if (!p.parse(*calculator)) | |
860 | { | |
861 | return NULL; | |
862 | } | |
863 | } | |
864 | return calculator.release(); | |
865 | } | |
866 | ||
867 | ||
868 | ||
41524ffc | 869 | |
563d535e VS |
870 | // ---------------------------------------------------------------------------- |
871 | // wxMsgCatalogFile corresponds to one disk-file message catalog. | |
872 | // | |
873 | // This is a "low-level" class and is used only by wxMsgCatalog | |
874 | // ---------------------------------------------------------------------------- | |
875 | ||
dac7d53a | 876 | WX_DECLARE_EXPORTED_STRING_HASH_MAP(wxString, wxMessagesHash); |
563d535e VS |
877 | |
878 | class wxMsgCatalogFile | |
879 | { | |
880 | public: | |
881 | // ctor & dtor | |
882 | wxMsgCatalogFile(); | |
883 | ~wxMsgCatalogFile(); | |
884 | ||
885 | // load the catalog from disk (szDirPrefix corresponds to language) | |
849a28d0 VS |
886 | bool Load(const wxChar *szDirPrefix, const wxChar *szName, |
887 | wxPluralFormsCalculatorPtr& rPluralFormsCalculator); | |
563d535e VS |
888 | |
889 | // fills the hash with string-translation pairs | |
d721baa9 VS |
890 | void FillHash(wxMessagesHash& hash, const wxString& msgIdCharset, |
891 | bool convertEncoding) const; | |
563d535e VS |
892 | |
893 | private: | |
894 | // this implementation is binary compatible with GNU gettext() version 0.10 | |
895 | ||
896 | // an entry in the string table | |
897 | struct wxMsgTableEntry | |
898 | { | |
899 | size_t32 nLen; // length of the string | |
900 | size_t32 ofsString; // pointer to the string | |
901 | }; | |
902 | ||
903 | // header of a .mo file | |
904 | struct wxMsgCatalogHeader | |
905 | { | |
906 | size_t32 magic, // offset +00: magic id | |
907 | revision, // +04: revision | |
908 | numStrings; // +08: number of strings in the file | |
909 | size_t32 ofsOrigTable, // +0C: start of original string table | |
910 | ofsTransTable; // +10: start of translated string table | |
911 | size_t32 nHashSize, // +14: hash table size | |
912 | ofsHashTable; // +18: offset of hash table start | |
913 | }; | |
914 | ||
915 | // all data is stored here, NULL if no data loaded | |
916 | size_t8 *m_pData; | |
917 | ||
869c7549 VZ |
918 | // amount of memory pointed to by m_pData. |
919 | size_t32 m_nSize; | |
920 | ||
563d535e VS |
921 | // data description |
922 | size_t32 m_numStrings; // number of strings in this domain | |
923 | wxMsgTableEntry *m_pOrigTable, // pointer to original strings | |
924 | *m_pTransTable; // translated | |
925 | ||
849a28d0 | 926 | wxString m_charset; |
b7b97e77 | 927 | |
869c7549 VZ |
928 | // swap the 2 halves of 32 bit integer if needed |
929 | size_t32 Swap(size_t32 ui) const | |
930 | { | |
931 | return m_bSwapped ? (ui << 24) | ((ui & 0xff00) << 8) | | |
932 | ((ui >> 8) & 0xff00) | (ui >> 24) | |
933 | : ui; | |
934 | } | |
9e7ed2b0 | 935 | |
869c7549 VZ |
936 | const char *StringAtOfs(wxMsgTableEntry *pTable, size_t32 n) const |
937 | { | |
938 | const wxMsgTableEntry * const ent = pTable + n; | |
563d535e | 939 | |
869c7549 VZ |
940 | // this check could fail for a corrupt message catalog |
941 | size_t32 ofsString = Swap(ent->ofsString); | |
942 | if ( ofsString + Swap(ent->nLen) > m_nSize) | |
849a28d0 | 943 | { |
869c7549 | 944 | return NULL; |
849a28d0 | 945 | } |
563d535e | 946 | |
869c7549 | 947 | return (const char *)(m_pData + ofsString); |
b7b97e77 | 948 | } |
869c7549 VZ |
949 | |
950 | bool m_bSwapped; // wrong endianness? | |
22f3361e VZ |
951 | |
952 | DECLARE_NO_COPY_CLASS(wxMsgCatalogFile) | |
563d535e VS |
953 | }; |
954 | ||
955 | ||
c801d85f | 956 | // ---------------------------------------------------------------------------- |
563d535e | 957 | // wxMsgCatalog corresponds to one loaded message catalog. |
c801d85f KB |
958 | // |
959 | // This is a "low-level" class and is used only by wxLocale (that's why | |
960 | // it's designed to be stored in a linked list) | |
961 | // ---------------------------------------------------------------------------- | |
962 | ||
963 | class wxMsgCatalog | |
964 | { | |
965 | public: | |
563d535e | 966 | // load the catalog from disk (szDirPrefix corresponds to language) |
d721baa9 VS |
967 | bool Load(const wxChar *szDirPrefix, const wxChar *szName, |
968 | const wxChar *msgIdCharset = NULL, bool bConvertEncoding = false); | |
c801d85f | 969 | |
563d535e VS |
970 | // get name of the catalog |
971 | wxString GetName() const { return m_name; } | |
c801d85f | 972 | |
563d535e | 973 | // get the translated string: returns NULL if not found |
849a28d0 | 974 | const wxChar *GetString(const wxChar *sz, size_t n = size_t(-1)) const; |
c801d85f | 975 | |
563d535e VS |
976 | // public variable pointing to the next element in a linked list (or NULL) |
977 | wxMsgCatalog *m_pNext; | |
7af89395 | 978 | |
c801d85f | 979 | private: |
563d535e VS |
980 | wxMessagesHash m_messages; // all messages in the catalog |
981 | wxString m_name; // name of the domain | |
849a28d0 | 982 | wxPluralFormsCalculatorPtr m_pluralFormsCalculator; |
c801d85f KB |
983 | }; |
984 | ||
fd323a5e VZ |
985 | // ---------------------------------------------------------------------------- |
986 | // global variables | |
987 | // ---------------------------------------------------------------------------- | |
988 | ||
989 | // the list of the directories to search for message catalog files | |
990 | static wxArrayString s_searchPrefixes; | |
991 | ||
c801d85f KB |
992 | // ============================================================================ |
993 | // implementation | |
994 | // ============================================================================ | |
995 | ||
996 | // ---------------------------------------------------------------------------- | |
563d535e | 997 | // wxMsgCatalogFile class |
c801d85f KB |
998 | // ---------------------------------------------------------------------------- |
999 | ||
563d535e | 1000 | wxMsgCatalogFile::wxMsgCatalogFile() |
7af89395 | 1001 | { |
869c7549 VZ |
1002 | m_pData = NULL; |
1003 | m_nSize = 0; | |
c801d85f KB |
1004 | } |
1005 | ||
563d535e | 1006 | wxMsgCatalogFile::~wxMsgCatalogFile() |
7af89395 | 1007 | { |
869c7549 | 1008 | wxDELETEA(m_pData); |
c801d85f KB |
1009 | } |
1010 | ||
fd323a5e | 1011 | // return all directories to search for given prefix |
e36e6f95 OK |
1012 | static wxString GetAllMsgCatalogSubdirs(const wxChar *prefix, |
1013 | const wxChar *lang) | |
fd323a5e VZ |
1014 | { |
1015 | wxString searchPath; | |
1016 | ||
1017 | // search first in prefix/fr/LC_MESSAGES, then in prefix/fr and finally in | |
1018 | // prefix (assuming the language is 'fr') | |
7af89395 | 1019 | searchPath << prefix << wxFILE_SEP_PATH << lang << wxFILE_SEP_PATH |
223d09f6 | 1020 | << wxT("LC_MESSAGES") << wxPATH_SEP |
7af89395 VZ |
1021 | << prefix << wxFILE_SEP_PATH << lang << wxPATH_SEP |
1022 | << prefix << wxPATH_SEP; | |
fd323a5e VZ |
1023 | |
1024 | return searchPath; | |
1025 | } | |
1026 | ||
1027 | // construct the search path for the given language | |
e36e6f95 | 1028 | static wxString GetFullSearchPath(const wxChar *lang) |
fd323a5e VZ |
1029 | { |
1030 | wxString searchPath; | |
1031 | ||
1032 | // first take the entries explicitly added by the program | |
1033 | size_t count = s_searchPrefixes.Count(); | |
1034 | for ( size_t n = 0; n < count; n++ ) | |
1035 | { | |
1036 | searchPath << GetAllMsgCatalogSubdirs(s_searchPrefixes[n], lang) | |
7af89395 | 1037 | << wxPATH_SEP; |
fd323a5e VZ |
1038 | } |
1039 | ||
5f170f33 VZ |
1040 | // LC_PATH is a standard env var containing the search path for the .mo |
1041 | // files | |
1c193821 | 1042 | #ifndef __WXWINCE__ |
f6bcfd97 | 1043 | const wxChar *pszLcPath = wxGetenv(wxT("LC_PATH")); |
5f170f33 VZ |
1044 | if ( pszLcPath != NULL ) |
1045 | searchPath << GetAllMsgCatalogSubdirs(pszLcPath, lang); | |
1c193821 | 1046 | #endif |
5f170f33 | 1047 | |
c3ccca4a VS |
1048 | #ifdef __UNIX__ |
1049 | // add some standard ones and the one in the tree where wxWin was installed: | |
1050 | searchPath | |
1051 | << GetAllMsgCatalogSubdirs(wxString(wxGetInstallPrefix()) + wxT("/share/locale"), lang) | |
1052 | << GetAllMsgCatalogSubdirs(wxT("/usr/share/locale"), lang) | |
1053 | << GetAllMsgCatalogSubdirs(wxT("/usr/lib/locale"), lang) | |
1054 | << GetAllMsgCatalogSubdirs(wxT("/usr/local/share/locale"), lang); | |
1055 | #endif // __UNIX__ | |
1056 | ||
fd323a5e VZ |
1057 | // then take the current directory |
1058 | // FIXME it should be the directory of the executable | |
0e32fdb8 SC |
1059 | #ifdef __WXMAC__ |
1060 | wxChar cwd[512] ; | |
1061 | wxGetWorkingDirectory( cwd , sizeof( cwd ) ) ; | |
1062 | searchPath << GetAllMsgCatalogSubdirs(cwd, lang); | |
1063 | // generic search paths could be somewhere in the system folder preferences | |
45e97ca0 | 1064 | #else // !Mac |
15b8c27a | 1065 | searchPath << GetAllMsgCatalogSubdirs(wxT("."), lang); |
fd323a5e | 1066 | |
45e97ca0 VZ |
1067 | #endif // platform |
1068 | ||
fd323a5e VZ |
1069 | return searchPath; |
1070 | } | |
1071 | ||
c801d85f | 1072 | // open disk file and read in it's contents |
849a28d0 VS |
1073 | bool wxMsgCatalogFile::Load(const wxChar *szDirPrefix, const wxChar *szName0, |
1074 | wxPluralFormsCalculatorPtr& rPluralFormsCalculator) | |
c801d85f | 1075 | { |
03443829 KB |
1076 | /* We need to handle locales like de_AT.iso-8859-1 |
1077 | For this we first chop off the .CHARSET specifier and ignore it. | |
1078 | FIXME: UNICODE SUPPORT: must use CHARSET specifier! | |
1079 | */ | |
1080 | wxString szName = szName0; | |
7beb59f3 | 1081 | if(szName.Find(wxT('.')) != wxNOT_FOUND) // contains a dot |
58c837a4 | 1082 | szName = szName.Left(szName.Find(wxT('.'))); |
2ce0a6e2 | 1083 | |
fd323a5e | 1084 | wxString searchPath = GetFullSearchPath(szDirPrefix); |
223d09f6 | 1085 | const wxChar *sublocale = wxStrchr(szDirPrefix, wxT('_')); |
fd323a5e VZ |
1086 | if ( sublocale ) |
1087 | { | |
1088 | // also add just base locale name: for things like "fr_BE" (belgium | |
1089 | // french) we should use "fr" if no belgium specific message catalogs | |
1090 | // exist | |
1091 | searchPath << GetFullSearchPath(wxString(szDirPrefix). | |
1092 | Left((size_t)(sublocale - szDirPrefix))) | |
7af89395 | 1093 | << wxPATH_SEP; |
fd323a5e | 1094 | } |
7af89395 | 1095 | |
c801d85f KB |
1096 | wxString strFile = szName; |
1097 | strFile += MSGCATALOG_EXTENSION; | |
1098 | ||
1099 | // don't give translation errors here because the wxstd catalog might | |
1100 | // not yet be loaded (and it's normal) | |
1101 | // | |
1102 | // (we're using an object because we have several return paths) | |
ed58dbea | 1103 | |
c801d85f | 1104 | NoTransErr noTransErr; |
5f170f33 | 1105 | wxLogVerbose(_("looking for catalog '%s' in path '%s'."), |
742af071 | 1106 | szName.c_str(), searchPath.c_str()); |
c801d85f KB |
1107 | |
1108 | wxString strFullName; | |
fd323a5e | 1109 | if ( !wxFindFileInPath(&strFullName, searchPath, strFile) ) { |
c611452f | 1110 | wxLogVerbose(_("catalog file for domain '%s' not found."), szName.c_str()); |
7beb59f3 | 1111 | return false; |
c801d85f KB |
1112 | } |
1113 | ||
1114 | // open file | |
1a5a8367 | 1115 | wxLogVerbose(_("using catalog '%s' from '%s'."), |
ed58dbea | 1116 | szName.c_str(), strFullName.c_str()); |
7af89395 | 1117 | |
c801d85f KB |
1118 | wxFile fileMsg(strFullName); |
1119 | if ( !fileMsg.IsOpened() ) | |
7beb59f3 | 1120 | return false; |
c801d85f KB |
1121 | |
1122 | // get the file size | |
1678ad78 GL |
1123 | off_t nSize = fileMsg.Length(); |
1124 | if ( nSize == wxInvalidOffset ) | |
7beb59f3 | 1125 | return false; |
c801d85f KB |
1126 | |
1127 | // read the whole file in memory | |
c86f1403 | 1128 | m_pData = new size_t8[nSize]; |
c801d85f | 1129 | if ( fileMsg.Read(m_pData, nSize) != nSize ) { |
a3622daa | 1130 | wxDELETEA(m_pData); |
7beb59f3 | 1131 | return false; |
c801d85f | 1132 | } |
7af89395 | 1133 | |
c801d85f | 1134 | // examine header |
1678ad78 | 1135 | bool bValid = (size_t)nSize > sizeof(wxMsgCatalogHeader); |
7af89395 | 1136 | |
fd3f686c | 1137 | wxMsgCatalogHeader *pHeader = (wxMsgCatalogHeader *)m_pData; |
c801d85f | 1138 | if ( bValid ) { |
c801d85f KB |
1139 | // we'll have to swap all the integers if it's true |
1140 | m_bSwapped = pHeader->magic == MSGCATALOG_MAGIC_SW; | |
1141 | ||
1142 | // check the magic number | |
1143 | bValid = m_bSwapped || pHeader->magic == MSGCATALOG_MAGIC; | |
1144 | } | |
7af89395 | 1145 | |
c801d85f KB |
1146 | if ( !bValid ) { |
1147 | // it's either too short or has incorrect magic number | |
1a5a8367 | 1148 | wxLogWarning(_("'%s' is not a valid message catalog."), strFullName.c_str()); |
7af89395 | 1149 | |
a3622daa | 1150 | wxDELETEA(m_pData); |
7beb59f3 | 1151 | return false; |
c801d85f | 1152 | } |
7af89395 | 1153 | |
c801d85f KB |
1154 | // initialize |
1155 | m_numStrings = Swap(pHeader->numStrings); | |
7af89395 | 1156 | m_pOrigTable = (wxMsgTableEntry *)(m_pData + |
1678ad78 | 1157 | Swap(pHeader->ofsOrigTable)); |
7af89395 | 1158 | m_pTransTable = (wxMsgTableEntry *)(m_pData + |
1678ad78 | 1159 | Swap(pHeader->ofsTransTable)); |
869c7549 | 1160 | m_nSize = nSize; |
b7b97e77 | 1161 | |
849a28d0 VS |
1162 | // now parse catalog's header and try to extract catalog charset and |
1163 | // plural forms formula from it: | |
1164 | ||
1165 | const char* headerData = StringAtOfs(m_pOrigTable, 0); | |
1166 | if (headerData && headerData[0] == 0) | |
1167 | { | |
1168 | // Extract the charset: | |
1169 | wxString header = wxString::FromAscii(StringAtOfs(m_pTransTable, 0)); | |
1170 | int begin = header.Find(wxT("Content-Type: text/plain; charset=")); | |
1171 | if (begin != wxNOT_FOUND) | |
1172 | { | |
1173 | begin += 34; //strlen("Content-Type: text/plain; charset=") | |
1174 | size_t end = header.find('\n', begin); | |
1175 | if (end != size_t(-1)) | |
1176 | { | |
1177 | m_charset.assign(header, begin, end - begin); | |
1178 | if (m_charset == wxT("CHARSET")) | |
1179 | { | |
1180 | // "CHARSET" is not valid charset, but lazy translator | |
1181 | m_charset.Clear(); | |
1182 | } | |
1183 | } | |
1184 | } | |
1185 | // else: incorrectly filled Content-Type header | |
b7b97e77 | 1186 | |
849a28d0 VS |
1187 | // Extract plural forms: |
1188 | begin = header.Find(wxT("Plural-Forms:")); | |
1189 | if (begin != wxNOT_FOUND) | |
1190 | { | |
1191 | begin += 13; | |
1192 | size_t end = header.find('\n', begin); | |
1193 | if (end != size_t(-1)) | |
1194 | { | |
1195 | wxString pfs(header, begin, end - begin); | |
1196 | wxPluralFormsCalculator* pCalculator = wxPluralFormsCalculator | |
1197 | ::make(pfs.ToAscii()); | |
1198 | if (pCalculator != 0) | |
1199 | { | |
1200 | rPluralFormsCalculator.reset(pCalculator); | |
1201 | } | |
1202 | else | |
1203 | { | |
1204 | wxLogVerbose(_("Cannot parse Plural-Forms:'%s'"), | |
1205 | pfs.c_str()); | |
1206 | } | |
1207 | } | |
1208 | } | |
1209 | if (rPluralFormsCalculator.get() == NULL) | |
1210 | { | |
1211 | rPluralFormsCalculator.reset(wxPluralFormsCalculator::make()); | |
1212 | } | |
1213 | } | |
c801d85f | 1214 | |
c801d85f | 1215 | // everything is fine |
849a28d0 | 1216 | return true; |
c801d85f KB |
1217 | } |
1218 | ||
d721baa9 VS |
1219 | void wxMsgCatalogFile::FillHash(wxMessagesHash& hash, |
1220 | const wxString& msgIdCharset, | |
1221 | bool convertEncoding) const | |
c801d85f | 1222 | { |
563d535e VS |
1223 | #if wxUSE_WCHAR_T |
1224 | wxCSConv *csConv = NULL; | |
7beb59f3 | 1225 | if ( !m_charset.IsEmpty() ) |
849a28d0 | 1226 | csConv = new wxCSConv(m_charset); |
7af89395 | 1227 | |
821d0fef | 1228 | wxMBConv& inputConv = csConv ? *((wxMBConv*)csConv) : *wxConvCurrent; |
d721baa9 VS |
1229 | |
1230 | wxCSConv *sourceConv = NULL; | |
1231 | if ( !msgIdCharset.empty() && (m_charset != msgIdCharset) ) | |
1232 | sourceConv = new wxCSConv(msgIdCharset); | |
1233 | ||
849a28d0 | 1234 | #elif wxUSE_FONTMAP |
d721baa9 VS |
1235 | wxASSERT_MSG( msgIdCharset == NULL, |
1236 | _T("non-ASCII msgid languages only supported if wxUSE_WCHAR_T=1") ); | |
7beb59f3 | 1237 | |
849a28d0 | 1238 | wxEncodingConverter converter; |
563d535e VS |
1239 | if ( convertEncoding ) |
1240 | { | |
baf736e1 | 1241 | wxFontEncoding targetEnc = wxFONTENCODING_SYSTEM; |
7beb59f3 | 1242 | wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(m_charset, false); |
563d535e VS |
1243 | if ( enc == wxFONTENCODING_SYSTEM ) |
1244 | { | |
7beb59f3 | 1245 | convertEncoding = false; // unknown encoding |
563d535e VS |
1246 | } |
1247 | else | |
1248 | { | |
baf736e1 | 1249 | targetEnc = wxLocale::GetSystemEncoding(); |
563d535e VS |
1250 | if (targetEnc == wxFONTENCODING_SYSTEM) |
1251 | { | |
1252 | wxFontEncodingArray a = wxEncodingConverter::GetPlatformEquivalents(enc); | |
1253 | if (a[0] == enc) | |
1254 | // no conversion needed, locale uses native encoding | |
7beb59f3 | 1255 | convertEncoding = false; |
563d535e VS |
1256 | if (a.GetCount() == 0) |
1257 | // we don't know common equiv. under this platform | |
7beb59f3 | 1258 | convertEncoding = false; |
563d535e VS |
1259 | targetEnc = a[0]; |
1260 | } | |
1261 | } | |
1262 | ||
1263 | if ( convertEncoding ) | |
1264 | { | |
563d535e | 1265 | converter.Init(enc, targetEnc); |
563d535e VS |
1266 | } |
1267 | } | |
563d535e | 1268 | #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T |
0c93d67c | 1269 | (void)convertEncoding; // get rid of warnings about unused parameter |
bc385ba9 | 1270 | |
849a28d0 | 1271 | for (size_t i = 0; i < m_numStrings; i++) |
563d535e | 1272 | { |
849a28d0 | 1273 | const char *data = StringAtOfs(m_pOrigTable, i); |
d721baa9 | 1274 | #if wxUSE_UNICODE |
849a28d0 VS |
1275 | wxString msgid(data, inputConv); |
1276 | #else | |
d721baa9 VS |
1277 | wxString msgid; |
1278 | #if wxUSE_WCHAR_T | |
1279 | if ( convertEncoding && sourceConv ) | |
1280 | msgid = wxString(inputConv.cMB2WC(data), *sourceConv); | |
1281 | else | |
849a28d0 | 1282 | #endif |
d721baa9 VS |
1283 | msgid = data; |
1284 | #endif // wxUSE_UNICODE | |
563d535e | 1285 | |
849a28d0 VS |
1286 | data = StringAtOfs(m_pTransTable, i); |
1287 | size_t length = Swap(m_pTransTable[i].nLen); | |
1288 | size_t offset = 0; | |
1289 | size_t index = 0; | |
1290 | while (offset < length) | |
1291 | { | |
1292 | wxString msgstr; | |
1293 | #if wxUSE_WCHAR_T | |
1294 | #if wxUSE_UNICODE | |
1295 | msgstr = wxString(data + offset, inputConv); | |
1296 | #else | |
1297 | if ( convertEncoding ) | |
1298 | msgstr = wxString(inputConv.cMB2WC(data + offset), wxConvLocal); | |
1299 | else | |
1300 | msgstr = wxString(data + offset); | |
1301 | #endif | |
1302 | #else // !wxUSE_WCHAR_T | |
1303 | #if wxUSE_FONTMAP | |
1304 | if ( convertEncoding ) | |
1305 | msgstr = wxString(converter.Convert(data + offset)); | |
1306 | else | |
1307 | #endif | |
1308 | msgstr = wxString(data + offset); | |
1309 | #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T | |
9e7ed2b0 | 1310 | |
849a28d0 VS |
1311 | if ( !msgstr.empty() ) |
1312 | { | |
1313 | hash[index == 0 ? msgid : msgid + wxChar(index)] = msgstr; | |
1314 | } | |
1315 | offset += strlen(data + offset) + 1; | |
1316 | ++index; | |
1317 | } | |
41780009 | 1318 | } |
9e7ed2b0 | 1319 | |
849a28d0 | 1320 | #if wxUSE_WCHAR_T |
d721baa9 | 1321 | delete sourceConv; |
849a28d0 VS |
1322 | delete csConv; |
1323 | #endif | |
563d535e | 1324 | } |
bc385ba9 | 1325 | |
849a28d0 | 1326 | |
563d535e VS |
1327 | // ---------------------------------------------------------------------------- |
1328 | // wxMsgCatalog class | |
1329 | // ---------------------------------------------------------------------------- | |
bc385ba9 | 1330 | |
9e7ed2b0 | 1331 | bool wxMsgCatalog::Load(const wxChar *szDirPrefix, const wxChar *szName, |
d721baa9 | 1332 | const wxChar *msgIdCharset, bool bConvertEncoding) |
563d535e VS |
1333 | { |
1334 | wxMsgCatalogFile file; | |
9e7ed2b0 | 1335 | |
563d535e | 1336 | m_name = szName; |
9e7ed2b0 | 1337 | |
849a28d0 | 1338 | if ( file.Load(szDirPrefix, szName, m_pluralFormsCalculator) ) |
563d535e | 1339 | { |
d721baa9 | 1340 | file.FillHash(m_messages, msgIdCharset, bConvertEncoding); |
7beb59f3 | 1341 | return true; |
563d535e | 1342 | } |
821d0fef | 1343 | |
7beb59f3 | 1344 | return false; |
afc94fa6 VS |
1345 | } |
1346 | ||
849a28d0 | 1347 | const wxChar *wxMsgCatalog::GetString(const wxChar *sz, size_t n) const |
563d535e | 1348 | { |
849a28d0 VS |
1349 | int index = 0; |
1350 | if (n != size_t(-1)) | |
1351 | { | |
1352 | index = m_pluralFormsCalculator->evaluate(n); | |
1353 | } | |
1354 | wxMessagesHash::const_iterator i; | |
1355 | if (index != 0) | |
1356 | { | |
1357 | i = m_messages.find(wxString(sz) + wxChar(index)); // plural | |
1358 | } | |
1359 | else | |
1360 | { | |
1361 | i = m_messages.find(sz); | |
1362 | } | |
1363 | ||
563d535e VS |
1364 | if ( i != m_messages.end() ) |
1365 | { | |
1366 | return i->second.c_str(); | |
1367 | } | |
1368 | else | |
1369 | return NULL; | |
1370 | } | |
afc94fa6 | 1371 | |
c801d85f KB |
1372 | // ---------------------------------------------------------------------------- |
1373 | // wxLocale | |
1374 | // ---------------------------------------------------------------------------- | |
1375 | ||
d3f3e35f VS |
1376 | #include "wx/arrimpl.cpp" |
1377 | WX_DECLARE_EXPORTED_OBJARRAY(wxLanguageInfo, wxLanguageInfoArray); | |
1378 | WX_DEFINE_OBJARRAY(wxLanguageInfoArray); | |
1379 | ||
41780009 VS |
1380 | wxLanguageInfoArray *wxLocale::ms_languagesDB = NULL; |
1381 | ||
1382 | /*static*/ void wxLocale::CreateLanguagesDB() | |
1383 | { | |
1384 | if (ms_languagesDB == NULL) | |
1385 | { | |
1386 | ms_languagesDB = new wxLanguageInfoArray; | |
1387 | InitLanguagesDB(); | |
1388 | } | |
1389 | } | |
1390 | ||
1391 | /*static*/ void wxLocale::DestroyLanguagesDB() | |
1392 | { | |
1393 | delete ms_languagesDB; | |
1394 | ms_languagesDB = NULL; | |
1395 | } | |
1396 | ||
1397 | ||
ea8f6fc7 | 1398 | void wxLocale::DoCommonInit() |
c801d85f | 1399 | { |
23fcecf7 VZ |
1400 | m_pszOldLocale = NULL; |
1401 | m_pMsgCat = NULL; | |
d3f3e35f | 1402 | m_language = wxLANGUAGE_UNKNOWN; |
3202d00d | 1403 | m_initialized = false; |
23fcecf7 VZ |
1404 | } |
1405 | ||
1406 | // NB: this function has (desired) side effect of changing current locale | |
e36e6f95 OK |
1407 | bool wxLocale::Init(const wxChar *szName, |
1408 | const wxChar *szShort, | |
1409 | const wxChar *szLocale, | |
afc94fa6 VS |
1410 | bool bLoadDefault, |
1411 | bool bConvertEncoding) | |
23fcecf7 | 1412 | { |
3202d00d VS |
1413 | wxASSERT_MSG( !m_initialized, |
1414 | _T("you can't call wxLocale::Init more than once") ); | |
b7b97e77 | 1415 | |
3202d00d | 1416 | m_initialized = true; |
23fcecf7 VZ |
1417 | m_strLocale = szName; |
1418 | m_strShort = szShort; | |
afc94fa6 | 1419 | m_bConvertEncoding = bConvertEncoding; |
d3f3e35f | 1420 | m_language = wxLANGUAGE_UNKNOWN; |
23fcecf7 | 1421 | |
c801d85f KB |
1422 | // change current locale (default: same as long name) |
1423 | if ( szLocale == NULL ) | |
9dea50fc VZ |
1424 | { |
1425 | // the argument to setlocale() | |
1426 | szLocale = szShort; | |
52558258 | 1427 | |
7beb59f3 | 1428 | wxCHECK_MSG( szLocale, false, _T("no locale to set in wxLocale::Init()") ); |
9dea50fc | 1429 | } |
10545ca4 | 1430 | |
1c193821 JS |
1431 | #ifdef __WXWINCE__ |
1432 | // FIXME: I'm guessing here | |
1433 | wxChar localeName[256]; | |
1434 | int ret = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SLANGUAGE, localeName, | |
1435 | 256); | |
1436 | if (ret != 0) | |
1437 | { | |
b7b97e77 | 1438 | m_pszOldLocale = wxStrdup(localeName); |
1c193821 JS |
1439 | } |
1440 | else | |
1441 | m_pszOldLocale = NULL; | |
1442 | ||
1443 | // TODO: how to find languageId | |
1444 | // SetLocaleInfo(languageId, SORT_DEFAULT, localeName); | |
1445 | #else | |
c76b6474 VS |
1446 | wxMB2WXbuf oldLocale = wxSetlocale(LC_ALL, szLocale); |
1447 | if ( oldLocale ) | |
1448 | m_pszOldLocale = wxStrdup(oldLocale); | |
1449 | else | |
1450 | m_pszOldLocale = NULL; | |
1c193821 JS |
1451 | #endif |
1452 | ||
c801d85f | 1453 | if ( m_pszOldLocale == NULL ) |
1a5a8367 | 1454 | wxLogError(_("locale '%s' can not be set."), szLocale); |
c801d85f KB |
1455 | |
1456 | // the short name will be used to look for catalog files as well, | |
1457 | // so we need something here | |
1458 | if ( m_strShort.IsEmpty() ) { | |
fd323a5e VZ |
1459 | // FIXME I don't know how these 2 letter abbreviations are formed, |
1460 | // this wild guess is surely wrong | |
c7c06291 | 1461 | if ( szLocale && szLocale[0] ) |
70426fba VZ |
1462 | { |
1463 | m_strShort += (wxChar)wxTolower(szLocale[0]); | |
1464 | if ( szLocale[1] ) | |
1465 | m_strShort += (wxChar)wxTolower(szLocale[1]); | |
1466 | } | |
c801d85f | 1467 | } |
7af89395 | 1468 | |
c801d85f | 1469 | // save the old locale to be able to restore it later |
7af89395 VZ |
1470 | m_pOldLocale = wxSetLocale(this); |
1471 | ||
77ffb593 | 1472 | // load the default catalog with wxWidgets standard messages |
c801d85f | 1473 | m_pMsgCat = NULL; |
7beb59f3 | 1474 | bool bOk = true; |
c801d85f | 1475 | if ( bLoadDefault ) |
223d09f6 | 1476 | bOk = AddCatalog(wxT("wxstd")); |
23fcecf7 VZ |
1477 | |
1478 | return bOk; | |
c801d85f KB |
1479 | } |
1480 | ||
41524ffc VS |
1481 | |
1482 | #if defined(__UNIX__) && wxUSE_UNICODE | |
1483 | static wxWCharBuffer wxSetlocaleTryUTF(int c, const wxChar *lc) | |
1484 | { | |
1485 | wxMB2WXbuf l = wxSetlocale(c, lc); | |
2d34a303 | 1486 | if ( !l && lc && lc[0] != 0 ) |
41524ffc | 1487 | { |
7beb59f3 | 1488 | wxString buf(lc); |
2d34a303 | 1489 | wxString buf2; |
7beb59f3 WS |
1490 | buf2 = buf + wxT(".UTF-8"); |
1491 | l = wxSetlocale(c, buf2.c_str()); | |
2d34a303 VS |
1492 | if ( !l ) |
1493 | { | |
1494 | buf2 = buf + wxT(".utf-8"); | |
7beb59f3 | 1495 | l = wxSetlocale(c, buf2.c_str()); |
2d34a303 VS |
1496 | } |
1497 | if ( !l ) | |
1498 | { | |
1499 | buf2 = buf + wxT(".UTF8"); | |
7beb59f3 | 1500 | l = wxSetlocale(c, buf2.c_str()); |
2d34a303 VS |
1501 | } |
1502 | if ( !l ) | |
1503 | { | |
1504 | buf2 = buf + wxT(".utf8"); | |
7beb59f3 | 1505 | l = wxSetlocale(c, buf2.c_str()); |
2d34a303 | 1506 | } |
41524ffc VS |
1507 | } |
1508 | return l; | |
1509 | } | |
1510 | #else | |
1511 | #define wxSetlocaleTryUTF(c, lc) wxSetlocale(c, lc) | |
1512 | #endif | |
1513 | ||
d3f3e35f VS |
1514 | bool wxLocale::Init(int language, int flags) |
1515 | { | |
d3f3e35f | 1516 | int lang = language; |
ec37df57 VZ |
1517 | if (lang == wxLANGUAGE_DEFAULT) |
1518 | { | |
1519 | // auto detect the language | |
1520 | lang = GetSystemLanguage(); | |
1521 | } | |
1522 | ||
1523 | // We failed to detect system language, so we will use English: | |
1524 | if (lang == wxLANGUAGE_UNKNOWN) | |
1525 | { | |
7beb59f3 | 1526 | return false; |
ec37df57 VZ |
1527 | } |
1528 | ||
14f8fa9d | 1529 | const wxLanguageInfo *info = GetLanguageInfo(lang); |
d3f3e35f | 1530 | |
d3f3e35f VS |
1531 | // Unknown language: |
1532 | if (info == NULL) | |
1533 | { | |
1534 | wxLogError(wxT("Unknown language %i."), lang); | |
7beb59f3 | 1535 | return false; |
d3f3e35f VS |
1536 | } |
1537 | ||
1538 | wxString name = info->Description; | |
1539 | wxString canonical = info->CanonicalName; | |
1540 | wxString locale; | |
ec37df57 | 1541 | |
d3f3e35f | 1542 | // Set the locale: |
432e8391 | 1543 | #if defined(__UNIX__) && !defined(__WXMAC__) |
ec37df57 VZ |
1544 | if (language == wxLANGUAGE_DEFAULT) |
1545 | locale = wxEmptyString; | |
1546 | else | |
1547 | locale = info->CanonicalName; | |
d3f3e35f | 1548 | |
41524ffc | 1549 | wxMB2WXbuf retloc = wxSetlocaleTryUTF(LC_ALL, locale); |
d3f3e35f | 1550 | |
2b5f62a0 | 1551 | if ( !retloc ) |
d3f3e35f VS |
1552 | { |
1553 | // Some C libraries don't like xx_YY form and require xx only | |
41524ffc | 1554 | retloc = wxSetlocaleTryUTF(LC_ALL, locale.Mid(0,2)); |
d3f3e35f | 1555 | } |
2b5f62a0 | 1556 | if ( !retloc ) |
d3f3e35f VS |
1557 | { |
1558 | // Some C libraries (namely glibc) still use old ISO 639, | |
1559 | // so will translate the abbrev for them | |
1560 | wxString mid = locale.Mid(0,2); | |
2b5f62a0 VZ |
1561 | if (mid == wxT("he")) |
1562 | locale = wxT("iw") + locale.Mid(3); | |
1563 | else if (mid == wxT("id")) | |
1564 | locale = wxT("in") + locale.Mid(3); | |
1565 | else if (mid == wxT("yi")) | |
1566 | locale = wxT("ji") + locale.Mid(3); | |
cf5e94bc VS |
1567 | else if (mid == wxT("nb")) |
1568 | locale = wxT("no_NO"); | |
1569 | else if (mid == wxT("nn")) | |
1570 | locale = wxT("no_NY"); | |
2b5f62a0 | 1571 | |
41524ffc | 1572 | retloc = wxSetlocaleTryUTF(LC_ALL, locale); |
d3f3e35f | 1573 | } |
2b5f62a0 | 1574 | if ( !retloc ) |
d3f3e35f VS |
1575 | { |
1576 | // (This time, we changed locale in previous if-branch, so try again.) | |
1577 | // Some C libraries don't like xx_YY form and require xx only | |
41524ffc | 1578 | retloc = wxSetlocaleTryUTF(LC_ALL, locale.Mid(0,2)); |
d3f3e35f | 1579 | } |
2b5f62a0 | 1580 | if ( !retloc ) |
d3f3e35f VS |
1581 | { |
1582 | wxLogError(wxT("Cannot set locale to '%s'."), locale.c_str()); | |
7beb59f3 | 1583 | return false; |
d3f3e35f | 1584 | } |
d3f3e35f | 1585 | #elif defined(__WIN32__) |
65dc921d VS |
1586 | |
1587 | #if wxUSE_UNICODE && (defined(__VISUALC__) || defined(__MINGW32__)) | |
1588 | // NB: setlocale() from msvcrt.dll (used by VC++ and Mingw) | |
1589 | // can't set locale to language that can only be written using | |
1590 | // Unicode. Therefore wxSetlocale call failed, but we don't want | |
1591 | // to report it as an error -- so that at least message catalogs | |
1592 | // can be used. Watch for code marked with | |
1593 | // #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS bellow. | |
1594 | #define SETLOCALE_FAILS_ON_UNICODE_LANGS | |
1595 | #endif | |
b7b97e77 VZ |
1596 | |
1597 | #if !wxUSE_UNICODE | |
1598 | const | |
1599 | #endif | |
2b5f62a0 | 1600 | wxMB2WXbuf retloc = wxT("C"); |
d3f3e35f VS |
1601 | if (language != wxLANGUAGE_DEFAULT) |
1602 | { | |
63986ba6 | 1603 | if (info->WinLang == 0) |
d3f3e35f | 1604 | { |
63986ba6 | 1605 | wxLogWarning(wxT("Locale '%s' not supported by OS."), name.c_str()); |
2b5f62a0 | 1606 | // retloc already set to "C" |
63986ba6 VS |
1607 | } |
1608 | else | |
ec37df57 | 1609 | { |
b7b97e77 | 1610 | int codepage |
999836aa VZ |
1611 | #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS |
1612 | = -1 | |
1613 | #endif | |
1614 | ; | |
ec37df57 | 1615 | wxUint32 lcid = MAKELCID(MAKELANGID(info->WinLang, info->WinSublang), |
63986ba6 | 1616 | SORT_DEFAULT); |
1c193821 JS |
1617 | // FIXME |
1618 | #ifndef __WXWINCE__ | |
65dc921d | 1619 | SetThreadLocale(lcid); |
1c193821 | 1620 | #endif |
65dc921d VS |
1621 | // NB: we must translate LCID to CRT's setlocale string ourselves, |
1622 | // because SetThreadLocale does not modify change the | |
1623 | // interpretation of setlocale(LC_ALL, "") call: | |
1624 | wxChar buffer[256]; | |
1625 | buffer[0] = wxT('\0'); | |
1626 | GetLocaleInfo(lcid, LOCALE_SENGLANGUAGE, buffer, 256); | |
1627 | locale << buffer; | |
1628 | if (GetLocaleInfo(lcid, LOCALE_SENGCOUNTRY, buffer, 256) > 0) | |
1629 | locale << wxT("_") << buffer; | |
1630 | if (GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE, buffer, 256) > 0) | |
1631 | { | |
1632 | codepage = wxAtoi(buffer); | |
1633 | if (codepage != 0) | |
1634 | locale << wxT(".") << buffer; | |
1635 | } | |
1636 | if (locale.IsEmpty()) | |
2b5f62a0 | 1637 | { |
65dc921d VS |
1638 | wxLogLastError(wxT("SetThreadLocale")); |
1639 | wxLogError(wxT("Cannot set locale to language %s."), name.c_str()); | |
7beb59f3 | 1640 | return false; |
2b5f62a0 | 1641 | } |
63986ba6 | 1642 | else |
c611452f | 1643 | { |
1c193821 JS |
1644 | // FIXME |
1645 | #ifndef __WXWINCE__ | |
65dc921d | 1646 | retloc = wxSetlocale(LC_ALL, locale); |
1c193821 | 1647 | #endif |
65dc921d VS |
1648 | #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS |
1649 | if (codepage == 0 && (const wxChar*)retloc == NULL) | |
2b5f62a0 | 1650 | { |
65dc921d | 1651 | retloc = wxT("C"); |
2b5f62a0 | 1652 | } |
65dc921d | 1653 | #endif |
c611452f | 1654 | } |
d3f3e35f VS |
1655 | } |
1656 | } | |
c611452f | 1657 | else |
2b5f62a0 | 1658 | { |
1c193821 JS |
1659 | // FIXME |
1660 | #ifndef __WXWINCE__ | |
c611452f | 1661 | retloc = wxSetlocale(LC_ALL, wxEmptyString); |
1c193821 JS |
1662 | #else |
1663 | retloc = NULL; | |
1664 | #endif | |
65dc921d VS |
1665 | #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS |
1666 | if ((const wxChar*)retloc == NULL) | |
1667 | { | |
1668 | wxChar buffer[16]; | |
1669 | if (GetLocaleInfo(LOCALE_USER_DEFAULT, | |
1670 | LOCALE_IDEFAULTANSICODEPAGE, buffer, 16) > 0 && | |
1671 | wxStrcmp(buffer, wxT("0")) == 0) | |
1672 | { | |
1673 | retloc = wxT("C"); | |
1674 | } | |
1675 | } | |
1676 | #endif | |
2b5f62a0 | 1677 | } |
c611452f | 1678 | |
2b5f62a0 | 1679 | if ( !retloc ) |
d3f3e35f VS |
1680 | { |
1681 | wxLogError(wxT("Cannot set locale to language %s."), name.c_str()); | |
7beb59f3 | 1682 | return false; |
d3f3e35f | 1683 | } |
2b5f62a0 VZ |
1684 | #elif defined(__WXMAC__) || defined(__WXPM__) |
1685 | wxMB2WXbuf retloc = wxSetlocale(LC_ALL , wxEmptyString); | |
d3f3e35f | 1686 | #else |
7beb59f3 | 1687 | return false; |
e879e020 | 1688 | #define WX_NO_LOCALE_SUPPORT |
d3f3e35f | 1689 | #endif |
ec37df57 | 1690 | |
e879e020 | 1691 | #ifndef WX_NO_LOCALE_SUPPORT |
10545ca4 | 1692 | wxChar *szLocale = retloc ? wxStrdup(retloc) : NULL; |
b78a78f7 VS |
1693 | bool ret = Init(name, canonical, retloc, |
1694 | (flags & wxLOCALE_LOAD_DEFAULT) != 0, | |
1695 | (flags & wxLOCALE_CONV_ENCODING) != 0); | |
10545ca4 VZ |
1696 | free(szLocale); |
1697 | ||
549a7c37 | 1698 | if (IsOk()) // setlocale() succeeded |
10545ca4 VZ |
1699 | m_language = lang; |
1700 | ||
b78a78f7 | 1701 | return ret; |
e879e020 | 1702 | #endif |
d3f3e35f VS |
1703 | } |
1704 | ||
1705 | ||
1706 | ||
fd323a5e VZ |
1707 | void wxLocale::AddCatalogLookupPathPrefix(const wxString& prefix) |
1708 | { | |
3c67202d | 1709 | if ( s_searchPrefixes.Index(prefix) == wxNOT_FOUND ) |
fd323a5e VZ |
1710 | { |
1711 | s_searchPrefixes.Add(prefix); | |
1712 | } | |
1713 | //else: already have it | |
1714 | } | |
1715 | ||
41780009 | 1716 | /*static*/ int wxLocale::GetSystemLanguage() |
d3f3e35f | 1717 | { |
41780009 | 1718 | CreateLanguagesDB(); |
ec37df57 VZ |
1719 | |
1720 | // init i to avoid compiler warning | |
1721 | size_t i = 0, | |
41780009 | 1722 | count = ms_languagesDB->GetCount(); |
d3f3e35f | 1723 | |
432e8391 | 1724 | #if defined(__UNIX__) && !defined(__WXMAC__) |
ec37df57 VZ |
1725 | // first get the string identifying the language from the environment |
1726 | wxString langFull; | |
1727 | if (!wxGetEnv(wxT("LC_ALL"), &langFull) && | |
1728 | !wxGetEnv(wxT("LC_MESSAGES"), &langFull) && | |
1729 | !wxGetEnv(wxT("LANG"), &langFull)) | |
1730 | { | |
41780009 VS |
1731 | // no language specified, threat it as English |
1732 | return wxLANGUAGE_ENGLISH; | |
ec37df57 | 1733 | } |
d3f3e35f | 1734 | |
efd1393b | 1735 | if ( langFull == _T("C") || langFull == _T("POSIX") ) |
d3f3e35f | 1736 | { |
ec37df57 | 1737 | // default C locale |
41780009 | 1738 | return wxLANGUAGE_ENGLISH; |
d3f3e35f VS |
1739 | } |
1740 | ||
ec37df57 VZ |
1741 | // the language string has the following form |
1742 | // | |
efd1393b | 1743 | // lang[_LANG][.encoding][@modifier] |
ec37df57 | 1744 | // |
efd1393b VZ |
1745 | // (see environ(5) in the Open Unix specification) |
1746 | // | |
1747 | // where lang is the primary language, LANG is a sublang/territory, | |
1748 | // encoding is the charset to use and modifier "allows the user to select | |
1749 | // a specific instance of localization data within a single category" | |
ec37df57 VZ |
1750 | // |
1751 | // for example, the following strings are valid: | |
1752 | // fr | |
1753 | // fr_FR | |
1754 | // de_DE.iso88591 | |
efd1393b VZ |
1755 | // de_DE@euro |
1756 | // de_DE.iso88591@euro | |
ec37df57 VZ |
1757 | |
1758 | // for now we don't use the encoding, although we probably should (doing | |
1759 | // translations of the msg catalogs on the fly as required) (TODO) | |
efd1393b VZ |
1760 | // |
1761 | // we don't use the modifiers neither but we probably should translate | |
1762 | // "euro" into iso885915 | |
1763 | size_t posEndLang = langFull.find_first_of(_T("@.")); | |
1764 | if ( posEndLang != wxString::npos ) | |
1765 | { | |
1766 | langFull.Truncate(posEndLang); | |
1767 | } | |
ec37df57 VZ |
1768 | |
1769 | // in addition to the format above, we also can have full language names | |
1770 | // in LANG env var - for example, SuSE is known to use LANG="german" - so | |
1771 | // check for this | |
1772 | ||
1773 | // do we have just the language (or sublang too)? | |
1774 | bool justLang = langFull.Len() == LEN_LANG; | |
1775 | if ( justLang || | |
1776 | (langFull.Len() == LEN_FULL && langFull[LEN_LANG] == wxT('_')) ) | |
d3f3e35f | 1777 | { |
ec37df57 VZ |
1778 | // 0. Make sure the lang is according to latest ISO 639 |
1779 | // (this is neccessary because glibc uses iw and in instead | |
1780 | // of he and id respectively). | |
1781 | ||
1782 | // the language itself (second part is the dialect/sublang) | |
1783 | wxString langOrig = ExtractLang(langFull); | |
1784 | ||
1785 | wxString lang; | |
1786 | if ( langOrig == wxT("iw")) | |
1787 | lang = _T("he"); | |
cf5e94bc | 1788 | else if (langOrig == wxT("in")) |
ec37df57 | 1789 | lang = wxT("id"); |
cf5e94bc | 1790 | else if (langOrig == wxT("ji")) |
ec37df57 | 1791 | lang = wxT("yi"); |
cf5e94bc VS |
1792 | else if (langOrig == wxT("no_NO")) |
1793 | lang = wxT("nb_NO"); | |
1794 | else if (langOrig == wxT("no_NY")) | |
1795 | lang = wxT("nn_NO"); | |
1796 | else if (langOrig == wxT("no")) | |
1797 | lang = wxT("nb_NO"); | |
ec37df57 VZ |
1798 | else |
1799 | lang = langOrig; | |
1800 | ||
1801 | // did we change it? | |
1802 | if ( lang != langOrig ) | |
d3f3e35f | 1803 | { |
ec37df57 VZ |
1804 | langFull = lang + ExtractNotLang(langFull); |
1805 | } | |
1806 | ||
1807 | // 1. Try to find the language either as is: | |
1808 | for ( i = 0; i < count; i++ ) | |
1809 | { | |
41780009 | 1810 | if ( ms_languagesDB->Item(i).CanonicalName == langFull ) |
d3f3e35f | 1811 | { |
d3f3e35f VS |
1812 | break; |
1813 | } | |
1814 | } | |
d3f3e35f | 1815 | |
ec37df57 VZ |
1816 | // 2. If langFull is of the form xx_YY, try to find xx: |
1817 | if ( i == count && !justLang ) | |
d3f3e35f | 1818 | { |
ec37df57 | 1819 | for ( i = 0; i < count; i++ ) |
d3f3e35f | 1820 | { |
41780009 | 1821 | if ( ms_languagesDB->Item(i).CanonicalName == lang ) |
ec37df57 VZ |
1822 | { |
1823 | break; | |
1824 | } | |
d3f3e35f VS |
1825 | } |
1826 | } | |
d3f3e35f | 1827 | |
ec37df57 VZ |
1828 | // 3. If langFull is of the form xx, try to find any xx_YY record: |
1829 | if ( i == count && justLang ) | |
d3f3e35f | 1830 | { |
ec37df57 | 1831 | for ( i = 0; i < count; i++ ) |
d3f3e35f | 1832 | { |
41780009 | 1833 | if ( ExtractLang(ms_languagesDB->Item(i).CanonicalName) |
ec37df57 VZ |
1834 | == langFull ) |
1835 | { | |
1836 | break; | |
1837 | } | |
d3f3e35f VS |
1838 | } |
1839 | } | |
1840 | } | |
ec37df57 | 1841 | else // not standard format |
d3f3e35f | 1842 | { |
ec37df57 VZ |
1843 | // try to find the name in verbose description |
1844 | for ( i = 0; i < count; i++ ) | |
d3f3e35f | 1845 | { |
41780009 | 1846 | if (ms_languagesDB->Item(i).Description.CmpNoCase(langFull) == 0) |
d3f3e35f | 1847 | { |
d3f3e35f VS |
1848 | break; |
1849 | } | |
1850 | } | |
1851 | } | |
0e32fdb8 | 1852 | #elif defined(__WXMAC__) |
44c44c82 | 1853 | const wxChar * lc = NULL ; |
0e32fdb8 SC |
1854 | long lang = GetScriptVariable( smSystemScript, smScriptLang) ; |
1855 | switch( GetScriptManagerVariable( smRegionCode ) ) { | |
1856 | case verUS : | |
44c44c82 | 1857 | lc = wxT("en_US") ; |
0e32fdb8 SC |
1858 | break ; |
1859 | case verFrance : | |
44c44c82 | 1860 | lc = wxT("fr_FR") ; |
0e32fdb8 SC |
1861 | break ; |
1862 | case verBritain : | |
44c44c82 | 1863 | lc = wxT("en_GB") ; |
0e32fdb8 SC |
1864 | break ; |
1865 | case verGermany : | |
44c44c82 | 1866 | lc = wxT("de_DE") ; |
0e32fdb8 SC |
1867 | break ; |
1868 | case verItaly : | |
44c44c82 | 1869 | lc = wxT("it_IT") ; |
0e32fdb8 SC |
1870 | break ; |
1871 | case verNetherlands : | |
44c44c82 | 1872 | lc = wxT("nl_NL") ; |
0e32fdb8 SC |
1873 | break ; |
1874 | case verFlemish : | |
44c44c82 | 1875 | lc = wxT("nl_BE") ; |
0e32fdb8 SC |
1876 | break ; |
1877 | case verSweden : | |
44c44c82 | 1878 | lc = wxT("sv_SE" ); |
0e32fdb8 SC |
1879 | break ; |
1880 | case verSpain : | |
44c44c82 | 1881 | lc = wxT("es_ES" ); |
0e32fdb8 SC |
1882 | break ; |
1883 | case verDenmark : | |
44c44c82 | 1884 | lc = wxT("da_DK") ; |
0e32fdb8 SC |
1885 | break ; |
1886 | case verPortugal : | |
44c44c82 | 1887 | lc = wxT("pt_PT") ; |
0e32fdb8 SC |
1888 | break ; |
1889 | case verFrCanada: | |
44c44c82 | 1890 | lc = wxT("fr_CA") ; |
0e32fdb8 SC |
1891 | break ; |
1892 | case verNorway: | |
cf5e94bc | 1893 | lc = wxT("nb_NO") ; |
0e32fdb8 SC |
1894 | break ; |
1895 | case verIsrael: | |
44c44c82 | 1896 | lc = wxT("iw_IL") ; |
0e32fdb8 SC |
1897 | break ; |
1898 | case verJapan: | |
44c44c82 | 1899 | lc = wxT("ja_JP") ; |
0e32fdb8 SC |
1900 | break ; |
1901 | case verAustralia: | |
44c44c82 | 1902 | lc = wxT("en_AU") ; |
0e32fdb8 SC |
1903 | break ; |
1904 | case verArabic: | |
44c44c82 | 1905 | lc = wxT("ar") ; |
0e32fdb8 SC |
1906 | break ; |
1907 | case verFinland: | |
44c44c82 | 1908 | lc = wxT("fi_FI") ; |
0e32fdb8 SC |
1909 | break ; |
1910 | case verFrSwiss: | |
44c44c82 | 1911 | lc = wxT("fr_CH") ; |
0e32fdb8 SC |
1912 | break ; |
1913 | case verGrSwiss: | |
44c44c82 | 1914 | lc = wxT("de_CH") ; |
0e32fdb8 SC |
1915 | break ; |
1916 | case verGreece: | |
44c44c82 | 1917 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
1918 | break ; |
1919 | case verIceland: | |
44c44c82 | 1920 | lc = wxT("is_IS") ; |
0e32fdb8 SC |
1921 | break ; |
1922 | case verMalta: | |
44c44c82 | 1923 | lc = wxT("mt_MT") ; |
0e32fdb8 SC |
1924 | break ; |
1925 | case verCyprus: | |
1926 | // _CY is not part of wx, so we have to translate according to the system language | |
1927 | if ( lang == langGreek ) { | |
44c44c82 | 1928 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
1929 | } |
1930 | else if ( lang == langTurkish ) { | |
44c44c82 | 1931 | lc = wxT("tr_TR") ; |
0e32fdb8 SC |
1932 | } |
1933 | break ; | |
1934 | case verTurkey: | |
44c44c82 | 1935 | lc = wxT("tr_TR") ; |
0e32fdb8 SC |
1936 | break ; |
1937 | case verYugoCroatian: | |
44c44c82 | 1938 | lc = wxT("hr_HR") ; |
0e32fdb8 SC |
1939 | break ; |
1940 | case verIndiaHindi: | |
44c44c82 | 1941 | lc = wxT("hi_IN") ; |
0e32fdb8 SC |
1942 | break ; |
1943 | case verPakistanUrdu: | |
44c44c82 | 1944 | lc = wxT("ur_PK") ; |
0e32fdb8 SC |
1945 | break ; |
1946 | case verTurkishModified: | |
44c44c82 | 1947 | lc = wxT("tr_TR") ; |
0e32fdb8 SC |
1948 | break ; |
1949 | case verItalianSwiss: | |
44c44c82 | 1950 | lc = wxT("it_CH") ; |
0e32fdb8 SC |
1951 | break ; |
1952 | case verInternational: | |
44c44c82 | 1953 | lc = wxT("en") ; |
0e32fdb8 SC |
1954 | break ; |
1955 | case verRomania: | |
44c44c82 | 1956 | lc = wxT("ro_RO") ; |
0e32fdb8 SC |
1957 | break ; |
1958 | case verGreecePoly: | |
44c44c82 | 1959 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
1960 | break ; |
1961 | case verLithuania: | |
44c44c82 | 1962 | lc = wxT("lt_LT") ; |
0e32fdb8 SC |
1963 | break ; |
1964 | case verPoland: | |
44c44c82 | 1965 | lc = wxT("pl_PL") ; |
0e32fdb8 SC |
1966 | break ; |
1967 | case verMagyar : | |
1968 | case verHungary: | |
44c44c82 | 1969 | lc = wxT("hu_HU") ; |
0e32fdb8 SC |
1970 | break ; |
1971 | case verEstonia: | |
44c44c82 | 1972 | lc = wxT("et_EE") ; |
0e32fdb8 SC |
1973 | break ; |
1974 | case verLatvia: | |
44c44c82 | 1975 | lc = wxT("lv_LV") ; |
0e32fdb8 SC |
1976 | break ; |
1977 | case verSami: | |
1978 | // not known | |
1979 | break ; | |
1980 | case verFaroeIsl: | |
44c44c82 | 1981 | lc = wxT("fo_FO") ; |
0e32fdb8 SC |
1982 | break ; |
1983 | case verIran: | |
44c44c82 | 1984 | lc = wxT("fa_IR") ; |
0e32fdb8 SC |
1985 | break ; |
1986 | case verRussia: | |
44c44c82 | 1987 | lc = wxT("ru_RU") ; |
0e32fdb8 SC |
1988 | break ; |
1989 | case verIreland: | |
44c44c82 | 1990 | lc = wxT("ga_IE") ; |
0e32fdb8 SC |
1991 | break ; |
1992 | case verKorea: | |
44c44c82 | 1993 | lc = wxT("ko_KR") ; |
0e32fdb8 SC |
1994 | break ; |
1995 | case verChina: | |
44c44c82 | 1996 | lc = wxT("zh_CN") ; |
0e32fdb8 SC |
1997 | break ; |
1998 | case verTaiwan: | |
44c44c82 | 1999 | lc = wxT("zh_TW") ; |
0e32fdb8 SC |
2000 | break ; |
2001 | case verThailand: | |
44c44c82 | 2002 | lc = wxT("th_TH") ; |
0e32fdb8 SC |
2003 | break ; |
2004 | case verCzech: | |
44c44c82 | 2005 | lc = wxT("cs_CZ") ; |
0e32fdb8 SC |
2006 | break ; |
2007 | case verSlovak: | |
44c44c82 | 2008 | lc = wxT("sk_SK") ; |
0e32fdb8 SC |
2009 | break ; |
2010 | case verBengali: | |
44c44c82 | 2011 | lc = wxT("bn") ; |
0e32fdb8 SC |
2012 | break ; |
2013 | case verByeloRussian: | |
44c44c82 | 2014 | lc = wxT("be_BY") ; |
0e32fdb8 SC |
2015 | break ; |
2016 | case verUkraine: | |
44c44c82 | 2017 | lc = wxT("uk_UA") ; |
0e32fdb8 SC |
2018 | break ; |
2019 | case verGreeceAlt: | |
44c44c82 | 2020 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
2021 | break ; |
2022 | case verSerbian: | |
44c44c82 | 2023 | lc = wxT("sr_YU") ; |
0e32fdb8 SC |
2024 | break ; |
2025 | case verSlovenian: | |
44c44c82 | 2026 | lc = wxT("sl_SI") ; |
0e32fdb8 SC |
2027 | break ; |
2028 | case verMacedonian: | |
44c44c82 | 2029 | lc = wxT("mk_MK") ; |
0e32fdb8 SC |
2030 | break ; |
2031 | case verCroatia: | |
44c44c82 | 2032 | lc = wxT("hr_HR") ; |
0e32fdb8 SC |
2033 | break ; |
2034 | case verBrazil: | |
44c44c82 | 2035 | lc = wxT("pt_BR ") ; |
0e32fdb8 SC |
2036 | break ; |
2037 | case verBulgaria: | |
44c44c82 | 2038 | lc = wxT("bg_BG") ; |
0e32fdb8 SC |
2039 | break ; |
2040 | case verCatalonia: | |
44c44c82 | 2041 | lc = wxT("ca_ES") ; |
0e32fdb8 SC |
2042 | break ; |
2043 | case verScottishGaelic: | |
44c44c82 | 2044 | lc = wxT("gd") ; |
0e32fdb8 SC |
2045 | break ; |
2046 | case verManxGaelic: | |
44c44c82 | 2047 | lc = wxT("gv") ; |
0e32fdb8 SC |
2048 | break ; |
2049 | case verBreton: | |
44c44c82 | 2050 | lc = wxT("br") ; |
0e32fdb8 SC |
2051 | break ; |
2052 | case verNunavut: | |
44c44c82 | 2053 | lc = wxT("iu_CA") ; |
0e32fdb8 SC |
2054 | break ; |
2055 | case verWelsh: | |
44c44c82 | 2056 | lc = wxT("cy") ; |
0e32fdb8 SC |
2057 | break ; |
2058 | case verIrishGaelicScript: | |
44c44c82 | 2059 | lc = wxT("ga_IE") ; |
0e32fdb8 SC |
2060 | break ; |
2061 | case verEngCanada: | |
44c44c82 | 2062 | lc = wxT("en_CA") ; |
0e32fdb8 SC |
2063 | break ; |
2064 | case verBhutan: | |
44c44c82 | 2065 | lc = wxT("dz_BT") ; |
0e32fdb8 SC |
2066 | break ; |
2067 | case verArmenian: | |
44c44c82 | 2068 | lc = wxT("hy_AM") ; |
0e32fdb8 SC |
2069 | break ; |
2070 | case verGeorgian: | |
44c44c82 | 2071 | lc = wxT("ka_GE") ; |
0e32fdb8 SC |
2072 | break ; |
2073 | case verSpLatinAmerica: | |
44c44c82 | 2074 | lc = wxT("es_AR") ; |
0e32fdb8 SC |
2075 | break ; |
2076 | case verTonga: | |
44c44c82 | 2077 | lc = wxT("to_TO" ); |
0e32fdb8 SC |
2078 | break ; |
2079 | case verFrenchUniversal: | |
44c44c82 | 2080 | lc = wxT("fr_FR") ; |
0e32fdb8 SC |
2081 | break ; |
2082 | case verAustria: | |
44c44c82 | 2083 | lc = wxT("de_AT") ; |
0e32fdb8 SC |
2084 | break ; |
2085 | case verGujarati: | |
44c44c82 | 2086 | lc = wxT("gu_IN") ; |
0e32fdb8 SC |
2087 | break ; |
2088 | case verPunjabi: | |
44c44c82 | 2089 | lc = wxT("pa") ; |
0e32fdb8 SC |
2090 | break ; |
2091 | case verIndiaUrdu: | |
44c44c82 | 2092 | lc = wxT("ur_IN") ; |
0e32fdb8 SC |
2093 | break ; |
2094 | case verVietnam: | |
44c44c82 | 2095 | lc = wxT("vi_VN") ; |
0e32fdb8 SC |
2096 | break ; |
2097 | case verFrBelgium: | |
44c44c82 | 2098 | lc = wxT("fr_BE") ; |
0e32fdb8 SC |
2099 | break ; |
2100 | case verUzbek: | |
44c44c82 | 2101 | lc = wxT("uz_UZ") ; |
0e32fdb8 SC |
2102 | break ; |
2103 | case verSingapore: | |
44c44c82 | 2104 | lc = wxT("zh_SG") ; |
0e32fdb8 SC |
2105 | break ; |
2106 | case verNynorsk: | |
44c44c82 | 2107 | lc = wxT("nn_NO") ; |
0e32fdb8 SC |
2108 | break ; |
2109 | case verAfrikaans: | |
44c44c82 | 2110 | lc = wxT("af_ZA") ; |
0e32fdb8 SC |
2111 | break ; |
2112 | case verEsperanto: | |
44c44c82 | 2113 | lc = wxT("eo") ; |
0e32fdb8 SC |
2114 | break ; |
2115 | case verMarathi: | |
44c44c82 | 2116 | lc = wxT("mr_IN") ; |
0e32fdb8 SC |
2117 | break ; |
2118 | case verTibetan: | |
44c44c82 | 2119 | lc = wxT("bo") ; |
0e32fdb8 SC |
2120 | break ; |
2121 | case verNepal: | |
44c44c82 | 2122 | lc = wxT("ne_NP") ; |
0e32fdb8 SC |
2123 | break ; |
2124 | case verGreenland: | |
44c44c82 | 2125 | lc = wxT("kl_GL") ; |
0e32fdb8 SC |
2126 | break ; |
2127 | default : | |
2128 | break ; | |
2129 | } | |
2130 | for ( i = 0; i < count; i++ ) | |
2131 | { | |
2132 | if ( ms_languagesDB->Item(i).CanonicalName == lc ) | |
2133 | { | |
2134 | break; | |
2135 | } | |
2136 | } | |
9e7ed2b0 | 2137 | |
d3f3e35f VS |
2138 | #elif defined(__WIN32__) |
2139 | LCID lcid = GetUserDefaultLCID(); | |
ec37df57 | 2140 | if ( lcid != 0 ) |
d3f3e35f | 2141 | { |
ec37df57 VZ |
2142 | wxUint32 lang = PRIMARYLANGID(LANGIDFROMLCID(lcid)); |
2143 | wxUint32 sublang = SUBLANGID(LANGIDFROMLCID(lcid)); | |
2144 | ||
2145 | for ( i = 0; i < count; i++ ) | |
d3f3e35f | 2146 | { |
41780009 VS |
2147 | if (ms_languagesDB->Item(i).WinLang == lang && |
2148 | ms_languagesDB->Item(i).WinSublang == sublang) | |
ec37df57 VZ |
2149 | { |
2150 | break; | |
2151 | } | |
d3f3e35f VS |
2152 | } |
2153 | } | |
ec37df57 VZ |
2154 | //else: leave wxlang == wxLANGUAGE_UNKNOWN |
2155 | #endif // Unix/Win32 | |
d3f3e35f | 2156 | |
ec37df57 VZ |
2157 | if ( i < count ) |
2158 | { | |
2159 | // we did find a matching entry, use it | |
41780009 | 2160 | return ms_languagesDB->Item(i).Language; |
ec37df57 | 2161 | } |
d3f3e35f | 2162 | |
ec37df57 VZ |
2163 | // no info about this language in the database |
2164 | return wxLANGUAGE_UNKNOWN; | |
2165 | } | |
d3f3e35f | 2166 | |
dccce9ea VZ |
2167 | // ---------------------------------------------------------------------------- |
2168 | // encoding stuff | |
2169 | // ---------------------------------------------------------------------------- | |
2170 | ||
2171 | // this is a bit strange as under Windows we get the encoding name using its | |
2172 | // numeric value and under Unix we do it the other way round, but this just | |
97626624 | 2173 | // reflects the way different systems provide the encoding info |
dccce9ea VZ |
2174 | |
2175 | /* static */ | |
2176 | wxString wxLocale::GetSystemEncodingName() | |
2177 | { | |
2178 | wxString encname; | |
2179 | ||
c67d6888 | 2180 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
dccce9ea VZ |
2181 | // FIXME: what is the error return value for GetACP()? |
2182 | UINT codepage = ::GetACP(); | |
ecffe992 | 2183 | encname.Printf(_T("windows-%u"), codepage); |
dccce9ea VZ |
2184 | #elif defined(__UNIX_LIKE__) |
2185 | ||
2186 | #if defined(HAVE_LANGINFO_H) && defined(CODESET) | |
2187 | // GNU libc provides current character set this way (this conforms | |
2188 | // to Unix98) | |
2ec6905c VS |
2189 | char *oldLocale = strdup(setlocale(LC_CTYPE, NULL)); |
2190 | setlocale(LC_CTYPE, ""); | |
f284605f | 2191 | const char *alang = nl_langinfo(CODESET); |
2ec6905c | 2192 | setlocale(LC_CTYPE, oldLocale); |
030c0bea | 2193 | free(oldLocale); |
84f858e9 VZ |
2194 | |
2195 | if ( alang ) | |
dccce9ea | 2196 | { |
84f858e9 VZ |
2197 | // 7 bit ASCII encoding has several alternative names which we should |
2198 | // recognize to avoid warnings about unrecognized encoding on each | |
2199 | // program startup | |
2200 | ||
9cf28550 | 2201 | // nl_langinfo() under Solaris returns 646 by default which stands for |
84f858e9 VZ |
2202 | // ISO-646, i.e. 7 bit ASCII |
2203 | // | |
2204 | // and recent glibc call it ANSI_X3.4-1968... | |
97626624 VZ |
2205 | // |
2206 | // HP-UX uses HP-Roman8 cset which is not the same as ASCII (see RFC | |
2207 | // 1345 for its definition) but must be recognized as otherwise HP | |
2208 | // users get a warning about it on each program startup, so handle it | |
2209 | // here -- but it would be obviously better to add real supprot to it, | |
2210 | // of course! | |
2211 | if ( strcmp(alang, "646") == 0 | |
2212 | || strcmp(alang, "ANSI_X3.4-1968") == 0 | |
2213 | #ifdef __HPUX__ | |
2214 | || strcmp(alang, "roman8") == 0 | |
2215 | #endif // __HPUX__ | |
2216 | ) | |
9cf28550 VZ |
2217 | { |
2218 | encname = _T("US-ASCII"); | |
2219 | } | |
9cf28550 VZ |
2220 | else |
2221 | { | |
b1ac3b56 | 2222 | encname = wxString::FromAscii( alang ); |
9cf28550 | 2223 | } |
dccce9ea VZ |
2224 | } |
2225 | else | |
2226 | #endif // HAVE_LANGINFO_H | |
2227 | { | |
2228 | // if we can't get at the character set directly, try to see if it's in | |
2229 | // the environment variables (in most cases this won't work, but I was | |
2230 | // out of ideas) | |
b1ac3b56 RR |
2231 | char *lang = getenv( "LC_ALL"); |
2232 | char *dot = lang ? strchr(lang, '.') : (char *)NULL; | |
dccce9ea VZ |
2233 | if (!dot) |
2234 | { | |
b1ac3b56 | 2235 | lang = getenv( "LC_CTYPE" ); |
dccce9ea | 2236 | if ( lang ) |
b1ac3b56 | 2237 | dot = strchr(lang, '.' ); |
dccce9ea VZ |
2238 | } |
2239 | if (!dot) | |
2240 | { | |
b1ac3b56 | 2241 | lang = getenv( "LANG"); |
dccce9ea | 2242 | if ( lang ) |
b1ac3b56 | 2243 | dot = strchr(lang, '.'); |
dccce9ea VZ |
2244 | } |
2245 | ||
2246 | if ( dot ) | |
2247 | { | |
b1ac3b56 | 2248 | encname = wxString::FromAscii( dot+1 ); |
dccce9ea VZ |
2249 | } |
2250 | } | |
2251 | #endif // Win32/Unix | |
2252 | ||
2253 | return encname; | |
2254 | } | |
2255 | ||
2256 | /* static */ | |
2257 | wxFontEncoding wxLocale::GetSystemEncoding() | |
2258 | { | |
c67d6888 | 2259 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
dccce9ea VZ |
2260 | UINT codepage = ::GetACP(); |
2261 | ||
77ffb593 | 2262 | // wxWidgets only knows about CP1250-1257, 932, 936, 949, 950 |
dccce9ea VZ |
2263 | if ( codepage >= 1250 && codepage <= 1257 ) |
2264 | { | |
2265 | return (wxFontEncoding)(wxFONTENCODING_CP1250 + codepage - 1250); | |
2266 | } | |
c7821f94 VZ |
2267 | |
2268 | if ( codepage == 932 ) | |
2269 | { | |
2270 | return wxFONTENCODING_CP932; | |
2271 | } | |
2272 | ||
2273 | if ( codepage == 936 ) | |
2274 | { | |
2275 | return wxFONTENCODING_CP936; | |
2276 | } | |
2277 | ||
2278 | if ( codepage == 949 ) | |
2279 | { | |
2280 | return wxFONTENCODING_CP949; | |
2281 | } | |
2282 | ||
2283 | if ( codepage == 950 ) | |
2284 | { | |
2285 | return wxFONTENCODING_CP950; | |
2286 | } | |
ec79aded | 2287 | #elif defined(__WXMAC__) |
7beb59f3 | 2288 | TextEncoding encoding = 0 ; |
9e687455 | 2289 | #if TARGET_CARBON |
7beb59f3 | 2290 | encoding = CFStringGetSystemEncoding() ; |
9e687455 | 2291 | #else |
7beb59f3 | 2292 | UpgradeScriptInfoToTextEncoding ( smSystemScript , kTextLanguageDontCare , kTextRegionDontCare , NULL , &encoding ) ; |
9e687455 SC |
2293 | #endif |
2294 | return wxMacGetFontEncFromSystemEnc( encoding ) ; | |
1e6feb95 | 2295 | #elif defined(__UNIX_LIKE__) && wxUSE_FONTMAP |
dccce9ea VZ |
2296 | wxString encname = GetSystemEncodingName(); |
2297 | if ( !encname.empty() ) | |
2298 | { | |
142b3bc2 | 2299 | wxFontEncoding enc = wxFontMapper::Get()-> |
7beb59f3 | 2300 | CharsetToEncoding(encname, false /* not interactive */); |
9cf28550 | 2301 | |
2b5f62a0 VZ |
2302 | // on some modern Linux systems (RedHat 8) the default system locale |
2303 | // is UTF8 -- but it isn't supported by wxGTK in ANSI build at all so | |
2304 | // don't even try to use it in this case | |
2305 | #if !wxUSE_UNICODE | |
2306 | if ( enc == wxFONTENCODING_UTF8 ) | |
2307 | { | |
2308 | // the most similar supported encoding... | |
2309 | enc = wxFONTENCODING_ISO8859_1; | |
2310 | } | |
2311 | #endif // !wxUSE_UNICODE | |
2312 | ||
9cf28550 VZ |
2313 | // this should probably be considered as a bug in CharsetToEncoding(): |
2314 | // it shouldn't return wxFONTENCODING_DEFAULT at all - but it does it | |
2315 | // for US-ASCII charset | |
2316 | // | |
2317 | // we, OTOH, definitely shouldn't return it as it doesn't make sense at | |
2318 | // all (which encoding is it?) | |
2319 | if ( enc != wxFONTENCODING_DEFAULT ) | |
2320 | { | |
2321 | return enc; | |
2322 | } | |
2323 | //else: return wxFONTENCODING_SYSTEM below | |
dccce9ea VZ |
2324 | } |
2325 | #endif // Win32/Unix | |
2326 | ||
2327 | return wxFONTENCODING_SYSTEM; | |
2328 | } | |
2329 | ||
14f8fa9d VZ |
2330 | /* static */ |
2331 | void wxLocale::AddLanguage(const wxLanguageInfo& info) | |
d3f3e35f | 2332 | { |
41780009 VS |
2333 | CreateLanguagesDB(); |
2334 | ms_languagesDB->Add(info); | |
d3f3e35f VS |
2335 | } |
2336 | ||
14f8fa9d VZ |
2337 | /* static */ |
2338 | const wxLanguageInfo *wxLocale::GetLanguageInfo(int lang) | |
2339 | { | |
2340 | CreateLanguagesDB(); | |
2341 | ||
f0ab09cc VZ |
2342 | // calling GetLanguageInfo(wxLANGUAGE_DEFAULT) is a natural thing to do, so |
2343 | // make it work | |
2344 | if ( lang == wxLANGUAGE_DEFAULT ) | |
2345 | lang = GetSystemLanguage(); | |
2346 | ||
9d1e1be4 | 2347 | const size_t count = ms_languagesDB->GetCount(); |
14f8fa9d VZ |
2348 | for ( size_t i = 0; i < count; i++ ) |
2349 | { | |
2350 | if ( ms_languagesDB->Item(i).Language == lang ) | |
2351 | { | |
2352 | return &ms_languagesDB->Item(i); | |
2353 | } | |
2354 | } | |
2355 | ||
2356 | return NULL; | |
2357 | } | |
2358 | ||
4a6e4a46 VS |
2359 | /* static */ |
2360 | wxString wxLocale::GetLanguageName(int lang) | |
2361 | { | |
2362 | const wxLanguageInfo *info = GetLanguageInfo(lang); | |
2363 | if ( !info ) | |
2364 | return wxEmptyString; | |
2365 | else | |
2366 | return info->Description; | |
2367 | } | |
2368 | ||
9d1e1be4 VZ |
2369 | /* static */ |
2370 | const wxLanguageInfo *wxLocale::FindLanguageInfo(const wxString& locale) | |
2371 | { | |
2372 | CreateLanguagesDB(); | |
2373 | ||
2374 | const wxLanguageInfo *infoRet = NULL; | |
2375 | ||
2376 | const size_t count = ms_languagesDB->GetCount(); | |
2377 | for ( size_t i = 0; i < count; i++ ) | |
2378 | { | |
2379 | const wxLanguageInfo *info = &ms_languagesDB->Item(i); | |
2380 | ||
2381 | if ( wxStricmp(locale, info->CanonicalName) == 0 || | |
2382 | wxStricmp(locale, info->Description) == 0 ) | |
2383 | { | |
2384 | // exact match, stop searching | |
2385 | infoRet = info; | |
2386 | break; | |
2387 | } | |
2388 | ||
2389 | if ( wxStricmp(locale, info->CanonicalName.BeforeFirst(_T('_'))) == 0 ) | |
2390 | { | |
2391 | // a match -- but maybe we'll find an exact one later, so continue | |
2392 | // looking | |
2393 | // | |
2394 | // OTOH, maybe we had already found a language match and in this | |
2395 | // case don't overwrite it becauce the entry for the default | |
2396 | // country always appears first in ms_languagesDB | |
2397 | if ( !infoRet ) | |
2398 | infoRet = info; | |
2399 | } | |
2400 | } | |
2401 | ||
2402 | return infoRet; | |
2403 | } | |
2404 | ||
d3f3e35f VS |
2405 | wxString wxLocale::GetSysName() const |
2406 | { | |
1c193821 JS |
2407 | // FIXME |
2408 | #ifndef __WXWINCE__ | |
d3f3e35f | 2409 | return wxSetlocale(LC_ALL, NULL); |
1c193821 JS |
2410 | #else |
2411 | return wxEmptyString; | |
2412 | #endif | |
d3f3e35f VS |
2413 | } |
2414 | ||
c801d85f KB |
2415 | // clean up |
2416 | wxLocale::~wxLocale() | |
2417 | { | |
fd323a5e VZ |
2418 | // free memory |
2419 | wxMsgCatalog *pTmpCat; | |
2420 | while ( m_pMsgCat != NULL ) { | |
2421 | pTmpCat = m_pMsgCat; | |
2422 | m_pMsgCat = m_pMsgCat->m_pNext; | |
2423 | delete pTmpCat; | |
2424 | } | |
2425 | ||
2426 | // restore old locale | |
2427 | wxSetLocale(m_pOldLocale); | |
1c193821 JS |
2428 | // FIXME |
2429 | #ifndef __WXWINCE__ | |
e36e6f95 | 2430 | wxSetlocale(LC_ALL, m_pszOldLocale); |
1c193821 | 2431 | #endif |
10545ca4 | 2432 | free((wxChar *)m_pszOldLocale); // const_cast |
c801d85f KB |
2433 | } |
2434 | ||
2435 | // get the translation of given string in current locale | |
563d535e VS |
2436 | const wxChar *wxLocale::GetString(const wxChar *szOrigString, |
2437 | const wxChar *szDomain) const | |
849a28d0 VS |
2438 | { |
2439 | return GetString(szOrigString, szOrigString, size_t(-1), szDomain); | |
2440 | } | |
2441 | ||
2442 | const wxChar *wxLocale::GetString(const wxChar *szOrigString, | |
2443 | const wxChar *szOrigString2, | |
2444 | size_t n, | |
2445 | const wxChar *szDomain) const | |
c801d85f | 2446 | { |
563d535e | 2447 | if ( wxIsEmpty(szOrigString) ) |
849a28d0 | 2448 | return wxEmptyString; |
c801d85f | 2449 | |
563d535e VS |
2450 | const wxChar *pszTrans = NULL; |
2451 | wxMsgCatalog *pMsgCat; | |
7af89395 | 2452 | |
9e7ed2b0 | 2453 | if ( szDomain != NULL ) |
563d535e VS |
2454 | { |
2455 | pMsgCat = FindCatalog(szDomain); | |
2456 | ||
2457 | // does the catalog exist? | |
2458 | if ( pMsgCat != NULL ) | |
849a28d0 | 2459 | pszTrans = pMsgCat->GetString(szOrigString, n); |
563d535e | 2460 | } |
9e7ed2b0 | 2461 | else |
563d535e VS |
2462 | { |
2463 | // search in all domains | |
9e7ed2b0 | 2464 | for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) |
563d535e | 2465 | { |
849a28d0 | 2466 | pszTrans = pMsgCat->GetString(szOrigString, n); |
563d535e VS |
2467 | if ( pszTrans != NULL ) // take the first found |
2468 | break; | |
2469 | } | |
c801d85f KB |
2470 | } |
2471 | ||
9e7ed2b0 | 2472 | if ( pszTrans == NULL ) |
563d535e VS |
2473 | { |
2474 | #ifdef __WXDEBUG__ | |
9e7ed2b0 | 2475 | if ( !NoTransErr::Suppress() ) |
563d535e VS |
2476 | { |
2477 | NoTransErr noTransErr; | |
e90c1d2a | 2478 | |
563d535e VS |
2479 | if ( szDomain != NULL ) |
2480 | { | |
45e97ca0 | 2481 | wxLogTrace(_T("i18n"), |
3aefa658 VS |
2482 | _T("string '%s'[%lu] not found in domain '%s' for locale '%s'."), |
2483 | szOrigString, (unsigned long)n, | |
2484 | szDomain, m_strLocale.c_str()); | |
849a28d0 | 2485 | |
563d535e VS |
2486 | } |
2487 | else | |
2488 | { | |
45e97ca0 | 2489 | wxLogTrace(_T("i18n"), |
3aefa658 VS |
2490 | _T("string '%s'[%lu] not found in locale '%s'."), |
2491 | szOrigString, (unsigned long)n, m_strLocale.c_str()); | |
563d535e VS |
2492 | } |
2493 | } | |
2494 | #endif // __WXDEBUG__ | |
12419383 | 2495 | |
849a28d0 VS |
2496 | if (n == size_t(-1)) |
2497 | return szOrigString; | |
2498 | else | |
2499 | return n == 1 ? szOrigString : szOrigString2; | |
563d535e | 2500 | } |
12419383 | 2501 | |
563d535e | 2502 | return pszTrans; |
c801d85f KB |
2503 | } |
2504 | ||
c48908df VZ |
2505 | wxString wxLocale::GetHeaderValue( const wxChar* szHeader, |
2506 | const wxChar* szDomain ) const | |
2507 | { | |
e6bf9573 | 2508 | if ( wxIsEmpty(szHeader) ) |
c48908df VZ |
2509 | return wxEmptyString; |
2510 | ||
2511 | wxChar const * pszTrans = NULL; | |
2512 | wxMsgCatalog *pMsgCat; | |
2513 | ||
2514 | if ( szDomain != NULL ) | |
2515 | { | |
2516 | pMsgCat = FindCatalog(szDomain); | |
2517 | ||
2518 | // does the catalog exist? | |
2519 | if ( pMsgCat == NULL ) | |
2520 | return wxEmptyString; | |
2521 | ||
2522 | pszTrans = pMsgCat->GetString(wxT(""), (size_t)-1); | |
2523 | } | |
2524 | else | |
2525 | { | |
2526 | // search in all domains | |
2527 | for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) | |
2528 | { | |
2529 | pszTrans = pMsgCat->GetString(wxT(""), (size_t)-1); | |
2530 | if ( pszTrans != NULL ) // take the first found | |
2531 | break; | |
2532 | } | |
2533 | } | |
2534 | ||
2535 | if ( wxIsEmpty(pszTrans) ) | |
2536 | return wxEmptyString; | |
2537 | ||
e6bf9573 | 2538 | wxChar const * pszFound = wxStrstr(pszTrans, szHeader); |
c48908df VZ |
2539 | if ( pszFound == NULL ) |
2540 | return wxEmptyString; | |
7beb59f3 | 2541 | |
e6bf9573 | 2542 | pszFound += wxStrlen(szHeader) + 2 /* ': ' */; |
c48908df VZ |
2543 | |
2544 | // Every header is separated by \n | |
7beb59f3 | 2545 | |
c48908df VZ |
2546 | wxChar const * pszEndLine = wxStrchr(pszFound, wxT('\n')); |
2547 | if ( pszEndLine == NULL ) pszEndLine = pszFound + wxStrlen(pszFound); | |
2548 | ||
2549 | ||
2550 | // wxString( wxChar*, length); | |
2551 | wxString retVal( pszFound, pszEndLine - pszFound ); | |
2552 | ||
2553 | return retVal; | |
2554 | } | |
2555 | ||
2556 | ||
c801d85f | 2557 | // find catalog by name in a linked list, return NULL if !found |
e36e6f95 | 2558 | wxMsgCatalog *wxLocale::FindCatalog(const wxChar *szDomain) const |
c801d85f | 2559 | { |
563d535e VS |
2560 | // linear search in the linked list |
2561 | wxMsgCatalog *pMsgCat; | |
9e7ed2b0 | 2562 | for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) |
563d535e VS |
2563 | { |
2564 | if ( wxStricmp(pMsgCat->GetName(), szDomain) == 0 ) | |
2565 | return pMsgCat; | |
2566 | } | |
7af89395 | 2567 | |
563d535e | 2568 | return NULL; |
c801d85f KB |
2569 | } |
2570 | ||
2571 | // check if the given catalog is loaded | |
e36e6f95 | 2572 | bool wxLocale::IsLoaded(const wxChar *szDomain) const |
c801d85f KB |
2573 | { |
2574 | return FindCatalog(szDomain) != NULL; | |
2575 | } | |
2576 | ||
2577 | // add a catalog to our linked list | |
e36e6f95 | 2578 | bool wxLocale::AddCatalog(const wxChar *szDomain) |
d721baa9 VS |
2579 | { |
2580 | return AddCatalog(szDomain, wxLANGUAGE_ENGLISH, NULL); | |
2581 | } | |
2582 | ||
2583 | // add a catalog to our linked list | |
2584 | bool wxLocale::AddCatalog(const wxChar *szDomain, | |
2585 | wxLanguage msgIdLanguage, | |
2586 | const wxChar *msgIdCharset) | |
2587 | ||
c801d85f KB |
2588 | { |
2589 | wxMsgCatalog *pMsgCat = new wxMsgCatalog; | |
7af89395 | 2590 | |
d721baa9 | 2591 | if ( pMsgCat->Load(m_strShort, szDomain, msgIdCharset, m_bConvertEncoding) ) { |
c801d85f KB |
2592 | // add it to the head of the list so that in GetString it will |
2593 | // be searched before the catalogs added earlier | |
2594 | pMsgCat->m_pNext = m_pMsgCat; | |
2595 | m_pMsgCat = pMsgCat; | |
7af89395 | 2596 | |
d721baa9 | 2597 | return true; |
c801d85f KB |
2598 | } |
2599 | else { | |
2600 | // don't add it because it couldn't be loaded anyway | |
2601 | delete pMsgCat; | |
7af89395 | 2602 | |
d721baa9 VS |
2603 | // It is OK to not load catalog if the msgid language and m_language match, |
2604 | // in which case we can directly display the texts embedded in program's | |
2605 | // source code: | |
2606 | if (m_language == msgIdLanguage) | |
2607 | return true; | |
395a6701 | 2608 | |
d721baa9 VS |
2609 | // If there's no exact match, we may still get partial match where the |
2610 | // (basic) language is same, but the country differs. For example, it's | |
2611 | // permitted to use en_US strings from sources even if m_language is en_GB: | |
2612 | const wxLanguageInfo *msgIdLangInfo = GetLanguageInfo(msgIdLanguage); | |
2613 | if ( msgIdLangInfo && | |
2614 | msgIdLangInfo->CanonicalName.Mid(0, 2) == m_strShort.Mid(0, 2) ) | |
2615 | { | |
2616 | return true; | |
2617 | } | |
2618 | ||
2619 | return false; | |
c801d85f KB |
2620 | } |
2621 | } | |
2622 | ||
cfb20656 VZ |
2623 | // ---------------------------------------------------------------------------- |
2624 | // accessors for locale-dependent data | |
2625 | // ---------------------------------------------------------------------------- | |
2626 | ||
2627 | #ifdef __WXMSW__ | |
2628 | ||
2629 | /* static */ | |
3fe73755 | 2630 | wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory WXUNUSED(cat)) |
cfb20656 VZ |
2631 | { |
2632 | wxString str; | |
2633 | wxChar buffer[256]; | |
2634 | size_t count; | |
2635 | buffer[0] = wxT('\0'); | |
2636 | switch (index) | |
2637 | { | |
60d876f3 | 2638 | case wxLOCALE_DECIMAL_POINT: |
cfb20656 VZ |
2639 | count = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buffer, 256); |
2640 | if (!count) | |
1e8bd6b2 | 2641 | str << wxT("."); |
cfb20656 VZ |
2642 | else |
2643 | str << buffer; | |
2644 | break; | |
60d876f3 | 2645 | #if 0 |
cfb20656 VZ |
2646 | case wxSYS_LIST_SEPARATOR: |
2647 | count = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SLIST, buffer, 256); | |
2648 | if (!count) | |
1e8bd6b2 | 2649 | str << wxT(","); |
cfb20656 VZ |
2650 | else |
2651 | str << buffer; | |
2652 | break; | |
2653 | case wxSYS_LEADING_ZERO: // 0 means no leading zero, 1 means leading zero | |
2654 | count = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILZERO, buffer, 256); | |
2655 | if (!count) | |
1e8bd6b2 | 2656 | str << wxT("0"); |
cfb20656 VZ |
2657 | else |
2658 | str << buffer; | |
2659 | break; | |
60d876f3 | 2660 | #endif |
cfb20656 | 2661 | default: |
1e8bd6b2 | 2662 | wxFAIL_MSG(wxT("Unknown System String !")); |
cfb20656 VZ |
2663 | } |
2664 | return str; | |
2665 | } | |
2666 | ||
2667 | #else // !__WXMSW__ | |
2668 | ||
2669 | /* static */ | |
60d876f3 | 2670 | wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory cat) |
cfb20656 | 2671 | { |
60d876f3 SN |
2672 | struct lconv *locale_info = localeconv(); |
2673 | switch (cat) | |
2674 | { | |
2675 | case wxLOCALE_CAT_NUMBER: | |
2676 | switch (index) | |
2677 | { | |
2678 | case wxLOCALE_THOUSANDS_SEP: | |
3fe73755 SN |
2679 | return wxString(locale_info->thousands_sep, |
2680 | *wxConvCurrent); | |
60d876f3 | 2681 | case wxLOCALE_DECIMAL_POINT: |
3fe73755 SN |
2682 | return wxString(locale_info->decimal_point, |
2683 | *wxConvCurrent); | |
60d876f3 SN |
2684 | default: |
2685 | return wxEmptyString; | |
2686 | } | |
2687 | case wxLOCALE_CAT_MONEY: | |
2688 | switch (index) | |
2689 | { | |
2690 | case wxLOCALE_THOUSANDS_SEP: | |
3fe73755 SN |
2691 | return wxString(locale_info->mon_thousands_sep, |
2692 | *wxConvCurrent); | |
60d876f3 | 2693 | case wxLOCALE_DECIMAL_POINT: |
3fe73755 SN |
2694 | return wxString(locale_info->mon_decimal_point, |
2695 | *wxConvCurrent); | |
60d876f3 SN |
2696 | default: |
2697 | return wxEmptyString; | |
2698 | } | |
2699 | default: | |
2700 | return wxEmptyString; | |
2701 | } | |
b7b97e77 | 2702 | } |
cfb20656 VZ |
2703 | |
2704 | #endif // __WXMSW__/!__WXMSW__ | |
2705 | ||
c801d85f KB |
2706 | // ---------------------------------------------------------------------------- |
2707 | // global functions and variables | |
2708 | // ---------------------------------------------------------------------------- | |
2709 | ||
c801d85f KB |
2710 | // retrieve/change current locale |
2711 | // ------------------------------ | |
2712 | ||
2713 | // the current locale object | |
84c18814 | 2714 | static wxLocale *g_pLocale = NULL; |
c801d85f | 2715 | |
1678ad78 GL |
2716 | wxLocale *wxGetLocale() |
2717 | { | |
7af89395 | 2718 | return g_pLocale; |
1678ad78 GL |
2719 | } |
2720 | ||
c801d85f KB |
2721 | wxLocale *wxSetLocale(wxLocale *pLocale) |
2722 | { | |
7af89395 VZ |
2723 | wxLocale *pOld = g_pLocale; |
2724 | g_pLocale = pLocale; | |
2725 | return pOld; | |
c801d85f | 2726 | } |
d427503c | 2727 | |
41780009 VS |
2728 | |
2729 | ||
2730 | // ---------------------------------------------------------------------------- | |
2731 | // wxLocale module (for lazy destruction of languagesDB) | |
2732 | // ---------------------------------------------------------------------------- | |
2733 | ||
2734 | class wxLocaleModule: public wxModule | |
2735 | { | |
2736 | DECLARE_DYNAMIC_CLASS(wxLocaleModule) | |
2737 | public: | |
2738 | wxLocaleModule() {} | |
7beb59f3 | 2739 | bool OnInit() { return true; } |
41780009 VS |
2740 | void OnExit() { wxLocale::DestroyLanguagesDB(); } |
2741 | }; | |
2742 | ||
2743 | IMPLEMENT_DYNAMIC_CLASS(wxLocaleModule, wxModule) | |
2744 | ||
2745 | ||
2746 | ||
d3f3e35f VS |
2747 | // ---------------------------------------------------------------------------- |
2748 | // default languages table & initialization | |
2749 | // ---------------------------------------------------------------------------- | |
2750 | ||
865a1730 | 2751 | |
41780009 VS |
2752 | |
2753 | // --- --- --- generated code begins here --- --- --- | |
2754 | ||
d3f3e35f VS |
2755 | // This table is generated by misc/languages/genlang.py |
2756 | // When making changes, please put them into misc/languages/langtabl.txt | |
2757 | ||
04ef50df | 2758 | #if !defined(__WIN32__) || defined(__WXMICROWIN__) |
63986ba6 VS |
2759 | |
2760 | #define SETWINLANG(info,lang,sublang) | |
2761 | ||
2762 | #else | |
2763 | ||
d3f3e35f VS |
2764 | #define SETWINLANG(info,lang,sublang) \ |
2765 | info.WinLang = lang, info.WinSublang = sublang; | |
63986ba6 VS |
2766 | |
2767 | #ifndef LANG_AFRIKAANS | |
2768 | #define LANG_AFRIKAANS (0) | |
2769 | #endif | |
2770 | #ifndef LANG_ALBANIAN | |
2771 | #define LANG_ALBANIAN (0) | |
2772 | #endif | |
2773 | #ifndef LANG_ARABIC | |
2774 | #define LANG_ARABIC (0) | |
2775 | #endif | |
2776 | #ifndef LANG_ARMENIAN | |
2777 | #define LANG_ARMENIAN (0) | |
2778 | #endif | |
2779 | #ifndef LANG_ASSAMESE | |
2780 | #define LANG_ASSAMESE (0) | |
2781 | #endif | |
2782 | #ifndef LANG_AZERI | |
2783 | #define LANG_AZERI (0) | |
2784 | #endif | |
2785 | #ifndef LANG_BASQUE | |
2786 | #define LANG_BASQUE (0) | |
2787 | #endif | |
2788 | #ifndef LANG_BELARUSIAN | |
2789 | #define LANG_BELARUSIAN (0) | |
2790 | #endif | |
2791 | #ifndef LANG_BENGALI | |
2792 | #define LANG_BENGALI (0) | |
2793 | #endif | |
2794 | #ifndef LANG_BULGARIAN | |
2795 | #define LANG_BULGARIAN (0) | |
2796 | #endif | |
2797 | #ifndef LANG_CATALAN | |
2798 | #define LANG_CATALAN (0) | |
2799 | #endif | |
2800 | #ifndef LANG_CHINESE | |
2801 | #define LANG_CHINESE (0) | |
2802 | #endif | |
2803 | #ifndef LANG_CROATIAN | |
2804 | #define LANG_CROATIAN (0) | |
2805 | #endif | |
2806 | #ifndef LANG_CZECH | |
2807 | #define LANG_CZECH (0) | |
2808 | #endif | |
2809 | #ifndef LANG_DANISH | |
2810 | #define LANG_DANISH (0) | |
2811 | #endif | |
2812 | #ifndef LANG_DUTCH | |
2813 | #define LANG_DUTCH (0) | |
2814 | #endif | |
2815 | #ifndef LANG_ENGLISH | |
2816 | #define LANG_ENGLISH (0) | |
2817 | #endif | |
2818 | #ifndef LANG_ESTONIAN | |
2819 | #define LANG_ESTONIAN (0) | |
2820 | #endif | |
2821 | #ifndef LANG_FAEROESE | |
2822 | #define LANG_FAEROESE (0) | |
2823 | #endif | |
2824 | #ifndef LANG_FARSI | |
2825 | #define LANG_FARSI (0) | |
2826 | #endif | |
2827 | #ifndef LANG_FINNISH | |
2828 | #define LANG_FINNISH (0) | |
2829 | #endif | |
2830 | #ifndef LANG_FRENCH | |
2831 | #define LANG_FRENCH (0) | |
2832 | #endif | |
2833 | #ifndef LANG_GEORGIAN | |
2834 | #define LANG_GEORGIAN (0) | |
2835 | #endif | |
2836 | #ifndef LANG_GERMAN | |
2837 | #define LANG_GERMAN (0) | |
2838 | #endif | |
2839 | #ifndef LANG_GREEK | |
2840 | #define LANG_GREEK (0) | |
2841 | #endif | |
2842 | #ifndef LANG_GUJARATI | |
2843 | #define LANG_GUJARATI (0) | |
2844 | #endif | |
2845 | #ifndef LANG_HEBREW | |
2846 | #define LANG_HEBREW (0) | |
2847 | #endif | |
2848 | #ifndef LANG_HINDI | |
2849 | #define LANG_HINDI (0) | |
2850 | #endif | |
2851 | #ifndef LANG_HUNGARIAN | |
2852 | #define LANG_HUNGARIAN (0) | |
2853 | #endif | |
2854 | #ifndef LANG_ICELANDIC | |
2855 | #define LANG_ICELANDIC (0) | |
2856 | #endif | |
2857 | #ifndef LANG_INDONESIAN | |
2858 | #define LANG_INDONESIAN (0) | |
2859 | #endif | |
2860 | #ifndef LANG_ITALIAN | |
2861 | #define LANG_ITALIAN (0) | |
2862 | #endif | |
2863 | #ifndef LANG_JAPANESE | |
2864 | #define LANG_JAPANESE (0) | |
2865 | #endif | |
2866 | #ifndef LANG_KANNADA | |
2867 | #define LANG_KANNADA (0) | |
2868 | #endif | |
2869 | #ifndef LANG_KASHMIRI | |
2870 | #define LANG_KASHMIRI (0) | |
2871 | #endif | |
2872 | #ifndef LANG_KAZAK | |
2873 | #define LANG_KAZAK (0) | |
2874 | #endif | |
2875 | #ifndef LANG_KONKANI | |
2876 | #define LANG_KONKANI (0) | |
2877 | #endif | |
2878 | #ifndef LANG_KOREAN | |
2879 | #define LANG_KOREAN (0) | |
2880 | #endif | |
2881 | #ifndef LANG_LATVIAN | |
2882 | #define LANG_LATVIAN (0) | |
2883 | #endif | |
2884 | #ifndef LANG_LITHUANIAN | |
2885 | #define LANG_LITHUANIAN (0) | |
2886 | #endif | |
2887 | #ifndef LANG_MACEDONIAN | |
2888 | #define LANG_MACEDONIAN (0) | |
2889 | #endif | |
2890 | #ifndef LANG_MALAY | |
2891 | #define LANG_MALAY (0) | |
2892 | #endif | |
2893 | #ifndef LANG_MALAYALAM | |
2894 | #define LANG_MALAYALAM (0) | |
2895 | #endif | |
2896 | #ifndef LANG_MANIPURI | |
2897 | #define LANG_MANIPURI (0) | |
2898 | #endif | |
2899 | #ifndef LANG_MARATHI | |
2900 | #define LANG_MARATHI (0) | |
2901 | #endif | |
2902 | #ifndef LANG_NEPALI | |
2903 | #define LANG_NEPALI (0) | |
2904 | #endif | |
2905 | #ifndef LANG_NORWEGIAN | |
2906 | #define LANG_NORWEGIAN (0) | |
2907 | #endif | |
2908 | #ifndef LANG_ORIYA | |
2909 | #define LANG_ORIYA (0) | |
2910 | #endif | |
2911 | #ifndef LANG_POLISH | |
2912 | #define LANG_POLISH (0) | |
2913 | #endif | |
2914 | #ifndef LANG_PORTUGUESE | |
2915 | #define LANG_PORTUGUESE (0) | |
2916 | #endif | |
2917 | #ifndef LANG_PUNJABI | |
2918 | #define LANG_PUNJABI (0) | |
2919 | #endif | |
2920 | #ifndef LANG_ROMANIAN | |
2921 | #define LANG_ROMANIAN (0) | |
2922 | #endif | |
2923 | #ifndef LANG_RUSSIAN | |
2924 | #define LANG_RUSSIAN (0) | |
2925 | #endif | |
2926 | #ifndef LANG_SANSKRIT | |
2927 | #define LANG_SANSKRIT (0) | |
2928 | #endif | |
2929 | #ifndef LANG_SERBIAN | |
2930 | #define LANG_SERBIAN (0) | |
2931 | #endif | |
2932 | #ifndef LANG_SINDHI | |
2933 | #define LANG_SINDHI (0) | |
2934 | #endif | |
2935 | #ifndef LANG_SLOVAK | |
2936 | #define LANG_SLOVAK (0) | |
2937 | #endif | |
2938 | #ifndef LANG_SLOVENIAN | |
2939 | #define LANG_SLOVENIAN (0) | |
2940 | #endif | |
2941 | #ifndef LANG_SPANISH | |
2942 | #define LANG_SPANISH (0) | |
2943 | #endif | |
2944 | #ifndef LANG_SWAHILI | |
2945 | #define LANG_SWAHILI (0) | |
2946 | #endif | |
2947 | #ifndef LANG_SWEDISH | |
2948 | #define LANG_SWEDISH (0) | |
2949 | #endif | |
2950 | #ifndef LANG_TAMIL | |
2951 | #define LANG_TAMIL (0) | |
2952 | #endif | |
2953 | #ifndef LANG_TATAR | |
2954 | #define LANG_TATAR (0) | |
2955 | #endif | |
2956 | #ifndef LANG_TELUGU | |
2957 | #define LANG_TELUGU (0) | |
2958 | #endif | |
2959 | #ifndef LANG_THAI | |
2960 | #define LANG_THAI (0) | |
2961 | #endif | |
2962 | #ifndef LANG_TURKISH | |
2963 | #define LANG_TURKISH (0) | |
2964 | #endif | |
2965 | #ifndef LANG_UKRAINIAN | |
2966 | #define LANG_UKRAINIAN (0) | |
2967 | #endif | |
2968 | #ifndef LANG_URDU | |
2969 | #define LANG_URDU (0) | |
2970 | #endif | |
2971 | #ifndef LANG_UZBEK | |
2972 | #define LANG_UZBEK (0) | |
2973 | #endif | |
2974 | #ifndef LANG_VIETNAMESE | |
2975 | #define LANG_VIETNAMESE (0) | |
2976 | #endif | |
2977 | #ifndef SUBLANG_ARABIC_ALGERIA | |
2978 | #define SUBLANG_ARABIC_ALGERIA SUBLANG_DEFAULT | |
2979 | #endif | |
2980 | #ifndef SUBLANG_ARABIC_BAHRAIN | |
2981 | #define SUBLANG_ARABIC_BAHRAIN SUBLANG_DEFAULT | |
2982 | #endif | |
2983 | #ifndef SUBLANG_ARABIC_EGYPT | |
2984 | #define SUBLANG_ARABIC_EGYPT SUBLANG_DEFAULT | |
2985 | #endif | |
2986 | #ifndef SUBLANG_ARABIC_IRAQ | |
2987 | #define SUBLANG_ARABIC_IRAQ SUBLANG_DEFAULT | |
2988 | #endif | |
2989 | #ifndef SUBLANG_ARABIC_JORDAN | |
2990 | #define SUBLANG_ARABIC_JORDAN SUBLANG_DEFAULT | |
2991 | #endif | |
2992 | #ifndef SUBLANG_ARABIC_KUWAIT | |
2993 | #define SUBLANG_ARABIC_KUWAIT SUBLANG_DEFAULT | |
2994 | #endif | |
2995 | #ifndef SUBLANG_ARABIC_LEBANON | |
2996 | #define SUBLANG_ARABIC_LEBANON SUBLANG_DEFAULT | |
2997 | #endif | |
2998 | #ifndef SUBLANG_ARABIC_LIBYA | |
2999 | #define SUBLANG_ARABIC_LIBYA SUBLANG_DEFAULT | |
3000 | #endif | |
3001 | #ifndef SUBLANG_ARABIC_MOROCCO | |
3002 | #define SUBLANG_ARABIC_MOROCCO SUBLANG_DEFAULT | |
3003 | #endif | |
3004 | #ifndef SUBLANG_ARABIC_OMAN | |
3005 | #define SUBLANG_ARABIC_OMAN SUBLANG_DEFAULT | |
3006 | #endif | |
3007 | #ifndef SUBLANG_ARABIC_QATAR | |
3008 | #define SUBLANG_ARABIC_QATAR SUBLANG_DEFAULT | |
3009 | #endif | |
3010 | #ifndef SUBLANG_ARABIC_SAUDI_ARABIA | |
3011 | #define SUBLANG_ARABIC_SAUDI_ARABIA SUBLANG_DEFAULT | |
3012 | #endif | |
3013 | #ifndef SUBLANG_ARABIC_SYRIA | |
3014 | #define SUBLANG_ARABIC_SYRIA SUBLANG_DEFAULT | |
3015 | #endif | |
3016 | #ifndef SUBLANG_ARABIC_TUNISIA | |
3017 | #define SUBLANG_ARABIC_TUNISIA SUBLANG_DEFAULT | |
3018 | #endif | |
3019 | #ifndef SUBLANG_ARABIC_UAE | |
3020 | #define SUBLANG_ARABIC_UAE SUBLANG_DEFAULT | |
3021 | #endif | |
3022 | #ifndef SUBLANG_ARABIC_YEMEN | |
3023 | #define SUBLANG_ARABIC_YEMEN SUBLANG_DEFAULT | |
3024 | #endif | |
3025 | #ifndef SUBLANG_AZERI_CYRILLIC | |
3026 | #define SUBLANG_AZERI_CYRILLIC SUBLANG_DEFAULT | |
3027 | #endif | |
3028 | #ifndef SUBLANG_AZERI_LATIN | |
3029 | #define SUBLANG_AZERI_LATIN SUBLANG_DEFAULT | |
3030 | #endif | |
3031 | #ifndef SUBLANG_CHINESE_SIMPLIFIED | |
3032 | #define SUBLANG_CHINESE_SIMPLIFIED SUBLANG_DEFAULT | |
3033 | #endif | |
3034 | #ifndef SUBLANG_CHINESE_TRADITIONAL | |
3035 | #define SUBLANG_CHINESE_TRADITIONAL SUBLANG_DEFAULT | |
3036 | #endif | |
3037 | #ifndef SUBLANG_CHINESE_HONGKONG | |
3038 | #define SUBLANG_CHINESE_HONGKONG SUBLANG_DEFAULT | |
3039 | #endif | |
3040 | #ifndef SUBLANG_CHINESE_MACAU | |
3041 | #define SUBLANG_CHINESE_MACAU SUBLANG_DEFAULT | |
3042 | #endif | |
3043 | #ifndef SUBLANG_CHINESE_SINGAPORE | |
3044 | #define SUBLANG_CHINESE_SINGAPORE SUBLANG_DEFAULT | |
3045 | #endif | |
3046 | #ifndef SUBLANG_DUTCH | |
3047 | #define SUBLANG_DUTCH SUBLANG_DEFAULT | |
3048 | #endif | |
3049 | #ifndef SUBLANG_DUTCH_BELGIAN | |
3050 | #define SUBLANG_DUTCH_BELGIAN SUBLANG_DEFAULT | |
3051 | #endif | |
3052 | #ifndef SUBLANG_ENGLISH_UK | |
3053 | #define SUBLANG_ENGLISH_UK SUBLANG_DEFAULT | |
3054 | #endif | |
3055 | #ifndef SUBLANG_ENGLISH_US | |
3056 | #define SUBLANG_ENGLISH_US SUBLANG_DEFAULT | |
3057 | #endif | |
3058 | #ifndef SUBLANG_ENGLISH_AUS | |
3059 | #define SUBLANG_ENGLISH_AUS SUBLANG_DEFAULT | |
3060 | #endif | |
3061 | #ifndef SUBLANG_ENGLISH_BELIZE | |
3062 | #define SUBLANG_ENGLISH_BELIZE SUBLANG_DEFAULT | |
3063 | #endif | |
3064 | #ifndef SUBLANG_ENGLISH_CAN | |
3065 | #define SUBLANG_ENGLISH_CAN SUBLANG_DEFAULT | |
3066 | #endif | |
3067 | #ifndef SUBLANG_ENGLISH_CARIBBEAN | |
3068 | #define SUBLANG_ENGLISH_CARIBBEAN SUBLANG_DEFAULT | |
3069 | #endif | |
3070 | #ifndef SUBLANG_ENGLISH_EIRE | |
3071 | #define SUBLANG_ENGLISH_EIRE SUBLANG_DEFAULT | |
3072 | #endif | |
3073 | #ifndef SUBLANG_ENGLISH_JAMAICA | |
3074 | #define SUBLANG_ENGLISH_JAMAICA SUBLANG_DEFAULT | |
3075 | #endif | |
3076 | #ifndef SUBLANG_ENGLISH_NZ | |
3077 | #define SUBLANG_ENGLISH_NZ SUBLANG_DEFAULT | |
3078 | #endif | |
3079 | #ifndef SUBLANG_ENGLISH_PHILIPPINES | |
3080 | #define SUBLANG_ENGLISH_PHILIPPINES SUBLANG_DEFAULT | |
3081 | #endif | |
3082 | #ifndef SUBLANG_ENGLISH_SOUTH_AFRICA | |
3083 | #define SUBLANG_ENGLISH_SOUTH_AFRICA SUBLANG_DEFAULT | |
3084 | #endif | |
3085 | #ifndef SUBLANG_ENGLISH_TRINIDAD | |
3086 | #define SUBLANG_ENGLISH_TRINIDAD SUBLANG_DEFAULT | |
3087 | #endif | |
3088 | #ifndef SUBLANG_ENGLISH_ZIMBABWE | |
3089 | #define SUBLANG_ENGLISH_ZIMBABWE SUBLANG_DEFAULT | |
3090 | #endif | |
3091 | #ifndef SUBLANG_FRENCH | |
3092 | #define SUBLANG_FRENCH SUBLANG_DEFAULT | |
3093 | #endif | |
3094 | #ifndef SUBLANG_FRENCH_BELGIAN | |
3095 | #define SUBLANG_FRENCH_BELGIAN SUBLANG_DEFAULT | |
3096 | #endif | |
3097 | #ifndef SUBLANG_FRENCH_CANADIAN | |
3098 | #define SUBLANG_FRENCH_CANADIAN SUBLANG_DEFAULT | |
3099 | #endif | |
3100 | #ifndef SUBLANG_FRENCH_LUXEMBOURG | |
3101 | #define SUBLANG_FRENCH_LUXEMBOURG SUBLANG_DEFAULT | |
3102 | #endif | |
3103 | #ifndef SUBLANG_FRENCH_MONACO | |
3104 | #define SUBLANG_FRENCH_MONACO SUBLANG_DEFAULT | |
3105 | #endif | |
3106 | #ifndef SUBLANG_FRENCH_SWISS | |
3107 | #define SUBLANG_FRENCH_SWISS SUBLANG_DEFAULT | |
3108 | #endif | |
3109 | #ifndef SUBLANG_GERMAN | |
3110 | #define SUBLANG_GERMAN SUBLANG_DEFAULT | |
3111 | #endif | |
3112 | #ifndef SUBLANG_GERMAN_AUSTRIAN | |
3113 | #define SUBLANG_GERMAN_AUSTRIAN SUBLANG_DEFAULT | |
3114 | #endif | |
3115 | #ifndef SUBLANG_GERMAN_LIECHTENSTEIN | |
3116 | #define SUBLANG_GERMAN_LIECHTENSTEIN SUBLANG_DEFAULT | |
3117 | #endif | |
3118 | #ifndef SUBLANG_GERMAN_LUXEMBOURG | |
3119 | #define SUBLANG_GERMAN_LUXEMBOURG SUBLANG_DEFAULT | |
3120 | #endif | |
3121 | #ifndef SUBLANG_GERMAN_SWISS | |
3122 | #define SUBLANG_GERMAN_SWISS SUBLANG_DEFAULT | |
3123 | #endif | |
3124 | #ifndef SUBLANG_ITALIAN | |
3125 | #define SUBLANG_ITALIAN SUBLANG_DEFAULT | |
3126 | #endif | |
3127 | #ifndef SUBLANG_ITALIAN_SWISS | |
3128 | #define SUBLANG_ITALIAN_SWISS SUBLANG_DEFAULT | |
3129 | #endif | |
3130 | #ifndef SUBLANG_KASHMIRI_INDIA | |
3131 | #define SUBLANG_KASHMIRI_INDIA SUBLANG_DEFAULT | |
3132 | #endif | |
3133 | #ifndef SUBLANG_KOREAN | |
3134 | #define SUBLANG_KOREAN SUBLANG_DEFAULT | |
3135 | #endif | |
3136 | #ifndef SUBLANG_LITHUANIAN | |
3137 | #define SUBLANG_LITHUANIAN SUBLANG_DEFAULT | |
3138 | #endif | |
3139 | #ifndef SUBLANG_MALAY_BRUNEI_DARUSSALAM | |
3140 | #define SUBLANG_MALAY_BRUNEI_DARUSSALAM SUBLANG_DEFAULT | |
3141 | #endif | |
3142 | #ifndef SUBLANG_MALAY_MALAYSIA | |
3143 | #define SUBLANG_MALAY_MALAYSIA SUBLANG_DEFAULT | |
3144 | #endif | |
3145 | #ifndef SUBLANG_NEPALI_INDIA | |
3146 | #define SUBLANG_NEPALI_INDIA SUBLANG_DEFAULT | |
3147 | #endif | |
3148 | #ifndef SUBLANG_NORWEGIAN_BOKMAL | |
3149 | #define SUBLANG_NORWEGIAN_BOKMAL SUBLANG_DEFAULT | |
3150 | #endif | |
3151 | #ifndef SUBLANG_NORWEGIAN_NYNORSK | |
3152 | #define SUBLANG_NORWEGIAN_NYNORSK SUBLANG_DEFAULT | |
3153 | #endif | |
3154 | #ifndef SUBLANG_PORTUGUESE | |
3155 | #define SUBLANG_PORTUGUESE SUBLANG_DEFAULT | |
3156 | #endif | |
3157 | #ifndef SUBLANG_PORTUGUESE_BRAZILIAN | |
3158 | #define SUBLANG_PORTUGUESE_BRAZILIAN SUBLANG_DEFAULT | |
3159 | #endif | |
3160 | #ifndef SUBLANG_SERBIAN_CYRILLIC | |
3161 | #define SUBLANG_SERBIAN_CYRILLIC SUBLANG_DEFAULT | |
3162 | #endif | |
3163 | #ifndef SUBLANG_SERBIAN_LATIN | |
3164 | #define SUBLANG_SERBIAN_LATIN SUBLANG_DEFAULT | |
3165 | #endif | |
3166 | #ifndef SUBLANG_SPANISH | |
3167 | #define SUBLANG_SPANISH SUBLANG_DEFAULT | |
3168 | #endif | |
3169 | #ifndef SUBLANG_SPANISH_ARGENTINA | |
3170 | #define SUBLANG_SPANISH_ARGENTINA SUBLANG_DEFAULT | |
3171 | #endif | |
3172 | #ifndef SUBLANG_SPANISH_BOLIVIA | |
3173 | #define SUBLANG_SPANISH_BOLIVIA SUBLANG_DEFAULT | |
3174 | #endif | |
3175 | #ifndef SUBLANG_SPANISH_CHILE | |
3176 | #define SUBLANG_SPANISH_CHILE SUBLANG_DEFAULT | |
3177 | #endif | |
3178 | #ifndef SUBLANG_SPANISH_COLOMBIA | |
3179 | #define SUBLANG_SPANISH_COLOMBIA SUBLANG_DEFAULT | |
3180 | #endif | |
3181 | #ifndef SUBLANG_SPANISH_COSTA_RICA | |
3182 | #define SUBLANG_SPANISH_COSTA_RICA SUBLANG_DEFAULT | |
3183 | #endif | |
3184 | #ifndef SUBLANG_SPANISH_DOMINICAN_REPUBLIC | |
3185 | #define SUBLANG_SPANISH_DOMINICAN_REPUBLIC SUBLANG_DEFAULT | |
3186 | #endif | |
3187 | #ifndef SUBLANG_SPANISH_ECUADOR | |
3188 | #define SUBLANG_SPANISH_ECUADOR SUBLANG_DEFAULT | |
3189 | #endif | |
3190 | #ifndef SUBLANG_SPANISH_EL_SALVADOR | |
3191 | #define SUBLANG_SPANISH_EL_SALVADOR SUBLANG_DEFAULT | |
3192 | #endif | |
3193 | #ifndef SUBLANG_SPANISH_GUATEMALA | |
3194 | #define SUBLANG_SPANISH_GUATEMALA SUBLANG_DEFAULT | |
3195 | #endif | |
3196 | #ifndef SUBLANG_SPANISH_HONDURAS | |
3197 | #define SUBLANG_SPANISH_HONDURAS SUBLANG_DEFAULT | |
3198 | #endif | |
3199 | #ifndef SUBLANG_SPANISH_MEXICAN | |
3200 | #define SUBLANG_SPANISH_MEXICAN SUBLANG_DEFAULT | |
3201 | #endif | |
3202 | #ifndef SUBLANG_SPANISH_MODERN | |
3203 | #define SUBLANG_SPANISH_MODERN SUBLANG_DEFAULT | |
3204 | #endif | |
3205 | #ifndef SUBLANG_SPANISH_NICARAGUA | |
3206 | #define SUBLANG_SPANISH_NICARAGUA SUBLANG_DEFAULT | |
3207 | #endif | |
3208 | #ifndef SUBLANG_SPANISH_PANAMA | |
3209 | #define SUBLANG_SPANISH_PANAMA SUBLANG_DEFAULT | |
3210 | #endif | |
3211 | #ifndef SUBLANG_SPANISH_PARAGUAY | |
3212 | #define SUBLANG_SPANISH_PARAGUAY SUBLANG_DEFAULT | |
3213 | #endif | |
3214 | #ifndef SUBLANG_SPANISH_PERU | |
3215 | #define SUBLANG_SPANISH_PERU SUBLANG_DEFAULT | |
3216 | #endif | |
3217 | #ifndef SUBLANG_SPANISH_PUERTO_RICO | |
3218 | #define SUBLANG_SPANISH_PUERTO_RICO SUBLANG_DEFAULT | |
3219 | #endif | |
3220 | #ifndef SUBLANG_SPANISH_URUGUAY | |
3221 | #define SUBLANG_SPANISH_URUGUAY SUBLANG_DEFAULT | |
3222 | #endif | |
3223 | #ifndef SUBLANG_SPANISH_VENEZUELA | |
3224 | #define SUBLANG_SPANISH_VENEZUELA SUBLANG_DEFAULT | |
3225 | #endif | |
3226 | #ifndef SUBLANG_SWEDISH | |
3227 | #define SUBLANG_SWEDISH SUBLANG_DEFAULT | |
3228 | #endif | |
3229 | #ifndef SUBLANG_SWEDISH_FINLAND | |
3230 | #define SUBLANG_SWEDISH_FINLAND SUBLANG_DEFAULT | |
3231 | #endif | |
3232 | #ifndef SUBLANG_URDU_INDIA | |
3233 | #define SUBLANG_URDU_INDIA SUBLANG_DEFAULT | |
3234 | #endif | |
3235 | #ifndef SUBLANG_URDU_PAKISTAN | |
3236 | #define SUBLANG_URDU_PAKISTAN SUBLANG_DEFAULT | |
3237 | #endif | |
3238 | #ifndef SUBLANG_UZBEK_CYRILLIC | |
3239 | #define SUBLANG_UZBEK_CYRILLIC SUBLANG_DEFAULT | |
3240 | #endif | |
3241 | #ifndef SUBLANG_UZBEK_LATIN | |
3242 | #define SUBLANG_UZBEK_LATIN SUBLANG_DEFAULT | |
d3f3e35f VS |
3243 | #endif |
3244 | ||
63986ba6 VS |
3245 | |
3246 | #endif // __WIN32__ | |
3247 | ||
d3f3e35f VS |
3248 | #define LNG(wxlang, canonical, winlang, winsublang, desc) \ |
3249 | info.Language = wxlang; \ | |
3250 | info.CanonicalName = wxT(canonical); \ | |
2b5f62a0 | 3251 | info.Description = wxT(desc); \ |
d3f3e35f VS |
3252 | SETWINLANG(info, winlang, winsublang) \ |
3253 | AddLanguage(info); | |
3254 | ||
3255 | void wxLocale::InitLanguagesDB() | |
3256 | { | |
3257 | wxLanguageInfo info; | |
3258 | wxStringTokenizer tkn; | |
63986ba6 | 3259 | |
14f8fa9d | 3260 | LNG(wxLANGUAGE_ABKHAZIAN, "ab" , 0 , 0 , "Abkhazian") |
d3f3e35f VS |
3261 | LNG(wxLANGUAGE_AFAR, "aa" , 0 , 0 , "Afar") |
3262 | LNG(wxLANGUAGE_AFRIKAANS, "af_ZA", LANG_AFRIKAANS , SUBLANG_DEFAULT , "Afrikaans") | |
3263 | LNG(wxLANGUAGE_ALBANIAN, "sq_AL", LANG_ALBANIAN , SUBLANG_DEFAULT , "Albanian") | |
3264 | LNG(wxLANGUAGE_AMHARIC, "am" , 0 , 0 , "Amharic") | |
3265 | LNG(wxLANGUAGE_ARABIC, "ar" , LANG_ARABIC , SUBLANG_DEFAULT , "Arabic") | |
3266 | LNG(wxLANGUAGE_ARABIC_ALGERIA, "ar_DZ", LANG_ARABIC , SUBLANG_ARABIC_ALGERIA , "Arabic (Algeria)") | |
3267 | LNG(wxLANGUAGE_ARABIC_BAHRAIN, "ar_BH", LANG_ARABIC , SUBLANG_ARABIC_BAHRAIN , "Arabic (Bahrain)") | |
3268 | LNG(wxLANGUAGE_ARABIC_EGYPT, "ar_EG", LANG_ARABIC , SUBLANG_ARABIC_EGYPT , "Arabic (Egypt)") | |
3269 | LNG(wxLANGUAGE_ARABIC_IRAQ, "ar_IQ", LANG_ARABIC , SUBLANG_ARABIC_IRAQ , "Arabic (Iraq)") | |
3270 | LNG(wxLANGUAGE_ARABIC_JORDAN, "ar_JO", LANG_ARABIC , SUBLANG_ARABIC_JORDAN , "Arabic (Jordan)") | |
3271 | LNG(wxLANGUAGE_ARABIC_KUWAIT, "ar_KW", LANG_ARABIC , SUBLANG_ARABIC_KUWAIT , "Arabic (Kuwait)") | |
3272 | LNG(wxLANGUAGE_ARABIC_LEBANON, "ar_LB", LANG_ARABIC , SUBLANG_ARABIC_LEBANON , "Arabic (Lebanon)") | |
3273 | LNG(wxLANGUAGE_ARABIC_LIBYA, "ar_LY", LANG_ARABIC , SUBLANG_ARABIC_LIBYA , "Arabic (Libya)") | |
3274 | LNG(wxLANGUAGE_ARABIC_MOROCCO, "ar_MA", LANG_ARABIC , SUBLANG_ARABIC_MOROCCO , "Arabic (Morocco)") | |
3275 | LNG(wxLANGUAGE_ARABIC_OMAN, "ar_OM", LANG_ARABIC , SUBLANG_ARABIC_OMAN , "Arabic (Oman)") | |
3276 | LNG(wxLANGUAGE_ARABIC_QATAR, "ar_QA", LANG_ARABIC , SUBLANG_ARABIC_QATAR , "Arabic (Qatar)") | |
3277 | LNG(wxLANGUAGE_ARABIC_SAUDI_ARABIA, "ar_SA", LANG_ARABIC , SUBLANG_ARABIC_SAUDI_ARABIA , "Arabic (Saudi Arabia)") | |
3278 | LNG(wxLANGUAGE_ARABIC_SUDAN, "ar_SD", 0 , 0 , "Arabic (Sudan)") | |
3279 | LNG(wxLANGUAGE_ARABIC_SYRIA, "ar_SY", LANG_ARABIC , SUBLANG_ARABIC_SYRIA , "Arabic (Syria)") | |
3280 | LNG(wxLANGUAGE_ARABIC_TUNISIA, "ar_TN", LANG_ARABIC , SUBLANG_ARABIC_TUNISIA , "Arabic (Tunisia)") | |
3281 | LNG(wxLANGUAGE_ARABIC_UAE, "ar_AE", LANG_ARABIC , SUBLANG_ARABIC_UAE , "Arabic (Uae)") | |
3282 | LNG(wxLANGUAGE_ARABIC_YEMEN, "ar_YE", LANG_ARABIC , SUBLANG_ARABIC_YEMEN , "Arabic (Yemen)") | |
3283 | LNG(wxLANGUAGE_ARMENIAN, "hy" , LANG_ARMENIAN , SUBLANG_DEFAULT , "Armenian") | |
3284 | LNG(wxLANGUAGE_ASSAMESE, "as" , LANG_ASSAMESE , SUBLANG_DEFAULT , "Assamese") | |
3285 | LNG(wxLANGUAGE_AYMARA, "ay" , 0 , 0 , "Aymara") | |
3286 | LNG(wxLANGUAGE_AZERI, "az" , LANG_AZERI , SUBLANG_DEFAULT , "Azeri") | |
3287 | LNG(wxLANGUAGE_AZERI_CYRILLIC, "az" , LANG_AZERI , SUBLANG_AZERI_CYRILLIC , "Azeri (Cyrillic)") | |
3288 | LNG(wxLANGUAGE_AZERI_LATIN, "az" , LANG_AZERI , SUBLANG_AZERI_LATIN , "Azeri (Latin)") | |
3289 | LNG(wxLANGUAGE_BASHKIR, "ba" , 0 , 0 , "Bashkir") | |
3290 | LNG(wxLANGUAGE_BASQUE, "eu_ES", LANG_BASQUE , SUBLANG_DEFAULT , "Basque") | |
3291 | LNG(wxLANGUAGE_BELARUSIAN, "be_BY", LANG_BELARUSIAN, SUBLANG_DEFAULT , "Belarusian") | |
3292 | LNG(wxLANGUAGE_BENGALI, "bn" , LANG_BENGALI , SUBLANG_DEFAULT , "Bengali") | |
3293 | LNG(wxLANGUAGE_BHUTANI, "dz" , 0 , 0 , "Bhutani") | |
3294 | LNG(wxLANGUAGE_BIHARI, "bh" , 0 , 0 , "Bihari") | |
3295 | LNG(wxLANGUAGE_BISLAMA, "bi" , 0 , 0 , "Bislama") | |
3296 | LNG(wxLANGUAGE_BRETON, "br" , 0 , 0 , "Breton") | |
3297 | LNG(wxLANGUAGE_BULGARIAN, "bg_BG", LANG_BULGARIAN , SUBLANG_DEFAULT , "Bulgarian") | |
3298 | LNG(wxLANGUAGE_BURMESE, "my" , 0 , 0 , "Burmese") | |
3299 | LNG(wxLANGUAGE_CAMBODIAN, "km" , 0 , 0 , "Cambodian") | |
3300 | LNG(wxLANGUAGE_CATALAN, "ca_ES", LANG_CATALAN , SUBLANG_DEFAULT , "Catalan") | |
e6cea1d3 | 3301 | LNG(wxLANGUAGE_CHINESE, "zh_TW", LANG_CHINESE , SUBLANG_DEFAULT , "Chinese") |
d3f3e35f | 3302 | LNG(wxLANGUAGE_CHINESE_SIMPLIFIED, "zh_CN", LANG_CHINESE , SUBLANG_CHINESE_SIMPLIFIED , "Chinese (Simplified)") |
3ebd765d | 3303 | LNG(wxLANGUAGE_CHINESE_TRADITIONAL, "zh_TW", LANG_CHINESE , SUBLANG_CHINESE_TRADITIONAL , "Chinese (Traditional)") |
d3f3e35f VS |
3304 | LNG(wxLANGUAGE_CHINESE_HONGKONG, "zh_HK", LANG_CHINESE , SUBLANG_CHINESE_HONGKONG , "Chinese (Hongkong)") |
3305 | LNG(wxLANGUAGE_CHINESE_MACAU, "zh_MO", LANG_CHINESE , SUBLANG_CHINESE_MACAU , "Chinese (Macau)") | |
3306 | LNG(wxLANGUAGE_CHINESE_SINGAPORE, "zh_SG", LANG_CHINESE , SUBLANG_CHINESE_SINGAPORE , "Chinese (Singapore)") | |
2b5f62a0 | 3307 | LNG(wxLANGUAGE_CHINESE_TAIWAN, "zh_TW", LANG_CHINESE , SUBLANG_CHINESE_TRADITIONAL , "Chinese (Taiwan)") |
d3f3e35f VS |
3308 | LNG(wxLANGUAGE_CORSICAN, "co" , 0 , 0 , "Corsican") |
3309 | LNG(wxLANGUAGE_CROATIAN, "hr_HR", LANG_CROATIAN , SUBLANG_DEFAULT , "Croatian") | |
3310 | LNG(wxLANGUAGE_CZECH, "cs_CZ", LANG_CZECH , SUBLANG_DEFAULT , "Czech") | |
3311 | LNG(wxLANGUAGE_DANISH, "da_DK", LANG_DANISH , SUBLANG_DEFAULT , "Danish") | |
3312 | LNG(wxLANGUAGE_DUTCH, "nl_NL", LANG_DUTCH , SUBLANG_DUTCH , "Dutch") | |
3313 | LNG(wxLANGUAGE_DUTCH_BELGIAN, "nl_BE", LANG_DUTCH , SUBLANG_DUTCH_BELGIAN , "Dutch (Belgian)") | |
3314 | LNG(wxLANGUAGE_ENGLISH, "en_GB", LANG_ENGLISH , SUBLANG_ENGLISH_UK , "English") | |
3315 | LNG(wxLANGUAGE_ENGLISH_UK, "en_GB", LANG_ENGLISH , SUBLANG_ENGLISH_UK , "English (U.K.)") | |
3316 | LNG(wxLANGUAGE_ENGLISH_US, "en_US", LANG_ENGLISH , SUBLANG_ENGLISH_US , "English (U.S.)") | |
3317 | LNG(wxLANGUAGE_ENGLISH_AUSTRALIA, "en_AU", LANG_ENGLISH , SUBLANG_ENGLISH_AUS , "English (Australia)") | |
3318 | LNG(wxLANGUAGE_ENGLISH_BELIZE, "en_BZ", LANG_ENGLISH , SUBLANG_ENGLISH_BELIZE , "English (Belize)") | |
3319 | LNG(wxLANGUAGE_ENGLISH_BOTSWANA, "en_BW", 0 , 0 , "English (Botswana)") | |
3320 | LNG(wxLANGUAGE_ENGLISH_CANADA, "en_CA", LANG_ENGLISH , SUBLANG_ENGLISH_CAN , "English (Canada)") | |
3321 | LNG(wxLANGUAGE_ENGLISH_CARIBBEAN, "en_CB", LANG_ENGLISH , SUBLANG_ENGLISH_CARIBBEAN , "English (Caribbean)") | |
3322 | LNG(wxLANGUAGE_ENGLISH_DENMARK, "en_DK", 0 , 0 , "English (Denmark)") | |
3323 | LNG(wxLANGUAGE_ENGLISH_EIRE, "en_IE", LANG_ENGLISH , SUBLANG_ENGLISH_EIRE , "English (Eire)") | |
3324 | LNG(wxLANGUAGE_ENGLISH_JAMAICA, "en_JM", LANG_ENGLISH , SUBLANG_ENGLISH_JAMAICA , "English (Jamaica)") | |
3325 | LNG(wxLANGUAGE_ENGLISH_NEW_ZEALAND, "en_NZ", LANG_ENGLISH , SUBLANG_ENGLISH_NZ , "English (New Zealand)") | |
3326 | LNG(wxLANGUAGE_ENGLISH_PHILIPPINES, "en_PH", LANG_ENGLISH , SUBLANG_ENGLISH_PHILIPPINES , "English (Philippines)") | |
3327 | LNG(wxLANGUAGE_ENGLISH_SOUTH_AFRICA, "en_ZA", LANG_ENGLISH , SUBLANG_ENGLISH_SOUTH_AFRICA , "English (South Africa)") | |
3328 | LNG(wxLANGUAGE_ENGLISH_TRINIDAD, "en_TT", LANG_ENGLISH , SUBLANG_ENGLISH_TRINIDAD , "English (Trinidad)") | |
3329 | LNG(wxLANGUAGE_ENGLISH_ZIMBABWE, "en_ZW", LANG_ENGLISH , SUBLANG_ENGLISH_ZIMBABWE , "English (Zimbabwe)") | |
3330 | LNG(wxLANGUAGE_ESPERANTO, "eo" , 0 , 0 , "Esperanto") | |
3331 | LNG(wxLANGUAGE_ESTONIAN, "et_EE", LANG_ESTONIAN , SUBLANG_DEFAULT , "Estonian") | |
3332 | LNG(wxLANGUAGE_FAEROESE, "fo_FO", LANG_FAEROESE , SUBLANG_DEFAULT , "Faeroese") | |
865a1730 | 3333 | LNG(wxLANGUAGE_FARSI, "fa_IR", LANG_FARSI , SUBLANG_DEFAULT , "Farsi") |
d3f3e35f VS |
3334 | LNG(wxLANGUAGE_FIJI, "fj" , 0 , 0 , "Fiji") |
3335 | LNG(wxLANGUAGE_FINNISH, "fi_FI", LANG_FINNISH , SUBLANG_DEFAULT , "Finnish") | |
3336 | LNG(wxLANGUAGE_FRENCH, "fr_FR", LANG_FRENCH , SUBLANG_FRENCH , "French") | |
3337 | LNG(wxLANGUAGE_FRENCH_BELGIAN, "fr_BE", LANG_FRENCH , SUBLANG_FRENCH_BELGIAN , "French (Belgian)") | |
3338 | LNG(wxLANGUAGE_FRENCH_CANADIAN, "fr_CA", LANG_FRENCH , SUBLANG_FRENCH_CANADIAN , "French (Canadian)") | |
3339 | LNG(wxLANGUAGE_FRENCH_LUXEMBOURG, "fr_LU", LANG_FRENCH , SUBLANG_FRENCH_LUXEMBOURG , "French (Luxembourg)") | |
3340 | LNG(wxLANGUAGE_FRENCH_MONACO, "fr_MC", LANG_FRENCH , SUBLANG_FRENCH_MONACO , "French (Monaco)") | |
3341 | LNG(wxLANGUAGE_FRENCH_SWISS, "fr_CH", LANG_FRENCH , SUBLANG_FRENCH_SWISS , "French (Swiss)") | |
3342 | LNG(wxLANGUAGE_FRISIAN, "fy" , 0 , 0 , "Frisian") | |
3343 | LNG(wxLANGUAGE_GALICIAN, "gl_ES", 0 , 0 , "Galician") | |
3344 | LNG(wxLANGUAGE_GEORGIAN, "ka" , LANG_GEORGIAN , SUBLANG_DEFAULT , "Georgian") | |
3345 | LNG(wxLANGUAGE_GERMAN, "de_DE", LANG_GERMAN , SUBLANG_GERMAN , "German") | |
3346 | LNG(wxLANGUAGE_GERMAN_AUSTRIAN, "de_AT", LANG_GERMAN , SUBLANG_GERMAN_AUSTRIAN , "German (Austrian)") | |
3347 | LNG(wxLANGUAGE_GERMAN_BELGIUM, "de_BE", 0 , 0 , "German (Belgium)") | |
3348 | LNG(wxLANGUAGE_GERMAN_LIECHTENSTEIN, "de_LI", LANG_GERMAN , SUBLANG_GERMAN_LIECHTENSTEIN , "German (Liechtenstein)") | |
3349 | LNG(wxLANGUAGE_GERMAN_LUXEMBOURG, "de_LU", LANG_GERMAN , SUBLANG_GERMAN_LUXEMBOURG , "German (Luxembourg)") | |
3350 | LNG(wxLANGUAGE_GERMAN_SWISS, "de_CH", LANG_GERMAN , SUBLANG_GERMAN_SWISS , "German (Swiss)") | |
3351 | LNG(wxLANGUAGE_GREEK, "el_GR", LANG_GREEK , SUBLANG_DEFAULT , "Greek") | |
3352 | LNG(wxLANGUAGE_GREENLANDIC, "kl_GL", 0 , 0 , "Greenlandic") | |
3353 | LNG(wxLANGUAGE_GUARANI, "gn" , 0 , 0 , "Guarani") | |
3354 | LNG(wxLANGUAGE_GUJARATI, "gu" , LANG_GUJARATI , SUBLANG_DEFAULT , "Gujarati") | |
3355 | LNG(wxLANGUAGE_HAUSA, "ha" , 0 , 0 , "Hausa") | |
3356 | LNG(wxLANGUAGE_HEBREW, "he_IL", LANG_HEBREW , SUBLANG_DEFAULT , "Hebrew") | |
3357 | LNG(wxLANGUAGE_HINDI, "hi_IN", LANG_HINDI , SUBLANG_DEFAULT , "Hindi") | |
3358 | LNG(wxLANGUAGE_HUNGARIAN, "hu_HU", LANG_HUNGARIAN , SUBLANG_DEFAULT , "Hungarian") | |
3359 | LNG(wxLANGUAGE_ICELANDIC, "is_IS", LANG_ICELANDIC , SUBLANG_DEFAULT , "Icelandic") | |
3360 | LNG(wxLANGUAGE_INDONESIAN, "id_ID", LANG_INDONESIAN, SUBLANG_DEFAULT , "Indonesian") | |
3361 | LNG(wxLANGUAGE_INTERLINGUA, "ia" , 0 , 0 , "Interlingua") | |
3362 | LNG(wxLANGUAGE_INTERLINGUE, "ie" , 0 , 0 , "Interlingue") | |
3363 | LNG(wxLANGUAGE_INUKTITUT, "iu" , 0 , 0 , "Inuktitut") | |
3364 | LNG(wxLANGUAGE_INUPIAK, "ik" , 0 , 0 , "Inupiak") | |
3365 | LNG(wxLANGUAGE_IRISH, "ga_IE", 0 , 0 , "Irish") | |
3366 | LNG(wxLANGUAGE_ITALIAN, "it_IT", LANG_ITALIAN , SUBLANG_ITALIAN , "Italian") | |
3367 | LNG(wxLANGUAGE_ITALIAN_SWISS, "it_CH", LANG_ITALIAN , SUBLANG_ITALIAN_SWISS , "Italian (Swiss)") | |
3368 | LNG(wxLANGUAGE_JAPANESE, "ja_JP", LANG_JAPANESE , SUBLANG_DEFAULT , "Japanese") | |
3369 | LNG(wxLANGUAGE_JAVANESE, "jw" , 0 , 0 , "Javanese") | |
3370 | LNG(wxLANGUAGE_KANNADA, "kn" , LANG_KANNADA , SUBLANG_DEFAULT , "Kannada") | |
3371 | LNG(wxLANGUAGE_KASHMIRI, "ks" , LANG_KASHMIRI , SUBLANG_DEFAULT , "Kashmiri") | |
3372 | LNG(wxLANGUAGE_KASHMIRI_INDIA, "ks_IN", LANG_KASHMIRI , SUBLANG_KASHMIRI_INDIA , "Kashmiri (India)") | |
3373 | LNG(wxLANGUAGE_KAZAKH, "kk" , LANG_KAZAK , SUBLANG_DEFAULT , "Kazakh") | |
c611452f | 3374 | LNG(wxLANGUAGE_KERNEWEK, "kw_GB", 0 , 0 , "Kernewek") |
d3f3e35f VS |
3375 | LNG(wxLANGUAGE_KINYARWANDA, "rw" , 0 , 0 , "Kinyarwanda") |
3376 | LNG(wxLANGUAGE_KIRGHIZ, "ky" , 0 , 0 , "Kirghiz") | |
3377 | LNG(wxLANGUAGE_KIRUNDI, "rn" , 0 , 0 , "Kirundi") | |
3378 | LNG(wxLANGUAGE_KONKANI, "" , LANG_KONKANI , SUBLANG_DEFAULT , "Konkani") | |
3379 | LNG(wxLANGUAGE_KOREAN, "ko_KR", LANG_KOREAN , SUBLANG_KOREAN , "Korean") | |
3380 | LNG(wxLANGUAGE_KURDISH, "ku" , 0 , 0 , "Kurdish") | |
3381 | LNG(wxLANGUAGE_LAOTHIAN, "lo" , 0 , 0 , "Laothian") | |
3382 | LNG(wxLANGUAGE_LATIN, "la" , 0 , 0 , "Latin") | |
3383 | LNG(wxLANGUAGE_LATVIAN, "lv_LV", LANG_LATVIAN , SUBLANG_DEFAULT , "Latvian") | |
3384 | LNG(wxLANGUAGE_LINGALA, "ln" , 0 , 0 , "Lingala") | |
3385 | LNG(wxLANGUAGE_LITHUANIAN, "lt_LT", LANG_LITHUANIAN, SUBLANG_LITHUANIAN , "Lithuanian") | |
3386 | LNG(wxLANGUAGE_MACEDONIAN, "mk_MK", LANG_MACEDONIAN, SUBLANG_DEFAULT , "Macedonian") | |
3387 | LNG(wxLANGUAGE_MALAGASY, "mg" , 0 , 0 , "Malagasy") | |
3388 | LNG(wxLANGUAGE_MALAY, "ms_MY", LANG_MALAY , SUBLANG_DEFAULT , "Malay") | |
3389 | LNG(wxLANGUAGE_MALAYALAM, "ml" , LANG_MALAYALAM , SUBLANG_DEFAULT , "Malayalam") | |
3390 | LNG(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM, "ms_BN", LANG_MALAY , SUBLANG_MALAY_BRUNEI_DARUSSALAM , "Malay (Brunei Darussalam)") | |
3391 | LNG(wxLANGUAGE_MALAY_MALAYSIA, "ms_MY", LANG_MALAY , SUBLANG_MALAY_MALAYSIA , "Malay (Malaysia)") | |
3392 | LNG(wxLANGUAGE_MALTESE, "mt_MT", 0 , 0 , "Maltese") | |
3393 | LNG(wxLANGUAGE_MANIPURI, "" , LANG_MANIPURI , SUBLANG_DEFAULT , "Manipuri") | |
3394 | LNG(wxLANGUAGE_MAORI, "mi" , 0 , 0 , "Maori") | |
3395 | LNG(wxLANGUAGE_MARATHI, "mr_IN", LANG_MARATHI , SUBLANG_DEFAULT , "Marathi") | |
3396 | LNG(wxLANGUAGE_MOLDAVIAN, "mo" , 0 , 0 , "Moldavian") | |
3397 | LNG(wxLANGUAGE_MONGOLIAN, "mn" , 0 , 0 , "Mongolian") | |
3398 | LNG(wxLANGUAGE_NAURU, "na" , 0 , 0 , "Nauru") | |
3399 | LNG(wxLANGUAGE_NEPALI, "ne" , LANG_NEPALI , SUBLANG_DEFAULT , "Nepali") | |
3400 | LNG(wxLANGUAGE_NEPALI_INDIA, "ne_IN", LANG_NEPALI , SUBLANG_NEPALI_INDIA , "Nepali (India)") | |
cf5e94bc | 3401 | LNG(wxLANGUAGE_NORWEGIAN_BOKMAL, "nb_NO", LANG_NORWEGIAN , SUBLANG_NORWEGIAN_BOKMAL , "Norwegian (Bokmal)") |
c611452f | 3402 | LNG(wxLANGUAGE_NORWEGIAN_NYNORSK, "nn_NO", LANG_NORWEGIAN , SUBLANG_NORWEGIAN_NYNORSK , "Norwegian (Nynorsk)") |
d3f3e35f VS |
3403 | LNG(wxLANGUAGE_OCCITAN, "oc" , 0 , 0 , "Occitan") |
3404 | LNG(wxLANGUAGE_ORIYA, "or" , LANG_ORIYA , SUBLANG_DEFAULT , "Oriya") | |
3405 | LNG(wxLANGUAGE_OROMO, "om" , 0 , 0 , "(Afan) Oromo") | |
3406 | LNG(wxLANGUAGE_PASHTO, "ps" , 0 , 0 , "Pashto, Pushto") | |
d3f3e35f VS |
3407 | LNG(wxLANGUAGE_POLISH, "pl_PL", LANG_POLISH , SUBLANG_DEFAULT , "Polish") |
3408 | LNG(wxLANGUAGE_PORTUGUESE, "pt_PT", LANG_PORTUGUESE, SUBLANG_PORTUGUESE , "Portuguese") | |
3409 | LNG(wxLANGUAGE_PORTUGUESE_BRAZILIAN, "pt_BR", LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN , "Portuguese (Brazilian)") | |
3410 | LNG(wxLANGUAGE_PUNJABI, "pa" , LANG_PUNJABI , SUBLANG_DEFAULT , "Punjabi") | |
3411 | LNG(wxLANGUAGE_QUECHUA, "qu" , 0 , 0 , "Quechua") | |
3412 | LNG(wxLANGUAGE_RHAETO_ROMANCE, "rm" , 0 , 0 , "Rhaeto-Romance") | |
3413 | LNG(wxLANGUAGE_ROMANIAN, "ro_RO", LANG_ROMANIAN , SUBLANG_DEFAULT , "Romanian") | |
3414 | LNG(wxLANGUAGE_RUSSIAN, "ru_RU", LANG_RUSSIAN , SUBLANG_DEFAULT , "Russian") | |
3415 | LNG(wxLANGUAGE_RUSSIAN_UKRAINE, "ru_UA", 0 , 0 , "Russian (Ukraine)") | |
3416 | LNG(wxLANGUAGE_SAMOAN, "sm" , 0 , 0 , "Samoan") | |
3417 | LNG(wxLANGUAGE_SANGHO, "sg" , 0 , 0 , "Sangho") | |
3418 | LNG(wxLANGUAGE_SANSKRIT, "sa" , LANG_SANSKRIT , SUBLANG_DEFAULT , "Sanskrit") | |
3419 | LNG(wxLANGUAGE_SCOTS_GAELIC, "gd" , 0 , 0 , "Scots Gaelic") | |
3420 | LNG(wxLANGUAGE_SERBIAN, "sr_YU", LANG_SERBIAN , SUBLANG_DEFAULT , "Serbian") | |
3421 | LNG(wxLANGUAGE_SERBIAN_CYRILLIC, "sr_YU", LANG_SERBIAN , SUBLANG_SERBIAN_CYRILLIC , "Serbian (Cyrillic)") | |
3422 | LNG(wxLANGUAGE_SERBIAN_LATIN, "sr_YU", LANG_SERBIAN , SUBLANG_SERBIAN_LATIN , "Serbian (Latin)") | |
3423 | LNG(wxLANGUAGE_SERBO_CROATIAN, "sh" , 0 , 0 , "Serbo-Croatian") | |
3424 | LNG(wxLANGUAGE_SESOTHO, "st" , 0 , 0 , "Sesotho") | |
3425 | LNG(wxLANGUAGE_SETSWANA, "tn" , 0 , 0 , "Setswana") | |
3426 | LNG(wxLANGUAGE_SHONA, "sn" , 0 , 0 , "Shona") | |
3427 | LNG(wxLANGUAGE_SINDHI, "sd" , LANG_SINDHI , SUBLANG_DEFAULT , "Sindhi") | |
3428 | LNG(wxLANGUAGE_SINHALESE, "si" , 0 , 0 , "Sinhalese") | |
3429 | LNG(wxLANGUAGE_SISWATI, "ss" , 0 , 0 , "Siswati") | |
3430 | LNG(wxLANGUAGE_SLOVAK, "sk_SK", LANG_SLOVAK , SUBLANG_DEFAULT , "Slovak") | |
3431 | LNG(wxLANGUAGE_SLOVENIAN, "sl_SI", LANG_SLOVENIAN , SUBLANG_DEFAULT , "Slovenian") | |
3432 | LNG(wxLANGUAGE_SOMALI, "so" , 0 , 0 , "Somali") | |
3433 | LNG(wxLANGUAGE_SPANISH, "es_ES", LANG_SPANISH , SUBLANG_SPANISH , "Spanish") | |
3434 | LNG(wxLANGUAGE_SPANISH_ARGENTINA, "es_AR", LANG_SPANISH , SUBLANG_SPANISH_ARGENTINA , "Spanish (Argentina)") | |
3435 | LNG(wxLANGUAGE_SPANISH_BOLIVIA, "es_BO", LANG_SPANISH , SUBLANG_SPANISH_BOLIVIA , "Spanish (Bolivia)") | |
3436 | LNG(wxLANGUAGE_SPANISH_CHILE, "es_CL", LANG_SPANISH , SUBLANG_SPANISH_CHILE , "Spanish (Chile)") | |
3437 | LNG(wxLANGUAGE_SPANISH_COLOMBIA, "es_CO", LANG_SPANISH , SUBLANG_SPANISH_COLOMBIA , "Spanish (Colombia)") | |
3438 | LNG(wxLANGUAGE_SPANISH_COSTA_RICA, "es_CR", LANG_SPANISH , SUBLANG_SPANISH_COSTA_RICA , "Spanish (Costa Rica)") | |
3439 | LNG(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC, "es_DO", LANG_SPANISH , SUBLANG_SPANISH_DOMINICAN_REPUBLIC, "Spanish (Dominican republic)") | |
3440 | LNG(wxLANGUAGE_SPANISH_ECUADOR, "es_EC", LANG_SPANISH , SUBLANG_SPANISH_ECUADOR , "Spanish (Ecuador)") | |
3441 | LNG(wxLANGUAGE_SPANISH_EL_SALVADOR, "es_SV", LANG_SPANISH , SUBLANG_SPANISH_EL_SALVADOR , "Spanish (El Salvador)") | |
3442 | LNG(wxLANGUAGE_SPANISH_GUATEMALA, "es_GT", LANG_SPANISH , SUBLANG_SPANISH_GUATEMALA , "Spanish (Guatemala)") | |
3443 | LNG(wxLANGUAGE_SPANISH_HONDURAS, "es_HN", LANG_SPANISH , SUBLANG_SPANISH_HONDURAS , "Spanish (Honduras)") | |
3444 | LNG(wxLANGUAGE_SPANISH_MEXICAN, "es_MX", LANG_SPANISH , SUBLANG_SPANISH_MEXICAN , "Spanish (Mexican)") | |
3445 | LNG(wxLANGUAGE_SPANISH_MODERN, "es_ES", LANG_SPANISH , SUBLANG_SPANISH_MODERN , "Spanish (Modern)") | |
3446 | LNG(wxLANGUAGE_SPANISH_NICARAGUA, "es_NI", LANG_SPANISH , SUBLANG_SPANISH_NICARAGUA , "Spanish (Nicaragua)") | |
3447 | LNG(wxLANGUAGE_SPANISH_PANAMA, "es_PA", LANG_SPANISH , SUBLANG_SPANISH_PANAMA , "Spanish (Panama)") | |
3448 | LNG(wxLANGUAGE_SPANISH_PARAGUAY, "es_PY", LANG_SPANISH , SUBLANG_SPANISH_PARAGUAY , "Spanish (Paraguay)") | |
3449 | LNG(wxLANGUAGE_SPANISH_PERU, "es_PE", LANG_SPANISH , SUBLANG_SPANISH_PERU , "Spanish (Peru)") | |
3450 | LNG(wxLANGUAGE_SPANISH_PUERTO_RICO, "es_PR", LANG_SPANISH , SUBLANG_SPANISH_PUERTO_RICO , "Spanish (Puerto Rico)") | |
3451 | LNG(wxLANGUAGE_SPANISH_URUGUAY, "es_UY", LANG_SPANISH , SUBLANG_SPANISH_URUGUAY , "Spanish (Uruguay)") | |
3452 | LNG(wxLANGUAGE_SPANISH_US, "es_US", 0 , 0 , "Spanish (U.S.)") | |
3453 | LNG(wxLANGUAGE_SPANISH_VENEZUELA, "es_VE", LANG_SPANISH , SUBLANG_SPANISH_VENEZUELA , "Spanish (Venezuela)") | |
3454 | LNG(wxLANGUAGE_SUNDANESE, "su" , 0 , 0 , "Sundanese") | |
3455 | LNG(wxLANGUAGE_SWAHILI, "sw_KE", LANG_SWAHILI , SUBLANG_DEFAULT , "Swahili") | |
3456 | LNG(wxLANGUAGE_SWEDISH, "sv_SE", LANG_SWEDISH , SUBLANG_SWEDISH , "Swedish") | |
3457 | LNG(wxLANGUAGE_SWEDISH_FINLAND, "sv_FI", LANG_SWEDISH , SUBLANG_SWEDISH_FINLAND , "Swedish (Finland)") | |
25a5f9a9 | 3458 | LNG(wxLANGUAGE_TAGALOG, "tl_PH", 0 , 0 , "Tagalog") |
d3f3e35f VS |
3459 | LNG(wxLANGUAGE_TAJIK, "tg" , 0 , 0 , "Tajik") |
3460 | LNG(wxLANGUAGE_TAMIL, "ta" , LANG_TAMIL , SUBLANG_DEFAULT , "Tamil") | |
3461 | LNG(wxLANGUAGE_TATAR, "tt" , LANG_TATAR , SUBLANG_DEFAULT , "Tatar") | |
3462 | LNG(wxLANGUAGE_TELUGU, "te" , LANG_TELUGU , SUBLANG_DEFAULT , "Telugu") | |
3463 | LNG(wxLANGUAGE_THAI, "th_TH", LANG_THAI , SUBLANG_DEFAULT , "Thai") | |
3464 | LNG(wxLANGUAGE_TIBETAN, "bo" , 0 , 0 , "Tibetan") | |
3465 | LNG(wxLANGUAGE_TIGRINYA, "ti" , 0 , 0 , "Tigrinya") | |
3466 | LNG(wxLANGUAGE_TONGA, "to" , 0 , 0 , "Tonga") | |
3467 | LNG(wxLANGUAGE_TSONGA, "ts" , 0 , 0 , "Tsonga") | |
3468 | LNG(wxLANGUAGE_TURKISH, "tr_TR", LANG_TURKISH , SUBLANG_DEFAULT , "Turkish") | |
3469 | LNG(wxLANGUAGE_TURKMEN, "tk" , 0 , 0 , "Turkmen") | |
3470 | LNG(wxLANGUAGE_TWI, "tw" , 0 , 0 , "Twi") | |
3471 | LNG(wxLANGUAGE_UIGHUR, "ug" , 0 , 0 , "Uighur") | |
3472 | LNG(wxLANGUAGE_UKRAINIAN, "uk_UA", LANG_UKRAINIAN , SUBLANG_DEFAULT , "Ukrainian") | |
3473 | LNG(wxLANGUAGE_URDU, "ur" , LANG_URDU , SUBLANG_DEFAULT , "Urdu") | |
3474 | LNG(wxLANGUAGE_URDU_INDIA, "ur_IN", LANG_URDU , SUBLANG_URDU_INDIA , "Urdu (India)") | |
3475 | LNG(wxLANGUAGE_URDU_PAKISTAN, "ur_PK", LANG_URDU , SUBLANG_URDU_PAKISTAN , "Urdu (Pakistan)") | |
3476 | LNG(wxLANGUAGE_UZBEK, "uz" , LANG_UZBEK , SUBLANG_DEFAULT , "Uzbek") | |
3477 | LNG(wxLANGUAGE_UZBEK_CYRILLIC, "uz" , LANG_UZBEK , SUBLANG_UZBEK_CYRILLIC , "Uzbek (Cyrillic)") | |
3478 | LNG(wxLANGUAGE_UZBEK_LATIN, "uz" , LANG_UZBEK , SUBLANG_UZBEK_LATIN , "Uzbek (Latin)") | |
3479 | LNG(wxLANGUAGE_VIETNAMESE, "vi_VN", LANG_VIETNAMESE, SUBLANG_DEFAULT , "Vietnamese") | |
3480 | LNG(wxLANGUAGE_VOLAPUK, "vo" , 0 , 0 , "Volapuk") | |
3481 | LNG(wxLANGUAGE_WELSH, "cy" , 0 , 0 , "Welsh") | |
3482 | LNG(wxLANGUAGE_WOLOF, "wo" , 0 , 0 , "Wolof") | |
3483 | LNG(wxLANGUAGE_XHOSA, "xh" , 0 , 0 , "Xhosa") | |
3484 | LNG(wxLANGUAGE_YIDDISH, "yi" , 0 , 0 , "Yiddish") | |
3485 | LNG(wxLANGUAGE_YORUBA, "yo" , 0 , 0 , "Yoruba") | |
3486 | LNG(wxLANGUAGE_ZHUANG, "za" , 0 , 0 , "Zhuang") | |
3487 | LNG(wxLANGUAGE_ZULU, "zu" , 0 , 0 , "Zulu") | |
9e7ed2b0 | 3488 | |
d3f3e35f VS |
3489 | }; |
3490 | #undef LNG | |
3491 | ||
41780009 VS |
3492 | // --- --- --- generated code ends here --- --- --- |
3493 | ||
d427503c VZ |
3494 | #endif // wxUSE_INTL |
3495 |