]>
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 | ||
30984dea VZ |
1040 | // TODO: use wxStandardPaths instead of all this mess!! |
1041 | ||
5f170f33 VZ |
1042 | // LC_PATH is a standard env var containing the search path for the .mo |
1043 | // files | |
1c193821 | 1044 | #ifndef __WXWINCE__ |
f6bcfd97 | 1045 | const wxChar *pszLcPath = wxGetenv(wxT("LC_PATH")); |
5f170f33 VZ |
1046 | if ( pszLcPath != NULL ) |
1047 | searchPath << GetAllMsgCatalogSubdirs(pszLcPath, lang); | |
1c193821 | 1048 | #endif |
5f170f33 | 1049 | |
c3ccca4a VS |
1050 | #ifdef __UNIX__ |
1051 | // add some standard ones and the one in the tree where wxWin was installed: | |
1052 | searchPath | |
1053 | << GetAllMsgCatalogSubdirs(wxString(wxGetInstallPrefix()) + wxT("/share/locale"), lang) | |
1054 | << GetAllMsgCatalogSubdirs(wxT("/usr/share/locale"), lang) | |
1055 | << GetAllMsgCatalogSubdirs(wxT("/usr/lib/locale"), lang) | |
1056 | << GetAllMsgCatalogSubdirs(wxT("/usr/local/share/locale"), lang); | |
1057 | #endif // __UNIX__ | |
1058 | ||
fd323a5e VZ |
1059 | // then take the current directory |
1060 | // FIXME it should be the directory of the executable | |
30984dea VZ |
1061 | #if defined(__WXMAC__) |
1062 | searchPath << GetAllMsgCatalogSubdirs(wxGetCwd(), lang); | |
0e32fdb8 | 1063 | // generic search paths could be somewhere in the system folder preferences |
30984dea VZ |
1064 | #elif defined(__WXMSW__) |
1065 | // look in the directory of the executable | |
1066 | wxString path; | |
1067 | wxSplitPath(wxGetFullModuleName(), &path, NULL, NULL); | |
1068 | searchPath << GetAllMsgCatalogSubdirs(path, lang); | |
1069 | #else // !Mac, !MSW | |
15b8c27a | 1070 | searchPath << GetAllMsgCatalogSubdirs(wxT("."), lang); |
45e97ca0 VZ |
1071 | #endif // platform |
1072 | ||
fd323a5e VZ |
1073 | return searchPath; |
1074 | } | |
1075 | ||
c801d85f | 1076 | // open disk file and read in it's contents |
849a28d0 VS |
1077 | bool wxMsgCatalogFile::Load(const wxChar *szDirPrefix, const wxChar *szName0, |
1078 | wxPluralFormsCalculatorPtr& rPluralFormsCalculator) | |
c801d85f | 1079 | { |
03443829 KB |
1080 | /* We need to handle locales like de_AT.iso-8859-1 |
1081 | For this we first chop off the .CHARSET specifier and ignore it. | |
1082 | FIXME: UNICODE SUPPORT: must use CHARSET specifier! | |
1083 | */ | |
1084 | wxString szName = szName0; | |
7beb59f3 | 1085 | if(szName.Find(wxT('.')) != wxNOT_FOUND) // contains a dot |
58c837a4 | 1086 | szName = szName.Left(szName.Find(wxT('.'))); |
2ce0a6e2 | 1087 | |
fd323a5e | 1088 | wxString searchPath = GetFullSearchPath(szDirPrefix); |
223d09f6 | 1089 | const wxChar *sublocale = wxStrchr(szDirPrefix, wxT('_')); |
fd323a5e VZ |
1090 | if ( sublocale ) |
1091 | { | |
1092 | // also add just base locale name: for things like "fr_BE" (belgium | |
1093 | // french) we should use "fr" if no belgium specific message catalogs | |
1094 | // exist | |
1095 | searchPath << GetFullSearchPath(wxString(szDirPrefix). | |
1096 | Left((size_t)(sublocale - szDirPrefix))) | |
7af89395 | 1097 | << wxPATH_SEP; |
fd323a5e | 1098 | } |
7af89395 | 1099 | |
c801d85f KB |
1100 | wxString strFile = szName; |
1101 | strFile += MSGCATALOG_EXTENSION; | |
1102 | ||
1103 | // don't give translation errors here because the wxstd catalog might | |
1104 | // not yet be loaded (and it's normal) | |
1105 | // | |
1106 | // (we're using an object because we have several return paths) | |
ed58dbea | 1107 | |
c801d85f | 1108 | NoTransErr noTransErr; |
5f170f33 | 1109 | wxLogVerbose(_("looking for catalog '%s' in path '%s'."), |
742af071 | 1110 | szName.c_str(), searchPath.c_str()); |
c801d85f KB |
1111 | |
1112 | wxString strFullName; | |
fd323a5e | 1113 | if ( !wxFindFileInPath(&strFullName, searchPath, strFile) ) { |
c611452f | 1114 | wxLogVerbose(_("catalog file for domain '%s' not found."), szName.c_str()); |
7beb59f3 | 1115 | return false; |
c801d85f KB |
1116 | } |
1117 | ||
1118 | // open file | |
1a5a8367 | 1119 | wxLogVerbose(_("using catalog '%s' from '%s'."), |
ed58dbea | 1120 | szName.c_str(), strFullName.c_str()); |
7af89395 | 1121 | |
c801d85f KB |
1122 | wxFile fileMsg(strFullName); |
1123 | if ( !fileMsg.IsOpened() ) | |
7beb59f3 | 1124 | return false; |
c801d85f | 1125 | |
170b04ba | 1126 | // get the file size (assume it is less than 4Gb...) |
30984dea | 1127 | wxFileOffset nSize = fileMsg.Length(); |
1678ad78 | 1128 | if ( nSize == wxInvalidOffset ) |
7beb59f3 | 1129 | return false; |
c801d85f KB |
1130 | |
1131 | // read the whole file in memory | |
c86f1403 | 1132 | m_pData = new size_t8[nSize]; |
2e0ef2ae | 1133 | if ( fileMsg.Read(m_pData, (size_t)nSize) != nSize ) { |
a3622daa | 1134 | wxDELETEA(m_pData); |
7beb59f3 | 1135 | return false; |
c801d85f | 1136 | } |
7af89395 | 1137 | |
c801d85f | 1138 | // examine header |
30984dea | 1139 | bool bValid = nSize + (size_t)0 > sizeof(wxMsgCatalogHeader); |
7af89395 | 1140 | |
fd3f686c | 1141 | wxMsgCatalogHeader *pHeader = (wxMsgCatalogHeader *)m_pData; |
c801d85f | 1142 | if ( bValid ) { |
c801d85f KB |
1143 | // we'll have to swap all the integers if it's true |
1144 | m_bSwapped = pHeader->magic == MSGCATALOG_MAGIC_SW; | |
1145 | ||
1146 | // check the magic number | |
1147 | bValid = m_bSwapped || pHeader->magic == MSGCATALOG_MAGIC; | |
1148 | } | |
7af89395 | 1149 | |
c801d85f KB |
1150 | if ( !bValid ) { |
1151 | // it's either too short or has incorrect magic number | |
1a5a8367 | 1152 | wxLogWarning(_("'%s' is not a valid message catalog."), strFullName.c_str()); |
7af89395 | 1153 | |
a3622daa | 1154 | wxDELETEA(m_pData); |
7beb59f3 | 1155 | return false; |
c801d85f | 1156 | } |
7af89395 | 1157 | |
c801d85f KB |
1158 | // initialize |
1159 | m_numStrings = Swap(pHeader->numStrings); | |
7af89395 | 1160 | m_pOrigTable = (wxMsgTableEntry *)(m_pData + |
1678ad78 | 1161 | Swap(pHeader->ofsOrigTable)); |
7af89395 | 1162 | m_pTransTable = (wxMsgTableEntry *)(m_pData + |
1678ad78 | 1163 | Swap(pHeader->ofsTransTable)); |
2e0ef2ae | 1164 | m_nSize = (size_t32)nSize; |
b7b97e77 | 1165 | |
849a28d0 VS |
1166 | // now parse catalog's header and try to extract catalog charset and |
1167 | // plural forms formula from it: | |
1168 | ||
1169 | const char* headerData = StringAtOfs(m_pOrigTable, 0); | |
1170 | if (headerData && headerData[0] == 0) | |
1171 | { | |
1172 | // Extract the charset: | |
1173 | wxString header = wxString::FromAscii(StringAtOfs(m_pTransTable, 0)); | |
1174 | int begin = header.Find(wxT("Content-Type: text/plain; charset=")); | |
1175 | if (begin != wxNOT_FOUND) | |
1176 | { | |
1177 | begin += 34; //strlen("Content-Type: text/plain; charset=") | |
1178 | size_t end = header.find('\n', begin); | |
1179 | if (end != size_t(-1)) | |
1180 | { | |
1181 | m_charset.assign(header, begin, end - begin); | |
1182 | if (m_charset == wxT("CHARSET")) | |
1183 | { | |
1184 | // "CHARSET" is not valid charset, but lazy translator | |
1185 | m_charset.Clear(); | |
1186 | } | |
1187 | } | |
1188 | } | |
1189 | // else: incorrectly filled Content-Type header | |
b7b97e77 | 1190 | |
849a28d0 VS |
1191 | // Extract plural forms: |
1192 | begin = header.Find(wxT("Plural-Forms:")); | |
1193 | if (begin != wxNOT_FOUND) | |
1194 | { | |
1195 | begin += 13; | |
1196 | size_t end = header.find('\n', begin); | |
1197 | if (end != size_t(-1)) | |
1198 | { | |
1199 | wxString pfs(header, begin, end - begin); | |
1200 | wxPluralFormsCalculator* pCalculator = wxPluralFormsCalculator | |
1201 | ::make(pfs.ToAscii()); | |
1202 | if (pCalculator != 0) | |
1203 | { | |
1204 | rPluralFormsCalculator.reset(pCalculator); | |
1205 | } | |
1206 | else | |
1207 | { | |
1208 | wxLogVerbose(_("Cannot parse Plural-Forms:'%s'"), | |
1209 | pfs.c_str()); | |
1210 | } | |
1211 | } | |
1212 | } | |
1213 | if (rPluralFormsCalculator.get() == NULL) | |
1214 | { | |
1215 | rPluralFormsCalculator.reset(wxPluralFormsCalculator::make()); | |
1216 | } | |
1217 | } | |
c801d85f | 1218 | |
c801d85f | 1219 | // everything is fine |
849a28d0 | 1220 | return true; |
c801d85f KB |
1221 | } |
1222 | ||
d721baa9 VS |
1223 | void wxMsgCatalogFile::FillHash(wxMessagesHash& hash, |
1224 | const wxString& msgIdCharset, | |
1225 | bool convertEncoding) const | |
c801d85f | 1226 | { |
563d535e VS |
1227 | #if wxUSE_WCHAR_T |
1228 | wxCSConv *csConv = NULL; | |
7beb59f3 | 1229 | if ( !m_charset.IsEmpty() ) |
849a28d0 | 1230 | csConv = new wxCSConv(m_charset); |
7af89395 | 1231 | |
821d0fef | 1232 | wxMBConv& inputConv = csConv ? *((wxMBConv*)csConv) : *wxConvCurrent; |
d721baa9 VS |
1233 | |
1234 | wxCSConv *sourceConv = NULL; | |
1235 | if ( !msgIdCharset.empty() && (m_charset != msgIdCharset) ) | |
1236 | sourceConv = new wxCSConv(msgIdCharset); | |
1237 | ||
849a28d0 | 1238 | #elif wxUSE_FONTMAP |
d721baa9 VS |
1239 | wxASSERT_MSG( msgIdCharset == NULL, |
1240 | _T("non-ASCII msgid languages only supported if wxUSE_WCHAR_T=1") ); | |
7beb59f3 | 1241 | |
849a28d0 | 1242 | wxEncodingConverter converter; |
563d535e VS |
1243 | if ( convertEncoding ) |
1244 | { | |
baf736e1 | 1245 | wxFontEncoding targetEnc = wxFONTENCODING_SYSTEM; |
7beb59f3 | 1246 | wxFontEncoding enc = wxFontMapper::Get()->CharsetToEncoding(m_charset, false); |
563d535e VS |
1247 | if ( enc == wxFONTENCODING_SYSTEM ) |
1248 | { | |
7beb59f3 | 1249 | convertEncoding = false; // unknown encoding |
563d535e VS |
1250 | } |
1251 | else | |
1252 | { | |
baf736e1 | 1253 | targetEnc = wxLocale::GetSystemEncoding(); |
563d535e VS |
1254 | if (targetEnc == wxFONTENCODING_SYSTEM) |
1255 | { | |
1256 | wxFontEncodingArray a = wxEncodingConverter::GetPlatformEquivalents(enc); | |
1257 | if (a[0] == enc) | |
1258 | // no conversion needed, locale uses native encoding | |
7beb59f3 | 1259 | convertEncoding = false; |
563d535e VS |
1260 | if (a.GetCount() == 0) |
1261 | // we don't know common equiv. under this platform | |
7beb59f3 | 1262 | convertEncoding = false; |
563d535e VS |
1263 | targetEnc = a[0]; |
1264 | } | |
1265 | } | |
1266 | ||
1267 | if ( convertEncoding ) | |
1268 | { | |
563d535e | 1269 | converter.Init(enc, targetEnc); |
563d535e VS |
1270 | } |
1271 | } | |
563d535e | 1272 | #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T |
0c93d67c | 1273 | (void)convertEncoding; // get rid of warnings about unused parameter |
bc385ba9 | 1274 | |
849a28d0 | 1275 | for (size_t i = 0; i < m_numStrings; i++) |
563d535e | 1276 | { |
849a28d0 | 1277 | const char *data = StringAtOfs(m_pOrigTable, i); |
d721baa9 | 1278 | #if wxUSE_UNICODE |
849a28d0 VS |
1279 | wxString msgid(data, inputConv); |
1280 | #else | |
d721baa9 VS |
1281 | wxString msgid; |
1282 | #if wxUSE_WCHAR_T | |
1283 | if ( convertEncoding && sourceConv ) | |
1284 | msgid = wxString(inputConv.cMB2WC(data), *sourceConv); | |
1285 | else | |
849a28d0 | 1286 | #endif |
d721baa9 VS |
1287 | msgid = data; |
1288 | #endif // wxUSE_UNICODE | |
563d535e | 1289 | |
849a28d0 VS |
1290 | data = StringAtOfs(m_pTransTable, i); |
1291 | size_t length = Swap(m_pTransTable[i].nLen); | |
1292 | size_t offset = 0; | |
1293 | size_t index = 0; | |
1294 | while (offset < length) | |
1295 | { | |
1296 | wxString msgstr; | |
1297 | #if wxUSE_WCHAR_T | |
1298 | #if wxUSE_UNICODE | |
1299 | msgstr = wxString(data + offset, inputConv); | |
1300 | #else | |
1301 | if ( convertEncoding ) | |
1302 | msgstr = wxString(inputConv.cMB2WC(data + offset), wxConvLocal); | |
1303 | else | |
1304 | msgstr = wxString(data + offset); | |
1305 | #endif | |
1306 | #else // !wxUSE_WCHAR_T | |
1307 | #if wxUSE_FONTMAP | |
1308 | if ( convertEncoding ) | |
1309 | msgstr = wxString(converter.Convert(data + offset)); | |
1310 | else | |
1311 | #endif | |
1312 | msgstr = wxString(data + offset); | |
1313 | #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T | |
9e7ed2b0 | 1314 | |
849a28d0 VS |
1315 | if ( !msgstr.empty() ) |
1316 | { | |
1317 | hash[index == 0 ? msgid : msgid + wxChar(index)] = msgstr; | |
1318 | } | |
1319 | offset += strlen(data + offset) + 1; | |
1320 | ++index; | |
1321 | } | |
41780009 | 1322 | } |
9e7ed2b0 | 1323 | |
849a28d0 | 1324 | #if wxUSE_WCHAR_T |
d721baa9 | 1325 | delete sourceConv; |
849a28d0 VS |
1326 | delete csConv; |
1327 | #endif | |
563d535e | 1328 | } |
bc385ba9 | 1329 | |
849a28d0 | 1330 | |
563d535e VS |
1331 | // ---------------------------------------------------------------------------- |
1332 | // wxMsgCatalog class | |
1333 | // ---------------------------------------------------------------------------- | |
bc385ba9 | 1334 | |
9e7ed2b0 | 1335 | bool wxMsgCatalog::Load(const wxChar *szDirPrefix, const wxChar *szName, |
d721baa9 | 1336 | const wxChar *msgIdCharset, bool bConvertEncoding) |
563d535e VS |
1337 | { |
1338 | wxMsgCatalogFile file; | |
9e7ed2b0 | 1339 | |
563d535e | 1340 | m_name = szName; |
9e7ed2b0 | 1341 | |
849a28d0 | 1342 | if ( file.Load(szDirPrefix, szName, m_pluralFormsCalculator) ) |
563d535e | 1343 | { |
d721baa9 | 1344 | file.FillHash(m_messages, msgIdCharset, bConvertEncoding); |
7beb59f3 | 1345 | return true; |
563d535e | 1346 | } |
821d0fef | 1347 | |
7beb59f3 | 1348 | return false; |
afc94fa6 VS |
1349 | } |
1350 | ||
849a28d0 | 1351 | const wxChar *wxMsgCatalog::GetString(const wxChar *sz, size_t n) const |
563d535e | 1352 | { |
849a28d0 VS |
1353 | int index = 0; |
1354 | if (n != size_t(-1)) | |
1355 | { | |
1356 | index = m_pluralFormsCalculator->evaluate(n); | |
1357 | } | |
1358 | wxMessagesHash::const_iterator i; | |
1359 | if (index != 0) | |
1360 | { | |
1361 | i = m_messages.find(wxString(sz) + wxChar(index)); // plural | |
1362 | } | |
1363 | else | |
1364 | { | |
1365 | i = m_messages.find(sz); | |
1366 | } | |
1367 | ||
563d535e VS |
1368 | if ( i != m_messages.end() ) |
1369 | { | |
1370 | return i->second.c_str(); | |
1371 | } | |
1372 | else | |
1373 | return NULL; | |
1374 | } | |
afc94fa6 | 1375 | |
c801d85f KB |
1376 | // ---------------------------------------------------------------------------- |
1377 | // wxLocale | |
1378 | // ---------------------------------------------------------------------------- | |
1379 | ||
d3f3e35f VS |
1380 | #include "wx/arrimpl.cpp" |
1381 | WX_DECLARE_EXPORTED_OBJARRAY(wxLanguageInfo, wxLanguageInfoArray); | |
1382 | WX_DEFINE_OBJARRAY(wxLanguageInfoArray); | |
1383 | ||
41780009 VS |
1384 | wxLanguageInfoArray *wxLocale::ms_languagesDB = NULL; |
1385 | ||
1386 | /*static*/ void wxLocale::CreateLanguagesDB() | |
1387 | { | |
1388 | if (ms_languagesDB == NULL) | |
1389 | { | |
1390 | ms_languagesDB = new wxLanguageInfoArray; | |
1391 | InitLanguagesDB(); | |
1392 | } | |
1393 | } | |
1394 | ||
1395 | /*static*/ void wxLocale::DestroyLanguagesDB() | |
1396 | { | |
1397 | delete ms_languagesDB; | |
1398 | ms_languagesDB = NULL; | |
1399 | } | |
1400 | ||
1401 | ||
ea8f6fc7 | 1402 | void wxLocale::DoCommonInit() |
c801d85f | 1403 | { |
23fcecf7 | 1404 | m_pszOldLocale = NULL; |
eb48778d VZ |
1405 | |
1406 | m_pOldLocale = wxSetLocale(this); | |
1407 | ||
23fcecf7 | 1408 | m_pMsgCat = NULL; |
d3f3e35f | 1409 | m_language = wxLANGUAGE_UNKNOWN; |
3202d00d | 1410 | m_initialized = false; |
23fcecf7 VZ |
1411 | } |
1412 | ||
1413 | // NB: this function has (desired) side effect of changing current locale | |
e36e6f95 OK |
1414 | bool wxLocale::Init(const wxChar *szName, |
1415 | const wxChar *szShort, | |
1416 | const wxChar *szLocale, | |
afc94fa6 VS |
1417 | bool bLoadDefault, |
1418 | bool bConvertEncoding) | |
23fcecf7 | 1419 | { |
3202d00d VS |
1420 | wxASSERT_MSG( !m_initialized, |
1421 | _T("you can't call wxLocale::Init more than once") ); | |
b7b97e77 | 1422 | |
3202d00d | 1423 | m_initialized = true; |
23fcecf7 VZ |
1424 | m_strLocale = szName; |
1425 | m_strShort = szShort; | |
afc94fa6 | 1426 | m_bConvertEncoding = bConvertEncoding; |
d3f3e35f | 1427 | m_language = wxLANGUAGE_UNKNOWN; |
23fcecf7 | 1428 | |
c801d85f KB |
1429 | // change current locale (default: same as long name) |
1430 | if ( szLocale == NULL ) | |
9dea50fc VZ |
1431 | { |
1432 | // the argument to setlocale() | |
1433 | szLocale = szShort; | |
52558258 | 1434 | |
7beb59f3 | 1435 | wxCHECK_MSG( szLocale, false, _T("no locale to set in wxLocale::Init()") ); |
9dea50fc | 1436 | } |
10545ca4 | 1437 | |
1c193821 JS |
1438 | #ifdef __WXWINCE__ |
1439 | // FIXME: I'm guessing here | |
1440 | wxChar localeName[256]; | |
1441 | int ret = GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SLANGUAGE, localeName, | |
1442 | 256); | |
1443 | if (ret != 0) | |
1444 | { | |
b7b97e77 | 1445 | m_pszOldLocale = wxStrdup(localeName); |
1c193821 JS |
1446 | } |
1447 | else | |
1448 | m_pszOldLocale = NULL; | |
1449 | ||
1450 | // TODO: how to find languageId | |
1451 | // SetLocaleInfo(languageId, SORT_DEFAULT, localeName); | |
1452 | #else | |
c76b6474 VS |
1453 | wxMB2WXbuf oldLocale = wxSetlocale(LC_ALL, szLocale); |
1454 | if ( oldLocale ) | |
1455 | m_pszOldLocale = wxStrdup(oldLocale); | |
1456 | else | |
1457 | m_pszOldLocale = NULL; | |
1c193821 JS |
1458 | #endif |
1459 | ||
c801d85f | 1460 | if ( m_pszOldLocale == NULL ) |
1a5a8367 | 1461 | wxLogError(_("locale '%s' can not be set."), szLocale); |
c801d85f KB |
1462 | |
1463 | // the short name will be used to look for catalog files as well, | |
1464 | // so we need something here | |
1465 | if ( m_strShort.IsEmpty() ) { | |
fd323a5e VZ |
1466 | // FIXME I don't know how these 2 letter abbreviations are formed, |
1467 | // this wild guess is surely wrong | |
c7c06291 | 1468 | if ( szLocale && szLocale[0] ) |
70426fba VZ |
1469 | { |
1470 | m_strShort += (wxChar)wxTolower(szLocale[0]); | |
1471 | if ( szLocale[1] ) | |
1472 | m_strShort += (wxChar)wxTolower(szLocale[1]); | |
1473 | } | |
c801d85f | 1474 | } |
7af89395 | 1475 | |
77ffb593 | 1476 | // load the default catalog with wxWidgets standard messages |
c801d85f | 1477 | m_pMsgCat = NULL; |
7beb59f3 | 1478 | bool bOk = true; |
c801d85f | 1479 | if ( bLoadDefault ) |
223d09f6 | 1480 | bOk = AddCatalog(wxT("wxstd")); |
23fcecf7 VZ |
1481 | |
1482 | return bOk; | |
c801d85f KB |
1483 | } |
1484 | ||
41524ffc | 1485 | |
1cc549e5 | 1486 | #if defined(__UNIX__) && wxUSE_UNICODE && !defined(__WXMAC__) |
41524ffc VS |
1487 | static wxWCharBuffer wxSetlocaleTryUTF(int c, const wxChar *lc) |
1488 | { | |
1489 | wxMB2WXbuf l = wxSetlocale(c, lc); | |
2d34a303 | 1490 | if ( !l && lc && lc[0] != 0 ) |
41524ffc | 1491 | { |
7beb59f3 | 1492 | wxString buf(lc); |
2d34a303 | 1493 | wxString buf2; |
7beb59f3 WS |
1494 | buf2 = buf + wxT(".UTF-8"); |
1495 | l = wxSetlocale(c, buf2.c_str()); | |
2d34a303 VS |
1496 | if ( !l ) |
1497 | { | |
1498 | buf2 = buf + wxT(".utf-8"); | |
7beb59f3 | 1499 | l = wxSetlocale(c, buf2.c_str()); |
2d34a303 VS |
1500 | } |
1501 | if ( !l ) | |
1502 | { | |
1503 | buf2 = buf + wxT(".UTF8"); | |
7beb59f3 | 1504 | l = wxSetlocale(c, buf2.c_str()); |
2d34a303 VS |
1505 | } |
1506 | if ( !l ) | |
1507 | { | |
1508 | buf2 = buf + wxT(".utf8"); | |
7beb59f3 | 1509 | l = wxSetlocale(c, buf2.c_str()); |
2d34a303 | 1510 | } |
41524ffc VS |
1511 | } |
1512 | return l; | |
1513 | } | |
1514 | #else | |
1515 | #define wxSetlocaleTryUTF(c, lc) wxSetlocale(c, lc) | |
1516 | #endif | |
1517 | ||
d3f3e35f VS |
1518 | bool wxLocale::Init(int language, int flags) |
1519 | { | |
d3f3e35f | 1520 | int lang = language; |
ec37df57 VZ |
1521 | if (lang == wxLANGUAGE_DEFAULT) |
1522 | { | |
1523 | // auto detect the language | |
1524 | lang = GetSystemLanguage(); | |
1525 | } | |
1526 | ||
1527 | // We failed to detect system language, so we will use English: | |
1528 | if (lang == wxLANGUAGE_UNKNOWN) | |
1529 | { | |
7beb59f3 | 1530 | return false; |
ec37df57 VZ |
1531 | } |
1532 | ||
14f8fa9d | 1533 | const wxLanguageInfo *info = GetLanguageInfo(lang); |
d3f3e35f | 1534 | |
d3f3e35f VS |
1535 | // Unknown language: |
1536 | if (info == NULL) | |
1537 | { | |
1538 | wxLogError(wxT("Unknown language %i."), lang); | |
7beb59f3 | 1539 | return false; |
d3f3e35f VS |
1540 | } |
1541 | ||
1542 | wxString name = info->Description; | |
1543 | wxString canonical = info->CanonicalName; | |
1544 | wxString locale; | |
ec37df57 | 1545 | |
d3f3e35f | 1546 | // Set the locale: |
432e8391 | 1547 | #if defined(__UNIX__) && !defined(__WXMAC__) |
ec37df57 VZ |
1548 | if (language == wxLANGUAGE_DEFAULT) |
1549 | locale = wxEmptyString; | |
1550 | else | |
1551 | locale = info->CanonicalName; | |
d3f3e35f | 1552 | |
41524ffc | 1553 | wxMB2WXbuf retloc = wxSetlocaleTryUTF(LC_ALL, locale); |
d3f3e35f | 1554 | |
2b5f62a0 | 1555 | if ( !retloc ) |
d3f3e35f VS |
1556 | { |
1557 | // Some C libraries don't like xx_YY form and require xx only | |
41524ffc | 1558 | retloc = wxSetlocaleTryUTF(LC_ALL, locale.Mid(0,2)); |
d3f3e35f | 1559 | } |
2b5f62a0 | 1560 | if ( !retloc ) |
d3f3e35f VS |
1561 | { |
1562 | // Some C libraries (namely glibc) still use old ISO 639, | |
1563 | // so will translate the abbrev for them | |
1564 | wxString mid = locale.Mid(0,2); | |
2b5f62a0 VZ |
1565 | if (mid == wxT("he")) |
1566 | locale = wxT("iw") + locale.Mid(3); | |
1567 | else if (mid == wxT("id")) | |
1568 | locale = wxT("in") + locale.Mid(3); | |
1569 | else if (mid == wxT("yi")) | |
1570 | locale = wxT("ji") + locale.Mid(3); | |
cf5e94bc VS |
1571 | else if (mid == wxT("nb")) |
1572 | locale = wxT("no_NO"); | |
1573 | else if (mid == wxT("nn")) | |
1574 | locale = wxT("no_NY"); | |
2b5f62a0 | 1575 | |
41524ffc | 1576 | retloc = wxSetlocaleTryUTF(LC_ALL, locale); |
d3f3e35f | 1577 | } |
2b5f62a0 | 1578 | if ( !retloc ) |
d3f3e35f VS |
1579 | { |
1580 | // (This time, we changed locale in previous if-branch, so try again.) | |
1581 | // Some C libraries don't like xx_YY form and require xx only | |
41524ffc | 1582 | retloc = wxSetlocaleTryUTF(LC_ALL, locale.Mid(0,2)); |
d3f3e35f | 1583 | } |
2b5f62a0 | 1584 | if ( !retloc ) |
d3f3e35f VS |
1585 | { |
1586 | wxLogError(wxT("Cannot set locale to '%s'."), locale.c_str()); | |
7beb59f3 | 1587 | return false; |
d3f3e35f | 1588 | } |
d3f3e35f | 1589 | #elif defined(__WIN32__) |
65dc921d VS |
1590 | |
1591 | #if wxUSE_UNICODE && (defined(__VISUALC__) || defined(__MINGW32__)) | |
1592 | // NB: setlocale() from msvcrt.dll (used by VC++ and Mingw) | |
1593 | // can't set locale to language that can only be written using | |
1594 | // Unicode. Therefore wxSetlocale call failed, but we don't want | |
1595 | // to report it as an error -- so that at least message catalogs | |
1596 | // can be used. Watch for code marked with | |
1597 | // #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS bellow. | |
1598 | #define SETLOCALE_FAILS_ON_UNICODE_LANGS | |
1599 | #endif | |
b7b97e77 VZ |
1600 | |
1601 | #if !wxUSE_UNICODE | |
1602 | const | |
1603 | #endif | |
2b5f62a0 | 1604 | wxMB2WXbuf retloc = wxT("C"); |
d3f3e35f VS |
1605 | if (language != wxLANGUAGE_DEFAULT) |
1606 | { | |
63986ba6 | 1607 | if (info->WinLang == 0) |
d3f3e35f | 1608 | { |
63986ba6 | 1609 | wxLogWarning(wxT("Locale '%s' not supported by OS."), name.c_str()); |
2b5f62a0 | 1610 | // retloc already set to "C" |
63986ba6 VS |
1611 | } |
1612 | else | |
ec37df57 | 1613 | { |
b7b97e77 | 1614 | int codepage |
999836aa VZ |
1615 | #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS |
1616 | = -1 | |
1617 | #endif | |
1618 | ; | |
ec37df57 | 1619 | wxUint32 lcid = MAKELCID(MAKELANGID(info->WinLang, info->WinSublang), |
63986ba6 | 1620 | SORT_DEFAULT); |
1c193821 JS |
1621 | // FIXME |
1622 | #ifndef __WXWINCE__ | |
65dc921d | 1623 | SetThreadLocale(lcid); |
1c193821 | 1624 | #endif |
65dc921d VS |
1625 | // NB: we must translate LCID to CRT's setlocale string ourselves, |
1626 | // because SetThreadLocale does not modify change the | |
1627 | // interpretation of setlocale(LC_ALL, "") call: | |
1628 | wxChar buffer[256]; | |
1629 | buffer[0] = wxT('\0'); | |
1630 | GetLocaleInfo(lcid, LOCALE_SENGLANGUAGE, buffer, 256); | |
1631 | locale << buffer; | |
1632 | if (GetLocaleInfo(lcid, LOCALE_SENGCOUNTRY, buffer, 256) > 0) | |
1633 | locale << wxT("_") << buffer; | |
1634 | if (GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE, buffer, 256) > 0) | |
1635 | { | |
1636 | codepage = wxAtoi(buffer); | |
1637 | if (codepage != 0) | |
1638 | locale << wxT(".") << buffer; | |
1639 | } | |
1640 | if (locale.IsEmpty()) | |
2b5f62a0 | 1641 | { |
65dc921d VS |
1642 | wxLogLastError(wxT("SetThreadLocale")); |
1643 | wxLogError(wxT("Cannot set locale to language %s."), name.c_str()); | |
7beb59f3 | 1644 | return false; |
2b5f62a0 | 1645 | } |
63986ba6 | 1646 | else |
c611452f | 1647 | { |
1c193821 JS |
1648 | // FIXME |
1649 | #ifndef __WXWINCE__ | |
65dc921d | 1650 | retloc = wxSetlocale(LC_ALL, locale); |
1c193821 | 1651 | #endif |
65dc921d VS |
1652 | #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS |
1653 | if (codepage == 0 && (const wxChar*)retloc == NULL) | |
2b5f62a0 | 1654 | { |
65dc921d | 1655 | retloc = wxT("C"); |
2b5f62a0 | 1656 | } |
65dc921d | 1657 | #endif |
c611452f | 1658 | } |
d3f3e35f VS |
1659 | } |
1660 | } | |
c611452f | 1661 | else |
2b5f62a0 | 1662 | { |
1c193821 JS |
1663 | // FIXME |
1664 | #ifndef __WXWINCE__ | |
c611452f | 1665 | retloc = wxSetlocale(LC_ALL, wxEmptyString); |
1c193821 JS |
1666 | #else |
1667 | retloc = NULL; | |
1668 | #endif | |
65dc921d VS |
1669 | #ifdef SETLOCALE_FAILS_ON_UNICODE_LANGS |
1670 | if ((const wxChar*)retloc == NULL) | |
1671 | { | |
1672 | wxChar buffer[16]; | |
1673 | if (GetLocaleInfo(LOCALE_USER_DEFAULT, | |
1674 | LOCALE_IDEFAULTANSICODEPAGE, buffer, 16) > 0 && | |
1675 | wxStrcmp(buffer, wxT("0")) == 0) | |
1676 | { | |
1677 | retloc = wxT("C"); | |
1678 | } | |
1679 | } | |
1680 | #endif | |
2b5f62a0 | 1681 | } |
c611452f | 1682 | |
2b5f62a0 | 1683 | if ( !retloc ) |
d3f3e35f VS |
1684 | { |
1685 | wxLogError(wxT("Cannot set locale to language %s."), name.c_str()); | |
7beb59f3 | 1686 | return false; |
d3f3e35f | 1687 | } |
85fb2206 | 1688 | #elif defined(__WXMAC__) |
b51daa4f | 1689 | if (lang == wxLANGUAGE_DEFAULT) |
85fb2206 SC |
1690 | locale = wxEmptyString; |
1691 | else | |
1692 | locale = info->CanonicalName; | |
1693 | ||
1694 | wxMB2WXbuf retloc = wxSetlocale(LC_ALL, locale); | |
1695 | ||
1696 | if ( !retloc ) | |
1697 | { | |
1698 | // Some C libraries don't like xx_YY form and require xx only | |
1699 | retloc = wxSetlocale(LC_ALL, locale.Mid(0,2)); | |
1700 | } | |
1701 | if ( !retloc ) | |
1702 | { | |
1703 | wxLogError(wxT("Cannot set locale to '%s'."), locale.c_str()); | |
1704 | return false; | |
1705 | } | |
1706 | #elif defined(__WXPM__) | |
2b5f62a0 | 1707 | wxMB2WXbuf retloc = wxSetlocale(LC_ALL , wxEmptyString); |
d3f3e35f | 1708 | #else |
7beb59f3 | 1709 | return false; |
e879e020 | 1710 | #define WX_NO_LOCALE_SUPPORT |
d3f3e35f | 1711 | #endif |
ec37df57 | 1712 | |
e879e020 | 1713 | #ifndef WX_NO_LOCALE_SUPPORT |
10545ca4 | 1714 | wxChar *szLocale = retloc ? wxStrdup(retloc) : NULL; |
b78a78f7 VS |
1715 | bool ret = Init(name, canonical, retloc, |
1716 | (flags & wxLOCALE_LOAD_DEFAULT) != 0, | |
1717 | (flags & wxLOCALE_CONV_ENCODING) != 0); | |
10545ca4 VZ |
1718 | free(szLocale); |
1719 | ||
549a7c37 | 1720 | if (IsOk()) // setlocale() succeeded |
10545ca4 VZ |
1721 | m_language = lang; |
1722 | ||
b78a78f7 | 1723 | return ret; |
e879e020 | 1724 | #endif |
d3f3e35f VS |
1725 | } |
1726 | ||
1727 | ||
1728 | ||
fd323a5e VZ |
1729 | void wxLocale::AddCatalogLookupPathPrefix(const wxString& prefix) |
1730 | { | |
3c67202d | 1731 | if ( s_searchPrefixes.Index(prefix) == wxNOT_FOUND ) |
fd323a5e VZ |
1732 | { |
1733 | s_searchPrefixes.Add(prefix); | |
1734 | } | |
1735 | //else: already have it | |
1736 | } | |
1737 | ||
41780009 | 1738 | /*static*/ int wxLocale::GetSystemLanguage() |
d3f3e35f | 1739 | { |
41780009 | 1740 | CreateLanguagesDB(); |
ec37df57 VZ |
1741 | |
1742 | // init i to avoid compiler warning | |
1743 | size_t i = 0, | |
41780009 | 1744 | count = ms_languagesDB->GetCount(); |
d3f3e35f | 1745 | |
432e8391 | 1746 | #if defined(__UNIX__) && !defined(__WXMAC__) |
ec37df57 VZ |
1747 | // first get the string identifying the language from the environment |
1748 | wxString langFull; | |
1749 | if (!wxGetEnv(wxT("LC_ALL"), &langFull) && | |
1750 | !wxGetEnv(wxT("LC_MESSAGES"), &langFull) && | |
1751 | !wxGetEnv(wxT("LANG"), &langFull)) | |
1752 | { | |
41780009 VS |
1753 | // no language specified, threat it as English |
1754 | return wxLANGUAGE_ENGLISH; | |
ec37df57 | 1755 | } |
d3f3e35f | 1756 | |
efd1393b | 1757 | if ( langFull == _T("C") || langFull == _T("POSIX") ) |
d3f3e35f | 1758 | { |
ec37df57 | 1759 | // default C locale |
41780009 | 1760 | return wxLANGUAGE_ENGLISH; |
d3f3e35f VS |
1761 | } |
1762 | ||
ec37df57 VZ |
1763 | // the language string has the following form |
1764 | // | |
efd1393b | 1765 | // lang[_LANG][.encoding][@modifier] |
ec37df57 | 1766 | // |
efd1393b VZ |
1767 | // (see environ(5) in the Open Unix specification) |
1768 | // | |
1769 | // where lang is the primary language, LANG is a sublang/territory, | |
1770 | // encoding is the charset to use and modifier "allows the user to select | |
1771 | // a specific instance of localization data within a single category" | |
ec37df57 VZ |
1772 | // |
1773 | // for example, the following strings are valid: | |
1774 | // fr | |
1775 | // fr_FR | |
1776 | // de_DE.iso88591 | |
efd1393b VZ |
1777 | // de_DE@euro |
1778 | // de_DE.iso88591@euro | |
ec37df57 VZ |
1779 | |
1780 | // for now we don't use the encoding, although we probably should (doing | |
1781 | // translations of the msg catalogs on the fly as required) (TODO) | |
efd1393b VZ |
1782 | // |
1783 | // we don't use the modifiers neither but we probably should translate | |
1784 | // "euro" into iso885915 | |
1785 | size_t posEndLang = langFull.find_first_of(_T("@.")); | |
1786 | if ( posEndLang != wxString::npos ) | |
1787 | { | |
1788 | langFull.Truncate(posEndLang); | |
1789 | } | |
ec37df57 VZ |
1790 | |
1791 | // in addition to the format above, we also can have full language names | |
1792 | // in LANG env var - for example, SuSE is known to use LANG="german" - so | |
1793 | // check for this | |
1794 | ||
1795 | // do we have just the language (or sublang too)? | |
1796 | bool justLang = langFull.Len() == LEN_LANG; | |
1797 | if ( justLang || | |
1798 | (langFull.Len() == LEN_FULL && langFull[LEN_LANG] == wxT('_')) ) | |
d3f3e35f | 1799 | { |
ec37df57 VZ |
1800 | // 0. Make sure the lang is according to latest ISO 639 |
1801 | // (this is neccessary because glibc uses iw and in instead | |
1802 | // of he and id respectively). | |
1803 | ||
1804 | // the language itself (second part is the dialect/sublang) | |
1805 | wxString langOrig = ExtractLang(langFull); | |
1806 | ||
1807 | wxString lang; | |
1808 | if ( langOrig == wxT("iw")) | |
1809 | lang = _T("he"); | |
cf5e94bc | 1810 | else if (langOrig == wxT("in")) |
ec37df57 | 1811 | lang = wxT("id"); |
cf5e94bc | 1812 | else if (langOrig == wxT("ji")) |
ec37df57 | 1813 | lang = wxT("yi"); |
cf5e94bc VS |
1814 | else if (langOrig == wxT("no_NO")) |
1815 | lang = wxT("nb_NO"); | |
1816 | else if (langOrig == wxT("no_NY")) | |
1817 | lang = wxT("nn_NO"); | |
1818 | else if (langOrig == wxT("no")) | |
1819 | lang = wxT("nb_NO"); | |
ec37df57 VZ |
1820 | else |
1821 | lang = langOrig; | |
1822 | ||
1823 | // did we change it? | |
1824 | if ( lang != langOrig ) | |
d3f3e35f | 1825 | { |
ec37df57 VZ |
1826 | langFull = lang + ExtractNotLang(langFull); |
1827 | } | |
1828 | ||
1829 | // 1. Try to find the language either as is: | |
1830 | for ( i = 0; i < count; i++ ) | |
1831 | { | |
41780009 | 1832 | if ( ms_languagesDB->Item(i).CanonicalName == langFull ) |
d3f3e35f | 1833 | { |
d3f3e35f VS |
1834 | break; |
1835 | } | |
1836 | } | |
d3f3e35f | 1837 | |
ec37df57 VZ |
1838 | // 2. If langFull is of the form xx_YY, try to find xx: |
1839 | if ( i == count && !justLang ) | |
d3f3e35f | 1840 | { |
ec37df57 | 1841 | for ( i = 0; i < count; i++ ) |
d3f3e35f | 1842 | { |
41780009 | 1843 | if ( ms_languagesDB->Item(i).CanonicalName == lang ) |
ec37df57 VZ |
1844 | { |
1845 | break; | |
1846 | } | |
d3f3e35f VS |
1847 | } |
1848 | } | |
d3f3e35f | 1849 | |
ec37df57 VZ |
1850 | // 3. If langFull is of the form xx, try to find any xx_YY record: |
1851 | if ( i == count && justLang ) | |
d3f3e35f | 1852 | { |
ec37df57 | 1853 | for ( i = 0; i < count; i++ ) |
d3f3e35f | 1854 | { |
41780009 | 1855 | if ( ExtractLang(ms_languagesDB->Item(i).CanonicalName) |
ec37df57 VZ |
1856 | == langFull ) |
1857 | { | |
1858 | break; | |
1859 | } | |
d3f3e35f VS |
1860 | } |
1861 | } | |
1862 | } | |
ec37df57 | 1863 | else // not standard format |
d3f3e35f | 1864 | { |
ec37df57 VZ |
1865 | // try to find the name in verbose description |
1866 | for ( i = 0; i < count; i++ ) | |
d3f3e35f | 1867 | { |
41780009 | 1868 | if (ms_languagesDB->Item(i).Description.CmpNoCase(langFull) == 0) |
d3f3e35f | 1869 | { |
d3f3e35f VS |
1870 | break; |
1871 | } | |
1872 | } | |
1873 | } | |
0e32fdb8 | 1874 | #elif defined(__WXMAC__) |
44c44c82 | 1875 | const wxChar * lc = NULL ; |
0e32fdb8 SC |
1876 | long lang = GetScriptVariable( smSystemScript, smScriptLang) ; |
1877 | switch( GetScriptManagerVariable( smRegionCode ) ) { | |
1878 | case verUS : | |
44c44c82 | 1879 | lc = wxT("en_US") ; |
0e32fdb8 SC |
1880 | break ; |
1881 | case verFrance : | |
44c44c82 | 1882 | lc = wxT("fr_FR") ; |
0e32fdb8 SC |
1883 | break ; |
1884 | case verBritain : | |
44c44c82 | 1885 | lc = wxT("en_GB") ; |
0e32fdb8 SC |
1886 | break ; |
1887 | case verGermany : | |
44c44c82 | 1888 | lc = wxT("de_DE") ; |
0e32fdb8 SC |
1889 | break ; |
1890 | case verItaly : | |
44c44c82 | 1891 | lc = wxT("it_IT") ; |
0e32fdb8 SC |
1892 | break ; |
1893 | case verNetherlands : | |
44c44c82 | 1894 | lc = wxT("nl_NL") ; |
0e32fdb8 SC |
1895 | break ; |
1896 | case verFlemish : | |
44c44c82 | 1897 | lc = wxT("nl_BE") ; |
0e32fdb8 SC |
1898 | break ; |
1899 | case verSweden : | |
44c44c82 | 1900 | lc = wxT("sv_SE" ); |
0e32fdb8 SC |
1901 | break ; |
1902 | case verSpain : | |
44c44c82 | 1903 | lc = wxT("es_ES" ); |
0e32fdb8 SC |
1904 | break ; |
1905 | case verDenmark : | |
44c44c82 | 1906 | lc = wxT("da_DK") ; |
0e32fdb8 SC |
1907 | break ; |
1908 | case verPortugal : | |
44c44c82 | 1909 | lc = wxT("pt_PT") ; |
0e32fdb8 SC |
1910 | break ; |
1911 | case verFrCanada: | |
44c44c82 | 1912 | lc = wxT("fr_CA") ; |
0e32fdb8 SC |
1913 | break ; |
1914 | case verNorway: | |
cf5e94bc | 1915 | lc = wxT("nb_NO") ; |
0e32fdb8 SC |
1916 | break ; |
1917 | case verIsrael: | |
44c44c82 | 1918 | lc = wxT("iw_IL") ; |
0e32fdb8 SC |
1919 | break ; |
1920 | case verJapan: | |
44c44c82 | 1921 | lc = wxT("ja_JP") ; |
0e32fdb8 SC |
1922 | break ; |
1923 | case verAustralia: | |
44c44c82 | 1924 | lc = wxT("en_AU") ; |
0e32fdb8 SC |
1925 | break ; |
1926 | case verArabic: | |
44c44c82 | 1927 | lc = wxT("ar") ; |
0e32fdb8 SC |
1928 | break ; |
1929 | case verFinland: | |
44c44c82 | 1930 | lc = wxT("fi_FI") ; |
0e32fdb8 SC |
1931 | break ; |
1932 | case verFrSwiss: | |
44c44c82 | 1933 | lc = wxT("fr_CH") ; |
0e32fdb8 SC |
1934 | break ; |
1935 | case verGrSwiss: | |
44c44c82 | 1936 | lc = wxT("de_CH") ; |
0e32fdb8 SC |
1937 | break ; |
1938 | case verGreece: | |
44c44c82 | 1939 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
1940 | break ; |
1941 | case verIceland: | |
44c44c82 | 1942 | lc = wxT("is_IS") ; |
0e32fdb8 SC |
1943 | break ; |
1944 | case verMalta: | |
44c44c82 | 1945 | lc = wxT("mt_MT") ; |
0e32fdb8 SC |
1946 | break ; |
1947 | case verCyprus: | |
1948 | // _CY is not part of wx, so we have to translate according to the system language | |
1949 | if ( lang == langGreek ) { | |
44c44c82 | 1950 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
1951 | } |
1952 | else if ( lang == langTurkish ) { | |
44c44c82 | 1953 | lc = wxT("tr_TR") ; |
0e32fdb8 SC |
1954 | } |
1955 | break ; | |
1956 | case verTurkey: | |
44c44c82 | 1957 | lc = wxT("tr_TR") ; |
0e32fdb8 SC |
1958 | break ; |
1959 | case verYugoCroatian: | |
44c44c82 | 1960 | lc = wxT("hr_HR") ; |
0e32fdb8 SC |
1961 | break ; |
1962 | case verIndiaHindi: | |
44c44c82 | 1963 | lc = wxT("hi_IN") ; |
0e32fdb8 SC |
1964 | break ; |
1965 | case verPakistanUrdu: | |
44c44c82 | 1966 | lc = wxT("ur_PK") ; |
0e32fdb8 SC |
1967 | break ; |
1968 | case verTurkishModified: | |
44c44c82 | 1969 | lc = wxT("tr_TR") ; |
0e32fdb8 SC |
1970 | break ; |
1971 | case verItalianSwiss: | |
44c44c82 | 1972 | lc = wxT("it_CH") ; |
0e32fdb8 SC |
1973 | break ; |
1974 | case verInternational: | |
44c44c82 | 1975 | lc = wxT("en") ; |
0e32fdb8 SC |
1976 | break ; |
1977 | case verRomania: | |
44c44c82 | 1978 | lc = wxT("ro_RO") ; |
0e32fdb8 SC |
1979 | break ; |
1980 | case verGreecePoly: | |
44c44c82 | 1981 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
1982 | break ; |
1983 | case verLithuania: | |
44c44c82 | 1984 | lc = wxT("lt_LT") ; |
0e32fdb8 SC |
1985 | break ; |
1986 | case verPoland: | |
44c44c82 | 1987 | lc = wxT("pl_PL") ; |
0e32fdb8 SC |
1988 | break ; |
1989 | case verMagyar : | |
1990 | case verHungary: | |
44c44c82 | 1991 | lc = wxT("hu_HU") ; |
0e32fdb8 SC |
1992 | break ; |
1993 | case verEstonia: | |
44c44c82 | 1994 | lc = wxT("et_EE") ; |
0e32fdb8 SC |
1995 | break ; |
1996 | case verLatvia: | |
44c44c82 | 1997 | lc = wxT("lv_LV") ; |
0e32fdb8 SC |
1998 | break ; |
1999 | case verSami: | |
2000 | // not known | |
2001 | break ; | |
2002 | case verFaroeIsl: | |
44c44c82 | 2003 | lc = wxT("fo_FO") ; |
0e32fdb8 SC |
2004 | break ; |
2005 | case verIran: | |
44c44c82 | 2006 | lc = wxT("fa_IR") ; |
0e32fdb8 SC |
2007 | break ; |
2008 | case verRussia: | |
44c44c82 | 2009 | lc = wxT("ru_RU") ; |
0e32fdb8 SC |
2010 | break ; |
2011 | case verIreland: | |
44c44c82 | 2012 | lc = wxT("ga_IE") ; |
0e32fdb8 SC |
2013 | break ; |
2014 | case verKorea: | |
44c44c82 | 2015 | lc = wxT("ko_KR") ; |
0e32fdb8 SC |
2016 | break ; |
2017 | case verChina: | |
44c44c82 | 2018 | lc = wxT("zh_CN") ; |
0e32fdb8 SC |
2019 | break ; |
2020 | case verTaiwan: | |
44c44c82 | 2021 | lc = wxT("zh_TW") ; |
0e32fdb8 SC |
2022 | break ; |
2023 | case verThailand: | |
44c44c82 | 2024 | lc = wxT("th_TH") ; |
0e32fdb8 SC |
2025 | break ; |
2026 | case verCzech: | |
44c44c82 | 2027 | lc = wxT("cs_CZ") ; |
0e32fdb8 SC |
2028 | break ; |
2029 | case verSlovak: | |
44c44c82 | 2030 | lc = wxT("sk_SK") ; |
0e32fdb8 SC |
2031 | break ; |
2032 | case verBengali: | |
44c44c82 | 2033 | lc = wxT("bn") ; |
0e32fdb8 SC |
2034 | break ; |
2035 | case verByeloRussian: | |
44c44c82 | 2036 | lc = wxT("be_BY") ; |
0e32fdb8 SC |
2037 | break ; |
2038 | case verUkraine: | |
44c44c82 | 2039 | lc = wxT("uk_UA") ; |
0e32fdb8 SC |
2040 | break ; |
2041 | case verGreeceAlt: | |
44c44c82 | 2042 | lc = wxT("el_GR") ; |
0e32fdb8 SC |
2043 | break ; |
2044 | case verSerbian: | |
44c44c82 | 2045 | lc = wxT("sr_YU") ; |
0e32fdb8 SC |
2046 | break ; |
2047 | case verSlovenian: | |
44c44c82 | 2048 | lc = wxT("sl_SI") ; |
0e32fdb8 SC |
2049 | break ; |
2050 | case verMacedonian: | |
44c44c82 | 2051 | lc = wxT("mk_MK") ; |
0e32fdb8 SC |
2052 | break ; |
2053 | case verCroatia: | |
44c44c82 | 2054 | lc = wxT("hr_HR") ; |
0e32fdb8 SC |
2055 | break ; |
2056 | case verBrazil: | |
44c44c82 | 2057 | lc = wxT("pt_BR ") ; |
0e32fdb8 SC |
2058 | break ; |
2059 | case verBulgaria: | |
44c44c82 | 2060 | lc = wxT("bg_BG") ; |
0e32fdb8 SC |
2061 | break ; |
2062 | case verCatalonia: | |
44c44c82 | 2063 | lc = wxT("ca_ES") ; |
0e32fdb8 SC |
2064 | break ; |
2065 | case verScottishGaelic: | |
44c44c82 | 2066 | lc = wxT("gd") ; |
0e32fdb8 SC |
2067 | break ; |
2068 | case verManxGaelic: | |
44c44c82 | 2069 | lc = wxT("gv") ; |
0e32fdb8 SC |
2070 | break ; |
2071 | case verBreton: | |
44c44c82 | 2072 | lc = wxT("br") ; |
0e32fdb8 SC |
2073 | break ; |
2074 | case verNunavut: | |
44c44c82 | 2075 | lc = wxT("iu_CA") ; |
0e32fdb8 SC |
2076 | break ; |
2077 | case verWelsh: | |
44c44c82 | 2078 | lc = wxT("cy") ; |
0e32fdb8 SC |
2079 | break ; |
2080 | case verIrishGaelicScript: | |
44c44c82 | 2081 | lc = wxT("ga_IE") ; |
0e32fdb8 SC |
2082 | break ; |
2083 | case verEngCanada: | |
44c44c82 | 2084 | lc = wxT("en_CA") ; |
0e32fdb8 SC |
2085 | break ; |
2086 | case verBhutan: | |
44c44c82 | 2087 | lc = wxT("dz_BT") ; |
0e32fdb8 SC |
2088 | break ; |
2089 | case verArmenian: | |
44c44c82 | 2090 | lc = wxT("hy_AM") ; |
0e32fdb8 SC |
2091 | break ; |
2092 | case verGeorgian: | |
44c44c82 | 2093 | lc = wxT("ka_GE") ; |
0e32fdb8 SC |
2094 | break ; |
2095 | case verSpLatinAmerica: | |
44c44c82 | 2096 | lc = wxT("es_AR") ; |
0e32fdb8 SC |
2097 | break ; |
2098 | case verTonga: | |
44c44c82 | 2099 | lc = wxT("to_TO" ); |
0e32fdb8 SC |
2100 | break ; |
2101 | case verFrenchUniversal: | |
44c44c82 | 2102 | lc = wxT("fr_FR") ; |
0e32fdb8 SC |
2103 | break ; |
2104 | case verAustria: | |
44c44c82 | 2105 | lc = wxT("de_AT") ; |
0e32fdb8 SC |
2106 | break ; |
2107 | case verGujarati: | |
44c44c82 | 2108 | lc = wxT("gu_IN") ; |
0e32fdb8 SC |
2109 | break ; |
2110 | case verPunjabi: | |
44c44c82 | 2111 | lc = wxT("pa") ; |
0e32fdb8 SC |
2112 | break ; |
2113 | case verIndiaUrdu: | |
44c44c82 | 2114 | lc = wxT("ur_IN") ; |
0e32fdb8 SC |
2115 | break ; |
2116 | case verVietnam: | |
44c44c82 | 2117 | lc = wxT("vi_VN") ; |
0e32fdb8 SC |
2118 | break ; |
2119 | case verFrBelgium: | |
44c44c82 | 2120 | lc = wxT("fr_BE") ; |
0e32fdb8 SC |
2121 | break ; |
2122 | case verUzbek: | |
44c44c82 | 2123 | lc = wxT("uz_UZ") ; |
0e32fdb8 SC |
2124 | break ; |
2125 | case verSingapore: | |
44c44c82 | 2126 | lc = wxT("zh_SG") ; |
0e32fdb8 SC |
2127 | break ; |
2128 | case verNynorsk: | |
44c44c82 | 2129 | lc = wxT("nn_NO") ; |
0e32fdb8 SC |
2130 | break ; |
2131 | case verAfrikaans: | |
44c44c82 | 2132 | lc = wxT("af_ZA") ; |
0e32fdb8 SC |
2133 | break ; |
2134 | case verEsperanto: | |
44c44c82 | 2135 | lc = wxT("eo") ; |
0e32fdb8 SC |
2136 | break ; |
2137 | case verMarathi: | |
44c44c82 | 2138 | lc = wxT("mr_IN") ; |
0e32fdb8 SC |
2139 | break ; |
2140 | case verTibetan: | |
44c44c82 | 2141 | lc = wxT("bo") ; |
0e32fdb8 SC |
2142 | break ; |
2143 | case verNepal: | |
44c44c82 | 2144 | lc = wxT("ne_NP") ; |
0e32fdb8 SC |
2145 | break ; |
2146 | case verGreenland: | |
44c44c82 | 2147 | lc = wxT("kl_GL") ; |
0e32fdb8 SC |
2148 | break ; |
2149 | default : | |
2150 | break ; | |
2151 | } | |
2152 | for ( i = 0; i < count; i++ ) | |
2153 | { | |
2154 | if ( ms_languagesDB->Item(i).CanonicalName == lc ) | |
2155 | { | |
2156 | break; | |
2157 | } | |
2158 | } | |
9e7ed2b0 | 2159 | |
d3f3e35f VS |
2160 | #elif defined(__WIN32__) |
2161 | LCID lcid = GetUserDefaultLCID(); | |
ec37df57 | 2162 | if ( lcid != 0 ) |
d3f3e35f | 2163 | { |
ec37df57 VZ |
2164 | wxUint32 lang = PRIMARYLANGID(LANGIDFROMLCID(lcid)); |
2165 | wxUint32 sublang = SUBLANGID(LANGIDFROMLCID(lcid)); | |
2166 | ||
2167 | for ( i = 0; i < count; i++ ) | |
d3f3e35f | 2168 | { |
41780009 VS |
2169 | if (ms_languagesDB->Item(i).WinLang == lang && |
2170 | ms_languagesDB->Item(i).WinSublang == sublang) | |
ec37df57 VZ |
2171 | { |
2172 | break; | |
2173 | } | |
d3f3e35f VS |
2174 | } |
2175 | } | |
ec37df57 VZ |
2176 | //else: leave wxlang == wxLANGUAGE_UNKNOWN |
2177 | #endif // Unix/Win32 | |
d3f3e35f | 2178 | |
ec37df57 VZ |
2179 | if ( i < count ) |
2180 | { | |
2181 | // we did find a matching entry, use it | |
41780009 | 2182 | return ms_languagesDB->Item(i).Language; |
ec37df57 | 2183 | } |
d3f3e35f | 2184 | |
ec37df57 VZ |
2185 | // no info about this language in the database |
2186 | return wxLANGUAGE_UNKNOWN; | |
2187 | } | |
d3f3e35f | 2188 | |
dccce9ea VZ |
2189 | // ---------------------------------------------------------------------------- |
2190 | // encoding stuff | |
2191 | // ---------------------------------------------------------------------------- | |
2192 | ||
2193 | // this is a bit strange as under Windows we get the encoding name using its | |
2194 | // numeric value and under Unix we do it the other way round, but this just | |
97626624 | 2195 | // reflects the way different systems provide the encoding info |
dccce9ea VZ |
2196 | |
2197 | /* static */ | |
2198 | wxString wxLocale::GetSystemEncodingName() | |
2199 | { | |
2200 | wxString encname; | |
2201 | ||
c67d6888 | 2202 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
dccce9ea VZ |
2203 | // FIXME: what is the error return value for GetACP()? |
2204 | UINT codepage = ::GetACP(); | |
ecffe992 | 2205 | encname.Printf(_T("windows-%u"), codepage); |
1ad48afb SC |
2206 | #elif defined(__WXMAC__) |
2207 | // default is just empty string, this resolves to the default system | |
2208 | // encoding later | |
dccce9ea VZ |
2209 | #elif defined(__UNIX_LIKE__) |
2210 | ||
2211 | #if defined(HAVE_LANGINFO_H) && defined(CODESET) | |
2212 | // GNU libc provides current character set this way (this conforms | |
2213 | // to Unix98) | |
2ec6905c VS |
2214 | char *oldLocale = strdup(setlocale(LC_CTYPE, NULL)); |
2215 | setlocale(LC_CTYPE, ""); | |
f284605f | 2216 | const char *alang = nl_langinfo(CODESET); |
2ec6905c | 2217 | setlocale(LC_CTYPE, oldLocale); |
030c0bea | 2218 | free(oldLocale); |
84f858e9 VZ |
2219 | |
2220 | if ( alang ) | |
dccce9ea | 2221 | { |
84f858e9 VZ |
2222 | // 7 bit ASCII encoding has several alternative names which we should |
2223 | // recognize to avoid warnings about unrecognized encoding on each | |
2224 | // program startup | |
2225 | ||
9cf28550 | 2226 | // nl_langinfo() under Solaris returns 646 by default which stands for |
84f858e9 VZ |
2227 | // ISO-646, i.e. 7 bit ASCII |
2228 | // | |
2229 | // and recent glibc call it ANSI_X3.4-1968... | |
97626624 VZ |
2230 | // |
2231 | // HP-UX uses HP-Roman8 cset which is not the same as ASCII (see RFC | |
2232 | // 1345 for its definition) but must be recognized as otherwise HP | |
2233 | // users get a warning about it on each program startup, so handle it | |
2234 | // here -- but it would be obviously better to add real supprot to it, | |
2235 | // of course! | |
2236 | if ( strcmp(alang, "646") == 0 | |
2237 | || strcmp(alang, "ANSI_X3.4-1968") == 0 | |
2238 | #ifdef __HPUX__ | |
2239 | || strcmp(alang, "roman8") == 0 | |
2240 | #endif // __HPUX__ | |
2241 | ) | |
9cf28550 VZ |
2242 | { |
2243 | encname = _T("US-ASCII"); | |
2244 | } | |
9cf28550 VZ |
2245 | else |
2246 | { | |
b1ac3b56 | 2247 | encname = wxString::FromAscii( alang ); |
9cf28550 | 2248 | } |
dccce9ea VZ |
2249 | } |
2250 | else | |
2251 | #endif // HAVE_LANGINFO_H | |
2252 | { | |
2253 | // if we can't get at the character set directly, try to see if it's in | |
2254 | // the environment variables (in most cases this won't work, but I was | |
2255 | // out of ideas) | |
b1ac3b56 RR |
2256 | char *lang = getenv( "LC_ALL"); |
2257 | char *dot = lang ? strchr(lang, '.') : (char *)NULL; | |
dccce9ea VZ |
2258 | if (!dot) |
2259 | { | |
b1ac3b56 | 2260 | lang = getenv( "LC_CTYPE" ); |
dccce9ea | 2261 | if ( lang ) |
b1ac3b56 | 2262 | dot = strchr(lang, '.' ); |
dccce9ea VZ |
2263 | } |
2264 | if (!dot) | |
2265 | { | |
b1ac3b56 | 2266 | lang = getenv( "LANG"); |
dccce9ea | 2267 | if ( lang ) |
b1ac3b56 | 2268 | dot = strchr(lang, '.'); |
dccce9ea VZ |
2269 | } |
2270 | ||
2271 | if ( dot ) | |
2272 | { | |
b1ac3b56 | 2273 | encname = wxString::FromAscii( dot+1 ); |
dccce9ea VZ |
2274 | } |
2275 | } | |
2276 | #endif // Win32/Unix | |
2277 | ||
2278 | return encname; | |
2279 | } | |
2280 | ||
2281 | /* static */ | |
2282 | wxFontEncoding wxLocale::GetSystemEncoding() | |
2283 | { | |
c67d6888 | 2284 | #if defined(__WIN32__) && !defined(__WXMICROWIN__) |
dccce9ea VZ |
2285 | UINT codepage = ::GetACP(); |
2286 | ||
77ffb593 | 2287 | // wxWidgets only knows about CP1250-1257, 932, 936, 949, 950 |
dccce9ea VZ |
2288 | if ( codepage >= 1250 && codepage <= 1257 ) |
2289 | { | |
2290 | return (wxFontEncoding)(wxFONTENCODING_CP1250 + codepage - 1250); | |
2291 | } | |
c7821f94 VZ |
2292 | |
2293 | if ( codepage == 932 ) | |
2294 | { | |
2295 | return wxFONTENCODING_CP932; | |
2296 | } | |
2297 | ||
2298 | if ( codepage == 936 ) | |
2299 | { | |
2300 | return wxFONTENCODING_CP936; | |
2301 | } | |
2302 | ||
2303 | if ( codepage == 949 ) | |
2304 | { | |
2305 | return wxFONTENCODING_CP949; | |
2306 | } | |
2307 | ||
2308 | if ( codepage == 950 ) | |
2309 | { | |
2310 | return wxFONTENCODING_CP950; | |
2311 | } | |
ec79aded | 2312 | #elif defined(__WXMAC__) |
7beb59f3 | 2313 | TextEncoding encoding = 0 ; |
9e687455 | 2314 | #if TARGET_CARBON |
7beb59f3 | 2315 | encoding = CFStringGetSystemEncoding() ; |
9e687455 | 2316 | #else |
7beb59f3 | 2317 | UpgradeScriptInfoToTextEncoding ( smSystemScript , kTextLanguageDontCare , kTextRegionDontCare , NULL , &encoding ) ; |
9e687455 SC |
2318 | #endif |
2319 | return wxMacGetFontEncFromSystemEnc( encoding ) ; | |
1e6feb95 | 2320 | #elif defined(__UNIX_LIKE__) && wxUSE_FONTMAP |
dccce9ea VZ |
2321 | wxString encname = GetSystemEncodingName(); |
2322 | if ( !encname.empty() ) | |
2323 | { | |
142b3bc2 | 2324 | wxFontEncoding enc = wxFontMapper::Get()-> |
7beb59f3 | 2325 | CharsetToEncoding(encname, false /* not interactive */); |
9cf28550 | 2326 | |
2b5f62a0 VZ |
2327 | // on some modern Linux systems (RedHat 8) the default system locale |
2328 | // is UTF8 -- but it isn't supported by wxGTK in ANSI build at all so | |
2329 | // don't even try to use it in this case | |
2330 | #if !wxUSE_UNICODE | |
2331 | if ( enc == wxFONTENCODING_UTF8 ) | |
2332 | { | |
2333 | // the most similar supported encoding... | |
2334 | enc = wxFONTENCODING_ISO8859_1; | |
2335 | } | |
2336 | #endif // !wxUSE_UNICODE | |
2337 | ||
9cf28550 VZ |
2338 | // this should probably be considered as a bug in CharsetToEncoding(): |
2339 | // it shouldn't return wxFONTENCODING_DEFAULT at all - but it does it | |
2340 | // for US-ASCII charset | |
2341 | // | |
2342 | // we, OTOH, definitely shouldn't return it as it doesn't make sense at | |
2343 | // all (which encoding is it?) | |
2344 | if ( enc != wxFONTENCODING_DEFAULT ) | |
2345 | { | |
2346 | return enc; | |
2347 | } | |
2348 | //else: return wxFONTENCODING_SYSTEM below | |
dccce9ea VZ |
2349 | } |
2350 | #endif // Win32/Unix | |
2351 | ||
2352 | return wxFONTENCODING_SYSTEM; | |
2353 | } | |
2354 | ||
14f8fa9d VZ |
2355 | /* static */ |
2356 | void wxLocale::AddLanguage(const wxLanguageInfo& info) | |
d3f3e35f | 2357 | { |
41780009 VS |
2358 | CreateLanguagesDB(); |
2359 | ms_languagesDB->Add(info); | |
d3f3e35f VS |
2360 | } |
2361 | ||
14f8fa9d VZ |
2362 | /* static */ |
2363 | const wxLanguageInfo *wxLocale::GetLanguageInfo(int lang) | |
2364 | { | |
2365 | CreateLanguagesDB(); | |
2366 | ||
f0ab09cc VZ |
2367 | // calling GetLanguageInfo(wxLANGUAGE_DEFAULT) is a natural thing to do, so |
2368 | // make it work | |
2369 | if ( lang == wxLANGUAGE_DEFAULT ) | |
2370 | lang = GetSystemLanguage(); | |
2371 | ||
9d1e1be4 | 2372 | const size_t count = ms_languagesDB->GetCount(); |
14f8fa9d VZ |
2373 | for ( size_t i = 0; i < count; i++ ) |
2374 | { | |
2375 | if ( ms_languagesDB->Item(i).Language == lang ) | |
2376 | { | |
2377 | return &ms_languagesDB->Item(i); | |
2378 | } | |
2379 | } | |
2380 | ||
2381 | return NULL; | |
2382 | } | |
2383 | ||
4a6e4a46 VS |
2384 | /* static */ |
2385 | wxString wxLocale::GetLanguageName(int lang) | |
2386 | { | |
2387 | const wxLanguageInfo *info = GetLanguageInfo(lang); | |
2388 | if ( !info ) | |
2389 | return wxEmptyString; | |
2390 | else | |
2391 | return info->Description; | |
2392 | } | |
2393 | ||
9d1e1be4 VZ |
2394 | /* static */ |
2395 | const wxLanguageInfo *wxLocale::FindLanguageInfo(const wxString& locale) | |
2396 | { | |
2397 | CreateLanguagesDB(); | |
2398 | ||
2399 | const wxLanguageInfo *infoRet = NULL; | |
2400 | ||
2401 | const size_t count = ms_languagesDB->GetCount(); | |
2402 | for ( size_t i = 0; i < count; i++ ) | |
2403 | { | |
2404 | const wxLanguageInfo *info = &ms_languagesDB->Item(i); | |
2405 | ||
2406 | if ( wxStricmp(locale, info->CanonicalName) == 0 || | |
2407 | wxStricmp(locale, info->Description) == 0 ) | |
2408 | { | |
2409 | // exact match, stop searching | |
2410 | infoRet = info; | |
2411 | break; | |
2412 | } | |
2413 | ||
2414 | if ( wxStricmp(locale, info->CanonicalName.BeforeFirst(_T('_'))) == 0 ) | |
2415 | { | |
2416 | // a match -- but maybe we'll find an exact one later, so continue | |
2417 | // looking | |
2418 | // | |
2419 | // OTOH, maybe we had already found a language match and in this | |
2420 | // case don't overwrite it becauce the entry for the default | |
2421 | // country always appears first in ms_languagesDB | |
2422 | if ( !infoRet ) | |
2423 | infoRet = info; | |
2424 | } | |
2425 | } | |
2426 | ||
2427 | return infoRet; | |
2428 | } | |
2429 | ||
d3f3e35f VS |
2430 | wxString wxLocale::GetSysName() const |
2431 | { | |
1c193821 JS |
2432 | // FIXME |
2433 | #ifndef __WXWINCE__ | |
d3f3e35f | 2434 | return wxSetlocale(LC_ALL, NULL); |
1c193821 JS |
2435 | #else |
2436 | return wxEmptyString; | |
2437 | #endif | |
d3f3e35f VS |
2438 | } |
2439 | ||
c801d85f KB |
2440 | // clean up |
2441 | wxLocale::~wxLocale() | |
2442 | { | |
fd323a5e VZ |
2443 | // free memory |
2444 | wxMsgCatalog *pTmpCat; | |
2445 | while ( m_pMsgCat != NULL ) { | |
2446 | pTmpCat = m_pMsgCat; | |
2447 | m_pMsgCat = m_pMsgCat->m_pNext; | |
2448 | delete pTmpCat; | |
2449 | } | |
2450 | ||
eb48778d VZ |
2451 | // restore old locale pointer |
2452 | wxSetLocale(m_pOldLocale); | |
bea561ce | 2453 | |
1c193821 JS |
2454 | // FIXME |
2455 | #ifndef __WXWINCE__ | |
e36e6f95 | 2456 | wxSetlocale(LC_ALL, m_pszOldLocale); |
1c193821 | 2457 | #endif |
10545ca4 | 2458 | free((wxChar *)m_pszOldLocale); // const_cast |
c801d85f KB |
2459 | } |
2460 | ||
2461 | // get the translation of given string in current locale | |
563d535e VS |
2462 | const wxChar *wxLocale::GetString(const wxChar *szOrigString, |
2463 | const wxChar *szDomain) const | |
849a28d0 VS |
2464 | { |
2465 | return GetString(szOrigString, szOrigString, size_t(-1), szDomain); | |
2466 | } | |
2467 | ||
2468 | const wxChar *wxLocale::GetString(const wxChar *szOrigString, | |
2469 | const wxChar *szOrigString2, | |
2470 | size_t n, | |
2471 | const wxChar *szDomain) const | |
c801d85f | 2472 | { |
563d535e | 2473 | if ( wxIsEmpty(szOrigString) ) |
849a28d0 | 2474 | return wxEmptyString; |
c801d85f | 2475 | |
563d535e VS |
2476 | const wxChar *pszTrans = NULL; |
2477 | wxMsgCatalog *pMsgCat; | |
7af89395 | 2478 | |
9e7ed2b0 | 2479 | if ( szDomain != NULL ) |
563d535e VS |
2480 | { |
2481 | pMsgCat = FindCatalog(szDomain); | |
2482 | ||
2483 | // does the catalog exist? | |
2484 | if ( pMsgCat != NULL ) | |
849a28d0 | 2485 | pszTrans = pMsgCat->GetString(szOrigString, n); |
563d535e | 2486 | } |
9e7ed2b0 | 2487 | else |
563d535e VS |
2488 | { |
2489 | // search in all domains | |
9e7ed2b0 | 2490 | for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) |
563d535e | 2491 | { |
849a28d0 | 2492 | pszTrans = pMsgCat->GetString(szOrigString, n); |
563d535e VS |
2493 | if ( pszTrans != NULL ) // take the first found |
2494 | break; | |
2495 | } | |
c801d85f KB |
2496 | } |
2497 | ||
9e7ed2b0 | 2498 | if ( pszTrans == NULL ) |
563d535e VS |
2499 | { |
2500 | #ifdef __WXDEBUG__ | |
9e7ed2b0 | 2501 | if ( !NoTransErr::Suppress() ) |
563d535e VS |
2502 | { |
2503 | NoTransErr noTransErr; | |
e90c1d2a | 2504 | |
563d535e VS |
2505 | if ( szDomain != NULL ) |
2506 | { | |
45e97ca0 | 2507 | wxLogTrace(_T("i18n"), |
3aefa658 VS |
2508 | _T("string '%s'[%lu] not found in domain '%s' for locale '%s'."), |
2509 | szOrigString, (unsigned long)n, | |
2510 | szDomain, m_strLocale.c_str()); | |
849a28d0 | 2511 | |
563d535e VS |
2512 | } |
2513 | else | |
2514 | { | |
45e97ca0 | 2515 | wxLogTrace(_T("i18n"), |
3aefa658 VS |
2516 | _T("string '%s'[%lu] not found in locale '%s'."), |
2517 | szOrigString, (unsigned long)n, m_strLocale.c_str()); | |
563d535e VS |
2518 | } |
2519 | } | |
2520 | #endif // __WXDEBUG__ | |
12419383 | 2521 | |
849a28d0 VS |
2522 | if (n == size_t(-1)) |
2523 | return szOrigString; | |
2524 | else | |
2525 | return n == 1 ? szOrigString : szOrigString2; | |
563d535e | 2526 | } |
12419383 | 2527 | |
563d535e | 2528 | return pszTrans; |
c801d85f KB |
2529 | } |
2530 | ||
c48908df VZ |
2531 | wxString wxLocale::GetHeaderValue( const wxChar* szHeader, |
2532 | const wxChar* szDomain ) const | |
2533 | { | |
e6bf9573 | 2534 | if ( wxIsEmpty(szHeader) ) |
c48908df VZ |
2535 | return wxEmptyString; |
2536 | ||
2537 | wxChar const * pszTrans = NULL; | |
2538 | wxMsgCatalog *pMsgCat; | |
2539 | ||
2540 | if ( szDomain != NULL ) | |
2541 | { | |
2542 | pMsgCat = FindCatalog(szDomain); | |
2543 | ||
2544 | // does the catalog exist? | |
2545 | if ( pMsgCat == NULL ) | |
2546 | return wxEmptyString; | |
2547 | ||
2548 | pszTrans = pMsgCat->GetString(wxT(""), (size_t)-1); | |
2549 | } | |
2550 | else | |
2551 | { | |
2552 | // search in all domains | |
2553 | for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) | |
2554 | { | |
2555 | pszTrans = pMsgCat->GetString(wxT(""), (size_t)-1); | |
2556 | if ( pszTrans != NULL ) // take the first found | |
2557 | break; | |
2558 | } | |
2559 | } | |
2560 | ||
2561 | if ( wxIsEmpty(pszTrans) ) | |
2562 | return wxEmptyString; | |
2563 | ||
e6bf9573 | 2564 | wxChar const * pszFound = wxStrstr(pszTrans, szHeader); |
c48908df VZ |
2565 | if ( pszFound == NULL ) |
2566 | return wxEmptyString; | |
7beb59f3 | 2567 | |
e6bf9573 | 2568 | pszFound += wxStrlen(szHeader) + 2 /* ': ' */; |
c48908df VZ |
2569 | |
2570 | // Every header is separated by \n | |
7beb59f3 | 2571 | |
c48908df VZ |
2572 | wxChar const * pszEndLine = wxStrchr(pszFound, wxT('\n')); |
2573 | if ( pszEndLine == NULL ) pszEndLine = pszFound + wxStrlen(pszFound); | |
2574 | ||
2575 | ||
2576 | // wxString( wxChar*, length); | |
2577 | wxString retVal( pszFound, pszEndLine - pszFound ); | |
2578 | ||
2579 | return retVal; | |
2580 | } | |
2581 | ||
2582 | ||
c801d85f | 2583 | // find catalog by name in a linked list, return NULL if !found |
e36e6f95 | 2584 | wxMsgCatalog *wxLocale::FindCatalog(const wxChar *szDomain) const |
c801d85f | 2585 | { |
563d535e VS |
2586 | // linear search in the linked list |
2587 | wxMsgCatalog *pMsgCat; | |
9e7ed2b0 | 2588 | for ( pMsgCat = m_pMsgCat; pMsgCat != NULL; pMsgCat = pMsgCat->m_pNext ) |
563d535e VS |
2589 | { |
2590 | if ( wxStricmp(pMsgCat->GetName(), szDomain) == 0 ) | |
2591 | return pMsgCat; | |
2592 | } | |
7af89395 | 2593 | |
563d535e | 2594 | return NULL; |
c801d85f KB |
2595 | } |
2596 | ||
2597 | // check if the given catalog is loaded | |
e36e6f95 | 2598 | bool wxLocale::IsLoaded(const wxChar *szDomain) const |
c801d85f KB |
2599 | { |
2600 | return FindCatalog(szDomain) != NULL; | |
2601 | } | |
2602 | ||
2603 | // add a catalog to our linked list | |
e36e6f95 | 2604 | bool wxLocale::AddCatalog(const wxChar *szDomain) |
d721baa9 VS |
2605 | { |
2606 | return AddCatalog(szDomain, wxLANGUAGE_ENGLISH, NULL); | |
2607 | } | |
2608 | ||
2609 | // add a catalog to our linked list | |
2610 | bool wxLocale::AddCatalog(const wxChar *szDomain, | |
2611 | wxLanguage msgIdLanguage, | |
2612 | const wxChar *msgIdCharset) | |
2613 | ||
c801d85f KB |
2614 | { |
2615 | wxMsgCatalog *pMsgCat = new wxMsgCatalog; | |
7af89395 | 2616 | |
d721baa9 | 2617 | if ( pMsgCat->Load(m_strShort, szDomain, msgIdCharset, m_bConvertEncoding) ) { |
c801d85f KB |
2618 | // add it to the head of the list so that in GetString it will |
2619 | // be searched before the catalogs added earlier | |
2620 | pMsgCat->m_pNext = m_pMsgCat; | |
2621 | m_pMsgCat = pMsgCat; | |
7af89395 | 2622 | |
d721baa9 | 2623 | return true; |
c801d85f KB |
2624 | } |
2625 | else { | |
2626 | // don't add it because it couldn't be loaded anyway | |
2627 | delete pMsgCat; | |
7af89395 | 2628 | |
d721baa9 VS |
2629 | // It is OK to not load catalog if the msgid language and m_language match, |
2630 | // in which case we can directly display the texts embedded in program's | |
2631 | // source code: | |
2632 | if (m_language == msgIdLanguage) | |
2633 | return true; | |
395a6701 | 2634 | |
d721baa9 VS |
2635 | // If there's no exact match, we may still get partial match where the |
2636 | // (basic) language is same, but the country differs. For example, it's | |
2637 | // permitted to use en_US strings from sources even if m_language is en_GB: | |
2638 | const wxLanguageInfo *msgIdLangInfo = GetLanguageInfo(msgIdLanguage); | |
2639 | if ( msgIdLangInfo && | |
2640 | msgIdLangInfo->CanonicalName.Mid(0, 2) == m_strShort.Mid(0, 2) ) | |
2641 | { | |
2642 | return true; | |
2643 | } | |
2644 | ||
2645 | return false; | |
c801d85f KB |
2646 | } |
2647 | } | |
2648 | ||
cfb20656 VZ |
2649 | // ---------------------------------------------------------------------------- |
2650 | // accessors for locale-dependent data | |
2651 | // ---------------------------------------------------------------------------- | |
2652 | ||
2653 | #ifdef __WXMSW__ | |
2654 | ||
2655 | /* static */ | |
3fe73755 | 2656 | wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory WXUNUSED(cat)) |
cfb20656 VZ |
2657 | { |
2658 | wxString str; | |
2659 | wxChar buffer[256]; | |
2660 | size_t count; | |
2661 | buffer[0] = wxT('\0'); | |
2662 | switch (index) | |
2663 | { | |
60d876f3 | 2664 | case wxLOCALE_DECIMAL_POINT: |
cfb20656 VZ |
2665 | count = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, buffer, 256); |
2666 | if (!count) | |
1e8bd6b2 | 2667 | str << wxT("."); |
cfb20656 VZ |
2668 | else |
2669 | str << buffer; | |
2670 | break; | |
60d876f3 | 2671 | #if 0 |
cfb20656 VZ |
2672 | case wxSYS_LIST_SEPARATOR: |
2673 | count = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SLIST, buffer, 256); | |
2674 | if (!count) | |
1e8bd6b2 | 2675 | str << wxT(","); |
cfb20656 VZ |
2676 | else |
2677 | str << buffer; | |
2678 | break; | |
2679 | case wxSYS_LEADING_ZERO: // 0 means no leading zero, 1 means leading zero | |
2680 | count = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILZERO, buffer, 256); | |
2681 | if (!count) | |
1e8bd6b2 | 2682 | str << wxT("0"); |
cfb20656 VZ |
2683 | else |
2684 | str << buffer; | |
2685 | break; | |
60d876f3 | 2686 | #endif |
cfb20656 | 2687 | default: |
1e8bd6b2 | 2688 | wxFAIL_MSG(wxT("Unknown System String !")); |
cfb20656 VZ |
2689 | } |
2690 | return str; | |
2691 | } | |
2692 | ||
2693 | #else // !__WXMSW__ | |
2694 | ||
2695 | /* static */ | |
60d876f3 | 2696 | wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory cat) |
cfb20656 | 2697 | { |
60d876f3 SN |
2698 | struct lconv *locale_info = localeconv(); |
2699 | switch (cat) | |
2700 | { | |
2701 | case wxLOCALE_CAT_NUMBER: | |
2702 | switch (index) | |
2703 | { | |
2704 | case wxLOCALE_THOUSANDS_SEP: | |
3fe73755 SN |
2705 | return wxString(locale_info->thousands_sep, |
2706 | *wxConvCurrent); | |
60d876f3 | 2707 | case wxLOCALE_DECIMAL_POINT: |
3fe73755 SN |
2708 | return wxString(locale_info->decimal_point, |
2709 | *wxConvCurrent); | |
60d876f3 SN |
2710 | default: |
2711 | return wxEmptyString; | |
2712 | } | |
2713 | case wxLOCALE_CAT_MONEY: | |
2714 | switch (index) | |
2715 | { | |
2716 | case wxLOCALE_THOUSANDS_SEP: | |
3fe73755 SN |
2717 | return wxString(locale_info->mon_thousands_sep, |
2718 | *wxConvCurrent); | |
60d876f3 | 2719 | case wxLOCALE_DECIMAL_POINT: |
3fe73755 SN |
2720 | return wxString(locale_info->mon_decimal_point, |
2721 | *wxConvCurrent); | |
60d876f3 SN |
2722 | default: |
2723 | return wxEmptyString; | |
2724 | } | |
2725 | default: | |
2726 | return wxEmptyString; | |
2727 | } | |
b7b97e77 | 2728 | } |
cfb20656 VZ |
2729 | |
2730 | #endif // __WXMSW__/!__WXMSW__ | |
2731 | ||
c801d85f KB |
2732 | // ---------------------------------------------------------------------------- |
2733 | // global functions and variables | |
2734 | // ---------------------------------------------------------------------------- | |
2735 | ||
c801d85f KB |
2736 | // retrieve/change current locale |
2737 | // ------------------------------ | |
2738 | ||
2739 | // the current locale object | |
84c18814 | 2740 | static wxLocale *g_pLocale = NULL; |
c801d85f | 2741 | |
1678ad78 GL |
2742 | wxLocale *wxGetLocale() |
2743 | { | |
7af89395 | 2744 | return g_pLocale; |
1678ad78 GL |
2745 | } |
2746 | ||
c801d85f KB |
2747 | wxLocale *wxSetLocale(wxLocale *pLocale) |
2748 | { | |
7af89395 VZ |
2749 | wxLocale *pOld = g_pLocale; |
2750 | g_pLocale = pLocale; | |
2751 | return pOld; | |
c801d85f | 2752 | } |
d427503c | 2753 | |
41780009 VS |
2754 | |
2755 | ||
2756 | // ---------------------------------------------------------------------------- | |
2757 | // wxLocale module (for lazy destruction of languagesDB) | |
2758 | // ---------------------------------------------------------------------------- | |
2759 | ||
2760 | class wxLocaleModule: public wxModule | |
2761 | { | |
2762 | DECLARE_DYNAMIC_CLASS(wxLocaleModule) | |
2763 | public: | |
2764 | wxLocaleModule() {} | |
7beb59f3 | 2765 | bool OnInit() { return true; } |
41780009 VS |
2766 | void OnExit() { wxLocale::DestroyLanguagesDB(); } |
2767 | }; | |
2768 | ||
2769 | IMPLEMENT_DYNAMIC_CLASS(wxLocaleModule, wxModule) | |
2770 | ||
2771 | ||
2772 | ||
d3f3e35f VS |
2773 | // ---------------------------------------------------------------------------- |
2774 | // default languages table & initialization | |
2775 | // ---------------------------------------------------------------------------- | |
2776 | ||
865a1730 | 2777 | |
41780009 VS |
2778 | |
2779 | // --- --- --- generated code begins here --- --- --- | |
2780 | ||
d3f3e35f VS |
2781 | // This table is generated by misc/languages/genlang.py |
2782 | // When making changes, please put them into misc/languages/langtabl.txt | |
2783 | ||
04ef50df | 2784 | #if !defined(__WIN32__) || defined(__WXMICROWIN__) |
63986ba6 VS |
2785 | |
2786 | #define SETWINLANG(info,lang,sublang) | |
2787 | ||
2788 | #else | |
2789 | ||
d3f3e35f VS |
2790 | #define SETWINLANG(info,lang,sublang) \ |
2791 | info.WinLang = lang, info.WinSublang = sublang; | |
63986ba6 VS |
2792 | |
2793 | #ifndef LANG_AFRIKAANS | |
2794 | #define LANG_AFRIKAANS (0) | |
2795 | #endif | |
2796 | #ifndef LANG_ALBANIAN | |
2797 | #define LANG_ALBANIAN (0) | |
2798 | #endif | |
2799 | #ifndef LANG_ARABIC | |
2800 | #define LANG_ARABIC (0) | |
2801 | #endif | |
2802 | #ifndef LANG_ARMENIAN | |
2803 | #define LANG_ARMENIAN (0) | |
2804 | #endif | |
2805 | #ifndef LANG_ASSAMESE | |
2806 | #define LANG_ASSAMESE (0) | |
2807 | #endif | |
2808 | #ifndef LANG_AZERI | |
2809 | #define LANG_AZERI (0) | |
2810 | #endif | |
2811 | #ifndef LANG_BASQUE | |
2812 | #define LANG_BASQUE (0) | |
2813 | #endif | |
2814 | #ifndef LANG_BELARUSIAN | |
2815 | #define LANG_BELARUSIAN (0) | |
2816 | #endif | |
2817 | #ifndef LANG_BENGALI | |
2818 | #define LANG_BENGALI (0) | |
2819 | #endif | |
2820 | #ifndef LANG_BULGARIAN | |
2821 | #define LANG_BULGARIAN (0) | |
2822 | #endif | |
2823 | #ifndef LANG_CATALAN | |
2824 | #define LANG_CATALAN (0) | |
2825 | #endif | |
2826 | #ifndef LANG_CHINESE | |
2827 | #define LANG_CHINESE (0) | |
2828 | #endif | |
2829 | #ifndef LANG_CROATIAN | |
2830 | #define LANG_CROATIAN (0) | |
2831 | #endif | |
2832 | #ifndef LANG_CZECH | |
2833 | #define LANG_CZECH (0) | |
2834 | #endif | |
2835 | #ifndef LANG_DANISH | |
2836 | #define LANG_DANISH (0) | |
2837 | #endif | |
2838 | #ifndef LANG_DUTCH | |
2839 | #define LANG_DUTCH (0) | |
2840 | #endif | |
2841 | #ifndef LANG_ENGLISH | |
2842 | #define LANG_ENGLISH (0) | |
2843 | #endif | |
2844 | #ifndef LANG_ESTONIAN | |
2845 | #define LANG_ESTONIAN (0) | |
2846 | #endif | |
2847 | #ifndef LANG_FAEROESE | |
2848 | #define LANG_FAEROESE (0) | |
2849 | #endif | |
2850 | #ifndef LANG_FARSI | |
2851 | #define LANG_FARSI (0) | |
2852 | #endif | |
2853 | #ifndef LANG_FINNISH | |
2854 | #define LANG_FINNISH (0) | |
2855 | #endif | |
2856 | #ifndef LANG_FRENCH | |
2857 | #define LANG_FRENCH (0) | |
2858 | #endif | |
2859 | #ifndef LANG_GEORGIAN | |
2860 | #define LANG_GEORGIAN (0) | |
2861 | #endif | |
2862 | #ifndef LANG_GERMAN | |
2863 | #define LANG_GERMAN (0) | |
2864 | #endif | |
2865 | #ifndef LANG_GREEK | |
2866 | #define LANG_GREEK (0) | |
2867 | #endif | |
2868 | #ifndef LANG_GUJARATI | |
2869 | #define LANG_GUJARATI (0) | |
2870 | #endif | |
2871 | #ifndef LANG_HEBREW | |
2872 | #define LANG_HEBREW (0) | |
2873 | #endif | |
2874 | #ifndef LANG_HINDI | |
2875 | #define LANG_HINDI (0) | |
2876 | #endif | |
2877 | #ifndef LANG_HUNGARIAN | |
2878 | #define LANG_HUNGARIAN (0) | |
2879 | #endif | |
2880 | #ifndef LANG_ICELANDIC | |
2881 | #define LANG_ICELANDIC (0) | |
2882 | #endif | |
2883 | #ifndef LANG_INDONESIAN | |
2884 | #define LANG_INDONESIAN (0) | |
2885 | #endif | |
2886 | #ifndef LANG_ITALIAN | |
2887 | #define LANG_ITALIAN (0) | |
2888 | #endif | |
2889 | #ifndef LANG_JAPANESE | |
2890 | #define LANG_JAPANESE (0) | |
2891 | #endif | |
2892 | #ifndef LANG_KANNADA | |
2893 | #define LANG_KANNADA (0) | |
2894 | #endif | |
2895 | #ifndef LANG_KASHMIRI | |
2896 | #define LANG_KASHMIRI (0) | |
2897 | #endif | |
2898 | #ifndef LANG_KAZAK | |
2899 | #define LANG_KAZAK (0) | |
2900 | #endif | |
2901 | #ifndef LANG_KONKANI | |
2902 | #define LANG_KONKANI (0) | |
2903 | #endif | |
2904 | #ifndef LANG_KOREAN | |
2905 | #define LANG_KOREAN (0) | |
2906 | #endif | |
2907 | #ifndef LANG_LATVIAN | |
2908 | #define LANG_LATVIAN (0) | |
2909 | #endif | |
2910 | #ifndef LANG_LITHUANIAN | |
2911 | #define LANG_LITHUANIAN (0) | |
2912 | #endif | |
2913 | #ifndef LANG_MACEDONIAN | |
2914 | #define LANG_MACEDONIAN (0) | |
2915 | #endif | |
2916 | #ifndef LANG_MALAY | |
2917 | #define LANG_MALAY (0) | |
2918 | #endif | |
2919 | #ifndef LANG_MALAYALAM | |
2920 | #define LANG_MALAYALAM (0) | |
2921 | #endif | |
2922 | #ifndef LANG_MANIPURI | |
2923 | #define LANG_MANIPURI (0) | |
2924 | #endif | |
2925 | #ifndef LANG_MARATHI | |
2926 | #define LANG_MARATHI (0) | |
2927 | #endif | |
2928 | #ifndef LANG_NEPALI | |
2929 | #define LANG_NEPALI (0) | |
2930 | #endif | |
2931 | #ifndef LANG_NORWEGIAN | |
2932 | #define LANG_NORWEGIAN (0) | |
2933 | #endif | |
2934 | #ifndef LANG_ORIYA | |
2935 | #define LANG_ORIYA (0) | |
2936 | #endif | |
2937 | #ifndef LANG_POLISH | |
2938 | #define LANG_POLISH (0) | |
2939 | #endif | |
2940 | #ifndef LANG_PORTUGUESE | |
2941 | #define LANG_PORTUGUESE (0) | |
2942 | #endif | |
2943 | #ifndef LANG_PUNJABI | |
2944 | #define LANG_PUNJABI (0) | |
2945 | #endif | |
2946 | #ifndef LANG_ROMANIAN | |
2947 | #define LANG_ROMANIAN (0) | |
2948 | #endif | |
2949 | #ifndef LANG_RUSSIAN | |
2950 | #define LANG_RUSSIAN (0) | |
2951 | #endif | |
2952 | #ifndef LANG_SANSKRIT | |
2953 | #define LANG_SANSKRIT (0) | |
2954 | #endif | |
2955 | #ifndef LANG_SERBIAN | |
2956 | #define LANG_SERBIAN (0) | |
2957 | #endif | |
2958 | #ifndef LANG_SINDHI | |
2959 | #define LANG_SINDHI (0) | |
2960 | #endif | |
2961 | #ifndef LANG_SLOVAK | |
2962 | #define LANG_SLOVAK (0) | |
2963 | #endif | |
2964 | #ifndef LANG_SLOVENIAN | |
2965 | #define LANG_SLOVENIAN (0) | |
2966 | #endif | |
2967 | #ifndef LANG_SPANISH | |
2968 | #define LANG_SPANISH (0) | |
2969 | #endif | |
2970 | #ifndef LANG_SWAHILI | |
2971 | #define LANG_SWAHILI (0) | |
2972 | #endif | |
2973 | #ifndef LANG_SWEDISH | |
2974 | #define LANG_SWEDISH (0) | |
2975 | #endif | |
2976 | #ifndef LANG_TAMIL | |
2977 | #define LANG_TAMIL (0) | |
2978 | #endif | |
2979 | #ifndef LANG_TATAR | |
2980 | #define LANG_TATAR (0) | |
2981 | #endif | |
2982 | #ifndef LANG_TELUGU | |
2983 | #define LANG_TELUGU (0) | |
2984 | #endif | |
2985 | #ifndef LANG_THAI | |
2986 | #define LANG_THAI (0) | |
2987 | #endif | |
2988 | #ifndef LANG_TURKISH | |
2989 | #define LANG_TURKISH (0) | |
2990 | #endif | |
2991 | #ifndef LANG_UKRAINIAN | |
2992 | #define LANG_UKRAINIAN (0) | |
2993 | #endif | |
2994 | #ifndef LANG_URDU | |
2995 | #define LANG_URDU (0) | |
2996 | #endif | |
2997 | #ifndef LANG_UZBEK | |
2998 | #define LANG_UZBEK (0) | |
2999 | #endif | |
3000 | #ifndef LANG_VIETNAMESE | |
3001 | #define LANG_VIETNAMESE (0) | |
3002 | #endif | |
3003 | #ifndef SUBLANG_ARABIC_ALGERIA | |
3004 | #define SUBLANG_ARABIC_ALGERIA SUBLANG_DEFAULT | |
3005 | #endif | |
3006 | #ifndef SUBLANG_ARABIC_BAHRAIN | |
3007 | #define SUBLANG_ARABIC_BAHRAIN SUBLANG_DEFAULT | |
3008 | #endif | |
3009 | #ifndef SUBLANG_ARABIC_EGYPT | |
3010 | #define SUBLANG_ARABIC_EGYPT SUBLANG_DEFAULT | |
3011 | #endif | |
3012 | #ifndef SUBLANG_ARABIC_IRAQ | |
3013 | #define SUBLANG_ARABIC_IRAQ SUBLANG_DEFAULT | |
3014 | #endif | |
3015 | #ifndef SUBLANG_ARABIC_JORDAN | |
3016 | #define SUBLANG_ARABIC_JORDAN SUBLANG_DEFAULT | |
3017 | #endif | |
3018 | #ifndef SUBLANG_ARABIC_KUWAIT | |
3019 | #define SUBLANG_ARABIC_KUWAIT SUBLANG_DEFAULT | |
3020 | #endif | |
3021 | #ifndef SUBLANG_ARABIC_LEBANON | |
3022 | #define SUBLANG_ARABIC_LEBANON SUBLANG_DEFAULT | |
3023 | #endif | |
3024 | #ifndef SUBLANG_ARABIC_LIBYA | |
3025 | #define SUBLANG_ARABIC_LIBYA SUBLANG_DEFAULT | |
3026 | #endif | |
3027 | #ifndef SUBLANG_ARABIC_MOROCCO | |
3028 | #define SUBLANG_ARABIC_MOROCCO SUBLANG_DEFAULT | |
3029 | #endif | |
3030 | #ifndef SUBLANG_ARABIC_OMAN | |
3031 | #define SUBLANG_ARABIC_OMAN SUBLANG_DEFAULT | |
3032 | #endif | |
3033 | #ifndef SUBLANG_ARABIC_QATAR | |
3034 | #define SUBLANG_ARABIC_QATAR SUBLANG_DEFAULT | |
3035 | #endif | |
3036 | #ifndef SUBLANG_ARABIC_SAUDI_ARABIA | |
3037 | #define SUBLANG_ARABIC_SAUDI_ARABIA SUBLANG_DEFAULT | |
3038 | #endif | |
3039 | #ifndef SUBLANG_ARABIC_SYRIA | |
3040 | #define SUBLANG_ARABIC_SYRIA SUBLANG_DEFAULT | |
3041 | #endif | |
3042 | #ifndef SUBLANG_ARABIC_TUNISIA | |
3043 | #define SUBLANG_ARABIC_TUNISIA SUBLANG_DEFAULT | |
3044 | #endif | |
3045 | #ifndef SUBLANG_ARABIC_UAE | |
3046 | #define SUBLANG_ARABIC_UAE SUBLANG_DEFAULT | |
3047 | #endif | |
3048 | #ifndef SUBLANG_ARABIC_YEMEN | |
3049 | #define SUBLANG_ARABIC_YEMEN SUBLANG_DEFAULT | |
3050 | #endif | |
3051 | #ifndef SUBLANG_AZERI_CYRILLIC | |
3052 | #define SUBLANG_AZERI_CYRILLIC SUBLANG_DEFAULT | |
3053 | #endif | |
3054 | #ifndef SUBLANG_AZERI_LATIN | |
3055 | #define SUBLANG_AZERI_LATIN SUBLANG_DEFAULT | |
3056 | #endif | |
3057 | #ifndef SUBLANG_CHINESE_SIMPLIFIED | |
3058 | #define SUBLANG_CHINESE_SIMPLIFIED SUBLANG_DEFAULT | |
3059 | #endif | |
3060 | #ifndef SUBLANG_CHINESE_TRADITIONAL | |
3061 | #define SUBLANG_CHINESE_TRADITIONAL SUBLANG_DEFAULT | |
3062 | #endif | |
3063 | #ifndef SUBLANG_CHINESE_HONGKONG | |
3064 | #define SUBLANG_CHINESE_HONGKONG SUBLANG_DEFAULT | |
3065 | #endif | |
3066 | #ifndef SUBLANG_CHINESE_MACAU | |
3067 | #define SUBLANG_CHINESE_MACAU SUBLANG_DEFAULT | |
3068 | #endif | |
3069 | #ifndef SUBLANG_CHINESE_SINGAPORE | |
3070 | #define SUBLANG_CHINESE_SINGAPORE SUBLANG_DEFAULT | |
3071 | #endif | |
3072 | #ifndef SUBLANG_DUTCH | |
3073 | #define SUBLANG_DUTCH SUBLANG_DEFAULT | |
3074 | #endif | |
3075 | #ifndef SUBLANG_DUTCH_BELGIAN | |
3076 | #define SUBLANG_DUTCH_BELGIAN SUBLANG_DEFAULT | |
3077 | #endif | |
3078 | #ifndef SUBLANG_ENGLISH_UK | |
3079 | #define SUBLANG_ENGLISH_UK SUBLANG_DEFAULT | |
3080 | #endif | |
3081 | #ifndef SUBLANG_ENGLISH_US | |
3082 | #define SUBLANG_ENGLISH_US SUBLANG_DEFAULT | |
3083 | #endif | |
3084 | #ifndef SUBLANG_ENGLISH_AUS | |
3085 | #define SUBLANG_ENGLISH_AUS SUBLANG_DEFAULT | |
3086 | #endif | |
3087 | #ifndef SUBLANG_ENGLISH_BELIZE | |
3088 | #define SUBLANG_ENGLISH_BELIZE SUBLANG_DEFAULT | |
3089 | #endif | |
3090 | #ifndef SUBLANG_ENGLISH_CAN | |
3091 | #define SUBLANG_ENGLISH_CAN SUBLANG_DEFAULT | |
3092 | #endif | |
3093 | #ifndef SUBLANG_ENGLISH_CARIBBEAN | |
3094 | #define SUBLANG_ENGLISH_CARIBBEAN SUBLANG_DEFAULT | |
3095 | #endif | |
3096 | #ifndef SUBLANG_ENGLISH_EIRE | |
3097 | #define SUBLANG_ENGLISH_EIRE SUBLANG_DEFAULT | |
3098 | #endif | |
3099 | #ifndef SUBLANG_ENGLISH_JAMAICA | |
3100 | #define SUBLANG_ENGLISH_JAMAICA SUBLANG_DEFAULT | |
3101 | #endif | |
3102 | #ifndef SUBLANG_ENGLISH_NZ | |
3103 | #define SUBLANG_ENGLISH_NZ SUBLANG_DEFAULT | |
3104 | #endif | |
3105 | #ifndef SUBLANG_ENGLISH_PHILIPPINES | |
3106 | #define SUBLANG_ENGLISH_PHILIPPINES SUBLANG_DEFAULT | |
3107 | #endif | |
3108 | #ifndef SUBLANG_ENGLISH_SOUTH_AFRICA | |
3109 | #define SUBLANG_ENGLISH_SOUTH_AFRICA SUBLANG_DEFAULT | |
3110 | #endif | |
3111 | #ifndef SUBLANG_ENGLISH_TRINIDAD | |
3112 | #define SUBLANG_ENGLISH_TRINIDAD SUBLANG_DEFAULT | |
3113 | #endif | |
3114 | #ifndef SUBLANG_ENGLISH_ZIMBABWE | |
3115 | #define SUBLANG_ENGLISH_ZIMBABWE SUBLANG_DEFAULT | |
3116 | #endif | |
3117 | #ifndef SUBLANG_FRENCH | |
3118 | #define SUBLANG_FRENCH SUBLANG_DEFAULT | |
3119 | #endif | |
3120 | #ifndef SUBLANG_FRENCH_BELGIAN | |
3121 | #define SUBLANG_FRENCH_BELGIAN SUBLANG_DEFAULT | |
3122 | #endif | |
3123 | #ifndef SUBLANG_FRENCH_CANADIAN | |
3124 | #define SUBLANG_FRENCH_CANADIAN SUBLANG_DEFAULT | |
3125 | #endif | |
3126 | #ifndef SUBLANG_FRENCH_LUXEMBOURG | |
3127 | #define SUBLANG_FRENCH_LUXEMBOURG SUBLANG_DEFAULT | |
3128 | #endif | |
3129 | #ifndef SUBLANG_FRENCH_MONACO | |
3130 | #define SUBLANG_FRENCH_MONACO SUBLANG_DEFAULT | |
3131 | #endif | |
3132 | #ifndef SUBLANG_FRENCH_SWISS | |
3133 | #define SUBLANG_FRENCH_SWISS SUBLANG_DEFAULT | |
3134 | #endif | |
3135 | #ifndef SUBLANG_GERMAN | |
3136 | #define SUBLANG_GERMAN SUBLANG_DEFAULT | |
3137 | #endif | |
3138 | #ifndef SUBLANG_GERMAN_AUSTRIAN | |
3139 | #define SUBLANG_GERMAN_AUSTRIAN SUBLANG_DEFAULT | |
3140 | #endif | |
3141 | #ifndef SUBLANG_GERMAN_LIECHTENSTEIN | |
3142 | #define SUBLANG_GERMAN_LIECHTENSTEIN SUBLANG_DEFAULT | |
3143 | #endif | |
3144 | #ifndef SUBLANG_GERMAN_LUXEMBOURG | |
3145 | #define SUBLANG_GERMAN_LUXEMBOURG SUBLANG_DEFAULT | |
3146 | #endif | |
3147 | #ifndef SUBLANG_GERMAN_SWISS | |
3148 | #define SUBLANG_GERMAN_SWISS SUBLANG_DEFAULT | |
3149 | #endif | |
3150 | #ifndef SUBLANG_ITALIAN | |
3151 | #define SUBLANG_ITALIAN SUBLANG_DEFAULT | |
3152 | #endif | |
3153 | #ifndef SUBLANG_ITALIAN_SWISS | |
3154 | #define SUBLANG_ITALIAN_SWISS SUBLANG_DEFAULT | |
3155 | #endif | |
3156 | #ifndef SUBLANG_KASHMIRI_INDIA | |
3157 | #define SUBLANG_KASHMIRI_INDIA SUBLANG_DEFAULT | |
3158 | #endif | |
3159 | #ifndef SUBLANG_KOREAN | |
3160 | #define SUBLANG_KOREAN SUBLANG_DEFAULT | |
3161 | #endif | |
3162 | #ifndef SUBLANG_LITHUANIAN | |
3163 | #define SUBLANG_LITHUANIAN SUBLANG_DEFAULT | |
3164 | #endif | |
3165 | #ifndef SUBLANG_MALAY_BRUNEI_DARUSSALAM | |
3166 | #define SUBLANG_MALAY_BRUNEI_DARUSSALAM SUBLANG_DEFAULT | |
3167 | #endif | |
3168 | #ifndef SUBLANG_MALAY_MALAYSIA | |
3169 | #define SUBLANG_MALAY_MALAYSIA SUBLANG_DEFAULT | |
3170 | #endif | |
3171 | #ifndef SUBLANG_NEPALI_INDIA | |
3172 | #define SUBLANG_NEPALI_INDIA SUBLANG_DEFAULT | |
3173 | #endif | |
3174 | #ifndef SUBLANG_NORWEGIAN_BOKMAL | |
3175 | #define SUBLANG_NORWEGIAN_BOKMAL SUBLANG_DEFAULT | |
3176 | #endif | |
3177 | #ifndef SUBLANG_NORWEGIAN_NYNORSK | |
3178 | #define SUBLANG_NORWEGIAN_NYNORSK SUBLANG_DEFAULT | |
3179 | #endif | |
3180 | #ifndef SUBLANG_PORTUGUESE | |
3181 | #define SUBLANG_PORTUGUESE SUBLANG_DEFAULT | |
3182 | #endif | |
3183 | #ifndef SUBLANG_PORTUGUESE_BRAZILIAN | |
3184 | #define SUBLANG_PORTUGUESE_BRAZILIAN SUBLANG_DEFAULT | |
3185 | #endif | |
3186 | #ifndef SUBLANG_SERBIAN_CYRILLIC | |
3187 | #define SUBLANG_SERBIAN_CYRILLIC SUBLANG_DEFAULT | |
3188 | #endif | |
3189 | #ifndef SUBLANG_SERBIAN_LATIN | |
3190 | #define SUBLANG_SERBIAN_LATIN SUBLANG_DEFAULT | |
3191 | #endif | |
3192 | #ifndef SUBLANG_SPANISH | |
3193 | #define SUBLANG_SPANISH SUBLANG_DEFAULT | |
3194 | #endif | |
3195 | #ifndef SUBLANG_SPANISH_ARGENTINA | |
3196 | #define SUBLANG_SPANISH_ARGENTINA SUBLANG_DEFAULT | |
3197 | #endif | |
3198 | #ifndef SUBLANG_SPANISH_BOLIVIA | |
3199 | #define SUBLANG_SPANISH_BOLIVIA SUBLANG_DEFAULT | |
3200 | #endif | |
3201 | #ifndef SUBLANG_SPANISH_CHILE | |
3202 | #define SUBLANG_SPANISH_CHILE SUBLANG_DEFAULT | |
3203 | #endif | |
3204 | #ifndef SUBLANG_SPANISH_COLOMBIA | |
3205 | #define SUBLANG_SPANISH_COLOMBIA SUBLANG_DEFAULT | |
3206 | #endif | |
3207 | #ifndef SUBLANG_SPANISH_COSTA_RICA | |
3208 | #define SUBLANG_SPANISH_COSTA_RICA SUBLANG_DEFAULT | |
3209 | #endif | |
3210 | #ifndef SUBLANG_SPANISH_DOMINICAN_REPUBLIC | |
3211 | #define SUBLANG_SPANISH_DOMINICAN_REPUBLIC SUBLANG_DEFAULT | |
3212 | #endif | |
3213 | #ifndef SUBLANG_SPANISH_ECUADOR | |
3214 | #define SUBLANG_SPANISH_ECUADOR SUBLANG_DEFAULT | |
3215 | #endif | |
3216 | #ifndef SUBLANG_SPANISH_EL_SALVADOR | |
3217 | #define SUBLANG_SPANISH_EL_SALVADOR SUBLANG_DEFAULT | |
3218 | #endif | |
3219 | #ifndef SUBLANG_SPANISH_GUATEMALA | |
3220 | #define SUBLANG_SPANISH_GUATEMALA SUBLANG_DEFAULT | |
3221 | #endif | |
3222 | #ifndef SUBLANG_SPANISH_HONDURAS | |
3223 | #define SUBLANG_SPANISH_HONDURAS SUBLANG_DEFAULT | |
3224 | #endif | |
3225 | #ifndef SUBLANG_SPANISH_MEXICAN | |
3226 | #define SUBLANG_SPANISH_MEXICAN SUBLANG_DEFAULT | |
3227 | #endif | |
3228 | #ifndef SUBLANG_SPANISH_MODERN | |
3229 | #define SUBLANG_SPANISH_MODERN SUBLANG_DEFAULT | |
3230 | #endif | |
3231 | #ifndef SUBLANG_SPANISH_NICARAGUA | |
3232 | #define SUBLANG_SPANISH_NICARAGUA SUBLANG_DEFAULT | |
3233 | #endif | |
3234 | #ifndef SUBLANG_SPANISH_PANAMA | |
3235 | #define SUBLANG_SPANISH_PANAMA SUBLANG_DEFAULT | |
3236 | #endif | |
3237 | #ifndef SUBLANG_SPANISH_PARAGUAY | |
3238 | #define SUBLANG_SPANISH_PARAGUAY SUBLANG_DEFAULT | |
3239 | #endif | |
3240 | #ifndef SUBLANG_SPANISH_PERU | |
3241 | #define SUBLANG_SPANISH_PERU SUBLANG_DEFAULT | |
3242 | #endif | |
3243 | #ifndef SUBLANG_SPANISH_PUERTO_RICO | |
3244 | #define SUBLANG_SPANISH_PUERTO_RICO SUBLANG_DEFAULT | |
3245 | #endif | |
3246 | #ifndef SUBLANG_SPANISH_URUGUAY | |
3247 | #define SUBLANG_SPANISH_URUGUAY SUBLANG_DEFAULT | |
3248 | #endif | |
3249 | #ifndef SUBLANG_SPANISH_VENEZUELA | |
3250 | #define SUBLANG_SPANISH_VENEZUELA SUBLANG_DEFAULT | |
3251 | #endif | |
3252 | #ifndef SUBLANG_SWEDISH | |
3253 | #define SUBLANG_SWEDISH SUBLANG_DEFAULT | |
3254 | #endif | |
3255 | #ifndef SUBLANG_SWEDISH_FINLAND | |
3256 | #define SUBLANG_SWEDISH_FINLAND SUBLANG_DEFAULT | |
3257 | #endif | |
3258 | #ifndef SUBLANG_URDU_INDIA | |
3259 | #define SUBLANG_URDU_INDIA SUBLANG_DEFAULT | |
3260 | #endif | |
3261 | #ifndef SUBLANG_URDU_PAKISTAN | |
3262 | #define SUBLANG_URDU_PAKISTAN SUBLANG_DEFAULT | |
3263 | #endif | |
3264 | #ifndef SUBLANG_UZBEK_CYRILLIC | |
3265 | #define SUBLANG_UZBEK_CYRILLIC SUBLANG_DEFAULT | |
3266 | #endif | |
3267 | #ifndef SUBLANG_UZBEK_LATIN | |
3268 | #define SUBLANG_UZBEK_LATIN SUBLANG_DEFAULT | |
d3f3e35f VS |
3269 | #endif |
3270 | ||
63986ba6 VS |
3271 | |
3272 | #endif // __WIN32__ | |
3273 | ||
d3f3e35f VS |
3274 | #define LNG(wxlang, canonical, winlang, winsublang, desc) \ |
3275 | info.Language = wxlang; \ | |
3276 | info.CanonicalName = wxT(canonical); \ | |
2b5f62a0 | 3277 | info.Description = wxT(desc); \ |
d3f3e35f VS |
3278 | SETWINLANG(info, winlang, winsublang) \ |
3279 | AddLanguage(info); | |
3280 | ||
3281 | void wxLocale::InitLanguagesDB() | |
3282 | { | |
3283 | wxLanguageInfo info; | |
3284 | wxStringTokenizer tkn; | |
63986ba6 | 3285 | |
14f8fa9d | 3286 | LNG(wxLANGUAGE_ABKHAZIAN, "ab" , 0 , 0 , "Abkhazian") |
d3f3e35f VS |
3287 | LNG(wxLANGUAGE_AFAR, "aa" , 0 , 0 , "Afar") |
3288 | LNG(wxLANGUAGE_AFRIKAANS, "af_ZA", LANG_AFRIKAANS , SUBLANG_DEFAULT , "Afrikaans") | |
3289 | LNG(wxLANGUAGE_ALBANIAN, "sq_AL", LANG_ALBANIAN , SUBLANG_DEFAULT , "Albanian") | |
3290 | LNG(wxLANGUAGE_AMHARIC, "am" , 0 , 0 , "Amharic") | |
3291 | LNG(wxLANGUAGE_ARABIC, "ar" , LANG_ARABIC , SUBLANG_DEFAULT , "Arabic") | |
3292 | LNG(wxLANGUAGE_ARABIC_ALGERIA, "ar_DZ", LANG_ARABIC , SUBLANG_ARABIC_ALGERIA , "Arabic (Algeria)") | |
3293 | LNG(wxLANGUAGE_ARABIC_BAHRAIN, "ar_BH", LANG_ARABIC , SUBLANG_ARABIC_BAHRAIN , "Arabic (Bahrain)") | |
3294 | LNG(wxLANGUAGE_ARABIC_EGYPT, "ar_EG", LANG_ARABIC , SUBLANG_ARABIC_EGYPT , "Arabic (Egypt)") | |
3295 | LNG(wxLANGUAGE_ARABIC_IRAQ, "ar_IQ", LANG_ARABIC , SUBLANG_ARABIC_IRAQ , "Arabic (Iraq)") | |
3296 | LNG(wxLANGUAGE_ARABIC_JORDAN, "ar_JO", LANG_ARABIC , SUBLANG_ARABIC_JORDAN , "Arabic (Jordan)") | |
3297 | LNG(wxLANGUAGE_ARABIC_KUWAIT, "ar_KW", LANG_ARABIC , SUBLANG_ARABIC_KUWAIT , "Arabic (Kuwait)") | |
3298 | LNG(wxLANGUAGE_ARABIC_LEBANON, "ar_LB", LANG_ARABIC , SUBLANG_ARABIC_LEBANON , "Arabic (Lebanon)") | |
3299 | LNG(wxLANGUAGE_ARABIC_LIBYA, "ar_LY", LANG_ARABIC , SUBLANG_ARABIC_LIBYA , "Arabic (Libya)") | |
3300 | LNG(wxLANGUAGE_ARABIC_MOROCCO, "ar_MA", LANG_ARABIC , SUBLANG_ARABIC_MOROCCO , "Arabic (Morocco)") | |
3301 | LNG(wxLANGUAGE_ARABIC_OMAN, "ar_OM", LANG_ARABIC , SUBLANG_ARABIC_OMAN , "Arabic (Oman)") | |
3302 | LNG(wxLANGUAGE_ARABIC_QATAR, "ar_QA", LANG_ARABIC , SUBLANG_ARABIC_QATAR , "Arabic (Qatar)") | |
3303 | LNG(wxLANGUAGE_ARABIC_SAUDI_ARABIA, "ar_SA", LANG_ARABIC , SUBLANG_ARABIC_SAUDI_ARABIA , "Arabic (Saudi Arabia)") | |
3304 | LNG(wxLANGUAGE_ARABIC_SUDAN, "ar_SD", 0 , 0 , "Arabic (Sudan)") | |
3305 | LNG(wxLANGUAGE_ARABIC_SYRIA, "ar_SY", LANG_ARABIC , SUBLANG_ARABIC_SYRIA , "Arabic (Syria)") | |
3306 | LNG(wxLANGUAGE_ARABIC_TUNISIA, "ar_TN", LANG_ARABIC , SUBLANG_ARABIC_TUNISIA , "Arabic (Tunisia)") | |
3307 | LNG(wxLANGUAGE_ARABIC_UAE, "ar_AE", LANG_ARABIC , SUBLANG_ARABIC_UAE , "Arabic (Uae)") | |
3308 | LNG(wxLANGUAGE_ARABIC_YEMEN, "ar_YE", LANG_ARABIC , SUBLANG_ARABIC_YEMEN , "Arabic (Yemen)") | |
3309 | LNG(wxLANGUAGE_ARMENIAN, "hy" , LANG_ARMENIAN , SUBLANG_DEFAULT , "Armenian") | |
3310 | LNG(wxLANGUAGE_ASSAMESE, "as" , LANG_ASSAMESE , SUBLANG_DEFAULT , "Assamese") | |
3311 | LNG(wxLANGUAGE_AYMARA, "ay" , 0 , 0 , "Aymara") | |
3312 | LNG(wxLANGUAGE_AZERI, "az" , LANG_AZERI , SUBLANG_DEFAULT , "Azeri") | |
3313 | LNG(wxLANGUAGE_AZERI_CYRILLIC, "az" , LANG_AZERI , SUBLANG_AZERI_CYRILLIC , "Azeri (Cyrillic)") | |
3314 | LNG(wxLANGUAGE_AZERI_LATIN, "az" , LANG_AZERI , SUBLANG_AZERI_LATIN , "Azeri (Latin)") | |
3315 | LNG(wxLANGUAGE_BASHKIR, "ba" , 0 , 0 , "Bashkir") | |
3316 | LNG(wxLANGUAGE_BASQUE, "eu_ES", LANG_BASQUE , SUBLANG_DEFAULT , "Basque") | |
3317 | LNG(wxLANGUAGE_BELARUSIAN, "be_BY", LANG_BELARUSIAN, SUBLANG_DEFAULT , "Belarusian") | |
3318 | LNG(wxLANGUAGE_BENGALI, "bn" , LANG_BENGALI , SUBLANG_DEFAULT , "Bengali") | |
3319 | LNG(wxLANGUAGE_BHUTANI, "dz" , 0 , 0 , "Bhutani") | |
3320 | LNG(wxLANGUAGE_BIHARI, "bh" , 0 , 0 , "Bihari") | |
3321 | LNG(wxLANGUAGE_BISLAMA, "bi" , 0 , 0 , "Bislama") | |
3322 | LNG(wxLANGUAGE_BRETON, "br" , 0 , 0 , "Breton") | |
3323 | LNG(wxLANGUAGE_BULGARIAN, "bg_BG", LANG_BULGARIAN , SUBLANG_DEFAULT , "Bulgarian") | |
3324 | LNG(wxLANGUAGE_BURMESE, "my" , 0 , 0 , "Burmese") | |
3325 | LNG(wxLANGUAGE_CAMBODIAN, "km" , 0 , 0 , "Cambodian") | |
3326 | LNG(wxLANGUAGE_CATALAN, "ca_ES", LANG_CATALAN , SUBLANG_DEFAULT , "Catalan") | |
e6cea1d3 | 3327 | LNG(wxLANGUAGE_CHINESE, "zh_TW", LANG_CHINESE , SUBLANG_DEFAULT , "Chinese") |
d3f3e35f | 3328 | LNG(wxLANGUAGE_CHINESE_SIMPLIFIED, "zh_CN", LANG_CHINESE , SUBLANG_CHINESE_SIMPLIFIED , "Chinese (Simplified)") |
3ebd765d | 3329 | LNG(wxLANGUAGE_CHINESE_TRADITIONAL, "zh_TW", LANG_CHINESE , SUBLANG_CHINESE_TRADITIONAL , "Chinese (Traditional)") |
d3f3e35f VS |
3330 | LNG(wxLANGUAGE_CHINESE_HONGKONG, "zh_HK", LANG_CHINESE , SUBLANG_CHINESE_HONGKONG , "Chinese (Hongkong)") |
3331 | LNG(wxLANGUAGE_CHINESE_MACAU, "zh_MO", LANG_CHINESE , SUBLANG_CHINESE_MACAU , "Chinese (Macau)") | |
3332 | LNG(wxLANGUAGE_CHINESE_SINGAPORE, "zh_SG", LANG_CHINESE , SUBLANG_CHINESE_SINGAPORE , "Chinese (Singapore)") | |
2b5f62a0 | 3333 | LNG(wxLANGUAGE_CHINESE_TAIWAN, "zh_TW", LANG_CHINESE , SUBLANG_CHINESE_TRADITIONAL , "Chinese (Taiwan)") |
d3f3e35f VS |
3334 | LNG(wxLANGUAGE_CORSICAN, "co" , 0 , 0 , "Corsican") |
3335 | LNG(wxLANGUAGE_CROATIAN, "hr_HR", LANG_CROATIAN , SUBLANG_DEFAULT , "Croatian") | |
3336 | LNG(wxLANGUAGE_CZECH, "cs_CZ", LANG_CZECH , SUBLANG_DEFAULT , "Czech") | |
3337 | LNG(wxLANGUAGE_DANISH, "da_DK", LANG_DANISH , SUBLANG_DEFAULT , "Danish") | |
3338 | LNG(wxLANGUAGE_DUTCH, "nl_NL", LANG_DUTCH , SUBLANG_DUTCH , "Dutch") | |
3339 | LNG(wxLANGUAGE_DUTCH_BELGIAN, "nl_BE", LANG_DUTCH , SUBLANG_DUTCH_BELGIAN , "Dutch (Belgian)") | |
3340 | LNG(wxLANGUAGE_ENGLISH, "en_GB", LANG_ENGLISH , SUBLANG_ENGLISH_UK , "English") | |
3341 | LNG(wxLANGUAGE_ENGLISH_UK, "en_GB", LANG_ENGLISH , SUBLANG_ENGLISH_UK , "English (U.K.)") | |
3342 | LNG(wxLANGUAGE_ENGLISH_US, "en_US", LANG_ENGLISH , SUBLANG_ENGLISH_US , "English (U.S.)") | |
3343 | LNG(wxLANGUAGE_ENGLISH_AUSTRALIA, "en_AU", LANG_ENGLISH , SUBLANG_ENGLISH_AUS , "English (Australia)") | |
3344 | LNG(wxLANGUAGE_ENGLISH_BELIZE, "en_BZ", LANG_ENGLISH , SUBLANG_ENGLISH_BELIZE , "English (Belize)") | |
3345 | LNG(wxLANGUAGE_ENGLISH_BOTSWANA, "en_BW", 0 , 0 , "English (Botswana)") | |
3346 | LNG(wxLANGUAGE_ENGLISH_CANADA, "en_CA", LANG_ENGLISH , SUBLANG_ENGLISH_CAN , "English (Canada)") | |
3347 | LNG(wxLANGUAGE_ENGLISH_CARIBBEAN, "en_CB", LANG_ENGLISH , SUBLANG_ENGLISH_CARIBBEAN , "English (Caribbean)") | |
3348 | LNG(wxLANGUAGE_ENGLISH_DENMARK, "en_DK", 0 , 0 , "English (Denmark)") | |
3349 | LNG(wxLANGUAGE_ENGLISH_EIRE, "en_IE", LANG_ENGLISH , SUBLANG_ENGLISH_EIRE , "English (Eire)") | |
3350 | LNG(wxLANGUAGE_ENGLISH_JAMAICA, "en_JM", LANG_ENGLISH , SUBLANG_ENGLISH_JAMAICA , "English (Jamaica)") | |
3351 | LNG(wxLANGUAGE_ENGLISH_NEW_ZEALAND, "en_NZ", LANG_ENGLISH , SUBLANG_ENGLISH_NZ , "English (New Zealand)") | |
3352 | LNG(wxLANGUAGE_ENGLISH_PHILIPPINES, "en_PH", LANG_ENGLISH , SUBLANG_ENGLISH_PHILIPPINES , "English (Philippines)") | |
3353 | LNG(wxLANGUAGE_ENGLISH_SOUTH_AFRICA, "en_ZA", LANG_ENGLISH , SUBLANG_ENGLISH_SOUTH_AFRICA , "English (South Africa)") | |
3354 | LNG(wxLANGUAGE_ENGLISH_TRINIDAD, "en_TT", LANG_ENGLISH , SUBLANG_ENGLISH_TRINIDAD , "English (Trinidad)") | |
3355 | LNG(wxLANGUAGE_ENGLISH_ZIMBABWE, "en_ZW", LANG_ENGLISH , SUBLANG_ENGLISH_ZIMBABWE , "English (Zimbabwe)") | |
3356 | LNG(wxLANGUAGE_ESPERANTO, "eo" , 0 , 0 , "Esperanto") | |
3357 | LNG(wxLANGUAGE_ESTONIAN, "et_EE", LANG_ESTONIAN , SUBLANG_DEFAULT , "Estonian") | |
3358 | LNG(wxLANGUAGE_FAEROESE, "fo_FO", LANG_FAEROESE , SUBLANG_DEFAULT , "Faeroese") | |
865a1730 | 3359 | LNG(wxLANGUAGE_FARSI, "fa_IR", LANG_FARSI , SUBLANG_DEFAULT , "Farsi") |
d3f3e35f VS |
3360 | LNG(wxLANGUAGE_FIJI, "fj" , 0 , 0 , "Fiji") |
3361 | LNG(wxLANGUAGE_FINNISH, "fi_FI", LANG_FINNISH , SUBLANG_DEFAULT , "Finnish") | |
3362 | LNG(wxLANGUAGE_FRENCH, "fr_FR", LANG_FRENCH , SUBLANG_FRENCH , "French") | |
3363 | LNG(wxLANGUAGE_FRENCH_BELGIAN, "fr_BE", LANG_FRENCH , SUBLANG_FRENCH_BELGIAN , "French (Belgian)") | |
3364 | LNG(wxLANGUAGE_FRENCH_CANADIAN, "fr_CA", LANG_FRENCH , SUBLANG_FRENCH_CANADIAN , "French (Canadian)") | |
3365 | LNG(wxLANGUAGE_FRENCH_LUXEMBOURG, "fr_LU", LANG_FRENCH , SUBLANG_FRENCH_LUXEMBOURG , "French (Luxembourg)") | |
3366 | LNG(wxLANGUAGE_FRENCH_MONACO, "fr_MC", LANG_FRENCH , SUBLANG_FRENCH_MONACO , "French (Monaco)") | |
3367 | LNG(wxLANGUAGE_FRENCH_SWISS, "fr_CH", LANG_FRENCH , SUBLANG_FRENCH_SWISS , "French (Swiss)") | |
3368 | LNG(wxLANGUAGE_FRISIAN, "fy" , 0 , 0 , "Frisian") | |
3369 | LNG(wxLANGUAGE_GALICIAN, "gl_ES", 0 , 0 , "Galician") | |
3370 | LNG(wxLANGUAGE_GEORGIAN, "ka" , LANG_GEORGIAN , SUBLANG_DEFAULT , "Georgian") | |
3371 | LNG(wxLANGUAGE_GERMAN, "de_DE", LANG_GERMAN , SUBLANG_GERMAN , "German") | |
3372 | LNG(wxLANGUAGE_GERMAN_AUSTRIAN, "de_AT", LANG_GERMAN , SUBLANG_GERMAN_AUSTRIAN , "German (Austrian)") | |
3373 | LNG(wxLANGUAGE_GERMAN_BELGIUM, "de_BE", 0 , 0 , "German (Belgium)") | |
3374 | LNG(wxLANGUAGE_GERMAN_LIECHTENSTEIN, "de_LI", LANG_GERMAN , SUBLANG_GERMAN_LIECHTENSTEIN , "German (Liechtenstein)") | |
3375 | LNG(wxLANGUAGE_GERMAN_LUXEMBOURG, "de_LU", LANG_GERMAN , SUBLANG_GERMAN_LUXEMBOURG , "German (Luxembourg)") | |
3376 | LNG(wxLANGUAGE_GERMAN_SWISS, "de_CH", LANG_GERMAN , SUBLANG_GERMAN_SWISS , "German (Swiss)") | |
3377 | LNG(wxLANGUAGE_GREEK, "el_GR", LANG_GREEK , SUBLANG_DEFAULT , "Greek") | |
3378 | LNG(wxLANGUAGE_GREENLANDIC, "kl_GL", 0 , 0 , "Greenlandic") | |
3379 | LNG(wxLANGUAGE_GUARANI, "gn" , 0 , 0 , "Guarani") | |
3380 | LNG(wxLANGUAGE_GUJARATI, "gu" , LANG_GUJARATI , SUBLANG_DEFAULT , "Gujarati") | |
3381 | LNG(wxLANGUAGE_HAUSA, "ha" , 0 , 0 , "Hausa") | |
3382 | LNG(wxLANGUAGE_HEBREW, "he_IL", LANG_HEBREW , SUBLANG_DEFAULT , "Hebrew") | |
3383 | LNG(wxLANGUAGE_HINDI, "hi_IN", LANG_HINDI , SUBLANG_DEFAULT , "Hindi") | |
3384 | LNG(wxLANGUAGE_HUNGARIAN, "hu_HU", LANG_HUNGARIAN , SUBLANG_DEFAULT , "Hungarian") | |
3385 | LNG(wxLANGUAGE_ICELANDIC, "is_IS", LANG_ICELANDIC , SUBLANG_DEFAULT , "Icelandic") | |
3386 | LNG(wxLANGUAGE_INDONESIAN, "id_ID", LANG_INDONESIAN, SUBLANG_DEFAULT , "Indonesian") | |
3387 | LNG(wxLANGUAGE_INTERLINGUA, "ia" , 0 , 0 , "Interlingua") | |
3388 | LNG(wxLANGUAGE_INTERLINGUE, "ie" , 0 , 0 , "Interlingue") | |
3389 | LNG(wxLANGUAGE_INUKTITUT, "iu" , 0 , 0 , "Inuktitut") | |
3390 | LNG(wxLANGUAGE_INUPIAK, "ik" , 0 , 0 , "Inupiak") | |
3391 | LNG(wxLANGUAGE_IRISH, "ga_IE", 0 , 0 , "Irish") | |
3392 | LNG(wxLANGUAGE_ITALIAN, "it_IT", LANG_ITALIAN , SUBLANG_ITALIAN , "Italian") | |
3393 | LNG(wxLANGUAGE_ITALIAN_SWISS, "it_CH", LANG_ITALIAN , SUBLANG_ITALIAN_SWISS , "Italian (Swiss)") | |
3394 | LNG(wxLANGUAGE_JAPANESE, "ja_JP", LANG_JAPANESE , SUBLANG_DEFAULT , "Japanese") | |
3395 | LNG(wxLANGUAGE_JAVANESE, "jw" , 0 , 0 , "Javanese") | |
3396 | LNG(wxLANGUAGE_KANNADA, "kn" , LANG_KANNADA , SUBLANG_DEFAULT , "Kannada") | |
3397 | LNG(wxLANGUAGE_KASHMIRI, "ks" , LANG_KASHMIRI , SUBLANG_DEFAULT , "Kashmiri") | |
3398 | LNG(wxLANGUAGE_KASHMIRI_INDIA, "ks_IN", LANG_KASHMIRI , SUBLANG_KASHMIRI_INDIA , "Kashmiri (India)") | |
3399 | LNG(wxLANGUAGE_KAZAKH, "kk" , LANG_KAZAK , SUBLANG_DEFAULT , "Kazakh") | |
c611452f | 3400 | LNG(wxLANGUAGE_KERNEWEK, "kw_GB", 0 , 0 , "Kernewek") |
d3f3e35f VS |
3401 | LNG(wxLANGUAGE_KINYARWANDA, "rw" , 0 , 0 , "Kinyarwanda") |
3402 | LNG(wxLANGUAGE_KIRGHIZ, "ky" , 0 , 0 , "Kirghiz") | |
3403 | LNG(wxLANGUAGE_KIRUNDI, "rn" , 0 , 0 , "Kirundi") | |
3404 | LNG(wxLANGUAGE_KONKANI, "" , LANG_KONKANI , SUBLANG_DEFAULT , "Konkani") | |
3405 | LNG(wxLANGUAGE_KOREAN, "ko_KR", LANG_KOREAN , SUBLANG_KOREAN , "Korean") | |
3406 | LNG(wxLANGUAGE_KURDISH, "ku" , 0 , 0 , "Kurdish") | |
3407 | LNG(wxLANGUAGE_LAOTHIAN, "lo" , 0 , 0 , "Laothian") | |
3408 | LNG(wxLANGUAGE_LATIN, "la" , 0 , 0 , "Latin") | |
3409 | LNG(wxLANGUAGE_LATVIAN, "lv_LV", LANG_LATVIAN , SUBLANG_DEFAULT , "Latvian") | |
3410 | LNG(wxLANGUAGE_LINGALA, "ln" , 0 , 0 , "Lingala") | |
3411 | LNG(wxLANGUAGE_LITHUANIAN, "lt_LT", LANG_LITHUANIAN, SUBLANG_LITHUANIAN , "Lithuanian") | |
3412 | LNG(wxLANGUAGE_MACEDONIAN, "mk_MK", LANG_MACEDONIAN, SUBLANG_DEFAULT , "Macedonian") | |
3413 | LNG(wxLANGUAGE_MALAGASY, "mg" , 0 , 0 , "Malagasy") | |
3414 | LNG(wxLANGUAGE_MALAY, "ms_MY", LANG_MALAY , SUBLANG_DEFAULT , "Malay") | |
3415 | LNG(wxLANGUAGE_MALAYALAM, "ml" , LANG_MALAYALAM , SUBLANG_DEFAULT , "Malayalam") | |
3416 | LNG(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM, "ms_BN", LANG_MALAY , SUBLANG_MALAY_BRUNEI_DARUSSALAM , "Malay (Brunei Darussalam)") | |
3417 | LNG(wxLANGUAGE_MALAY_MALAYSIA, "ms_MY", LANG_MALAY , SUBLANG_MALAY_MALAYSIA , "Malay (Malaysia)") | |
3418 | LNG(wxLANGUAGE_MALTESE, "mt_MT", 0 , 0 , "Maltese") | |
3419 | LNG(wxLANGUAGE_MANIPURI, "" , LANG_MANIPURI , SUBLANG_DEFAULT , "Manipuri") | |
3420 | LNG(wxLANGUAGE_MAORI, "mi" , 0 , 0 , "Maori") | |
3421 | LNG(wxLANGUAGE_MARATHI, "mr_IN", LANG_MARATHI , SUBLANG_DEFAULT , "Marathi") | |
3422 | LNG(wxLANGUAGE_MOLDAVIAN, "mo" , 0 , 0 , "Moldavian") | |
3423 | LNG(wxLANGUAGE_MONGOLIAN, "mn" , 0 , 0 , "Mongolian") | |
3424 | LNG(wxLANGUAGE_NAURU, "na" , 0 , 0 , "Nauru") | |
3425 | LNG(wxLANGUAGE_NEPALI, "ne" , LANG_NEPALI , SUBLANG_DEFAULT , "Nepali") | |
3426 | LNG(wxLANGUAGE_NEPALI_INDIA, "ne_IN", LANG_NEPALI , SUBLANG_NEPALI_INDIA , "Nepali (India)") | |
cf5e94bc | 3427 | LNG(wxLANGUAGE_NORWEGIAN_BOKMAL, "nb_NO", LANG_NORWEGIAN , SUBLANG_NORWEGIAN_BOKMAL , "Norwegian (Bokmal)") |
c611452f | 3428 | LNG(wxLANGUAGE_NORWEGIAN_NYNORSK, "nn_NO", LANG_NORWEGIAN , SUBLANG_NORWEGIAN_NYNORSK , "Norwegian (Nynorsk)") |
d3f3e35f VS |
3429 | LNG(wxLANGUAGE_OCCITAN, "oc" , 0 , 0 , "Occitan") |
3430 | LNG(wxLANGUAGE_ORIYA, "or" , LANG_ORIYA , SUBLANG_DEFAULT , "Oriya") | |
3431 | LNG(wxLANGUAGE_OROMO, "om" , 0 , 0 , "(Afan) Oromo") | |
3432 | LNG(wxLANGUAGE_PASHTO, "ps" , 0 , 0 , "Pashto, Pushto") | |
d3f3e35f VS |
3433 | LNG(wxLANGUAGE_POLISH, "pl_PL", LANG_POLISH , SUBLANG_DEFAULT , "Polish") |
3434 | LNG(wxLANGUAGE_PORTUGUESE, "pt_PT", LANG_PORTUGUESE, SUBLANG_PORTUGUESE , "Portuguese") | |
3435 | LNG(wxLANGUAGE_PORTUGUESE_BRAZILIAN, "pt_BR", LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN , "Portuguese (Brazilian)") | |
3436 | LNG(wxLANGUAGE_PUNJABI, "pa" , LANG_PUNJABI , SUBLANG_DEFAULT , "Punjabi") | |
3437 | LNG(wxLANGUAGE_QUECHUA, "qu" , 0 , 0 , "Quechua") | |
3438 | LNG(wxLANGUAGE_RHAETO_ROMANCE, "rm" , 0 , 0 , "Rhaeto-Romance") | |
3439 | LNG(wxLANGUAGE_ROMANIAN, "ro_RO", LANG_ROMANIAN , SUBLANG_DEFAULT , "Romanian") | |
3440 | LNG(wxLANGUAGE_RUSSIAN, "ru_RU", LANG_RUSSIAN , SUBLANG_DEFAULT , "Russian") | |
3441 | LNG(wxLANGUAGE_RUSSIAN_UKRAINE, "ru_UA", 0 , 0 , "Russian (Ukraine)") | |
3442 | LNG(wxLANGUAGE_SAMOAN, "sm" , 0 , 0 , "Samoan") | |
3443 | LNG(wxLANGUAGE_SANGHO, "sg" , 0 , 0 , "Sangho") | |
3444 | LNG(wxLANGUAGE_SANSKRIT, "sa" , LANG_SANSKRIT , SUBLANG_DEFAULT , "Sanskrit") | |
3445 | LNG(wxLANGUAGE_SCOTS_GAELIC, "gd" , 0 , 0 , "Scots Gaelic") | |
3446 | LNG(wxLANGUAGE_SERBIAN, "sr_YU", LANG_SERBIAN , SUBLANG_DEFAULT , "Serbian") | |
3447 | LNG(wxLANGUAGE_SERBIAN_CYRILLIC, "sr_YU", LANG_SERBIAN , SUBLANG_SERBIAN_CYRILLIC , "Serbian (Cyrillic)") | |
3448 | LNG(wxLANGUAGE_SERBIAN_LATIN, "sr_YU", LANG_SERBIAN , SUBLANG_SERBIAN_LATIN , "Serbian (Latin)") | |
3449 | LNG(wxLANGUAGE_SERBO_CROATIAN, "sh" , 0 , 0 , "Serbo-Croatian") | |
3450 | LNG(wxLANGUAGE_SESOTHO, "st" , 0 , 0 , "Sesotho") | |
3451 | LNG(wxLANGUAGE_SETSWANA, "tn" , 0 , 0 , "Setswana") | |
3452 | LNG(wxLANGUAGE_SHONA, "sn" , 0 , 0 , "Shona") | |
3453 | LNG(wxLANGUAGE_SINDHI, "sd" , LANG_SINDHI , SUBLANG_DEFAULT , "Sindhi") | |
3454 | LNG(wxLANGUAGE_SINHALESE, "si" , 0 , 0 , "Sinhalese") | |
3455 | LNG(wxLANGUAGE_SISWATI, "ss" , 0 , 0 , "Siswati") | |
3456 | LNG(wxLANGUAGE_SLOVAK, "sk_SK", LANG_SLOVAK , SUBLANG_DEFAULT , "Slovak") | |
3457 | LNG(wxLANGUAGE_SLOVENIAN, "sl_SI", LANG_SLOVENIAN , SUBLANG_DEFAULT , "Slovenian") | |
3458 | LNG(wxLANGUAGE_SOMALI, "so" , 0 , 0 , "Somali") | |
3459 | LNG(wxLANGUAGE_SPANISH, "es_ES", LANG_SPANISH , SUBLANG_SPANISH , "Spanish") | |
3460 | LNG(wxLANGUAGE_SPANISH_ARGENTINA, "es_AR", LANG_SPANISH , SUBLANG_SPANISH_ARGENTINA , "Spanish (Argentina)") | |
3461 | LNG(wxLANGUAGE_SPANISH_BOLIVIA, "es_BO", LANG_SPANISH , SUBLANG_SPANISH_BOLIVIA , "Spanish (Bolivia)") | |
3462 | LNG(wxLANGUAGE_SPANISH_CHILE, "es_CL", LANG_SPANISH , SUBLANG_SPANISH_CHILE , "Spanish (Chile)") | |
3463 | LNG(wxLANGUAGE_SPANISH_COLOMBIA, "es_CO", LANG_SPANISH , SUBLANG_SPANISH_COLOMBIA , "Spanish (Colombia)") | |
3464 | LNG(wxLANGUAGE_SPANISH_COSTA_RICA, "es_CR", LANG_SPANISH , SUBLANG_SPANISH_COSTA_RICA , "Spanish (Costa Rica)") | |
3465 | LNG(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC, "es_DO", LANG_SPANISH , SUBLANG_SPANISH_DOMINICAN_REPUBLIC, "Spanish (Dominican republic)") | |
3466 | LNG(wxLANGUAGE_SPANISH_ECUADOR, "es_EC", LANG_SPANISH , SUBLANG_SPANISH_ECUADOR , "Spanish (Ecuador)") | |
3467 | LNG(wxLANGUAGE_SPANISH_EL_SALVADOR, "es_SV", LANG_SPANISH , SUBLANG_SPANISH_EL_SALVADOR , "Spanish (El Salvador)") | |
3468 | LNG(wxLANGUAGE_SPANISH_GUATEMALA, "es_GT", LANG_SPANISH , SUBLANG_SPANISH_GUATEMALA , "Spanish (Guatemala)") | |
3469 | LNG(wxLANGUAGE_SPANISH_HONDURAS, "es_HN", LANG_SPANISH , SUBLANG_SPANISH_HONDURAS , "Spanish (Honduras)") | |
3470 | LNG(wxLANGUAGE_SPANISH_MEXICAN, "es_MX", LANG_SPANISH , SUBLANG_SPANISH_MEXICAN , "Spanish (Mexican)") | |
3471 | LNG(wxLANGUAGE_SPANISH_MODERN, "es_ES", LANG_SPANISH , SUBLANG_SPANISH_MODERN , "Spanish (Modern)") | |
3472 | LNG(wxLANGUAGE_SPANISH_NICARAGUA, "es_NI", LANG_SPANISH , SUBLANG_SPANISH_NICARAGUA , "Spanish (Nicaragua)") | |
3473 | LNG(wxLANGUAGE_SPANISH_PANAMA, "es_PA", LANG_SPANISH , SUBLANG_SPANISH_PANAMA , "Spanish (Panama)") | |
3474 | LNG(wxLANGUAGE_SPANISH_PARAGUAY, "es_PY", LANG_SPANISH , SUBLANG_SPANISH_PARAGUAY , "Spanish (Paraguay)") | |
3475 | LNG(wxLANGUAGE_SPANISH_PERU, "es_PE", LANG_SPANISH , SUBLANG_SPANISH_PERU , "Spanish (Peru)") | |
3476 | LNG(wxLANGUAGE_SPANISH_PUERTO_RICO, "es_PR", LANG_SPANISH , SUBLANG_SPANISH_PUERTO_RICO , "Spanish (Puerto Rico)") | |
3477 | LNG(wxLANGUAGE_SPANISH_URUGUAY, "es_UY", LANG_SPANISH , SUBLANG_SPANISH_URUGUAY , "Spanish (Uruguay)") | |
3478 | LNG(wxLANGUAGE_SPANISH_US, "es_US", 0 , 0 , "Spanish (U.S.)") | |
3479 | LNG(wxLANGUAGE_SPANISH_VENEZUELA, "es_VE", LANG_SPANISH , SUBLANG_SPANISH_VENEZUELA , "Spanish (Venezuela)") | |
3480 | LNG(wxLANGUAGE_SUNDANESE, "su" , 0 , 0 , "Sundanese") | |
3481 | LNG(wxLANGUAGE_SWAHILI, "sw_KE", LANG_SWAHILI , SUBLANG_DEFAULT , "Swahili") | |
3482 | LNG(wxLANGUAGE_SWEDISH, "sv_SE", LANG_SWEDISH , SUBLANG_SWEDISH , "Swedish") | |
3483 | LNG(wxLANGUAGE_SWEDISH_FINLAND, "sv_FI", LANG_SWEDISH , SUBLANG_SWEDISH_FINLAND , "Swedish (Finland)") | |
25a5f9a9 | 3484 | LNG(wxLANGUAGE_TAGALOG, "tl_PH", 0 , 0 , "Tagalog") |
d3f3e35f VS |
3485 | LNG(wxLANGUAGE_TAJIK, "tg" , 0 , 0 , "Tajik") |
3486 | LNG(wxLANGUAGE_TAMIL, "ta" , LANG_TAMIL , SUBLANG_DEFAULT , "Tamil") | |
3487 | LNG(wxLANGUAGE_TATAR, "tt" , LANG_TATAR , SUBLANG_DEFAULT , "Tatar") | |
3488 | LNG(wxLANGUAGE_TELUGU, "te" , LANG_TELUGU , SUBLANG_DEFAULT , "Telugu") | |
3489 | LNG(wxLANGUAGE_THAI, "th_TH", LANG_THAI , SUBLANG_DEFAULT , "Thai") | |
3490 | LNG(wxLANGUAGE_TIBETAN, "bo" , 0 , 0 , "Tibetan") | |
3491 | LNG(wxLANGUAGE_TIGRINYA, "ti" , 0 , 0 , "Tigrinya") | |
3492 | LNG(wxLANGUAGE_TONGA, "to" , 0 , 0 , "Tonga") | |
3493 | LNG(wxLANGUAGE_TSONGA, "ts" , 0 , 0 , "Tsonga") | |
3494 | LNG(wxLANGUAGE_TURKISH, "tr_TR", LANG_TURKISH , SUBLANG_DEFAULT , "Turkish") | |
3495 | LNG(wxLANGUAGE_TURKMEN, "tk" , 0 , 0 , "Turkmen") | |
3496 | LNG(wxLANGUAGE_TWI, "tw" , 0 , 0 , "Twi") | |
3497 | LNG(wxLANGUAGE_UIGHUR, "ug" , 0 , 0 , "Uighur") | |
3498 | LNG(wxLANGUAGE_UKRAINIAN, "uk_UA", LANG_UKRAINIAN , SUBLANG_DEFAULT , "Ukrainian") | |
3499 | LNG(wxLANGUAGE_URDU, "ur" , LANG_URDU , SUBLANG_DEFAULT , "Urdu") | |
3500 | LNG(wxLANGUAGE_URDU_INDIA, "ur_IN", LANG_URDU , SUBLANG_URDU_INDIA , "Urdu (India)") | |
3501 | LNG(wxLANGUAGE_URDU_PAKISTAN, "ur_PK", LANG_URDU , SUBLANG_URDU_PAKISTAN , "Urdu (Pakistan)") | |
3502 | LNG(wxLANGUAGE_UZBEK, "uz" , LANG_UZBEK , SUBLANG_DEFAULT , "Uzbek") | |
3503 | LNG(wxLANGUAGE_UZBEK_CYRILLIC, "uz" , LANG_UZBEK , SUBLANG_UZBEK_CYRILLIC , "Uzbek (Cyrillic)") | |
3504 | LNG(wxLANGUAGE_UZBEK_LATIN, "uz" , LANG_UZBEK , SUBLANG_UZBEK_LATIN , "Uzbek (Latin)") | |
3505 | LNG(wxLANGUAGE_VIETNAMESE, "vi_VN", LANG_VIETNAMESE, SUBLANG_DEFAULT , "Vietnamese") | |
3506 | LNG(wxLANGUAGE_VOLAPUK, "vo" , 0 , 0 , "Volapuk") | |
3507 | LNG(wxLANGUAGE_WELSH, "cy" , 0 , 0 , "Welsh") | |
3508 | LNG(wxLANGUAGE_WOLOF, "wo" , 0 , 0 , "Wolof") | |
3509 | LNG(wxLANGUAGE_XHOSA, "xh" , 0 , 0 , "Xhosa") | |
3510 | LNG(wxLANGUAGE_YIDDISH, "yi" , 0 , 0 , "Yiddish") | |
3511 | LNG(wxLANGUAGE_YORUBA, "yo" , 0 , 0 , "Yoruba") | |
3512 | LNG(wxLANGUAGE_ZHUANG, "za" , 0 , 0 , "Zhuang") | |
3513 | LNG(wxLANGUAGE_ZULU, "zu" , 0 , 0 , "Zulu") | |
9e7ed2b0 | 3514 | |
d3f3e35f VS |
3515 | }; |
3516 | #undef LNG | |
3517 | ||
41780009 VS |
3518 | // --- --- --- generated code ends here --- --- --- |
3519 | ||
d427503c VZ |
3520 | #endif // wxUSE_INTL |
3521 |