469 lines
16 KiB
C
469 lines
16 KiB
C
/*
|
|
*
|
|
* ***** BEGIN GPL/BL DUAL 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. The Blender
|
|
* Foundation also sells licenses for use in proprietary software under
|
|
* the Blender License. See http://www.blender.org/BL/ for information
|
|
* about this.
|
|
*
|
|
* 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.
|
|
*
|
|
* This is a new part of Blender.
|
|
*
|
|
* Contributor(s): Joseph Gilbert
|
|
*
|
|
* ***** END GPL/BL DUAL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include "logic.h"
|
|
#include "gen_utils.h"
|
|
#include <MEM_guardedalloc.h>
|
|
#include <BLI_blenlib.h>
|
|
|
|
//--------------- Python BPy_Property methods declarations:---------------------------------------------------
|
|
static PyObject *Property_getName (BPy_Property * self);
|
|
static PyObject *Property_setName (BPy_Property * self, PyObject * args);
|
|
static PyObject *Property_getData (BPy_Property * self);
|
|
static PyObject *Property_setData (BPy_Property * self, PyObject * args);
|
|
static PyObject *Property_getType (BPy_Property * self);
|
|
//--------------- Python BPy_Property methods table:-----------------------------------------------------------------
|
|
static PyMethodDef BPy_Property_methods[] = {
|
|
{"getName", (PyCFunction) Property_getName, METH_NOARGS,
|
|
"() - return Property name"},
|
|
{"setName", (PyCFunction)Property_setName, METH_VARARGS,
|
|
"() - set the name of this Property"},
|
|
{"getData", (PyCFunction) Property_getData, METH_NOARGS,
|
|
"() - return Property data"},
|
|
{"setData", (PyCFunction)Property_setData, METH_VARARGS,
|
|
"() - set the data of this Property"},
|
|
{"getType", (PyCFunction) Property_getType, METH_NOARGS,
|
|
"() - return Property type"},
|
|
{NULL, NULL, 0, NULL}
|
|
};
|
|
//--------------- Python TypeProperty callback function prototypes----------------------------------------
|
|
static void Property_dealloc (BPy_Property * Property);
|
|
static PyObject *Property_getAttr (BPy_Property * Property, char *name);
|
|
static int Property_setAttr (BPy_Property * Property, char *name, PyObject * v);
|
|
static PyObject *Property_repr (BPy_Property * Property);
|
|
static int Property_compare (BPy_Property * a1, BPy_Property * a2);
|
|
//--------------- Python TypeProperty structure definition------------------------------------------------------
|
|
PyTypeObject property_Type = {
|
|
PyObject_HEAD_INIT (NULL) 0, /* ob_size */
|
|
"Blender Property", /* tp_name */
|
|
sizeof (BPy_Property), /* tp_basicsize */
|
|
0, /* tp_itemsize */
|
|
/* methods */
|
|
(destructor) Property_dealloc, /* tp_dealloc */
|
|
0, /* tp_print */
|
|
(getattrfunc) Property_getAttr, /* tp_getattr */
|
|
(setattrfunc) Property_setAttr, /* tp_setattr */
|
|
(cmpfunc) Property_compare, /* tp_compare */
|
|
(reprfunc) Property_repr, /* tp_repr */
|
|
0, /* tp_as_number */
|
|
0, /* tp_as_sequence */
|
|
0, /* tp_as_mapping */
|
|
0, /* tp_as_hash */
|
|
0, 0, 0, 0, 0, 0,
|
|
0, /* tp_doc */
|
|
0, 0, 0, 0, 0, 0,
|
|
BPy_Property_methods, /* tp_methods */
|
|
0, /* tp_members */
|
|
};
|
|
//--------------- Property module internal callbacks-------------------------------------------------------------
|
|
//--------------- updatePyProperty-------------------------------------------------------------------------------------
|
|
int
|
|
updatePyProperty(BPy_Property *self)
|
|
{
|
|
if(!self->property){
|
|
return 0; //nothing to update - not linked
|
|
}else{
|
|
BLI_strncpy(self->name, self->property->name, 32);
|
|
self->type = self->property->type;
|
|
if(self->property->type == PROP_BOOL){
|
|
if(*((int*)&self->property->poin)){
|
|
self->data = EXPP_incr_ret(Py_True);
|
|
}else{
|
|
self->data = EXPP_incr_ret(Py_False);
|
|
}
|
|
}else if (self->property->type == PROP_INT){
|
|
self->data = PyInt_FromLong(self->property->data);
|
|
}else if (self->property->type == PROP_FLOAT){
|
|
self->data = PyFloat_FromDouble(*((float*)&self->property->data));
|
|
}else if (self->property->type == PROP_TIME){
|
|
self->data = PyFloat_FromDouble(*((float*)&self->property->data));
|
|
}else if (self->property->type == PROP_STRING){
|
|
self->data = PyString_FromString(self->property->poin);
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
//--------------- updatePropertyData-------------------------------------------------------------------------------------
|
|
int
|
|
updateProperyData(BPy_Property *self)
|
|
{
|
|
if(!self->property){
|
|
//nothing to update - not linked
|
|
return 0;
|
|
}else{
|
|
BLI_strncpy(self->property->name, self->name, 32);
|
|
self->property->type = self->type;
|
|
if(PyInt_Check(self->data)){
|
|
*((int*)&self->property->data) = (int)PyInt_AsLong(self->data);
|
|
}else if (PyFloat_Check(self->data)){
|
|
*((float *)&self->property->data) = (float)PyFloat_AsDouble(self->data);
|
|
}else if (PyString_Check(self->data)){
|
|
BLI_strncpy(self->property->poin, PyString_AsString(self->data), MAX_PROPSTRING);
|
|
}
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
//--------------- checkValidData_ptr-------------------------------------------------------------------------------------
|
|
int
|
|
checkValidData_ptr(BPy_Property *self)
|
|
{
|
|
int length;
|
|
//test pointer to see if data was removed (oops)
|
|
length = MEM_allocN_len(self->property);
|
|
if(length != sizeof(bProperty)){ //data was freed
|
|
self->property = NULL;
|
|
return 0;
|
|
}else{ //it's ok as far as we can tell
|
|
return 1;
|
|
}
|
|
}
|
|
//---------------BPy_Property internal callbacks/methods---------------------------------------------
|
|
//--------------- dealloc---------------------------------------------------------------------------------------
|
|
static void
|
|
Property_dealloc (BPy_Property * self)
|
|
{
|
|
PyMem_Free (self->name);
|
|
PyObject_DEL (self);
|
|
}
|
|
//---------------getattr---------------------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_getAttr (BPy_Property * self, char *name)
|
|
{
|
|
PyObject *attr = Py_None;
|
|
|
|
checkValidData_ptr(self);
|
|
if (strcmp (name, "name") == 0)
|
|
attr = Property_getName (self);
|
|
else if (strcmp (name, "data") == 0)
|
|
attr = Property_getData (self);
|
|
else if (strcmp (name, "type") == 0)
|
|
attr = Property_getType (self);
|
|
else if (strcmp (name, "__members__") == 0){
|
|
attr = Py_BuildValue ("[s,s,s]", "name", "data","type");
|
|
}
|
|
|
|
if (!attr)
|
|
return (EXPP_ReturnPyObjError (PyExc_MemoryError,"couldn't create PyObject"));
|
|
|
|
if (attr != Py_None) return attr;
|
|
|
|
return Py_FindMethod (BPy_Property_methods, (PyObject *) self, name);
|
|
}
|
|
//--------------- setattr---------------------------------------------------------------------------------------
|
|
static int
|
|
Property_setAttr (BPy_Property * self, char *name, PyObject * value)
|
|
{
|
|
PyObject *valtuple;
|
|
PyObject *error = NULL;
|
|
|
|
checkValidData_ptr(self);
|
|
valtuple = Py_BuildValue ("(O)", value);
|
|
if (!valtuple)
|
|
return EXPP_ReturnIntError (PyExc_MemoryError,
|
|
"PropertySetAttr: couldn't create tuple");
|
|
|
|
if (strcmp (name, "name") == 0)
|
|
error = Property_setName (self, valtuple);
|
|
else if (strcmp(name, "data") == 0)
|
|
error = Property_setData (self, valtuple);
|
|
else{
|
|
Py_DECREF (valtuple);
|
|
return (EXPP_ReturnIntError (PyExc_KeyError, "attribute not found"));
|
|
}
|
|
Py_DECREF (valtuple);
|
|
|
|
if (error != Py_None) return -1;
|
|
|
|
Py_DECREF (Py_None);
|
|
return 0;
|
|
}
|
|
//--------------- repr---------------------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_repr (BPy_Property * self)
|
|
{
|
|
checkValidData_ptr(self);
|
|
if (self->property){
|
|
return PyString_FromFormat ("[Property \"%s\"]", self->property->name);
|
|
}else{
|
|
return PyString_FromFormat ("[Property \"%s\"]", self->name);
|
|
}
|
|
}
|
|
//--------------- compare---------------------------------------------------------------------------------------
|
|
//compares property.name and property.data
|
|
static int
|
|
Property_compare (BPy_Property * a, BPy_Property * b)
|
|
{
|
|
BPy_Property *py_propA, *py_propB;
|
|
int retval = -1;
|
|
|
|
checkValidData_ptr(a);
|
|
checkValidData_ptr(b);
|
|
//2 python objects
|
|
if (!a->property && !b->property) {
|
|
if(a->type != b->type) retval = -1;
|
|
if(BLI_streq(a->name, b->name)){
|
|
retval = PyObject_Compare(a->data, b->data);
|
|
}else retval = -1;
|
|
}else if (a->property && b->property){ //2 real properties
|
|
if(a->property->type != b->property->type) retval = -1;
|
|
if(BLI_streq(a->property->name, b->property->name)){
|
|
if(a->property->type == PROP_BOOL || a->property->type == PROP_INT){
|
|
if(a->property->data == b->property->data) retval = 0;
|
|
else retval = -1;
|
|
}else if (a->property->type == PROP_FLOAT || a->property->type == PROP_TIME){
|
|
if(*((float*)&a->property->data) == *((float*)&b->property->data)) retval = 0;
|
|
else retval = -1;
|
|
}else if (a->property->type == PROP_STRING){
|
|
if(BLI_streq(a->property->poin, b->property->poin)) retval = 0;
|
|
else retval = -1;
|
|
}
|
|
}else retval = -1;
|
|
}else{ //1 real 1 python
|
|
if(!a->property){
|
|
py_propA = a; py_propB = b;
|
|
}else {
|
|
py_propA = b; py_propB = a;
|
|
}
|
|
if(py_propB->property->type != py_propA->type) retval = -1;
|
|
if(BLI_streq(py_propB->property->name, py_propA->name)){
|
|
if(py_propB->property->type == PROP_BOOL ||
|
|
py_propB->property->type == PROP_INT){
|
|
retval = PyObject_Compare(py_propA->data,
|
|
PyInt_FromLong(py_propB->property->data));
|
|
}else if (py_propB->property->type == PROP_FLOAT ||
|
|
py_propB->property->type == PROP_TIME){
|
|
retval = PyObject_Compare(py_propA->data,
|
|
PyFloat_FromDouble(*((float*)&py_propB->property->data)));
|
|
}else if (py_propB->property->type == PROP_STRING){
|
|
retval = PyObject_Compare(py_propA->data,
|
|
PyString_FromString(py_propB->property->poin));
|
|
}
|
|
}else retval = -1;
|
|
}
|
|
return retval;
|
|
}
|
|
//--------------- Property visible functions--------------------------------------------------------------------
|
|
//--------------- Property_CreatePyObject--------------------------------------------------------------------
|
|
PyObject *
|
|
Property_CreatePyObject (struct bProperty * Property)
|
|
{
|
|
BPy_Property *py_property;
|
|
|
|
py_property = (BPy_Property *)PyObject_NEW (BPy_Property, &property_Type);
|
|
|
|
//set the struct flag
|
|
py_property->property = Property;
|
|
|
|
//allocate space for python vars
|
|
py_property->name= PyMem_Malloc (32);
|
|
|
|
if(!updatePyProperty(py_property))
|
|
return (EXPP_ReturnPyObjError (PyExc_AttributeError , "Property struct empty"));
|
|
|
|
return ((PyObject *) py_property);
|
|
}
|
|
//--------------- Property_CheckPyObject--------------------------------------------------------------------
|
|
int
|
|
Property_CheckPyObject (PyObject * py_obj)
|
|
{
|
|
return (py_obj->ob_type == &property_Type);
|
|
}
|
|
//--------------- Property_FromPyObject--------------------------------------------------------------------
|
|
struct bProperty *
|
|
Property_FromPyObject (PyObject * py_obj)
|
|
{
|
|
BPy_Property *py_property;
|
|
|
|
py_property = (BPy_Property *) py_obj;
|
|
if (!py_property->property) return NULL;
|
|
else return (py_property->property);
|
|
}
|
|
//--------------- newPropertyObject()----------------------------------------------------------------------------
|
|
PyObject *
|
|
newPropertyObject (char *name, PyObject *data, int type)
|
|
{
|
|
BPy_Property *py_property;
|
|
|
|
py_property = (BPy_Property *)PyObject_NEW (BPy_Property, &property_Type);
|
|
py_property->name= PyMem_Malloc (32);
|
|
py_property->property = NULL;
|
|
|
|
BLI_strncpy(py_property->name, name, 32);
|
|
py_property->data = data;
|
|
py_property->type = type;
|
|
|
|
return (PyObject*)py_property;
|
|
}
|
|
//--------------- Python BPy_Property methods------------------------------------------------------------------
|
|
//--------------- BPy_Property.getName()--------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_getName (BPy_Property * self)
|
|
{
|
|
PyObject *attr = NULL;
|
|
|
|
if (!self->property) attr = PyString_FromString (self->name);
|
|
else attr = PyString_FromString (self->property->name);
|
|
|
|
if (attr) return attr;
|
|
|
|
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Property.name attribute"));
|
|
}
|
|
//--------------- BPy_Property.setName()--------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_setName (BPy_Property * self, PyObject * args)
|
|
{
|
|
char *name;
|
|
|
|
if (!PyArg_ParseTuple (args, "s", &name))
|
|
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
|
|
"expected string argument"));
|
|
|
|
if (!self->property){
|
|
BLI_strncpy(self->name, name, 32);
|
|
}else{
|
|
BLI_strncpy(self->property->name, name, 32);
|
|
updatePyProperty(self);
|
|
}
|
|
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
//--------------- BPy_Property.getData()--------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_getData (BPy_Property * self)
|
|
{
|
|
PyObject *attr = NULL;
|
|
|
|
if (!self->property) {
|
|
attr = EXPP_incr_ret(self->data);
|
|
}else{
|
|
if(self->property->type == PROP_BOOL){
|
|
if(*((int*)&self->property->poin))
|
|
attr = EXPP_incr_ret(Py_True);
|
|
else
|
|
attr = EXPP_incr_ret(Py_False);
|
|
}else if (self->property->type == PROP_INT){
|
|
attr = PyInt_FromLong(self->property->data);
|
|
}else if (self->property->type == PROP_FLOAT ||
|
|
self->property->type == PROP_TIME){
|
|
attr = PyFloat_FromDouble(*((float*)&self->property->data));
|
|
}else if (self->property->type == PROP_STRING){
|
|
attr = PyString_FromString(self->property->poin);
|
|
}
|
|
}
|
|
if (attr) return attr;
|
|
|
|
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"couldn't get Property.name attribute"));
|
|
}
|
|
//--------------- BPy_Property.setData()--------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_setData (BPy_Property * self, PyObject * args)
|
|
{
|
|
PyObject *data;
|
|
char *type_str = NULL;
|
|
int type = -1;
|
|
short *p_type = NULL;
|
|
|
|
if (!PyArg_ParseTuple (args, "O|s", &data, &type_str))
|
|
return (EXPP_ReturnPyObjError (PyExc_AttributeError,
|
|
"expected object and optional string argument"));
|
|
|
|
if(!PyInt_Check(data) && !PyFloat_Check(data) && !PyString_Check(data))
|
|
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"float, int, or string expected as data"));
|
|
|
|
//parse property name
|
|
if(type_str){
|
|
if(BLI_streq(type_str, "BOOL")) type = PROP_BOOL;
|
|
else if (BLI_streq(type_str, "INT")) type = PROP_INT;
|
|
else if (BLI_streq(type_str, "FLOAT")) type = PROP_FLOAT;
|
|
else if (BLI_streq(type_str, "TIME")) type = PROP_TIME;
|
|
else if (BLI_streq(type_str, "STRING")) type = PROP_STRING;
|
|
else return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"BOOL, INT, FLOAT, TIME or STRING expected"));
|
|
}
|
|
|
|
//get pointer to type
|
|
if(self->property) p_type = &self->property->type;
|
|
else p_type = &self->type;
|
|
|
|
//set the type
|
|
if(PyInt_Check(data)){
|
|
if(type == -1 || type == PROP_INT) *p_type = PROP_INT;
|
|
else *p_type = PROP_BOOL;
|
|
}else if(PyFloat_Check(data)){
|
|
if(type == -1 || type == PROP_FLOAT) *p_type = PROP_FLOAT;
|
|
else *p_type = PROP_TIME;
|
|
}else if(PyString_Check(data)){
|
|
if(type == -1 || type == PROP_STRING) *p_type = PROP_STRING;
|
|
}else{
|
|
return (EXPP_ReturnPyObjError (PyExc_RuntimeError,
|
|
"cant set unknown data type"));
|
|
}
|
|
|
|
//set the data
|
|
if(self->property){
|
|
if(PyInt_Check(data)){
|
|
*((int*)&self->property->data) = (int)PyInt_AsLong(data);
|
|
}else if (PyFloat_Check(data)){
|
|
*((float *)&self->property->data) = (float)PyFloat_AsDouble(data);
|
|
}else if (PyString_Check(data)){
|
|
BLI_strncpy(self->property->poin, PyString_AsString(data), MAX_PROPSTRING);
|
|
}
|
|
updatePyProperty(self);
|
|
}else{
|
|
self->data = data;
|
|
}
|
|
return EXPP_incr_ret (Py_None);
|
|
}
|
|
//--------------- BPy_Property.getType()--------------------------------------------------------------------------
|
|
static PyObject *
|
|
Property_getType (BPy_Property * self)
|
|
{
|
|
PyObject *attr = Py_None;
|
|
int type;
|
|
|
|
if(self->property) type = self->property->type;
|
|
else type = self->type;
|
|
|
|
if(type == PROP_BOOL) attr = Py_BuildValue("s", "BOOL");
|
|
else if (type == PROP_INT) attr = Py_BuildValue("s", "INT");
|
|
else if (type == PROP_FLOAT) attr = Py_BuildValue("s", "FLOAT");
|
|
else if (type == PROP_STRING) attr = Py_BuildValue("s", "STRING");
|
|
else if (type == PROP_TIME) attr = Py_BuildValue("s", "TIME");
|
|
|
|
return attr;
|
|
}
|
|
|