wip operator py-api
authorCampbell Barton <ideasman42@gmail.com>
Sun, 21 Dec 2008 08:53:36 +0000 (08:53 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Sun, 21 Dec 2008 08:53:36 +0000 (08:53 +0000)
"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
source/blender/python/SConscript
source/blender/python/intern/bpy_idprop.c [new file with mode: 0644]
source/blender/python/intern/bpy_idprop.h [new file with mode: 0644]
source/blender/python/intern/bpy_interface.c
source/blender/python/intern/bpy_operator.c [new file with mode: 0644]
source/blender/python/intern/bpy_operator.h [new file with mode: 0644]
source/blender/windowmanager/WM_api.h
source/blender/windowmanager/intern/wm_operators.c
source/creator/creator.c

index 1761ce14ed6c766a72c610f619a7de4859d07328..8561f9d1b55a2bddf850d5b59bbbad3846e16dac 100644 (file)
@@ -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 );
 
index 6190ed5c0ec0fd03bcfe7619bbbe90948f203f36..975b7a7a7e7070536f2ed83e3405527d6f15c534 100644 (file)
@@ -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 (file)
index 0000000..e7e8a5f
--- /dev/null
@@ -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; i<val.array.len; i++) {
+                       item = PySequence_GetItem(ob, i);
+                       if (PyFloat_Check(item)) val.array.type = IDP_DOUBLE;
+                       else if (!PyLong_Check(item)) return "only floats and ints are allowed in ID property arrays";
+                       Py_XDECREF(item);
+               }
+               
+               prop = IDP_New(IDP_ARRAY, val, name);
+               for (i=0; i<val.array.len; i++) {
+                       item = PySequence_GetItem(ob, i);
+                       if (val.array.type == IDP_INT) {
+                               item = PyNumber_Int(item);
+                               ((int*)prop->data.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; i<len; i++) {
+                       key = PySequence_GetItem(keys, i);
+                       pval = PySequence_GetItem(vals, i);
+                       if (!PyUnicode_Check(key)) {
+                               IDP_FreeProperty(prop);
+                               MEM_freeN(prop);
+                               Py_XDECREF(keys);
+                               Py_XDECREF(vals);
+                               Py_XDECREF(key);
+                               Py_XDECREF(pval);
+                               return "invalid element in subgroup dict template!";
+                       }
+                       if (BPy_IDProperty_Map_ValidateAndCreate(_PyUnicode_AsString(key), prop, pval)) {
+                               IDP_FreeProperty(prop);
+                               MEM_freeN(prop);
+                               Py_XDECREF(keys);
+                               Py_XDECREF(vals);
+                               Py_XDECREF(key);
+                               Py_XDECREF(pval);
+                               return "invalid element in subgroup dict template!";
+                       }
+                       Py_XDECREF(key);
+                       Py_XDECREF(pval);
+               }
+               Py_XDECREF(keys);
+               Py_XDECREF(vals);
+       } else return "invalid property value";
+       
+       IDP_ReplaceInGroup(group, prop);
+       return NULL;
+}
+
+
+static int BPy_IDGroup_Map_SetItem(IDProperty *prop, PyObject *key, PyObject *val)
+{
+       char *err;
+       
+       if (prop->type  != 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 (file)
index 0000000..c68265a
--- /dev/null
@@ -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 <Python.h>
+
+struct ID;
+struct IDProperty;
+
+PyObject *BPy_IDGroup_Update(IDProperty *prop, PyObject *value);
\ No newline at end of file
index d30809ff39b6c64b6bad8224a1988bb91c1bf409..7c54c728a05f66d33a87485e3f303ead08497a24 100644 (file)
@@ -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 (file)
index 0000000..85badf1
--- /dev/null
@@ -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 (file)
index 0000000..55797f6
--- /dev/null
@@ -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 <Python.h>
+
+#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
index 19ddd43f7ecf2ce6c9e1d19135cfde646cb237d6..b1209af9afeb171dcf6390fef9d7ab6a70391f4a 100644 (file)
@@ -114,6 +114,7 @@ void                WM_error(struct bContext *C, char *str);
 
                        /* operator api */
 wmOperatorType *WM_operatortype_find(const char *idname);
+wmOperatorType *WM_operatortype_first(void);
 void           WM_operatortype_append  (void (*opfunc)(wmOperatorType*));
 
 int         WM_operator_call           (struct bContext *C, const char *opstring, int context, struct IDProperty *properties);
index d69b0901bc6a6e9a4cd619c5c4196008c689002a..11f6f8fa93ab9ce2ca2af179ea88af8e76ddf03e 100644 (file)
@@ -77,6 +77,11 @@ wmOperatorType *WM_operatortype_find(const char *idname)
        return NULL;
 }
 
+wmOperatorType *WM_operatortype_first(void)
+{
+       return global_ops.first;
+}
+
 /* all ops in 1 list (for time being... needs evaluation later) */
 void WM_operatortype_append(void (*opfunc)(wmOperatorType*))
 {
index 471ea6bbe5bb84ea4ab8565e7a6b0bb3c58abd76..5c10b0c346cf44fec7ffc3f3f86a2452d02fa6e4 100644 (file)
@@ -679,7 +679,7 @@ int main(int argc, char **argv)
                                //XXX 
                                // FOR TESTING ONLY
                                a++;
-                               BPY_run_python_script (argv[a]);
+                               BPY_run_python_script(C, argv[a]);
 #if 0
                                a++;
                                if (a < argc) {
@@ -688,7 +688,7 @@ int main(int argc, char **argv)
                                                main_init_screen();
                                                scr_init = 1;
                                        }
-                                       BPY_run_python_script (argv[a]);
+                                       BPY_run_python_script(C, argv[a]);
                                }
                                else printf("\nError: you must specify a Python script after '-P '.\n");
 #endif