archive/blender-archive
Archived
1
1
Fork 0
Code Pull Requests Packages Activity

Merged changes in the trunk up to revision 54110.

Browse Source 
Conflicts resolved:
source/blender/blenfont/SConscript
source/blender/blenkernel/intern/subsurf_ccg.c
source/blender/makesdna/intern/makesdna.c
source/blender/makesrna/intern/rna_scene.c
This commit is contained in:
Tamito Kajiyama
2013-01-26 23:49:13 +00:00
parent 9251d628db c84383301c
commit 556912792a
748 changed files with 31619 additions and 23270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
source/blender/python/BPY_extern.h
View 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

6
source/blender/python/bmesh/bmesh_py_api.c
View File

@@ -115,8 +115,8 @@ static PyObject *bpy_bm_update_edit_mesh(PyObject *UNUSED(self), PyObject *args,
static const char *kwlist[] = {"mesh", "tessface", "destructive", NULL};
PyObject *py_me;
Mesh *me;
int do_tessface = TRUE;
int is_destructive = TRUE;
int do_tessface = true;
int is_destructive = true;
if (!PyArg_ParseTupleAndKeywords(args, kw, "O|ii:update_edit_mesh", (char **)kwlist,
&py_me, &do_tessface, &is_destructive))
@@ -137,7 +137,7 @@ static PyObject *bpy_bm_update_edit_mesh(PyObject *UNUSED(self), PyObject *args,
}
{
extern void EDBM_update_generic(BMEditMesh *em, const short do_tessface, const short is_destructive);
extern void EDBM_update_generic(BMEditMesh *em, const bool do_tessface, const bool is_destructive);
EDBM_update_generic(me->edit_btmesh, do_tessface, is_destructive);
}

4
source/blender/python/bmesh/bmesh_py_ops_call.c
View File

@@ -214,7 +214,7 @@ static int bpy_slot_from_py(BMesh *bm, BMOperator *bmop, BMOpSlot *slot, PyObjec
return -1;
}
else if (((size = ((MatrixObject *)value)->num_col) != ((MatrixObject *)value)->num_row) ||
(ELEM(size, 3, 4) == FALSE))
(ELEM(size, 3, 4) == false))
{
PyErr_Format(PyExc_TypeError,
"%.200s: keyword \"%.200s\" expected a 3x3 or 4x4 matrix Matrix",
@@ -319,7 +319,7 @@ static int bpy_slot_from_py(BMesh *bm, BMOperator *bmop, BMOpSlot *slot, PyObjec
elem_array = BPy_BMElem_PySeq_As_Array(&bm, value, 0, PY_SSIZE_T_MAX,
&elem_array_len, (slot->slot_subtype.elem & BM_ALL_NOLOOP),
TRUE, TRUE, slot_name);
true, true, slot_name);
/* error is set above */
if (elem_array == NULL) {

66
source/blender/python/bmesh/bmesh_py_types.c
View File

@@ -127,11 +127,11 @@ static int bpy_bm_elem_hflag_set(BPy_BMElem *self, PyObject *value, void *flag)
param = PyLong_AsLong(value);
if (param == TRUE) {
if (param == true) {
BM_elem_flag_enable(self->ele, hflag);
return 0;
}
else if (param == FALSE) {
else if (param == false) {
BM_elem_flag_disable(self->ele, hflag);
return 0;
}
@@ -869,7 +869,7 @@ static PyObject *bpy_bmesh_to_mesh(BPy_BMesh *self, PyObject *args)
bm = self->bm;
BM_mesh_bm_to_me(bm, me, FALSE);
BM_mesh_bm_to_me(bm, me, false);
/* we could have the user do this but if they forget blender can easy crash
* since the references arrays for the objects derived meshes are now invalid */
@@ -899,9 +899,9 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args)
Object *ob;
struct Scene *scene;
BMesh *bm;
int use_deform = TRUE;
int use_render = FALSE;
int use_cage = FALSE;
int use_deform = true;
int use_render = false;
int use_cage = false;
DerivedMesh *dm;
const int mask = CD_MASK_BMESH;
@@ -999,7 +999,7 @@ static PyObject *bpy_bmesh_from_mesh(BPy_BMesh *self, PyObject *args, PyObject *
BMesh *bm;
PyObject *py_mesh;
Mesh *me;
int use_shape_key = FALSE;
int use_shape_key = false;
int shape_key_index = 0;
if (!PyArg_ParseTupleAndKeywords(args, kw, "O|ii:from_mesh", (char **)kwlist,
@@ -1047,7 +1047,7 @@ static PyObject *bpy_bmesh_select_flush(BPy_BMesh *self, PyObject *value)
BPY_BM_CHECK_OBJ(self);
param = PyLong_AsLong(value);
if (param != FALSE && param != TRUE) {
if (param != false && param != true) {
PyErr_SetString(PyExc_TypeError,
"expected a boolean type 0/1");
return NULL;
@@ -1071,7 +1071,7 @@ PyDoc_STRVAR(bpy_bmesh_normal_update_doc,
static PyObject *bpy_bmesh_normal_update(BPy_BMesh *self, PyObject *args)
{
int skip_hidden = FALSE;
int skip_hidden = false;
BPY_BM_CHECK_OBJ(self);
@@ -1178,7 +1178,7 @@ static PyObject *bpy_bm_elem_select_set(BPy_BMElem *self, PyObject *value)
BPY_BM_CHECK_OBJ(self);
param = PyLong_AsLong(value);
if (param != FALSE && param != TRUE) {
if (param != false && param != true) {
PyErr_SetString(PyExc_TypeError,
"expected a boolean type 0/1");
return NULL;
@@ -1206,7 +1206,7 @@ static PyObject *bpy_bm_elem_hide_set(BPy_BMElem *self, PyObject *value)
BPY_BM_CHECK_OBJ(self);
param = PyLong_AsLong(value);
if (param != FALSE && param != TRUE) {
if (param != false && param != true) {
PyErr_SetString(PyExc_TypeError,
"expected a boolean type 0/1");
return NULL;
@@ -1273,7 +1273,7 @@ static PyObject *bpy_bmvert_copy_from_vert_interp(BPy_BMVert *self, PyObject *ar
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 2, 2,
&vert_seq_len, BM_VERT,
TRUE, TRUE, "BMVert.copy_from_vert_interp(...)");
true, true, "BMVert.copy_from_vert_interp(...)");
if (vert_array == NULL) {
return NULL;
@@ -1523,8 +1523,8 @@ static PyObject *bpy_bmface_copy(BPy_BMFace *self, PyObject *args, PyObject *kw)
static const char *kwlist[] = {"verts", "edges", NULL};
BMesh *bm = self->bm;
int do_verts = TRUE;
int do_edges = TRUE;
int do_verts = true;
int do_edges = true;
BMFace *f_cpy;
BPY_BM_CHECK_OBJ(self);
@@ -1664,8 +1664,8 @@ PyDoc_STRVAR(bpy_bmloop_copy_from_face_interp_doc,
static PyObject *bpy_bmloop_copy_from_face_interp(BPy_BMLoop *self, PyObject *args)
{
BPy_BMFace *py_face = NULL;
int do_vertex = TRUE;
int do_multires = TRUE;
int do_vertex = true;
int do_multires = true;
BPY_BM_CHECK_OBJ(self);
@@ -1833,7 +1833,7 @@ static PyObject *bpy_bmedgeseq_new(BPy_BMElemSeq *self, PyObject *args)
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 2, 2,
&vert_seq_len, BM_VERT,
TRUE, TRUE, "edges.new(...)");
true, true, "edges.new(...)");
if (vert_array == NULL) {
return NULL;
@@ -1911,7 +1911,7 @@ static PyObject *bpy_bmfaceseq_new(BPy_BMElemSeq *self, PyObject *args)
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 3, PY_SSIZE_T_MAX,
&vert_seq_len, BM_VERT,
TRUE, TRUE, "faces.new(...)");
true, true, "faces.new(...)");
if (vert_array == NULL) {
return NULL;
@@ -2064,7 +2064,7 @@ static PyObject *bpy_bmedgeseq_get__method(BPy_BMElemSeq *self, PyObject *args)
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 2, 2,
&vert_seq_len, BM_VERT,
TRUE, TRUE, "edges.get(...)");
true, true, "edges.get(...)");
if (vert_array == NULL) {
return NULL;
@@ -2116,7 +2116,7 @@ static PyObject *bpy_bmfaceseq_get__method(BPy_BMElemSeq *self, PyObject *args)
vert_array = BPy_BMElem_PySeq_As_Array(&bm, vert_seq, 1, PY_SSIZE_T_MAX,
&vert_seq_len, BM_VERT,
TRUE, TRUE, "faces.get(...)");
true, true, "faces.get(...)");
if (vert_array == NULL) {
return NULL;
@@ -2243,7 +2243,7 @@ static PyObject *bpy_bmelemseq_sort(BPy_BMElemSeq *self, PyObject *args, PyObjec
{
static const char *kwlist[] = {"key", "reverse", NULL};
PyObject *keyfunc = NULL; /* optional */
int reverse = FALSE; /* optional */
int do_reverse = false; /* optional */
const char htype = bm_iter_itype_htype_map[self->itype];
int n_elem;
@@ -2268,7 +2268,7 @@ static PyObject *bpy_bmelemseq_sort(BPy_BMElemSeq *self, PyObject *args, PyObjec
if (!PyArg_ParseTupleAndKeywords(args, kw,
"|Oi:BMElemSeq.sort",
(char **)kwlist,
&keyfunc, &reverse))
&keyfunc, &do_reverse))
{
return NULL;
}
@@ -2338,7 +2338,7 @@ static PyObject *bpy_bmelemseq_sort(BPy_BMElemSeq *self, PyObject *args, PyObjec
range_vn_i(elem_idx, n_elem, 0);
/* Sort the index array according to the order of the 'keys' array */
if (reverse)
if (do_reverse)
elem_idx_compare_by_keys = bpy_bmelemseq_sort_cmp_by_keys_descending;
else
elem_idx_compare_by_keys = bpy_bmelemseq_sort_cmp_by_keys_ascending;
@@ -2616,7 +2616,7 @@ static PyObject *bpy_bmelemseq_subscript_slice(BPy_BMElemSeq *self, Py_ssize_t s
{
BMIter iter;
int count = 0;
int ok;
bool ok;
PyObject *list;
PyObject *item;
@@ -2628,14 +2628,14 @@ static PyObject *bpy_bmelemseq_subscript_slice(BPy_BMElemSeq *self, Py_ssize_t s
ok = BM_iter_init(&iter, self->bm, self->itype, self->py_ele ? self->py_ele->ele : NULL);
BLI_assert(ok == TRUE);
BLI_assert(ok == true);
if (UNLIKELY(ok == FALSE)) {
if (UNLIKELY(ok == false)) {
return list;
}
/* first loop up-until the start */
for (ok = TRUE; ok; ok = (BM_iter_step(&iter) != NULL)) {
for (ok = true; ok; ok = (BM_iter_step(&iter) != NULL)) {
if (count == start) {
break;
}
@@ -3434,7 +3434,7 @@ int bpy_bm_generic_valid_check(BPy_BMGeneric *self)
* function where the actual error will be caused by
* the previous action. */
#if 0
if (BM_mesh_validate(self->bm) == FALSE) {
if (BM_mesh_validate(self->bm) == false) {
PyErr_Format(PyExc_ReferenceError,
"BMesh used by %.200s has become invalid",
Py_TYPE(self)->tp_name);
@@ -3479,7 +3479,7 @@ void bpy_bm_generic_invalidate(BPy_BMGeneric *self)
*/
void *BPy_BMElem_PySeq_As_Array(BMesh **r_bm, PyObject *seq, Py_ssize_t min, Py_ssize_t max, Py_ssize_t *r_size,
const char htype,
const char do_unique_check, const char do_bm_check,
const bool do_unique_check, const bool do_bm_check,
const char *error_prefix)
{
BMesh *bm = (r_bm && *r_bm) ? *r_bm : NULL;
@@ -3546,17 +3546,17 @@ void *BPy_BMElem_PySeq_As_Array(BMesh **r_bm, PyObject *seq, Py_ssize_t min, Py_
if (do_unique_check) {
/* check for double verts! */
int ok = TRUE;
bool ok = true;
for (i = 0; i < seq_len; i++) {
if (UNLIKELY(BM_elem_flag_test(alloc[i], BM_ELEM_INTERNAL_TAG) == FALSE)) {
ok = FALSE;
if (UNLIKELY(BM_elem_flag_test(alloc[i], BM_ELEM_INTERNAL_TAG) == false)) {
ok = false;
}
/* ensure we don't leave this enabled */
BM_elem_flag_disable(alloc[i], BM_ELEM_INTERNAL_TAG);
}
if (ok == FALSE) {
if (ok == false) {
PyErr_Format(PyExc_ValueError,
"%s: found the same %.200s used multiple times",
error_prefix, BPy_BMElem_StringFromHType(htype));

2
source/blender/python/bmesh/bmesh_py_types.h
View File

@@ -160,7 +160,7 @@ PyObject *BPy_BMElem_CreatePyObject(BMesh *bm, BMHeader *ele); /* just checks ty
void *BPy_BMElem_PySeq_As_Array(BMesh **r_bm, PyObject *seq, Py_ssize_t min, Py_ssize_t max, Py_ssize_t *r_size,
const char htype,
const char do_unique_check, const char do_bm_check,
const bool do_unique_check, const bool do_bm_check,
const char *error_prefix);
PyObject *BPy_BMElem_Array_As_Tuple(BMesh *bm, BMHeader **elem, Py_ssize_t elem_len);

4
source/blender/python/bmesh/bmesh_py_types_meshdata.c
View File

@@ -187,10 +187,10 @@ static int bpy_bmloopuv_flag_set(BPy_BMLoopUV *self, PyObject *value, void *flag
const int flag = GET_INT_FROM_POINTER(flag_p);
switch (PyLong_AsLong(value)) {
case TRUE:
case true:
self->data->flag |= flag;
return 0;
case FALSE:
case false:
self->data->flag &= ~flag;
return 0;
default:

14
source/blender/python/bmesh/bmesh_py_types_select.c
View File

@@ -107,7 +107,7 @@ static PyObject *bpy_bmeditselseq_add(BPy_BMEditSelSeq *self, BPy_BMElem *value)
if ((BPy_BMVert_Check(value) ||
BPy_BMEdge_Check(value) ||
BPy_BMFace_Check(value)) == FALSE)
BPy_BMFace_Check(value)) == false)
{
PyErr_Format(PyExc_TypeError,
"Expected a BMVert/BMedge/BMFace not a %.200s", Py_TYPE(value)->tp_name);
@@ -132,7 +132,7 @@ static PyObject *bpy_bmeditselseq_remove(BPy_BMEditSelSeq *self, BPy_BMElem *val
if ((BPy_BMVert_Check(value) ||
BPy_BMEdge_Check(value) ||
BPy_BMFace_Check(value)) == FALSE)
BPy_BMFace_Check(value)) == false)
{
PyErr_Format(PyExc_TypeError,
"Expected a BMVert/BMedge/BMFace not a %.200s", Py_TYPE(value)->tp_name);
@@ -141,7 +141,7 @@ static PyObject *bpy_bmeditselseq_remove(BPy_BMEditSelSeq *self, BPy_BMElem *val
BPY_BM_CHECK_SOURCE_OBJ(value, self->bm, "select_history.remove()");
if (BM_select_history_remove(self->bm, value->ele) == FALSE) {
if (BM_select_history_remove(self->bm, value->ele) == false) {
PyErr_SetString(PyExc_ValueError,
"Element not found in selection history");
return NULL;
@@ -196,7 +196,7 @@ static PyObject *bpy_bmeditselseq_subscript_int(BPy_BMEditSelSeq *self, int keyn
static PyObject *bpy_bmeditselseq_subscript_slice(BPy_BMEditSelSeq *self, Py_ssize_t start, Py_ssize_t stop)
{
int count = 0;
int ok;
bool ok;
PyObject *list;
PyObject *item;
@@ -210,12 +210,12 @@ static PyObject *bpy_bmeditselseq_subscript_slice(BPy_BMEditSelSeq *self, Py_ssi
ok = (ese != NULL);
if (UNLIKELY(ok == FALSE)) {
if (UNLIKELY(ok == false)) {
return list;
}
/* first loop up-until the start */
for (ok = TRUE; ok; ok = ((ese = ese->next) != NULL)) {
for (ok = true; ok; ok = ((ese = ese->next) != NULL)) {
if (count == start) {
break;
}
@@ -429,7 +429,7 @@ int BPy_BMEditSel_Assign(BPy_BMesh *self, PyObject *value)
value_array = BPy_BMElem_PySeq_As_Array(&bm, value, 0, PY_SSIZE_T_MAX,
&value_len, BM_VERT | BM_EDGE | BM_FACE,
TRUE, TRUE, "BMesh.select_history = value");
true, true, "BMesh.select_history = value");
if (value_array == NULL) {
return -1;

18
source/blender/python/bmesh/bmesh_py_utils.c
View File

@@ -90,7 +90,7 @@ static PyObject *bpy_bm_utils_vert_collapse_edge(PyObject *UNUSED(self), PyObjec
bm = py_edge->bm;
e_new = BM_vert_collapse_edge(bm, py_edge->e, py_vert->v, TRUE);
e_new = BM_vert_collapse_edge(bm, py_edge->e, py_vert->v, true);
if (e_new) {
return BPy_BMEdge_CreatePyObject(bm, e_new);
@@ -156,7 +156,7 @@ static PyObject *bpy_bm_utils_vert_collapse_faces(PyObject *UNUSED(self), PyObje
bm = py_edge->bm;
e_new = BM_vert_collapse_faces(bm, py_edge->e, py_vert->v, CLAMPIS(fac, 0.0f, 1.0f), do_join_faces, TRUE);
e_new = BM_vert_collapse_faces(bm, py_edge->e, py_vert->v, CLAMPIS(fac, 0.0f, 1.0f), do_join_faces, true);
if (e_new) {
return BPy_BMEdge_CreatePyObject(bm, e_new);
@@ -239,7 +239,7 @@ static PyObject *bpy_bm_utils_vert_separate(PyObject *UNUSED(self), PyObject *ar
edge_array = BPy_BMElem_PySeq_As_Array(&bm, edge_seq, 0, PY_SSIZE_T_MAX,
&edge_array_len, BM_EDGE,
TRUE, TRUE, "vert_separate(...)");
true, true, "vert_separate(...)");
if (edge_array == NULL) {
return NULL;
@@ -338,7 +338,7 @@ PyDoc_STRVAR(bpy_bm_utils_edge_rotate_doc,
static PyObject *bpy_bm_utils_edge_rotate(PyObject *UNUSED(self), PyObject *args)
{
BPy_BMEdge *py_edge;
int do_ccw = FALSE;
int do_ccw = false;
BMesh *bm;
BMEdge *e_new = NULL;
@@ -396,7 +396,7 @@ static PyObject *bpy_bm_utils_face_split(PyObject *UNUSED(self), PyObject *args,
/* optional */
PyObject *py_coords = NULL;
int edge_exists = TRUE;
int edge_exists = true;
BPy_BMEdge *py_edge_example = NULL;
float *coords;
@@ -426,8 +426,8 @@ static PyObject *bpy_bm_utils_face_split(PyObject *UNUSED(self), PyObject *args,
}
/* this doubles for checking that the verts are in the same mesh */
if (BM_vert_in_face(py_face->f, py_vert_a->v) == FALSE ||
BM_vert_in_face(py_face->f, py_vert_b->v) == FALSE)
if (BM_vert_in_face(py_face->f, py_vert_a->v) == false ||
BM_vert_in_face(py_face->f, py_vert_b->v) == false)
{
PyErr_SetString(PyExc_ValueError,
"face_split(...): one of the verts passed is not found in the face");
@@ -496,7 +496,7 @@ static PyObject *bpy_bm_utils_face_join(PyObject *UNUSED(self), PyObject *args)
BMFace **face_array;
Py_ssize_t face_seq_len = 0;
BMFace *f_new;
int do_remove = TRUE;
int do_remove = true;
if (!PyArg_ParseTuple(args, "O|i:face_join", &py_face_array, &do_remove)) {
return NULL;
@@ -504,7 +504,7 @@ static PyObject *bpy_bm_utils_face_join(PyObject *UNUSED(self), PyObject *args)
face_array = BPy_BMElem_PySeq_As_Array(&bm, py_face_array, 2, PY_SSIZE_T_MAX,
&face_seq_len, BM_FACE,
TRUE, TRUE, "face_join(...)");
true, true, "face_join(...)");
if (face_array == NULL) {
return NULL; /* error will be set */

2
source/blender/python/intern/CMakeLists.txt
View 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

6
source/blender/python/intern/bpy_app.c
View File

@@ -36,6 +36,8 @@
#include "bpy_app_ffmpeg.h"
#include "bpy_app_build_options.h"
#include "bpy_app_translations.h"
#include "bpy_app_handlers.h"
#include "bpy_driver.h"
@@ -86,7 +88,8 @@ 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}
{(char *)"translations", (char *)"Application and addons internationalization API"},
{NULL},
};
static PyStructSequence_Desc app_info_desc = {
@@ -152,6 +155,7 @@ static PyObject *make_app_info(void)
SetObjItem(BPY_app_ffmpeg_struct());
SetObjItem(BPY_app_build_options_struct());
SetObjItem(BPY_app_handlers_struct());
SetObjItem(BPY_app_translations_struct());
#undef SetIntItem
#undef SetStrItem

4
source/blender/python/intern/bpy_app_build_options.c
View 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},
@@ -72,7 +72,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
};

753
source/blender/python/intern/bpy_app_translations.c Normal file
View File

@@ -0,0 +1,753 @@
/*
* ***** 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>
#include "BLI_string.h"
#include "BLI_ghash.h"
#include "BLI_utildefines.h"
#include "BPY_extern.h"
#include "bpy_app_translations.h"
#include "MEM_guardedalloc.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;
#ifdef WITH_INTERNATIONAL
/***** 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), "Py i18n GHashKey");
key->msgctxt = BLI_strdup(msgctxt ? msgctxt : BLF_I18NCONTEXT_DEFAULT_BPY_INTERN);
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, *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, &uuid, &uuid_dict)) {
PyObject *lang_dict;
#if 0
PyObject_Print(uuid_dict, stdout, 0);
printf("\n");
#endif
/* 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);
locale = language_country;
}
if (!lang_dict && language_variant) {
lang_dict = PyDict_GetItemString(uuid_dict, language_variant);
locale = language_variant;
}
if (!lang_dict && language) {
lang_dict = PyDict_GetItemString(uuid_dict, language);
locale = language;
}
if (lang_dict) {
PyObject *pykey, *trans;
Py_ssize_t ppos = 0;
if (!PyDict_Check(lang_dict)) {
printf("WARNING! In translations' dict of \"");
PyObject_Print(uuid, stdout, Py_PRINT_RAW);
printf("\":\n");
printf(" Each language key must have a dictionary as value, \"%s\" is not valid, skipping: ",
locale);
PyObject_Print(lang_dict, stdout, Py_PRINT_RAW);
printf("\n");
continue;
}
/* Iterate over all translations of the found language dict, and populate our ghash cache. */
while (PyDict_Next(lang_dict, &ppos, &pykey, &trans)) {
GHashKey *key;
const char *msgctxt = NULL, *msgid = NULL;
bool invalid_key = false;
if ((PyTuple_CheckExact(pykey) == false) || (PyTuple_GET_SIZE(pykey) != 2)) {
invalid_key = true;
}
else {
PyObject *tmp = PyTuple_GET_ITEM(pykey, 0);
if (tmp == Py_None) {
msgctxt = BLF_I18NCONTEXT_DEFAULT;
}
else if (PyUnicode_Check(tmp)) {
msgctxt = _PyUnicode_AsString(tmp);
}
else {
invalid_key = true;
}
tmp = PyTuple_GET_ITEM(pykey, 1);
if (PyUnicode_Check(tmp)) {
msgid = _PyUnicode_AsString(tmp);
}
else {
invalid_key = true;
}
}
if (invalid_key) {
printf("WARNING! In translations' dict of \"");
PyObject_Print(uuid, stdout, Py_PRINT_RAW);
printf("\", %s language:\n", locale);
printf(" Keys must be tuples of (msgctxt [string or None], msgid [string]), "
"this one is not valid, skipping: ");
PyObject_Print(pykey, stdout, Py_PRINT_RAW);
printf("\n");
continue;
}
if (PyUnicode_Check(trans) == false) {
printf("WARNING! In translations' dict of \"");
PyObject_Print(uuid, stdout, Py_PRINT_RAW);
printf("\":\n");
printf(" Values must be strings, this one is not valid, skipping: ");
PyObject_Print(trans, stdout, Py_PRINT_RAW);
printf("\n");
continue;
}
key = _ghashutil_keyalloc(msgctxt, msgid);
/* Do not overwrite existing keys! */
if (BLI_ghash_lookup(_translations_cache, (void *)key)) {
continue;
}
BLI_ghash_insert(_translations_cache, key, BLI_strdup(_PyUnicode_AsString(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, msgid);
tmp = BLI_ghash_lookup(_translations_cache, key);
_ghashutil_keyfree((void *)key);
if (tmp)
return tmp;
return msgid;
#undef STATIC_LOCALE_SIZE
}
#endif /* WITH_INTERNATIONAL */
PyDoc_STRVAR(app_translations_py_messages_register_doc,
".. method:: register(module_name, translations_dict)\n"
"\n"
" Registers an addon's UI translations.\n"
"\n"
" Note: Does nothing when Blender is built without internationalization support.\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)
{
#ifdef WITH_INTERNATIONAL
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_AsString(module_name));
return NULL;
}
PyDict_SetItem(self->py_messages, module_name, uuid_dict);
/* Clear cached messages dict! */
_clear_translations_cache();
#else
(void)self;
(void)args;
(void)kw;
#endif
/* 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"
" Note: Does nothing when Blender is built without internationalization support.\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)
{
#ifdef WITH_INTERNATIONAL
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();
}
#else
(void)self;
(void)args;
(void)kw;
#endif
/* And we are done! */
Py_RETURN_NONE;
}
/***** C-defined contexts *****/
/* This is always available (even when WITH_INTERNATIONAL is not defined). */
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)))
#define SetObjNone() Py_INCREF(Py_None); PyStructSequence_SET_ITEM(translations_contexts, pos++, Py_None)
for (ctxt = _contexts; ctxt->c_id; ctxt++) {
if (ctxt->value) {
SetObjString(ctxt->value);
}
else {
SetObjNone();
}
}
#undef SetObjString
#undef SetObjNone
return translations_contexts;
}
/***** Main BlenderAppTranslations Py object definition *****/
PyDoc_STRVAR(app_translations_contexts_doc,
"A named tuple containing all pre-defined translation contexts.\n"
"WARNING: do not use the \"" BLF_I18NCONTEXT_DEFAULT_BPY_INTERN "\" context, it is internally assimilated as the "
"default one!\n"
);
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 (will always return a void string when Blender is built without "
"internationalization support)."
);
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;
if (items) {
/* This is not elegant, but simple! */
for (it = items; it->identifier; it++) {
if (it->value)
num_locales++;
}
}
ret = PyTuple_New(num_locales);
if (items) {
for (it = items; it->identifier; it++) {
if (it->value)
PyTuple_SET_ITEM(ret, pos++, PyUnicode_FromString(it->description));
}
}
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).\n"
" 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"
" Note: Does nothing when Blender is built without internationalization support (hence always returns msgid).\n"
"\n"
" :arg msgid: The string to translate.\n"
" :type msgid: string\n"
" :arg msgctxt: The translation context.\n"
" :type msgctxt: string or None\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)
{
/* Note we could optimize this a bit when WITH_INTERNATIONAL is not defined, but don't think "code complexity" would
* be worth it, as this func should not often be used!
*/
/* XXX This code fails with scons when WITH_INTERNATIONAL is not defined, at link time, stating that BLF_pgettext
* is undefined... So using #ifdef after all, rather than removing scons from blender trunk!
*/
static const char *kwlist[] = {"msgid", "msgctxt", NULL};
char *msgid, *msgctxt = NULL;
if (!PyArg_ParseTupleAndKeywords(args, kw, "s|z:bpy.app.translations.pgettext", (char **)kwlist,
&msgid, &msgctxt))
{
return NULL;
}
#ifdef WITH_INTERNATIONAL
return PyUnicode_FromString(BLF_pgettext(msgctxt ? msgctxt : BLF_I18NCONTEXT_DEFAULT, msgid));
#else
return PyUnicode_FromString(msgid);
#endif
}
PyDoc_STRVAR(app_translations_locale_explode_doc,
".. method:: locale_explode(locale)\n"
"\n"
" Return all components and their combinations of the given ISO locale string.\n"
"\n"
" >>> bpy.app.translations.locale_explode(\"sr_RS@latin\")\n"
" (\"sr\", \"RS\", \"latin\", \"sr_RS\", \"sr@latin\")\n"
"\n"
" For non-complete locales, missing elements will be None.\n"
"\n"
" :arg locale: The ISO locale string to explode.\n"
" :type msgid: string\n"
" :return: A tuple (language, country, variant, language_country, language@variant).\n"
"\n"
);
static PyObject *app_translations_locale_explode(BlenderAppTranslations *UNUSED(self), PyObject *args, PyObject *kw)
{
static const char *kwlist[] = {"locale", NULL};
const char *locale;
char *language, *country, *variant, *language_country, *language_variant;
if (!PyArg_ParseTupleAndKeywords(args, kw, "s:bpy.app.translations.locale_explode", (char **)kwlist, &locale)) {
return NULL;
}
BLF_locale_explode(locale, &language, &country, &variant, &language_country, &language_variant);
return Py_BuildValue("sssss", language, country, variant, language_country, language_variant);
}
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},
{(char *)"locale_explode", (PyCFunction)app_translations_locale_explode, METH_VARARGS | METH_KEYWORDS | METH_STATIC,
app_translations_locale_explode_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;
}
static void app_translations_free(void *obj)
{
PyObject_Del(obj);
#ifdef WITH_INTERNATIONAL
_clear_translations_cache();
#endif
}
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 */
app_translations_free, /* 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;
}

32
source/blender/python/intern/bpy_app_translations.h Normal file
View File

@@ -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__ */

38
source/blender/python/intern/bpy_props.c
View 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}};
@@ -1257,6 +1259,20 @@ static size_t strswapbufcpy(char *buf, const char **orig)
}
#endif
static int icon_id_from_name(const char *name)
{
EnumPropertyItem *item;
int id;
if (name[0]) {
for (item = icon_items, id = 0; item->identifier; item++, id++)
if (strcmp(item->name, name) == 0)
return item->value;
}
return 0;
}
static EnumPropertyItem *enum_items_from_py(PyObject *seq_fast, PyObject *def, int *defvalue, const short is_enum_flag)
{
EnumPropertyItem *items;
@@ -1303,6 +1319,7 @@ static EnumPropertyItem *enum_items_from_py(PyObject *seq_fast, PyObject *def, i
for (i = 0; i < seq_len; i++) {
EnumPropertyItem tmp = {0, "", 0, "", ""};
const char *tmp_icon = NULL;
Py_ssize_t item_size;
Py_ssize_t id_str_size;
Py_ssize_t name_str_size;
@@ -1312,12 +1329,14 @@ static EnumPropertyItem *enum_items_from_py(PyObject *seq_fast, PyObject *def, i
if ((PyTuple_CheckExact(item)) &&
(item_size = PyTuple_GET_SIZE(item)) &&
(item_size == 3 || item_size == 4) &&
(item_size >= 3 && item_size <= 5) &&
(tmp.identifier = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 0), &id_str_size)) &&
(tmp.name = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 1), &name_str_size)) &&
(tmp.description = _PyUnicode_AsStringAndSize(PyTuple_GET_ITEM(item, 2), &desc_str_size)) &&
/* TODO, number isn't ensured to be unique from the script author */
(item_size < 4 || py_long_as_int(PyTuple_GET_ITEM(item, 3), &tmp.value) != -1))
(item_size != 4 || py_long_as_int(PyTuple_GET_ITEM(item, 3), &tmp.value) != -1) &&
(item_size != 5 || ((tmp_icon = _PyUnicode_AsString(PyTuple_GET_ITEM(item, 3))) &&
py_long_as_int(PyTuple_GET_ITEM(item, 4), &tmp.value) != -1)))
{
if (is_enum_flag) {
if (item_size < 4) {
@@ -1340,6 +1359,9 @@ static EnumPropertyItem *enum_items_from_py(PyObject *seq_fast, PyObject *def, i
}
}
if (tmp_icon)
tmp.icon = icon_id_from_name(tmp_icon);
items[i] = tmp;
/* calculate combine string length */
@@ -1349,8 +1371,8 @@ static EnumPropertyItem *enum_items_from_py(PyObject *seq_fast, PyObject *def, i
MEM_freeN(items);
PyErr_SetString(PyExc_TypeError,
"EnumProperty(...): expected a tuple containing "
"(identifier, name, description) and optionally a "
"unique number");
"(identifier, name, description) and optionally an "
"icon name and unique number");
return NULL;
}
@@ -2501,7 +2523,7 @@ BPY_PROPDEF_DESC_DOC
" :arg options: Enumerator in ['HIDDEN', 'SKIP_SAVE', 'ANIMATABLE', 'ENUM_FLAG', 'LIBRARY_EDITABLE'].\n"
" :type options: set\n"
" :arg items: sequence of enum items formatted:\n"
" [(identifier, name, description, number), ...] where the identifier is used\n"
" [(identifier, name, description, icon, number), ...] where the identifier is used\n"
" for python access and other values are used for the interface.\n"
" Note the item is optional.\n"
" For dynamic values a callback can be passed which returns a list in\n"
@@ -2509,7 +2531,7 @@ BPY_PROPDEF_DESC_DOC
" This function must take 2 arguments (self, context)\n"
" WARNING: Do not use generators here (they will work the first time, but will lead to empty values\n"
" in some unload/reload scenarii)!\n"
" :type items: sequence of string triplets or a function\n"
" :type items: sequence of string triples or a function\n"
BPY_PROPDEF_UPDATE_DOC
);
static PyObject *BPy_EnumProperty(PyObject *self, PyObject *args, PyObject *kw)

17
source/blender/python/intern/bpy_rna.c
View File

@@ -1623,8 +1623,10 @@ 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;
#endif /* WITH_INTERNATIONAL */
#ifdef USE_STRING_COERCE
PyObject *value_coerce = NULL;
@@ -1634,17 +1636,18 @@ 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 */
#ifdef WITH_INTERNATIONAL
if (do_translate) {
param = IFACE_(param);
}
#endif
if (param == NULL) {
if (PyUnicode_Check(value)) {
/* there was an error assigning a string type,