Python operators

- simplified C operator API bpy.__ops__ since its wrapped by python now.
- needs the class to have an __idname__ rather then __name__ (like menus, headers)
- convert python names "console.exec" into blender names "CONSOLE_OT_exec" when registering (store the blender name as class.__idname_bl__, users scripters wont notice)
- bpy.props.props ???, removed

5 files changed, 83 insertions, 112 deletions

diff --git a/source/blender/python/intern/bpy_operator.c b/source/blender/python/intern/bpy_operator.c
index b57ef54304b..240ce2030ba 100644
--- a/source/blender/python/intern/bpy_operator.c
+++ b/source/blender/python/intern/bpy_operator.c
@@ -23,65 +23,79 @@
  * ***** END GPL LICENSE BLOCK *****
  */
 
+/* Note, this module is not to be used directly by the user.
+ * its accessed from blender with bpy.__ops__
+ * */
+
 #include "bpy_operator.h"
 #include "bpy_operator_wrap.h"
 #include "bpy_rna.h" /* for setting arg props only - pyrna_py_to_prop() */
 #include "bpy_compat.h"
 #include "bpy_util.h"
 
-//#include "blendef.h"
-#include "BLI_dynstr.h"
-
 #include "WM_api.h"
 #include "WM_types.h"
 
 #include "MEM_guardedalloc.h"
-//#include "BKE_idprop.h"
 #include "BKE_report.h"
 
-extern ListBase global_ops; /* evil, temp use */
-
-static PyObject *pyop_base_dir(PyObject *self);
-static PyObject *pyop_base_rna(PyObject *self, PyObject *pyname);
-static struct PyMethodDef pyop_base_methods[] = {
-	{"__dir__", (PyCFunction)pyop_base_dir, METH_NOARGS, ""},
-	{"__rna__", (PyCFunction)pyop_base_rna, METH_O, ""},
-	{"add", (PyCFunction)PYOP_wrap_add, METH_O, ""},
-	{"remove", (PyCFunction)PYOP_wrap_remove, METH_O, ""},
-	{NULL, NULL, 0, NULL}
-};
 
 /* 'self' stores the operator string */
-static PyObject *pyop_base_call( PyObject * self, PyObject * args,  PyObject * kw)
+static PyObject *pyop_call( PyObject * self, PyObject * args)
 {
 	wmOperatorType *ot;
 	int error_val = 0;
 	PointerRNA ptr;
 	
+	char *opname;
+	PyObject *kw= NULL;
+
 	// XXX Todo, work out a better solution for passing on context, could make a tuple from self and pack the name and Context into it...
 	bContext *C = BPy_GetContext();
 	
-	char *opname = _PyUnicode_AsString(self);
 
-	if (PyTuple_Size(args)) {
-		PyErr_SetString( PyExc_AttributeError, "All operator args must be keywords");
+	switch(PyTuple_Size(args)) {
+	case 2:
+		kw = PyTuple_GET_ITEM(args, 1);
+
+		if(!PyDict_Check(kw)) {
+			PyErr_SetString( PyExc_AttributeError, "bpy.__ops__.call: expected second arg to be a dict");
+			return NULL;
+		}
+		/* pass through */
+	case 1:
+		opname = _PyUnicode_AsString(PyTuple_GET_ITEM(args, 0));
+
+		if(opname==NULL) {
+			PyErr_SetString( PyExc_AttributeError, "bpy.__ops__.call: expected the first arg to be a string");
+			return NULL;
+		}
+		break;
+	default:
+		PyErr_SetString( PyExc_AttributeError, "bpy.__ops__.call: expected a string and optional dict");
 		return NULL;
 	}
 
+
 	ot= WM_operatortype_find(opname, 1);
+
 	if (ot == NULL) {
-		PyErr_Format( PyExc_SystemError, "Operator \"%s\"could not be found", opname);
+		PyErr_Format( PyExc_SystemError, "bpy.__ops__.call: operator \"%s\"could not be found", opname);
 		return NULL;
 	}
 	
 	if(ot->poll && (ot->poll(C) == 0)) {
-		PyErr_SetString( PyExc_SystemError, "Operator poll() function failed, context is incorrect");
+		PyErr_SetString( PyExc_SystemError, "bpy.__ops__.call: operator poll() function failed, context is incorrect");
 		return NULL;
 	}
 	
-	WM_operator_properties_create(&ptr, opname);
+	/* WM_operator_properties_create(&ptr, opname); */
+	/* Save another lookup */
+	RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
 	
-	error_val= pyrna_pydict_to_props(&ptr, kw, "Converting py args to operator properties: ");
+	if(kw && PyDict_Size(kw))
+		error_val= pyrna_pydict_to_props(&ptr, kw, "Converting py args to operator properties: ");
+
 	
 	if (error_val==0) {
 		ReportList reports;
@@ -118,96 +132,34 @@ static PyObject *pyop_base_call( PyObject * self, PyObject * args,  PyObject * k
 	Py_RETURN_NONE;
 }
 
-static PyMethodDef pyop_base_call_meth[] = {
-	{"__op_call__", (PyCFunction)pyop_base_call, METH_VARARGS|METH_KEYWORDS, "generic operator calling function"}
-};
-
-
-//---------------getattr--------------------------------------------
-static PyObject *pyop_base_getattro( BPy_OperatorBase * self, PyObject *pyname )
-{
-	char *name = _PyUnicode_AsString(pyname);
-	PyObject *ret;
-	wmOperatorType *ot;
-	
-	/* First look for the operator, then our own methods if that fails.
-	 * when methods are searched first, PyObject_GenericGetAttr will raise an error
-	 * each time we want to call an operator, we could clear the error but I prefer
-	 * not to since calling operators is a lot more common then adding and removing. - Campbell */
-	
-	if ((ot= WM_operatortype_find(name, 1))) {
-		ret = PyCFunction_New( pyop_base_call_meth, pyname); /* set the name string as self, PyCFunction_New incref's self */
-	}
-	else if ((ret = PyObject_GenericGetAttr((PyObject *)self, pyname))) {
-		/* do nothing, this accounts for methoddef's add and remove
-		 * An exception is raised when PyObject_GenericGetAttr fails
-		 * but its ok because its overwritten below */
-	}
-	else {
-		PyErr_Format( PyExc_AttributeError, "Operator \"%s\" not found", name);
-		ret= NULL;
-	}
-
-	return ret;
-}
-
-static PyObject *pyop_base_dir(PyObject *self)
+static PyObject *pyop_dir(PyObject *self)
 {
 	PyObject *list = PyList_New(0), *name;
 	wmOperatorType *ot;
-	PyMethodDef *meth;
 	
 	for(ot= WM_operatortype_first(); ot; ot= ot->next) {
 		name = PyUnicode_FromString(ot->idname);
 		PyList_Append(list, name);
 		Py_DECREF(name);
 	}
-
-	for(meth=pyop_base_methods; meth->ml_name; meth++) {
-		name = PyUnicode_FromString(meth->ml_name);
-		PyList_Append(list, name);
-		Py_DECREF(name);
-	}
 	
 	return list;
 }
 
-static PyObject *pyop_base_rna(PyObject *self, PyObject *pyname)
+PyObject *BPY_operator_module( void )
 {
-	char *name = _PyUnicode_AsString(pyname);
-	wmOperatorType *ot;
-	
-	if ((ot= WM_operatortype_find(name, 1))) {
-		BPy_StructRNA *pyrna;
-		PointerRNA ptr;
-		
-		/* XXX POINTER - if this 'ot' is python generated, it could be free'd */
-		RNA_pointer_create(NULL, ot->srna, NULL, &ptr);
-		
-		pyrna= (BPy_StructRNA *)pyrna_struct_CreatePyObject(&ptr); /* were not really using &ptr, overwite next */
-		//pyrna->freeptr= 1;
-		return (PyObject *)pyrna;
-	}
-	else {
-		PyErr_Format(PyExc_AttributeError, "Operator \"%s\" not found", name);
-		return NULL;
-	}
-}
+	static PyMethodDef pyop_call_meth =		{"call", (PyCFunction) pyop_call, METH_VARARGS, NULL};
+	static PyMethodDef pyop_dir_meth =		{"dir", (PyCFunction) pyop_dir, METH_NOARGS, NULL};
+	static PyMethodDef pyop_add_meth =		{"add", (PyCFunction) PYOP_wrap_add, METH_O, NULL};
+	static PyMethodDef pyop_remove_meth =	{"remove", (PyCFunction) PYOP_wrap_remove, METH_O, NULL};
 
-PyTypeObject pyop_base_Type = {NULL};
+	PyObject *submodule = PyModule_New("bpy.__ops__");
+	PyDict_SetItemString(PySys_GetObject("modules"), "bpy.__ops__", submodule);
 
-PyObject *BPY_operator_module( void )
-{
-	pyop_base_Type.tp_name = "OperatorBase";
-	pyop_base_Type.tp_basicsize = sizeof( BPy_OperatorBase );
-	pyop_base_Type.tp_getattro = ( getattrofunc )pyop_base_getattro;
-	pyop_base_Type.tp_flags = Py_TPFLAGS_DEFAULT;
-	pyop_base_Type.tp_methods = pyop_base_methods;
-	
-	if( PyType_Ready( &pyop_base_Type ) < 0 )
-		return NULL;
+	PyModule_AddObject( submodule, "call",	PyCFunction_New(&pyop_call_meth,	NULL) );
+	PyModule_AddObject( submodule, "dir",		PyCFunction_New(&pyop_dir_meth,		NULL) );
+	PyModule_AddObject( submodule, "add",		PyCFunction_New(&pyop_add_meth,		NULL) );
+	PyModule_AddObject( submodule, "remove",	PyCFunction_New(&pyop_remove_meth,	NULL) );
 
-	//submodule = Py_InitModule3( "operator", M_rna_methods, "rna module" );
-	return (PyObject *)PyObject_NEW( BPy_OperatorBase, &pyop_base_Type );
+	return submodule;
 }
-
diff --git a/source/blender/python/intern/bpy_operator_wrap.c b/source/blender/python/intern/bpy_operator_wrap.c
index 9f4137a15c0..02d721739e7 100644
--- a/source/blender/python/intern/bpy_operator_wrap.c
+++ b/source/blender/python/intern/bpy_operator_wrap.c
@@ -44,7 +44,8 @@
 
 #define PYOP_ATTR_PROP			"__props__"
 #define PYOP_ATTR_UINAME		"__label__"
-#define PYOP_ATTR_IDNAME		"__name__"	/* use pythons class name */
+#define PYOP_ATTR_IDNAME		"__idname__"	/* the name given by python */
+#define PYOP_ATTR_IDNAME_BL		"__idname_bl__"	/* our own name converted into blender syntax, users wont see this */
 #define PYOP_ATTR_DESCRIPTION	"__doc__"	/* use pythons docstring */
 #define PYOP_ATTR_REGISTER		"__register__"	/* True/False. if this python operator should be registered */
 
@@ -249,10 +250,9 @@ void PYTHON_OT_wrapper(wmOperatorType *ot, void *userdata)
 	PyObject *props, *item;
 
 	/* identifiers */
-	item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME);
+	item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME_BL);
 	ot->idname= _PyUnicode_AsString(item);
 	Py_DECREF(item);
-	
 
 	item= PyObject_GetAttrString(py_class, PYOP_ATTR_UINAME);
 	if (item) {
@@ -338,16 +338,17 @@ PyObject *PYOP_wrap_add(PyObject *self, PyObject *py_class)
 	
 	
 	char *idname= NULL;
+	char idname_bl[OP_MAX_TYPENAME]; /* converted to blender syntax */
 	int i;
 
 	static struct BPY_class_attr_check pyop_class_attr_values[]= {
-		{PYOP_ATTR_IDNAME,		's', 0,	0},
-		{PYOP_ATTR_UINAME,		's', 0,	BPY_CLASS_ATTR_OPTIONAL},
-		{PYOP_ATTR_PROP,		'l', 0,	BPY_CLASS_ATTR_OPTIONAL},
-		{PYOP_ATTR_DESCRIPTION,	's', 0,	BPY_CLASS_ATTR_NONE_OK},
-		{"execute",	'f', 2,	BPY_CLASS_ATTR_OPTIONAL},
-		{"invoke",	'f', 3,	BPY_CLASS_ATTR_OPTIONAL},
-		{"poll",	'f', 2,	BPY_CLASS_ATTR_OPTIONAL},
+		{PYOP_ATTR_IDNAME,		's', -1, OP_MAX_TYPENAME-3,	0}, /* -3 because a.b -> A_OT_b */
+		{PYOP_ATTR_UINAME,		's', -1,-1,	BPY_CLASS_ATTR_OPTIONAL},
+		{PYOP_ATTR_PROP,		'l', -1,-1,	BPY_CLASS_ATTR_OPTIONAL},
+		{PYOP_ATTR_DESCRIPTION,	's', -1,-1,	BPY_CLASS_ATTR_NONE_OK},
+		{"execute",				'f', 2,	-1, BPY_CLASS_ATTR_OPTIONAL},
+		{"invoke",				'f', 3,	-1, BPY_CLASS_ATTR_OPTIONAL},
+		{"poll",				'f', 2,	-1, BPY_CLASS_ATTR_OPTIONAL},
 		{NULL, 0, 0, 0}
 	};
 
@@ -363,7 +364,18 @@ PyObject *PYOP_wrap_add(PyObject *self, PyObject *py_class)
 	/* class name is used for operator ID - this can be changed later if we want */
 	item= PyObject_GetAttrString(py_class, PYOP_ATTR_IDNAME);
 	idname =  _PyUnicode_AsString(item);
+
+
+	/* annoying conversion! */
+	WM_operator_bl_idname(idname_bl, idname);
+	Py_DECREF(item);
+
+	item= PyUnicode_FromString(idname_bl);
+	PyObject_SetAttrString(py_class, PYOP_ATTR_IDNAME_BL, item);
+	idname =  _PyUnicode_AsString(item);
 	Py_DECREF(item);
+	/* end annoying conversion! */
+
 	
 	/* remove if it already exists */
 	if ((ot=WM_operatortype_exists(idname))) {
diff --git a/source/blender/python/intern/bpy_rna.c b/source/blender/python/intern/bpy_rna.c
index d3f69e4db73..bebb745a27e 100644
--- a/source/blender/python/intern/bpy_rna.c
+++ b/source/blender/python/intern/bpy_rna.c
@@ -2550,7 +2550,7 @@ static struct PyMethodDef props_methods[] = {
 #if PY_VERSION_HEX >= 0x03000000
 static struct PyModuleDef props_module = {
 	PyModuleDef_HEAD_INIT,
-	"bpyprops",
+	"bpy.props",
 	"",
 	-1,/* multiple "initialization" just copies the module dict. */
 	props_methods,
@@ -2567,9 +2567,6 @@ PyObject *BPY_rna_props( void )
 	submodule= Py_InitModule3( "bpy.props", props_methods, "" );
 #endif
 	
-	mod = PyModule_New("props");
-	PyModule_AddObject( submodule, "props", mod );
-	
 	/* INCREF since its its assumed that all these functions return the
 	 * module with a new ref like PyDict_New, since they are passed to
 	  * PyModule_AddObject which steals a ref */
diff --git a/source/blender/python/intern/bpy_util.c b/source/blender/python/intern/bpy_util.c
index b451923e780..3084cc1f871 100644
--- a/source/blender/python/intern/bpy_util.c
+++ b/source/blender/python/intern/bpy_util.c
@@ -304,12 +304,21 @@ int BPY_class_validate(const char *class_type, PyObject *class, PyObject *base_c
 						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a string", class_type, class_attrs->name);
 						return -1;
 					}
+					if(class_attrs->len != -1 && class_attrs->len < PyUnicode_GetSize(item)) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute string to be shorter then %d", class_type, class_attrs->name, class_attrs->len);
+						return -1;
+					}
+
 					break;
 				case 'l':
 					if (PyList_Check(item)==0) {
 						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute to be a list", class_type, class_attrs->name);
 						return -1;
 					}
+					if(class_attrs->len != -1 && class_attrs->len < PyList_GET_SIZE(item)) {
+						PyErr_Format( PyExc_AttributeError, "expected %s class \"%s\" attribute list to be shorter then %d", class_type, class_attrs->name, class_attrs->len);
+						return -1;
+					}
 					break;
 				case 'f':
 					if (PyMethod_Check(item))
diff --git a/source/blender/python/intern/bpy_util.h b/source/blender/python/intern/bpy_util.h
index 6429af67eb0..470dd4c2a45 100644
--- a/source/blender/python/intern/bpy_util.h
+++ b/source/blender/python/intern/bpy_util.h
@@ -59,6 +59,7 @@ typedef struct BPY_class_attr_check {
 	const char	*name;		/* name of the class attribute */
     char		type;		/* 's' = string, 'f' = function, 'l' = list, (add as needed) */
     int			arg_count;	/* only for function types, -1 for undefined, includes self arg */
+    int 		len;		/* only for string types currently */
 	int			flag;		/* other options */
 } BPY_class_attr_check;