Merged changes in the trunk up to revision 54110.

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

15 files changed, 896 insertions, 75 deletions

diff --git a/source/blender/python/BPY_extern.h b/source/blender/python/BPY_extern.h
index 13cb11d1301..0f5be095e0f 100644
--- a/source/blender/python/BPY_extern.h
+++ b/source/blender/python/BPY_extern.h
@@ -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
diff --git a/source/blender/python/bmesh/bmesh_py_api.c b/source/blender/python/bmesh/bmesh_py_api.c
index ce8153fb994..47e6baf8e93 100644
--- a/source/blender/python/bmesh/bmesh_py_api.c
+++ b/source/blender/python/bmesh/bmesh_py_api.c
@@ -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);
 	}
 
diff --git a/source/blender/python/bmesh/bmesh_py_ops_call.c b/source/blender/python/bmesh/bmesh_py_ops_call.c
index 32315195072..d4c8033589a 100644
--- a/source/blender/python/bmesh/bmesh_py_ops_call.c
+++ b/source/blender/python/bmesh/bmesh_py_ops_call.c
@@ -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) {
diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c
index 37376cc7610..cde977288d1 100644
--- a/source/blender/python/bmesh/bmesh_py_types.c
+++ b/source/blender/python/bmesh/bmesh_py_types.c
@@ -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));
diff --git a/source/blender/python/bmesh/bmesh_py_types.h b/source/blender/python/bmesh/bmesh_py_types.h
index d15918a3c11..8e6d04ec9ba 100644
--- a/source/blender/python/bmesh/bmesh_py_types.h
+++ b/source/blender/python/bmesh/bmesh_py_types.h
@@ -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);
diff --git a/source/blender/python/bmesh/bmesh_py_types_meshdata.c b/source/blender/python/bmesh/bmesh_py_types_meshdata.c
index b0870578f5a..f59676252d4 100644
--- a/source/blender/python/bmesh/bmesh_py_types_meshdata.c
+++ b/source/blender/python/bmesh/bmesh_py_types_meshdata.c
@@ -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:
diff --git a/source/blender/python/bmesh/bmesh_py_types_select.c b/source/blender/python/bmesh/bmesh_py_types_select.c
index dfcfbeb0ab5..33cb1f5d0fb 100644
--- a/source/blender/python/bmesh/bmesh_py_types_select.c
+++ b/source/blender/python/bmesh/bmesh_py_types_select.c
@@ -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;
diff --git a/source/blender/python/bmesh/bmesh_py_utils.c b/source/blender/python/bmesh/bmesh_py_utils.c
index a43c5c18126..7c0adcfc997 100644
--- a/source/blender/python/bmesh/bmesh_py_utils.c
+++ b/source/blender/python/bmesh/bmesh_py_utils.c
@@ -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 */
diff --git a/source/blender/python/intern/CMakeLists.txt b/source/blender/python/intern/CMakeLists.txt
index 823c7c709d7..30ab4bd4b0e 100644
--- a/source/blender/python/intern/CMakeLists.txt
+++ b/source/blender/python/intern/CMakeLists.txt
@@ -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
diff --git a/source/blender/python/intern/bpy_app.c b/source/blender/python/intern/bpy_app.c
index 65568e9a0c1..7889b9a7f0b 100644
--- a/source/blender/python/intern/bpy_app.c
+++ b/source/blender/python/intern/bpy_app.c
@@ -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
diff --git a/source/blender/python/intern/bpy_app_build_options.c b/source/blender/python/intern/bpy_app_build_options.c
index 8815348c22d..60105f73f37 100644
--- a/source/blender/python/intern/bpy_app_build_options.c
+++ b/source/blender/python/intern/bpy_app_build_options.c
@@ -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
 };
diff --git a/source/blender/python/intern/bpy_app_translations.c b/source/blender/python/intern/bpy_app_translations.c
new file mode 100644
index 00000000000..b6d2f624229
--- /dev/null
+++ b/source/blender/python/intern/bpy_app_translations.c
@@ -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;
+}
diff --git a/source/blender/python/intern/bpy_app_translations.h b/source/blender/python/intern/bpy_app_translations.h
new file mode 100644
index 00000000000..704307574d0
--- /dev/null
+++ b/source/blender/python/intern/bpy_app_translations.h
@@ -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__ */
diff --git a/source/blender/python/intern/bpy_props.c b/source/blender/python/intern/bpy_props.c
index f3fa0c9a0a9..b42fdbd0ca4 100644
--- a/source/blender/python/intern/bpy_props.c
+++ b/source/blender/python/intern/bpy_props.c
@@ -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)
diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c
index 94f262f57f5..85a6db00703 100644
--- a/source/blender/python/intern/bpy_rna.c
+++ b/source/blender/python/intern/bpy_rna.c
@@ -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,