document various enumerations defined in defs.h; give a name to the anonymous enum...

[wxWidgets.git] / include / wx / intl.h

diff --git a/include/wx/intl.h b/include/wx/intl.h
index aaf724eacd020d25e8a3069802ec1c6ae4686bdc..cead0308847621d817aa0e41c8769cde41cc56fe 100644 (file)
--- a/include/wx/intl.h
+++ b/include/wx/intl.h
@@ -1,26 +1,38 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/intl.h
 /////////////////////////////////////////////////////////////////////////////
 // Name:        wx/intl.h

-// Purpose:     Internationalization and localisation for wxWindows
+// Purpose:     Internationalization and localisation for wxWidgets

 // Author:      Vadim Zeitlin
 // Author:      Vadim Zeitlin

-// Modified by:
+// Modified by: Michael N. Filippov <michael@idisys.iae.nsk.su>
+//              (2003/09/30 - plural forms support)

 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
 // Created:     29/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>

-// Licence:     wxWindows license
+// Licence:     wxWindows licence

 /////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////////////////////////////////////
 

-#ifndef   __INTLH__
-#define   __INTLH__
+// WARNING: Parts of this file are generated. See misc/languages/README for
+// details.

 
 

-#ifdef __GNUG__
-    #pragma interface "intl.h"
-#endif
+#ifndef _WX_INTL_H_
+#define _WX_INTL_H_

 
 #include "wx/defs.h"
 #include "wx/string.h"
 
 
 #include "wx/defs.h"
 #include "wx/string.h"
 

+// Make wxLayoutDirection enum available without need for wxUSE_INTL so wxWindow, wxApp
+// and other classes are not distrubed by wxUSE_INTL
+
+enum wxLayoutDirection
+{
+    wxLayout_Default,
+    wxLayout_LeftToRight,
+    wxLayout_RightToLeft
+};
+

 #if wxUSE_INTL
 
 #if wxUSE_INTL
 

+#include "wx/fontenc.h"
+

 // ============================================================================
 // global decls
 // ============================================================================
 // ============================================================================
 // global decls
 // ============================================================================


@@ -29,23 +41,25 @@
 // macros
 // ----------------------------------------------------------------------------
 
 // macros
 // ----------------------------------------------------------------------------
 

-// gettext() style macro (notice that xgettext should be invoked with "-k_"
-// option to extract the strings inside _() from the sources)
+// gettext() style macros (notice that xgettext should be invoked with
+// --keyword="_" --keyword="wxPLURAL:1,2" options
+// to extract the strings from the sources)

 #ifndef WXINTL_NO_GETTEXT_MACRO
 #ifndef WXINTL_NO_GETTEXT_MACRO

-    #define   _(str)  wxGetTranslation(_T(str))
+    #define _(s)                     wxGetTranslation((s))
+    #define wxPLURAL(sing, plur, n)  wxGetTranslation((sing), (plur), n)

 #endif
 
 // another one which just marks the strings for extraction, but doesn't
 // perform the translation (use -kwxTRANSLATE with xgettext!)
 #endif
 
 // another one which just marks the strings for extraction, but doesn't
 // perform the translation (use -kwxTRANSLATE with xgettext!)

-#define wxTRANSLATE(str) _T(str)
+#define wxTRANSLATE(str) str

 
 // ----------------------------------------------------------------------------
 // forward decls
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // forward decls
 // ----------------------------------------------------------------------------
 

-class WXDLLEXPORT wxLocale;
-class WXDLLEXPORT wxMsgCatalog;
-class WXDLLEXPORT wxLanguageInfoArray;
+class WXDLLIMPEXP_FWD_BASE wxLocale;
+class WXDLLIMPEXP_FWD_BASE wxLanguageInfoArray;
+class wxMsgCatalog;

 
 // ============================================================================
 // locale support
 
 // ============================================================================
 // locale support


@@ -222,6 +236,7 @@ enum wxLanguage
     wxLANGUAGE_ROMANIAN,
     wxLANGUAGE_RUSSIAN,
     wxLANGUAGE_RUSSIAN_UKRAINE,
     wxLANGUAGE_ROMANIAN,
     wxLANGUAGE_RUSSIAN,
     wxLANGUAGE_RUSSIAN_UKRAINE,

+    wxLANGUAGE_SAMI,

     wxLANGUAGE_SAMOAN,
     wxLANGUAGE_SANGHO,
     wxLANGUAGE_SANSKRIT,
     wxLANGUAGE_SAMOAN,
     wxLANGUAGE_SANGHO,
     wxLANGUAGE_SANSKRIT,


@@ -285,6 +300,7 @@ enum wxLanguage
     wxLANGUAGE_UZBEK,
     wxLANGUAGE_UZBEK_CYRILLIC,
     wxLANGUAGE_UZBEK_LATIN,
     wxLANGUAGE_UZBEK,
     wxLANGUAGE_UZBEK_CYRILLIC,
     wxLANGUAGE_UZBEK_LATIN,

+    wxLANGUAGE_VALENCIAN,

     wxLANGUAGE_VIETNAMESE,
     wxLANGUAGE_VOLAPUK,
     wxLANGUAGE_WELSH,
     wxLANGUAGE_VIETNAMESE,
     wxLANGUAGE_VOLAPUK,
     wxLANGUAGE_WELSH,


@@ -301,21 +317,68 @@ enum wxLanguage
 
 // --- --- --- generated code ends here --- --- ---
 
 
 // --- --- --- generated code ends here --- --- ---
 

-
-

 // ----------------------------------------------------------------------------
 // wxLanguageInfo: encapsulates wxLanguage to OS native lang.desc.
 //                 translation information
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // wxLanguageInfo: encapsulates wxLanguage to OS native lang.desc.
 //                 translation information
 // ----------------------------------------------------------------------------
 

-struct WXDLLEXPORT wxLanguageInfo
+struct WXDLLIMPEXP_BASE wxLanguageInfo

 {
     int Language;                   // wxLanguage id
     wxString CanonicalName;         // Canonical name, e.g. fr_FR
 {
     int Language;                   // wxLanguage id
     wxString CanonicalName;         // Canonical name, e.g. fr_FR

-#ifdef __WIN32__
-    wxUint32 WinLang, WinSublang;   // Win32 language identifiers
-#endif
+#ifdef __WXMSW__
+    wxUint32 WinLang,               // Win32 language identifiers
+             WinSublang;
+#endif // __WXMSW__

     wxString Description;           // human-readable name of the language
     wxString Description;           // human-readable name of the language

+    wxLayoutDirection LayoutDirection;
+
+#ifdef __WXMSW__
+    // return the LCID corresponding to this language
+    wxUint32 GetLCID() const;
+#endif // __WXMSW__
+
+    // return the locale name corresponding to this language usable with
+    // setlocale() on the current system
+    wxString GetLocaleName() const;
+};
+
+// for Unix systems GetLocaleName() is trivial so implement it inline here, for
+// MSW it's implemented in intl.cpp
+#ifndef __WXMSW__
+inline wxString wxLanguageInfo::GetLocaleName() const { return CanonicalName; }
+#endif // !__WXMSW__
+
+// ----------------------------------------------------------------------------
+// wxLocaleCategory: the category of locale settings
+// ----------------------------------------------------------------------------
+
+enum wxLocaleCategory
+{
+    // (any) numbers
+    wxLOCALE_CAT_NUMBER,
+
+    // date/time
+    wxLOCALE_CAT_DATE,
+
+    // monetary value
+    wxLOCALE_CAT_MONEY,
+
+    wxLOCALE_CAT_MAX
+};
+
+// ----------------------------------------------------------------------------
+// wxLocaleInfo: the items understood by wxLocale::GetInfo()
+// ----------------------------------------------------------------------------
+
+enum wxLocaleInfo
+{
+    // the thounsands separator
+    wxLOCALE_THOUSANDS_SEP,
+
+    // the character used as decimal point
+    wxLOCALE_DECIMAL_POINT
+

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -329,52 +392,70 @@ enum wxLocaleInitFlags
     wxLOCALE_CONV_ENCODING = 0x0002      // convert encoding on the fly?
 };
 
     wxLOCALE_CONV_ENCODING = 0x0002      // convert encoding on the fly?
 };
 

-
-class WXDLLEXPORT wxLocale
+class WXDLLIMPEXP_BASE wxLocale

 {
 public:
     // ctor & dtor
     // -----------
 
         // call Init() if you use this ctor
 {
 public:
     // ctor & dtor
     // -----------
 
         // call Init() if you use this ctor

-    wxLocale();
+    wxLocale() { DoCommonInit(); }
+

         // the ctor has a side effect of changing current locale
         // the ctor has a side effect of changing current locale

-    wxLocale(const wxChar *szName,                               // name (for messages)
-             const wxChar *szShort = (const wxChar *) NULL,      // dir prefix (for msg files)
-             const wxChar *szLocale = (const wxChar *) NULL,     // locale (for setlocale)
-             bool bLoadDefault = TRUE,                           // preload wxstd.mo?
-             bool bConvertEncoding = FALSE)                      // convert Win<->Unix if neccessary?
+    wxLocale(const wxString& name,                               // name (for messages)
+             const wxString& shortName = wxEmptyString,      // dir prefix (for msg files)
+             const wxString& locale = wxEmptyString,     // locale (for setlocale)
+             bool bLoadDefault = true,                           // preload wxstd.mo?
+             bool bConvertEncoding = false)                      // convert Win<->Unix if necessary?

         {
         {

-            Init(szName, szShort, szLocale, bLoadDefault, bConvertEncoding);
+            DoCommonInit();
+
+            Init(name, shortName, locale, bLoadDefault, bConvertEncoding);

         }
 
     wxLocale(int language, // wxLanguage id or custom language
              int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING)
         }
 
     wxLocale(int language, // wxLanguage id or custom language
              int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING)

-        { Init(language, flags); }
+        {
+            DoCommonInit();

 
 

-        // the same as a function (returns TRUE on success)
-    bool Init(const wxChar *szName,
-              const wxChar *szShort = (const wxChar *) NULL,
-              const wxChar *szLocale = (const wxChar *) NULL,
-              bool bLoadDefault = TRUE,
-              bool bConvertEncoding = FALSE);
+            Init(language, flags);
+        }
+
+        // the same as a function (returns true on success)
+    bool Init(const wxString& name,
+              const wxString& shortName = wxEmptyString,
+              const wxString& locale = wxEmptyString,
+              bool bLoadDefault = true,
+              bool bConvertEncoding = false);

 
 

-        // same as second ctor (returns TRUE on success)
+        // same as second ctor (returns true on success)

     bool Init(int language = wxLANGUAGE_DEFAULT,
               int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING);
 
         // restores old locale
     bool Init(int language = wxLANGUAGE_DEFAULT,
               int flags = wxLOCALE_LOAD_DEFAULT | wxLOCALE_CONV_ENCODING);
 
         // restores old locale

-    ~wxLocale();
+    virtual ~wxLocale();

 
 

-    // Try to get user's (or OS's) prefered language setting.
+    // Try to get user's (or OS's) preferred language setting.

     // Return wxLANGUAGE_UNKNOWN if language-guessing algorithm failed
     static int GetSystemLanguage();
 
     // Return wxLANGUAGE_UNKNOWN if language-guessing algorithm failed
     static int GetSystemLanguage();
 

-    // return TRUE if the locale was set successfully
+    // get the encoding used by default for text on this system, returns
+    // wxFONTENCODING_SYSTEM if it couldn't be determined
+    static wxFontEncoding GetSystemEncoding();
+
+    // get the string describing the system encoding, return empty string if
+    // couldn't be determined
+    static wxString GetSystemEncodingName();
+
+    // get the values of the given locale-dependent datum: the current locale
+    // is used, the US default value is returned if everything else fails
+    static wxString GetInfo(wxLocaleInfo index, wxLocaleCategory cat);
+
+    // return true if the locale was set successfully

     bool IsOk() const { return m_pszOldLocale != NULL; }
 
     // returns locale name
     bool IsOk() const { return m_pszOldLocale != NULL; }
 
     // returns locale name

-    const wxChar *GetLocale() const { return m_strLocale; }
+    const wxString& GetLocale() const { return m_strLocale; }

 
     // return current locale wxLanguage value
     int GetLanguage() const { return m_language; }
 
     // return current locale wxLanguage value
     int GetLanguage() const { return m_language; }


@@ -401,10 +482,31 @@ public:
     // The loaded catalog will be used for message lookup by GetString().
     //
     // Returns 'true' if it was successfully loaded
     // The loaded catalog will be used for message lookup by GetString().
     //
     // Returns 'true' if it was successfully loaded

-    bool AddCatalog(const wxChar *szDomain);
+    bool AddCatalog(const wxString& domain);
+    bool AddCatalog(const wxString& domain,
+                    wxLanguage msgIdLanguage, const wxString& msgIdCharset);
+
+    // check if the given locale is provided by OS and C run time
+    static bool IsAvailable(int lang);

 
     // check if the given catalog is loaded
 
     // check if the given catalog is loaded

-    bool IsLoaded(const wxChar *szDomain) const;
+    bool IsLoaded(const wxString& domain) const;
+
+    // Retrieve the language info struct for the given language
+    //
+    // Returns NULL if no info found, pointer must *not* be deleted by caller
+    static const wxLanguageInfo *GetLanguageInfo(int lang);
+
+    // Returns language name in English or empty string if the language
+    // is not in database
+    static wxString GetLanguageName(int lang);
+
+    // Find the language for the given locale string which may be either a
+    // canonical ISO 2 letter language code ("xx"), a language code followed by
+    // the country code ("xx_XX") or a Windows full language name ("Xxxxx...")
+    //
+    // Returns NULL if no info found, pointer must *not* be deleted by caller
+    static const wxLanguageInfo *FindLanguageInfo(const wxString& locale);

 
     // Add custom language to the list of known languages.
     // Notes: 1) wxLanguageInfo contains platform-specific data
 
     // Add custom language to the list of known languages.
     // Notes: 1) wxLanguageInfo contains platform-specific data


@@ -414,6 +516,7 @@ public:
     // retrieve the translation for a string in all loaded domains unless
     // the szDomain parameter is specified (and then only this domain is
     // searched)
     // retrieve the translation for a string in all loaded domains unless
     // the szDomain parameter is specified (and then only this domain is
     // searched)

+    // n - additional parameter for PluralFormsParser

     //
     // return original string if translation is not available
     // (in this case an error message is generated the first time
     //
     // return original string if translation is not available
     // (in this case an error message is generated the first time


@@ -421,12 +524,26 @@ public:
     //
     // domains are searched in the last to first order, i.e. catalogs
     // added later override those added before.
     //
     // domains are searched in the last to first order, i.e. catalogs
     // added later override those added before.

-    const wxMB2WXbuf GetString(const wxChar *szOrigString,
-                               const wxChar *szDomain = (const wxChar *) NULL) const;
+    virtual const wxString& GetString(const wxString& origString,
+                                      const wxString& domain = wxEmptyString) const;
+    // plural form version of the same:
+    virtual const wxString& GetString(const wxString& origString,
+                                      const wxString& origString2,
+                                      size_t n,
+                                      const wxString& domain = wxEmptyString) const;
+
+    // this is hack to work around a problem with wxGetTranslation() which
+    // returns const wxString& and not wxString, so when it returns untranslated
+    // string, it needs to have a copy of it somewhere
+    static const wxString& GetUntranslatedString(const wxString& str);

 
     // Returns the current short name for the locale
     const wxString& GetName() const { return m_strShort; }
 
 
     // Returns the current short name for the locale
     const wxString& GetName() const { return m_strShort; }
 

+    // return the contents of .po file header
+    wxString GetHeaderValue(const wxString& header,
+                            const wxString& domain = wxEmptyString) const;
+

     // These two methods are for internal use only. First one creates
     // ms_languagesDB if it doesn't already exist, second one destroys
     // it.
     // These two methods are for internal use only. First one creates
     // ms_languagesDB if it doesn't already exist, second one destroys
     // it.


@@ -435,24 +552,31 @@ public:
 
 private:
     // find catalog by name in a linked list, return NULL if !found
 
 private:
     // find catalog by name in a linked list, return NULL if !found

-    wxMsgCatalog  *FindCatalog(const wxChar *szDomain) const;
+    wxMsgCatalog *FindCatalog(const wxString& domain) const;

 
     // copy default table of languages from global static array to
     // m_langugagesInfo, called by InitLanguagesDB
     static void InitLanguagesDB();
 
 
     // copy default table of languages from global static array to
     // m_langugagesInfo, called by InitLanguagesDB
     static void InitLanguagesDB();
 

+    // initialize the member fields to default values
+    void DoCommonInit();
+

     wxString       m_strLocale,       // this locale name
                    m_strShort;        // short name for the locale
     int            m_language;        // this locale wxLanguage value
 
     wxString       m_strLocale,       // this locale name
                    m_strShort;        // short name for the locale
     int            m_language;        // this locale wxLanguage value
 

-    const wxChar  *m_pszOldLocale;    // previous locale from setlocale()
+    const char  *m_pszOldLocale;      // previous locale from setlocale()

     wxLocale      *m_pOldLocale;      // previous wxLocale
 
     wxMsgCatalog  *m_pMsgCat;         // pointer to linked list of catalogs
 
     bool           m_bConvertEncoding;
 
     wxLocale      *m_pOldLocale;      // previous wxLocale
 
     wxMsgCatalog  *m_pMsgCat;         // pointer to linked list of catalogs
 
     bool           m_bConvertEncoding;
 

+    bool           m_initialized;
+

     static wxLanguageInfoArray *ms_languagesDB;
     static wxLanguageInfoArray *ms_languagesDB;

+
+    DECLARE_NO_COPY_CLASS(wxLocale)

 };
 
 // ----------------------------------------------------------------------------
 };
 
 // ----------------------------------------------------------------------------


@@ -460,37 +584,82 @@ private:
 // ----------------------------------------------------------------------------
 
 // get the current locale object (note that it may be NULL!)
 // ----------------------------------------------------------------------------
 
 // get the current locale object (note that it may be NULL!)

-extern WXDLLEXPORT wxLocale* wxGetLocale();
+extern WXDLLIMPEXP_BASE wxLocale* wxGetLocale();

 
 // get the translation of the string in the current locale
 
 // get the translation of the string in the current locale

-inline const wxMB2WXbuf wxGetTranslation(const wxChar *sz)
+inline const wxString& wxGetTranslation(const wxString& str,
+                                        const wxString& domain = wxEmptyString)
+{
+    wxLocale *pLoc = wxGetLocale();
+    if (pLoc)
+        return pLoc->GetString(str, domain);
+    else
+        // NB: this function returns reference to a string, so we have to keep
+        //     a copy of it somewhere
+        return wxLocale::GetUntranslatedString(str);
+}
+inline const wxString& wxGetTranslation(const wxString& str1,
+                                        const wxString& str2,
+                                        size_t n,
+                                        const wxString& domain = wxEmptyString)

 {
     wxLocale *pLoc = wxGetLocale();
     if (pLoc)
 {
     wxLocale *pLoc = wxGetLocale();
     if (pLoc)

-        return pLoc->GetString(sz);
+        return pLoc->GetString(str1, str2, n, domain);

     else
     else

-        return (const wxMB2WXbuf)sz;
+        // NB: this function returns reference to a string, so we have to keep
+        //     a copy of it somewhere
+        return n == 1
+               ? wxLocale::GetUntranslatedString(str1)
+               : wxLocale::GetUntranslatedString(str2);

 }
 
 #else // !wxUSE_INTL
 
 // the macros should still be defined - otherwise compilation would fail
 
 }
 
 #else // !wxUSE_INTL
 
 // the macros should still be defined - otherwise compilation would fail
 

-#if !defined(WXINTL_NO_GETTEXT_MACRO) && !defined(_)
-    #define   _(str)  (str)
+#if !defined(WXINTL_NO_GETTEXT_MACRO)
+    #if !defined(_)
+        #define _(s)                 (s)
+    #endif
+    #define wxPLURAL(sing, plur, n)  ((n) == 1 ? (sing) : (plur))

 #endif
 
 #endif
 

-#define wxTRANSLATE(str) _T(str)
+#define wxTRANSLATE(str) str
+
+// NB: we use a template here in order to avoid using
+//     wxLocale::GetUntranslatedString() above, which would be required if
+//     we returned const wxString&; this way, the compiler should be able to
+//     optimize wxGetTranslation() away
+
+template<typename TString>
+inline TString wxGetTranslation(TString str)
+    { return str; }

 
 

-inline const wxChar *wxGetTranslation(const wxChar *sz) { return sz; }
+template<typename TString, typename TDomain>
+inline TString wxGetTranslation(TString str, TDomain WXUNUSED(domain))
+    { return str; }
+
+template<typename TString, typename TDomain>
+inline TString wxGetTranslation(TString str1, TString str2, size_t n)
+    { return n == 1 ? str1 : str2; }
+
+template<typename TString, typename TDomain>
+inline TString wxGetTranslation(TString str1, TString str2, size_t n,
+                                TDomain WXUNUSED(domain))
+    { return n == 1 ? str1 : str2; }

 
 #endif // wxUSE_INTL/!wxUSE_INTL
 
 // define this one just in case it occurs somewhere (instead of preferred
 // wxTRANSLATE) too
 
 #endif // wxUSE_INTL/!wxUSE_INTL
 
 // define this one just in case it occurs somewhere (instead of preferred
 // wxTRANSLATE) too

-#if !defined(WXINTL_NO_GETTEXT_MACRO) && !defined(gettext_noop)
-    #define gettext_noop(str) _T(str)
+#if !defined(WXINTL_NO_GETTEXT_MACRO)
+    #if !defined(gettext_noop)
+        #define gettext_noop(str) (str)
+    #endif
+    #if !defined(N_)
+        #define N_(s)             (s)
+    #endif

 #endif
 
 #endif
 

-#endif
-    // _WX_INTLH__
+#endif // _WX_INTL_H_