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