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

Python operators

Browse Source 
- 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
This commit is contained in:
Campbell Barton
2009-07-19 13:32:02 +00:00
parent 8efdb04817
commit d9a7e5144f
9 changed files with 99 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
source/blender/python/intern/bpy_operator.c
View File

@@ -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)
{
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;
}
}
PyTypeObject pyop_base_Type = {NULL};
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;
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};
//submodule = Py_InitModule3( "operator", M_rna_methods, "rna module" );
return (PyObject *)PyObject_NEW( BPy_OperatorBase, &pyop_base_Type );
PyObject *submodule = PyModule_New("bpy.__ops__");
PyDict_SetItemString(PySys_GetObject("modules"), "bpy.__ops__", submodule);
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) );
return submodule;
}

32
source/blender/python/intern/bpy_operator_wrap.c
View File

@@ -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))) {

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

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

9
source/blender/python/intern/bpy_util.c
View File

@@ -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))

1
source/blender/python/intern/bpy_util.h
View File

@@ -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;