svn merge ^/trunk/blender -r42742:42757

17 files changed, 394 insertions, 188 deletions

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index e47c197cfa0..20688151c11 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -958,11 +958,15 @@ void vDM_ColorBand_store(ColorBand *coba)
 	stored_cb= coba;
 }
 
-/* return an array of vertex weight colors */
+/* return an array of vertex weight colors, caller must free.
+ *
+ * note that we could save some memory and allocate RGB only but then we'd need to
+ * re-arrange the colors when copying to the face since MCol has odd ordering,
+ * so leave this as is - campbell */
 static unsigned char *calc_weightpaint_vert_array(Object *ob, int const draw_flag, ColorBand *coba)
 {
 	Mesh *me = ob->data;
-	unsigned char *wtcol_v = MEM_callocN (sizeof(unsigned char) * me->totvert * 4, "weightmap_v");
+	unsigned char *wtcol_v = MEM_mallocN (sizeof(unsigned char) * me->totvert * 4, "weightmap_v");
 
 	if (me->dvert) {
 		unsigned char *wc = wtcol_v;
@@ -1011,8 +1015,8 @@ static void add_weight_mcol_dm(Object *ob, DerivedMesh *dm, int const draw_flag)
 		/*origindex being NULL means we're operating on original mesh data*/
 		unsigned int fidx= mf->v4 ? 3:2;
 		do {
-		copy_v4_v4_char((char *)&wtcol_f[(4 * i + fidx) * 4],
-						(char *)&wtcol_v[4 * (*(&mf->v1 + fidx))]);
+			copy_v4_v4_char((char *)&wtcol_f[(4 * i + fidx) * 4],
+			                (char *)&wtcol_v[4 * (*(&mf->v1 + fidx))]);
 		} while (fidx--);
 	}
 
diff --git a/source/blender/blenlib/BLI_dynstr.h b/source/blender/blenlib/BLI_dynstr.h
index e27a315a023..861da665a30 100644
--- a/source/blender/blenlib/BLI_dynstr.h
+++ b/source/blender/blenlib/BLI_dynstr.h
@@ -100,6 +100,17 @@ int		BLI_dynstr_get_len				(DynStr *ds);
 	 */
 char*	BLI_dynstr_get_cstring			(DynStr *ds);
 
+/**
+ * Get a DynStr's contents as a c-string.
+ * <i> The str argument must be allocated to be at
+ * least the size of BLI_dynstr_get_len(ds). </i>
+ *
+ * @param ds The DynStr of interest.
+ * @param str The string to fill.
+ * @return The contents of @a ds as a c-string.
+ */
+void	BLI_dynstr_get_cstring_ex		(DynStr *ds, char *str);
+
 	/**
 	 * Free the DynStr
 	 * 
diff --git a/source/blender/blenlib/intern/BLI_dynstr.c b/source/blender/blenlib/intern/BLI_dynstr.c
index 349bc3492e7..ad52de180aa 100644
--- a/source/blender/blenlib/intern/BLI_dynstr.c
+++ b/source/blender/blenlib/intern/BLI_dynstr.c
@@ -226,11 +226,11 @@ int BLI_dynstr_get_len(DynStr *ds)
 	return ds->curlen;
 }
 
-char *BLI_dynstr_get_cstring(DynStr *ds)
+void BLI_dynstr_get_cstring_ex(DynStr *ds, char *rets)
 {
-	char *s, *rets= MEM_mallocN(ds->curlen+1, "dynstr_cstring");
+	char *s;
 	DynStrElem *dse;
-	
+
 	for (s= rets, dse= ds->elems; dse; dse= dse->next) {
 		int slen= strlen(dse->str);
 
@@ -239,7 +239,12 @@ char *BLI_dynstr_get_cstring(DynStr *ds)
 		s+= slen;
 	}
 	rets[ds->curlen]= '\0';
-	
+}
+
+char *BLI_dynstr_get_cstring(DynStr *ds)
+{
+	char *rets= MEM_mallocN(ds->curlen+1, "dynstr_cstring");
+	BLI_dynstr_get_cstring_ex(ds, rets);
 	return rets;
 }
 
diff --git a/source/blender/blenloader/intern/readfile.c b/source/blender/blenloader/intern/readfile.c
index 99c3ec0c134..1c554cdcf9a 100644
--- a/source/blender/blenloader/intern/readfile.c
+++ b/source/blender/blenloader/intern/readfile.c
@@ -12805,6 +12805,14 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
 			for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next)
 				do_versions_nodetree_socket_use_flags_2_62(ntree);
 		}
+		{
+			/* Initialize BGE exit key to esc key */
+			Scene *scene;
+			for(scene= main->scene.first; scene; scene= scene->id.next) {
+				if (!scene->gm.exitkey)
+					scene->gm.exitkey = 218; // Blender key code for ESC
+			}
+		}
 	}
 
 	/* WATCH IT!!!: pointers from libdata have not been converted yet here! */
diff --git a/source/blender/editors/screen/screen_ops.c b/source/blender/editors/screen/screen_ops.c
index b15278bd583..2f80c58a836 100644
--- a/source/blender/editors/screen/screen_ops.c
+++ b/source/blender/editors/screen/screen_ops.c
@@ -1291,6 +1291,7 @@ static void area_split_exit(bContext *C, wmOperator *op)
 		op->customdata = NULL;
 	}
 	
+	WM_cursor_restore(CTX_wm_window(C));
 	WM_event_add_notifier(C, NC_SCREEN|NA_EDITED, NULL);
 	
 	/* this makes sure aligned edges will result in aligned grabbing */
@@ -1489,6 +1490,37 @@ static int area_split_modal(bContext *C, wmOperator *op, wmEvent *event)
 				}
 			}
 			break;
+			
+		case MIDDLEMOUSE:
+		case TABKEY:
+			if (sd->previewmode==0){
+			}
+			else{
+				dir = RNA_enum_get(op->ptr, "direction");
+				
+				if(event->val==KM_PRESS){
+					if (sd->sarea){
+						sd->sarea->flag &= ~(AREA_FLAG_DRAWSPLIT_H|AREA_FLAG_DRAWSPLIT_V);
+						ED_area_tag_redraw(sd->sarea);
+						
+						if (dir=='v'){
+							RNA_enum_set(op->ptr, "direction", 'h');
+							sd->sarea->flag |= AREA_FLAG_DRAWSPLIT_H;
+							
+							WM_cursor_set(CTX_wm_window(C),CURSOR_X_MOVE);
+						}
+						else{
+							RNA_enum_set(op->ptr, "direction", 'v');
+							sd->sarea->flag |= AREA_FLAG_DRAWSPLIT_V;
+							
+							WM_cursor_set(CTX_wm_window(C),CURSOR_Y_MOVE);
+						}
+					}
+				}
+			}
+			
+			break;
+			
 		case RIGHTMOUSE: /* cancel operation */
 		case ESCKEY:
 			return area_split_cancel(C, op);
diff --git a/source/blender/editors/sculpt_paint/paint_ops.c b/source/blender/editors/sculpt_paint/paint_ops.c
index 2d0ad349be8..eb20465a2ab 100644
--- a/source/blender/editors/sculpt_paint/paint_ops.c
+++ b/source/blender/editors/sculpt_paint/paint_ops.c
@@ -605,9 +605,13 @@ void ED_keymap_paint(wmKeyConfig *keyconf)
 	ed_keymap_paint_brush_size(keymap, "tool_settings.weight_paint.brush.size");
 	ed_keymap_paint_brush_radial_control(keymap, "weight_paint", 0);
 
-	kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", MKEY, KM_PRESS, 0, 0); /* mask toggle */
+	kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", MKEY, KM_PRESS, 0, 0); /* face mask toggle */
 	RNA_string_set(kmi->ptr, "data_path", "weight_paint_object.data.use_paint_mask");
 
+	/* note, conflicts with vertex paint, but this is more useful */
+	kmi = WM_keymap_add_item(keymap, "WM_OT_context_toggle", VKEY, KM_PRESS, 0, 0); /* vert mask toggle */
+	RNA_string_set(kmi->ptr, "data_path", "weight_paint_object.data.use_paint_mask_vertex");
+
 	WM_keymap_verify_item(keymap, "PAINT_OT_weight_from_bones", WKEY, KM_PRESS, 0, 0);
 
 	
diff --git a/source/blender/makesdna/DNA_scene_types.h b/source/blender/makesdna/DNA_scene_types.h
index 1b849754db8..345e78d70c9 100644
--- a/source/blender/makesdna/DNA_scene_types.h
+++ b/source/blender/makesdna/DNA_scene_types.h
@@ -576,7 +576,7 @@ typedef struct GameData {
 	short mode, matmode;
 	short occlusionRes;		/* resolution of occlusion Z buffer in pixel */
 	short physicsEngine;
-	short pad[2];
+	short exitkey, pad;
 	short ticrate, maxlogicstep, physubstep, maxphystep;
 	short obstacleSimulation, pad1;
 	float levelHeight;
diff --git a/source/blender/makesrna/intern/rna_scene.c b/source/blender/makesrna/intern/rna_scene.c
index eef7cddf088..a193f5d0f33 100644
--- a/source/blender/makesrna/intern/rna_scene.c
+++ b/source/blender/makesrna/intern/rna_scene.c
@@ -1215,6 +1215,13 @@ static void rna_GameSettings_auto_start_set(PointerRNA *UNUSED(ptr), int value)
 		G.fileflags &= ~G_FILE_AUTOPLAY;
 }
 
+static void rna_GameSettings_exit_key_set(PointerRNA *ptr, int value)
+{
+	GameData *gm = (GameData*)ptr->data;
+
+	if(ISKEYBOARD(value))
+		gm->exitkey=value;
+}
 
 static TimeMarker *rna_TimeLine_add(Scene *scene, const char name[])
 {
@@ -2105,6 +2112,13 @@ static void rna_def_scene_game_data(BlenderRNA *brna)
 	RNA_def_property_range(prop, 8, 32);
 	RNA_def_property_ui_text(prop, "Bits", "Display bit depth of full screen display");
 	RNA_def_property_update(prop, NC_SCENE, NULL);
+
+	prop= RNA_def_property(srna, "exit_key", PROP_ENUM, PROP_NONE);
+	RNA_def_property_enum_sdna(prop, NULL, "exitkey");
+	RNA_def_property_enum_items(prop, event_type_items);
+	RNA_def_property_enum_funcs(prop, NULL, "rna_GameSettings_exit_key_set", NULL);
+	RNA_def_property_ui_text(prop, "Exit Key",  "Sets the key that exits the Game Engine");
+	RNA_def_property_update(prop, NC_SCENE, NULL);
 	
 	// Do we need it here ? (since we already have it in World
 	prop= RNA_def_property(srna, "frequency", PROP_INT, PROP_NONE);
diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c
index 69a5fb39b67..ded0f2f768c 100644
--- a/source/blender/python/intern/bpy_rna.c
+++ b/source/blender/python/intern/bpy_rna.c
@@ -642,7 +642,7 @@ PyObject *pyrna_math_object_from_array(PointerRNA *ptr, PropertyRNA *prop)
 			if (len==16) {
 				if (is_thick) {
 					ret= Matrix_CreatePyObject(NULL, 4, 4, Py_NEW, NULL);
-					RNA_property_float_get_array(ptr, prop, ((MatrixObject *)ret)->contigPtr);
+					RNA_property_float_get_array(ptr, prop, ((MatrixObject *)ret)->matrix);
 				}
 				else {
 					PyObject *mat_cb= Matrix_CreatePyObject_cb(ret, 4,4, mathutils_rna_matrix_cb_index, FALSE);
@@ -653,7 +653,7 @@ PyObject *pyrna_math_object_from_array(PointerRNA *ptr, PropertyRNA *prop)
 			else if (len==9) {
 				if (is_thick) {
 					ret= Matrix_CreatePyObject(NULL, 3, 3, Py_NEW, NULL);
-					RNA_property_float_get_array(ptr, prop, ((MatrixObject *)ret)->contigPtr);
+					RNA_property_float_get_array(ptr, prop, ((MatrixObject *)ret)->matrix);
 				}
 				else {
 					PyObject *mat_cb= Matrix_CreatePyObject_cb(ret, 3,3, mathutils_rna_matrix_cb_index, FALSE);
diff --git a/source/blender/python/mathutils/mathutils.c b/source/blender/python/mathutils/mathutils.c
index 5587028d812..1dfd7c574dd 100644
--- a/source/blender/python/mathutils/mathutils.c
+++ b/source/blender/python/mathutils/mathutils.c
@@ -35,6 +35,7 @@
 
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
+#include "BLI_dynstr.h"
 
 PyDoc_STRVAR(M_Mathutils_doc,
 "This module provides access to matrices, eulers, quaternions and vectors."
@@ -211,7 +212,7 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error
 		if (BaseMath_ReadCallback((BaseMathObject *)value) == -1) {
 			return -1;
 		}
-		else if (((MatrixObject *)value)->col_size < 3 || ((MatrixObject *)value)->row_size < 3) {
+		else if (((MatrixObject *)value)->num_row < 3 || ((MatrixObject *)value)->num_col < 3) {
 			PyErr_Format(PyExc_ValueError,
 			             "%.200s: matrix must have minimum 3x3 dimensions",
 			             error_prefix);
@@ -267,6 +268,18 @@ int EXPP_VectorsAreEqual(float *vecA, float *vecB, int size, int floatSteps)
 	return 1;
 }
 
+/* dynstr as python string utility funcions, frees 'ds'! */
+PyObject *mathutils_dynstr_to_py(struct DynStr *ds)
+{
+	const int ds_len = BLI_dynstr_get_len(ds); /* space for \0 */
+	char *ds_buf     = PyMem_Malloc(ds_len + 1);
+	PyObject *ret;
+	BLI_dynstr_get_cstring_ex(ds, ds_buf);
+	BLI_dynstr_free(ds);
+	ret = PyUnicode_FromStringAndSize(ds_buf, ds_len);
+	PyMem_Free(ds_buf);
+	return ret;
+}
 
 /* Mathutils Callbacks */
 
diff --git a/source/blender/python/mathutils/mathutils.h b/source/blender/python/mathutils/mathutils.h
index cd3548b9b82..2454e953949 100644
--- a/source/blender/python/mathutils/mathutils.h
+++ b/source/blender/python/mathutils/mathutils.h
@@ -37,6 +37,8 @@
 
 /* Can cast different mathutils types to this, use for generic funcs */
 
+struct DynStr;
+
 extern char BaseMathObject_Wrapped_doc[];
 extern char BaseMathObject_Owner_doc[];
 
@@ -120,4 +122,7 @@ int mathutils_any_to_rotmat(float rmat[3][3], PyObject *value, const char *error
 
 int column_vector_multiplication(float rvec[4], VectorObject *vec, MatrixObject *mat);
 
+/* dynstr as python string utility funcions */
+PyObject *mathutils_dynstr_to_py(struct DynStr *ds);
+
 #endif /* MATHUTILS_H */
diff --git a/source/blender/python/mathutils/mathutils_Color.c b/source/blender/python/mathutils/mathutils_Color.c
index e46dda7560f..e0a0deb9a0e 100644
--- a/source/blender/python/mathutils/mathutils_Color.c
+++ b/source/blender/python/mathutils/mathutils_Color.c
@@ -32,6 +32,7 @@
 
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
+#include "BLI_dynstr.h"
 
 #define COLOR_SIZE 3
 
@@ -125,6 +126,21 @@ static PyObject *Color_repr(ColorObject * self)
 	return ret;
 }
 
+static PyObject *Color_str(ColorObject * self)
+{
+	DynStr *ds;
+
+	if (BaseMath_ReadCallback(self) == -1)
+		return NULL;
+
+	ds= BLI_dynstr_new();
+
+	BLI_dynstr_appendf(ds, "<Color (r=%.4f, g=%.4f, b=%.4f)>",
+	                   self->col[0], self->col[1], self->col[2]);
+
+	return mathutils_dynstr_to_py(ds); /* frees ds */
+}
+
 //------------------------tp_richcmpr
 //returns -1 execption, 0 false, 1 true
 static PyObject* Color_richcmpr(PyObject *a, PyObject *b, int op)
@@ -789,7 +805,7 @@ PyTypeObject color_Type = {
 	&Color_AsMapping,				//tp_as_mapping
 	NULL,							//tp_hash
 	NULL,							//tp_call
-	NULL,							//tp_str
+	(reprfunc) Color_str,			//tp_str
 	NULL,							//tp_getattro
 	NULL,							//tp_setattro
 	NULL,							//tp_as_buffer
diff --git a/source/blender/python/mathutils/mathutils_Euler.c b/source/blender/python/mathutils/mathutils_Euler.c
index f44c0b82a2d..443e77c3798 100644
--- a/source/blender/python/mathutils/mathutils_Euler.c
+++ b/source/blender/python/mathutils/mathutils_Euler.c
@@ -36,6 +36,7 @@
 
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
+#include "BLI_dynstr.h"
 
 #define EULER_SIZE 3
 
@@ -317,6 +318,21 @@ static PyObject *Euler_repr(EulerObject * self)
 	return ret;
 }
 
+static PyObject *Euler_str(EulerObject * self)
+{
+	DynStr *ds;
+
+	if (BaseMath_ReadCallback(self) == -1)
+		return NULL;
+
+	ds= BLI_dynstr_new();
+
+	BLI_dynstr_appendf(ds, "<Euler (x=%.4f, y=%.4f, z=%.4f), order='%s'>",
+	                   self->eul[0], self->eul[1], self->eul[2], euler_order_str(self));
+
+	return mathutils_dynstr_to_py(ds); /* frees ds */
+}
+
 static PyObject* Euler_richcmpr(PyObject *a, PyObject *b, int op)
 {
 	PyObject *res;
@@ -635,7 +651,7 @@ PyTypeObject euler_Type = {
 	&Euler_AsMapping,				//tp_as_mapping
 	NULL,							//tp_hash
 	NULL,							//tp_call
-	NULL,							//tp_str
+	(reprfunc) Euler_str,			//tp_str
 	NULL,							//tp_getattro
 	NULL,							//tp_setattro
 	NULL,							//tp_as_buffer
diff --git a/source/blender/python/mathutils/mathutils_Matrix.c b/source/blender/python/mathutils/mathutils_Matrix.c
index 44799bb7943..59aad37f746 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.c
+++ b/source/blender/python/mathutils/mathutils_Matrix.c
@@ -35,6 +35,8 @@
 
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
+#include "BLI_string.h"
+#include "BLI_dynstr.h"
 
 static PyObject *Matrix_copy(MatrixObject *self);
 static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *value);
@@ -49,56 +51,56 @@ static int mathutils_matrix_vector_check(BaseMathObject *bmo)
 	return BaseMath_ReadCallback(self);
 }
 
-static int mathutils_matrix_vector_get(BaseMathObject *bmo, int subtype)
+static int mathutils_matrix_vector_get(BaseMathObject *bmo, int col)
 {
 	MatrixObject *self= (MatrixObject *)bmo->cb_user;
-	int index;
+	int row;
 
 	if (BaseMath_ReadCallback(self) == -1)
 		return -1;
 
-	for (index=0; index < self->col_size; index++) {
-		bmo->data[index] = MATRIX_ITEM(self, subtype, index);
+	for (row=0; row < self->num_row; row++) {
+		bmo->data[row] = MATRIX_ITEM(self, row, col);
 	}
 
 	return 0;
 }
 
-static int mathutils_matrix_vector_set(BaseMathObject *bmo, int subtype)
+static int mathutils_matrix_vector_set(BaseMathObject *bmo, int col)
 {
 	MatrixObject *self= (MatrixObject *)bmo->cb_user;
-	int index;
+	int row;
 
 	if (BaseMath_ReadCallback(self) == -1)
 		return -1;
 
-	for (index=0; index < self->col_size; index++) {
-		MATRIX_ITEM(self, subtype, index) = bmo->data[index];
+	for (row=0; row < self->num_row; row++) {
+		MATRIX_ITEM(self, row, col) = bmo->data[row];
 	}
 
 	(void)BaseMath_WriteCallback(self);
 	return 0;
 }
 
-static int mathutils_matrix_vector_get_index(BaseMathObject *bmo, int subtype, int index)
+static int mathutils_matrix_vector_get_index(BaseMathObject *bmo, int col, int row)
 {
 	MatrixObject *self= (MatrixObject *)bmo->cb_user;
 
 	if (BaseMath_ReadCallback(self) == -1)
 		return -1;
 
-	bmo->data[index]= MATRIX_ITEM(self, subtype, index);
+	bmo->data[row]= MATRIX_ITEM(self, row, col);
 	return 0;
 }
 
-static int mathutils_matrix_vector_set_index(BaseMathObject *bmo, int subtype, int index)
+static int mathutils_matrix_vector_set_index(BaseMathObject *bmo, int col, int row)
 {
 	MatrixObject *self= (MatrixObject *)bmo->cb_user;
 
 	if (BaseMath_ReadCallback(self) == -1)
 		return -1;
 
-	MATRIX_ITEM(self, subtype, index) = bmo->data[index];
+	MATRIX_ITEM(self, row, col) = bmo->data[row];
 
 	(void)BaseMath_WriteCallback(self);
 	return 0;
@@ -133,16 +135,16 @@ static PyObject *Matrix_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 			PyObject *arg= PyTuple_GET_ITEM(args, 0);
 
 			/* -1 is an error, size checks will accunt for this */
-			const unsigned short row_size= PySequence_Size(arg);
+			const unsigned short num_col= PySequence_Size(arg);
 
-			if (row_size >= 2 && row_size <= 4) {
+			if (num_col >= 2 && num_col <= 4) {
 				PyObject *item= PySequence_GetItem(arg, 0);
-				const unsigned short col_size= PySequence_Size(item);
+				const unsigned short num_row= PySequence_Size(item);
 				Py_XDECREF(item);
 
-				if (col_size >= 2 && col_size <= 4) {
+				if (num_row >= 2 && num_row <= 4) {
 					/* sane row & col size, new matrix and assign as slice  */
-					PyObject *matrix= Matrix_CreatePyObject(NULL, row_size, col_size, Py_NEW, type);
+					PyObject *matrix= Matrix_CreatePyObject(NULL, num_col, num_row, Py_NEW, type);
 					if (Matrix_ass_slice((MatrixObject *)matrix, 0, INT_MAX, arg) == 0) {
 						return matrix;
 					}
@@ -622,25 +624,25 @@ static PyObject *C_Matrix_Shear(PyObject *cls, PyObject *args)
 
 void matrix_as_3x3(float mat[3][3], MatrixObject *self)
 {
-	copy_v3_v3(mat[0], MATRIX_ROW_PTR(self, 0));
-	copy_v3_v3(mat[1], MATRIX_ROW_PTR(self, 1));
-	copy_v3_v3(mat[2], MATRIX_ROW_PTR(self, 2));
+	copy_v3_v3(mat[0], MATRIX_COL_PTR(self, 0));
+	copy_v3_v3(mat[1], MATRIX_COL_PTR(self, 1));
+	copy_v3_v3(mat[2], MATRIX_COL_PTR(self, 2));
 }
 
 /* assumes rowsize == colsize is checked and the read callback has run */
 static float matrix_determinant_internal(MatrixObject *self)
 {
-	if (self->row_size == 2) {
+	if (self->num_col == 2) {
 		return determinant_m2(MATRIX_ITEM(self, 0, 0), MATRIX_ITEM(self, 0, 1),
 		                      MATRIX_ITEM(self, 1, 0), MATRIX_ITEM(self, 1, 1));
 	}
-	else if (self->row_size == 3) {
+	else if (self->num_col == 3) {
 		return determinant_m3(MATRIX_ITEM(self, 0, 0), MATRIX_ITEM(self, 0, 1), MATRIX_ITEM(self, 0, 2),
 		                      MATRIX_ITEM(self, 1, 0), MATRIX_ITEM(self, 1, 1), MATRIX_ITEM(self, 1, 2),
 		                      MATRIX_ITEM(self, 2, 0), MATRIX_ITEM(self, 2, 1), MATRIX_ITEM(self, 2, 2));
 	}
 	else {
-		return determinant_m4((float (*)[4])self->contigPtr);
+		return determinant_m4((float (*)[4])self->matrix);
 	}
 }
 
@@ -662,17 +664,17 @@ static PyObject *Matrix_to_quaternion(MatrixObject *self)
 		return NULL;
 
 	/*must be 3-4 cols, 3-4 rows, square matrix*/
-	if ((self->col_size < 3) || (self->row_size < 3) || (self->col_size != self->row_size)) {
+	if ((self->num_row < 3) || (self->num_col < 3) || (self->num_row != self->num_col)) {
 		PyErr_SetString(PyExc_ValueError,
 		                "Matrix.to_quat(): "
 		                "inappropriate matrix size - expects 3x3 or 4x4 matrix");
 		return NULL;
 	}
-	if (self->col_size == 3) {
-		mat3_to_quat(quat, (float (*)[3])self->contigPtr);
+	if (self->num_row == 3) {
+		mat3_to_quat(quat, (float (*)[3])self->matrix);
 	}
 	else {
-		mat4_to_quat(quat, (float (*)[4])self->contigPtr);
+		mat4_to_quat(quat, (float (*)[4])self->matrix);
 	}
 
 	return Quaternion_CreatePyObject(quat, Py_NEW, NULL);
@@ -719,11 +721,11 @@ static PyObject *Matrix_to_euler(MatrixObject *self, PyObject *args)
 	}
 
 	/*must be 3-4 cols, 3-4 rows, square matrix*/
-	if (self->col_size ==3 && self->row_size ==3) {
-		mat= (float (*)[3])self->contigPtr;
+	if (self->num_row ==3 && self->num_col ==3) {
+		mat= (float (*)[3])self->matrix;
 	}
-	else if (self->col_size ==4 && self->row_size ==4) {
-		copy_m3_m4(tmat, (float (*)[4])self->contigPtr);
+	else if (self->num_row ==4 && self->num_col ==4) {
+		copy_m3_m4(tmat, (float (*)[4])self->matrix);
 		mat= tmat;
 	}
 	else {
@@ -774,8 +776,8 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
 		return NULL;
 	}
 
-	self->contigPtr = PyMem_Realloc(self->contigPtr, (sizeof(float) * 16));
-	if (self->contigPtr == NULL) {
+	self->matrix = PyMem_Realloc(self->matrix, (sizeof(float) * 16));
+	if (self->matrix == NULL) {
 		PyErr_SetString(PyExc_MemoryError,
 		                "Matrix.resize_4x4(): "
 		                "problem allocating pointer space");
@@ -783,31 +785,31 @@ static PyObject *Matrix_resize_4x4(MatrixObject *self)
 	}
 
 	/*move data to new spot in array + clean*/
-	for (blank_rows = (4 - self->row_size); blank_rows > 0; blank_rows--) {
+	for (blank_rows = (4 - self->num_col); blank_rows > 0; blank_rows--) {
 		for (x = 0; x < 4; x++) {
-			index = (4 * (self->row_size + (blank_rows - 1))) + x;
+			index = (4 * (self->num_col + (blank_rows - 1))) + x;
 			if (index == 10 || index == 15) {
-				self->contigPtr[index] = 1.0f;
+				self->matrix[index] = 1.0f;
 			}
 			else {
-				self->contigPtr[index] = 0.0f;
+				self->matrix[index] = 0.0f;
 			}
 		}
 	}
-	for (x = 1; x <= self->row_size; x++) {
-		first_row_elem = (self->col_size * (self->row_size - x));
-		curr_pos = (first_row_elem + (self->col_size -1));
-		new_pos = (4 * (self->row_size - x)) + (curr_pos - first_row_elem);
-		for (blank_columns = (4 - self->col_size); blank_columns > 0; blank_columns--) {
-			self->contigPtr[new_pos + blank_columns] = 0.0f;
+	for (x = 1; x <= self->num_col; x++) {
+		first_row_elem = (self->num_row * (self->num_col - x));
+		curr_pos = (first_row_elem + (self->num_row -1));
+		new_pos = (4 * (self->num_col - x)) + (curr_pos - first_row_elem);
+		for (blank_columns = (4 - self->num_row); blank_columns > 0; blank_columns--) {
+			self->matrix[new_pos + blank_columns] = 0.0f;
 		}
 		for ( ; curr_pos >= first_row_elem; curr_pos--) {
-			self->contigPtr[new_pos] = self->contigPtr[curr_pos];
+			self->matrix[new_pos] = self->matrix[curr_pos];
 			new_pos--;
 		}
 	}
-	self->row_size = 4;
-	self->col_size = 4;
+	self->num_col = 4;
+	self->num_row = 4;
 
 	Py_RETURN_NONE;
 }
@@ -825,12 +827,12 @@ static PyObject *Matrix_to_4x4(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if (self->col_size==4 && self->row_size==4) {
-		return Matrix_CreatePyObject(self->contigPtr, 4, 4, Py_NEW, Py_TYPE(self));
+	if (self->num_row==4 && self->num_col==4) {
+		return Matrix_CreatePyObject(self->matrix, 4, 4, Py_NEW, Py_TYPE(self));
 	}
-	else if (self->col_size==3 && self->row_size==3) {
+	else if (self->num_row==3 && self->num_col==3) {
 		float mat[4][4];
-		copy_m4_m3(mat, (float (*)[3])self->contigPtr);
+		copy_m4_m3(mat, (float (*)[3])self->matrix);
 		return Matrix_CreatePyObject((float *)mat, 4, 4, Py_NEW, Py_TYPE(self));
 	}
 	/* TODO, 2x2 matrix */
@@ -856,7 +858,7 @@ static PyObject *Matrix_to_3x3(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if ((self->col_size < 3) || (self->row_size < 3)) {
+	if ((self->num_row < 3) || (self->num_col < 3)) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.to_3x3(): inappropriate matrix size");
 		return NULL;
@@ -880,14 +882,14 @@ static PyObject *Matrix_to_translation(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if ((self->col_size < 3) || self->row_size < 4) {
+	if ((self->num_row < 3) || self->num_col < 4) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.to_translation(): "
 		                "inappropriate matrix size");
 		return NULL;
 	}
 
-	return Vector_CreatePyObject(MATRIX_ROW_PTR(self, 3), 3, Py_NEW, NULL);
+	return Vector_CreatePyObject(MATRIX_COL_PTR(self, 3), 3, Py_NEW, NULL);
 }
 
 PyDoc_STRVAR(Matrix_to_scale_doc,
@@ -910,7 +912,7 @@ static PyObject *Matrix_to_scale(MatrixObject *self)
 		return NULL;
 
 	/*must be 3-4 cols, 3-4 rows, square matrix*/
-	if ((self->col_size < 3) || (self->row_size < 3)) {
+	if ((self->num_row < 3) || (self->num_col < 3)) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.to_scale(): "
 		                "inappropriate matrix size, 3x3 minimum size");
@@ -948,7 +950,7 @@ static PyObject *Matrix_invert(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if (self->row_size != self->col_size) {
+	if (self->num_col != self->num_row) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.invert(ed): "
 		                "only square matrices are supported");
@@ -960,26 +962,26 @@ static PyObject *Matrix_invert(MatrixObject *self)
 
 	if (det != 0) {
 		/*calculate the classical adjoint*/
-		if (self->row_size == 2) {
+		if (self->num_col == 2) {
 			mat[0] =  MATRIX_ITEM(self, 1, 1);
 			mat[1] = -MATRIX_ITEM(self, 0, 1);
 			mat[2] = -MATRIX_ITEM(self, 1, 0);
 			mat[3] =  MATRIX_ITEM(self, 0, 0);
 		}
-		else if (self->row_size == 3) {
-			adjoint_m3_m3((float (*)[3]) mat,(float (*)[3])self->contigPtr);
+		else if (self->num_col == 3) {
+			adjoint_m3_m3((float (*)[3]) mat,(float (*)[3])self->matrix);
 		}
-		else if (self->row_size == 4) {
-			adjoint_m4_m4((float (*)[4]) mat, (float (*)[4])self->contigPtr);
+		else if (self->num_col == 4) {
+			adjoint_m4_m4((float (*)[4]) mat, (float (*)[4])self->matrix);
 		}
 		/*divide by determinate*/
-		for (x = 0; x < (self->row_size * self->col_size); x++) {
+		for (x = 0; x < (self->num_col * self->num_row); x++) {
 			mat[x] /= det;
 		}
 		/*set values*/
-		for (x = 0; x < self->row_size; x++) {
-			for (y = 0; y < self->col_size; y++) {
-				MATRIX_ITEM(self, x, y) = mat[z];
+		for (x = 0; x < self->num_col; x++) {
+			for (y = 0; y < self->num_row; y++) {
+				MATRIX_ITEM(self, y, x) = mat[z];
 				z++;
 			}
 		}
@@ -1032,7 +1034,7 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value)
 	if (mathutils_any_to_rotmat(other_rmat, value, "matrix.rotate(value)") == -1)
 		return NULL;
 
-	if (self->col_size != 3 || self->row_size != 3) {
+	if (self->num_row != 3 || self->num_col != 3) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.rotate(): "
 		                "must have 3x3 dimensions");
@@ -1042,7 +1044,7 @@ static PyObject *Matrix_rotate(MatrixObject *self, PyObject *value)
 	matrix_as_3x3(self_rmat, self);
 	mul_m3_m3m3(rmat, other_rmat, self_rmat);
 
-	copy_m3_m3((float (*)[3])(self->contigPtr), rmat);
+	copy_m3_m3((float (*)[3])(self->matrix), rmat);
 
 	(void)BaseMath_WriteCallback(self);
 	Py_RETURN_NONE;
@@ -1065,7 +1067,7 @@ static PyObject *Matrix_decompose(MatrixObject *self)
 	float quat[4];
 	float size[3];
 
-	if (self->col_size != 4 || self->row_size != 4) {
+	if (self->num_row != 4 || self->num_col != 4) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.decompose(): "
 		                "inappropriate matrix size - expects 4x4 matrix");
@@ -1075,7 +1077,7 @@ static PyObject *Matrix_decompose(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	mat4_to_loc_rot_size(loc, rot, size, (float (*)[4])self->contigPtr);
+	mat4_to_loc_rot_size(loc, rot, size, (float (*)[4])self->matrix);
 	mat3_to_quat(quat, rot);
 
 	ret= PyTuple_New(3);
@@ -1108,7 +1110,7 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
 	if (!PyArg_ParseTuple(args, "O!f:lerp", &matrix_Type, &mat2, &fac))
 		return NULL;
 
-	if (self->row_size != mat2->row_size || self->col_size != mat2->col_size) {
+	if (self->num_col != mat2->num_col || self->num_row != mat2->num_row) {
 		PyErr_SetString(PyExc_ValueError,
 		                "Matrix.lerp(): "
 		                "expects both matrix objects of the same dimensions");
@@ -1119,11 +1121,11 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
 		return NULL;
 
 	/* TODO, different sized matrix */
-	if (self->row_size==4 && self->col_size==4) {
-		blend_m4_m4m4((float (*)[4])mat, (float (*)[4])self->contigPtr, (float (*)[4])mat2->contigPtr, fac);
+	if (self->num_col==4 && self->num_row==4) {
+		blend_m4_m4m4((float (*)[4])mat, (float (*)[4])self->matrix, (float (*)[4])mat2->matrix, fac);
 	}
-	else if (self->row_size==3 && self->col_size==3) {
-		blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->contigPtr, (float (*)[3])mat2->contigPtr, fac);
+	else if (self->num_col==3 && self->num_row==3) {
+		blend_m3_m3m3((float (*)[3])mat, (float (*)[3])self->matrix, (float (*)[3])mat2->matrix, fac);
 	}
 	else {
 		PyErr_SetString(PyExc_ValueError,
@@ -1132,7 +1134,7 @@ static PyObject *Matrix_lerp(MatrixObject *self, PyObject *args)
 		return NULL;
 	}
 
-	return Matrix_CreatePyObject(mat, self->row_size, self->col_size, Py_NEW, Py_TYPE(self));
+	return Matrix_CreatePyObject(mat, self->num_col, self->num_row, Py_NEW, Py_TYPE(self));
 }
 
 /*---------------------------matrix.determinant() ----------------*/
@@ -1151,7 +1153,7 @@ static PyObject *Matrix_determinant(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if (self->row_size != self->col_size) {
+	if (self->num_col != self->num_row) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.determinant(): "
 		                "only square matrices are supported");
@@ -1173,23 +1175,23 @@ static PyObject *Matrix_transpose(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if (self->row_size != self->col_size) {
+	if (self->num_col != self->num_row) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.transpose(d): "
 		                "only square matrices are supported");
 		return NULL;
 	}
 
-	if (self->row_size == 2) {
+	if (self->num_col == 2) {
 		const float t = MATRIX_ITEM(self, 1, 0);
 		MATRIX_ITEM(self, 1, 0) = MATRIX_ITEM(self, 0, 1);
 		MATRIX_ITEM(self, 0, 1) = t;
 	}
-	else if (self->row_size == 3) {
-		transpose_m3((float (*)[3])self->contigPtr);
+	else if (self->num_col == 3) {
+		transpose_m3((float (*)[3])self->matrix);
 	}
 	else {
-		transpose_m4((float (*)[4])self->contigPtr);
+		transpose_m4((float (*)[4])self->matrix);
 	}
 
 	(void)BaseMath_WriteCallback(self);
@@ -1220,7 +1222,7 @@ PyDoc_STRVAR(Matrix_zero_doc,
 );
 static PyObject *Matrix_zero(MatrixObject *self)
 {
-	fill_vn_fl(self->contigPtr, self->row_size * self->col_size, 0.0f);
+	fill_vn_fl(self->matrix, self->num_col * self->num_row, 0.0f);
 
 	if (BaseMath_WriteCallback(self) == -1)
 		return NULL;
@@ -1243,24 +1245,24 @@ static PyObject *Matrix_identity(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if (self->row_size != self->col_size) {
+	if (self->num_col != self->num_row) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix.identity(): "
 		                "only square matrices are supported");
 		return NULL;
 	}
 
-	if (self->row_size == 2) {
+	if (self->num_col == 2) {
 		MATRIX_ITEM(self, 0, 0) = 1.0f;
 		MATRIX_ITEM(self, 0, 1) = 0.0f;
 		MATRIX_ITEM(self, 1, 0) = 0.0f;
 		MATRIX_ITEM(self, 1, 1) = 1.0f;
 	}
-	else if (self->row_size == 3) {
-		unit_m3((float (*)[3])self->contigPtr);
+	else if (self->num_col == 3) {
+		unit_m3((float (*)[3])self->matrix);
 	}
 	else {
-		unit_m4((float (*)[4])self->contigPtr);
+		unit_m4((float (*)[4])self->matrix);
 	}
 
 	if (BaseMath_WriteCallback(self) == -1)
@@ -1283,26 +1285,26 @@ static PyObject *Matrix_copy(MatrixObject *self)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	return Matrix_CreatePyObject((float (*))self->contigPtr, self->row_size, self->col_size, Py_NEW, Py_TYPE(self));
+	return Matrix_CreatePyObject((float (*))self->matrix, self->num_col, self->num_row, Py_NEW, Py_TYPE(self));
 }
 
 /*----------------------------print object (internal)-------------*/
 /*print the object to screen*/
 static PyObject *Matrix_repr(MatrixObject *self)
 {
-	int x, y;
+	int col, row;
 	PyObject *rows[MATRIX_MAX_DIM]= {NULL};
 
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	for (x = 0; x < self->row_size; x++) {
-		rows[x]= PyTuple_New(self->col_size);
-		for (y = 0; y < self->col_size; y++) {
-			PyTuple_SET_ITEM(rows[x], y, PyFloat_FromDouble(MATRIX_ITEM(self, x, y)));
+	for (col = 0; col < self->num_col; col++) {
+		rows[col]= PyTuple_New(self->num_row);
+		for (row = 0; row < self->num_row; row++) {
+			PyTuple_SET_ITEM(rows[col], row, PyFloat_FromDouble(MATRIX_ITEM(self, row, col)));
 		}
 	}
-	switch (self->row_size) {
+	switch (self->num_col) {
 	case 2:	return PyUnicode_FromFormat("Matrix((%R,\n"
 										"        %R))", rows[0], rows[1]);
 
@@ -1320,6 +1322,42 @@ static PyObject *Matrix_repr(MatrixObject *self)
 	return NULL;
 }
 
+static PyObject* Matrix_str(MatrixObject *self)
+{
+	DynStr *ds;
+
+	int maxsize[MATRIX_MAX_DIM];
+	int row, col;
+
+	char dummy_buf[1];
+
+	if (BaseMath_ReadCallback(self) == -1)
+		return NULL;
+
+	ds= BLI_dynstr_new();
+
+	/* First determine the maximum width for each column */
+	for (col = 0; col < self->num_col; col++) {
+		maxsize[col]= 0;
+		for (row = 0; row < self->num_row; row++) {
+			int size= BLI_snprintf(dummy_buf, sizeof(dummy_buf), "%.4f", MATRIX_ITEM(self, row, col));
+			maxsize[col]= MAX2(maxsize[col], size);
+		}
+	}
+
+	/* Now write the unicode string to be printed */
+	BLI_dynstr_appendf(ds, "<Matrix %dx%d (", self->num_row, self->num_col);
+	for (row = 0; row < self->num_row; row++) {
+		for (col = 0; col < self->num_col; col++) {
+			BLI_dynstr_appendf(ds, col ? ", %*.4f" : "%*.4f", maxsize[col], MATRIX_ITEM(self, row, col));
+		}
+		BLI_dynstr_append(ds, row + 1 != self->num_row ? ")\n             " : ")");
+	}
+	BLI_dynstr_append(ds, ">");
+
+	return mathutils_dynstr_to_py(ds); /* frees ds */
+}
+
 static PyObject* Matrix_richcmpr(PyObject *a, PyObject *b, int op)
 {
 	PyObject *res;
@@ -1332,9 +1370,9 @@ static PyObject* Matrix_richcmpr(PyObject *a, PyObject *b, int op)
 		if (BaseMath_ReadCallback(matA) == -1 || BaseMath_ReadCallback(matB) == -1)
 			return NULL;
 
-		ok=	(	(matA->col_size == matB->col_size) &&
-				(matA->row_size == matB->row_size) &&
-				EXPP_VectorsAreEqual(matA->contigPtr, matB->contigPtr, (matA->row_size * matA->col_size), 1)
+		ok=	(	(matA->num_row == matB->num_row) &&
+				(matA->num_col == matB->num_col) &&
+				EXPP_VectorsAreEqual(matA->matrix, matB->matrix, (matA->num_col * matA->num_row), 1)
 			) ? 0 : -1;
 	}
 
@@ -1364,7 +1402,7 @@ static PyObject* Matrix_richcmpr(PyObject *a, PyObject *b, int op)
   sequence length*/
 static int Matrix_len(MatrixObject *self)
 {
-	return (self->row_size);
+	return (self->num_col);
 }
 /*----------------------------object[]---------------------------
   sequence accessor (get)
@@ -1374,13 +1412,13 @@ static PyObject *Matrix_item(MatrixObject *self, int i)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	if (i < 0 || i >= self->row_size) {
+	if (i < 0 || i >= self->num_col) {
 		PyErr_SetString(PyExc_IndexError,
 		                "matrix[attribute]: "
 		                "array index out of range");
 		return NULL;
 	}
-	return Vector_CreatePyObject_cb((PyObject *)self, self->col_size, mathutils_matrix_vector_cb_index, i);
+	return Vector_CreatePyObject_cb((PyObject *)self, self->num_row, mathutils_matrix_vector_cb_index, i);
 }
 /*----------------------------object[]-------------------------
   sequence accessor (set) */
@@ -1391,17 +1429,17 @@ static int Matrix_ass_item(MatrixObject *self, int i, PyObject *value)
 	if (BaseMath_ReadCallback(self) == -1)
 		return -1;
 
-	if (i >= self->row_size || i < 0) {
+	if (i >= self->num_col || i < 0) {
 		PyErr_SetString(PyExc_IndexError,
 		                "matrix[attribute] = x: bad column");
 		return -1;
 	}
 
-	if (mathutils_array_parse(vec, self->col_size, self->col_size, value, "matrix[i] = value assignment") < 0) {
+	if (mathutils_array_parse(vec, self->num_row, self->num_row, value, "matrix[i] = value assignment") < 0) {
 		return -1;
 	}
 
-	memcpy(MATRIX_ROW_PTR(self, i), vec, self->col_size * sizeof(float));
+	memcpy(MATRIX_COL_PTR(self, i), vec, self->num_row * sizeof(float));
 
 	(void)BaseMath_WriteCallback(self);
 	return 0;
@@ -1418,14 +1456,14 @@ static PyObject *Matrix_slice(MatrixObject *self, int begin, int end)
 	if (BaseMath_ReadCallback(self) == -1)
 		return NULL;
 
-	CLAMP(begin, 0, self->row_size);
-	CLAMP(end, 0, self->row_size);
+	CLAMP(begin, 0, self->num_col);
+	CLAMP(end, 0, self->num_col);
 	begin= MIN2(begin, end);
 
 	tuple= PyTuple_New(end - begin);
 	for (count= begin; count < end; count++) {
 		PyTuple_SET_ITEM(tuple, count - begin,
-				Vector_CreatePyObject_cb((PyObject *)self, self->col_size, mathutils_matrix_vector_cb_index, count));
+				Vector_CreatePyObject_cb((PyObject *)self, self->num_row, mathutils_matrix_vector_cb_index, count));
 
 	}
 
@@ -1440,8 +1478,8 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
 	if (BaseMath_ReadCallback(self) == -1)
 		return -1;
 
-	CLAMP(begin, 0, self->row_size);
-	CLAMP(end, 0, self->row_size);
+	CLAMP(begin, 0, self->num_col);
+	CLAMP(end, 0, self->num_col);
 	begin = MIN2(begin, end);
 
 	/* non list/tuple cases */
@@ -1467,7 +1505,7 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
 			/*parse each sub sequence*/
 			PyObject *item= PySequence_Fast_GET_ITEM(value_fast, i);
 
-			if (mathutils_array_parse(&mat[i * self->col_size], self->col_size, self->col_size, item,
+			if (mathutils_array_parse(&mat[i * self->num_row], self->num_row, self->num_row, item,
 			                          "matrix[begin:end] = value assignment") < 0)
 			{
 				return -1;
@@ -1477,7 +1515,7 @@ static int Matrix_ass_slice(MatrixObject *self, int begin, int end, PyObject *va
 		Py_DECREF(value_fast);
 
 		/*parsed well - now set in matrix*/
-		memcpy(self->contigPtr + (begin * self->col_size), mat, sizeof(float) * (size * self->col_size));
+		memcpy(self->matrix + (begin * self->num_row), mat, sizeof(float) * (size * self->num_row));
 
 		(void)BaseMath_WriteCallback(self);
 		return 0;
@@ -1504,16 +1542,16 @@ static PyObject *Matrix_add(PyObject *m1, PyObject *m2)
 	if (BaseMath_ReadCallback(mat1) == -1 || BaseMath_ReadCallback(mat2) == -1)
 		return NULL;
 
-	if (mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size) {
+	if (mat1->num_col != mat2->num_col || mat1->num_row != mat2->num_row) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix addition: "
 		                "matrices must have the same dimensions for this operation");
 		return NULL;
 	}
 
-	add_vn_vnvn(mat, mat1->contigPtr, mat2->contigPtr, mat1->row_size * mat1->col_size);
+	add_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->num_col * mat1->num_row);
 
-	return Matrix_CreatePyObject(mat, mat1->row_size, mat1->col_size, Py_NEW, Py_TYPE(mat1));
+	return Matrix_CreatePyObject(mat, mat1->num_col, mat1->num_row, Py_NEW, Py_TYPE(mat1));
 }
 /*------------------------obj - obj------------------------------
   subtraction*/
@@ -1537,24 +1575,24 @@ static PyObject *Matrix_sub(PyObject *m1, PyObject *m2)
 	if (BaseMath_ReadCallback(mat1) == -1 || BaseMath_ReadCallback(mat2) == -1)
 		return NULL;
 
-	if (mat1->row_size != mat2->row_size || mat1->col_size != mat2->col_size) {
+	if (mat1->num_col != mat2->num_col || mat1->num_row != mat2->num_row) {
 		PyErr_SetString(PyExc_TypeError,
 		                "Matrix addition: "
 		                "matrices must have the same dimensions for this operation");
 		return NULL;
 	}
 
-	sub_vn_vnvn(mat, mat1->contigPtr, mat2->contigPtr, mat1->row_size * mat1->col_size);
+	sub_vn_vnvn(mat, mat1->matrix, mat2->matrix, mat1->num_col * mat1->num_row);
 
-	return Matrix_CreatePyObject(mat, mat1->row_size, mat1->col_size, Py_NEW, Py_TYPE(mat1));
+	return Matrix_CreatePyObject(mat, mat1->num_col, mat1->num_row, Py_NEW, Py_TYPE(mat1));
 }
 /*------------------------obj * obj------------------------------
   mulplication*/
 static PyObject *matrix_mul_float(MatrixObject *mat, const float scalar)
 {
 	float tmat[16];
-	mul_vn_vn_fl(tmat, mat->contigPtr, mat->row_size * mat->col_size, scalar);
-	return Matrix_CreatePyObject(tmat, mat->row_size, mat->col_size, Py_NEW, Py_TYPE(mat));
+	mul_vn_vn_fl(tmat, mat->matrix, mat->num_col * mat->num_row, scalar);
+	return Matrix_CreatePyObject(tmat, mat->num_col, mat->num_row, Py_NEW, Py_TYPE(mat));
 }
 
 static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
@@ -1581,19 +1619,19 @@ static PyObject *Matrix_mul(PyObject *m1, PyObject *m2)
 						0.0f, 0.0f, 0.0f, 0.0f,
 						0.0f, 0.0f, 0.0f, 1.0f};
 		double dot = 0.0f;
-		int x, y, z;
+		int col, row, item;
 
-		for (x = 0; x < mat2->row_size; x++) {
-			for (y = 0; y < mat1->col_size; y++) {
-				for (z = 0; z < mat1->row_size; z++) {
-					dot += MATRIX_ITEM(mat1, z, y) * MATRIX_ITEM(mat2, x, z);
+		for (col = 0; col < mat2->num_col; col++) {
+			for (row = 0; row < mat1->num_row; row++) {
+				for (item = 0; item < mat1->num_col; item++) {
+					dot += MATRIX_ITEM(mat1, row, item) * MATRIX_ITEM(mat2, item, col);
 				}
-				mat[((x * mat1->col_size) + y)] = (float)dot;
+				mat[((col * mat1->num_row) + row)] = (float)dot;
 				dot = 0.0f;
 			}
 		}
 
-		return Matrix_CreatePyObject(mat, mat2->row_size, mat1->col_size, Py_NEW, Py_TYPE(mat1));
+		return Matrix_CreatePyObject(mat, mat2->num_col, mat1->num_row, Py_NEW, Py_TYPE(mat1));
 	}
 	else if (mat2) {
 		/*FLOAT/INT * MATRIX */
@@ -1660,13 +1698,13 @@ static PyObject *Matrix_subscript(MatrixObject* self, PyObject* item)
 		if (i == -1 && PyErr_Occurred())
 			return NULL;
 		if (i < 0)
-			i += self->row_size;
+			i += self->num_col;
 		return Matrix_item(self, i);
 	}
 	else if (PySlice_Check(item)) {
 		Py_ssize_t start, stop, step, slicelength;
 
-		if (PySlice_GetIndicesEx((void *)item, self->row_size, &start, &stop, &step, &slicelength) < 0)
+		if (PySlice_GetIndicesEx((void *)item, self->num_col, &start, &stop, &step, &slicelength) < 0)
 			return NULL;
 
 		if (slicelength <= 0) {
@@ -1696,13 +1734,13 @@ static int Matrix_ass_subscript(MatrixObject* self, PyObject* item, PyObject* va
 		if (i == -1 && PyErr_Occurred())
 			return -1;
 		if (i < 0)
-			i += self->row_size;
+			i += self->num_col;
 		return Matrix_ass_item(self, i, value);
 	}
 	else if (PySlice_Check(item)) {
 		Py_ssize_t start, stop, step, slicelength;
 
-		if (PySlice_GetIndicesEx((void *)item, self->row_size, &start, &stop, &step, &slicelength) < 0)
+		if (PySlice_GetIndicesEx((void *)item, self->num_col, &start, &stop, &step, &slicelength) < 0)
 			return -1;
 
 		if (step == 1)
@@ -1767,12 +1805,12 @@ static PyNumberMethods Matrix_NumMethods = {
 
 static PyObject *Matrix_getRowSize(MatrixObject *self, void *UNUSED(closure))
 {
-	return PyLong_FromLong((long) self->row_size);
+	return PyLong_FromLong((long) self->num_col);
 }
 
 static PyObject *Matrix_getColSize(MatrixObject *self, void *UNUSED(closure))
 {
-	return PyLong_FromLong((long) self->col_size);
+	return PyLong_FromLong((long) self->num_row);
 }
 
 static PyObject *Matrix_median_scale_get(MatrixObject *self, void *UNUSED(closure))
@@ -1783,7 +1821,7 @@ static PyObject *Matrix_median_scale_get(MatrixObject *self, void *UNUSED(closur
 		return NULL;
 
 	/*must be 3-4 cols, 3-4 rows, square matrix*/
-	if ((self->col_size < 3) || (self->row_size < 3)) {
+	if ((self->num_row < 3) || (self->num_col < 3)) {
 		PyErr_SetString(PyExc_AttributeError,
 		                "Matrix.median_scale: "
 		                "inappropriate matrix size, 3x3 minimum");
@@ -1801,10 +1839,10 @@ static PyObject *Matrix_is_negative_get(MatrixObject *self, void *UNUSED(closure
 		return NULL;
 
 	/*must be 3-4 cols, 3-4 rows, square matrix*/
-	if (self->col_size == 4 && self->row_size == 4)
-		return PyBool_FromLong(is_negative_m4((float (*)[4])self->contigPtr));
-	else if (self->col_size == 3 && self->row_size == 3)
-		return PyBool_FromLong(is_negative_m3((float (*)[3])self->contigPtr));
+	if (self->num_row == 4 && self->num_col == 4)
+		return PyBool_FromLong(is_negative_m4((float (*)[4])self->matrix));
+	else if (self->num_row == 3 && self->num_col == 3)
+		return PyBool_FromLong(is_negative_m3((float (*)[3])self->matrix));
 	else {
 		PyErr_SetString(PyExc_AttributeError,
 		                "Matrix.is_negative: "
@@ -1819,10 +1857,10 @@ static PyObject *Matrix_is_orthogonal_get(MatrixObject *self, void *UNUSED(closu
 		return NULL;
 
 	/*must be 3-4 cols, 3-4 rows, square matrix*/
-	if (self->col_size == 4 && self->row_size == 4)
-		return PyBool_FromLong(is_orthogonal_m4((float (*)[4])self->contigPtr));
-	else if (self->col_size == 3 && self->row_size == 3)
-		return PyBool_FromLong(is_orthogonal_m3((float (*)[3])self->contigPtr));
+	if (self->num_row == 4 && self->num_col == 4)
+		return PyBool_FromLong(is_orthogonal_m4((float (*)[4])self->matrix));
+	else if (self->num_row == 3 && self->num_col == 3)
+		return PyBool_FromLong(is_orthogonal_m3((float (*)[3])self->matrix));
 	else {
 		PyErr_SetString(PyExc_AttributeError,
 		                "Matrix.is_orthogonal: "
@@ -1906,7 +1944,7 @@ PyTypeObject matrix_Type = {
 	&Matrix_AsMapping,					/*tp_as_mapping*/
 	NULL,								/*tp_hash*/
 	NULL,								/*tp_call*/
-	NULL,								/*tp_str*/
+	(reprfunc) Matrix_str,				/*tp_str*/
 	NULL,								/*tp_getattro*/
 	NULL,								/*tp_setattro*/
 	NULL,								/*tp_as_buffer*/
@@ -1944,37 +1982,37 @@ PyTypeObject matrix_Type = {
  * pass Py_NEW - if vector is not a WRAPPER and managed by PYTHON
  * (i.e. it must be created here with PyMEM_malloc()) */
 PyObject *Matrix_CreatePyObject(float *mat,
-                                const unsigned short row_size, const unsigned short col_size,
+                                const unsigned short num_col, const unsigned short num_row,
                                 int type, PyTypeObject *base_type)
 {
 	MatrixObject *self;
 
 	/* matrix objects can be any 2-4row x 2-4col matrix */
-	if (row_size < 2 || row_size > 4 || col_size < 2 || col_size > 4) {
+	if (num_col < 2 || num_col > 4 || num_row < 2 || num_row > 4) {
 		PyErr_SetString(PyExc_RuntimeError,
 		                "Matrix(): "
 		                "row and column sizes must be between 2 and 4");
 		return NULL;
 	}
 
-	self= base_type ?	(MatrixObject *)base_type->tp_alloc(base_type, 0) :
-						(MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type);
+	self= base_type ? (MatrixObject *)base_type->tp_alloc(base_type, 0) :
+	                  (MatrixObject *)PyObject_GC_New(MatrixObject, &matrix_Type);
 
 	if (self) {
-		self->row_size = row_size;
-		self->col_size = col_size;
+		self->num_col = num_col;
+		self->num_row = num_row;
 
 		/* init callbacks as NULL */
 		self->cb_user= NULL;
 		self->cb_type= self->cb_subtype= 0;
 
 		if (type == Py_WRAP) {
-			self->contigPtr = mat;
+			self->matrix = mat;
 			self->wrapped = Py_WRAP;
 		}
 		else if (type == Py_NEW) {
-			self->contigPtr = PyMem_Malloc(row_size * col_size * sizeof(float));
-			if (self->contigPtr == NULL) { /*allocation failure*/
+			self->matrix = PyMem_Malloc(num_col * num_row * sizeof(float));
+			if (self->matrix == NULL) { /*allocation failure*/
 				PyErr_SetString(PyExc_MemoryError,
 				                "Matrix(): "
 				                "problem allocating pointer space");
@@ -1982,16 +2020,16 @@ PyObject *Matrix_CreatePyObject(float *mat,
 			}
 
 			if (mat) {	/*if a float array passed*/
-				memcpy(self->contigPtr, mat, row_size * col_size * sizeof(float));
+				memcpy(self->matrix, mat, num_col * num_row * sizeof(float));
 			}
-			else if (row_size == col_size) {
+			else if (num_col == num_row) {
 				/* or if no arguments are passed return identity matrix for square matrices */
 				PyObject *ret_dummy= Matrix_identity(self);
 				Py_DECREF(ret_dummy);
 			}
 			else {
 				/* otherwise zero everything */
-				memset(self->contigPtr, 0, row_size * col_size * sizeof(float));
+				memset(self->matrix, 0, num_col * num_row * sizeof(float));
 			}
 			self->wrapped = Py_NEW;
 		}
diff --git a/source/blender/python/mathutils/mathutils_Matrix.h b/source/blender/python/mathutils/mathutils_Matrix.h
index 95768febca0..91a276b648e 100644
--- a/source/blender/python/mathutils/mathutils_Matrix.h
+++ b/source/blender/python/mathutils/mathutils_Matrix.h
@@ -41,22 +41,22 @@ extern PyTypeObject matrix_Type;
 /* matrix[row][col] == MATRIX_ITEM_INDEX(matrix, row, col) */
 
 #ifdef DEBUG
-#  define MATRIX_ITEM_ASSERT(_mat, _row, _col) (BLI_assert(_row < (_mat)->row_size && _col < (_mat)->col_size))
+#  define MATRIX_ITEM_ASSERT(_mat, _row, _col) (BLI_assert(_row < (_mat)->num_row && _col < (_mat)->num_col))
 #else
 #  define MATRIX_ITEM_ASSERT(_mat, _row, _col) (void)0
 #endif
 
-#define MATRIX_ITEM_INDEX(_mat, _row, _col) (MATRIX_ITEM_ASSERT(_mat, _row, _col),(((_mat)->col_size * (_row)) + (_col)))
-#define MATRIX_ITEM_PTR(  _mat, _row, _col) ((_mat)->contigPtr + MATRIX_ITEM_INDEX(_mat, _row, _col))
-#define MATRIX_ITEM(      _mat, _row, _col) ((_mat)->contigPtr  [MATRIX_ITEM_INDEX(_mat, _row, _col)])
+#define MATRIX_ITEM_INDEX(_mat, _row, _col) (MATRIX_ITEM_ASSERT(_mat, _row, _col),(((_mat)->num_row * (_col)) + (_row)))
+#define MATRIX_ITEM_PTR(  _mat, _row, _col) ((_mat)->matrix + MATRIX_ITEM_INDEX(_mat, _row, _col))
+#define MATRIX_ITEM(      _mat, _row, _col) ((_mat)->matrix  [MATRIX_ITEM_INDEX(_mat, _row, _col)])
 
-#define MATRIX_ROW_INDEX(_mat, _row) (MATRIX_ITEM_INDEX(_mat, _row, 0))
-#define MATRIX_ROW_PTR(  _mat, _row) ((_mat)->contigPtr + MATRIX_ROW_INDEX(_mat, _row))
+#define MATRIX_COL_INDEX(_mat, _col) (MATRIX_ITEM_INDEX(_mat, 0, _col))
+#define MATRIX_COL_PTR(  _mat, _col) ((_mat)->matrix + MATRIX_COL_INDEX(_mat, _col))
 
 typedef struct {
-	BASE_MATH_MEMBERS(contigPtr);
-	unsigned short row_size;
-	unsigned short col_size;
+	BASE_MATH_MEMBERS(matrix);
+	unsigned short num_col;
+	unsigned short num_row;
 } MatrixObject;
 
 /* struct data contains a pointer to the actual data that the
@@ -66,9 +66,9 @@ typedef struct {
 
 /* prototypes */
 PyObject *Matrix_CreatePyObject(float *mat,
-                                const unsigned short row_size, const unsigned short col_size,
+                                const unsigned short num_col, const unsigned short num_row,
                                 int type, PyTypeObject *base_type);
-PyObject *Matrix_CreatePyObject_cb(PyObject *user, int row_size, int col_size, int cb_type, int cb_subtype);
+PyObject *Matrix_CreatePyObject_cb(PyObject *user, int num_col, int num_row, int cb_type, int cb_subtype);
 
 extern int mathutils_matrix_vector_cb_index;
 extern struct Mathutils_Callback mathutils_matrix_vector_cb;
diff --git a/source/blender/python/mathutils/mathutils_Quaternion.c b/source/blender/python/mathutils/mathutils_Quaternion.c
index 7ab9b7b0713..7c339807ee9 100644
--- a/source/blender/python/mathutils/mathutils_Quaternion.c
+++ b/source/blender/python/mathutils/mathutils_Quaternion.c
@@ -35,6 +35,7 @@
 
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
+#include "BLI_dynstr.h"
 
 #define QUAT_SIZE 4
 
@@ -493,6 +494,21 @@ static PyObject *Quaternion_repr(QuaternionObject *self)
 	return ret;
 }
 
+static PyObject *Quaternion_str(QuaternionObject *self)
+{
+	DynStr *ds;
+
+	if (BaseMath_ReadCallback(self) == -1)
+		return NULL;
+
+	ds= BLI_dynstr_new();
+
+	BLI_dynstr_appendf(ds, "<Quaternion (w=%.4f, x=%.4f, y=%.4f, z=%.4f)>",
+	                   self->quat[0], self->quat[1], self->quat[2], self->quat[3]);
+
+	return mathutils_dynstr_to_py(ds); /* frees ds */
+}
+
 static PyObject* Quaternion_richcmpr(PyObject *a, PyObject *b, int op)
 {
 	PyObject *res;
@@ -1167,7 +1183,7 @@ PyTypeObject quaternion_Type = {
 	&Quaternion_AsMapping,			//tp_as_mapping
 	NULL,								//tp_hash
 	NULL,								//tp_call
-	NULL,								//tp_str
+	(reprfunc) Quaternion_str,			//tp_str
 	NULL,								//tp_getattro
 	NULL,								//tp_setattro
 	NULL,								//tp_as_buffer
diff --git a/source/blender/python/mathutils/mathutils_Vector.c b/source/blender/python/mathutils/mathutils_Vector.c
index aedf60e7191..25760910c4e 100644
--- a/source/blender/python/mathutils/mathutils_Vector.c
+++ b/source/blender/python/mathutils/mathutils_Vector.c
@@ -35,6 +35,7 @@
 
 #include "BLI_math.h"
 #include "BLI_utildefines.h"
+#include "BLI_dynstr.h"
 
 #define MAX_DIMENSIONS 4
 
@@ -1171,6 +1172,29 @@ static PyObject *Vector_repr(VectorObject *self)
 	return ret;
 }
 
+static PyObject *Vector_str(VectorObject *self)
+{
+	int i;
+
+	DynStr *ds;
+
+	if (BaseMath_ReadCallback(self) == -1)
+		return NULL;
+
+	ds= BLI_dynstr_new();
+
+	BLI_dynstr_append(ds, "<Vector (");
+
+	for (i = 0; i < self->size; i++) {
+		BLI_dynstr_appendf(ds, i ? ", %.4f" : "%.4f", self->vec[i]);
+	}
+
+	BLI_dynstr_append(ds, ")>");
+
+	return mathutils_dynstr_to_py(ds); /* frees ds */
+}
+
+
 /* Sequence Protocol */
 /* sequence length len(vector) */
 static int Vector_len(VectorObject *self)
@@ -1468,8 +1492,8 @@ int column_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject* vec,
 	double dot = 0.0f;
 	int x, y, z = 0;
 
-	if (mat->row_size != vec->size) {
-		if (mat->row_size == 4 && vec->size == 3) {
+	if (mat->num_col != vec->size) {
+		if (mat->num_col == 4 && vec->size == 3) {
 			vec_cpy[3] = 1.0f;
 		}
 		else {
@@ -1485,8 +1509,8 @@ int column_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject* vec,
 
 	rvec[3] = 1.0f;
 
-	for (x = 0; x < mat->col_size; x++) {
-		for (y = 0; y < mat->row_size; y++) {
+	for (x = 0; x < mat->num_row; x++) {
+		for (y = 0; y < mat->num_col; y++) {
 			dot += (double)(MATRIX_ITEM(mat, y, x) * vec_cpy[y]);
 		}
 		rvec[z++] = (float)dot;
@@ -2589,8 +2613,8 @@ static int row_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject *v
 	double dot = 0.0f;
 	int x, y, z= 0, vec_size= vec->size;
 
-	if (mat->col_size != vec_size) {
-		if (mat->col_size == 4 && vec_size != 3) {
+	if (mat->num_row != vec_size) {
+		if (mat->num_row == 4 && vec_size != 3) {
 			PyErr_SetString(PyExc_ValueError,
 			                "vector * matrix: matrix column size "
 			                "and the vector size must be the same");
@@ -2608,8 +2632,8 @@ static int row_vector_multiplication(float rvec[MAX_DIMENSIONS], VectorObject *v
 
 	rvec[3] = 1.0f;
 	//muliplication
-	for (x = 0; x < mat->row_size; x++) {
-		for (y = 0; y < mat->col_size; y++) {
+	for (x = 0; x < mat->num_col; x++) {
+		for (y = 0; y < mat->num_row; y++) {
 			dot += MATRIX_ITEM(mat, x, y) * vec_cpy[y];
 		}
 		rvec[z++] = (float)dot;
@@ -2715,7 +2739,7 @@ PyTypeObject vector_Type = {
 
 	NULL,                       /* hashfunc tp_hash; */
 	NULL,                       /* ternaryfunc tp_call; */
-	NULL,                       /* reprfunc tp_str; */
+	(reprfunc)Vector_str,       /* reprfunc tp_str; */
 	NULL,                       /* getattrofunc tp_getattro; */
 	NULL,                       /* setattrofunc tp_setattro; */