From 4a86a07f8a8344ce7bd0dce02d8902e33d652a1a Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Sun, 21 Dec 2008 08:53:36 +0000 Subject: wip operator py-api "operator.ED_VIEW3D_OT_viewhome(center=1)" calls the operator, converting keyword args to properties. Need a way to run scripts in the UI for useful testing. Still need to deal with operator exceptions and verifying args against operator options. Added temporary WM_operatortype_first() to allow python to return a list if available operators, can replace this with something better later (operator iterator?) --- source/blender/python/BPY_extern.h | 2 +- source/blender/python/SConscript | 2 +- source/blender/python/intern/bpy_idprop.c | 182 ++++++++++++++ source/blender/python/intern/bpy_idprop.h | 33 +++ source/blender/python/intern/bpy_interface.c | 13 +- source/blender/python/intern/bpy_operator.c | 340 +++++++++++++++++++++++++++ source/blender/python/intern/bpy_operator.h | 54 +++++ 7 files changed, 621 insertions(+), 5 deletions(-) create mode 100644 source/blender/python/intern/bpy_idprop.c create mode 100644 source/blender/python/intern/bpy_idprop.h create mode 100644 source/blender/python/intern/bpy_operator.c create mode 100644 source/blender/python/intern/bpy_operator.h (limited to 'source/blender/python') diff --git a/source/blender/python/BPY_extern.h b/source/blender/python/BPY_extern.h index 1761ce14ed6..8561f9d1b55 100644 --- a/source/blender/python/BPY_extern.h +++ b/source/blender/python/BPY_extern.h @@ -94,7 +94,7 @@ extern "C" { int BPY_menu_do_python( short menutype, int event ); int BPY_menu_do_shortcut( short menutype, unsigned short key, unsigned short modifiers ); int BPY_menu_invoke( struct BPyMenu *pym, short menutype ); - void BPY_run_python_script( const char *filename ); + void BPY_run_python_script( struct bContext *C, const char *filename ); int BPY_run_script(struct Script *script); void BPY_free_compiled_text( struct Text *text ); diff --git a/source/blender/python/SConscript b/source/blender/python/SConscript index 6190ed5c0ec..975b7a7a7e7 100644 --- a/source/blender/python/SConscript +++ b/source/blender/python/SConscript @@ -4,7 +4,7 @@ Import ('env') sources = env.Glob('intern/*.c') incs = '. ../editors/include ../makesdna ../makesrna ../blenlib ../blenkernel ../nodes' -incs += ' ../imbuf ../blenloader ../render/extern/include' +incs += ' ../imbuf ../blenloader ../render/extern/include ../windowmanager' incs += ' #intern/guardedalloc #intern/memutil' incs += ' ' + env['BF_PYTHON_INC'] diff --git a/source/blender/python/intern/bpy_idprop.c b/source/blender/python/intern/bpy_idprop.c new file mode 100644 index 00000000000..e7e8a5fd8b5 --- /dev/null +++ b/source/blender/python/intern/bpy_idprop.c @@ -0,0 +1,182 @@ +/** + * $Id: IDProp.c + * + * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Joseph Eagar, Campbell Barton + * + * ***** END GPL LICENSE BLOCK ***** + */ + + #include "DNA_ID.h" + +#include "BKE_idprop.h" + +#include "bpy_idprop.h" + +#include "MEM_guardedalloc.h" + +#define BSTR_EQ(a, b) (*(a) == *(b) && !strcmp(a, b)) + +static PyObject *EXPP_ReturnPyObjError( PyObject * type, char *error_msg ) +{ /* same as above, just to change its name smoothly */ + PyErr_SetString( type, error_msg ); + return NULL; +} + +static int EXPP_ReturnIntError( PyObject * type, char *error_msg ) +{ + PyErr_SetString( type, error_msg ); + return -1; +} + + +/*returns NULL on success, error string on failure*/ +static char *BPy_IDProperty_Map_ValidateAndCreate(char *name, IDProperty *group, PyObject *ob) +{ + IDProperty *prop = NULL; + IDPropertyTemplate val = {0}; + + if (PyFloat_Check(ob)) { + val.d = PyFloat_AsDouble(ob); + prop = IDP_New(IDP_DOUBLE, val, name); + } else if (PyLong_Check(ob)) { + val.i = (int) PyLong_AsLong(ob); + prop = IDP_New(IDP_INT, val, name); + } else if (PyUnicode_Check(ob)) { + val.str = _PyUnicode_AsString(ob); + prop = IDP_New(IDP_STRING, val, name); + } else if (PySequence_Check(ob)) { + PyObject *item; + int i; + + /*validate sequence and derive type. + we assume IDP_INT unless we hit a float + number; then we assume it's */ + val.array.type = IDP_INT; + val.array.len = PySequence_Length(ob); + for (i=0; idata.pointer)[i] = (int)PyLong_AsLong(item); + } else { + item = PyNumber_Float(item); + ((double*)prop->data.pointer)[i] = (float)PyFloat_AsDouble(item); + } + Py_XDECREF(item); + } + } else if (PyMapping_Check(ob)) { + PyObject *keys, *vals, *key, *pval; + int i, len; + /*yay! we get into recursive stuff now!*/ + keys = PyMapping_Keys(ob); + vals = PyMapping_Values(ob); + + /*we allocate the group first; if we hit any invalid data, + we can delete it easily enough.*/ + prop = IDP_New(IDP_GROUP, val, name); + len = PyMapping_Length(ob); + for (i=0; itype != IDP_GROUP) + return EXPP_ReturnIntError( PyExc_TypeError, + "unsubscriptable object"); + + if (!PyUnicode_Check(key)) + return EXPP_ReturnIntError( PyExc_TypeError, + "only strings are allowed as subgroup keys" ); + + if (val == NULL) { + IDProperty *pkey = IDP_GetPropertyFromGroup(prop, _PyUnicode_AsString(key)); + if (pkey) { + IDP_RemFromGroup(prop, pkey); + IDP_FreeProperty(pkey); + MEM_freeN(pkey); + return 0; + } else return EXPP_ReturnIntError( PyExc_RuntimeError, "property not found in group" ); + } + + err = BPy_IDProperty_Map_ValidateAndCreate(_PyUnicode_AsString(key), prop, val); + if (err) return EXPP_ReturnIntError( PyExc_RuntimeError, err ); + + return 0; +} + + +PyObject *BPy_IDGroup_Update(IDProperty *prop, PyObject *value) +{ + PyObject *pkey, *pval; + Py_ssize_t i=0; + + if (!PyDict_Check(value)) + return EXPP_ReturnPyObjError( PyExc_TypeError, + "expected an object derived from dict."); + + while (PyDict_Next(value, &i, &pkey, &pval)) { + BPy_IDGroup_Map_SetItem(prop, pkey, pval); + if (PyErr_Occurred()) return NULL; + } + + Py_RETURN_NONE; +} \ No newline at end of file diff --git a/source/blender/python/intern/bpy_idprop.h b/source/blender/python/intern/bpy_idprop.h new file mode 100644 index 00000000000..c68265aca83 --- /dev/null +++ b/source/blender/python/intern/bpy_idprop.h @@ -0,0 +1,33 @@ +/** + * $Id: IDProp.h + * + * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * Contributor(s): Joseph Eagar + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include + +struct ID; +struct IDProperty; + +PyObject *BPy_IDGroup_Update(IDProperty *prop, PyObject *value); \ No newline at end of file diff --git a/source/blender/python/intern/bpy_interface.c b/source/blender/python/intern/bpy_interface.c index d30809ff39b..7c54c728a05 100644 --- a/source/blender/python/intern/bpy_interface.c +++ b/source/blender/python/intern/bpy_interface.c @@ -3,16 +3,19 @@ #include "compile.h" /* for the PyCodeObject */ #include "eval.h" /* for PyEval_EvalCode */ +#include "BKE_context.h" + #include "bpy_compat.h" #include "bpy_rna.h" +#include "bpy_operator.h" /***************************************************************************** * Description: This function creates a new Python dictionary object. *****************************************************************************/ -static PyObject *CreateGlobalDictionary( void ) +static PyObject *CreateGlobalDictionary( bContext *C ) { PyObject *dict = PyDict_New( ); PyObject *item = PyUnicode_FromString( "__main__" ); @@ -28,6 +31,10 @@ static PyObject *CreateGlobalDictionary( void ) item = BPY_rna_doc(); PyDict_SetItemString( dict, "bpydoc", item ); Py_DECREF(item); + + item = BPY_operator_module(C); + PyDict_SetItemString( dict, "bpyoperator", item ); + Py_DECREF(item); return dict; } @@ -60,7 +67,7 @@ static void BPY_end_python( void ) return; } -void BPY_run_python_script( const char *fn ) +void BPY_run_python_script( bContext *C, const char *fn ) { PyObject *py_dict, *py_result; char pystring[512]; @@ -73,7 +80,7 @@ void BPY_run_python_script( const char *fn ) gilstate = PyGILState_Ensure(); - py_dict = CreateGlobalDictionary(); + py_dict = CreateGlobalDictionary(C); py_result = PyRun_String( pystring, Py_file_input, py_dict, py_dict ); diff --git a/source/blender/python/intern/bpy_operator.c b/source/blender/python/intern/bpy_operator.c new file mode 100644 index 00000000000..85badf18bb7 --- /dev/null +++ b/source/blender/python/intern/bpy_operator.c @@ -0,0 +1,340 @@ + +/** + * $Id$ + * + * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Contributor(s): Campbell Barton + * + * ***** END GPL LICENSE BLOCK ***** + */ + +#include "bpy_operator.h" +#include "bpy_compat.h" +#include "bpy_idprop.h" + +//#include "blendef.h" +#include "BLI_dynstr.h" +#include "WM_api.h" +#include "WM_types.h" + +#include "MEM_guardedalloc.h" +#include "BKE_idprop.h" + +extern ListBase global_ops; /* evil, temp use */ + +/* floats bigger then this are displayed as inf in the docstrings */ +#define MAXFLOAT_DOC 10000000 + +static int pyop_func_compare( BPy_OperatorFunc * a, BPy_OperatorFunc * b ) +{ + return (strcmp(a->name, b->name)==0) ? 0 : -1; +} + +/*----------------------repr--------------------------------------------*/ +static PyObject *pyop_base_repr( BPy_OperatorBase * self ) +{ + return PyUnicode_FromFormat( "[BPy_OperatorBase]"); +} + +static PyObject *pyop_func_repr( BPy_OperatorFunc * self ) +{ + return PyUnicode_FromFormat( "[BPy_OperatorFunc \"%s\"]", self->name); +} + +//---------------getattr-------------------------------------------- +static PyObject *pyop_base_getattro( BPy_OperatorBase * self, PyObject *pyname ) +{ + char *name = _PyUnicode_AsString(pyname); + PyObject *ret; + wmOperatorType *ot; + + if( strcmp( name, "__members__" ) == 0 ) { + PyObject *item; + + ret = PyList_New(0); + + for(ot= WM_operatortype_first(); ot; ot= ot->next) { + item = PyUnicode_FromString( ot->idname ); + PyList_Append(ret, item); + Py_DECREF(item); + } + } else { + ot = WM_operatortype_find(name); + + if (ot) { + return pyop_func_CreatePyObject(self->C, name); + } + else { + PyErr_Format( PyExc_AttributeError, "Operator \"%s\" not found", name); + } + } + + return ret; +} + +static PyObject * pyop_func_call(BPy_OperatorFunc * self, PyObject *args, PyObject *kw) +{ + IDProperty *properties = NULL; + + if (PyTuple_Size(args)) { + PyErr_SetString( PyExc_AttributeError, "All operator args must be keywords"); + return NULL; + } + + if (kw && PyDict_Size(kw) > 0) { + IDPropertyTemplate val; + val.i = 0; /* silence MSVC warning about uninitialized var when debugging */ + + properties= IDP_New(IDP_GROUP, val, "property"); + BPy_IDGroup_Update(properties, kw); + + if (PyErr_Occurred()) { + IDP_FreeProperty(properties); + MEM_freeN(properties); + return NULL; + } + } + + WM_operator_call(self->C, self->name, WM_OP_DEFAULT, properties); + + if (properties) { + IDP_FreeProperty(properties); + MEM_freeN(properties); + } + Py_RETURN_NONE; +} + +/*-----------------------BPy_OperatorBase method def------------------------------*/ +PyTypeObject pyop_base_Type = { +#if (PY_VERSION_HEX >= 0x02060000) + PyVarObject_HEAD_INIT(&PyType_Type, 0) +#else + /* python 2.5 and below */ + PyObject_HEAD_INIT( NULL ) /* required py macro */ + 0, /* ob_size */ +#endif + + "Operator", /* tp_name */ + sizeof( BPy_OperatorBase ), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + NULL, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + NULL, /* tp_compare */ + ( reprfunc ) pyop_base_repr, /* 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; */ + ( getattrofunc )pyop_base_getattro, /*PyObject_GenericGetAttr - MINGW Complains, assign later */ /* getattrofunc tp_getattro; */ + NULL, /*PyObject_GenericSetAttr - MINGW Complains, assign later */ /* 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; */ + + NULL, /* 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 ***/ + NULL, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* 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; */ + NULL, /* newfunc tp_new; */ + /* Low-level free-memory routine */ + NULL, /* 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 +}; + +/*-----------------------BPy_OperatorBase method def------------------------------*/ +PyTypeObject pyop_func_Type = { +#if (PY_VERSION_HEX >= 0x02060000) + PyVarObject_HEAD_INIT(&PyType_Type, 0) +#else + /* python 2.5 and below */ + PyObject_HEAD_INIT( NULL ) /* required py macro */ + 0, /* ob_size */ +#endif + + "OperatorFunc", /* tp_name */ + sizeof( BPy_OperatorFunc ), /* tp_basicsize */ + 0, /* tp_itemsize */ + /* methods */ + NULL, /* tp_dealloc */ + NULL, /* printfunc tp_print; */ + NULL, /* getattrfunc tp_getattr; */ + NULL, /* setattrfunc tp_setattr; */ + ( cmpfunc ) pyop_func_compare, /* tp_compare */ + ( reprfunc ) pyop_func_repr, /* 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; */ + (ternaryfunc)pyop_func_call, /* ternaryfunc tp_call; */ + NULL, /* reprfunc tp_str; */ + NULL, /*PyObject_GenericGetAttr - MINGW Complains, assign later */ /* getattrofunc tp_getattro; */ + NULL, /*PyObject_GenericSetAttr - MINGW Complains, assign later */ /* 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; */ + + NULL, /* 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 ***/ + NULL, /* struct PyMethodDef *tp_methods; */ + NULL, /* struct PyMemberDef *tp_members; */ + NULL, /* 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; */ + NULL, /* newfunc tp_new; */ + /* Low-level free-memory routine */ + NULL, /* 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 *pyop_base_CreatePyObject( bContext *C ) +{ + BPy_OperatorBase *pyop; + + pyop = ( BPy_OperatorBase * ) PyObject_NEW( BPy_OperatorBase, &pyop_base_Type ); + + if( !pyop ) { + PyErr_SetString( PyExc_MemoryError, "couldn't create BPy_OperatorBase object" ); + return NULL; + } + + pyop->C = C; /* TODO - copy this? */ + + return ( PyObject * ) pyop; +} + +PyObject *pyop_func_CreatePyObject( bContext *C, char *name ) +{ + BPy_OperatorFunc *pyop; + + pyop = ( BPy_OperatorFunc * ) PyObject_NEW( BPy_OperatorFunc, &pyop_func_Type ); + + if( !pyop ) { + PyErr_SetString( PyExc_MemoryError, "couldn't create BPy_OperatorFunc object" ); + return NULL; + } + + strcpy(pyop->name, name); + pyop->C= C; /* TODO - how should contexts be dealt with? */ + + return ( PyObject * ) pyop; +} + +PyObject *BPY_operator_module( bContext *C ) +{ + if( PyType_Ready( &pyop_base_Type ) < 0 ) + return NULL; + + if( PyType_Ready( &pyop_func_Type ) < 0 ) + return NULL; + + //submodule = Py_InitModule3( "operator", M_rna_methods, "rna module" ); + return pyop_base_CreatePyObject(C); +} + + + diff --git a/source/blender/python/intern/bpy_operator.h b/source/blender/python/intern/bpy_operator.h new file mode 100644 index 00000000000..55797f6d8cc --- /dev/null +++ b/source/blender/python/intern/bpy_operator.h @@ -0,0 +1,54 @@ + +/** + * $Id$ + * + * ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Contributor(s): Campbell Barton + * + * ***** END GPL LICENSE BLOCK ***** + */ +#ifndef BPY_OPERATOR_H +#define BPY_OPERATOR_H + +#include + +#include "RNA_access.h" +#include "RNA_types.h" +#include "DNA_windowmanager_types.h" +#include "BKE_context.h" + +extern PyTypeObject pyop_base_Type; +extern PyTypeObject pyop_func_Type; + +typedef struct { + PyObject_VAR_HEAD /* required python macro */ + bContext *C; +} BPy_OperatorBase; + +typedef struct { + PyObject_VAR_HEAD /* required python macro */ + char name[OP_MAX_TYPENAME]; + bContext *C; +} BPy_OperatorFunc; + +PyObject *BPY_operator_module(bContext *C ); + +PyObject *pyop_base_CreatePyObject(bContext *C ); +PyObject *pyop_func_CreatePyObject(bContext *C, char *name ); + +#endif -- cgit v1.2.3