src/common/intl.cpp

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