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)
9 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
13 // ============================================================================
15 // ============================================================================
17 // ----------------------------------------------------------------------------
19 // ----------------------------------------------------------------------------
21 // For compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
29 // The following define is needed by Innotek's libc to
30 // make the definition of struct localeconv available.
31 #define __INTERNAL_DEFS
37 #include "wx/dynarray.h"
38 #include "wx/string.h"
43 #include "wx/hashmap.h"
44 #include "wx/module.h"
54 #ifdef HAVE_LANGINFO_H
59 #include "wx/msw/private.h"
60 #elif defined(__UNIX_LIKE__)
61 #include "wx/fontmap.h" // for CharsetToEncoding()
65 #include "wx/filename.h"
66 #include "wx/tokenzr.h"
67 #include "wx/fontmap.h"
68 #include "wx/encconv.h"
69 #include "wx/scopedptr.h"
70 #include "wx/apptrait.h"
71 #include "wx/stdpaths.h"
72 #include "wx/hashset.h"
73 #include "wx/filesys.h"
75 #if defined(__DARWIN__)
76 #include "wx/osx/core/cfref.h"
77 #include <CoreFoundation/CFLocale.h>
78 #include "wx/osx/core/cfstring.h"
81 // ----------------------------------------------------------------------------
83 // ----------------------------------------------------------------------------
85 // this should *not* be wxChar, this type must have exactly 8 bits!
86 typedef wxUint8 size_t8
;
87 typedef wxUint32 size_t32
;
89 // ----------------------------------------------------------------------------
91 // ----------------------------------------------------------------------------
93 // magic number identifying the .mo format file
94 const size_t32 MSGCATALOG_MAGIC
= 0x950412de;
95 const size_t32 MSGCATALOG_MAGIC_SW
= 0xde120495;
97 // the constants describing the format of ll_CC locale string
98 static const size_t LEN_LANG
= 2;
99 static const size_t LEN_SUBLANG
= 2;
100 static const size_t LEN_FULL
= LEN_LANG
+ 1 + LEN_SUBLANG
; // 1 for '_'
102 #define TRACE_I18N wxS("i18n")
104 // ----------------------------------------------------------------------------
106 // ----------------------------------------------------------------------------
108 static wxLocale
*wxSetLocale(wxLocale
*pLocale
);
113 // get just the language part
114 inline wxString
ExtractLang(const wxString
& langFull
)
116 return langFull
.Left(LEN_LANG
);
119 // helper functions of GetSystemLanguage()
122 // get everything else (including the leading '_')
123 inline wxString
ExtractNotLang(const wxString
& langFull
)
125 return langFull
.Mid(LEN_LANG
);
130 } // anonymous namespace
132 // ----------------------------------------------------------------------------
133 // Plural forms parser
134 // ----------------------------------------------------------------------------
140 LogicalOrExpression '?' Expression ':' Expression
144 LogicalAndExpression "||" LogicalOrExpression // to (a || b) || c
147 LogicalAndExpression:
148 EqualityExpression "&&" LogicalAndExpression // to (a && b) && c
152 RelationalExpression "==" RelationalExperession
153 RelationalExpression "!=" RelationalExperession
156 RelationalExpression:
157 MultiplicativeExpression '>' MultiplicativeExpression
158 MultiplicativeExpression '<' MultiplicativeExpression
159 MultiplicativeExpression ">=" MultiplicativeExpression
160 MultiplicativeExpression "<=" MultiplicativeExpression
161 MultiplicativeExpression
163 MultiplicativeExpression:
164 PmExpression '%' PmExpression
173 class wxPluralFormsToken
178 T_ERROR
, T_EOF
, T_NUMBER
, T_N
, T_PLURAL
, T_NPLURALS
, T_EQUAL
, T_ASSIGN
,
179 T_GREATER
, T_GREATER_OR_EQUAL
, T_LESS
, T_LESS_OR_EQUAL
,
180 T_REMINDER
, T_NOT_EQUAL
,
181 T_LOGICAL_AND
, T_LOGICAL_OR
, T_QUESTION
, T_COLON
, T_SEMICOLON
,
182 T_LEFT_BRACKET
, T_RIGHT_BRACKET
184 Type
type() const { return m_type
; }
185 void setType(Type type
) { m_type
= type
; }
188 Number
number() const { return m_number
; }
189 void setNumber(Number num
) { m_number
= num
; }
196 class wxPluralFormsScanner
199 wxPluralFormsScanner(const char* s
);
200 const wxPluralFormsToken
& token() const { return m_token
; }
201 bool nextToken(); // returns false if error
204 wxPluralFormsToken m_token
;
207 wxPluralFormsScanner::wxPluralFormsScanner(const char* s
) : m_s(s
)
212 bool wxPluralFormsScanner::nextToken()
214 wxPluralFormsToken::Type type
= wxPluralFormsToken::T_ERROR
;
215 while (isspace((unsigned char) *m_s
))
221 type
= wxPluralFormsToken::T_EOF
;
223 else if (isdigit((unsigned char) *m_s
))
225 wxPluralFormsToken::Number number
= *m_s
++ - '0';
226 while (isdigit((unsigned char) *m_s
))
228 number
= number
* 10 + (*m_s
++ - '0');
230 m_token
.setNumber(number
);
231 type
= wxPluralFormsToken::T_NUMBER
;
233 else if (isalpha((unsigned char) *m_s
))
235 const char* begin
= m_s
++;
236 while (isalnum((unsigned char) *m_s
))
240 size_t size
= m_s
- begin
;
241 if (size
== 1 && memcmp(begin
, "n", size
) == 0)
243 type
= wxPluralFormsToken::T_N
;
245 else if (size
== 6 && memcmp(begin
, "plural", size
) == 0)
247 type
= wxPluralFormsToken::T_PLURAL
;
249 else if (size
== 8 && memcmp(begin
, "nplurals", size
) == 0)
251 type
= wxPluralFormsToken::T_NPLURALS
;
254 else if (*m_s
== '=')
260 type
= wxPluralFormsToken::T_EQUAL
;
264 type
= wxPluralFormsToken::T_ASSIGN
;
267 else if (*m_s
== '>')
273 type
= wxPluralFormsToken::T_GREATER_OR_EQUAL
;
277 type
= wxPluralFormsToken::T_GREATER
;
280 else if (*m_s
== '<')
286 type
= wxPluralFormsToken::T_LESS_OR_EQUAL
;
290 type
= wxPluralFormsToken::T_LESS
;
293 else if (*m_s
== '%')
296 type
= wxPluralFormsToken::T_REMINDER
;
298 else if (*m_s
== '!' && m_s
[1] == '=')
301 type
= wxPluralFormsToken::T_NOT_EQUAL
;
303 else if (*m_s
== '&' && m_s
[1] == '&')
306 type
= wxPluralFormsToken::T_LOGICAL_AND
;
308 else if (*m_s
== '|' && m_s
[1] == '|')
311 type
= wxPluralFormsToken::T_LOGICAL_OR
;
313 else if (*m_s
== '?')
316 type
= wxPluralFormsToken::T_QUESTION
;
318 else if (*m_s
== ':')
321 type
= wxPluralFormsToken::T_COLON
;
322 } else if (*m_s
== ';') {
324 type
= wxPluralFormsToken::T_SEMICOLON
;
326 else if (*m_s
== '(')
329 type
= wxPluralFormsToken::T_LEFT_BRACKET
;
331 else if (*m_s
== ')')
334 type
= wxPluralFormsToken::T_RIGHT_BRACKET
;
336 m_token
.setType(type
);
337 return type
!= wxPluralFormsToken::T_ERROR
;
340 class wxPluralFormsNode
;
342 // NB: Can't use wxDEFINE_SCOPED_PTR_TYPE because wxPluralFormsNode is not
343 // fully defined yet:
344 class wxPluralFormsNodePtr
347 wxPluralFormsNodePtr(wxPluralFormsNode
*p
= NULL
) : m_p(p
) {}
348 ~wxPluralFormsNodePtr();
349 wxPluralFormsNode
& operator*() const { return *m_p
; }
350 wxPluralFormsNode
* operator->() const { return m_p
; }
351 wxPluralFormsNode
* get() const { return m_p
; }
352 wxPluralFormsNode
* release();
353 void reset(wxPluralFormsNode
*p
);
356 wxPluralFormsNode
*m_p
;
359 class wxPluralFormsNode
362 wxPluralFormsNode(const wxPluralFormsToken
& token
) : m_token(token
) {}
363 const wxPluralFormsToken
& token() const { return m_token
; }
364 const wxPluralFormsNode
* node(size_t i
) const
365 { return m_nodes
[i
].get(); }
366 void setNode(size_t i
, wxPluralFormsNode
* n
);
367 wxPluralFormsNode
* releaseNode(size_t i
);
368 wxPluralFormsToken::Number
evaluate(wxPluralFormsToken::Number n
) const;
371 wxPluralFormsToken m_token
;
372 wxPluralFormsNodePtr m_nodes
[3];
375 wxPluralFormsNodePtr::~wxPluralFormsNodePtr()
379 wxPluralFormsNode
* wxPluralFormsNodePtr::release()
381 wxPluralFormsNode
*p
= m_p
;
385 void wxPluralFormsNodePtr::reset(wxPluralFormsNode
*p
)
395 void wxPluralFormsNode::setNode(size_t i
, wxPluralFormsNode
* n
)
400 wxPluralFormsNode
* wxPluralFormsNode::releaseNode(size_t i
)
402 return m_nodes
[i
].release();
405 wxPluralFormsToken::Number
406 wxPluralFormsNode::evaluate(wxPluralFormsToken::Number n
) const
408 switch (token().type())
411 case wxPluralFormsToken::T_NUMBER
:
412 return token().number();
413 case wxPluralFormsToken::T_N
:
416 case wxPluralFormsToken::T_EQUAL
:
417 return node(0)->evaluate(n
) == node(1)->evaluate(n
);
418 case wxPluralFormsToken::T_NOT_EQUAL
:
419 return node(0)->evaluate(n
) != node(1)->evaluate(n
);
420 case wxPluralFormsToken::T_GREATER
:
421 return node(0)->evaluate(n
) > node(1)->evaluate(n
);
422 case wxPluralFormsToken::T_GREATER_OR_EQUAL
:
423 return node(0)->evaluate(n
) >= node(1)->evaluate(n
);
424 case wxPluralFormsToken::T_LESS
:
425 return node(0)->evaluate(n
) < node(1)->evaluate(n
);
426 case wxPluralFormsToken::T_LESS_OR_EQUAL
:
427 return node(0)->evaluate(n
) <= node(1)->evaluate(n
);
428 case wxPluralFormsToken::T_REMINDER
:
430 wxPluralFormsToken::Number number
= node(1)->evaluate(n
);
433 return node(0)->evaluate(n
) % number
;
440 case wxPluralFormsToken::T_LOGICAL_AND
:
441 return node(0)->evaluate(n
) && node(1)->evaluate(n
);
442 case wxPluralFormsToken::T_LOGICAL_OR
:
443 return node(0)->evaluate(n
) || node(1)->evaluate(n
);
445 case wxPluralFormsToken::T_QUESTION
:
446 return node(0)->evaluate(n
)
447 ? node(1)->evaluate(n
)
448 : node(2)->evaluate(n
);
455 class wxPluralFormsCalculator
458 wxPluralFormsCalculator() : m_nplurals(0), m_plural(0) {}
460 // input: number, returns msgstr index
461 int evaluate(int n
) const;
463 // input: text after "Plural-Forms:" (e.g. "nplurals=2; plural=(n != 1);"),
464 // if s == 0, creates default handler
465 // returns 0 if error
466 static wxPluralFormsCalculator
* make(const char* s
= 0);
468 ~wxPluralFormsCalculator() {}
470 void init(wxPluralFormsToken::Number nplurals
, wxPluralFormsNode
* plural
);
473 wxPluralFormsToken::Number m_nplurals
;
474 wxPluralFormsNodePtr m_plural
;
477 wxDEFINE_SCOPED_PTR_TYPE(wxPluralFormsCalculator
)
479 void wxPluralFormsCalculator::init(wxPluralFormsToken::Number nplurals
,
480 wxPluralFormsNode
* plural
)
482 m_nplurals
= nplurals
;
483 m_plural
.reset(plural
);
486 int wxPluralFormsCalculator::evaluate(int n
) const
488 if (m_plural
.get() == 0)
492 wxPluralFormsToken::Number number
= m_plural
->evaluate(n
);
493 if (number
< 0 || number
> m_nplurals
)
501 class wxPluralFormsParser
504 wxPluralFormsParser(wxPluralFormsScanner
& scanner
) : m_scanner(scanner
) {}
505 bool parse(wxPluralFormsCalculator
& rCalculator
);
508 wxPluralFormsNode
* parsePlural();
509 // stops at T_SEMICOLON, returns 0 if error
510 wxPluralFormsScanner
& m_scanner
;
511 const wxPluralFormsToken
& token() const;
514 wxPluralFormsNode
* expression();
515 wxPluralFormsNode
* logicalOrExpression();
516 wxPluralFormsNode
* logicalAndExpression();
517 wxPluralFormsNode
* equalityExpression();
518 wxPluralFormsNode
* multiplicativeExpression();
519 wxPluralFormsNode
* relationalExpression();
520 wxPluralFormsNode
* pmExpression();
523 bool wxPluralFormsParser::parse(wxPluralFormsCalculator
& rCalculator
)
525 if (token().type() != wxPluralFormsToken::T_NPLURALS
)
529 if (token().type() != wxPluralFormsToken::T_ASSIGN
)
533 if (token().type() != wxPluralFormsToken::T_NUMBER
)
535 wxPluralFormsToken::Number nplurals
= token().number();
538 if (token().type() != wxPluralFormsToken::T_SEMICOLON
)
542 if (token().type() != wxPluralFormsToken::T_PLURAL
)
546 if (token().type() != wxPluralFormsToken::T_ASSIGN
)
550 wxPluralFormsNode
* plural
= parsePlural();
553 if (token().type() != wxPluralFormsToken::T_SEMICOLON
)
557 if (token().type() != wxPluralFormsToken::T_EOF
)
559 rCalculator
.init(nplurals
, plural
);
563 wxPluralFormsNode
* wxPluralFormsParser::parsePlural()
565 wxPluralFormsNode
* p
= expression();
570 wxPluralFormsNodePtr
n(p
);
571 if (token().type() != wxPluralFormsToken::T_SEMICOLON
)
578 const wxPluralFormsToken
& wxPluralFormsParser::token() const
580 return m_scanner
.token();
583 bool wxPluralFormsParser::nextToken()
585 if (!m_scanner
.nextToken())
590 wxPluralFormsNode
* wxPluralFormsParser::expression()
592 wxPluralFormsNode
* p
= logicalOrExpression();
595 wxPluralFormsNodePtr
n(p
);
596 if (token().type() == wxPluralFormsToken::T_QUESTION
)
598 wxPluralFormsNodePtr
qn(new wxPluralFormsNode(token()));
609 if (token().type() != wxPluralFormsToken::T_COLON
)
623 qn
->setNode(0, n
.release());
629 wxPluralFormsNode
*wxPluralFormsParser::logicalOrExpression()
631 wxPluralFormsNode
* p
= logicalAndExpression();
634 wxPluralFormsNodePtr
ln(p
);
635 if (token().type() == wxPluralFormsToken::T_LOGICAL_OR
)
637 wxPluralFormsNodePtr
un(new wxPluralFormsNode(token()));
642 p
= logicalOrExpression();
647 wxPluralFormsNodePtr
rn(p
); // right
648 if (rn
->token().type() == wxPluralFormsToken::T_LOGICAL_OR
)
650 // see logicalAndExpression comment
651 un
->setNode(0, ln
.release());
652 un
->setNode(1, rn
->releaseNode(0));
653 rn
->setNode(0, un
.release());
658 un
->setNode(0, ln
.release());
659 un
->setNode(1, rn
.release());
665 wxPluralFormsNode
* wxPluralFormsParser::logicalAndExpression()
667 wxPluralFormsNode
* p
= equalityExpression();
670 wxPluralFormsNodePtr
ln(p
); // left
671 if (token().type() == wxPluralFormsToken::T_LOGICAL_AND
)
673 wxPluralFormsNodePtr
un(new wxPluralFormsNode(token())); // up
678 p
= logicalAndExpression();
683 wxPluralFormsNodePtr
rn(p
); // right
684 if (rn
->token().type() == wxPluralFormsToken::T_LOGICAL_AND
)
686 // transform 1 && (2 && 3) -> (1 && 2) && 3
690 un
->setNode(0, ln
.release());
691 un
->setNode(1, rn
->releaseNode(0));
692 rn
->setNode(0, un
.release());
696 un
->setNode(0, ln
.release());
697 un
->setNode(1, rn
.release());
703 wxPluralFormsNode
* wxPluralFormsParser::equalityExpression()
705 wxPluralFormsNode
* p
= relationalExpression();
708 wxPluralFormsNodePtr
n(p
);
709 if (token().type() == wxPluralFormsToken::T_EQUAL
710 || token().type() == wxPluralFormsToken::T_NOT_EQUAL
)
712 wxPluralFormsNodePtr
qn(new wxPluralFormsNode(token()));
717 p
= relationalExpression();
723 qn
->setNode(0, n
.release());
729 wxPluralFormsNode
* wxPluralFormsParser::relationalExpression()
731 wxPluralFormsNode
* p
= multiplicativeExpression();
734 wxPluralFormsNodePtr
n(p
);
735 if (token().type() == wxPluralFormsToken::T_GREATER
736 || token().type() == wxPluralFormsToken::T_LESS
737 || token().type() == wxPluralFormsToken::T_GREATER_OR_EQUAL
738 || token().type() == wxPluralFormsToken::T_LESS_OR_EQUAL
)
740 wxPluralFormsNodePtr
qn(new wxPluralFormsNode(token()));
745 p
= multiplicativeExpression();
751 qn
->setNode(0, n
.release());
757 wxPluralFormsNode
* wxPluralFormsParser::multiplicativeExpression()
759 wxPluralFormsNode
* p
= pmExpression();
762 wxPluralFormsNodePtr
n(p
);
763 if (token().type() == wxPluralFormsToken::T_REMINDER
)
765 wxPluralFormsNodePtr
qn(new wxPluralFormsNode(token()));
776 qn
->setNode(0, n
.release());
782 wxPluralFormsNode
* wxPluralFormsParser::pmExpression()
784 wxPluralFormsNodePtr n
;
785 if (token().type() == wxPluralFormsToken::T_N
786 || token().type() == wxPluralFormsToken::T_NUMBER
)
788 n
.reset(new wxPluralFormsNode(token()));
794 else if (token().type() == wxPluralFormsToken::T_LEFT_BRACKET
) {
799 wxPluralFormsNode
* p
= expression();
805 if (token().type() != wxPluralFormsToken::T_RIGHT_BRACKET
)
821 wxPluralFormsCalculator
* wxPluralFormsCalculator::make(const char* s
)
823 wxPluralFormsCalculatorPtr
calculator(new wxPluralFormsCalculator
);
826 wxPluralFormsScanner
scanner(s
);
827 wxPluralFormsParser
p(scanner
);
828 if (!p
.parse(*calculator
))
833 return calculator
.release();
839 // ----------------------------------------------------------------------------
840 // wxMsgCatalogFile corresponds to one disk-file message catalog.
842 // This is a "low-level" class and is used only by wxMsgCatalog
843 // NOTE: for the documentation of the binary catalog (.MO) files refer to
844 // the GNU gettext manual:
845 // http://www.gnu.org/software/autoconf/manual/gettext/MO-Files.html
846 // ----------------------------------------------------------------------------
848 WX_DECLARE_EXPORTED_STRING_HASH_MAP(wxString
, wxMessagesHash
);
850 class wxMsgCatalogFile
857 // load the catalog from disk (szDirPrefix corresponds to language)
858 bool Load(const wxString
& szDirPrefix
, const wxString
& szName
,
859 wxPluralFormsCalculatorPtr
& rPluralFormsCalculator
);
861 // fills the hash with string-translation pairs
862 bool FillHash(wxMessagesHash
& hash
,
863 const wxString
& msgIdCharset
,
864 bool convertEncoding
) const;
866 // return the charset of the strings in this catalog or empty string if
868 wxString
GetCharset() const { return m_charset
; }
871 // this implementation is binary compatible with GNU gettext() version 0.10
873 // an entry in the string table
874 struct wxMsgTableEntry
876 size_t32 nLen
; // length of the string
877 size_t32 ofsString
; // pointer to the string
880 // header of a .mo file
881 struct wxMsgCatalogHeader
883 size_t32 magic
, // offset +00: magic id
884 revision
, // +04: revision
885 numStrings
; // +08: number of strings in the file
886 size_t32 ofsOrigTable
, // +0C: start of original string table
887 ofsTransTable
; // +10: start of translated string table
888 size_t32 nHashSize
, // +14: hash table size
889 ofsHashTable
; // +18: offset of hash table start
892 // all data is stored here
893 wxMemoryBuffer m_data
;
896 size_t32 m_numStrings
; // number of strings in this domain
897 wxMsgTableEntry
*m_pOrigTable
, // pointer to original strings
898 *m_pTransTable
; // translated
900 wxString m_charset
; // from the message catalog header
903 // swap the 2 halves of 32 bit integer if needed
904 size_t32
Swap(size_t32 ui
) const
906 return m_bSwapped
? (ui
<< 24) | ((ui
& 0xff00) << 8) |
907 ((ui
>> 8) & 0xff00) | (ui
>> 24)
911 // just return the pointer to the start of the data as "char *" to
912 // facilitate doing pointer arithmetic with it
913 char *StringData() const
915 return static_cast<char *>(m_data
.GetData());
918 const char *StringAtOfs(wxMsgTableEntry
*pTable
, size_t32 n
) const
920 const wxMsgTableEntry
* const ent
= pTable
+ n
;
922 // this check could fail for a corrupt message catalog
923 size_t32 ofsString
= Swap(ent
->ofsString
);
924 if ( ofsString
+ Swap(ent
->nLen
) > m_data
.GetDataLen())
929 return StringData() + ofsString
;
932 bool m_bSwapped
; // wrong endianness?
934 wxDECLARE_NO_COPY_CLASS(wxMsgCatalogFile
);
938 // ----------------------------------------------------------------------------
939 // wxMsgCatalog corresponds to one loaded message catalog.
941 // This is a "low-level" class and is used only by wxLocale (that's why
942 // it's designed to be stored in a linked list)
943 // ----------------------------------------------------------------------------
949 wxMsgCatalog() { m_conv
= NULL
; }
953 // load the catalog from disk (szDirPrefix corresponds to language)
954 bool Load(const wxString
& dirPrefix
, const wxString
& name
,
955 const wxString
& msgIdCharset
, bool bConvertEncoding
= false);
957 // get name of the catalog
958 wxString
GetName() const { return m_name
; }
960 // get the translated string: returns NULL if not found
961 const wxString
*GetString(const wxString
& sz
, size_t n
= size_t(-1)) const;
963 // public variable pointing to the next element in a linked list (or NULL)
964 wxMsgCatalog
*m_pNext
;
967 wxMessagesHash m_messages
; // all messages in the catalog
968 wxString m_name
; // name of the domain
971 // the conversion corresponding to this catalog charset if we installed it
976 wxPluralFormsCalculatorPtr m_pluralFormsCalculator
;
979 // ----------------------------------------------------------------------------
981 // ----------------------------------------------------------------------------
983 // the list of the directories to search for message catalog files
984 static wxArrayString gs_searchPrefixes
;
986 // ============================================================================
988 // ============================================================================
990 // ----------------------------------------------------------------------------
992 // ----------------------------------------------------------------------------
996 // helper used by wxLanguageInfo::GetLocaleName() and elsewhere to determine
997 // whether the locale is Unicode-only (it is if this function returns empty
999 static wxString
wxGetANSICodePageForLocale(LCID lcid
)
1004 if ( ::GetLocaleInfo(lcid
, LOCALE_IDEFAULTANSICODEPAGE
,
1005 buffer
, WXSIZEOF(buffer
)) > 0 )
1007 if ( buffer
[0] != _T('0') || buffer
[1] != _T('\0') )
1009 //else: this locale doesn't use ANSI code page
1015 wxUint32
wxLanguageInfo::GetLCID() const
1017 return MAKELCID(MAKELANGID(WinLang
, WinSublang
), SORT_DEFAULT
);
1020 wxString
wxLanguageInfo::GetLocaleName() const
1024 const LCID lcid
= GetLCID();
1027 buffer
[0] = _T('\0');
1028 if ( !::GetLocaleInfo(lcid
, LOCALE_SENGLANGUAGE
, buffer
, WXSIZEOF(buffer
)) )
1030 wxLogLastError(_T("GetLocaleInfo(LOCALE_SENGLANGUAGE)"));
1035 if ( ::GetLocaleInfo(lcid
, LOCALE_SENGCOUNTRY
,
1036 buffer
, WXSIZEOF(buffer
)) > 0 )
1038 locale
<< _T('_') << buffer
;
1041 const wxString cp
= wxGetANSICodePageForLocale(lcid
);
1044 locale
<< _T('.') << cp
;
1052 // ----------------------------------------------------------------------------
1053 // wxMsgCatalogFile class
1054 // ----------------------------------------------------------------------------
1056 wxMsgCatalogFile::wxMsgCatalogFile()
1060 wxMsgCatalogFile::~wxMsgCatalogFile()
1064 // return the directories to search for message catalogs under the given
1065 // prefix, separated by wxPATH_SEP
1067 wxString
GetMsgCatalogSubdirs(const wxString
& prefix
, const wxString
& lang
)
1069 // Search first in Unix-standard prefix/lang/LC_MESSAGES, then in
1070 // prefix/lang and finally in just prefix.
1072 // Note that we use LC_MESSAGES on all platforms and not just Unix, because
1073 // it doesn't cost much to look into one more directory and doing it this
1074 // way has two important benefits:
1075 // a) we don't break compatibility with wx-2.6 and older by stopping to
1076 // look in a directory where the catalogs used to be and thus silently
1077 // breaking apps after they are recompiled against the latest wx
1078 // b) it makes it possible to package app's support files in the same
1079 // way on all target platforms
1080 const wxString pathPrefix
= wxFileName(prefix
, lang
).GetFullPath();
1082 wxString searchPath
;
1083 searchPath
.reserve(4*pathPrefix
.length());
1084 searchPath
<< pathPrefix
<< wxFILE_SEP_PATH
<< "LC_MESSAGES" << wxPATH_SEP
1085 << prefix
<< wxFILE_SEP_PATH
<< wxPATH_SEP
1091 // construct the search path for the given language
1092 static wxString
GetFullSearchPath(const wxString
& lang
)
1094 // first take the entries explicitly added by the program
1095 wxArrayString paths
;
1096 paths
.reserve(gs_searchPrefixes
.size() + 1);
1098 count
= gs_searchPrefixes
.size();
1099 for ( n
= 0; n
< count
; n
++ )
1101 paths
.Add(GetMsgCatalogSubdirs(gs_searchPrefixes
[n
], lang
));
1106 // then look in the standard location
1107 const wxString stdp
= wxStandardPaths::Get().
1108 GetLocalizedResourcesDir(lang
, wxStandardPaths::ResourceCat_Messages
);
1110 if ( paths
.Index(stdp
) == wxNOT_FOUND
)
1112 #endif // wxUSE_STDPATHS
1114 // last look in default locations
1116 // LC_PATH is a standard env var containing the search path for the .mo
1118 const char *pszLcPath
= wxGetenv("LC_PATH");
1121 const wxString lcp
= GetMsgCatalogSubdirs(pszLcPath
, lang
);
1122 if ( paths
.Index(lcp
) == wxNOT_FOUND
)
1126 // also add the one from where wxWin was installed:
1127 wxString wxp
= wxGetInstallPrefix();
1130 wxp
= GetMsgCatalogSubdirs(wxp
+ wxS("/share/locale"), lang
);
1131 if ( paths
.Index(wxp
) == wxNOT_FOUND
)
1137 // finally construct the full search path
1138 wxString searchPath
;
1139 searchPath
.reserve(500);
1140 count
= paths
.size();
1141 for ( n
= 0; n
< count
; n
++ )
1143 searchPath
+= paths
[n
];
1144 if ( n
!= count
- 1 )
1145 searchPath
+= wxPATH_SEP
;
1151 // open disk file and read in it's contents
1152 bool wxMsgCatalogFile::Load(const wxString
& szDirPrefix
, const wxString
& szName
,
1153 wxPluralFormsCalculatorPtr
& rPluralFormsCalculator
)
1155 wxCHECK_MSG( szDirPrefix
.length() >= LEN_LANG
, false,
1156 "invalid language specification" );
1158 wxString searchPath
;
1161 // first look for the catalog for this language and the current locale:
1162 // notice that we don't use the system name for the locale as this would
1163 // force us to install catalogs in different locations depending on the
1164 // system but always use the canonical name
1165 wxFontEncoding encSys
= wxLocale::GetSystemEncoding();
1166 if ( encSys
!= wxFONTENCODING_SYSTEM
)
1168 wxString
fullname(szDirPrefix
);
1169 fullname
<< wxS('.') << wxFontMapperBase::GetEncodingName(encSys
);
1170 searchPath
<< GetFullSearchPath(fullname
) << wxPATH_SEP
;
1172 #endif // wxUSE_FONTMAP
1175 searchPath
+= GetFullSearchPath(szDirPrefix
);
1176 if ( szDirPrefix
.length() > LEN_LANG
&& szDirPrefix
[LEN_LANG
] == wxS('_') )
1178 // also add just base locale name: for things like "fr_BE" (Belgium
1179 // French) we should use fall back on plain "fr" if no Belgium-specific
1180 // message catalogs exist
1181 searchPath
<< wxPATH_SEP
1182 << GetFullSearchPath(ExtractLang(szDirPrefix
));
1185 wxLogTrace(TRACE_I18N
, wxS("Looking for \"%s.mo\" in search path \"%s\""),
1186 szName
, searchPath
);
1188 wxFileName
fn(szName
);
1189 fn
.SetExt(wxS("mo"));
1191 wxString strFullName
;
1192 #if wxUSE_FILESYSTEM
1193 wxFileSystem fileSys
;
1194 if ( !fileSys
.FindFileInPath(&strFullName
, searchPath
, fn
.GetFullPath()) )
1195 #else // !wxUSE_FILESYSTEM
1196 if ( !wxFindFileInPath(&strFullName
, searchPath
, fn
.GetFullPath()) )
1197 #endif // wxUSE_FILESYSTEM/!wxUSE_FILESYSTEM
1199 wxLogVerbose(_("catalog file for domain '%s' not found."), szName
);
1200 wxLogTrace(TRACE_I18N
, wxS("Catalog \"%s.mo\" not found"), szName
);
1204 // open file and read its data
1205 wxLogVerbose(_("using catalog '%s' from '%s'."), szName
, strFullName
.c_str());
1206 wxLogTrace(TRACE_I18N
, wxS("Using catalog \"%s\"."), strFullName
.c_str());
1208 #if wxUSE_FILESYSTEM
1209 wxFSFile
* const fileMsg
= fileSys
.OpenFile(strFullName
);
1213 wxInputStream
*fileStream
= fileMsg
->GetStream();
1214 m_data
.SetDataLen(0);
1216 static const size_t chunkSize
= 4096;
1217 while ( !fileStream
->Eof() ) {
1218 fileStream
->Read(m_data
.GetAppendBuf(chunkSize
), chunkSize
);
1219 m_data
.UngetAppendBuf(fileStream
->LastRead());
1223 #else // !wxUSE_FILESYSTEM
1224 wxFile
fileMsg(strFullName
);
1225 if ( !fileMsg
.IsOpened() )
1228 // get the file size (assume it is less than 4Gb...)
1229 wxFileOffset lenFile
= fileMsg
.Length();
1230 if ( lenFile
== wxInvalidOffset
)
1233 size_t nSize
= wx_truncate_cast(size_t, lenFile
);
1234 wxASSERT_MSG( nSize
== lenFile
+ size_t(0), wxS("message catalog bigger than 4GB?") );
1236 // read the whole file in memory
1237 if ( fileMsg
.Read(m_data
.GetWriteBuf(nSize
), nSize
) != lenFile
)
1240 m_data
.UngetWriteBuf(nSize
);
1241 #endif // wxUSE_FILESYSTEM/!wxUSE_FILESYSTEM
1245 bool bValid
= m_data
.GetDataLen() > sizeof(wxMsgCatalogHeader
);
1247 const wxMsgCatalogHeader
*pHeader
= (wxMsgCatalogHeader
*)m_data
.GetData();
1249 // we'll have to swap all the integers if it's true
1250 m_bSwapped
= pHeader
->magic
== MSGCATALOG_MAGIC_SW
;
1252 // check the magic number
1253 bValid
= m_bSwapped
|| pHeader
->magic
== MSGCATALOG_MAGIC
;
1257 // it's either too short or has incorrect magic number
1258 wxLogWarning(_("'%s' is not a valid message catalog."), strFullName
.c_str());
1264 m_numStrings
= Swap(pHeader
->numStrings
);
1265 m_pOrigTable
= (wxMsgTableEntry
*)(StringData() +
1266 Swap(pHeader
->ofsOrigTable
));
1267 m_pTransTable
= (wxMsgTableEntry
*)(StringData() +
1268 Swap(pHeader
->ofsTransTable
));
1270 // now parse catalog's header and try to extract catalog charset and
1271 // plural forms formula from it:
1273 const char* headerData
= StringAtOfs(m_pOrigTable
, 0);
1274 if ( headerData
&& headerData
[0] == '\0' )
1276 // Extract the charset:
1277 const char * const header
= StringAtOfs(m_pTransTable
, 0);
1279 cset
= strstr(header
, "Content-Type: text/plain; charset=");
1282 cset
+= 34; // strlen("Content-Type: text/plain; charset=")
1284 const char * const csetEnd
= strchr(cset
, '\n');
1287 m_charset
= wxString(cset
, csetEnd
- cset
);
1288 if ( m_charset
== wxS("CHARSET") )
1290 // "CHARSET" is not valid charset, but lazy translator
1295 // else: incorrectly filled Content-Type header
1297 // Extract plural forms:
1298 const char * plurals
= strstr(header
, "Plural-Forms:");
1301 plurals
+= 13; // strlen("Plural-Forms:")
1302 const char * const pluralsEnd
= strchr(plurals
, '\n');
1305 const size_t pluralsLen
= pluralsEnd
- plurals
;
1306 wxCharBuffer
buf(pluralsLen
);
1307 strncpy(buf
.data(), plurals
, pluralsLen
);
1308 wxPluralFormsCalculator
* const
1309 pCalculator
= wxPluralFormsCalculator::make(buf
);
1312 rPluralFormsCalculator
.reset(pCalculator
);
1316 wxLogVerbose(_("Failed to parse Plural-Forms: '%s'"),
1322 if ( !rPluralFormsCalculator
.get() )
1323 rPluralFormsCalculator
.reset(wxPluralFormsCalculator::make());
1326 // everything is fine
1330 bool wxMsgCatalogFile::FillHash(wxMessagesHash
& hash
,
1331 const wxString
& msgIdCharset
,
1332 bool convertEncoding
) const
1335 // this parameter doesn't make sense, we always must convert encoding in
1337 convertEncoding
= true;
1339 if ( convertEncoding
)
1341 // determine if we need any conversion at all
1342 wxFontEncoding encCat
= wxFontMapperBase::GetEncodingFromName(m_charset
);
1343 if ( encCat
== wxLocale::GetSystemEncoding() )
1345 // no need to convert
1346 convertEncoding
= false;
1349 #endif // wxUSE_UNICODE/wxUSE_FONTMAP
1352 // conversion to use to convert catalog strings to the GUI encoding
1353 wxMBConv
*inputConv
,
1354 *inputConvPtr
= NULL
; // same as inputConv but safely deleteable
1355 if ( convertEncoding
&& !m_charset
.empty() )
1358 inputConv
= new wxCSConv(m_charset
);
1360 else // no need or not possible to convert the encoding
1363 // we must somehow convert the narrow strings in the message catalog to
1364 // wide strings, so use the default conversion if we have no charset
1365 inputConv
= wxConvCurrent
;
1366 #else // !wxUSE_UNICODE
1368 #endif // wxUSE_UNICODE/!wxUSE_UNICODE
1371 // conversion to apply to msgid strings before looking them up: we only
1372 // need it if the msgids are neither in 7 bit ASCII nor in the same
1373 // encoding as the catalog
1374 wxCSConv
*sourceConv
= msgIdCharset
.empty() || (msgIdCharset
== m_charset
)
1376 : new wxCSConv(msgIdCharset
);
1379 wxASSERT_MSG( msgIdCharset
.empty(),
1380 wxS("non-ASCII msgid languages only supported if wxUSE_WCHAR_T=1") );
1382 wxEncodingConverter converter
;
1383 if ( convertEncoding
)
1385 wxFontEncoding targetEnc
= wxFONTENCODING_SYSTEM
;
1386 wxFontEncoding enc
= wxFontMapperBase::Get()->CharsetToEncoding(m_charset
, false);
1387 if ( enc
== wxFONTENCODING_SYSTEM
)
1389 convertEncoding
= false; // unknown encoding
1393 targetEnc
= wxLocale::GetSystemEncoding();
1394 if (targetEnc
== wxFONTENCODING_SYSTEM
)
1396 wxFontEncodingArray a
= wxEncodingConverter::GetPlatformEquivalents(enc
);
1398 // no conversion needed, locale uses native encoding
1399 convertEncoding
= false;
1400 if (a
.GetCount() == 0)
1401 // we don't know common equiv. under this platform
1402 convertEncoding
= false;
1407 if ( convertEncoding
)
1409 converter
.Init(enc
, targetEnc
);
1412 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
1413 (void)convertEncoding
; // get rid of warnings about unused parameter
1415 for (size_t32 i
= 0; i
< m_numStrings
; i
++)
1417 const char *data
= StringAtOfs(m_pOrigTable
, i
);
1419 return false; // may happen for invalid MO files
1423 msgid
= wxString(data
, *inputConv
);
1426 if ( inputConv
&& sourceConv
)
1427 msgid
= wxString(inputConv
->cMB2WC(data
), *sourceConv
);
1431 #endif // wxUSE_UNICODE
1433 data
= StringAtOfs(m_pTransTable
, i
);
1435 return false; // may happen for invalid MO files
1437 size_t length
= Swap(m_pTransTable
[i
].nLen
);
1440 while (offset
< length
)
1442 const char * const str
= data
+ offset
;
1446 msgstr
= wxString(str
, *inputConv
);
1449 msgstr
= wxString(inputConv
->cMB2WC(str
), *wxConvUI
);
1452 #else // !wxUSE_WCHAR_T
1454 if ( bConvertEncoding
)
1455 msgstr
= wxString(converter
.Convert(str
));
1459 #endif // wxUSE_WCHAR_T/!wxUSE_WCHAR_T
1461 if ( !msgstr
.empty() )
1463 hash
[index
== 0 ? msgid
: msgid
+ wxChar(index
)] = msgstr
;
1467 // IMPORTANT: accesses to the 'data' pointer are valid only for
1468 // the first 'length+1' bytes (GNU specs says that the
1469 // final NUL is not counted in length); using wxStrnlen()
1470 // we make sure we don't access memory beyond the valid range
1471 // (which otherwise may happen for invalid MO files):
1472 offset
+= wxStrnlen(str
, length
- offset
) + 1;
1479 delete inputConvPtr
;
1480 #endif // wxUSE_WCHAR_T
1486 // ----------------------------------------------------------------------------
1487 // wxMsgCatalog class
1488 // ----------------------------------------------------------------------------
1491 wxMsgCatalog::~wxMsgCatalog()
1495 if ( wxConvUI
== m_conv
)
1497 // we only change wxConvUI if it points to wxConvLocal so we reset
1498 // it back to it too
1499 wxConvUI
= &wxConvLocal
;
1505 #endif // !wxUSE_UNICODE
1507 bool wxMsgCatalog::Load(const wxString
& dirPrefix
, const wxString
& name
,
1508 const wxString
& msgIdCharset
, bool bConvertEncoding
)
1510 wxMsgCatalogFile file
;
1514 if ( !file
.Load(dirPrefix
, name
, m_pluralFormsCalculator
) )
1517 if ( !file
.FillHash(m_messages
, msgIdCharset
, bConvertEncoding
) )
1521 // we should use a conversion compatible with the message catalog encoding
1522 // in the GUI if we don't convert the strings to the current conversion but
1523 // as the encoding is global, only change it once, otherwise we could get
1524 // into trouble if we use several message catalogs with different encodings
1526 // this is, of course, a hack but it at least allows the program to use
1527 // message catalogs in any encodings without asking the user to change his
1529 if ( !bConvertEncoding
&&
1530 !file
.GetCharset().empty() &&
1531 wxConvUI
== &wxConvLocal
)
1534 m_conv
= new wxCSConv(file
.GetCharset());
1536 #endif // !wxUSE_UNICODE
1541 const wxString
*wxMsgCatalog::GetString(const wxString
& str
, size_t n
) const
1544 if (n
!= size_t(-1))
1546 index
= m_pluralFormsCalculator
->evaluate(n
);
1548 wxMessagesHash::const_iterator i
;
1551 i
= m_messages
.find(wxString(str
) + wxChar(index
)); // plural
1555 i
= m_messages
.find(str
);
1558 if ( i
!= m_messages
.end() )
1566 // ----------------------------------------------------------------------------
1568 // ----------------------------------------------------------------------------
1570 #include "wx/arrimpl.cpp"
1571 WX_DECLARE_EXPORTED_OBJARRAY(wxLanguageInfo
, wxLanguageInfoArray
);
1572 WX_DEFINE_OBJARRAY(wxLanguageInfoArray
)
1574 wxLanguageInfoArray
*wxLocale::ms_languagesDB
= NULL
;
1576 /*static*/ void wxLocale::CreateLanguagesDB()
1578 if (ms_languagesDB
== NULL
)
1580 ms_languagesDB
= new wxLanguageInfoArray
;
1585 /*static*/ void wxLocale::DestroyLanguagesDB()
1587 delete ms_languagesDB
;
1588 ms_languagesDB
= NULL
;
1592 void wxLocale::DoCommonInit()
1594 m_pszOldLocale
= NULL
;
1596 m_pOldLocale
= wxSetLocale(this);
1599 m_language
= wxLANGUAGE_UNKNOWN
;
1600 m_initialized
= false;
1603 // NB: this function has (desired) side effect of changing current locale
1604 bool wxLocale::Init(const wxString
& name
,
1605 const wxString
& shortName
,
1606 const wxString
& locale
,
1608 bool bConvertEncoding
)
1610 wxASSERT_MSG( !m_initialized
,
1611 wxS("you can't call wxLocale::Init more than once") );
1613 m_initialized
= true;
1615 m_strShort
= shortName
;
1616 m_bConvertEncoding
= bConvertEncoding
;
1617 m_language
= wxLANGUAGE_UNKNOWN
;
1619 // change current locale (default: same as long name)
1620 wxString
szLocale(locale
);
1621 if ( szLocale
.empty() )
1623 // the argument to setlocale()
1624 szLocale
= shortName
;
1626 wxCHECK_MSG( !szLocale
.empty(), false,
1627 wxS("no locale to set in wxLocale::Init()") );
1630 const char *oldLocale
= wxSetlocale(LC_ALL
, szLocale
);
1632 m_pszOldLocale
= wxStrdup(oldLocale
);
1634 m_pszOldLocale
= NULL
;
1636 if ( m_pszOldLocale
== NULL
)
1637 wxLogError(_("locale '%s' can not be set."), szLocale
);
1639 // the short name will be used to look for catalog files as well,
1640 // so we need something here
1641 if ( m_strShort
.empty() ) {
1642 // FIXME I don't know how these 2 letter abbreviations are formed,
1643 // this wild guess is surely wrong
1644 if ( !szLocale
.empty() )
1646 m_strShort
+= (wxChar
)wxTolower(szLocale
[0]);
1647 if ( szLocale
.length() > 1 )
1648 m_strShort
+= (wxChar
)wxTolower(szLocale
[1]);
1652 // load the default catalog with wxWidgets standard messages
1657 bOk
= AddCatalog(wxS("wxstd"));
1659 // there may be a catalog with toolkit specific overrides, it is not
1660 // an error if this does not exist
1663 wxString
port(wxPlatformInfo::Get().GetPortIdName());
1664 if ( !port
.empty() )
1666 AddCatalog(port
.BeforeFirst(wxS('/')).MakeLower());
1675 #if defined(__UNIX__) && wxUSE_UNICODE && !defined(__WXMAC__)
1676 static const char *wxSetlocaleTryUTF8(int c
, const wxString
& lc
)
1678 const char *l
= NULL
;
1680 // NB: We prefer to set UTF-8 locale if it's possible and only fall back to
1681 // non-UTF-8 locale if it fails
1687 buf2
= buf
+ wxS(".UTF-8");
1688 l
= wxSetlocale(c
, buf2
);
1691 buf2
= buf
+ wxS(".utf-8");
1692 l
= wxSetlocale(c
, buf2
);
1696 buf2
= buf
+ wxS(".UTF8");
1697 l
= wxSetlocale(c
, buf2
);
1701 buf2
= buf
+ wxS(".utf8");
1702 l
= wxSetlocale(c
, buf2
);
1706 // if we can't set UTF-8 locale, try non-UTF-8 one:
1708 l
= wxSetlocale(c
, lc
);
1713 #define wxSetlocaleTryUTF8(c, lc) wxSetlocale(c, lc)
1716 bool wxLocale::Init(int language
, int flags
)
1720 int lang
= language
;
1721 if (lang
== wxLANGUAGE_DEFAULT
)
1723 // auto detect the language
1724 lang
= GetSystemLanguage();
1727 // We failed to detect system language, so we will use English:
1728 if (lang
== wxLANGUAGE_UNKNOWN
)
1733 const wxLanguageInfo
*info
= GetLanguageInfo(lang
);
1735 // Unknown language:
1738 wxLogError(wxS("Unknown language %i."), lang
);
1742 wxString name
= info
->Description
;
1743 wxString canonical
= info
->CanonicalName
;
1747 #if defined(__OS2__)
1748 const char *retloc
= wxSetlocale(LC_ALL
, wxEmptyString
);
1749 #elif defined(__UNIX__) && !defined(__WXMAC__)
1750 if (language
!= wxLANGUAGE_DEFAULT
)
1751 locale
= info
->CanonicalName
;
1753 const char *retloc
= wxSetlocaleTryUTF8(LC_ALL
, locale
);
1755 const wxString langOnly
= ExtractLang(locale
);
1758 // Some C libraries don't like xx_YY form and require xx only
1759 retloc
= wxSetlocaleTryUTF8(LC_ALL
, langOnly
);
1763 // some systems (e.g. FreeBSD and HP-UX) don't have xx_YY aliases but
1764 // require the full xx_YY.encoding form, so try using UTF-8 because this is
1765 // the only thing we can do generically
1767 // TODO: add encodings applicable to each language to the lang DB and try
1768 // them all in turn here
1771 const wxChar
**names
=
1772 wxFontMapperBase::GetAllEncodingNames(wxFONTENCODING_UTF8
);
1775 retloc
= wxSetlocale(LC_ALL
, locale
+ wxS('.') + *names
++);
1780 #endif // wxUSE_FONTMAP
1784 // Some C libraries (namely glibc) still use old ISO 639,
1785 // so will translate the abbrev for them
1787 if ( langOnly
== wxS("he") )
1788 localeAlt
= wxS("iw") + ExtractNotLang(locale
);
1789 else if ( langOnly
== wxS("id") )
1790 localeAlt
= wxS("in") + ExtractNotLang(locale
);
1791 else if ( langOnly
== wxS("yi") )
1792 localeAlt
= wxS("ji") + ExtractNotLang(locale
);
1793 else if ( langOnly
== wxS("nb") )
1794 localeAlt
= wxS("no_NO");
1795 else if ( langOnly
== wxS("nn") )
1796 localeAlt
= wxS("no_NY");
1798 if ( !localeAlt
.empty() )
1800 retloc
= wxSetlocaleTryUTF8(LC_ALL
, localeAlt
);
1802 retloc
= wxSetlocaleTryUTF8(LC_ALL
, ExtractLang(localeAlt
));
1810 // at least in AIX 5.2 libc is buggy and the string returned from
1811 // setlocale(LC_ALL) can't be passed back to it because it returns 6
1812 // strings (one for each locale category), i.e. for C locale we get back
1815 // this contradicts IBM own docs but this is not of much help, so just work
1816 // around it in the crudest possible manner
1817 char* p
= const_cast<char*>(wxStrchr(retloc
, ' '));
1822 #elif defined(__WIN32__)
1823 const char *retloc
= "C";
1824 if ( language
!= wxLANGUAGE_DEFAULT
)
1826 if ( info
->WinLang
== 0 )
1828 wxLogWarning(wxS("Locale '%s' not supported by OS."), name
.c_str());
1829 // retloc already set to "C"
1831 else // language supported by Windows
1833 // Windows CE doesn't have SetThreadLocale() and there doesn't seem
1834 // to be any equivalent
1836 const wxUint32 lcid
= info
->GetLCID();
1838 // change locale used by Windows functions
1839 ::SetThreadLocale(lcid
);
1842 // and also call setlocale() to change locale used by the CRT
1843 locale
= info
->GetLocaleName();
1844 if ( locale
.empty() )
1848 else // have a valid locale
1850 retloc
= wxSetlocale(LC_ALL
, locale
);
1854 else // language == wxLANGUAGE_DEFAULT
1856 retloc
= wxSetlocale(LC_ALL
, wxEmptyString
);
1859 #if wxUSE_UNICODE && (defined(__VISUALC__) || defined(__MINGW32__))
1860 // VC++ setlocale() (also used by Mingw) can't set locale to languages that
1861 // can only be written using Unicode, therefore wxSetlocale() call fails
1862 // for such languages but we don't want to report it as an error -- so that
1863 // at least message catalogs can be used.
1866 if ( wxGetANSICodePageForLocale(LOCALE_USER_DEFAULT
).empty() )
1868 // we set the locale to a Unicode-only language, don't treat the
1869 // inability of CRT to use it as an error
1873 #endif // CRT not handling Unicode-only languages
1877 #elif defined(__WXMAC__)
1878 if (lang
== wxLANGUAGE_DEFAULT
)
1879 locale
= wxEmptyString
;
1881 locale
= info
->CanonicalName
;
1883 const char *retloc
= wxSetlocale(LC_ALL
, locale
);
1887 // Some C libraries don't like xx_YY form and require xx only
1888 retloc
= wxSetlocale(LC_ALL
, ExtractLang(locale
));
1893 #define WX_NO_LOCALE_SUPPORT
1896 #ifndef WX_NO_LOCALE_SUPPORT
1899 wxLogWarning(_("Cannot set locale to language \"%s\"."), name
.c_str());
1901 // continue nevertheless and try to load at least the translations for
1905 if ( !Init(name
, canonical
, retloc
,
1906 (flags
& wxLOCALE_LOAD_DEFAULT
) != 0,
1907 (flags
& wxLOCALE_CONV_ENCODING
) != 0) )
1912 if (IsOk()) // setlocale() succeeded
1916 #endif // !WX_NO_LOCALE_SUPPORT
1921 void wxLocale::AddCatalogLookupPathPrefix(const wxString
& prefix
)
1923 if ( gs_searchPrefixes
.Index(prefix
) == wxNOT_FOUND
)
1925 gs_searchPrefixes
.Add(prefix
);
1927 //else: already have it
1930 /*static*/ int wxLocale::GetSystemLanguage()
1932 CreateLanguagesDB();
1934 // init i to avoid compiler warning
1936 count
= ms_languagesDB
->GetCount();
1938 #if defined(__UNIX__)
1939 // first get the string identifying the language from the environment
1942 wxCFRef
<CFLocaleRef
> userLocaleRef(CFLocaleCopyCurrent());
1944 // because the locale identifier (kCFLocaleIdentifier) is formatted a little bit differently, eg
1945 // az_Cyrl_AZ@calendar=buddhist;currency=JPY we just recreate the base info as expected by wx here
1947 wxCFStringRef
str(wxCFRetain((CFStringRef
)CFLocaleGetValue(userLocaleRef
, kCFLocaleLanguageCode
)));
1948 langFull
= str
.AsString()+"_";
1949 str
.reset(wxCFRetain((CFStringRef
)CFLocaleGetValue(userLocaleRef
, kCFLocaleCountryCode
)));
1950 langFull
+= str
.AsString();
1952 if (!wxGetEnv(wxS("LC_ALL"), &langFull
) &&
1953 !wxGetEnv(wxS("LC_MESSAGES"), &langFull
) &&
1954 !wxGetEnv(wxS("LANG"), &langFull
))
1956 // no language specified, treat it as English
1957 return wxLANGUAGE_ENGLISH_US
;
1960 if ( langFull
== wxS("C") || langFull
== wxS("POSIX") )
1962 // default C locale is English too
1963 return wxLANGUAGE_ENGLISH_US
;
1967 // the language string has the following form
1969 // lang[_LANG][.encoding][@modifier]
1971 // (see environ(5) in the Open Unix specification)
1973 // where lang is the primary language, LANG is a sublang/territory,
1974 // encoding is the charset to use and modifier "allows the user to select
1975 // a specific instance of localization data within a single category"
1977 // for example, the following strings are valid:
1982 // de_DE.iso88591@euro
1984 // for now we don't use the encoding, although we probably should (doing
1985 // translations of the msg catalogs on the fly as required) (TODO)
1987 // we need the modified for languages like Valencian: ca_ES@valencia
1988 // though, remember it
1990 size_t posModifier
= langFull
.find_first_of(wxS("@"));
1991 if ( posModifier
!= wxString::npos
)
1992 modifier
= langFull
.Mid(posModifier
);
1994 size_t posEndLang
= langFull
.find_first_of(wxS("@."));
1995 if ( posEndLang
!= wxString::npos
)
1997 langFull
.Truncate(posEndLang
);
2000 // in addition to the format above, we also can have full language names
2001 // in LANG env var - for example, SuSE is known to use LANG="german" - so
2004 // do we have just the language (or sublang too)?
2005 bool justLang
= langFull
.length() == LEN_LANG
;
2007 (langFull
.length() == LEN_FULL
&& langFull
[LEN_LANG
] == wxS('_')) )
2009 // 0. Make sure the lang is according to latest ISO 639
2010 // (this is necessary because glibc uses iw and in instead
2011 // of he and id respectively).
2013 // the language itself (second part is the dialect/sublang)
2014 wxString langOrig
= ExtractLang(langFull
);
2017 if ( langOrig
== wxS("iw"))
2019 else if (langOrig
== wxS("in"))
2021 else if (langOrig
== wxS("ji"))
2023 else if (langOrig
== wxS("no_NO"))
2024 lang
= wxS("nb_NO");
2025 else if (langOrig
== wxS("no_NY"))
2026 lang
= wxS("nn_NO");
2027 else if (langOrig
== wxS("no"))
2028 lang
= wxS("nb_NO");
2032 // did we change it?
2033 if ( lang
!= langOrig
)
2035 langFull
= lang
+ ExtractNotLang(langFull
);
2038 // 1. Try to find the language either as is:
2039 // a) With modifier if set
2040 if ( !modifier
.empty() )
2042 wxString langFullWithModifier
= langFull
+ modifier
;
2043 for ( i
= 0; i
< count
; i
++ )
2045 if ( ms_languagesDB
->Item(i
).CanonicalName
== langFullWithModifier
)
2050 // b) Without modifier
2051 if ( modifier
.empty() || i
== count
)
2053 for ( i
= 0; i
< count
; i
++ )
2055 if ( ms_languagesDB
->Item(i
).CanonicalName
== langFull
)
2060 // 2. If langFull is of the form xx_YY, try to find xx:
2061 if ( i
== count
&& !justLang
)
2063 for ( i
= 0; i
< count
; i
++ )
2065 if ( ms_languagesDB
->Item(i
).CanonicalName
== lang
)
2072 // 3. If langFull is of the form xx, try to find any xx_YY record:
2073 if ( i
== count
&& justLang
)
2075 for ( i
= 0; i
< count
; i
++ )
2077 if ( ExtractLang(ms_languagesDB
->Item(i
).CanonicalName
)
2085 else // not standard format
2087 // try to find the name in verbose description
2088 for ( i
= 0; i
< count
; i
++ )
2090 if (ms_languagesDB
->Item(i
).Description
.CmpNoCase(langFull
) == 0)
2096 #elif defined(__WIN32__)
2097 LCID lcid
= GetUserDefaultLCID();
2100 wxUint32 lang
= PRIMARYLANGID(LANGIDFROMLCID(lcid
));
2101 wxUint32 sublang
= SUBLANGID(LANGIDFROMLCID(lcid
));
2103 for ( i
= 0; i
< count
; i
++ )
2105 if (ms_languagesDB
->Item(i
).WinLang
== lang
&&
2106 ms_languagesDB
->Item(i
).WinSublang
== sublang
)
2112 //else: leave wxlang == wxLANGUAGE_UNKNOWN
2113 #endif // Unix/Win32
2117 // we did find a matching entry, use it
2118 return ms_languagesDB
->Item(i
).Language
;
2121 // no info about this language in the database
2122 return wxLANGUAGE_UNKNOWN
;
2125 // ----------------------------------------------------------------------------
2127 // ----------------------------------------------------------------------------
2129 // this is a bit strange as under Windows we get the encoding name using its
2130 // numeric value and under Unix we do it the other way round, but this just
2131 // reflects the way different systems provide the encoding info
2134 wxString
wxLocale::GetSystemEncodingName()
2138 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
2139 // FIXME: what is the error return value for GetACP()?
2140 UINT codepage
= ::GetACP();
2141 encname
.Printf(wxS("windows-%u"), codepage
);
2142 #elif defined(__WXMAC__)
2143 // default is just empty string, this resolves to the default system
2145 #elif defined(__UNIX_LIKE__)
2147 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
2148 // GNU libc provides current character set this way (this conforms
2150 char *oldLocale
= strdup(setlocale(LC_CTYPE
, NULL
));
2151 setlocale(LC_CTYPE
, "");
2152 const char *alang
= nl_langinfo(CODESET
);
2153 setlocale(LC_CTYPE
, oldLocale
);
2158 encname
= wxString::FromAscii( alang
);
2160 else // nl_langinfo() failed
2161 #endif // HAVE_LANGINFO_H
2163 // if we can't get at the character set directly, try to see if it's in
2164 // the environment variables (in most cases this won't work, but I was
2166 char *lang
= getenv( "LC_ALL");
2167 char *dot
= lang
? strchr(lang
, '.') : NULL
;
2170 lang
= getenv( "LC_CTYPE" );
2172 dot
= strchr(lang
, '.' );
2176 lang
= getenv( "LANG");
2178 dot
= strchr(lang
, '.');
2183 encname
= wxString::FromAscii( dot
+1 );
2186 #endif // Win32/Unix
2192 wxFontEncoding
wxLocale::GetSystemEncoding()
2194 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
2195 UINT codepage
= ::GetACP();
2197 // wxWidgets only knows about CP1250-1257, 874, 932, 936, 949, 950
2198 if ( codepage
>= 1250 && codepage
<= 1257 )
2200 return (wxFontEncoding
)(wxFONTENCODING_CP1250
+ codepage
- 1250);
2203 if ( codepage
== 874 )
2205 return wxFONTENCODING_CP874
;
2208 if ( codepage
== 932 )
2210 return wxFONTENCODING_CP932
;
2213 if ( codepage
== 936 )
2215 return wxFONTENCODING_CP936
;
2218 if ( codepage
== 949 )
2220 return wxFONTENCODING_CP949
;
2223 if ( codepage
== 950 )
2225 return wxFONTENCODING_CP950
;
2227 #elif defined(__WXMAC__)
2228 CFStringEncoding encoding
= 0 ;
2229 encoding
= CFStringGetSystemEncoding() ;
2230 return wxMacGetFontEncFromSystemEnc( encoding
) ;
2231 #elif defined(__UNIX_LIKE__) && wxUSE_FONTMAP
2232 const wxString encname
= GetSystemEncodingName();
2233 if ( !encname
.empty() )
2235 wxFontEncoding enc
= wxFontMapperBase::GetEncodingFromName(encname
);
2237 // on some modern Linux systems (RedHat 8) the default system locale
2238 // is UTF8 -- but it isn't supported by wxGTK1 in ANSI build at all so
2239 // don't even try to use it in this case
2240 #if !wxUSE_UNICODE && \
2241 ((defined(__WXGTK__) && !defined(__WXGTK20__)) || defined(__WXMOTIF__))
2242 if ( enc
== wxFONTENCODING_UTF8
)
2244 // the most similar supported encoding...
2245 enc
= wxFONTENCODING_ISO8859_1
;
2247 #endif // !wxUSE_UNICODE
2249 // GetEncodingFromName() returns wxFONTENCODING_DEFAULT for C locale
2250 // (a.k.a. US-ASCII) which is arguably a bug but keep it like this for
2251 // backwards compatibility and just take care to not return
2252 // wxFONTENCODING_DEFAULT from here as this surely doesn't make sense
2253 if ( enc
== wxFONTENCODING_DEFAULT
)
2255 // we don't have wxFONTENCODING_ASCII, so use the closest one
2256 return wxFONTENCODING_ISO8859_1
;
2259 if ( enc
!= wxFONTENCODING_MAX
)
2263 //else: return wxFONTENCODING_SYSTEM below
2265 #endif // Win32/Unix
2267 return wxFONTENCODING_SYSTEM
;
2271 void wxLocale::AddLanguage(const wxLanguageInfo
& info
)
2273 CreateLanguagesDB();
2274 ms_languagesDB
->Add(info
);
2278 const wxLanguageInfo
*wxLocale::GetLanguageInfo(int lang
)
2280 CreateLanguagesDB();
2282 // calling GetLanguageInfo(wxLANGUAGE_DEFAULT) is a natural thing to do, so
2284 if ( lang
== wxLANGUAGE_DEFAULT
)
2285 lang
= GetSystemLanguage();
2287 const size_t count
= ms_languagesDB
->GetCount();
2288 for ( size_t i
= 0; i
< count
; i
++ )
2290 if ( ms_languagesDB
->Item(i
).Language
== lang
)
2292 // We need to create a temporary here in order to make this work with BCC in final build mode
2293 wxLanguageInfo
*ptr
= &ms_languagesDB
->Item(i
);
2302 wxString
wxLocale::GetLanguageName(int lang
)
2304 const wxLanguageInfo
*info
= GetLanguageInfo(lang
);
2306 return wxEmptyString
;
2308 return info
->Description
;
2312 const wxLanguageInfo
*wxLocale::FindLanguageInfo(const wxString
& locale
)
2314 CreateLanguagesDB();
2316 const wxLanguageInfo
*infoRet
= NULL
;
2318 const size_t count
= ms_languagesDB
->GetCount();
2319 for ( size_t i
= 0; i
< count
; i
++ )
2321 const wxLanguageInfo
*info
= &ms_languagesDB
->Item(i
);
2323 if ( wxStricmp(locale
, info
->CanonicalName
) == 0 ||
2324 wxStricmp(locale
, info
->Description
) == 0 )
2326 // exact match, stop searching
2331 if ( wxStricmp(locale
, info
->CanonicalName
.BeforeFirst(wxS('_'))) == 0 )
2333 // a match -- but maybe we'll find an exact one later, so continue
2336 // OTOH, maybe we had already found a language match and in this
2337 // case don't overwrite it because the entry for the default
2338 // country always appears first in ms_languagesDB
2347 wxString
wxLocale::GetSysName() const
2349 return wxSetlocale(LC_ALL
, NULL
);
2353 wxLocale::~wxLocale()
2356 wxMsgCatalog
*pTmpCat
;
2357 while ( m_pMsgCat
!= NULL
) {
2358 pTmpCat
= m_pMsgCat
;
2359 m_pMsgCat
= m_pMsgCat
->m_pNext
;
2363 // restore old locale pointer
2364 wxSetLocale(m_pOldLocale
);
2366 wxSetlocale(LC_ALL
, m_pszOldLocale
);
2367 free((wxChar
*)m_pszOldLocale
); // const_cast
2370 // get the translation of given string in current locale
2371 const wxString
& wxLocale::GetString(const wxString
& origString
,
2372 const wxString
& domain
) const
2374 return GetString(origString
, origString
, size_t(-1), domain
);
2377 const wxString
& wxLocale::GetString(const wxString
& origString
,
2378 const wxString
& origString2
,
2380 const wxString
& domain
) const
2382 if ( origString
.empty() )
2383 return GetUntranslatedString(origString
);
2385 const wxString
*trans
= NULL
;
2386 wxMsgCatalog
*pMsgCat
;
2388 if ( !domain
.empty() )
2390 pMsgCat
= FindCatalog(domain
);
2392 // does the catalog exist?
2393 if ( pMsgCat
!= NULL
)
2394 trans
= pMsgCat
->GetString(origString
, n
);
2398 // search in all domains
2399 for ( pMsgCat
= m_pMsgCat
; pMsgCat
!= NULL
; pMsgCat
= pMsgCat
->m_pNext
)
2401 trans
= pMsgCat
->GetString(origString
, n
);
2402 if ( trans
!= NULL
) // take the first found
2407 if ( trans
== NULL
)
2409 wxLogTrace(TRACE_I18N
,
2410 wxS("string \"%s\"[%ld] not found in %slocale '%s'."),
2411 origString
, (long)n
,
2412 wxString::Format(wxS("domain '%s' "), domain
).c_str(),
2413 m_strLocale
.c_str());
2415 if (n
== size_t(-1))
2416 return GetUntranslatedString(origString
);
2418 return GetUntranslatedString(n
== 1 ? origString
: origString2
);
2424 WX_DECLARE_HASH_SET(wxString
, wxStringHash
, wxStringEqual
,
2425 wxLocaleUntranslatedStrings
);
2428 const wxString
& wxLocale::GetUntranslatedString(const wxString
& str
)
2430 static wxLocaleUntranslatedStrings s_strings
;
2432 wxLocaleUntranslatedStrings::iterator i
= s_strings
.find(str
);
2433 if ( i
== s_strings
.end() )
2434 return *s_strings
.insert(str
).first
;
2439 wxString
wxLocale::GetHeaderValue(const wxString
& header
,
2440 const wxString
& domain
) const
2442 if ( header
.empty() )
2443 return wxEmptyString
;
2445 const wxString
*trans
= NULL
;
2446 wxMsgCatalog
*pMsgCat
;
2448 if ( !domain
.empty() )
2450 pMsgCat
= FindCatalog(domain
);
2452 // does the catalog exist?
2453 if ( pMsgCat
== NULL
)
2454 return wxEmptyString
;
2456 trans
= pMsgCat
->GetString(wxEmptyString
, (size_t)-1);
2460 // search in all domains
2461 for ( pMsgCat
= m_pMsgCat
; pMsgCat
!= NULL
; pMsgCat
= pMsgCat
->m_pNext
)
2463 trans
= pMsgCat
->GetString(wxEmptyString
, (size_t)-1);
2464 if ( trans
!= NULL
) // take the first found
2469 if ( !trans
|| trans
->empty() )
2470 return wxEmptyString
;
2472 size_t found
= trans
->find(header
);
2473 if ( found
== wxString::npos
)
2474 return wxEmptyString
;
2476 found
+= header
.length() + 2 /* ': ' */;
2478 // Every header is separated by \n
2480 size_t endLine
= trans
->find(wxS('\n'), found
);
2481 size_t len
= (endLine
== wxString::npos
) ?
2482 wxString::npos
: (endLine
- found
);
2484 return trans
->substr(found
, len
);
2488 // find catalog by name in a linked list, return NULL if !found
2489 wxMsgCatalog
*wxLocale::FindCatalog(const wxString
& domain
) const
2491 // linear search in the linked list
2492 wxMsgCatalog
*pMsgCat
;
2493 for ( pMsgCat
= m_pMsgCat
; pMsgCat
!= NULL
; pMsgCat
= pMsgCat
->m_pNext
)
2495 if ( pMsgCat
->GetName() == domain
)
2502 // check if the given locale is provided by OS and C run time
2504 bool wxLocale::IsAvailable(int lang
)
2506 const wxLanguageInfo
*info
= wxLocale::GetLanguageInfo(lang
);
2507 wxCHECK_MSG( info
, false, wxS("invalid language") );
2509 #if defined(__WIN32__)
2510 if ( !info
->WinLang
)
2513 if ( !::IsValidLocale(info
->GetLCID(), LCID_INSTALLED
) )
2516 #elif defined(__UNIX__)
2518 // Test if setting the locale works, then set it back.
2519 const char *oldLocale
= wxSetlocale(LC_ALL
, "");
2520 const char *tmp
= wxSetlocaleTryUTF8(LC_ALL
, info
->CanonicalName
);
2523 // Some C libraries don't like xx_YY form and require xx only
2524 tmp
= wxSetlocaleTryUTF8(LC_ALL
, ExtractLang(info
->CanonicalName
));
2528 // restore the original locale
2529 wxSetlocale(LC_ALL
, oldLocale
);
2535 // check if the given catalog is loaded
2536 bool wxLocale::IsLoaded(const wxString
& szDomain
) const
2538 return FindCatalog(szDomain
) != NULL
;
2541 // add a catalog to our linked list
2542 bool wxLocale::AddCatalog(const wxString
& szDomain
)
2544 return AddCatalog(szDomain
, wxLANGUAGE_ENGLISH_US
, wxEmptyString
);
2547 // add a catalog to our linked list
2548 bool wxLocale::AddCatalog(const wxString
& szDomain
,
2549 wxLanguage msgIdLanguage
,
2550 const wxString
& msgIdCharset
)
2553 wxCHECK_MSG( !m_strShort
.empty(), false, "must initialize catalog first" );
2556 // It is OK to not load catalog if the msgid language and m_language match,
2557 // in which case we can directly display the texts embedded in program's
2559 if ( msgIdLanguage
== m_language
)
2563 wxMsgCatalog
*pMsgCat
= new wxMsgCatalog
;
2565 if ( pMsgCat
->Load(m_strShort
, szDomain
, msgIdCharset
, m_bConvertEncoding
) )
2567 // add it to the head of the list so that in GetString it will
2568 // be searched before the catalogs added earlier
2569 pMsgCat
->m_pNext
= m_pMsgCat
;
2570 m_pMsgCat
= pMsgCat
;
2575 // don't add it because it couldn't be loaded anyway
2579 // If there's no exact match, we may still get partial match where the
2580 // (basic) language is same, but the country differs. For example, it's
2581 // permitted to use en_US strings from sources even if m_language is en_GB:
2582 const wxLanguageInfo
*msgIdLangInfo
= GetLanguageInfo(msgIdLanguage
);
2583 if ( msgIdLangInfo
&&
2584 ExtractLang(msgIdLangInfo
->CanonicalName
) == ExtractLang(m_strShort
) )
2592 // ----------------------------------------------------------------------------
2593 // accessors for locale-dependent data
2594 // ----------------------------------------------------------------------------
2596 #if defined(__WXMSW__)
2599 wxString
wxLocale::GetInfo(wxLocaleInfo index
, wxLocaleCategory
WXUNUSED(cat
))
2601 wxUint32 lcid
= LOCALE_USER_DEFAULT
;
2605 const wxLanguageInfo
*info
= GetLanguageInfo(wxGetLocale()->GetLanguage());
2607 lcid
= info
->GetLCID();
2613 buffer
[0] = wxS('\0');
2616 case wxLOCALE_DECIMAL_POINT
:
2617 count
= ::GetLocaleInfo(lcid
, LOCALE_SDECIMAL
, buffer
, 256);
2624 case wxSYS_LIST_SEPARATOR
:
2625 count
= ::GetLocaleInfo(lcid
, LOCALE_SLIST
, buffer
, 256);
2631 case wxSYS_LEADING_ZERO
: // 0 means no leading zero, 1 means leading zero
2632 count
= ::GetLocaleInfo(lcid
, LOCALE_ILZERO
, buffer
, 256);
2640 wxFAIL_MSG(wxS("Unknown System String !"));
2645 #elif defined(__DARWIN__)
2648 wxString
wxLocale::GetInfo(wxLocaleInfo index
, wxLocaleCategory
WXUNUSED(cat
))
2650 CFLocaleRef userLocaleRefRaw
;
2651 if ( wxGetLocale() )
2653 userLocaleRefRaw
= CFLocaleCreate
2655 kCFAllocatorDefault
,
2656 wxCFStringRef(wxGetLocale()->GetCanonicalName())
2659 else // no current locale, use the default one
2661 userLocaleRefRaw
= CFLocaleCopyCurrent();
2664 wxCFRef
<CFLocaleRef
> userLocaleRef(userLocaleRefRaw
);
2666 CFStringRef cfstr
= 0;
2669 case wxLOCALE_THOUSANDS_SEP
:
2670 cfstr
= (CFStringRef
) CFLocaleGetValue(userLocaleRef
, kCFLocaleGroupingSeparator
);
2673 case wxLOCALE_DECIMAL_POINT
:
2674 cfstr
= (CFStringRef
) CFLocaleGetValue(userLocaleRef
, kCFLocaleDecimalSeparator
);
2678 wxFAIL_MSG( "Unknown locale info" );
2683 wxCFStringRef
str(wxCFRetain(cfstr
));
2684 return str
.AsString();
2687 #else // !__WXMSW__ && !__DARWIN__
2690 wxString
wxLocale::GetInfo(wxLocaleInfo index
, wxLocaleCategory cat
)
2692 struct lconv
*locale_info
= localeconv();
2695 case wxLOCALE_CAT_NUMBER
:
2698 case wxLOCALE_THOUSANDS_SEP
:
2699 return wxString(locale_info
->thousands_sep
,
2701 case wxLOCALE_DECIMAL_POINT
:
2702 return wxString(locale_info
->decimal_point
,
2705 return wxEmptyString
;
2707 case wxLOCALE_CAT_MONEY
:
2710 case wxLOCALE_THOUSANDS_SEP
:
2711 return wxString(locale_info
->mon_thousands_sep
,
2713 case wxLOCALE_DECIMAL_POINT
:
2714 return wxString(locale_info
->mon_decimal_point
,
2717 return wxEmptyString
;
2720 return wxEmptyString
;
2726 // ----------------------------------------------------------------------------
2727 // global functions and variables
2728 // ----------------------------------------------------------------------------
2730 // retrieve/change current locale
2731 // ------------------------------
2733 // the current locale object
2734 static wxLocale
*g_pLocale
= NULL
;
2736 wxLocale
*wxGetLocale()
2741 wxLocale
*wxSetLocale(wxLocale
*pLocale
)
2743 wxLocale
*pOld
= g_pLocale
;
2744 g_pLocale
= pLocale
;
2750 // ----------------------------------------------------------------------------
2751 // wxLocale module (for lazy destruction of languagesDB)
2752 // ----------------------------------------------------------------------------
2754 class wxLocaleModule
: public wxModule
2756 DECLARE_DYNAMIC_CLASS(wxLocaleModule
)
2759 bool OnInit() { return true; }
2760 void OnExit() { wxLocale::DestroyLanguagesDB(); }
2763 IMPLEMENT_DYNAMIC_CLASS(wxLocaleModule
, wxModule
)
2767 // ----------------------------------------------------------------------------
2768 // default languages table & initialization
2769 // ----------------------------------------------------------------------------
2773 // --- --- --- generated code begins here --- --- ---
2775 // This table is generated by misc/languages/genlang.py
2776 // When making changes, please put them into misc/languages/langtabl.txt
2778 #if !defined(__WIN32__) || defined(__WXMICROWIN__)
2780 #define SETWINLANG(info,lang,sublang)
2784 #define SETWINLANG(info,lang,sublang) \
2785 info.WinLang = lang, info.WinSublang = sublang;
2787 #ifndef LANG_AFRIKAANS
2788 #define LANG_AFRIKAANS (0)
2790 #ifndef LANG_ALBANIAN
2791 #define LANG_ALBANIAN (0)
2794 #define LANG_ARABIC (0)
2796 #ifndef LANG_ARMENIAN
2797 #define LANG_ARMENIAN (0)
2799 #ifndef LANG_ASSAMESE
2800 #define LANG_ASSAMESE (0)
2803 #define LANG_AZERI (0)
2806 #define LANG_BASQUE (0)
2808 #ifndef LANG_BELARUSIAN
2809 #define LANG_BELARUSIAN (0)
2811 #ifndef LANG_BENGALI
2812 #define LANG_BENGALI (0)
2814 #ifndef LANG_BULGARIAN
2815 #define LANG_BULGARIAN (0)
2817 #ifndef LANG_CATALAN
2818 #define LANG_CATALAN (0)
2820 #ifndef LANG_CHINESE
2821 #define LANG_CHINESE (0)
2823 #ifndef LANG_CROATIAN
2824 #define LANG_CROATIAN (0)
2827 #define LANG_CZECH (0)
2830 #define LANG_DANISH (0)
2833 #define LANG_DUTCH (0)
2835 #ifndef LANG_ENGLISH
2836 #define LANG_ENGLISH (0)
2838 #ifndef LANG_ESTONIAN
2839 #define LANG_ESTONIAN (0)
2841 #ifndef LANG_FAEROESE
2842 #define LANG_FAEROESE (0)
2845 #define LANG_FARSI (0)
2847 #ifndef LANG_FINNISH
2848 #define LANG_FINNISH (0)
2851 #define LANG_FRENCH (0)
2853 #ifndef LANG_GEORGIAN
2854 #define LANG_GEORGIAN (0)
2857 #define LANG_GERMAN (0)
2860 #define LANG_GREEK (0)
2862 #ifndef LANG_GUJARATI
2863 #define LANG_GUJARATI (0)
2866 #define LANG_HEBREW (0)
2869 #define LANG_HINDI (0)
2871 #ifndef LANG_HUNGARIAN
2872 #define LANG_HUNGARIAN (0)
2874 #ifndef LANG_ICELANDIC
2875 #define LANG_ICELANDIC (0)
2877 #ifndef LANG_INDONESIAN
2878 #define LANG_INDONESIAN (0)
2880 #ifndef LANG_ITALIAN
2881 #define LANG_ITALIAN (0)
2883 #ifndef LANG_JAPANESE
2884 #define LANG_JAPANESE (0)
2886 #ifndef LANG_KANNADA
2887 #define LANG_KANNADA (0)
2889 #ifndef LANG_KASHMIRI
2890 #define LANG_KASHMIRI (0)
2893 #define LANG_KAZAK (0)
2895 #ifndef LANG_KONKANI
2896 #define LANG_KONKANI (0)
2899 #define LANG_KOREAN (0)
2901 #ifndef LANG_LATVIAN
2902 #define LANG_LATVIAN (0)
2904 #ifndef LANG_LITHUANIAN
2905 #define LANG_LITHUANIAN (0)
2907 #ifndef LANG_MACEDONIAN
2908 #define LANG_MACEDONIAN (0)
2911 #define LANG_MALAY (0)
2913 #ifndef LANG_MALAYALAM
2914 #define LANG_MALAYALAM (0)
2916 #ifndef LANG_MANIPURI
2917 #define LANG_MANIPURI (0)
2919 #ifndef LANG_MARATHI
2920 #define LANG_MARATHI (0)
2923 #define LANG_NEPALI (0)
2925 #ifndef LANG_NORWEGIAN
2926 #define LANG_NORWEGIAN (0)
2929 #define LANG_ORIYA (0)
2932 #define LANG_POLISH (0)
2934 #ifndef LANG_PORTUGUESE
2935 #define LANG_PORTUGUESE (0)
2937 #ifndef LANG_PUNJABI
2938 #define LANG_PUNJABI (0)
2940 #ifndef LANG_ROMANIAN
2941 #define LANG_ROMANIAN (0)
2943 #ifndef LANG_RUSSIAN
2944 #define LANG_RUSSIAN (0)
2947 #define LANG_SAMI (0)
2949 #ifndef LANG_SANSKRIT
2950 #define LANG_SANSKRIT (0)
2952 #ifndef LANG_SERBIAN
2953 #define LANG_SERBIAN (0)
2956 #define LANG_SINDHI (0)
2959 #define LANG_SLOVAK (0)
2961 #ifndef LANG_SLOVENIAN
2962 #define LANG_SLOVENIAN (0)
2964 #ifndef LANG_SPANISH
2965 #define LANG_SPANISH (0)
2967 #ifndef LANG_SWAHILI
2968 #define LANG_SWAHILI (0)
2970 #ifndef LANG_SWEDISH
2971 #define LANG_SWEDISH (0)
2974 #define LANG_TAMIL (0)
2977 #define LANG_TATAR (0)
2980 #define LANG_TELUGU (0)
2983 #define LANG_THAI (0)
2985 #ifndef LANG_TURKISH
2986 #define LANG_TURKISH (0)
2988 #ifndef LANG_UKRAINIAN
2989 #define LANG_UKRAINIAN (0)
2992 #define LANG_URDU (0)
2995 #define LANG_UZBEK (0)
2997 #ifndef LANG_VIETNAMESE
2998 #define LANG_VIETNAMESE (0)
3000 #ifndef SUBLANG_ARABIC_ALGERIA
3001 #define SUBLANG_ARABIC_ALGERIA SUBLANG_DEFAULT
3003 #ifndef SUBLANG_ARABIC_BAHRAIN
3004 #define SUBLANG_ARABIC_BAHRAIN SUBLANG_DEFAULT
3006 #ifndef SUBLANG_ARABIC_EGYPT
3007 #define SUBLANG_ARABIC_EGYPT SUBLANG_DEFAULT
3009 #ifndef SUBLANG_ARABIC_IRAQ
3010 #define SUBLANG_ARABIC_IRAQ SUBLANG_DEFAULT
3012 #ifndef SUBLANG_ARABIC_JORDAN
3013 #define SUBLANG_ARABIC_JORDAN SUBLANG_DEFAULT
3015 #ifndef SUBLANG_ARABIC_KUWAIT
3016 #define SUBLANG_ARABIC_KUWAIT SUBLANG_DEFAULT
3018 #ifndef SUBLANG_ARABIC_LEBANON
3019 #define SUBLANG_ARABIC_LEBANON SUBLANG_DEFAULT
3021 #ifndef SUBLANG_ARABIC_LIBYA
3022 #define SUBLANG_ARABIC_LIBYA SUBLANG_DEFAULT
3024 #ifndef SUBLANG_ARABIC_MOROCCO
3025 #define SUBLANG_ARABIC_MOROCCO SUBLANG_DEFAULT
3027 #ifndef SUBLANG_ARABIC_OMAN
3028 #define SUBLANG_ARABIC_OMAN SUBLANG_DEFAULT
3030 #ifndef SUBLANG_ARABIC_QATAR
3031 #define SUBLANG_ARABIC_QATAR SUBLANG_DEFAULT
3033 #ifndef SUBLANG_ARABIC_SAUDI_ARABIA
3034 #define SUBLANG_ARABIC_SAUDI_ARABIA SUBLANG_DEFAULT
3036 #ifndef SUBLANG_ARABIC_SYRIA
3037 #define SUBLANG_ARABIC_SYRIA SUBLANG_DEFAULT
3039 #ifndef SUBLANG_ARABIC_TUNISIA
3040 #define SUBLANG_ARABIC_TUNISIA SUBLANG_DEFAULT
3042 #ifndef SUBLANG_ARABIC_UAE
3043 #define SUBLANG_ARABIC_UAE SUBLANG_DEFAULT
3045 #ifndef SUBLANG_ARABIC_YEMEN
3046 #define SUBLANG_ARABIC_YEMEN SUBLANG_DEFAULT
3048 #ifndef SUBLANG_AZERI_CYRILLIC
3049 #define SUBLANG_AZERI_CYRILLIC SUBLANG_DEFAULT
3051 #ifndef SUBLANG_AZERI_LATIN
3052 #define SUBLANG_AZERI_LATIN SUBLANG_DEFAULT
3054 #ifndef SUBLANG_CHINESE_SIMPLIFIED
3055 #define SUBLANG_CHINESE_SIMPLIFIED SUBLANG_DEFAULT
3057 #ifndef SUBLANG_CHINESE_TRADITIONAL
3058 #define SUBLANG_CHINESE_TRADITIONAL SUBLANG_DEFAULT
3060 #ifndef SUBLANG_CHINESE_HONGKONG
3061 #define SUBLANG_CHINESE_HONGKONG SUBLANG_DEFAULT
3063 #ifndef SUBLANG_CHINESE_MACAU
3064 #define SUBLANG_CHINESE_MACAU SUBLANG_DEFAULT
3066 #ifndef SUBLANG_CHINESE_SINGAPORE
3067 #define SUBLANG_CHINESE_SINGAPORE SUBLANG_DEFAULT
3069 #ifndef SUBLANG_DUTCH
3070 #define SUBLANG_DUTCH SUBLANG_DEFAULT
3072 #ifndef SUBLANG_DUTCH_BELGIAN
3073 #define SUBLANG_DUTCH_BELGIAN SUBLANG_DEFAULT
3075 #ifndef SUBLANG_ENGLISH_UK
3076 #define SUBLANG_ENGLISH_UK SUBLANG_DEFAULT
3078 #ifndef SUBLANG_ENGLISH_US
3079 #define SUBLANG_ENGLISH_US SUBLANG_DEFAULT
3081 #ifndef SUBLANG_ENGLISH_AUS
3082 #define SUBLANG_ENGLISH_AUS SUBLANG_DEFAULT
3084 #ifndef SUBLANG_ENGLISH_BELIZE
3085 #define SUBLANG_ENGLISH_BELIZE SUBLANG_DEFAULT
3087 #ifndef SUBLANG_ENGLISH_CAN
3088 #define SUBLANG_ENGLISH_CAN SUBLANG_DEFAULT
3090 #ifndef SUBLANG_ENGLISH_CARIBBEAN
3091 #define SUBLANG_ENGLISH_CARIBBEAN SUBLANG_DEFAULT
3093 #ifndef SUBLANG_ENGLISH_EIRE
3094 #define SUBLANG_ENGLISH_EIRE SUBLANG_DEFAULT
3096 #ifndef SUBLANG_ENGLISH_JAMAICA
3097 #define SUBLANG_ENGLISH_JAMAICA SUBLANG_DEFAULT
3099 #ifndef SUBLANG_ENGLISH_NZ
3100 #define SUBLANG_ENGLISH_NZ SUBLANG_DEFAULT
3102 #ifndef SUBLANG_ENGLISH_PHILIPPINES
3103 #define SUBLANG_ENGLISH_PHILIPPINES SUBLANG_DEFAULT
3105 #ifndef SUBLANG_ENGLISH_SOUTH_AFRICA
3106 #define SUBLANG_ENGLISH_SOUTH_AFRICA SUBLANG_DEFAULT
3108 #ifndef SUBLANG_ENGLISH_TRINIDAD
3109 #define SUBLANG_ENGLISH_TRINIDAD SUBLANG_DEFAULT
3111 #ifndef SUBLANG_ENGLISH_ZIMBABWE
3112 #define SUBLANG_ENGLISH_ZIMBABWE SUBLANG_DEFAULT
3114 #ifndef SUBLANG_FRENCH
3115 #define SUBLANG_FRENCH SUBLANG_DEFAULT
3117 #ifndef SUBLANG_FRENCH_BELGIAN
3118 #define SUBLANG_FRENCH_BELGIAN SUBLANG_DEFAULT
3120 #ifndef SUBLANG_FRENCH_CANADIAN
3121 #define SUBLANG_FRENCH_CANADIAN SUBLANG_DEFAULT
3123 #ifndef SUBLANG_FRENCH_LUXEMBOURG
3124 #define SUBLANG_FRENCH_LUXEMBOURG SUBLANG_DEFAULT
3126 #ifndef SUBLANG_FRENCH_MONACO
3127 #define SUBLANG_FRENCH_MONACO SUBLANG_DEFAULT
3129 #ifndef SUBLANG_FRENCH_SWISS
3130 #define SUBLANG_FRENCH_SWISS SUBLANG_DEFAULT
3132 #ifndef SUBLANG_GERMAN
3133 #define SUBLANG_GERMAN SUBLANG_DEFAULT
3135 #ifndef SUBLANG_GERMAN_AUSTRIAN
3136 #define SUBLANG_GERMAN_AUSTRIAN SUBLANG_DEFAULT
3138 #ifndef SUBLANG_GERMAN_LIECHTENSTEIN
3139 #define SUBLANG_GERMAN_LIECHTENSTEIN SUBLANG_DEFAULT
3141 #ifndef SUBLANG_GERMAN_LUXEMBOURG
3142 #define SUBLANG_GERMAN_LUXEMBOURG SUBLANG_DEFAULT
3144 #ifndef SUBLANG_GERMAN_SWISS
3145 #define SUBLANG_GERMAN_SWISS SUBLANG_DEFAULT
3147 #ifndef SUBLANG_ITALIAN
3148 #define SUBLANG_ITALIAN SUBLANG_DEFAULT
3150 #ifndef SUBLANG_ITALIAN_SWISS
3151 #define SUBLANG_ITALIAN_SWISS SUBLANG_DEFAULT
3153 #ifndef SUBLANG_KASHMIRI_INDIA
3154 #define SUBLANG_KASHMIRI_INDIA SUBLANG_DEFAULT
3156 #ifndef SUBLANG_KOREAN
3157 #define SUBLANG_KOREAN SUBLANG_DEFAULT
3159 #ifndef SUBLANG_LITHUANIAN
3160 #define SUBLANG_LITHUANIAN SUBLANG_DEFAULT
3162 #ifndef SUBLANG_MALAY_BRUNEI_DARUSSALAM
3163 #define SUBLANG_MALAY_BRUNEI_DARUSSALAM SUBLANG_DEFAULT
3165 #ifndef SUBLANG_MALAY_MALAYSIA
3166 #define SUBLANG_MALAY_MALAYSIA SUBLANG_DEFAULT
3168 #ifndef SUBLANG_NEPALI_INDIA
3169 #define SUBLANG_NEPALI_INDIA SUBLANG_DEFAULT
3171 #ifndef SUBLANG_NORWEGIAN_BOKMAL
3172 #define SUBLANG_NORWEGIAN_BOKMAL SUBLANG_DEFAULT
3174 #ifndef SUBLANG_NORWEGIAN_NYNORSK
3175 #define SUBLANG_NORWEGIAN_NYNORSK SUBLANG_DEFAULT
3177 #ifndef SUBLANG_PORTUGUESE
3178 #define SUBLANG_PORTUGUESE SUBLANG_DEFAULT
3180 #ifndef SUBLANG_PORTUGUESE_BRAZILIAN
3181 #define SUBLANG_PORTUGUESE_BRAZILIAN SUBLANG_DEFAULT
3183 #ifndef SUBLANG_SERBIAN_CYRILLIC
3184 #define SUBLANG_SERBIAN_CYRILLIC SUBLANG_DEFAULT
3186 #ifndef SUBLANG_SERBIAN_LATIN
3187 #define SUBLANG_SERBIAN_LATIN SUBLANG_DEFAULT
3189 #ifndef SUBLANG_SPANISH
3190 #define SUBLANG_SPANISH SUBLANG_DEFAULT
3192 #ifndef SUBLANG_SPANISH_ARGENTINA
3193 #define SUBLANG_SPANISH_ARGENTINA SUBLANG_DEFAULT
3195 #ifndef SUBLANG_SPANISH_BOLIVIA
3196 #define SUBLANG_SPANISH_BOLIVIA SUBLANG_DEFAULT
3198 #ifndef SUBLANG_SPANISH_CHILE
3199 #define SUBLANG_SPANISH_CHILE SUBLANG_DEFAULT
3201 #ifndef SUBLANG_SPANISH_COLOMBIA
3202 #define SUBLANG_SPANISH_COLOMBIA SUBLANG_DEFAULT
3204 #ifndef SUBLANG_SPANISH_COSTA_RICA
3205 #define SUBLANG_SPANISH_COSTA_RICA SUBLANG_DEFAULT
3207 #ifndef SUBLANG_SPANISH_DOMINICAN_REPUBLIC
3208 #define SUBLANG_SPANISH_DOMINICAN_REPUBLIC SUBLANG_DEFAULT
3210 #ifndef SUBLANG_SPANISH_ECUADOR
3211 #define SUBLANG_SPANISH_ECUADOR SUBLANG_DEFAULT
3213 #ifndef SUBLANG_SPANISH_EL_SALVADOR
3214 #define SUBLANG_SPANISH_EL_SALVADOR SUBLANG_DEFAULT
3216 #ifndef SUBLANG_SPANISH_GUATEMALA
3217 #define SUBLANG_SPANISH_GUATEMALA SUBLANG_DEFAULT
3219 #ifndef SUBLANG_SPANISH_HONDURAS
3220 #define SUBLANG_SPANISH_HONDURAS SUBLANG_DEFAULT
3222 #ifndef SUBLANG_SPANISH_MEXICAN
3223 #define SUBLANG_SPANISH_MEXICAN SUBLANG_DEFAULT
3225 #ifndef SUBLANG_SPANISH_MODERN
3226 #define SUBLANG_SPANISH_MODERN SUBLANG_DEFAULT
3228 #ifndef SUBLANG_SPANISH_NICARAGUA
3229 #define SUBLANG_SPANISH_NICARAGUA SUBLANG_DEFAULT
3231 #ifndef SUBLANG_SPANISH_PANAMA
3232 #define SUBLANG_SPANISH_PANAMA SUBLANG_DEFAULT
3234 #ifndef SUBLANG_SPANISH_PARAGUAY
3235 #define SUBLANG_SPANISH_PARAGUAY SUBLANG_DEFAULT
3237 #ifndef SUBLANG_SPANISH_PERU
3238 #define SUBLANG_SPANISH_PERU SUBLANG_DEFAULT
3240 #ifndef SUBLANG_SPANISH_PUERTO_RICO
3241 #define SUBLANG_SPANISH_PUERTO_RICO SUBLANG_DEFAULT
3243 #ifndef SUBLANG_SPANISH_URUGUAY
3244 #define SUBLANG_SPANISH_URUGUAY SUBLANG_DEFAULT
3246 #ifndef SUBLANG_SPANISH_VENEZUELA
3247 #define SUBLANG_SPANISH_VENEZUELA SUBLANG_DEFAULT
3249 #ifndef SUBLANG_SWEDISH
3250 #define SUBLANG_SWEDISH SUBLANG_DEFAULT
3252 #ifndef SUBLANG_SWEDISH_FINLAND
3253 #define SUBLANG_SWEDISH_FINLAND SUBLANG_DEFAULT
3255 #ifndef SUBLANG_URDU_INDIA
3256 #define SUBLANG_URDU_INDIA SUBLANG_DEFAULT
3258 #ifndef SUBLANG_URDU_PAKISTAN
3259 #define SUBLANG_URDU_PAKISTAN SUBLANG_DEFAULT
3261 #ifndef SUBLANG_UZBEK_CYRILLIC
3262 #define SUBLANG_UZBEK_CYRILLIC SUBLANG_DEFAULT
3264 #ifndef SUBLANG_UZBEK_LATIN
3265 #define SUBLANG_UZBEK_LATIN SUBLANG_DEFAULT
3271 #define LNG(wxlang, canonical, winlang, winsublang, layout, desc) \
3272 info.Language = wxlang; \
3273 info.CanonicalName = wxS(canonical); \
3274 info.LayoutDirection = layout; \
3275 info.Description = wxS(desc); \
3276 SETWINLANG(info, winlang, winsublang) \
3279 void wxLocale::InitLanguagesDB()
3281 wxLanguageInfo info
;
3282 wxStringTokenizer tkn
;
3284 LNG(wxLANGUAGE_ABKHAZIAN
, "ab" , 0 , 0 , wxLayout_LeftToRight
, "Abkhazian")
3285 LNG(wxLANGUAGE_AFAR
, "aa" , 0 , 0 , wxLayout_LeftToRight
, "Afar")
3286 LNG(wxLANGUAGE_AFRIKAANS
, "af_ZA", LANG_AFRIKAANS
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Afrikaans")
3287 LNG(wxLANGUAGE_ALBANIAN
, "sq_AL", LANG_ALBANIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Albanian")
3288 LNG(wxLANGUAGE_AMHARIC
, "am" , 0 , 0 , wxLayout_LeftToRight
, "Amharic")
3289 LNG(wxLANGUAGE_ARABIC
, "ar" , LANG_ARABIC
, SUBLANG_DEFAULT
, wxLayout_RightToLeft
, "Arabic")
3290 LNG(wxLANGUAGE_ARABIC_ALGERIA
, "ar_DZ", LANG_ARABIC
, SUBLANG_ARABIC_ALGERIA
, wxLayout_RightToLeft
, "Arabic (Algeria)")
3291 LNG(wxLANGUAGE_ARABIC_BAHRAIN
, "ar_BH", LANG_ARABIC
, SUBLANG_ARABIC_BAHRAIN
, wxLayout_RightToLeft
, "Arabic (Bahrain)")
3292 LNG(wxLANGUAGE_ARABIC_EGYPT
, "ar_EG", LANG_ARABIC
, SUBLANG_ARABIC_EGYPT
, wxLayout_RightToLeft
, "Arabic (Egypt)")
3293 LNG(wxLANGUAGE_ARABIC_IRAQ
, "ar_IQ", LANG_ARABIC
, SUBLANG_ARABIC_IRAQ
, wxLayout_RightToLeft
, "Arabic (Iraq)")
3294 LNG(wxLANGUAGE_ARABIC_JORDAN
, "ar_JO", LANG_ARABIC
, SUBLANG_ARABIC_JORDAN
, wxLayout_RightToLeft
, "Arabic (Jordan)")
3295 LNG(wxLANGUAGE_ARABIC_KUWAIT
, "ar_KW", LANG_ARABIC
, SUBLANG_ARABIC_KUWAIT
, wxLayout_RightToLeft
, "Arabic (Kuwait)")
3296 LNG(wxLANGUAGE_ARABIC_LEBANON
, "ar_LB", LANG_ARABIC
, SUBLANG_ARABIC_LEBANON
, wxLayout_RightToLeft
, "Arabic (Lebanon)")
3297 LNG(wxLANGUAGE_ARABIC_LIBYA
, "ar_LY", LANG_ARABIC
, SUBLANG_ARABIC_LIBYA
, wxLayout_RightToLeft
, "Arabic (Libya)")
3298 LNG(wxLANGUAGE_ARABIC_MOROCCO
, "ar_MA", LANG_ARABIC
, SUBLANG_ARABIC_MOROCCO
, wxLayout_RightToLeft
, "Arabic (Morocco)")
3299 LNG(wxLANGUAGE_ARABIC_OMAN
, "ar_OM", LANG_ARABIC
, SUBLANG_ARABIC_OMAN
, wxLayout_RightToLeft
, "Arabic (Oman)")
3300 LNG(wxLANGUAGE_ARABIC_QATAR
, "ar_QA", LANG_ARABIC
, SUBLANG_ARABIC_QATAR
, wxLayout_RightToLeft
, "Arabic (Qatar)")
3301 LNG(wxLANGUAGE_ARABIC_SAUDI_ARABIA
, "ar_SA", LANG_ARABIC
, SUBLANG_ARABIC_SAUDI_ARABIA
, wxLayout_RightToLeft
, "Arabic (Saudi Arabia)")
3302 LNG(wxLANGUAGE_ARABIC_SUDAN
, "ar_SD", 0 , 0 , wxLayout_RightToLeft
, "Arabic (Sudan)")
3303 LNG(wxLANGUAGE_ARABIC_SYRIA
, "ar_SY", LANG_ARABIC
, SUBLANG_ARABIC_SYRIA
, wxLayout_RightToLeft
, "Arabic (Syria)")
3304 LNG(wxLANGUAGE_ARABIC_TUNISIA
, "ar_TN", LANG_ARABIC
, SUBLANG_ARABIC_TUNISIA
, wxLayout_RightToLeft
, "Arabic (Tunisia)")
3305 LNG(wxLANGUAGE_ARABIC_UAE
, "ar_AE", LANG_ARABIC
, SUBLANG_ARABIC_UAE
, wxLayout_RightToLeft
, "Arabic (Uae)")
3306 LNG(wxLANGUAGE_ARABIC_YEMEN
, "ar_YE", LANG_ARABIC
, SUBLANG_ARABIC_YEMEN
, wxLayout_RightToLeft
, "Arabic (Yemen)")
3307 LNG(wxLANGUAGE_ARMENIAN
, "hy" , LANG_ARMENIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Armenian")
3308 LNG(wxLANGUAGE_ASSAMESE
, "as" , LANG_ASSAMESE
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Assamese")
3309 LNG(wxLANGUAGE_AYMARA
, "ay" , 0 , 0 , wxLayout_LeftToRight
, "Aymara")
3310 LNG(wxLANGUAGE_AZERI
, "az" , LANG_AZERI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Azeri")
3311 LNG(wxLANGUAGE_AZERI_CYRILLIC
, "az" , LANG_AZERI
, SUBLANG_AZERI_CYRILLIC
, wxLayout_LeftToRight
, "Azeri (Cyrillic)")
3312 LNG(wxLANGUAGE_AZERI_LATIN
, "az" , LANG_AZERI
, SUBLANG_AZERI_LATIN
, wxLayout_LeftToRight
, "Azeri (Latin)")
3313 LNG(wxLANGUAGE_BASHKIR
, "ba" , 0 , 0 , wxLayout_LeftToRight
, "Bashkir")
3314 LNG(wxLANGUAGE_BASQUE
, "eu_ES", LANG_BASQUE
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Basque")
3315 LNG(wxLANGUAGE_BELARUSIAN
, "be_BY", LANG_BELARUSIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Belarusian")
3316 LNG(wxLANGUAGE_BENGALI
, "bn" , LANG_BENGALI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Bengali")
3317 LNG(wxLANGUAGE_BHUTANI
, "dz" , 0 , 0 , wxLayout_LeftToRight
, "Bhutani")
3318 LNG(wxLANGUAGE_BIHARI
, "bh" , 0 , 0 , wxLayout_LeftToRight
, "Bihari")
3319 LNG(wxLANGUAGE_BISLAMA
, "bi" , 0 , 0 , wxLayout_LeftToRight
, "Bislama")
3320 LNG(wxLANGUAGE_BRETON
, "br" , 0 , 0 , wxLayout_LeftToRight
, "Breton")
3321 LNG(wxLANGUAGE_BULGARIAN
, "bg_BG", LANG_BULGARIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Bulgarian")
3322 LNG(wxLANGUAGE_BURMESE
, "my" , 0 , 0 , wxLayout_LeftToRight
, "Burmese")
3323 LNG(wxLANGUAGE_CAMBODIAN
, "km" , 0 , 0 , wxLayout_LeftToRight
, "Cambodian")
3324 LNG(wxLANGUAGE_CATALAN
, "ca_ES", LANG_CATALAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Catalan")
3325 LNG(wxLANGUAGE_CHINESE
, "zh_TW", LANG_CHINESE
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Chinese")
3326 LNG(wxLANGUAGE_CHINESE_SIMPLIFIED
, "zh_CN", LANG_CHINESE
, SUBLANG_CHINESE_SIMPLIFIED
, wxLayout_LeftToRight
, "Chinese (Simplified)")
3327 LNG(wxLANGUAGE_CHINESE_TRADITIONAL
, "zh_TW", LANG_CHINESE
, SUBLANG_CHINESE_TRADITIONAL
, wxLayout_LeftToRight
, "Chinese (Traditional)")
3328 LNG(wxLANGUAGE_CHINESE_HONGKONG
, "zh_HK", LANG_CHINESE
, SUBLANG_CHINESE_HONGKONG
, wxLayout_LeftToRight
, "Chinese (Hongkong)")
3329 LNG(wxLANGUAGE_CHINESE_MACAU
, "zh_MO", LANG_CHINESE
, SUBLANG_CHINESE_MACAU
, wxLayout_LeftToRight
, "Chinese (Macau)")
3330 LNG(wxLANGUAGE_CHINESE_SINGAPORE
, "zh_SG", LANG_CHINESE
, SUBLANG_CHINESE_SINGAPORE
, wxLayout_LeftToRight
, "Chinese (Singapore)")
3331 LNG(wxLANGUAGE_CHINESE_TAIWAN
, "zh_TW", LANG_CHINESE
, SUBLANG_CHINESE_TRADITIONAL
, wxLayout_LeftToRight
, "Chinese (Taiwan)")
3332 LNG(wxLANGUAGE_CORSICAN
, "co" , 0 , 0 , wxLayout_LeftToRight
, "Corsican")
3333 LNG(wxLANGUAGE_CROATIAN
, "hr_HR", LANG_CROATIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Croatian")
3334 LNG(wxLANGUAGE_CZECH
, "cs_CZ", LANG_CZECH
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Czech")
3335 LNG(wxLANGUAGE_DANISH
, "da_DK", LANG_DANISH
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Danish")
3336 LNG(wxLANGUAGE_DUTCH
, "nl_NL", LANG_DUTCH
, SUBLANG_DUTCH
, wxLayout_LeftToRight
, "Dutch")
3337 LNG(wxLANGUAGE_DUTCH_BELGIAN
, "nl_BE", LANG_DUTCH
, SUBLANG_DUTCH_BELGIAN
, wxLayout_LeftToRight
, "Dutch (Belgian)")
3338 LNG(wxLANGUAGE_ENGLISH
, "en_GB", LANG_ENGLISH
, SUBLANG_ENGLISH_UK
, wxLayout_LeftToRight
, "English")
3339 LNG(wxLANGUAGE_ENGLISH_UK
, "en_GB", LANG_ENGLISH
, SUBLANG_ENGLISH_UK
, wxLayout_LeftToRight
, "English (U.K.)")
3340 LNG(wxLANGUAGE_ENGLISH_US
, "en_US", LANG_ENGLISH
, SUBLANG_ENGLISH_US
, wxLayout_LeftToRight
, "English (U.S.)")
3341 LNG(wxLANGUAGE_ENGLISH_AUSTRALIA
, "en_AU", LANG_ENGLISH
, SUBLANG_ENGLISH_AUS
, wxLayout_LeftToRight
, "English (Australia)")
3342 LNG(wxLANGUAGE_ENGLISH_BELIZE
, "en_BZ", LANG_ENGLISH
, SUBLANG_ENGLISH_BELIZE
, wxLayout_LeftToRight
, "English (Belize)")
3343 LNG(wxLANGUAGE_ENGLISH_BOTSWANA
, "en_BW", 0 , 0 , wxLayout_LeftToRight
, "English (Botswana)")
3344 LNG(wxLANGUAGE_ENGLISH_CANADA
, "en_CA", LANG_ENGLISH
, SUBLANG_ENGLISH_CAN
, wxLayout_LeftToRight
, "English (Canada)")
3345 LNG(wxLANGUAGE_ENGLISH_CARIBBEAN
, "en_CB", LANG_ENGLISH
, SUBLANG_ENGLISH_CARIBBEAN
, wxLayout_LeftToRight
, "English (Caribbean)")
3346 LNG(wxLANGUAGE_ENGLISH_DENMARK
, "en_DK", 0 , 0 , wxLayout_LeftToRight
, "English (Denmark)")
3347 LNG(wxLANGUAGE_ENGLISH_EIRE
, "en_IE", LANG_ENGLISH
, SUBLANG_ENGLISH_EIRE
, wxLayout_LeftToRight
, "English (Eire)")
3348 LNG(wxLANGUAGE_ENGLISH_JAMAICA
, "en_JM", LANG_ENGLISH
, SUBLANG_ENGLISH_JAMAICA
, wxLayout_LeftToRight
, "English (Jamaica)")
3349 LNG(wxLANGUAGE_ENGLISH_NEW_ZEALAND
, "en_NZ", LANG_ENGLISH
, SUBLANG_ENGLISH_NZ
, wxLayout_LeftToRight
, "English (New Zealand)")
3350 LNG(wxLANGUAGE_ENGLISH_PHILIPPINES
, "en_PH", LANG_ENGLISH
, SUBLANG_ENGLISH_PHILIPPINES
, wxLayout_LeftToRight
, "English (Philippines)")
3351 LNG(wxLANGUAGE_ENGLISH_SOUTH_AFRICA
, "en_ZA", LANG_ENGLISH
, SUBLANG_ENGLISH_SOUTH_AFRICA
, wxLayout_LeftToRight
, "English (South Africa)")
3352 LNG(wxLANGUAGE_ENGLISH_TRINIDAD
, "en_TT", LANG_ENGLISH
, SUBLANG_ENGLISH_TRINIDAD
, wxLayout_LeftToRight
, "English (Trinidad)")
3353 LNG(wxLANGUAGE_ENGLISH_ZIMBABWE
, "en_ZW", LANG_ENGLISH
, SUBLANG_ENGLISH_ZIMBABWE
, wxLayout_LeftToRight
, "English (Zimbabwe)")
3354 LNG(wxLANGUAGE_ESPERANTO
, "eo" , 0 , 0 , wxLayout_LeftToRight
, "Esperanto")
3355 LNG(wxLANGUAGE_ESTONIAN
, "et_EE", LANG_ESTONIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Estonian")
3356 LNG(wxLANGUAGE_FAEROESE
, "fo_FO", LANG_FAEROESE
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Faeroese")
3357 LNG(wxLANGUAGE_FARSI
, "fa_IR", LANG_FARSI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Farsi")
3358 LNG(wxLANGUAGE_FIJI
, "fj" , 0 , 0 , wxLayout_LeftToRight
, "Fiji")
3359 LNG(wxLANGUAGE_FINNISH
, "fi_FI", LANG_FINNISH
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Finnish")
3360 LNG(wxLANGUAGE_FRENCH
, "fr_FR", LANG_FRENCH
, SUBLANG_FRENCH
, wxLayout_LeftToRight
, "French")
3361 LNG(wxLANGUAGE_FRENCH_BELGIAN
, "fr_BE", LANG_FRENCH
, SUBLANG_FRENCH_BELGIAN
, wxLayout_LeftToRight
, "French (Belgian)")
3362 LNG(wxLANGUAGE_FRENCH_CANADIAN
, "fr_CA", LANG_FRENCH
, SUBLANG_FRENCH_CANADIAN
, wxLayout_LeftToRight
, "French (Canadian)")
3363 LNG(wxLANGUAGE_FRENCH_LUXEMBOURG
, "fr_LU", LANG_FRENCH
, SUBLANG_FRENCH_LUXEMBOURG
, wxLayout_LeftToRight
, "French (Luxembourg)")
3364 LNG(wxLANGUAGE_FRENCH_MONACO
, "fr_MC", LANG_FRENCH
, SUBLANG_FRENCH_MONACO
, wxLayout_LeftToRight
, "French (Monaco)")
3365 LNG(wxLANGUAGE_FRENCH_SWISS
, "fr_CH", LANG_FRENCH
, SUBLANG_FRENCH_SWISS
, wxLayout_LeftToRight
, "French (Swiss)")
3366 LNG(wxLANGUAGE_FRISIAN
, "fy" , 0 , 0 , wxLayout_LeftToRight
, "Frisian")
3367 LNG(wxLANGUAGE_GALICIAN
, "gl_ES", 0 , 0 , wxLayout_LeftToRight
, "Galician")
3368 LNG(wxLANGUAGE_GEORGIAN
, "ka_GE", LANG_GEORGIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Georgian")
3369 LNG(wxLANGUAGE_GERMAN
, "de_DE", LANG_GERMAN
, SUBLANG_GERMAN
, wxLayout_LeftToRight
, "German")
3370 LNG(wxLANGUAGE_GERMAN_AUSTRIAN
, "de_AT", LANG_GERMAN
, SUBLANG_GERMAN_AUSTRIAN
, wxLayout_LeftToRight
, "German (Austrian)")
3371 LNG(wxLANGUAGE_GERMAN_BELGIUM
, "de_BE", 0 , 0 , wxLayout_LeftToRight
, "German (Belgium)")
3372 LNG(wxLANGUAGE_GERMAN_LIECHTENSTEIN
, "de_LI", LANG_GERMAN
, SUBLANG_GERMAN_LIECHTENSTEIN
, wxLayout_LeftToRight
, "German (Liechtenstein)")
3373 LNG(wxLANGUAGE_GERMAN_LUXEMBOURG
, "de_LU", LANG_GERMAN
, SUBLANG_GERMAN_LUXEMBOURG
, wxLayout_LeftToRight
, "German (Luxembourg)")
3374 LNG(wxLANGUAGE_GERMAN_SWISS
, "de_CH", LANG_GERMAN
, SUBLANG_GERMAN_SWISS
, wxLayout_LeftToRight
, "German (Swiss)")
3375 LNG(wxLANGUAGE_GREEK
, "el_GR", LANG_GREEK
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Greek")
3376 LNG(wxLANGUAGE_GREENLANDIC
, "kl_GL", 0 , 0 , wxLayout_LeftToRight
, "Greenlandic")
3377 LNG(wxLANGUAGE_GUARANI
, "gn" , 0 , 0 , wxLayout_LeftToRight
, "Guarani")
3378 LNG(wxLANGUAGE_GUJARATI
, "gu" , LANG_GUJARATI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Gujarati")
3379 LNG(wxLANGUAGE_HAUSA
, "ha" , 0 , 0 , wxLayout_LeftToRight
, "Hausa")
3380 LNG(wxLANGUAGE_HEBREW
, "he_IL", LANG_HEBREW
, SUBLANG_DEFAULT
, wxLayout_RightToLeft
, "Hebrew")
3381 LNG(wxLANGUAGE_HINDI
, "hi_IN", LANG_HINDI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Hindi")
3382 LNG(wxLANGUAGE_HUNGARIAN
, "hu_HU", LANG_HUNGARIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Hungarian")
3383 LNG(wxLANGUAGE_ICELANDIC
, "is_IS", LANG_ICELANDIC
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Icelandic")
3384 LNG(wxLANGUAGE_INDONESIAN
, "id_ID", LANG_INDONESIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Indonesian")
3385 LNG(wxLANGUAGE_INTERLINGUA
, "ia" , 0 , 0 , wxLayout_LeftToRight
, "Interlingua")
3386 LNG(wxLANGUAGE_INTERLINGUE
, "ie" , 0 , 0 , wxLayout_LeftToRight
, "Interlingue")
3387 LNG(wxLANGUAGE_INUKTITUT
, "iu" , 0 , 0 , wxLayout_LeftToRight
, "Inuktitut")
3388 LNG(wxLANGUAGE_INUPIAK
, "ik" , 0 , 0 , wxLayout_LeftToRight
, "Inupiak")
3389 LNG(wxLANGUAGE_IRISH
, "ga_IE", 0 , 0 , wxLayout_LeftToRight
, "Irish")
3390 LNG(wxLANGUAGE_ITALIAN
, "it_IT", LANG_ITALIAN
, SUBLANG_ITALIAN
, wxLayout_LeftToRight
, "Italian")
3391 LNG(wxLANGUAGE_ITALIAN_SWISS
, "it_CH", LANG_ITALIAN
, SUBLANG_ITALIAN_SWISS
, wxLayout_LeftToRight
, "Italian (Swiss)")
3392 LNG(wxLANGUAGE_JAPANESE
, "ja_JP", LANG_JAPANESE
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Japanese")
3393 LNG(wxLANGUAGE_JAVANESE
, "jw" , 0 , 0 , wxLayout_LeftToRight
, "Javanese")
3394 LNG(wxLANGUAGE_KANNADA
, "kn" , LANG_KANNADA
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Kannada")
3395 LNG(wxLANGUAGE_KASHMIRI
, "ks" , LANG_KASHMIRI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Kashmiri")
3396 LNG(wxLANGUAGE_KASHMIRI_INDIA
, "ks_IN", LANG_KASHMIRI
, SUBLANG_KASHMIRI_INDIA
, wxLayout_LeftToRight
, "Kashmiri (India)")
3397 LNG(wxLANGUAGE_KAZAKH
, "kk" , LANG_KAZAK
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Kazakh")
3398 LNG(wxLANGUAGE_KERNEWEK
, "kw_GB", 0 , 0 , wxLayout_LeftToRight
, "Kernewek")
3399 LNG(wxLANGUAGE_KINYARWANDA
, "rw" , 0 , 0 , wxLayout_LeftToRight
, "Kinyarwanda")
3400 LNG(wxLANGUAGE_KIRGHIZ
, "ky" , 0 , 0 , wxLayout_LeftToRight
, "Kirghiz")
3401 LNG(wxLANGUAGE_KIRUNDI
, "rn" , 0 , 0 , wxLayout_LeftToRight
, "Kirundi")
3402 LNG(wxLANGUAGE_KONKANI
, "" , LANG_KONKANI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Konkani")
3403 LNG(wxLANGUAGE_KOREAN
, "ko_KR", LANG_KOREAN
, SUBLANG_KOREAN
, wxLayout_LeftToRight
, "Korean")
3404 LNG(wxLANGUAGE_KURDISH
, "ku_TR", 0 , 0 , wxLayout_LeftToRight
, "Kurdish")
3405 LNG(wxLANGUAGE_LAOTHIAN
, "lo" , 0 , 0 , wxLayout_LeftToRight
, "Laothian")
3406 LNG(wxLANGUAGE_LATIN
, "la" , 0 , 0 , wxLayout_LeftToRight
, "Latin")
3407 LNG(wxLANGUAGE_LATVIAN
, "lv_LV", LANG_LATVIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Latvian")
3408 LNG(wxLANGUAGE_LINGALA
, "ln" , 0 , 0 , wxLayout_LeftToRight
, "Lingala")
3409 LNG(wxLANGUAGE_LITHUANIAN
, "lt_LT", LANG_LITHUANIAN
, SUBLANG_LITHUANIAN
, wxLayout_LeftToRight
, "Lithuanian")
3410 LNG(wxLANGUAGE_MACEDONIAN
, "mk_MK", LANG_MACEDONIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Macedonian")
3411 LNG(wxLANGUAGE_MALAGASY
, "mg" , 0 , 0 , wxLayout_LeftToRight
, "Malagasy")
3412 LNG(wxLANGUAGE_MALAY
, "ms_MY", LANG_MALAY
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Malay")
3413 LNG(wxLANGUAGE_MALAYALAM
, "ml" , LANG_MALAYALAM
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Malayalam")
3414 LNG(wxLANGUAGE_MALAY_BRUNEI_DARUSSALAM
, "ms_BN", LANG_MALAY
, SUBLANG_MALAY_BRUNEI_DARUSSALAM
, wxLayout_LeftToRight
, "Malay (Brunei Darussalam)")
3415 LNG(wxLANGUAGE_MALAY_MALAYSIA
, "ms_MY", LANG_MALAY
, SUBLANG_MALAY_MALAYSIA
, wxLayout_LeftToRight
, "Malay (Malaysia)")
3416 LNG(wxLANGUAGE_MALTESE
, "mt_MT", 0 , 0 , wxLayout_LeftToRight
, "Maltese")
3417 LNG(wxLANGUAGE_MANIPURI
, "" , LANG_MANIPURI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Manipuri")
3418 LNG(wxLANGUAGE_MAORI
, "mi" , 0 , 0 , wxLayout_LeftToRight
, "Maori")
3419 LNG(wxLANGUAGE_MARATHI
, "mr_IN", LANG_MARATHI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Marathi")
3420 LNG(wxLANGUAGE_MOLDAVIAN
, "mo" , 0 , 0 , wxLayout_LeftToRight
, "Moldavian")
3421 LNG(wxLANGUAGE_MONGOLIAN
, "mn" , 0 , 0 , wxLayout_LeftToRight
, "Mongolian")
3422 LNG(wxLANGUAGE_NAURU
, "na" , 0 , 0 , wxLayout_LeftToRight
, "Nauru")
3423 LNG(wxLANGUAGE_NEPALI
, "ne_NP", LANG_NEPALI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Nepali")
3424 LNG(wxLANGUAGE_NEPALI_INDIA
, "ne_IN", LANG_NEPALI
, SUBLANG_NEPALI_INDIA
, wxLayout_LeftToRight
, "Nepali (India)")
3425 LNG(wxLANGUAGE_NORWEGIAN_BOKMAL
, "nb_NO", LANG_NORWEGIAN
, SUBLANG_NORWEGIAN_BOKMAL
, wxLayout_LeftToRight
, "Norwegian (Bokmal)")
3426 LNG(wxLANGUAGE_NORWEGIAN_NYNORSK
, "nn_NO", LANG_NORWEGIAN
, SUBLANG_NORWEGIAN_NYNORSK
, wxLayout_LeftToRight
, "Norwegian (Nynorsk)")
3427 LNG(wxLANGUAGE_OCCITAN
, "oc" , 0 , 0 , wxLayout_LeftToRight
, "Occitan")
3428 LNG(wxLANGUAGE_ORIYA
, "or" , LANG_ORIYA
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Oriya")
3429 LNG(wxLANGUAGE_OROMO
, "om" , 0 , 0 , wxLayout_LeftToRight
, "(Afan) Oromo")
3430 LNG(wxLANGUAGE_PASHTO
, "ps" , 0 , 0 , wxLayout_LeftToRight
, "Pashto, Pushto")
3431 LNG(wxLANGUAGE_POLISH
, "pl_PL", LANG_POLISH
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Polish")
3432 LNG(wxLANGUAGE_PORTUGUESE
, "pt_PT", LANG_PORTUGUESE
, SUBLANG_PORTUGUESE
, wxLayout_LeftToRight
, "Portuguese")
3433 LNG(wxLANGUAGE_PORTUGUESE_BRAZILIAN
, "pt_BR", LANG_PORTUGUESE
, SUBLANG_PORTUGUESE_BRAZILIAN
, wxLayout_LeftToRight
, "Portuguese (Brazilian)")
3434 LNG(wxLANGUAGE_PUNJABI
, "pa" , LANG_PUNJABI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Punjabi")
3435 LNG(wxLANGUAGE_QUECHUA
, "qu" , 0 , 0 , wxLayout_LeftToRight
, "Quechua")
3436 LNG(wxLANGUAGE_RHAETO_ROMANCE
, "rm" , 0 , 0 , wxLayout_LeftToRight
, "Rhaeto-Romance")
3437 LNG(wxLANGUAGE_ROMANIAN
, "ro_RO", LANG_ROMANIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Romanian")
3438 LNG(wxLANGUAGE_RUSSIAN
, "ru_RU", LANG_RUSSIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Russian")
3439 LNG(wxLANGUAGE_RUSSIAN_UKRAINE
, "ru_UA", 0 , 0 , wxLayout_LeftToRight
, "Russian (Ukraine)")
3440 LNG(wxLANGUAGE_SAMI
, "se_NO", LANG_SAMI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Northern Sami")
3441 LNG(wxLANGUAGE_SAMOAN
, "sm" , 0 , 0 , wxLayout_LeftToRight
, "Samoan")
3442 LNG(wxLANGUAGE_SANGHO
, "sg" , 0 , 0 , wxLayout_LeftToRight
, "Sangho")
3443 LNG(wxLANGUAGE_SANSKRIT
, "sa" , LANG_SANSKRIT
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Sanskrit")
3444 LNG(wxLANGUAGE_SCOTS_GAELIC
, "gd" , 0 , 0 , wxLayout_LeftToRight
, "Scots Gaelic")
3445 LNG(wxLANGUAGE_SERBIAN
, "sr_RS", LANG_SERBIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Serbian")
3446 LNG(wxLANGUAGE_SERBIAN_CYRILLIC
, "sr_RS", LANG_SERBIAN
, SUBLANG_SERBIAN_CYRILLIC
, wxLayout_LeftToRight
, "Serbian (Cyrillic)")
3447 LNG(wxLANGUAGE_SERBIAN_LATIN
, "sr_RS@latin", LANG_SERBIAN
, SUBLANG_SERBIAN_LATIN
, wxLayout_LeftToRight
, "Serbian (Latin)")
3448 LNG(wxLANGUAGE_SERBIAN_CYRILLIC
, "sr_YU", LANG_SERBIAN
, SUBLANG_SERBIAN_CYRILLIC
, wxLayout_LeftToRight
, "Serbian (Cyrillic)")
3449 LNG(wxLANGUAGE_SERBIAN_LATIN
, "sr_YU@latin", LANG_SERBIAN
, SUBLANG_SERBIAN_LATIN
, wxLayout_LeftToRight
, "Serbian (Latin)")
3450 LNG(wxLANGUAGE_SERBO_CROATIAN
, "sh" , 0 , 0 , wxLayout_LeftToRight
, "Serbo-Croatian")
3451 LNG(wxLANGUAGE_SESOTHO
, "st" , 0 , 0 , wxLayout_LeftToRight
, "Sesotho")
3452 LNG(wxLANGUAGE_SETSWANA
, "tn" , 0 , 0 , wxLayout_LeftToRight
, "Setswana")
3453 LNG(wxLANGUAGE_SHONA
, "sn" , 0 , 0 , wxLayout_LeftToRight
, "Shona")
3454 LNG(wxLANGUAGE_SINDHI
, "sd" , LANG_SINDHI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Sindhi")
3455 LNG(wxLANGUAGE_SINHALESE
, "si" , 0 , 0 , wxLayout_LeftToRight
, "Sinhalese")
3456 LNG(wxLANGUAGE_SISWATI
, "ss" , 0 , 0 , wxLayout_LeftToRight
, "Siswati")
3457 LNG(wxLANGUAGE_SLOVAK
, "sk_SK", LANG_SLOVAK
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Slovak")
3458 LNG(wxLANGUAGE_SLOVENIAN
, "sl_SI", LANG_SLOVENIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Slovenian")
3459 LNG(wxLANGUAGE_SOMALI
, "so" , 0 , 0 , wxLayout_LeftToRight
, "Somali")
3460 LNG(wxLANGUAGE_SPANISH
, "es_ES", LANG_SPANISH
, SUBLANG_SPANISH
, wxLayout_LeftToRight
, "Spanish")
3461 LNG(wxLANGUAGE_SPANISH_ARGENTINA
, "es_AR", LANG_SPANISH
, SUBLANG_SPANISH_ARGENTINA
, wxLayout_LeftToRight
, "Spanish (Argentina)")
3462 LNG(wxLANGUAGE_SPANISH_BOLIVIA
, "es_BO", LANG_SPANISH
, SUBLANG_SPANISH_BOLIVIA
, wxLayout_LeftToRight
, "Spanish (Bolivia)")
3463 LNG(wxLANGUAGE_SPANISH_CHILE
, "es_CL", LANG_SPANISH
, SUBLANG_SPANISH_CHILE
, wxLayout_LeftToRight
, "Spanish (Chile)")
3464 LNG(wxLANGUAGE_SPANISH_COLOMBIA
, "es_CO", LANG_SPANISH
, SUBLANG_SPANISH_COLOMBIA
, wxLayout_LeftToRight
, "Spanish (Colombia)")
3465 LNG(wxLANGUAGE_SPANISH_COSTA_RICA
, "es_CR", LANG_SPANISH
, SUBLANG_SPANISH_COSTA_RICA
, wxLayout_LeftToRight
, "Spanish (Costa Rica)")
3466 LNG(wxLANGUAGE_SPANISH_DOMINICAN_REPUBLIC
, "es_DO", LANG_SPANISH
, SUBLANG_SPANISH_DOMINICAN_REPUBLIC
, wxLayout_LeftToRight
, "Spanish (Dominican republic)")
3467 LNG(wxLANGUAGE_SPANISH_ECUADOR
, "es_EC", LANG_SPANISH
, SUBLANG_SPANISH_ECUADOR
, wxLayout_LeftToRight
, "Spanish (Ecuador)")
3468 LNG(wxLANGUAGE_SPANISH_EL_SALVADOR
, "es_SV", LANG_SPANISH
, SUBLANG_SPANISH_EL_SALVADOR
, wxLayout_LeftToRight
, "Spanish (El Salvador)")
3469 LNG(wxLANGUAGE_SPANISH_GUATEMALA
, "es_GT", LANG_SPANISH
, SUBLANG_SPANISH_GUATEMALA
, wxLayout_LeftToRight
, "Spanish (Guatemala)")
3470 LNG(wxLANGUAGE_SPANISH_HONDURAS
, "es_HN", LANG_SPANISH
, SUBLANG_SPANISH_HONDURAS
, wxLayout_LeftToRight
, "Spanish (Honduras)")
3471 LNG(wxLANGUAGE_SPANISH_MEXICAN
, "es_MX", LANG_SPANISH
, SUBLANG_SPANISH_MEXICAN
, wxLayout_LeftToRight
, "Spanish (Mexican)")
3472 LNG(wxLANGUAGE_SPANISH_MODERN
, "es_ES", LANG_SPANISH
, SUBLANG_SPANISH_MODERN
, wxLayout_LeftToRight
, "Spanish (Modern)")
3473 LNG(wxLANGUAGE_SPANISH_NICARAGUA
, "es_NI", LANG_SPANISH
, SUBLANG_SPANISH_NICARAGUA
, wxLayout_LeftToRight
, "Spanish (Nicaragua)")
3474 LNG(wxLANGUAGE_SPANISH_PANAMA
, "es_PA", LANG_SPANISH
, SUBLANG_SPANISH_PANAMA
, wxLayout_LeftToRight
, "Spanish (Panama)")
3475 LNG(wxLANGUAGE_SPANISH_PARAGUAY
, "es_PY", LANG_SPANISH
, SUBLANG_SPANISH_PARAGUAY
, wxLayout_LeftToRight
, "Spanish (Paraguay)")
3476 LNG(wxLANGUAGE_SPANISH_PERU
, "es_PE", LANG_SPANISH
, SUBLANG_SPANISH_PERU
, wxLayout_LeftToRight
, "Spanish (Peru)")
3477 LNG(wxLANGUAGE_SPANISH_PUERTO_RICO
, "es_PR", LANG_SPANISH
, SUBLANG_SPANISH_PUERTO_RICO
, wxLayout_LeftToRight
, "Spanish (Puerto Rico)")
3478 LNG(wxLANGUAGE_SPANISH_URUGUAY
, "es_UY", LANG_SPANISH
, SUBLANG_SPANISH_URUGUAY
, wxLayout_LeftToRight
, "Spanish (Uruguay)")
3479 LNG(wxLANGUAGE_SPANISH_US
, "es_US", 0 , 0 , wxLayout_LeftToRight
, "Spanish (U.S.)")
3480 LNG(wxLANGUAGE_SPANISH_VENEZUELA
, "es_VE", LANG_SPANISH
, SUBLANG_SPANISH_VENEZUELA
, wxLayout_LeftToRight
, "Spanish (Venezuela)")
3481 LNG(wxLANGUAGE_SUNDANESE
, "su" , 0 , 0 , wxLayout_LeftToRight
, "Sundanese")
3482 LNG(wxLANGUAGE_SWAHILI
, "sw_KE", LANG_SWAHILI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Swahili")
3483 LNG(wxLANGUAGE_SWEDISH
, "sv_SE", LANG_SWEDISH
, SUBLANG_SWEDISH
, wxLayout_LeftToRight
, "Swedish")
3484 LNG(wxLANGUAGE_SWEDISH_FINLAND
, "sv_FI", LANG_SWEDISH
, SUBLANG_SWEDISH_FINLAND
, wxLayout_LeftToRight
, "Swedish (Finland)")
3485 LNG(wxLANGUAGE_TAGALOG
, "tl_PH", 0 , 0 , wxLayout_LeftToRight
, "Tagalog")
3486 LNG(wxLANGUAGE_TAJIK
, "tg" , 0 , 0 , wxLayout_LeftToRight
, "Tajik")
3487 LNG(wxLANGUAGE_TAMIL
, "ta" , LANG_TAMIL
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Tamil")
3488 LNG(wxLANGUAGE_TATAR
, "tt" , LANG_TATAR
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Tatar")
3489 LNG(wxLANGUAGE_TELUGU
, "te" , LANG_TELUGU
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Telugu")
3490 LNG(wxLANGUAGE_THAI
, "th_TH", LANG_THAI
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Thai")
3491 LNG(wxLANGUAGE_TIBETAN
, "bo" , 0 , 0 , wxLayout_LeftToRight
, "Tibetan")
3492 LNG(wxLANGUAGE_TIGRINYA
, "ti" , 0 , 0 , wxLayout_LeftToRight
, "Tigrinya")
3493 LNG(wxLANGUAGE_TONGA
, "to" , 0 , 0 , wxLayout_LeftToRight
, "Tonga")
3494 LNG(wxLANGUAGE_TSONGA
, "ts" , 0 , 0 , wxLayout_LeftToRight
, "Tsonga")
3495 LNG(wxLANGUAGE_TURKISH
, "tr_TR", LANG_TURKISH
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Turkish")
3496 LNG(wxLANGUAGE_TURKMEN
, "tk" , 0 , 0 , wxLayout_LeftToRight
, "Turkmen")
3497 LNG(wxLANGUAGE_TWI
, "tw" , 0 , 0 , wxLayout_LeftToRight
, "Twi")
3498 LNG(wxLANGUAGE_UIGHUR
, "ug" , 0 , 0 , wxLayout_LeftToRight
, "Uighur")
3499 LNG(wxLANGUAGE_UKRAINIAN
, "uk_UA", LANG_UKRAINIAN
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Ukrainian")
3500 LNG(wxLANGUAGE_URDU
, "ur" , LANG_URDU
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Urdu")
3501 LNG(wxLANGUAGE_URDU_INDIA
, "ur_IN", LANG_URDU
, SUBLANG_URDU_INDIA
, wxLayout_LeftToRight
, "Urdu (India)")
3502 LNG(wxLANGUAGE_URDU_PAKISTAN
, "ur_PK", LANG_URDU
, SUBLANG_URDU_PAKISTAN
, wxLayout_LeftToRight
, "Urdu (Pakistan)")
3503 LNG(wxLANGUAGE_UZBEK
, "uz" , LANG_UZBEK
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Uzbek")
3504 LNG(wxLANGUAGE_UZBEK_CYRILLIC
, "uz" , LANG_UZBEK
, SUBLANG_UZBEK_CYRILLIC
, wxLayout_LeftToRight
, "Uzbek (Cyrillic)")
3505 LNG(wxLANGUAGE_UZBEK_LATIN
, "uz" , LANG_UZBEK
, SUBLANG_UZBEK_LATIN
, wxLayout_LeftToRight
, "Uzbek (Latin)")
3506 LNG(wxLANGUAGE_VALENCIAN
, "ca_ES@valencia", 0 , 0 , wxLayout_LeftToRight
, "Valencian (Souternhern Catalan)")
3507 LNG(wxLANGUAGE_VIETNAMESE
, "vi_VN", LANG_VIETNAMESE
, SUBLANG_DEFAULT
, wxLayout_LeftToRight
, "Vietnamese")
3508 LNG(wxLANGUAGE_VOLAPUK
, "vo" , 0 , 0 , wxLayout_LeftToRight
, "Volapuk")
3509 LNG(wxLANGUAGE_WELSH
, "cy" , 0 , 0 , wxLayout_LeftToRight
, "Welsh")
3510 LNG(wxLANGUAGE_WOLOF
, "wo" , 0 , 0 , wxLayout_LeftToRight
, "Wolof")
3511 LNG(wxLANGUAGE_XHOSA
, "xh" , 0 , 0 , wxLayout_LeftToRight
, "Xhosa")
3512 LNG(wxLANGUAGE_YIDDISH
, "yi" , 0 , 0 , wxLayout_LeftToRight
, "Yiddish")
3513 LNG(wxLANGUAGE_YORUBA
, "yo" , 0 , 0 , wxLayout_LeftToRight
, "Yoruba")
3514 LNG(wxLANGUAGE_ZHUANG
, "za" , 0 , 0 , wxLayout_LeftToRight
, "Zhuang")
3515 LNG(wxLANGUAGE_ZULU
, "zu" , 0 , 0 , wxLayout_LeftToRight
, "Zulu")
3519 // --- --- --- generated code ends here --- --- ---
3521 #endif // wxUSE_INTL