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