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