Python i18n API. Many thanks to Campbell and Brecht for the reviews and suggestions!
authorBastien Montagne <montagne29@wanadoo.fr>
Sun, 20 Jan 2013 17:29:07 +0000 (17:29 +0000)
committerBastien Montagne <montagne29@wanadoo.fr>
Sun, 20 Jan 2013 17:29:07 +0000 (17:29 +0000)
This commit adds:
* A new bpy.app.translations module giving some info about locales/translation stuff (current active locale, all locales currently known by blender, all translation contexts currently defined, etc.).

* The ability for addons to feature translations, using the (un)register functions of above module.

* Also cleans up "translate py string when storing into RNA prop" by removing "PROP_TRANSLATE" string's subtype, and adding a PROP_STRING_PY_TRANSLATE flag instead (this way it is no more exposed to python...).

Addon translations work with py dictionaries: each addon features a dict {lang: {(context, message): translation, ...}, ...}, which is registered when the addon is enabled (and unregistered when disabled).

Then, when a key (context, message) is not found in regular mo catalog, a cache dict for current locale is built from all registered addon translations, and key is searched in it.

Note: currently addons writers have to do all the work by hand, will add something (probably extend "edit translation" addon) to automate messages extraction from addons soon(ish)! To get a look to expected behavior from addons, have a look at render_copy_settings/__init__.py and render_copy_settings/translations.py (rather stupid example currently, but...). Once we have a complete process, I'll also update relevant wiki pages.

23 files changed:
intern/locale/boost_locale_wrapper.cpp
intern/locale/boost_locale_wrapper.h
source/blender/blenfont/BLF_translation.h
source/blender/blenfont/CMakeLists.txt
source/blender/blenfont/SConscript
source/blender/blenfont/intern/blf_lang.c
source/blender/blenfont/intern/blf_translation.c
source/blender/makesrna/RNA_define.h
source/blender/makesrna/RNA_types.h
source/blender/makesrna/intern/makesrna.c
source/blender/makesrna/intern/rna_define.c
source/blender/makesrna/intern/rna_rna.c
source/blender/makesrna/intern/rna_ui.c
source/blender/makesrna/intern/rna_ui_api.c
source/blender/makesrna/intern/rna_wm.c
source/blender/python/BPY_extern.h
source/blender/python/intern/CMakeLists.txt
source/blender/python/intern/bpy_app.c
source/blender/python/intern/bpy_app_build_options.c
source/blender/python/intern/bpy_app_translations.c [new file with mode: 0644]
source/blender/python/intern/bpy_app_translations.h [new file with mode: 0644]
source/blender/python/intern/bpy_props.c
source/blender/python/intern/bpy_rna.c

index 80e75298d70ce74b1327f1ee0a33187b7be282f4..ebd2dd652c70e8713becd2bf3c4ad441418d5e0c 100644 (file)
@@ -33,6 +33,7 @@
 
 static std::string messages_path;
 static std::string default_domain;
+static std::string locale_str;
 
 void bl_locale_init(const char *_messages_path, const char *_default_domain)
 {
@@ -52,6 +53,7 @@ void bl_locale_init(const char *_messages_path, const char *_default_domain)
 void bl_locale_set(const char *locale)
 {
        boost::locale::generator gen;
+       std::locale _locale;
        // Specify location of dictionaries.
        gen.add_messages_path(messages_path);
        gen.add_messages_domain(default_domain);
@@ -59,7 +61,8 @@ void bl_locale_set(const char *locale)
 
        try {
                if (locale && locale[0]) {
-                       std::locale::global(gen(locale));
+                       _locale = gen(locale);
+                       std::locale::global(_locale);
                }
                else {
 #ifdef __APPLE__
@@ -85,9 +88,11 @@ void bl_locale_set(const char *locale)
                        if (locale_osx == "")
                                fprintf(stderr, "Locale set: failed to read AppleLocale read from defaults\n");
 
-                       std::locale::global(gen(locale_osx.c_str()));
+                       _locale = gen(locale_osx.c_str());
+                       std::locale::global(_locale);
 #else
-                       std::locale::global(gen(""));
+                       _locale = gen("");
+                       std::locale::global(_locale);
 #endif
                }
                // Note: boost always uses "C" LC_NUMERIC by default!
@@ -95,6 +100,22 @@ void bl_locale_set(const char *locale)
        catch(std::exception const &e) {
                std::cout << "bl_locale_set(" << locale << "): " << e.what() << " \n";
        }
+
+       /* Generate the locale string (useful to know which locale we are actually using in case of "default" one). */
+#define LOCALE_INFO std::use_facet<boost::locale::info>(_locale)
+
+       locale_str = LOCALE_INFO.language();
+       if (LOCALE_INFO.country() != "") {
+               locale_str += "_" + LOCALE_INFO.country();
+       }
+       if (LOCALE_INFO.variant() != "") {
+               locale_str += "@" + LOCALE_INFO.variant();
+       }
+}
+
+const char *bl_locale_get(void)
+{
+       return locale_str.c_str();
 }
 
 const char *bl_locale_pgettext(const char *msgctxt, const char *msgid)
@@ -115,5 +136,4 @@ const char *bl_locale_pgettext(const char *msgctxt, const char *msgid)
 //             std::cout << "bl_locale_pgettext(" << msgctxt << ", " << msgid << "): " << e.what() << " \n";
                return msgid;
        }
-}
-
+}
\ No newline at end of file
index e7956d216f18b934cbe93821e531848fa2d7084e..4e3a1f848d22a1eb80ca25ab6c11223516eb04a2 100644 (file)
@@ -40,7 +40,8 @@ extern "C" {
 
 void bl_locale_init(const char *messages_path, const char *default_domain);
 void bl_locale_set(const char *locale);
-const char* bl_locale_pgettext(const char *msgctxt, const char *msgid);
+const char *bl_locale_get(void);
+const char *bl_locale_pgettext(const char *msgctxt, const char *msgid);
 
 #ifdef __cplusplus
 }
index 0832907d1d92abe998ef43dc9db16a164a29ff29..59f66cae7277b3824ecf30ce1c81bb05dd2b4625 100644 (file)
@@ -51,6 +51,13 @@ void BLF_lang_set(const char *);
 /* Get the current locale (short code, e.g. es_ES). */
 const char *BLF_lang_get(void);
 
+/* Get locale's elements (if relevant pointer is not NULL and element actually exists, e.g. if there is no variant,
+ * *variant and *language_variant will always be NULL).
+ * Non-null elements are always MEM_mallocN'ed, it's the caller's responsibility to free them. 
+ */
+void BLF_locale_explode(const char *locale, char **language, char **country, char **variant,
+                        char **language_country, char **language_variant);
+
 /* Get EnumPropertyItem's for translations menu. */
 struct EnumPropertyItem *BLF_RNA_lang_enum_properties(void);
 
@@ -143,4 +150,54 @@ const char *BLF_translate_do_tooltip(const char *msgctxt, const char *msgid);
 #define BLF_I18NCONTEXT_ID_MOVIECLIP            "MovieClip"
 #define BLF_I18NCONTEXT_ID_MASK                 "Mask"
 
-#endif /* __BLF_TRANSLATION_H__ */
+/* Helper for bpy.app.i18n object... */
+typedef struct
+{
+       const char *c_id;
+       const char *py_id;
+       const char *value;
+} BLF_i18n_contexts_descriptor;
+
+#define BLF_I18NCONTEXTS_ITEM(ctxt_id, py_id) {#ctxt_id, py_id, ctxt_id}
+
+#define BLF_I18NCONTEXTS_DESC {                                                                                         \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_DEFAULT, "default"),                                                         \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_OPERATOR_DEFAULT, "operator_default"),                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_ACTION, "id_action"),                                                     \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_ARMATURE, "id_armature"),                                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_BRUSH, "id_brush"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_CAMERA, "id_camera"),                                                     \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_CURVE, "id_curve"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_GPENCIL, "id_gpencil"),                                                   \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_GROUP, "id_group"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_ID, "id_id"),                                                             \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_IMAGE, "id_image"),                                                       \
+       /*BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_IPO, "id_ipo"),*/                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_SHAPEKEY, "id_shapekey"),                                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_LAMP, "id_lamp"),                                                         \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_LIBRARY, "id_library"),                                                   \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_LATTICE, "id_lattice"),                                                   \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_MATERIAL, "id_material"),                                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_METABALL, "id_metaball"),                                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_MESH, "id_mesh"),                                                         \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_NODETREE, "id_nodetree"),                                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_OBJECT, "id_object"),                                                     \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_PARTICLESETTINGS, "id_particlesettings"),                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_SCENE, "id_scene"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_SCREEN, "id_screen"),                                                     \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_SEQUENCE, "id_sequence"),                                                 \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_SPEAKER, "id_speaker"),                                                   \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_SOUND, "id_sound"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_TEXTURE, "id_texture"),                                                   \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_TEXT, "id_text"),                                                         \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_VFONT, "id_vfont"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_WORLD, "id_world"),                                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_WINDOWMANAGER, "id_windowmanager"),                                       \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_MOVIECLIP, "id_movieclip"),                                               \
+       BLF_I18NCONTEXTS_ITEM(BLF_I18NCONTEXT_ID_MASK, "id_mask"),                                                         \
+       {NULL, NULL, NULL}                                                                                                 \
+}
+
+//#undef _BLF_I18NCONTEXTS_ITEM
+
+#endif /* __BLF_TRANSLATION_H__ */
\ No newline at end of file
index 90baef14a748530aacc1a044decce916d721af87..7bb80c343232e1d0a39f8501554b9d6c738dcb59 100644 (file)
@@ -29,6 +29,7 @@ set(INC
        ../editors/include
        ../makesdna
        ../makesrna
+       ../python
        ../imbuf
        ../../../intern/guardedalloc
        ../../../intern/locale
index a6ea724a51f25a169f95f6c8f92eb352f6791e67..d1ef181f75c766787019d187de65ae4b40c39077 100644 (file)
@@ -31,7 +31,7 @@ Import ('env')
 sources = env.Glob('intern/*.c')
 
 incs = '. intern  #/intern/guardedalloc #/intern/locale ../blenkernel ../blenlib ../blenloader'
-incs += ' ../makesdna ../makesrna ../imbuf ../editors/include'
+incs += ' ../makesdna ../makesrna ../python ../imbuf ../editors/include'
 incs += ' #/extern/glew/include'
 incs += ' ' + env['BF_FREETYPE_INC']
 
index 9086799f98456cc51bdf28ddc9fb976702d38410..ab29fae1a589946a3ebbc7b65f78e580dd1fa82f 100644 (file)
@@ -60,7 +60,7 @@ static EnumPropertyItem *locales_menu = NULL;
 static int num_locales_menu = 0;
 
 #define ULANGUAGE ((U.language >= 0 && U.language < num_locales) ? U.language : 0)
-#define LOCALE(_id) (locales ? locales[_id] : "")
+#define LOCALE(_id) (locales ? locales[(_id)] : "")
 
 static void free_locales(void)
 {
@@ -113,7 +113,7 @@ static void fill_locales(void)
        }
        num_locales_menu++; /* The "closing" void item... */
 
-       /* And now, buil locales and locale_menu! */
+       /* And now, build locales and locale_menu! */
        locales_menu = MEM_callocN(num_locales_menu * sizeof(EnumPropertyItem), __func__);
        line = lines;
        /* Do not allocate locales with zero-sized mem, as LOCALE macro uses NULL locales as invalid marker! */
@@ -234,10 +234,15 @@ void BLF_lang_set(const char *str)
        }
 }
 
+/* Get the current locale (short code, e.g. es_ES). */
 const char *BLF_lang_get(void)
 {
-       int uilang = ULANGUAGE;
-       return LOCALE(uilang);
+       const char *locale = LOCALE(ULANGUAGE);
+       if (locale[0] == '\0') {
+               /* Default locale, we have to find which one we are actually using! */
+               locale = bl_locale_get();
+       }
+       return locale;
 }
 
 #undef LOCALE
@@ -245,6 +250,11 @@ const char *BLF_lang_get(void)
 
 #else /* ! WITH_INTERNATIONAL */
 
+EnumPropertyItem *BLF_RNA_lang_enum_properties(void)
+{
+       return NULL;
+}
+
 void BLF_lang_init(void)
 {
        return;
@@ -266,3 +276,56 @@ const char *BLF_lang_get(void)
 }
 
 #endif /* WITH_INTERNATIONAL */
+
+
+/* Get locale's elements (if relevant pointer is not NULL and element actually exists, e.g. if there is no variant,
+ * *variant and *language_variant will always be NULL).
+ * Non-null elements are always MEM_mallocN'ed, it's the caller's responsibility to free them.
+ * NOTE: Keep that one always available, you never know, may become useful even in no-WITH_INTERNATIONAL context...
+ */
+void BLF_locale_explode(const char *locale, char **language, char **country, char **variant,
+                        char **language_country, char **language_variant)
+{
+       char *m1, *m2, *_t = NULL;
+
+       m1 = strchr(locale, '_');
+       m2 = strchr(locale, '@');
+
+       if (language || language_variant) {
+               if (m1 || m2) {
+                       _t = m1 ? BLI_strdupn(locale, m1 - locale) : BLI_strdupn(locale, m2 - locale);
+                       if (language)
+                               *language = _t;
+               }
+               else if (language) {
+                       *language = NULL;
+               }
+       }
+       if (country) {
+               if (m1)
+                       *country = m2 ? BLI_strdupn(m1 + 1, m2 - (m1 + 1)) : BLI_strdup(m1 + 1);
+               else
+                       *country = NULL;
+       }
+       if (variant) {
+               if (m2)
+                       *variant = BLI_strdup(m2 + 1);
+               else
+                       *variant = NULL;
+       }
+       if (language_country) {
+               if (m2)
+                       *language_country = BLI_strdupn(locale, m2 - locale);
+               else
+                       *language_country = NULL;
+       }
+       if (language_variant) {
+               if (m2)
+                       *language_variant = m1 ? BLI_strdupcat(_t, m2 + 1) : BLI_strdup(locale);
+               else
+                       *language_variant = NULL;
+       }
+       if (_t && !language) {
+               MEM_freeN(_t);
+       }
+}
\ No newline at end of file
index 5d4b631688a27c3991758aac338b86e960e38eba..3aaa61d55f27588320cf447309a97a32894d17f3 100644 (file)
@@ -47,6 +47,8 @@
 
 #include "DNA_userdef_types.h" /* For user settings. */
 
+#include "BPY_extern.h"
+
 static const char unifont_filename[] = "droidsans.ttf.gz";
 static unsigned char *unifont_ttf = NULL;
 static int unifont_size = 0;
@@ -84,7 +86,15 @@ const char *BLF_pgettext(const char *msgctxt, const char *msgid)
 {
 #ifdef WITH_INTERNATIONAL
        if (msgid && msgid[0]) {
-               return bl_locale_pgettext(msgctxt, msgid);
+               const char *ret = bl_locale_pgettext(msgctxt, msgid);
+               /* We assume if the returned string is the same (memory level) as the msgid, no translation was found,
+                * and we can try py scripts' ones!
+                */
+               if (ret == msgid) {
+                       ret = BPY_app_translations_py_pgettext(msgctxt, msgid);
+               }
+
+               return ret;
        }
        return "";
 #else
index 463e0e046795e01f6eb733ea89d9ea3f58828612..cd6d74c348800272c276944fdd6638afb656d2a8 100644 (file)
@@ -87,7 +87,7 @@ PropertyRNA *RNA_def_string(StructOrFunctionRNA *cont, const char *identifier, c
 PropertyRNA *RNA_def_string_file_path(StructOrFunctionRNA *cont, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description);
 PropertyRNA *RNA_def_string_dir_path(StructOrFunctionRNA *cont, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description);
 PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description);
-PropertyRNA *RNA_def_string_translate(StructOrFunctionRNA *cont, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description);
+PropertyRNA *RNA_def_string_py_translate(StructOrFunctionRNA *cont, const char *identifier, const char *default_value, int maxlen, const char *ui_name, const char *ui_description);
 
 PropertyRNA *RNA_def_enum(StructOrFunctionRNA *cont, const char *identifier, const EnumPropertyItem *items, int default_value, const char *ui_name, const char *ui_description);
 PropertyRNA *RNA_def_enum_flag(StructOrFunctionRNA *cont, const char *identifier, const EnumPropertyItem *items, int default_value, const char *ui_name, const char *ui_description);
index c76f9824c7384bdbf571e1d5cd010d5b724b3654..5f34fad09c60b6bb2ffbbab5c1a1617d90072418 100644 (file)
@@ -110,10 +110,9 @@ typedef enum PropertySubType {
        PROP_FILEPATH = 1,
        PROP_DIRPATH = 2,
        PROP_FILENAME = 3,
-       PROP_BYTESTRING = 4, /* a string which should be represented as bytes
-                             * in python, still NULL terminated though. */
-       PROP_TRANSLATE = 5, /* a string which should be translated */
-       PROP_PASSWORD = 6,      /* a string which should not be displayed in UI */
+       PROP_BYTESTRING = 4, /* a string which should be represented as bytes in python, still NULL terminated though. */
+       /* 5 was used by "PROP_TRANSLATE" sub-type, which is now a flag. */
+       PROP_PASSWORD = 6, /* a string which should not be displayed in UI */
 
        /* numbers */
        PROP_UNSIGNED = 13,
@@ -144,6 +143,7 @@ typedef enum PropertySubType {
 } PropertySubType;
 
 /* Make sure enums are updated with thses */
+/* HIGHEST FLAG IN USE: 1 << 29 */
 typedef enum PropertyFlag {
        /* editable means the property is editable in the user
         * interface, properties are editable by default except
@@ -200,6 +200,11 @@ typedef enum PropertyFlag {
         */
        PROP_ENUM_FLAG = (1 << 21),
 
+       /* A string which should be translated when converting from py string to RNA prop.
+        * Should only be used in some functions' properties (currently only "text" one of funcs in UI API).
+        */
+       PROP_STRING_PY_TRANSLATE = (1 << 28),
+
        /* need context for update function */
        PROP_CONTEXT_UPDATE = (1 << 22),
        PROP_CONTEXT_PROPERTY_UPDATE = (1 << 22) | (1 << 27),
index 4b512b650a5d5f673cc13fadc0c696d91a516131..605fb18d5aa31cf7086eca880a556963c7b05058 100644 (file)
@@ -2444,7 +2444,6 @@ static const char *rna_property_subtypename(PropertySubType type)
                case PROP_FILENAME: return "PROP_FILENAME";
                case PROP_DIRPATH: return "PROP_DIRPATH";
                case PROP_BYTESTRING: return "PROP_BYTESTRING";
-               case PROP_TRANSLATE: return "PROP_TRANSLATE";
                case PROP_UNSIGNED: return "PROP_UNSIGNED";
                case PROP_PERCENTAGE: return "PROP_PERCENTAGE";
                case PROP_FACTOR: return "PROP_FACTOR";
index b94d7eb691f20e390ebd5814be46acc1aee23f7c..ac30713986045eccee9ce0da286dbf190922a65f 100644 (file)
@@ -2534,13 +2534,14 @@ PropertyRNA *RNA_def_string_file_name(StructOrFunctionRNA *cont_, const char *id
        return prop;
 }
 
-PropertyRNA *RNA_def_string_translate(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
-                                      int maxlen, const char *ui_name, const char *ui_description)
+PropertyRNA *RNA_def_string_py_translate(StructOrFunctionRNA *cont_, const char *identifier, const char *default_value,
+                                         int maxlen, const char *ui_name, const char *ui_description)
 {
        ContainerRNA *cont = cont_;
        PropertyRNA *prop;
 
-       prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_TRANSLATE);
+       prop = RNA_def_property(cont, identifier, PROP_STRING, PROP_NONE);
+       RNA_def_property_flag(prop, PROP_STRING_PY_TRANSLATE);
        if (maxlen != 0) RNA_def_property_string_maxlength(prop, maxlen);
        if (default_value) RNA_def_property_string_default(prop, default_value);
        RNA_def_property_ui_text(prop, ui_name, ui_description);
index f86f6010e27b7e62b5f8faa2be0cea9e8a1295f2..b5b3897ed46c40e218f1a60b5b1e52ef35ba294d 100644 (file)
@@ -46,6 +46,9 @@ EnumPropertyItem property_type_items[] = {
        {0, NULL, 0, NULL, NULL}
 };
 
+/* XXX Keep in sync with bpy_props.c's property_subtype_xxx_items ???
+ *     Currently it is not...
+ */
 EnumPropertyItem property_subtype_items[] = {
        {PROP_NONE, "NONE", 0, "None", ""},
 
@@ -53,7 +56,7 @@ EnumPropertyItem property_subtype_items[] = {
        {PROP_FILEPATH, "FILEPATH", 0, "File Path", ""},
        {PROP_DIRPATH, "DIRPATH", 0, "Directory Path", ""},
        {PROP_FILENAME, "FILENAME", 0, "File Name", ""},
-       {PROP_TRANSLATE, "TRANSLATE", 0, "Translate", ""},
+       {PROP_PASSWORD, "PASSWORD", 0, "Password", "A string that is displayed hidden ('********')"},
 
        /* numbers */
        {PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned", ""},
index 00124a82dd1198bca475142ddff4e8db69f5911d..fad93ea9054d0d4ade68ec80946e5ea07d4dfd3a 100644 (file)
@@ -813,9 +813,6 @@ static void rna_def_panel(BlenderRNA *brna)
                                 "class name is \"OBJECT_PT_hello\", and bl_idname is not set by the "
                                 "script, then bl_idname = \"OBJECT_PT_hello\"");
 
-       /* panel's label indeed doesn't need PROP_TRANSLATE flag: translation of label happens in runtime
-        * when drawing panel and having this flag set will make runtime switching of language much more tricky
-        * because label will be stored translated */
        prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "type->label");
        RNA_def_property_flag(prop, PROP_REGISTER);
@@ -992,9 +989,6 @@ static void rna_def_menu(BlenderRNA *brna)
                                 "class name is \"OBJECT_MT_hello\", and bl_idname is not set by the "
                                 "script, then bl_idname = \"OBJECT_MT_hello\")");
 
-       /* menu's label indeed doesn't need PROP_TRANSLATE flag: translation of label happens in runtime
-        * when drawing panel and having this flag set will make runtime switching of language much more tricky
-        * because label will be stored translated */
        prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "type->label");
        RNA_def_property_flag(prop, PROP_REGISTER);
index 366d0dc1fd9d15b016ea7cc19022554da45c977a..93410383a582b1ed205d167376ffbc5dee37714b 100644 (file)
@@ -196,7 +196,7 @@ static void api_ui_item_common(FunctionRNA *func)
 {
        PropertyRNA *prop;
 
-       RNA_def_string_translate(func, "text", "", 0, "", "Override automatic text of the item");
+       RNA_def_string_py_translate(func, "text", "", 0, "", "Override automatic text of the item");
 
        prop = RNA_def_property(func, "icon", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_items(prop, icon_items);
@@ -466,7 +466,7 @@ void RNA_api_ui_layout(StructRNA *srna)
        parm = RNA_def_string(func, "type_property", "", 0, "",
                              "Identifier of property in data giving the type of the ID-blocks to use");
        RNA_def_property_flag(parm, PROP_REQUIRED);
-       RNA_def_string_translate(func, "text", "", 0, "", "Custom label to display in UI");
+       RNA_def_string_py_translate(func, "text", "", 0, "", "Custom label to display in UI");
        
        func = RNA_def_function(srna, "template_path_builder", "uiTemplatePathBuilder");
        parm = RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property");
@@ -475,7 +475,7 @@ void RNA_api_ui_layout(StructRNA *srna)
        RNA_def_property_flag(parm, PROP_REQUIRED);
        parm = RNA_def_pointer(func, "root", "ID", "", "ID-block from which path is evaluated from");
        RNA_def_property_flag(parm, PROP_REQUIRED | PROP_RNAPTR);
-       RNA_def_string_translate(func, "text", "", 0, "", "Custom label to display in UI");
+       RNA_def_string_py_translate(func, "text", "", 0, "", "Custom label to display in UI");
        
        func = RNA_def_function(srna, "template_modifier", "uiTemplateModifier");
        RNA_def_function_flag(func, FUNC_USE_CONTEXT);
index f416d3403add77efa2d702f1172f1b07f290eb9e..c0fb2a7238fe76cb8a3e4fa212edfc3600a6967a 100644 (file)
@@ -1330,9 +1330,6 @@ static void rna_def_operator(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_REGISTER | PROP_NEVER_CLAMP);
        RNA_def_struct_name_property(srna, prop);
 
-       /* operator's label indeed doesn't need PROP_TRANSLATE flag: translation of label happens in runtime
-        * when drawing panel and having this flag set will make runtime switching of language much more tricky
-        * because label will be stored translated */
        prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "type->name");
        RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
@@ -1397,9 +1394,6 @@ static void rna_def_macro_operator(BlenderRNA *brna)
        RNA_def_property_flag(prop, PROP_REGISTER | PROP_NEVER_CLAMP);
        RNA_def_struct_name_property(srna, prop);
 
-       /* menu's label indeed doesn't need PROP_TRANSLATE flag: translation of label happens in runtime
-        * when drawing panel and having this flag set will make runtime switching of language much more tricky
-        * because label will be stored translated */
        prop = RNA_def_property(srna, "bl_label", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "type->name");
        RNA_def_property_string_maxlength(prop, RNA_DYN_DESCR_MAX); /* else it uses the pointer size! */
index 13cb11d130161721b71851cd574ebe0bebc01939..0f5be095e0fcd272fac1037d74311a5b6dc6eca2 100644 (file)
@@ -87,6 +87,11 @@ void BPY_context_update(struct bContext *C);
 
 void   BPY_id_release(struct ID *id);
 
+/* I18n for addons */
+#ifdef WITH_INTERNATIONAL
+const char *BPY_app_translations_py_pgettext(const char *msgctxt, const char *msgid);
+#endif
+
 #ifdef __cplusplus
 }                              /* extern "C" */
 #endif
index 575185ece2d4e310e01d7a89fccb185eac7704e2..b531e08f8d4585d303938f4cfe7a8804b6cfd0f3 100644 (file)
@@ -49,6 +49,7 @@ set(SRC
        bpy_app_ffmpeg.c
        bpy_app_build_options.c
        bpy_app_handlers.c
+       bpy_app_translations.c
        bpy_driver.c
        bpy_interface.c
        bpy_interface_atexit.c
@@ -72,6 +73,7 @@ set(SRC
        bpy_app_ffmpeg.h
        bpy_app_build_options.h
        bpy_app_handlers.h
+       bpy_app_translations.h
        bpy_driver.h
        bpy_intern_string.h
        bpy_library.h
index 3e2353c357183c12cb376e7db4d44ed891361348..9ffee3ec1f5e24691879700929738c922c3b1728 100644 (file)
 #include "bpy_app_ffmpeg.h"
 #include "bpy_app_build_options.h"
 
+#ifdef WITH_INTERNATIONAL
+#  include "bpy_app_translations.h"
+#endif
+
 #include "bpy_app_handlers.h"
 #include "bpy_driver.h"
 
@@ -86,7 +90,10 @@ static PyStructSequence_Field app_info_fields[] = {
        {(char *)"ffmpeg", (char *)"FFmpeg library information backend"},
        {(char *)"build_options", (char *)"A set containing most important enabled optional build features"},
        {(char *)"handlers", (char *)"Application handler callbacks"},
-       {NULL}
+#ifdef WITH_INTERNATIONAL
+       {(char *)"translations", (char *)"Application and addons internationalization API"},
+#endif
+       {NULL},
 };
 
 static PyStructSequence_Desc app_info_desc = {
@@ -152,6 +159,9 @@ static PyObject *make_app_info(void)
        SetObjItem(BPY_app_ffmpeg_struct());
        SetObjItem(BPY_app_build_options_struct());
        SetObjItem(BPY_app_handlers_struct());
+#ifdef WITH_INTERNATIONAL
+       SetObjItem(BPY_app_translations_struct());
+#endif
 
 #undef SetIntItem
 #undef SetStrItem
index 0036b377d3c279cbef0c7c85cd7a46ae68eb8e40..6db0a52bdf0b7c499215f35cb745c25bcb1e5ba4 100644 (file)
@@ -32,7 +32,7 @@
 static PyTypeObject BlenderAppBuildOptionsType;
 
 static PyStructSequence_Field app_builtopts_info_fields[] = {
-       /* names mostly follow CMake options, lowecases, after WITH_ */
+       /* names mostly follow CMake options, lowercase, after WITH_ */
        {(char *)"bullet", NULL},
        {(char *)"codec_avi", NULL},
        {(char *)"codec_ffmpeg", NULL},
@@ -71,7 +71,7 @@ static PyStructSequence_Field app_builtopts_info_fields[] = {
 
 static PyStructSequence_Desc app_builtopts_info_desc = {
        (char *)"bpy.app.build_options",     /* name */
-       (char *)"This module contains information about FFmpeg blender is linked against",    /* doc */
+       (char *)"This module contains information about options blender is built with",    /* doc */
        app_builtopts_info_fields,    /* fields */
        (sizeof(app_builtopts_info_fields) / sizeof(PyStructSequence_Field)) - 1
 };
diff --git a/source/blender/python/intern/bpy_app_translations.c b/source/blender/python/intern/bpy_app_translations.c
new file mode 100644 (file)
index 0000000..b501ed2
--- /dev/null
@@ -0,0 +1,638 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Bastien Montagne
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/python/intern/bpy_app_translations.c
+ *  \ingroup pythonintern
+ *
+ * This file defines a singleton py object accessed via 'bpy.app.translations',
+ * which exposes various data and functions useful in i18n work.
+ * Most notably, it allows to extend main translations with py dicts.
+ */
+
+#include <Python.h>
+/* XXX Why bloody hell isn't that included in Python.h???? */
+#include <structmember.h>
+
+/* Need this one before BPY_extern.h, for bool def! */
+#include "BLI_utildefines.h"
+
+#include "BPY_extern.h"
+#include "bpy_app_translations.h"
+
+#ifdef WITH_INTERNATIONAL
+
+#include "MEM_guardedalloc.h"
+
+#include "BLI_string.h"
+#include "BLI_ghash.h"
+
+#include "BLF_translation.h"
+
+#include "RNA_types.h"
+#include "RNA_access.h"
+
+
+typedef struct
+{
+       PyObject_HEAD
+       /* The string used to separate context from actual message in PY_TRANSLATE RNA props. */
+       const char *context_separator;
+       /* A "named tuple" (StructSequence actually...) containing all C-defined contexts. */
+       PyObject *contexts;
+       /* A readonly mapping {C context id: python id}  (actually, a MappingProxy). */
+       PyObject *contexts_C_to_py;
+       /* A py dict containing all registered py dicts (order is more or less random, first match wins!). */
+       PyObject *py_messages;
+} BlenderAppTranslations;
+
+/* Our singleton instance pointer */
+static BlenderAppTranslations *_translations = NULL;
+
+/***** Helpers for ghash *****/
+typedef struct GHashKey {
+       const char *msgctxt;
+       const char *msgid;
+} GHashKey;
+
+static GHashKey *_ghashutil_keyalloc(const void *msgctxt, const void *msgid)
+{
+       GHashKey *key = MEM_mallocN(sizeof(GHashKey), "GHashPair");
+       key->msgctxt = BLI_strdup(msgctxt);
+       key->msgid = BLI_strdup(msgid);
+       return key;
+}
+
+static unsigned int _ghashutil_keyhash(const void *ptr)
+{
+       const GHashKey *key = ptr;
+       unsigned int hash =  BLI_ghashutil_strhash(key->msgctxt);
+       return hash ^ BLI_ghashutil_strhash(key->msgid);
+}
+
+static int _ghashutil_keycmp(const void *a, const void *b)
+{
+       const GHashKey *A = a;
+       const GHashKey *B = b;
+
+       /* Note: comparing msgid first, most of the time it will be enough! */
+       int cmp = BLI_ghashutil_strcmp(A->msgid, B->msgid);
+       if (cmp == 0)
+               return BLI_ghashutil_strcmp(A->msgctxt, B->msgctxt);
+       return cmp;
+}
+
+static void _ghashutil_keyfree(void *ptr)
+{
+       const GHashKey *key = ptr;
+
+       /* We assume both msgctxt and msgid were BLI_strdup'ed! */
+       MEM_freeN((void *)key->msgctxt);
+       MEM_freeN((void *)key->msgid);
+       MEM_freeN((void *)key);
+}
+
+static void _ghashutil_valfree(void *ptr)
+{
+       MEM_freeN(ptr);
+}
+
+/***** Python's messages cache *****/
+
+/* We cache all messages available for a given locale from all py dicts into a single ghash.
+ * Changing of locale is not so common, while looking for a message translation is, so let's try to optimize
+ * the later as much as we can!
+ * Note changing of locale, as well as (un)registering a message dict, invalidate that cache.
+ */
+static GHash *_translations_cache = NULL;
+
+static void _clear_translations_cache(void)
+{
+       if (_translations_cache) {
+               BLI_ghash_free(_translations_cache, _ghashutil_keyfree, _ghashutil_valfree);
+       }
+       _translations_cache = NULL;
+}
+
+static void _build_translations_cache(PyObject *py_messages, const char *locale)
+{
+       PyObject *uuid_dict;
+       Py_ssize_t pos = 0;
+       char *language = NULL, *language_country = NULL, *language_variant = NULL;
+
+       /* For each py dict, we'll search for full locale, then language+country, then language+variant,
+        * then only language keys... */
+       BLF_locale_explode(locale, &language, NULL, NULL, &language_country, &language_variant);
+
+       /* Clear the cached ghash if needed, and create a new one. */
+       _clear_translations_cache();
+       _translations_cache = BLI_ghash_new(_ghashutil_keyhash, _ghashutil_keycmp, __func__);
+
+       /* Iterate over all py dicts. */
+       while(PyDict_Next(py_messages, &pos, NULL, &uuid_dict)) {
+               PyObject *lang_dict;
+
+#if 0
+               PyObject_Print(uuid_dict, stdout, 0);
+               printf("\n");
+#endif
+
+               if (!PyDict_Check(uuid_dict))
+                       continue;
+
+               /* Try to get first complete locale, then language+country, then language+variant, then only language */
+               lang_dict = PyDict_GetItemString(uuid_dict, locale);
+               if (!lang_dict && language_country)
+                       lang_dict = PyDict_GetItemString(uuid_dict, language_country);
+               if (!lang_dict && language_variant)
+                       lang_dict = PyDict_GetItemString(uuid_dict, language_variant);
+               if (!lang_dict && language)
+                       lang_dict = PyDict_GetItemString(uuid_dict, language);
+
+               if (lang_dict && PyDict_Check(lang_dict)) {
+                       PyObject *pykey, *trans;
+                       Py_ssize_t ppos = 0;
+
+                       /* Iterate over all translations of the found language dict, and populate our ghash cache. */
+                       while(PyDict_Next(lang_dict, &ppos, &pykey, &trans)) {
+                               GHashKey *key;
+                               PyObject *tmp;
+                               const char *msgctxt = NULL, *msgid = NULL;
+
+                               tmp = PyTuple_GetItem(pykey, 0);
+                               if (tmp && PyUnicode_Check(tmp) && !PyUnicode_READY(tmp)) {
+                                       msgctxt = (const char *)PyUnicode_AsUTF8(tmp);
+                               }
+                               tmp = PyTuple_GetItem(pykey, 1);
+                               if (tmp && PyUnicode_Check(tmp) && !PyUnicode_READY(tmp)) {
+                                       msgid = (const char *)PyUnicode_AsUTF8(tmp);
+                               }
+
+                               if (!(msgctxt && msgid)) {
+                                       continue;
+                               }
+
+                               key = _ghashutil_keyalloc(msgctxt, msgid);
+
+                               /* Do not overwrite existing keys! */
+                               if (BLI_ghash_lookup(_translations_cache, (void *)key)) {
+                                       continue;
+                               }
+
+                               if (trans && PyUnicode_Check(trans) && !PyUnicode_READY(trans)) {
+                                       BLI_ghash_insert(_translations_cache, key, BLI_strdup((const char *)PyUnicode_AsUTF8(trans)));
+                               }
+                       }
+               }
+       }
+
+       /* Clean up! */
+       if (language)
+               MEM_freeN(language);
+       if (language_country)
+               MEM_freeN(language_country);
+       if (language_variant)
+               MEM_freeN(language_variant);
+}
+
+const char *BPY_app_translations_py_pgettext(const char *msgctxt, const char *msgid)
+{
+#define STATIC_LOCALE_SIZE 32  /* Should be more than enough! */
+
+       GHashKey *key;
+       static char locale[STATIC_LOCALE_SIZE] = "";
+       const char *tmp;
+
+       /* Just in case, should never happen! */
+       if (!_translations)
+               return msgid;
+
+       tmp = BLF_lang_get();
+       if (strcmp(tmp, locale) || !_translations_cache) {
+               PyGILState_STATE _py_state;
+
+               BLI_strncpy(locale, tmp, STATIC_LOCALE_SIZE);
+
+               /* Locale changed or cache does not exist, refresh the whole cache! */
+               /* This func may be called from C (i.e. outside of python interpreter 'context'). */
+               _py_state = PyGILState_Ensure();
+
+               _build_translations_cache(_translations->py_messages, locale);
+
+               PyGILState_Release(_py_state);
+       }
+
+       /* And now, simply create the key (context, messageid) and find it in the cached dict! */
+       key = _ghashutil_keyalloc(msgctxt ? msgctxt : BLF_I18NCONTEXT_DEFAULT, msgid);
+
+       tmp = BLI_ghash_lookup(_translations_cache, key);
+
+       if (tmp)
+               return tmp;
+       return msgid;
+
+#undef STATIC_LOCALE_SIZE
+}
+
+PyDoc_STRVAR(app_translations_py_messages_register_doc,
+".. method:: register(module_name, translations_dict)\n"
+"\n"
+"   Registers an addon's UI translations.\n"
+"\n"
+"   :arg module_name: The name identifying the addon.\n"
+"   :type module_name: string\n"
+"   :arg translations_dict: A dictionary built like that:\n"
+"       {locale: {msg_key: msg_translation, ...}, ...}\n"
+"   :type translations_dict: dict\n"
+"\n"
+);
+static PyObject *app_translations_py_messages_register(BlenderAppTranslations *self, PyObject *args, PyObject *kw)
+{
+       static const char *kwlist[] = {"module_name", "translations_dict", NULL};
+       PyObject *module_name, *uuid_dict;
+
+       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!O!:bpy.app.translations.register", (char **)kwlist, &PyUnicode_Type,
+                                        &module_name, &PyDict_Type, &uuid_dict))
+       {
+               return NULL;
+       }
+
+       if (PyDict_Contains(self->py_messages, module_name)) {
+               PyErr_Format(PyExc_ValueError,
+                            "bpy.app.translations.register: translations message cache already contains some data for "
+                            "addon '%s'", (const char *)PyUnicode_1BYTE_DATA(module_name));
+               return NULL;
+       }
+
+       PyDict_SetItem(self->py_messages, module_name, uuid_dict);
+
+       /* Clear cached messages dict! */
+       _clear_translations_cache();
+
+       /* And we are done! */
+       Py_RETURN_NONE;
+}
+
+PyDoc_STRVAR(app_translations_py_messages_unregister_doc,
+".. method:: unregister(module_name)\n"
+"\n"
+"   Unregisters an addon's UI translations.\n"
+"\n"
+"   :arg module_name: The name identifying the addon.\n"
+"   :type module_name: string\n"
+"\n"
+);
+static PyObject *app_translations_py_messages_unregister(BlenderAppTranslations *self, PyObject *args, PyObject *kw)
+{
+       static const char *kwlist[] = {"module_name", NULL};
+       PyObject *module_name;
+
+       if (!PyArg_ParseTupleAndKeywords(args, kw, "O!:bpy.app.translations.unregister", (char **)kwlist, &PyUnicode_Type,
+                                        &module_name))
+       {
+               return NULL;
+       }
+
+       if (PyDict_Contains(self->py_messages, module_name)) {
+               PyDict_DelItem(self->py_messages, module_name);
+               /* Clear cached messages ghash! */
+               _clear_translations_cache();
+       }
+
+       /* And we are done! */
+       Py_RETURN_NONE;
+}
+
+
+/***** C-defined contexts *****/
+
+static PyTypeObject BlenderAppTranslationsContextsType;
+
+static BLF_i18n_contexts_descriptor _contexts[] = BLF_I18NCONTEXTS_DESC;
+
+/* These fields are just empty placeholders, actual values get set in app_translations_struct().
+ * This allows us to avoid many handwriting, and above all, to keep all context definition stuff in BLF_translation.h!
+ */
+static PyStructSequence_Field
+app_translations_contexts_fields[sizeof(_contexts) / sizeof(BLF_i18n_contexts_descriptor)] = {{NULL}};
+
+static PyStructSequence_Desc app_translations_contexts_desc = {
+       (char *)"bpy.app.translations.contexts",     /* name */
+       (char *)"This named tuple contains all pre-defined translation contexts",    /* doc */
+       app_translations_contexts_fields,    /* fields */
+       (sizeof(app_translations_contexts_fields) / sizeof(PyStructSequence_Field)) - 1
+};
+
+static PyObject *app_translations_contexts_make(void)
+{
+       PyObject *translations_contexts;
+       BLF_i18n_contexts_descriptor *ctxt;
+       int pos = 0;
+
+       translations_contexts = PyStructSequence_New(&BlenderAppTranslationsContextsType);
+       if (translations_contexts == NULL) {
+               return NULL;
+       }
+
+#define SetObjString(item) PyStructSequence_SET_ITEM(translations_contexts, pos++, PyUnicode_FromString((item)))
+
+       for (ctxt = _contexts; ctxt->c_id; ctxt++) {
+               SetObjString(ctxt->value);
+       }
+
+#undef SetObjString
+
+       return translations_contexts;
+}
+
+/***** Main BlenderAppTranslations Py object definition *****/
+
+PyDoc_STRVAR(app_translations_contexts_doc,
+       "A named tuple containing all pre-defined translation contexts."
+);
+
+PyDoc_STRVAR(app_translations_contexts_C_to_py_doc,
+       "A readonly dict mapping contexts' C-identifiers to their py-identifiers."
+);
+
+PyMemberDef app_translations_members[] = {
+       {(char *)"contexts", T_OBJECT_EX, offsetof(BlenderAppTranslations, contexts), READONLY,
+                            app_translations_contexts_doc},
+       {(char *)"contexts_C_to_py", T_OBJECT_EX, offsetof(BlenderAppTranslations, contexts_C_to_py), READONLY,
+                                    app_translations_contexts_C_to_py_doc},
+       {NULL}
+};
+
+PyDoc_STRVAR(app_translations_locale_doc, "The actual locale currently in use.");
+static PyObject *app_translations_locale_get(PyObject *UNUSED(self), void *UNUSED(userdata))
+{
+       return PyUnicode_FromString(BLF_lang_get());
+}
+
+/* Note: defining as getter, as (even if quite unlikely), this *may* change during runtime... */
+PyDoc_STRVAR(app_translations_locales_doc, "All locales currently known by Blender (i.e. available as translations).");
+static PyObject *app_translations_locales_get(PyObject *UNUSED(self), void *UNUSED(userdata))
+{
+       PyObject *ret;
+       EnumPropertyItem *it, *items = BLF_RNA_lang_enum_properties();
+       int num_locales = 0, pos = 0;
+
+       /* This is not elegant, but simple! */
+       for (it = items; it->identifier; it++) {
+               if (it->value)
+                       num_locales++;
+       }
+
+       ret = PyTuple_New(num_locales);
+
+#define TupleSetItem() PyTuple_SET_ITEM(ret, pos++, PyUnicode_FromString(it->description))
+
+       for (it = items; it->identifier; it++) {
+               if (it->value)
+                       TupleSetItem();
+       }
+
+#undef TupleSetItem
+
+       return ret;
+}
+
+PyGetSetDef app_translations_getseters[] = {
+       /* {name, getter, setter, doc, userdata} */
+       {(char *)"locale", (getter)app_translations_locale_get, NULL, app_translations_locale_doc, NULL},
+       {(char *)"locales", (getter)app_translations_locales_get, NULL, app_translations_locales_doc, NULL},
+       {NULL}
+};
+
+PyDoc_STRVAR(app_translations_pgettext_doc,
+".. method:: pgettext(msgid, msgctxt)\n"
+"\n"
+"   Try to translate the given msgid (with optional msgctxt).\n"
+"   NOTE: The (msgid, msgctxt) parameter orders has been switched compared to gettext function, to allow\n"
+"         single-parameter calls (context then defaults to BLF_I18NCONTEXT_DEFAULT)."
+"   NOTE: You should really rarely need to use this function in regular addon code, as all translation should be\n"
+"         handled by Blender internal code."
+"\n"
+"   :arg msgid: The string to translate.\n"
+"   :type msgid: string\n"
+"   :arg msgctxt: The translation context.\n"
+"   :type msgctxt: string\n"
+"   :default msgctxt: BLF_I18NCONTEXT_DEFAULT value.\n"
+"   :return: The translated string (or msgid if no translation was found).\n"
+"\n"
+);
+static PyObject *app_translations_pgettext(BlenderAppTranslations *UNUSED(self), PyObject *args, PyObject *kw)
+{
+       static const char *kwlist[] = {"msgid", "msgctxt", NULL};
+       char *msgid, *msgctxt = NULL;
+
+       if (!PyArg_ParseTupleAndKeywords(args, kw, "s|s:bpy.app.translations.pgettext()", (char **)kwlist,
+                                        &msgid, &msgctxt))
+       {
+               return NULL;
+       }
+
+       return PyUnicode_FromString(BLF_pgettext(msgctxt ? msgctxt : BLF_I18NCONTEXT_DEFAULT, msgid));
+}
+
+PyMethodDef app_translations_methods[] = {
+       /* Can't use METH_KEYWORDS alone, see http://bugs.python.org/issue11587 */
+       {(char *)"register", (PyCFunction)app_translations_py_messages_register, METH_VARARGS | METH_KEYWORDS,
+                            app_translations_py_messages_register_doc},
+       {(char *)"unregister", (PyCFunction)app_translations_py_messages_unregister, METH_VARARGS | METH_KEYWORDS,
+                              app_translations_py_messages_unregister_doc},
+       {(char *)"pgettext", (PyCFunction)app_translations_pgettext, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
+                             app_translations_pgettext_doc},
+       {NULL}
+};
+
+static PyObject *app_translations_new(PyTypeObject *type, PyObject *UNUSED(args), PyObject *UNUSED(kw))
+{
+/*     printf("%s (%p)\n", __func__, _translations); */
+
+       if (!_translations) {
+               _translations = (BlenderAppTranslations *)type->tp_alloc(type, 0);
+               if (_translations) {
+                       PyObject *py_ctxts;
+                       BLF_i18n_contexts_descriptor *ctxt;
+
+                       _translations->contexts = app_translations_contexts_make();
+
+                       py_ctxts = PyDict_New();
+                       for (ctxt = _contexts; ctxt->c_id; ctxt++) {
+                               PyObject *val = PyUnicode_FromString(ctxt->py_id);
+                               PyDict_SetItemString(py_ctxts, ctxt->c_id, val);
+                               Py_DECREF(val);
+                       }
+                       _translations->contexts_C_to_py = PyDictProxy_New(py_ctxts);
+                       Py_DECREF(py_ctxts);  /* The actual dict is only owned by its proxy */
+
+                       _translations->py_messages = PyDict_New();
+               }
+       }
+
+       return (PyObject *)_translations;
+}
+
+PyDoc_STRVAR(app_translations_doc,
+"   This object contains some data/methods regarding internationalization in Blender, and allows every py script\n"
+"   to feature translations for its own UI messages.\n"
+"\n"
+"   WARNING: Most of this object should only be useful if you actually manipulate i18n stuff from Python.\n"
+"            If you are a regular addon, you should only bother about :contexts: and :context_sep: members, and the \n"
+"            :register:/:unregister: functions!"
+"\n"
+"   To add translations to your python script, you must define a dictionary formatted like that:\n"
+"       {locale: {msg_key: msg_translation, ...}, ...}\n"
+"       where:\n"
+"           locale is either a lang iso code (e.g. 'fr'), a lang+country code (e.g. 'pt_BR'),\n"
+"                  a lang+variant code (e.g. 'sr@latin'), or a full code (e.g. 'uz_UZ@cyrilic').\n"
+"           msg_key is a tuple (context, org message) - use, as much as possible, the predefined :contexts:.\n"
+"           msg_translation is the translated message in given language!"
+"   Then, call bpy.app.translations.register(__name__, your_dict) in your register() function, and \n"
+"   bpy.app.translations.unregister(__name__) in your unregister() one.\n"
+"\n"
+"   bl_i18n_utils module has several functions to help you collect strings to translate, and generate the needed\n"
+"   python code (the translation dictionary), as well as optional intermediary po files if you want some...\n"
+"   See its documentation for more details.\n"
+"\n"
+);
+static PyTypeObject BlenderAppTranslationsType = {
+       PyVarObject_HEAD_INIT(NULL, 0)
+                                   /* tp_name */
+       (char *)"bpy.app._translations_type",
+                                   /* tp_basicsize */
+       sizeof(BlenderAppTranslations),
+       0,                          /* tp_itemsize */
+       /* methods */
+       /* No destructor, this is a singleton! */
+       NULL,                       /* tp_dealloc */
+       NULL,                       /* printfunc tp_print; */
+       NULL,                       /* getattrfunc tp_getattr; */
+       NULL,                       /* setattrfunc tp_setattr; */
+       NULL,                       /* tp_compare */ /* DEPRECATED in python 3.0! */
+       NULL,                       /* tp_repr */
+
+       /* Method suites for standard classes */
+       NULL,                       /* PyNumberMethods *tp_as_number; */
+       NULL,                       /* PySequenceMethods *tp_as_sequence; */
+       NULL,                       /* PyMappingMethods *tp_as_mapping; */
+
+       /* More standard operations (here for binary compatibility) */
+       NULL,                       /* hashfunc tp_hash; */
+       NULL,                       /* ternaryfunc tp_call; */
+       NULL,                       /* reprfunc tp_str; */
+       NULL,                       /* getattrofunc tp_getattro; */
+       NULL,                       /* setattrofunc tp_setattro; */
+
+       /* Functions to access object as input/output buffer */
+       NULL,                       /* PyBufferProcs *tp_as_buffer; */
+
+       /*** Flags to define presence of optional/expanded features ***/
+       Py_TPFLAGS_DEFAULT,         /* long tp_flags; */
+
+       app_translations_doc,       /* char *tp_doc;  Documentation string */
+
+       /*** Assigned meaning in release 2.0 ***/
+       /* call function for all accessible objects */
+       NULL,                       /* traverseproc tp_traverse; */
+
+       /* delete references to contained objects */
+       NULL,                       /* inquiry tp_clear; */
+
+       /***  Assigned meaning in release 2.1 ***/
+       /*** rich comparisons ***/
+       NULL,                       /* richcmpfunc tp_richcompare; */
+
+       /***  weak reference enabler ***/
+       0,                          /* long tp_weaklistoffset */
+
+       /*** Added in release 2.2 ***/
+       /*   Iterators */
+       NULL,                       /* getiterfunc tp_iter; */
+       NULL,                       /* iternextfunc tp_iternext; */
+
+       /*** Attribute descriptor and subclassing stuff ***/
+       app_translations_methods,   /* struct PyMethodDef *tp_methods; */
+       app_translations_members,   /* struct PyMemberDef *tp_members; */
+       app_translations_getseters, /* struct PyGetSetDef *tp_getset; */
+       NULL,                       /* struct _typeobject *tp_base; */
+       NULL,                       /* PyObject *tp_dict; */
+       NULL,                       /* descrgetfunc tp_descr_get; */
+       NULL,                       /* descrsetfunc tp_descr_set; */
+       0,                          /* long tp_dictoffset; */
+       NULL,                       /* initproc tp_init; */
+       NULL,                       /* allocfunc tp_alloc; */
+                                   /* newfunc tp_new; */
+       (newfunc)app_translations_new,
+       /*  Low-level free-memory routine */
+       NULL,                       /* freefunc tp_free;  */
+       /* For PyObject_IS_GC */
+       NULL,                       /* inquiry tp_is_gc;  */
+       NULL,                       /* PyObject *tp_bases; */
+       /* method resolution order */
+       NULL,                       /* PyObject *tp_mro;  */
+       NULL,                       /* PyObject *tp_cache; */
+       NULL,                       /* PyObject *tp_subclasses; */
+       NULL,                       /* PyObject *tp_weaklist; */
+       NULL
+};
+
+PyObject *BPY_app_translations_struct(void)
+{
+       PyObject *ret;
+
+       /* Let's finalize our contexts structseq definition! */
+       {
+               BLF_i18n_contexts_descriptor *ctxt;
+               PyStructSequence_Field *desc;
+
+               /* We really populate the contexts' fields here! */
+               for (ctxt = _contexts, desc = app_translations_contexts_desc.fields; ctxt->c_id; ctxt++, desc++) {
+                       desc->name = (char *)ctxt->py_id;
+                       desc->doc = NULL;
+               }
+               desc->name = desc->doc = NULL;  /* End sentinel! */
+
+               PyStructSequence_InitType(&BlenderAppTranslationsContextsType, &app_translations_contexts_desc);
+       }
+
+       if (PyType_Ready(&BlenderAppTranslationsType) < 0)
+               return NULL;
+
+       ret = PyObject_CallObject((PyObject *)&BlenderAppTranslationsType, NULL);
+
+       /* prevent user from creating new instances */
+       BlenderAppTranslationsType.tp_new = NULL;
+       /* without this we can't do set(sys.modules) [#29635] */
+       BlenderAppTranslationsType.tp_hash = (hashfunc)_Py_HashPointer;
+
+       return ret;
+}
+
+#else  /* WITH_INTERNATIONAL */
+
+PyObject *BPY_app_translations_struct(void)
+{
+       Py_RETURN_NONE;
+}
+
+#endif  /* WITH_INTERNATIONAL */
diff --git a/source/blender/python/intern/bpy_app_translations.h b/source/blender/python/intern/bpy_app_translations.h
new file mode 100644 (file)
index 0000000..7043075
--- /dev/null
@@ -0,0 +1,32 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * Contributor(s): Bastien Montagne
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/python/intern/bpy_app_translations.h
+ *  \ingroup pythonintern
+ */
+
+#ifndef __BPY_APP_TRANSLATIONS_H__
+#define __BPY_APP_TRANSLATIONS_H__
+
+PyObject *BPY_app_translations_struct(void);
+
+#endif /* __BPY_APP_TRANSLATIONS_H__ */
index f3fa0c9a0a96a5a8a9e649a06e11f5e3597aacf9..f5033a97861823add7f301a461319c21dace1398 100644 (file)
@@ -74,13 +74,15 @@ static EnumPropertyItem property_flag_enum_items[] = {
        {0, NULL, 0, NULL, NULL}};
 
 /* subtypes */
+/* XXX Keep in sync with rna_rna.c's property_subtype_items ???
+ *     Currently it is not...
+ */
 static EnumPropertyItem property_subtype_string_items[] = {
        {PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
        {PROP_DIRPATH, "DIR_PATH", 0, "Directory Path", ""},
        {PROP_FILENAME, "FILE_NAME", 0, "Filename", ""},
        {PROP_BYTESTRING, "BYTE_STRING", 0, "Byte String", ""},
-       {PROP_TRANSLATE, "TRANSLATE", 0, "Translate", ""},
-       {PROP_PASSWORD, "PASSWORD", 0, "Password", 0},
+       {PROP_PASSWORD, "PASSWORD", 0, "Password", "A string that is displayed hidden ('********')"},
 
        {PROP_NONE, "NONE", 0, "None", ""},
        {0, NULL, 0, NULL, NULL}};
index 94f262f57f5738ebd6caa616fc47659f7f7684cc..611095bfe20afcfd5f1b7c8b4def501670f2a450 100644 (file)
@@ -1623,8 +1623,12 @@ static int pyrna_py_to_prop(PointerRNA *ptr, PropertyRNA *prop, void *data, PyOb
                                        }
                                }
                                else {
-
                                        /* Unicode String */
+#ifdef WITH_INTERNATIONAL
+                                       bool do_translate = RNA_property_flag(prop) & PROP_STRING_PY_TRANSLATE;
+#else
+                                       bool do_translate = false;
+#endif  /* WITH_INTERNATIONAL */
 
 #ifdef USE_STRING_COERCE
                                        PyObject *value_coerce = NULL;
@@ -1634,17 +1638,16 @@ static int pyrna_py_to_prop(PointerRNA *ptr, PropertyRNA *prop, void *data, PyOb
                                        }
                                        else {
                                                param = _PyUnicode_AsString(value);
-#ifdef WITH_INTERNATIONAL
-                                               if (subtype == PROP_TRANSLATE) {
-                                                       param = IFACE_(param);
-                                               }
-#endif  /* WITH_INTERNATIONAL */
-
                                        }
 #else  /* USE_STRING_COERCE */
                                        param = _PyUnicode_AsString(value);
 #endif  /* USE_STRING_COERCE */
 
+                                       /* Any half-brained compiler should be able to optimize this out when WITH_INTERNATIONAL is off */
+                                       if (do_translate) {
+                                               param = IFACE_(param);
+                                       }
+
                                        if (param == NULL) {
                                                if (PyUnicode_Check(value)) {
                                                        /* there was an error assigning a string type,