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 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declaration
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifdef __EMX__
  28 // The following define is needed by Innotek's libc to
  29 // make the definition of struct localeconv available.
  30 #define __INTERNAL_DEFS
  31 #endif
  32
  33 #if wxUSE_INTL
  34
  35 #ifndef WX_PRECOMP
  36     #include "wx/dynarray.h"
  37     #include "wx/string.h"
  38     #include "wx/intl.h"
  39     #include "wx/log.h"
  40     #include "wx/utils.h"
  41     #include "wx/app.h"
  42     #include "wx/hashmap.h"
  43     #include "wx/module.h"
  44 #endif // WX_PRECOMP
  45
  46 #ifndef __WXWINCE__
  47     #include <locale.h>
  48 #endif
  49
  50 // standard headers
  51 #include <ctype.h>
  52 #include <stdlib.h>
  53 #ifdef HAVE_LANGINFO_H
  54     #include <langinfo.h>
  55 #endif
  56
  57 #ifdef __WIN32__
  58     #include "wx/msw/private.h"
  59 #endif
  60
  61 #include "wx/file.h"
  62 #include "wx/filename.h"
  63 #include "wx/tokenzr.h"
  64 #include "wx/fontmap.h"
  65 #include "wx/scopedptr.h"
  66 #include "wx/apptrait.h"
  67 #include "wx/stdpaths.h"
  68 #include "wx/hashset.h"
  69
  70 #if defined(__WXOSX__)
  71     #include "wx/osx/core/cfref.h"
  72     #include <CoreFoundation/CFLocale.h>
  73     #include <CoreFoundation/CFDateFormatter.h>
  74     #include "wx/osx/core/cfstring.h"
  75 #endif
  76
  77 // ----------------------------------------------------------------------------
  78 // constants
  79 // ----------------------------------------------------------------------------
  80
  81 #define TRACE_I18N wxS("i18n")
  82
  83 // ============================================================================
  84 // implementation
  85 // ============================================================================
  86
  87 // ----------------------------------------------------------------------------
  88 // global functions
  89 // ----------------------------------------------------------------------------
  90
  91 static wxLocale *wxSetLocale(wxLocale *pLocale);
  92
  93 namespace
  94 {
  95
  96 // get just the language part ("en" in "en_GB")
  97 inline wxString ExtractLang(const wxString& langFull)
  98 {
  99     return langFull.BeforeFirst('_');
 100 }
 101
 102 // helper functions of GetSystemLanguage()
 103 #ifdef __UNIX__
 104
 105 // get everything else (including the leading '_')
 106 inline wxString ExtractNotLang(const wxString& langFull)
 107 {
 108     size_t pos = langFull.find('_');
 109     if ( pos != wxString::npos )
 110         return langFull.substr(pos);
 111     else
 112         return wxString();
 113 }
 114
 115 #endif // __UNIX__
 116
 117 } // anonymous namespace
 118
 119 // ----------------------------------------------------------------------------
 120 // wxLanguageInfo
 121 // ----------------------------------------------------------------------------
 122
 123 #ifdef __WINDOWS__
 124
 125 // helper used by wxLanguageInfo::GetLocaleName() and elsewhere to determine
 126 // whether the locale is Unicode-only (it is if this function returns empty
 127 // string)
 128 static wxString wxGetANSICodePageForLocale(LCID lcid)
 129 {
 130     wxString cp;
 131
 132     wxChar buffer[16];
 133     if ( ::GetLocaleInfo(lcid, LOCALE_IDEFAULTANSICODEPAGE,
 134                         buffer, WXSIZEOF(buffer)) > 0 )
 135     {
 136         if ( buffer[0] != wxT('0') || buffer[1] != wxT('\0') )
 137             cp = buffer;
 138         //else: this locale doesn't use ANSI code page
 139     }
 140
 141     return cp;
 142 }
 143
 144 wxUint32 wxLanguageInfo::GetLCID() const
 145 {
 146     return MAKELCID(MAKELANGID(WinLang, WinSublang), SORT_DEFAULT);
 147 }
 148
 149 wxString wxLanguageInfo::GetLocaleName() const
 150 {
 151     wxString locale;
 152
 153     const LCID lcid = GetLCID();
 154
 155     wxChar buffer[256];
 156     buffer[0] = wxT('\0');
 157     if ( !::GetLocaleInfo(lcid, LOCALE_SENGLANGUAGE, buffer, WXSIZEOF(buffer)) )
 158     {
 159         wxLogLastError(wxT("GetLocaleInfo(LOCALE_SENGLANGUAGE)"));
 160         return locale;
 161     }
 162
 163     locale << buffer;
 164     if ( ::GetLocaleInfo(lcid, LOCALE_SENGCOUNTRY,
 165                         buffer, WXSIZEOF(buffer)) > 0 )
 166     {
 167         locale << wxT('_') << buffer;
 168     }
 169
 170     const wxString cp = wxGetANSICodePageForLocale(lcid);
 171     if ( !cp.empty() )
 172     {
 173         locale << wxT('.') << cp;
 174     }
 175
 176     return locale;
 177 }
 178
 179 #endif // __WINDOWS__
 180
 181 // ----------------------------------------------------------------------------
 182 // wxLocale
 183 // ----------------------------------------------------------------------------
 184
 185 #include "wx/arrimpl.cpp"
 186 WX_DECLARE_EXPORTED_OBJARRAY(wxLanguageInfo, wxLanguageInfoArray);
 187 WX_DEFINE_OBJARRAY(wxLanguageInfoArray)
 188
 189 wxLanguageInfoArray *wxLocale::ms_languagesDB = NULL;
 190
 191 /*static*/ void wxLocale::CreateLanguagesDB()
 192 {
 193     if (ms_languagesDB == NULL)
 194     {
 195         ms_languagesDB = new wxLanguageInfoArray;
 196         InitLanguagesDB();
 197     }
 198 }
 199
 200 /*static*/ void wxLocale::DestroyLanguagesDB()
 201 {
 202     wxDELETE(ms_languagesDB);
 203 }
 204
 205
 206 void wxLocale::DoCommonInit()
 207 {
 208     // Store the current locale in order to be able to restore it in the dtor.
 209     m_pszOldLocale = wxSetlocale(LC_ALL, NULL);
 210     if ( m_pszOldLocale )
 211         m_pszOldLocale = wxStrdup(m_pszOldLocale);
 212
 213
 214     m_pOldLocale = wxSetLocale(this);
 215
 216     // Set translations object, but only if the user didn't do so yet.
 217     // This is to preserve compatibility with wx-2.8 where wxLocale was
 218     // the only API for translations. wxLocale works as a stack, with
 219     // latest-created one being the active one:
 220     //     wxLocale loc_fr(wxLANGUAGE_FRENCH);
 221     //     // _() returns French
 222     //     {
 223     //         wxLocale loc_cs(wxLANGUAGE_CZECH);
 224     //         // _() returns Czech
 225     //     }
 226     //     // _() returns French again
 227     wxTranslations *oldTrans = wxTranslations::Get();
 228     if ( !oldTrans ||
 229          (m_pOldLocale && oldTrans == &m_pOldLocale->m_translations) )
 230     {
 231         wxTranslations::SetNonOwned(&m_translations);
 232     }
 233
 234     m_language = wxLANGUAGE_UNKNOWN;
 235     m_initialized = false;
 236 }
 237
 238 // NB: this function has (desired) side effect of changing current locale
 239 bool wxLocale::Init(const wxString& name,
 240                     const wxString& shortName,
 241                     const wxString& locale,
 242                     bool            bLoadDefault
 243 #if WXWIN_COMPATIBILITY_2_8
 244                    ,bool            WXUNUSED_UNLESS_DEBUG(bConvertEncoding)
 245 #endif
 246                     )
 247 {
 248 #if WXWIN_COMPATIBILITY_2_8
 249     wxASSERT_MSG( bConvertEncoding,
 250                   wxS("wxLocale::Init with bConvertEncoding=false is no longer supported, add charset to your catalogs") );
 251 #endif
 252
 253     bool ret = DoInit(name, shortName, locale);
 254
 255     // NB: don't use 'lang' here, 'language' may be wxLANGUAGE_DEFAULT
 256     wxTranslations *t = wxTranslations::Get();
 257     if ( t )
 258     {
 259         t->SetLanguage(shortName);
 260
 261         if ( bLoadDefault )
 262             t->AddStdCatalog();
 263     }
 264
 265     return ret;
 266 }
 267
 268 bool wxLocale::DoInit(const wxString& name,
 269                       const wxString& shortName,
 270                       const wxString& locale)
 271 {
 272     wxASSERT_MSG( !m_initialized,
 273                     wxS("you can't call wxLocale::Init more than once") );
 274
 275     m_initialized = true;
 276     m_strLocale = name;
 277     m_strShort = shortName;
 278     m_language = wxLANGUAGE_UNKNOWN;
 279
 280     // change current locale (default: same as long name)
 281     wxString szLocale(locale);
 282     if ( szLocale.empty() )
 283     {
 284         // the argument to setlocale()
 285         szLocale = shortName;
 286
 287         wxCHECK_MSG( !szLocale.empty(), false,
 288                     wxS("no locale to set in wxLocale::Init()") );
 289     }
 290
 291     if ( !wxSetlocale(LC_ALL, szLocale) )
 292     {
 293         wxLogError(_("locale '%s' cannot be set."), szLocale);
 294     }
 295
 296     // the short name will be used to look for catalog files as well,
 297     // so we need something here
 298     if ( m_strShort.empty() ) {
 299         // FIXME I don't know how these 2 letter abbreviations are formed,
 300         //       this wild guess is surely wrong
 301         if ( !szLocale.empty() )
 302         {
 303             m_strShort += (wxChar)wxTolower(szLocale[0]);
 304             if ( szLocale.length() > 1 )
 305                 m_strShort += (wxChar)wxTolower(szLocale[1]);
 306         }
 307     }
 308
 309     return true;
 310 }
 311
 312
 313 #if defined(__UNIX__) && wxUSE_UNICODE && !defined(__WXMAC__)
 314 static const char *wxSetlocaleTryUTF8(int c, const wxString& lc)
 315 {
 316     const char *l = NULL;
 317
 318     // NB: We prefer to set UTF-8 locale if it's possible and only fall back to
 319     //     non-UTF-8 locale if it fails
 320
 321     if ( !lc.empty() )
 322     {
 323         wxString buf(lc);
 324         wxString buf2;
 325         buf2 = buf + wxS(".UTF-8");
 326         l = wxSetlocale(c, buf2);
 327         if ( !l )
 328         {
 329             buf2 = buf + wxS(".utf-8");
 330             l = wxSetlocale(c, buf2);
 331         }
 332         if ( !l )
 333         {
 334             buf2 = buf + wxS(".UTF8");
 335             l = wxSetlocale(c, buf2);
 336         }
 337         if ( !l )
 338         {
 339             buf2 = buf + wxS(".utf8");
 340             l = wxSetlocale(c, buf2);
 341         }
 342     }
 343
 344     // if we can't set UTF-8 locale, try non-UTF-8 one:
 345     if ( !l )
 346         l = wxSetlocale(c, lc);
 347
 348     return l;
 349 }
 350 #else
 351 #define wxSetlocaleTryUTF8(c, lc)  wxSetlocale(c, lc)
 352 #endif
 353
 354 bool wxLocale::Init(int language, int flags)
 355 {
 356 #if WXWIN_COMPATIBILITY_2_8
 357     wxASSERT_MSG( !(flags & wxLOCALE_CONV_ENCODING),
 358                   wxS("wxLOCALE_CONV_ENCODING is no longer supported, add charset to your catalogs") );
 359 #endif
 360
 361     bool ret = true;
 362
 363     int lang = language;
 364     if (lang == wxLANGUAGE_DEFAULT)
 365     {
 366         // auto detect the language
 367         lang = GetSystemLanguage();
 368     }
 369
 370     // We failed to detect system language, so we will use English:
 371     if (lang == wxLANGUAGE_UNKNOWN)
 372     {
 373         return false;
 374     }
 375
 376     const wxLanguageInfo *info = GetLanguageInfo(lang);
 377
 378     // Unknown language:
 379     if (info == NULL)
 380     {
 381         wxLogError(wxS("Unknown language %i."), lang);
 382         return false;
 383     }
 384
 385     wxString name = info->Description;
 386     wxString canonical = info->CanonicalName;
 387     wxString locale;
 388
 389     // Set the locale:
 390 #if defined(__OS2__)
 391     const char *retloc = wxSetlocale(LC_ALL , wxEmptyString);
 392 #elif defined(__UNIX__) && !defined(__WXMAC__)
 393     if (language != wxLANGUAGE_DEFAULT)
 394         locale = info->CanonicalName;
 395
 396     const char *retloc = wxSetlocaleTryUTF8(LC_ALL, locale);
 397
 398     const wxString langOnly = ExtractLang(locale);
 399     if ( !retloc )
 400     {
 401         // Some C libraries don't like xx_YY form and require xx only
 402         retloc = wxSetlocaleTryUTF8(LC_ALL, langOnly);
 403     }
 404
 405 #if wxUSE_FONTMAP
 406     // some systems (e.g. FreeBSD and HP-UX) don't have xx_YY aliases but
 407     // require the full xx_YY.encoding form, so try using UTF-8 because this is
 408     // the only thing we can do generically
 409     //
 410     // TODO: add encodings applicable to each language to the lang DB and try
 411     //       them all in turn here
 412     if ( !retloc )
 413     {
 414         const wxChar **names =
 415             wxFontMapperBase::GetAllEncodingNames(wxFONTENCODING_UTF8);
 416         while ( *names )
 417         {
 418             retloc = wxSetlocale(LC_ALL, locale + wxS('.') + *names++);
 419             if ( retloc )
 420                 break;
 421         }
 422     }
 423 #endif // wxUSE_FONTMAP
 424
 425     if ( !retloc )
 426     {
 427         // Some C libraries (namely glibc) still use old ISO 639,
 428         // so will translate the abbrev for them
 429         wxString localeAlt;
 430         if ( langOnly == wxS("he") )
 431             localeAlt = wxS("iw") + ExtractNotLang(locale);
 432         else if ( langOnly == wxS("id") )
 433             localeAlt = wxS("in") + ExtractNotLang(locale);
 434         else if ( langOnly == wxS("yi") )
 435             localeAlt = wxS("ji") + ExtractNotLang(locale);
 436         else if ( langOnly == wxS("nb") )
 437             localeAlt = wxS("no_NO");
 438         else if ( langOnly == wxS("nn") )
 439             localeAlt = wxS("no_NY");
 440
 441         if ( !localeAlt.empty() )
 442         {
 443             retloc = wxSetlocaleTryUTF8(LC_ALL, localeAlt);
 444             if ( !retloc )
 445                 retloc = wxSetlocaleTryUTF8(LC_ALL, ExtractLang(localeAlt));
 446         }
 447     }
 448
 449     if ( !retloc )
 450         ret = false;
 451
 452 #ifdef __AIX__
 453     // at least in AIX 5.2 libc is buggy and the string returned from
 454     // setlocale(LC_ALL) can't be passed back to it because it returns 6
 455     // strings (one for each locale category), i.e. for C locale we get back
 456     // "C C C C C C"
 457     //
 458     // this contradicts IBM own docs but this is not of much help, so just work
 459     // around it in the crudest possible manner
 460     char* p = const_cast<char*>(wxStrchr(retloc, ' '));
 461     if ( p )
 462         *p = '\0';
 463 #endif // __AIX__
 464
 465 #elif defined(__WIN32__)
 466     const char *retloc = "C";
 467     if ( language != wxLANGUAGE_DEFAULT )
 468     {
 469         if ( info->WinLang == 0 )
 470         {
 471             wxLogWarning(wxS("Locale '%s' not supported by OS."), name.c_str());
 472             // retloc already set to "C"
 473         }
 474         else // language supported by Windows
 475         {
 476             // Windows CE doesn't have SetThreadLocale() and there doesn't seem
 477             // to be any equivalent
 478 #ifndef __WXWINCE__
 479             const wxUint32 lcid = info->GetLCID();
 480
 481             // change locale used by Windows functions
 482             ::SetThreadLocale(lcid);
 483 #endif
 484
 485             // and also call setlocale() to change locale used by the CRT
 486             locale = info->GetLocaleName();
 487             if ( locale.empty() )
 488             {
 489                 ret = false;
 490             }
 491             else // have a valid locale
 492             {
 493                 retloc = wxSetlocale(LC_ALL, locale);
 494             }
 495         }
 496     }
 497     else // language == wxLANGUAGE_DEFAULT
 498     {
 499         retloc = wxSetlocale(LC_ALL, wxEmptyString);
 500     }
 501
 502 #if wxUSE_UNICODE && (defined(__VISUALC__) || defined(__MINGW32__))
 503     // VC++ setlocale() (also used by Mingw) can't set locale to languages that
 504     // can only be written using Unicode, therefore wxSetlocale() call fails
 505     // for such languages but we don't want to report it as an error -- so that
 506     // at least message catalogs can be used.
 507     if ( !retloc )
 508     {
 509         if ( wxGetANSICodePageForLocale(LOCALE_USER_DEFAULT).empty() )
 510         {
 511             // we set the locale to a Unicode-only language, don't treat the
 512             // inability of CRT to use it as an error
 513             retloc = "C";
 514         }
 515     }
 516 #endif // CRT not handling Unicode-only languages
 517
 518     if ( !retloc )
 519         ret = false;
 520 #elif defined(__WXMAC__)
 521     if (lang == wxLANGUAGE_DEFAULT)
 522         locale = wxEmptyString;
 523     else
 524         locale = info->CanonicalName;
 525
 526     const char *retloc = wxSetlocale(LC_ALL, locale);
 527
 528     if ( !retloc )
 529     {
 530         // Some C libraries don't like xx_YY form and require xx only
 531         retloc = wxSetlocale(LC_ALL, ExtractLang(locale));
 532     }
 533 #else
 534     wxUnusedVar(flags);
 535     return false;
 536     #define WX_NO_LOCALE_SUPPORT
 537 #endif
 538
 539 #ifndef WX_NO_LOCALE_SUPPORT
 540     if ( !ret )
 541     {
 542         wxLogWarning(_("Cannot set locale to language \"%s\"."), name.c_str());
 543
 544         // continue nevertheless and try to load at least the translations for
 545         // this language
 546     }
 547
 548     if ( !DoInit(name, canonical, retloc) )
 549     {
 550         ret = false;
 551     }
 552
 553     if (IsOk()) // setlocale() succeeded
 554         m_language = lang;
 555
 556     // NB: don't use 'lang' here, 'language'
 557     wxTranslations *t = wxTranslations::Get();
 558     if ( t )
 559     {
 560         t->SetLanguage(static_cast<wxLanguage>(language));
 561
 562         if ( flags & wxLOCALE_LOAD_DEFAULT )
 563             t->AddStdCatalog();
 564     }
 565
 566     return ret;
 567 #endif // !WX_NO_LOCALE_SUPPORT
 568 }
 569
 570 namespace
 571 {
 572
 573 #ifndef __WXOSX__
 574 // Small helper function: get the value of the given environment variable and
 575 // return true only if the variable was found and has non-empty value.
 576 inline bool wxGetNonEmptyEnvVar(const wxString& name, wxString* value)
 577 {
 578     return wxGetEnv(name, value) && !value->empty();
 579 }
 580 #endif
 581
 582 } // anonymous namespace
 583
 584 /*static*/ int wxLocale::GetSystemLanguage()
 585 {
 586     CreateLanguagesDB();
 587
 588     // init i to avoid compiler warning
 589     size_t i = 0,
 590         count = ms_languagesDB->GetCount();
 591
 592 #if defined(__UNIX__)
 593     // first get the string identifying the language from the environment
 594     wxString langFull;
 595 #ifdef __WXOSX__
 596     wxCFRef<CFLocaleRef> userLocaleRef(CFLocaleCopyCurrent());
 597
 598     // because the locale identifier (kCFLocaleIdentifier) is formatted a little bit differently, eg
 599     // az_Cyrl_AZ@calendar=buddhist;currency=JPY we just recreate the base info as expected by wx here
 600
 601     wxCFStringRef str(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleLanguageCode)));
 602     langFull = str.AsString()+"_";
 603     str.reset(wxCFRetain((CFStringRef)CFLocaleGetValue(userLocaleRef, kCFLocaleCountryCode)));
 604     langFull += str.AsString();
 605 #else
 606     if (!wxGetNonEmptyEnvVar(wxS("LC_ALL"), &langFull) &&
 607         !wxGetNonEmptyEnvVar(wxS("LC_MESSAGES"), &langFull) &&
 608         !wxGetNonEmptyEnvVar(wxS("LANG"), &langFull))
 609     {
 610         // no language specified, treat it as English
 611         return wxLANGUAGE_ENGLISH_US;
 612     }
 613
 614     if ( langFull == wxS("C") || langFull == wxS("POSIX") )
 615     {
 616         // default C locale is English too
 617         return wxLANGUAGE_ENGLISH_US;
 618     }
 619 #endif
 620
 621     // the language string has the following form
 622     //
 623     //      lang[_LANG][.encoding][@modifier]
 624     //
 625     // (see environ(5) in the Open Unix specification)
 626     //
 627     // where lang is the primary language, LANG is a sublang/territory,
 628     // encoding is the charset to use and modifier "allows the user to select
 629     // a specific instance of localization data within a single category"
 630     //
 631     // for example, the following strings are valid:
 632     //      fr
 633     //      fr_FR
 634     //      de_DE.iso88591
 635     //      de_DE@euro
 636     //      de_DE.iso88591@euro
 637
 638     // for now we don't use the encoding, although we probably should (doing
 639     // translations of the msg catalogs on the fly as required) (TODO)
 640     //
 641     // we need the modified for languages like Valencian: ca_ES@valencia
 642     // though, remember it
 643     wxString modifier;
 644     size_t posModifier = langFull.find_first_of(wxS("@"));
 645     if ( posModifier != wxString::npos )
 646         modifier = langFull.Mid(posModifier);
 647
 648     size_t posEndLang = langFull.find_first_of(wxS("@."));
 649     if ( posEndLang != wxString::npos )
 650     {
 651         langFull.Truncate(posEndLang);
 652     }
 653
 654     // do we have just the language (or sublang too)?
 655     const bool justLang = langFull.find('_') == wxString::npos;
 656
 657     // 0. Make sure the lang is according to latest ISO 639
 658     //    (this is necessary because glibc uses iw and in instead
 659     //    of he and id respectively).
 660
 661     // the language itself (second part is the dialect/sublang)
 662     wxString langOrig = ExtractLang(langFull);
 663
 664     wxString lang;
 665     if ( langOrig == wxS("iw"))
 666         lang = wxS("he");
 667     else if (langOrig == wxS("in"))
 668         lang = wxS("id");
 669     else if (langOrig == wxS("ji"))
 670         lang = wxS("yi");
 671     else if (langOrig == wxS("no_NO"))
 672         lang = wxS("nb_NO");
 673     else if (langOrig == wxS("no_NY"))
 674         lang = wxS("nn_NO");
 675     else if (langOrig == wxS("no"))
 676         lang = wxS("nb_NO");
 677     else
 678         lang = langOrig;
 679
 680     // did we change it?
 681     if ( lang != langOrig )
 682     {
 683         langFull = lang + ExtractNotLang(langFull);
 684     }
 685
 686     // 1. Try to find the language either as is:
 687     // a) With modifier if set
 688     if ( !modifier.empty() )
 689     {
 690         wxString langFullWithModifier = langFull + modifier;
 691         for ( i = 0; i < count; i++ )
 692         {
 693             if ( ms_languagesDB->Item(i).CanonicalName == langFullWithModifier )
 694                 break;
 695         }
 696     }
 697
 698     // b) Without modifier
 699     if ( modifier.empty() || i == count )
 700     {
 701         for ( i = 0; i < count; i++ )
 702         {
 703             if ( ms_languagesDB->Item(i).CanonicalName == langFull )
 704                 break;
 705         }
 706     }
 707
 708     // 2. If langFull is of the form xx_YY, try to find xx:
 709     if ( i == count && !justLang )
 710     {
 711         for ( i = 0; i < count; i++ )
 712         {
 713             if ( ms_languagesDB->Item(i).CanonicalName == lang )
 714             {
 715                 break;
 716             }
 717         }
 718     }
 719
 720     // 3. If langFull is of the form xx, try to find any xx_YY record:
 721     if ( i == count && justLang )
 722     {
 723         for ( i = 0; i < count; i++ )
 724         {
 725             if ( ExtractLang(ms_languagesDB->Item(i).CanonicalName)
 726                     == langFull )
 727             {
 728                 break;
 729             }
 730         }
 731     }
 732
 733
 734     if ( i == count )
 735     {
 736         // In addition to the format above, we also can have full language
 737         // names in LANG env var - for example, SuSE is known to use
 738         // LANG="german" - so check for use of non-standard format and try to
 739         // find the name in verbose description.
 740         for ( i = 0; i < count; i++ )
 741         {
 742             if (ms_languagesDB->Item(i).Description.CmpNoCase(langFull) == 0)
 743             {
 744                 break;
 745             }
 746         }
 747     }
 748 #elif defined(__WIN32__)
 749     LCID lcid = GetUserDefaultLCID();
 750     if ( lcid != 0 )
 751     {
 752         wxUint32 lang = PRIMARYLANGID(LANGIDFROMLCID(lcid));
 753         wxUint32 sublang = SUBLANGID(LANGIDFROMLCID(lcid));
 754
 755         for ( i = 0; i < count; i++ )
 756         {
 757             if (ms_languagesDB->Item(i).WinLang == lang &&
 758                 ms_languagesDB->Item(i).WinSublang == sublang)
 759             {
 760                 break;
 761             }
 762         }
 763     }
 764     //else: leave wxlang == wxLANGUAGE_UNKNOWN
 765 #endif // Unix/Win32
 766
 767     if ( i < count )
 768     {
 769         // we did find a matching entry, use it
 770         return ms_languagesDB->Item(i).Language;
 771     }
 772
 773     // no info about this language in the database
 774     return wxLANGUAGE_UNKNOWN;
 775 }
 776
 777 // ----------------------------------------------------------------------------
 778 // encoding stuff
 779 // ----------------------------------------------------------------------------
 780
 781 // this is a bit strange as under Windows we get the encoding name using its
 782 // numeric value and under Unix we do it the other way round, but this just
 783 // reflects the way different systems provide the encoding info
 784
 785 /* static */
 786 wxString wxLocale::GetSystemEncodingName()
 787 {
 788     wxString encname;
 789
 790 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
 791     // FIXME: what is the error return value for GetACP()?
 792     UINT codepage = ::GetACP();
 793     encname.Printf(wxS("windows-%u"), codepage);
 794 #elif defined(__WXMAC__)
 795     encname = wxCFStringRef::AsString(
 796                 CFStringGetNameOfEncoding(CFStringGetSystemEncoding())
 797               );
 798 #elif defined(__UNIX_LIKE__)
 799
 800 #if defined(HAVE_LANGINFO_H) && defined(CODESET)
 801     // GNU libc provides current character set this way (this conforms
 802     // to Unix98)
 803     char *oldLocale = strdup(setlocale(LC_CTYPE, NULL));
 804     setlocale(LC_CTYPE, "");
 805     const char *alang = nl_langinfo(CODESET);
 806     setlocale(LC_CTYPE, oldLocale);
 807     free(oldLocale);
 808
 809     if ( alang )
 810     {
 811         encname = wxString::FromAscii( alang );
 812     }
 813     else // nl_langinfo() failed
 814 #endif // HAVE_LANGINFO_H
 815     {
 816         // if we can't get at the character set directly, try to see if it's in
 817         // the environment variables (in most cases this won't work, but I was
 818         // out of ideas)
 819         char *lang = getenv( "LC_ALL");
 820         char *dot = lang ? strchr(lang, '.') : NULL;
 821         if (!dot)
 822         {
 823             lang = getenv( "LC_CTYPE" );
 824             if ( lang )
 825                 dot = strchr(lang, '.' );
 826         }
 827         if (!dot)
 828         {
 829             lang = getenv( "LANG");
 830             if ( lang )
 831                 dot = strchr(lang, '.');
 832         }
 833
 834         if ( dot )
 835         {
 836             encname = wxString::FromAscii( dot+1 );
 837         }
 838     }
 839 #endif // Win32/Unix
 840
 841     return encname;
 842 }
 843
 844 /* static */
 845 wxFontEncoding wxLocale::GetSystemEncoding()
 846 {
 847 #if defined(__WIN32__) && !defined(__WXMICROWIN__)
 848     UINT codepage = ::GetACP();
 849
 850     // wxWidgets only knows about CP1250-1257, 874, 932, 936, 949, 950
 851     if ( codepage >= 1250 && codepage <= 1257 )
 852     {
 853         return (wxFontEncoding)(wxFONTENCODING_CP1250 + codepage - 1250);
 854     }
 855
 856     if ( codepage == 874 )
 857     {
 858         return wxFONTENCODING_CP874;
 859     }
 860
 861     if ( codepage == 932 )
 862     {
 863         return wxFONTENCODING_CP932;
 864     }
 865
 866     if ( codepage == 936 )
 867     {
 868         return wxFONTENCODING_CP936;
 869     }
 870
 871     if ( codepage == 949 )
 872     {
 873         return wxFONTENCODING_CP949;
 874     }
 875
 876     if ( codepage == 950 )
 877     {
 878         return wxFONTENCODING_CP950;
 879     }
 880 #elif defined(__WXMAC__)
 881     CFStringEncoding encoding = 0 ;
 882     encoding = CFStringGetSystemEncoding() ;
 883     return wxMacGetFontEncFromSystemEnc( encoding ) ;
 884 #elif defined(__UNIX_LIKE__) && wxUSE_FONTMAP
 885     const wxString encname = GetSystemEncodingName();
 886     if ( !encname.empty() )
 887     {
 888         wxFontEncoding enc = wxFontMapperBase::GetEncodingFromName(encname);
 889
 890         // on some modern Linux systems (RedHat 8) the default system locale
 891         // is UTF8 -- but it isn't supported by wxGTK1 in ANSI build at all so
 892         // don't even try to use it in this case
 893 #if !wxUSE_UNICODE && \
 894         ((defined(__WXGTK__) && !defined(__WXGTK20__)) || defined(__WXMOTIF__))
 895         if ( enc == wxFONTENCODING_UTF8 )
 896         {
 897             // the most similar supported encoding...
 898             enc = wxFONTENCODING_ISO8859_1;
 899         }
 900 #endif // !wxUSE_UNICODE
 901
 902         // GetEncodingFromName() returns wxFONTENCODING_DEFAULT for C locale
 903         // (a.k.a. US-ASCII) which is arguably a bug but keep it like this for
 904         // backwards compatibility and just take care to not return
 905         // wxFONTENCODING_DEFAULT from here as this surely doesn't make sense
 906         if ( enc == wxFONTENCODING_DEFAULT )
 907         {
 908             // we don't have wxFONTENCODING_ASCII, so use the closest one
 909             return wxFONTENCODING_ISO8859_1;
 910         }
 911
 912         if ( enc != wxFONTENCODING_MAX )
 913         {
 914             return enc;
 915         }
 916         //else: return wxFONTENCODING_SYSTEM below
 917     }
 918 #endif // Win32/Unix
 919
 920     return wxFONTENCODING_SYSTEM;
 921 }
 922
 923 /* static */
 924 void wxLocale::AddLanguage(const wxLanguageInfo& info)
 925 {
 926     CreateLanguagesDB();
 927     ms_languagesDB->Add(info);
 928 }
 929
 930 /* static */
 931 const wxLanguageInfo *wxLocale::GetLanguageInfo(int lang)
 932 {
 933     CreateLanguagesDB();
 934
 935     // calling GetLanguageInfo(wxLANGUAGE_DEFAULT) is a natural thing to do, so
 936     // make it work
 937     if ( lang == wxLANGUAGE_DEFAULT )
 938         lang = GetSystemLanguage();
 939
 940     const size_t count = ms_languagesDB->GetCount();
 941     for ( size_t i = 0; i < count; i++ )
 942     {
 943         if ( ms_languagesDB->Item(i).Language == lang )
 944         {
 945             // We need to create a temporary here in order to make this work with BCC in final build mode
 946             wxLanguageInfo *ptr = &ms_languagesDB->Item(i);
 947             return ptr;
 948         }
 949     }
 950
 951     return NULL;
 952 }
 953
 954 /* static */
 955 wxString wxLocale::GetLanguageName(int lang)
 956 {
 957     if ( lang == wxLANGUAGE_DEFAULT || lang == wxLANGUAGE_UNKNOWN )
 958         return wxEmptyString;
 959
 960     const wxLanguageInfo *info = GetLanguageInfo(lang);
 961     if ( !info )
 962         return wxEmptyString;
 963     else
 964         return info->Description;
 965 }
 966
 967 /* static */
 968 wxString wxLocale::GetLanguageCanonicalName(int lang)
 969 {
 970     if ( lang == wxLANGUAGE_DEFAULT || lang == wxLANGUAGE_UNKNOWN )
 971         return wxEmptyString;
 972
 973     const wxLanguageInfo *info = GetLanguageInfo(lang);
 974     if ( !info )
 975         return wxEmptyString;
 976     else
 977         return info->CanonicalName;
 978 }
 979
 980 /* static */
 981 const wxLanguageInfo *wxLocale::FindLanguageInfo(const wxString& locale)
 982 {
 983     CreateLanguagesDB();
 984
 985     const wxLanguageInfo *infoRet = NULL;
 986
 987     const size_t count = ms_languagesDB->GetCount();
 988     for ( size_t i = 0; i < count; i++ )
 989     {
 990         const wxLanguageInfo *info = &ms_languagesDB->Item(i);
 991
 992         if ( wxStricmp(locale, info->CanonicalName) == 0 ||
 993                 wxStricmp(locale, info->Description) == 0 )
 994         {
 995             // exact match, stop searching
 996             infoRet = info;
 997             break;
 998         }
 999
1000         if ( wxStricmp(locale, info->CanonicalName.BeforeFirst(wxS('_'))) == 0 )
1001         {
1002             // a match -- but maybe we'll find an exact one later, so continue
1003             // looking
1004             //
1005             // OTOH, maybe we had already found a language match and in this
1006             // case don't overwrite it because the entry for the default
1007             // country always appears first in ms_languagesDB
1008             if ( !infoRet )
1009                 infoRet = info;
1010         }
1011     }
1012
1013     return infoRet;
1014 }
1015
1016 wxString wxLocale::GetSysName() const
1017 {
1018     return wxSetlocale(LC_ALL, NULL);
1019 }
1020
1021 // clean up
1022 wxLocale::~wxLocale()
1023 {
1024     // Restore old translations object.
1025     // See DoCommonInit() for explanation of why this is needed for backward
1026     // compatibility.
1027     if ( wxTranslations::Get() == &m_translations )
1028     {
1029         if ( m_pOldLocale )
1030             wxTranslations::SetNonOwned(&m_pOldLocale->m_translations);
1031         else
1032             wxTranslations::Set(NULL);
1033     }
1034
1035     // restore old locale pointer
1036     wxSetLocale(m_pOldLocale);
1037
1038     wxSetlocale(LC_ALL, m_pszOldLocale);
1039     free(const_cast<char *>(m_pszOldLocale));
1040 }
1041
1042
1043 // check if the given locale is provided by OS and C run time
1044 /* static */
1045 bool wxLocale::IsAvailable(int lang)
1046 {
1047     const wxLanguageInfo *info = wxLocale::GetLanguageInfo(lang);
1048     if ( !info )
1049     {
1050         // The language is unknown (this normally only happens when we're
1051         // passed wxLANGUAGE_DEFAULT), so we can't support it.
1052         wxASSERT_MSG( lang == wxLANGUAGE_DEFAULT,
1053                       wxS("No info for a valid language?") );
1054         return false;
1055     }
1056
1057 #if defined(__WIN32__)
1058     if ( !info->WinLang )
1059         return false;
1060
1061     if ( !::IsValidLocale(info->GetLCID(), LCID_INSTALLED) )
1062         return false;
1063
1064 #elif defined(__UNIX__)
1065
1066     // Test if setting the locale works, then set it back.
1067     char * const oldLocale = wxStrdupA(setlocale(LC_ALL, NULL));
1068
1069     // Some platforms don't like xx_YY form and require xx only so test for
1070     // it too.
1071     const bool
1072         available = wxSetlocaleTryUTF8(LC_ALL, info->CanonicalName) ||
1073                     wxSetlocaleTryUTF8(LC_ALL, ExtractLang(info->CanonicalName));
1074
1075     // restore the original locale
1076     wxSetlocale(LC_ALL, oldLocale);
1077
1078     free(oldLocale);
1079
1080     if ( !available )
1081         return false;
1082 #endif
1083
1084     return true;
1085 }
1086
1087
1088 bool wxLocale::AddCatalog(const wxString& domain)
1089 {
1090     wxTranslations *t = wxTranslations::Get();
1091     if ( !t )
1092         return false;
1093     return t->AddCatalog(domain);
1094 }
1095
1096 bool wxLocale::AddCatalog(const wxString& domain, wxLanguage msgIdLanguage)
1097 {
1098     wxTranslations *t = wxTranslations::Get();
1099     if ( !t )
1100         return false;
1101     return t->AddCatalog(domain, msgIdLanguage);
1102 }
1103
1104 // add a catalog to our linked list
1105 bool wxLocale::AddCatalog(const wxString& szDomain,
1106                         wxLanguage      msgIdLanguage,
1107                         const wxString& msgIdCharset)
1108 {
1109     wxTranslations *t = wxTranslations::Get();
1110     if ( !t )
1111         return false;
1112 #if wxUSE_UNICODE
1113     wxUnusedVar(msgIdCharset);
1114     return t->AddCatalog(szDomain, msgIdLanguage);
1115 #else
1116     return t->AddCatalog(szDomain, msgIdLanguage, msgIdCharset);
1117 #endif
1118 }
1119
1120 bool wxLocale::IsLoaded(const wxString& domain) const
1121 {
1122     wxTranslations *t = wxTranslations::Get();
1123     if ( !t )
1124         return false;
1125     return t->IsLoaded(domain);
1126 }
1127
1128 wxString wxLocale::GetHeaderValue(const wxString& header,
1129                                   const wxString& domain) const
1130 {
1131     wxTranslations *t = wxTranslations::Get();
1132     if ( !t )
1133         return wxEmptyString;
1134     return t->GetHeaderValue(header, domain);
1135 }
1136
1137 // ----------------------------------------------------------------------------
1138 // accessors for locale-dependent data
1139 // ----------------------------------------------------------------------------
1140
1141 #if defined(__WINDOWS__) || defined(__WXOSX__)
1142
1143 namespace
1144 {
1145
1146 // This function translates from Unicode date formats described at
1147 //
1148 //      http://unicode.org/reports/tr35/tr35-6.html#Date_Format_Patterns
1149 //
1150 // to strftime()-like syntax. This translation is not lossless but we try to do
1151 // our best.
1152
1153 static wxString TranslateFromUnicodeFormat(const wxString& fmt)
1154 {
1155     wxString fmtWX;
1156     fmtWX.reserve(fmt.length());
1157
1158     char chLast = '\0';
1159     size_t lastCount = 0;
1160
1161     const char* formatchars =
1162         "dghHmMsSy"
1163 #ifdef __WINDOWS__
1164         "t"
1165 #else
1166         "EawD"
1167 #endif
1168         ;
1169     for ( wxString::const_iterator p = fmt.begin(); /* end handled inside */; ++p )
1170     {
1171         if ( p != fmt.end() )
1172         {
1173             if ( *p == chLast )
1174             {
1175                 lastCount++;
1176                 continue;
1177             }
1178
1179             const wxUniChar ch = (*p).GetValue();
1180             if ( ch.IsAscii() && strchr(formatchars, ch) )
1181             {
1182                 // these characters come in groups, start counting them
1183                 chLast = ch;
1184                 lastCount = 1;
1185                 continue;
1186             }
1187         }
1188
1189         // interpret any special characters we collected so far
1190         if ( lastCount )
1191         {
1192             switch ( chLast )
1193             {
1194                 case 'd':
1195                     switch ( lastCount )
1196                     {
1197                         case 1: // d
1198                         case 2: // dd
1199                             // these two are the same as we don't distinguish
1200                             // between 1 and 2 digits for days
1201                             fmtWX += "%d";
1202                             break;
1203 #ifdef __WINDOWS__
1204                         case 3: // ddd
1205                             fmtWX += "%a";
1206                             break;
1207
1208                         case 4: // dddd
1209                             fmtWX += "%A";
1210                             break;
1211 #endif
1212                         default:
1213                             wxFAIL_MSG( "too many 'd's" );
1214                     }
1215                     break;
1216 #ifndef __WINDOWS__
1217                 case 'D':
1218                     switch ( lastCount )
1219                     {
1220                         case 1: // D
1221                         case 2: // DD
1222                         case 3: // DDD
1223                             fmtWX += "%j";
1224                             break;
1225
1226                         default:
1227                             wxFAIL_MSG( "wrong number of 'D's" );
1228                     }
1229                     break;
1230                case 'w':
1231                     switch ( lastCount )
1232                     {
1233                         case 1: // w
1234                         case 2: // ww
1235                             fmtWX += "%W";
1236                             break;
1237
1238                         default:
1239                             wxFAIL_MSG( "wrong number of 'w's" );
1240                     }
1241                     break;
1242                 case 'E':
1243                    switch ( lastCount )
1244                     {
1245                         case 1: // E
1246                         case 2: // EE
1247                         case 3: // EEE
1248                             fmtWX += "%a";
1249                             break;
1250                         case 4: // EEEE
1251                             fmtWX += "%A";
1252                             break;
1253                         case 5: // EEEEE
1254                             fmtWX += "%a";
1255                             break;
1256
1257                         default:
1258                             wxFAIL_MSG( "wrong number of 'E's" );
1259                     }
1260                     break;
1261 #endif
1262                 case 'M':
1263                     switch ( lastCount )
1264                     {
1265                         case 1: // M
1266                         case 2: // MM
1267                             // as for 'd' and 'dd' above
1268                             fmtWX += "%m";
1269                             break;
1270
1271                         case 3:
1272                             fmtWX += "%b";
1273                             break;
1274
1275                         case 4:
1276                             fmtWX += "%B";
1277                             break;
1278
1279                         default:
1280                             wxFAIL_MSG( "too many 'M's" );
1281                     }
1282                     break;
1283
1284                 case 'y':
1285                     switch ( lastCount )
1286                     {
1287                         case 1: // y
1288                         case 2: // yy
1289                             fmtWX += "%y";
1290                             break;
1291
1292                         case 4: // yyyy
1293                             fmtWX += "%Y";
1294                             break;
1295
1296                         default:
1297                             wxFAIL_MSG( "wrong number of 'y's" );
1298                     }
1299                     break;
1300
1301                 case 'H':
1302                     switch ( lastCount )
1303                     {
1304                         case 1: // H
1305                         case 2: // HH
1306                             fmtWX += "%H";
1307                             break;
1308
1309                         default:
1310                             wxFAIL_MSG( "wrong number of 'H's" );
1311                     }
1312                     break;
1313
1314                case 'h':
1315                     switch ( lastCount )
1316                     {
1317                         case 1: // h
1318                         case 2: // hh
1319                             fmtWX += "%I";
1320                             break;
1321
1322                         default:
1323                             wxFAIL_MSG( "wrong number of 'h's" );
1324                     }
1325                     break;
1326
1327                case 'm':
1328                     switch ( lastCount )
1329                     {
1330                         case 1: // m
1331                         case 2: // mm
1332                             fmtWX += "%M";
1333                             break;
1334
1335                         default:
1336                             wxFAIL_MSG( "wrong number of 'm's" );
1337                     }
1338                     break;
1339
1340                case 's':
1341                     switch ( lastCount )
1342                     {
1343                         case 1: // s
1344                         case 2: // ss
1345                             fmtWX += "%S";
1346                             break;
1347
1348                         default:
1349                             wxFAIL_MSG( "wrong number of 's's" );
1350                     }
1351                     break;
1352
1353                 case 'g':
1354                     // strftime() doesn't have era string,
1355                     // ignore this format
1356                     wxASSERT_MSG( lastCount <= 2, "too many 'g's" );
1357
1358                     break;
1359 #ifndef __WINDOWS__
1360                 case 'a':
1361                     fmtWX += "%p";
1362                     break;
1363 #endif
1364 #ifdef __WINDOWS__
1365                 case 't':
1366                     switch ( lastCount )
1367                     {
1368                         case 1: // t
1369                         case 2: // tt
1370                             fmtWX += "%p";
1371                             break;
1372
1373                         default:
1374                             wxFAIL_MSG( "too many 't's" );
1375                     }
1376                     break;
1377 #endif
1378                 default:
1379                     wxFAIL_MSG( "unreachable" );
1380             }
1381
1382             chLast = '\0';
1383             lastCount = 0;
1384         }
1385
1386         if ( p == fmt.end() )
1387             break;
1388
1389         // not a special character so must be just a separator, treat as is
1390         if ( *p == wxT('%') )
1391         {
1392             // this one needs to be escaped
1393             fmtWX += wxT('%');
1394         }
1395
1396         fmtWX += *p;
1397     }
1398
1399     return fmtWX;
1400 }
1401
1402 } // anonymous namespace
1403
1404 #endif // __WINDOWS__ || __WXOSX__
1405
1406 #if defined(__WINDOWS__)
1407
1408 namespace
1409 {
1410
1411 LCTYPE GetLCTYPEFormatFromLocalInfo(wxLocaleInfo index)
1412 {
1413     switch ( index )
1414     {
1415         case wxLOCALE_SHORT_DATE_FMT:
1416             return LOCALE_SSHORTDATE;
1417
1418         case wxLOCALE_LONG_DATE_FMT:
1419             return LOCALE_SLONGDATE;
1420
1421         case wxLOCALE_TIME_FMT:
1422             return LOCALE_STIMEFORMAT;
1423
1424         default:
1425             wxFAIL_MSG( "no matching LCTYPE" );
1426     }
1427
1428     return 0;
1429 }
1430
1431 } // anonymous namespace
1432
1433 /* static */
1434 wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory cat)
1435 {
1436     const wxLanguageInfo * const
1437         info = wxGetLocale() ? GetLanguageInfo(wxGetLocale()->GetLanguage())
1438                              : NULL;
1439     if ( !info )
1440     {
1441         // wxSetLocale() hadn't been called yet of failed, hence CRT must be
1442         // using "C" locale -- but check it to detect bugs that would happen if
1443         // this were not the case.
1444         wxASSERT_MSG( strcmp(setlocale(LC_ALL, NULL), "C") == 0,
1445                       wxS("You probably called setlocale() directly instead ")
1446                       wxS("of using wxLocale and now there is a ")
1447                       wxS("mismatch between C/C++ and Windows locale.\n")
1448                       wxS("Things are going to break, please only change ")
1449                       wxS("locale by creating wxLocale objects to avoid this!") );
1450
1451
1452         // Return the hard coded values for C locale. This is really the right
1453         // thing to do as there is no LCID we can use in the code below in this
1454         // case, even LOCALE_INVARIANT is not quite the same as C locale (the
1455         // only difference is that it uses %Y instead of %y in the date format
1456         // but this difference is significant enough).
1457         switch ( index )
1458         {
1459             case wxLOCALE_THOUSANDS_SEP:
1460                 return wxString();
1461
1462             case wxLOCALE_DECIMAL_POINT:
1463                 return ".";
1464
1465             case wxLOCALE_SHORT_DATE_FMT:
1466                 return "%m/%d/%y";
1467
1468             case wxLOCALE_LONG_DATE_FMT:
1469                 return "%A, %B %d, %Y";
1470
1471             case wxLOCALE_TIME_FMT:
1472                 return "%H:%M:%S";
1473
1474             case wxLOCALE_DATE_TIME_FMT:
1475                 return "%m/%d/%y %H:%M:%S";
1476
1477             default:
1478                 wxFAIL_MSG( "unknown wxLocaleInfo" );
1479         }
1480     }
1481
1482     const wxUint32 lcid = info->GetLCID();
1483
1484     wxString str;
1485
1486     wxChar buf[256];
1487     buf[0] = wxT('\0');
1488
1489     switch ( index )
1490     {
1491         case wxLOCALE_THOUSANDS_SEP:
1492             if ( ::GetLocaleInfo(lcid, LOCALE_STHOUSAND, buf, WXSIZEOF(buf)) )
1493                 str = buf;
1494             break;
1495
1496         case wxLOCALE_DECIMAL_POINT:
1497             if ( ::GetLocaleInfo(lcid,
1498                                  cat == wxLOCALE_CAT_MONEY
1499                                      ? LOCALE_SMONDECIMALSEP
1500                                      : LOCALE_SDECIMAL,
1501                                  buf,
1502                                  WXSIZEOF(buf)) )
1503             {
1504                 str = buf;
1505
1506                 // As we get our decimal point separator from Win32 and not the
1507                 // CRT there is a possibility of mismatch between them and this
1508                 // can easily happen if the user code called setlocale()
1509                 // instead of using wxLocale to change the locale. And this can
1510                 // result in very strange bugs elsewhere in the code as the
1511                 // assumptions that formatted strings do use the decimal
1512                 // separator actually fail, so check for it here.
1513                 wxASSERT_MSG
1514                 (
1515                     wxString::Format("%.3f", 1.23).find(str) != wxString::npos,
1516                     "Decimal separator mismatch -- did you use setlocale()?"
1517                     "If so, use wxLocale to change the locale instead."
1518                 );
1519             }
1520             break;
1521
1522         case wxLOCALE_SHORT_DATE_FMT:
1523         case wxLOCALE_LONG_DATE_FMT:
1524         case wxLOCALE_TIME_FMT:
1525             if ( ::GetLocaleInfo(lcid, GetLCTYPEFormatFromLocalInfo(index),
1526                                  buf, WXSIZEOF(buf)) )
1527             {
1528                 return TranslateFromUnicodeFormat(buf);
1529             }
1530             break;
1531
1532         case wxLOCALE_DATE_TIME_FMT:
1533             // there doesn't seem to be any specific setting for this, so just
1534             // combine date and time ones
1535             //
1536             // we use the short date because this is what "%c" uses by default
1537             // ("%#c" uses long date but we have no way to specify the
1538             // alternate representation here)
1539             {
1540                 const wxString datefmt = GetInfo(wxLOCALE_SHORT_DATE_FMT);
1541                 if ( datefmt.empty() )
1542                     break;
1543
1544                 const wxString timefmt = GetInfo(wxLOCALE_TIME_FMT);
1545                 if ( timefmt.empty() )
1546                     break;
1547
1548                 str << datefmt << ' ' << timefmt;
1549             }
1550             break;
1551
1552         default:
1553             wxFAIL_MSG( "unknown wxLocaleInfo" );
1554     }
1555
1556     return str;
1557 }
1558
1559 #elif defined(__WXOSX__)
1560
1561 /* static */
1562 wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory WXUNUSED(cat))
1563 {
1564     CFLocaleRef userLocaleRefRaw;
1565     if ( wxGetLocale() )
1566     {
1567         userLocaleRefRaw = CFLocaleCreate
1568                         (
1569                                 kCFAllocatorDefault,
1570                                 wxCFStringRef(wxGetLocale()->GetCanonicalName())
1571                         );
1572     }
1573     else // no current locale, use the default one
1574     {
1575         userLocaleRefRaw = CFLocaleCopyCurrent();
1576     }
1577
1578     wxCFRef<CFLocaleRef> userLocaleRef(userLocaleRefRaw);
1579
1580     CFStringRef cfstr = 0;
1581     switch ( index )
1582     {
1583         case wxLOCALE_THOUSANDS_SEP:
1584             cfstr = (CFStringRef) CFLocaleGetValue(userLocaleRef, kCFLocaleGroupingSeparator);
1585             break;
1586
1587         case wxLOCALE_DECIMAL_POINT:
1588             cfstr = (CFStringRef) CFLocaleGetValue(userLocaleRef, kCFLocaleDecimalSeparator);
1589             break;
1590
1591         case wxLOCALE_SHORT_DATE_FMT:
1592         case wxLOCALE_LONG_DATE_FMT:
1593         case wxLOCALE_DATE_TIME_FMT:
1594         case wxLOCALE_TIME_FMT:
1595             {
1596                 CFDateFormatterStyle dateStyle = kCFDateFormatterNoStyle;
1597                 CFDateFormatterStyle timeStyle = kCFDateFormatterNoStyle;
1598                 switch (index )
1599                 {
1600                     case wxLOCALE_SHORT_DATE_FMT:
1601                         dateStyle = kCFDateFormatterShortStyle;
1602                         break;
1603                     case wxLOCALE_LONG_DATE_FMT:
1604                         dateStyle = kCFDateFormatterFullStyle;
1605                         break;
1606                     case wxLOCALE_DATE_TIME_FMT:
1607                         dateStyle = kCFDateFormatterFullStyle;
1608                         timeStyle = kCFDateFormatterMediumStyle;
1609                         break;
1610                     case wxLOCALE_TIME_FMT:
1611                         timeStyle = kCFDateFormatterMediumStyle;
1612                         break;
1613                     default:
1614                         wxFAIL_MSG( "unexpected time locale" );
1615                         return wxString();
1616                 }
1617                 wxCFRef<CFDateFormatterRef> dateFormatter( CFDateFormatterCreate
1618                     (NULL, userLocaleRef, dateStyle, timeStyle));
1619                 wxCFStringRef cfs = wxCFRetain( CFDateFormatterGetFormat(dateFormatter ));
1620                 wxString format = TranslateFromUnicodeFormat(cfs.AsString());
1621                 // we always want full years
1622                 format.Replace("%y","%Y");
1623                 return format;
1624             }
1625             break;
1626
1627         default:
1628             wxFAIL_MSG( "Unknown locale info" );
1629             return wxString();
1630     }
1631
1632     wxCFStringRef str(wxCFRetain(cfstr));
1633     return str.AsString();
1634 }
1635
1636 #else // !__WINDOWS__ && !__WXOSX__, assume generic POSIX
1637
1638 namespace
1639 {
1640
1641 wxString GetDateFormatFromLangInfo(wxLocaleInfo index)
1642 {
1643 #ifdef HAVE_LANGINFO_H
1644     // array containing parameters for nl_langinfo() indexes by offset of index
1645     // from wxLOCALE_SHORT_DATE_FMT
1646     static const nl_item items[] =
1647     {
1648         D_FMT, D_T_FMT, D_T_FMT, T_FMT,
1649     };
1650
1651     const int nlidx = index - wxLOCALE_SHORT_DATE_FMT;
1652     if ( nlidx < 0 || nlidx >= (int)WXSIZEOF(items) )
1653     {
1654         wxFAIL_MSG( "logic error in GetInfo() code" );
1655         return wxString();
1656     }
1657
1658     const wxString fmt(nl_langinfo(items[nlidx]));
1659
1660     // just return the format returned by nl_langinfo() except for long date
1661     // format which we need to recover from date/time format ourselves (but not
1662     // if we failed completely)
1663     if ( fmt.empty() || index != wxLOCALE_LONG_DATE_FMT )
1664         return fmt;
1665
1666     // this is not 100% precise but the idea is that a typical date/time format
1667     // under POSIX systems is a combination of a long date format with time one
1668     // so we should be able to get just the long date format by removing all
1669     // time-specific format specifiers
1670     static const char *timeFmtSpecs = "HIklMpPrRsSTXzZ";
1671     static const char *timeSep = " :./-";
1672
1673     wxString fmtDateOnly;
1674     const wxString::const_iterator end = fmt.end();
1675     wxString::const_iterator lastSep = end;
1676     for ( wxString::const_iterator p = fmt.begin(); p != end; ++p )
1677     {
1678         if ( strchr(timeSep, *p) )
1679         {
1680             if ( lastSep == end )
1681                 lastSep = p;
1682
1683             // skip it for now, we'll discard it if it's followed by a time
1684             // specifier later or add it to fmtDateOnly if it is not
1685             continue;
1686         }
1687
1688         if ( *p == '%' &&
1689                 (p + 1 != end) && strchr(timeFmtSpecs, p[1]) )
1690         {
1691             // time specified found: skip it and any preceding separators
1692             ++p;
1693             lastSep = end;
1694             continue;
1695         }
1696
1697         if ( lastSep != end )
1698         {
1699             fmtDateOnly += wxString(lastSep, p);
1700             lastSep = end;
1701         }
1702
1703         fmtDateOnly += *p;
1704     }
1705
1706     return fmtDateOnly;
1707 #else // !HAVE_LANGINFO_H
1708     wxUnusedVar(index);
1709
1710     // no fallback, let the application deal with unavailability of
1711     // nl_langinfo() itself as there is no good way for us to do it (well, we
1712     // could try to reverse engineer the format from strftime() output but this
1713     // looks like too much trouble considering the relatively small number of
1714     // systems without nl_langinfo() still in use)
1715     return wxString();
1716 #endif // HAVE_LANGINFO_H/!HAVE_LANGINFO_H
1717 }
1718
1719 } // anonymous namespace
1720
1721 /* static */
1722 wxString wxLocale::GetInfo(wxLocaleInfo index, wxLocaleCategory cat)
1723 {
1724     lconv * const lc = localeconv();
1725     if ( !lc )
1726         return wxString();
1727
1728     switch ( index )
1729     {
1730         case wxLOCALE_THOUSANDS_SEP:
1731             if ( cat == wxLOCALE_CAT_NUMBER )
1732                 return lc->thousands_sep;
1733             else if ( cat == wxLOCALE_CAT_MONEY )
1734                 return lc->mon_thousands_sep;
1735
1736             wxFAIL_MSG( "invalid wxLocaleCategory" );
1737             break;
1738
1739
1740         case wxLOCALE_DECIMAL_POINT:
1741             if ( cat == wxLOCALE_CAT_NUMBER )
1742                 return lc->decimal_point;
1743             else if ( cat == wxLOCALE_CAT_MONEY )
1744                 return lc->mon_decimal_point;
1745
1746             wxFAIL_MSG( "invalid wxLocaleCategory" );
1747             break;
1748
1749         case wxLOCALE_SHORT_DATE_FMT:
1750         case wxLOCALE_LONG_DATE_FMT:
1751         case wxLOCALE_DATE_TIME_FMT:
1752         case wxLOCALE_TIME_FMT:
1753             if ( cat != wxLOCALE_CAT_DATE && cat != wxLOCALE_CAT_DEFAULT )
1754             {
1755                 wxFAIL_MSG( "invalid wxLocaleCategory" );
1756                 break;
1757             }
1758
1759             return GetDateFormatFromLangInfo(index);
1760
1761
1762         default:
1763             wxFAIL_MSG( "unknown wxLocaleInfo value" );
1764     }
1765
1766     return wxString();
1767 }
1768
1769 #endif // platform
1770
1771 // ----------------------------------------------------------------------------
1772 // global functions and variables
1773 // ----------------------------------------------------------------------------
1774
1775 // retrieve/change current locale
1776 // ------------------------------
1777
1778 // the current locale object
1779 static wxLocale *g_pLocale = NULL;
1780
1781 wxLocale *wxGetLocale()
1782 {
1783     return g_pLocale;
1784 }
1785
1786 wxLocale *wxSetLocale(wxLocale *pLocale)
1787 {
1788     wxLocale *pOld = g_pLocale;
1789     g_pLocale = pLocale;
1790     return pOld;
1791 }
1792
1793
1794
1795 // ----------------------------------------------------------------------------
1796 // wxLocale module (for lazy destruction of languagesDB)
1797 // ----------------------------------------------------------------------------
1798
1799 class wxLocaleModule: public wxModule
1800 {
1801     DECLARE_DYNAMIC_CLASS(wxLocaleModule)
1802     public:
1803         wxLocaleModule() {}
1804
1805         bool OnInit()
1806         {
1807             return true;
1808         }
1809
1810         void OnExit()
1811         {
1812             wxLocale::DestroyLanguagesDB();
1813         }
1814 };
1815
1816 IMPLEMENT_DYNAMIC_CLASS(wxLocaleModule, wxModule)
1817
1818 #endif // wxUSE_INTL